@anthropic-field/core 0.1.0

package/dist/src/mocks/msw.js

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { setupServer } from 'msw/node';
+export const server = setupServer();
+//# sourceMappingURL=msw.js.map

package/dist/src/mocks/msw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"msw.js","sourceRoot":"","sources":["../../../src/mocks/msw.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,MAAM,CAAC,MAAM,MAAM,GAAG,WAAW,EAAE,CAAC"}

package/dist/src/output/json-formatter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionMetrics } from '../telemetry/uiTelemetry.js';
+import type { JsonError } from './types.js';
+export declare class JsonFormatter {
+    format(sessionId?: string, response?: string, stats?: SessionMetrics, error?: JsonError): string;
+    formatError(error: Error, code?: string | number, sessionId?: string): string;
+}

package/dist/src/output/json-formatter.js

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import stripAnsi from 'strip-ansi';
+export class JsonFormatter {
+    format(sessionId, response, stats, error) {
+        const output = {};
+        if (sessionId) {
+            output.session_id = sessionId;
+        }
+        if (response !== undefined) {
+            output.response = stripAnsi(response);
+        }
+        if (stats) {
+            output.stats = stats;
+        }
+        if (error) {
+            output.error = error;
+        }
+        return JSON.stringify(output, null, 2);
+    }
+    formatError(error, code, sessionId) {
+        const jsonError = {
+            type: error.constructor.name,
+            message: stripAnsi(error.message),
+            ...(code && { code }),
+        };
+        return this.format(sessionId, undefined, undefined, jsonError);
+    }
+}
+//# sourceMappingURL=json-formatter.js.map

package/dist/src/output/json-formatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-formatter.js","sourceRoot":"","sources":["../../../src/output/json-formatter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,SAAS,MAAM,YAAY,CAAC;AAInC,MAAM,OAAO,aAAa;IACxB,MAAM,CACJ,SAAkB,EAClB,QAAiB,EACjB,KAAsB,EACtB,KAAiB;QAEjB,MAAM,MAAM,GAAe,EAAE,CAAC;QAE9B,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;QAChC,CAAC;QAED,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,MAAM,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;QACxC,CAAC;QAED,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;QACvB,CAAC;QAED,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;QACvB,CAAC;QAED,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IACzC,CAAC;IAED,WAAW,CACT,KAAY,EACZ,IAAsB,EACtB,SAAkB;QAElB,MAAM,SAAS,GAAc;YAC3B,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,IAAI;YAC5B,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC;YACjC,GAAG,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,CAAC;SACtB,CAAC;QAEF,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;IACjE,CAAC;CACF"}

package/dist/src/output/stream-json-formatter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { JsonStreamEvent, StreamStats } from './types.js';
+import type { SessionMetrics } from '../telemetry/uiTelemetry.js';
+/**
+ * Formatter for streaming JSON output.
+ * Emits newline-delimited JSON (JSONL) events to stdout in real-time.
+ */
+export declare class StreamJsonFormatter {
+    /**
+     * Formats a single event as a JSON string with newline (JSONL format).
+     * @param event - The stream event to format
+     * @returns JSON string with trailing newline
+     */
+    formatEvent(event: JsonStreamEvent): string;
+    /**
+     * Emits an event directly to stdout in JSONL format.
+     * @param event - The stream event to emit
+     */
+    emitEvent(event: JsonStreamEvent): void;
+    /**
+     * Converts SessionMetrics to simplified StreamStats format.
+     * Aggregates token counts across all models.
+     * @param metrics - The session metrics from telemetry
+     * @param durationMs - The session duration in milliseconds
+     * @returns Simplified stats for streaming output
+     */
+    convertToStreamStats(metrics: SessionMetrics, durationMs: number): StreamStats;
+}

package/dist/src/output/stream-json-formatter.js

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Formatter for streaming JSON output.
+ * Emits newline-delimited JSON (JSONL) events to stdout in real-time.
+ */
+export class StreamJsonFormatter {
+    /**
+     * Formats a single event as a JSON string with newline (JSONL format).
+     * @param event - The stream event to format
+     * @returns JSON string with trailing newline
+     */
+    formatEvent(event) {
+        return JSON.stringify(event) + '\n';
+    }
+    /**
+     * Emits an event directly to stdout in JSONL format.
+     * @param event - The stream event to emit
+     */
+    emitEvent(event) {
+        process.stdout.write(this.formatEvent(event));
+    }
+    /**
+     * Converts SessionMetrics to simplified StreamStats format.
+     * Aggregates token counts across all models.
+     * @param metrics - The session metrics from telemetry
+     * @param durationMs - The session duration in milliseconds
+     * @returns Simplified stats for streaming output
+     */
+    convertToStreamStats(metrics, durationMs) {
+        let totalTokens = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let cached = 0;
+        let input = 0;
+        // Aggregate token counts across all models
+        for (const modelMetrics of Object.values(metrics.models)) {
+            totalTokens += modelMetrics.tokens.total;
+            inputTokens += modelMetrics.tokens.prompt;
+            outputTokens += modelMetrics.tokens.candidates;
+            cached += modelMetrics.tokens.cached;
+            input += modelMetrics.tokens.input;
+        }
+        return {
+            total_tokens: totalTokens,
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cached,
+            input,
+            duration_ms: durationMs,
+            tool_calls: metrics.tools.totalCalls,
+        };
+    }
+}
+//# sourceMappingURL=stream-json-formatter.js.map

package/dist/src/output/stream-json-formatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-json-formatter.js","sourceRoot":"","sources":["../../../src/output/stream-json-formatter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;;GAGG;AACH,MAAM,OAAO,mBAAmB;IAC9B;;;;OAIG;IACH,WAAW,CAAC,KAAsB;QAChC,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IACtC,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,KAAsB;QAC9B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;OAMG;IACH,oBAAoB,CAClB,OAAuB,EACvB,UAAkB;QAElB,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,2CAA2C;QAC3C,KAAK,MAAM,YAAY,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACzD,WAAW,IAAI,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC;YACzC,WAAW,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC;YAC1C,YAAY,IAAI,YAAY,CAAC,MAAM,CAAC,UAAU,CAAC;YAC/C,MAAM,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC;YACrC,KAAK,IAAI,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC;QACrC,CAAC;QAED,OAAO;YACL,YAAY,EAAE,WAAW;YACzB,YAAY,EAAE,WAAW;YACzB,aAAa,EAAE,YAAY;YAC3B,MAAM;YACN,KAAK;YACL,WAAW,EAAE,UAAU;YACvB,UAAU,EAAE,OAAO,CAAC,KAAK,CAAC,UAAU;SACrC,CAAC;IACJ,CAAC;CACF"}

package/dist/src/output/types.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionMetrics } from '../telemetry/uiTelemetry.js';
+export declare enum OutputFormat {
+    TEXT = "text",
+    JSON = "json",
+    STREAM_JSON = "stream-json"
+}
+export interface JsonError {
+    type: string;
+    message: string;
+    code?: string | number;
+}
+export interface JsonOutput {
+    session_id?: string;
+    response?: string;
+    stats?: SessionMetrics;
+    error?: JsonError;
+}
+export declare enum JsonStreamEventType {
+    INIT = "init",
+    MESSAGE = "message",
+    TOOL_USE = "tool_use",
+    TOOL_RESULT = "tool_result",
+    ERROR = "error",
+    RESULT = "result"
+}
+export interface BaseJsonStreamEvent {
+    type: JsonStreamEventType;
+    timestamp: string;
+}
+export interface InitEvent extends BaseJsonStreamEvent {
+    type: JsonStreamEventType.INIT;
+    session_id: string;
+    model: string;
+}
+export interface MessageEvent extends BaseJsonStreamEvent {
+    type: JsonStreamEventType.MESSAGE;
+    role: 'user' | 'assistant';
+    content: string;
+    delta?: boolean;
+}
+export interface ToolUseEvent extends BaseJsonStreamEvent {
+    type: JsonStreamEventType.TOOL_USE;
+    tool_name: string;
+    tool_id: string;
+    parameters: Record<string, unknown>;
+}
+export interface ToolResultEvent extends BaseJsonStreamEvent {
+    type: JsonStreamEventType.TOOL_RESULT;
+    tool_id: string;
+    status: 'success' | 'error';
+    output?: string;
+    error?: {
+        type: string;
+        message: string;
+    };
+}
+export interface ErrorEvent extends BaseJsonStreamEvent {
+    type: JsonStreamEventType.ERROR;
+    severity: 'warning' | 'error';
+    message: string;
+}
+export interface StreamStats {
+    total_tokens: number;
+    input_tokens: number;
+    output_tokens: number;
+    cached: number;
+    input: number;
+    duration_ms: number;
+    tool_calls: number;
+}
+export interface ResultEvent extends BaseJsonStreamEvent {
+    type: JsonStreamEventType.RESULT;
+    status: 'success' | 'error';
+    error?: {
+        type: string;
+        message: string;
+    };
+    stats?: StreamStats;
+}
+export type JsonStreamEvent = InitEvent | MessageEvent | ToolUseEvent | ToolResultEvent | ErrorEvent | ResultEvent;

package/dist/src/output/types.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export var OutputFormat;
+(function (OutputFormat) {
+    OutputFormat["TEXT"] = "text";
+    OutputFormat["JSON"] = "json";
+    OutputFormat["STREAM_JSON"] = "stream-json";
+})(OutputFormat || (OutputFormat = {}));
+// Streaming JSON event types
+export var JsonStreamEventType;
+(function (JsonStreamEventType) {
+    JsonStreamEventType["INIT"] = "init";
+    JsonStreamEventType["MESSAGE"] = "message";
+    JsonStreamEventType["TOOL_USE"] = "tool_use";
+    JsonStreamEventType["TOOL_RESULT"] = "tool_result";
+    JsonStreamEventType["ERROR"] = "error";
+    JsonStreamEventType["RESULT"] = "result";
+})(JsonStreamEventType || (JsonStreamEventType = {}));
+//# sourceMappingURL=types.js.map

package/dist/src/output/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/output/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,CAAN,IAAY,YAIX;AAJD,WAAY,YAAY;IACtB,6BAAa,CAAA;IACb,6BAAa,CAAA;IACb,2CAA2B,CAAA;AAC7B,CAAC,EAJW,YAAY,KAAZ,YAAY,QAIvB;AAeD,6BAA6B;AAC7B,MAAM,CAAN,IAAY,mBAOX;AAPD,WAAY,mBAAmB;IAC7B,oCAAa,CAAA;IACb,0CAAmB,CAAA;IACnB,4CAAqB,CAAA;IACrB,kDAA2B,CAAA;IAC3B,sCAAe,CAAA;IACf,wCAAiB,CAAA;AACnB,CAAC,EAPW,mBAAmB,KAAnB,mBAAmB,QAO9B"}

package/dist/src/policy/config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type PolicyEngineConfig, type ApprovalMode, type PolicySettings } from './types.js';
+import type { PolicyEngine } from './policy-engine.js';
+import { type PolicyFileError } from './toml-loader.js';
+import { type MessageBus } from '../confirmation-bus/message-bus.js';
+export declare const DEFAULT_CORE_POLICIES_DIR: string;
+export declare const DEFAULT_POLICY_TIER = 1;
+export declare const USER_POLICY_TIER = 2;
+export declare const ADMIN_POLICY_TIER = 3;
+/**
+ * Gets the list of directories to search for policy files, in order of increasing priority
+ * (Default -> User -> Admin).
+ *
+ * @param defaultPoliciesDir Optional path to a directory containing default policies.
+ */
+export declare function getPolicyDirectories(defaultPoliciesDir?: string): string[];
+/**
+ * Determines the policy tier (1=default, 2=user, 3=admin) for a given directory.
+ * This is used by the TOML loader to assign priority bands.
+ */
+export declare function getPolicyTier(dir: string, defaultPoliciesDir?: string): number;
+/**
+ * Formats a policy file error for console logging.
+ */
+export declare function formatPolicyError(error: PolicyFileError): string;
+export declare function createPolicyEngineConfig(settings: PolicySettings, approvalMode: ApprovalMode, defaultPoliciesDir?: string): Promise<PolicyEngineConfig>;
+export declare function createPolicyUpdater(policyEngine: PolicyEngine, messageBus: MessageBus): void;

package/dist/src/policy/config.js

@@ -0,0 +1,355 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Storage } from '../config/storage.js';
+import { PolicyDecision, } from './types.js';
+import { loadPoliciesFromToml } from './toml-loader.js';
+import { buildArgsPatterns } from './utils.js';
+import toml from '@iarna/toml';
+import { MessageBusType, } from '../confirmation-bus/types.js';
+import {} from '../confirmation-bus/message-bus.js';
+import { coreEvents } from '../utils/events.js';
+import { debugLogger } from '../utils/debugLogger.js';
+import { SHELL_TOOL_NAMES } from '../utils/shell-utils.js';
+import { SHELL_TOOL_NAME } from '../tools/tool-names.js';
+import { isDirectorySecure } from '../utils/security.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const DEFAULT_CORE_POLICIES_DIR = path.join(__dirname, 'policies');
+// Policy tier constants for priority calculation
+export const DEFAULT_POLICY_TIER = 1;
+export const USER_POLICY_TIER = 2;
+export const ADMIN_POLICY_TIER = 3;
+/**
+ * Gets the list of directories to search for policy files, in order of increasing priority
+ * (Default -> User -> Admin).
+ *
+ * @param defaultPoliciesDir Optional path to a directory containing default policies.
+ */
+export function getPolicyDirectories(defaultPoliciesDir) {
+    const dirs = [];
+    if (defaultPoliciesDir) {
+        dirs.push(defaultPoliciesDir);
+    }
+    else {
+        dirs.push(DEFAULT_CORE_POLICIES_DIR);
+    }
+    dirs.push(Storage.getUserPoliciesDir());
+    dirs.push(Storage.getSystemPoliciesDir());
+    // Reverse so highest priority (Admin) is first for loading order if needed,
+    // though loadPoliciesFromToml might want them in a specific order.
+    // CLI implementation reversed them: [DEFAULT, USER, ADMIN].reverse() -> [ADMIN, USER, DEFAULT]
+    return dirs.reverse();
+}
+/**
+ * Determines the policy tier (1=default, 2=user, 3=admin) for a given directory.
+ * This is used by the TOML loader to assign priority bands.
+ */
+export function getPolicyTier(dir, defaultPoliciesDir) {
+    const USER_POLICIES_DIR = Storage.getUserPoliciesDir();
+    const ADMIN_POLICIES_DIR = Storage.getSystemPoliciesDir();
+    const normalizedDir = path.resolve(dir);
+    const normalizedUser = path.resolve(USER_POLICIES_DIR);
+    const normalizedAdmin = path.resolve(ADMIN_POLICIES_DIR);
+    if (defaultPoliciesDir &&
+        normalizedDir === path.resolve(defaultPoliciesDir)) {
+        return DEFAULT_POLICY_TIER;
+    }
+    if (normalizedDir === path.resolve(DEFAULT_CORE_POLICIES_DIR)) {
+        return DEFAULT_POLICY_TIER;
+    }
+    if (normalizedDir === normalizedUser) {
+        return USER_POLICY_TIER;
+    }
+    if (normalizedDir === normalizedAdmin) {
+        return ADMIN_POLICY_TIER;
+    }
+    return DEFAULT_POLICY_TIER;
+}
+/**
+ * Formats a policy file error for console logging.
+ */
+export function formatPolicyError(error) {
+    const tierLabel = error.tier.toUpperCase();
+    let message = `[${tierLabel}] Policy file error in ${error.fileName}:\n`;
+    message += `  ${error.message}`;
+    if (error.details) {
+        message += `\n${error.details}`;
+    }
+    if (error.suggestion) {
+        message += `\n  Suggestion: ${error.suggestion}`;
+    }
+    return message;
+}
+/**
+ * Filters out insecure policy directories (specifically the system policy directory).
+ * Emits warnings if insecure directories are found.
+ */
+async function filterSecurePolicyDirectories(dirs) {
+    const systemPoliciesDir = path.resolve(Storage.getSystemPoliciesDir());
+    const results = await Promise.all(dirs.map(async (dir) => {
+        // Only check security for system policies
+        if (path.resolve(dir) === systemPoliciesDir) {
+            const { secure, reason } = await isDirectorySecure(dir);
+            if (!secure) {
+                const msg = `Security Warning: Skipping system policies from ${dir}: ${reason}`;
+                coreEvents.emitFeedback('warning', msg);
+                return null;
+            }
+        }
+        return dir;
+    }));
+    return results.filter((dir) => dir !== null);
+}
+export async function createPolicyEngineConfig(settings, approvalMode, defaultPoliciesDir) {
+    const policyDirs = getPolicyDirectories(defaultPoliciesDir);
+    const securePolicyDirs = await filterSecurePolicyDirectories(policyDirs);
+    // Load policies from TOML files
+    const { rules: tomlRules, checkers: tomlCheckers, errors, } = await loadPoliciesFromToml(securePolicyDirs, (dir) => getPolicyTier(dir, defaultPoliciesDir));
+    // Emit any errors encountered during TOML loading to the UI
+    // coreEvents has a buffer that will display these once the UI is ready
+    if (errors.length > 0) {
+        for (const error of errors) {
+            coreEvents.emitFeedback('error', formatPolicyError(error));
+        }
+    }
+    const rules = [...tomlRules];
+    const checkers = [...tomlCheckers];
+    // Priority system for policy rules:
+    // - Higher priority numbers win over lower priority numbers
+    // - When multiple rules match, the highest priority rule is applied
+    // - Rules are evaluated in order of priority (highest first)
+    //
+    // Priority bands (tiers):
+    // - Default policies (TOML): 1 + priority/1000 (e.g., priority 100 → 1.100)
+    // - User policies (TOML): 2 + priority/1000 (e.g., priority 100 → 2.100)
+    // - Admin policies (TOML): 3 + priority/1000 (e.g., priority 100 → 3.100)
+    //
+    // This ensures Admin > User > Default hierarchy is always preserved,
+    // while allowing user-specified priorities to work within each tier.
+    //
+    // Settings-based and dynamic rules (all in user tier 2.x):
+    //   2.95: Tools that the user has selected as "Always Allow" in the interactive UI
+    //   2.9:  MCP servers excluded list (security: persistent server blocks)
+    //   2.4:  Command line flag --exclude-tools (explicit temporary blocks)
+    //   2.3:  Command line flag --allowed-tools (explicit temporary allows)
+    //   2.2:  MCP servers with trust=true (persistent trusted servers)
+    //   2.1:  MCP servers allowed list (persistent general server allows)
+    //
+    // TOML policy priorities (before transformation):
+    //   10: Write tools default to ASK_USER (becomes 1.010 in default tier)
+    //   15: Auto-edit tool override (becomes 1.015 in default tier)
+    //   50: Read-only tools (becomes 1.050 in default tier)
+    //   999: YOLO mode allow-all (becomes 1.999 in default tier)
+    // MCP servers that are explicitly excluded in settings.mcp.excluded
+    // Priority: 2.9 (highest in user tier for security - persistent server blocks)
+    if (settings.mcp?.excluded) {
+        for (const serverName of settings.mcp.excluded) {
+            rules.push({
+                toolName: `${serverName}__*`,
+                decision: PolicyDecision.DENY,
+                priority: 2.9,
+                source: 'Settings (MCP Excluded)',
+            });
+        }
+    }
+    // Tools that are explicitly excluded in the settings.
+    // Priority: 2.4 (user tier - explicit temporary blocks)
+    if (settings.tools?.exclude) {
+        for (const tool of settings.tools.exclude) {
+            rules.push({
+                toolName: tool,
+                decision: PolicyDecision.DENY,
+                priority: 2.4,
+                source: 'Settings (Tools Excluded)',
+            });
+        }
+    }
+    // Tools that are explicitly allowed in the settings.
+    // Priority: 2.3 (user tier - explicit temporary allows)
+    if (settings.tools?.allowed) {
+        for (const tool of settings.tools.allowed) {
+            // Check for legacy format: toolName(args)
+            const match = tool.match(/^([a-zA-Z0-9_-]+)\((.*)\)$/);
+            if (match) {
+                const [, rawToolName, args] = match;
+                // Normalize shell tool aliases
+                const toolName = SHELL_TOOL_NAMES.includes(rawToolName)
+                    ? SHELL_TOOL_NAME
+                    : rawToolName;
+                // Treat args as a command prefix for shell tool
+                if (toolName === SHELL_TOOL_NAME) {
+                    const patterns = buildArgsPatterns(undefined, args);
+                    for (const pattern of patterns) {
+                        if (pattern) {
+                            rules.push({
+                                toolName,
+                                decision: PolicyDecision.ALLOW,
+                                priority: 2.3,
+                                argsPattern: new RegExp(pattern),
+                                source: 'Settings (Tools Allowed)',
+                            });
+                        }
+                    }
+                }
+                else {
+                    // For non-shell tools, we allow the tool itself but ignore args
+                    // as args matching was only supported for shell tools historically.
+                    rules.push({
+                        toolName,
+                        decision: PolicyDecision.ALLOW,
+                        priority: 2.3,
+                        source: 'Settings (Tools Allowed)',
+                    });
+                }
+            }
+            else {
+                // Standard tool name
+                const toolName = SHELL_TOOL_NAMES.includes(tool)
+                    ? SHELL_TOOL_NAME
+                    : tool;
+                rules.push({
+                    toolName,
+                    decision: PolicyDecision.ALLOW,
+                    priority: 2.3,
+                    source: 'Settings (Tools Allowed)',
+                });
+            }
+        }
+    }
+    // MCP servers that are trusted in the settings.
+    // Priority: 2.2 (user tier - persistent trusted servers)
+    if (settings.mcpServers) {
+        for (const [serverName, serverConfig] of Object.entries(settings.mcpServers)) {
+            if (serverConfig.trust) {
+                // Trust all tools from this MCP server
+                // Using pattern matching for MCP tool names which are formatted as "serverName__toolName"
+                rules.push({
+                    toolName: `${serverName}__*`,
+                    decision: PolicyDecision.ALLOW,
+                    priority: 2.2,
+                    source: 'Settings (MCP Trusted)',
+                });
+            }
+        }
+    }
+    // MCP servers that are explicitly allowed in settings.mcp.allowed
+    // Priority: 2.1 (user tier - persistent general server allows)
+    if (settings.mcp?.allowed) {
+        for (const serverName of settings.mcp.allowed) {
+            rules.push({
+                toolName: `${serverName}__*`,
+                decision: PolicyDecision.ALLOW,
+                priority: 2.1,
+                source: 'Settings (MCP Allowed)',
+            });
+        }
+    }
+    return {
+        rules,
+        checkers,
+        defaultDecision: PolicyDecision.ASK_USER,
+        approvalMode,
+    };
+}
+export function createPolicyUpdater(policyEngine, messageBus) {
+    messageBus.subscribe(MessageBusType.UPDATE_POLICY, async (message) => {
+        const toolName = message.toolName;
+        if (message.commandPrefix) {
+            // Convert commandPrefix(es) to argsPatterns for in-memory rules
+            const patterns = buildArgsPatterns(undefined, message.commandPrefix);
+            for (const pattern of patterns) {
+                if (pattern) {
+                    policyEngine.addRule({
+                        toolName,
+                        decision: PolicyDecision.ALLOW,
+                        // User tier (2) + high priority (950/1000) = 2.95
+                        // This ensures user "always allow" selections are high priority
+                        // but still lose to admin policies (3.xxx) and settings excludes (200)
+                        priority: 2.95,
+                        argsPattern: new RegExp(pattern),
+                        source: 'Dynamic (Confirmed)',
+                    });
+                }
+            }
+        }
+        else {
+            const argsPattern = message.argsPattern
+                ? new RegExp(message.argsPattern)
+                : undefined;
+            policyEngine.addRule({
+                toolName,
+                decision: PolicyDecision.ALLOW,
+                // User tier (2) + high priority (950/1000) = 2.95
+                // This ensures user "always allow" selections are high priority
+                // but still lose to admin policies (3.xxx) and settings excludes (200)
+                priority: 2.95,
+                argsPattern,
+                source: 'Dynamic (Confirmed)',
+            });
+        }
+        if (message.persist) {
+            try {
+                const userPoliciesDir = Storage.getUserPoliciesDir();
+                await fs.mkdir(userPoliciesDir, { recursive: true });
+                const policyFile = path.join(userPoliciesDir, 'auto-saved.toml');
+                // Read existing file
+                let existingData = {};
+                try {
+                    const fileContent = await fs.readFile(policyFile, 'utf-8');
+                    existingData = toml.parse(fileContent);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT') {
+                        debugLogger.warn(`Failed to parse ${policyFile}, overwriting with new policy.`, error);
+                    }
+                }
+                // Initialize rule array if needed
+                if (!existingData.rule) {
+                    existingData.rule = [];
+                }
+                // Create new rule object
+                const newRule = {};
+                if (message.mcpName) {
+                    newRule.mcpName = message.mcpName;
+                    // Extract simple tool name
+                    const simpleToolName = toolName.startsWith(`${message.mcpName}__`)
+                        ? toolName.slice(message.mcpName.length + 2)
+                        : toolName;
+                    newRule.toolName = simpleToolName;
+                    newRule.decision = 'allow';
+                    newRule.priority = 200;
+                }
+                else {
+                    newRule.toolName = toolName;
+                    newRule.decision = 'allow';
+                    newRule.priority = 100;
+                }
+                if (message.commandPrefix) {
+                    newRule.commandPrefix = message.commandPrefix;
+                }
+                else if (message.argsPattern) {
+                    newRule.argsPattern = message.argsPattern;
+                }
+                // Add to rules
+                existingData.rule.push(newRule);
+                // Serialize back to TOML
+                // @iarna/toml stringify might not produce beautiful output but it handles escaping correctly
+                const newContent = toml.stringify(existingData);
+                // Atomic write: write to tmp then rename
+                const tmpFile = `${policyFile}.tmp`;
+                await fs.writeFile(tmpFile, newContent, 'utf-8');
+                await fs.rename(tmpFile, policyFile);
+            }
+            catch (error) {
+                coreEvents.emitFeedback('error', `Failed to persist policy for ${toolName}`, error);
+            }
+        }
+    });
+}
+//# sourceMappingURL=config.js.map