@jungjaehoon/mama-os 0.53.1 → 0.58.0

package/dist/agent/agent-loop.js

@@ -1,2842 +0,0 @@
-"use strict";
-/**
- * Agent Loop Engine for MAMA Standalone
- *
- * Main orchestrator that:
- * - Maintains conversation history
- * - Calls Claude API via ClaudeClient
- * - Parses tool_use blocks from responses
- * - Executes tools via MCPExecutor
- * - Sends tool_result back to Claude
- * - Loops until stop_reason is "end_turn" or max turns reached
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentLoop = exports.SOURCE_GLOBAL_LANES = void 0;
-exports.sanitizeLegacyCodexAgentsMd = sanitizeLegacyCodexAgentsMd;
-exports.loadBackendAgentsMd = loadBackendAgentsMd;
-exports.loadComposedSystemPrompt = loadComposedSystemPrompt;
-exports.getGatewayToolsPrompt = getGatewayToolsPrompt;
-exports.buildAgentToolExecutionContext = buildAgentToolExecutionContext;
-const fs_1 = require("fs");
-const native_effect_observer_js_1 = require("./native-effect-observer.js");
-const prompt_size_monitor_js_1 = require("./prompt-size-monitor.js");
-const skill_loader_js_1 = require("./skill-loader.js");
-const persistent_cli_adapter_js_1 = require("./persistent-cli-adapter.js");
-const cline_cli_adapter_js_1 = require("./cline-cli-adapter.js");
-const cline_native_tool_policy_js_1 = require("./cline-native-tool-policy.js");
-const runtime_process_js_1 = require("../multi-agent/runtime-process.js");
-const model_runner_js_1 = require("./model-runner.js");
-const gateway_tool_executor_js_1 = require("./gateway-tool-executor.js");
-const run_guard_js_1 = require("../envelope/run-guard.js");
-const tool_registry_js_1 = require("./tool-registry.js");
-const gateway_tool_catalog_js_1 = require("./gateway-tool-catalog.js");
-const private_connector_policy_js_1 = require("../connectors/private-connector-policy.js");
-const index_js_1 = require("./code-act/index.js");
-const index_js_2 = require("../concurrency/index.js");
-const session_pool_js_1 = require("./session-pool.js");
-const principal_js_1 = require("../gateways/principal.js");
-const owner_runtime_js_1 = require("../operator/owner-runtime.js");
-const owner_event_policy_js_1 = require("../operator/owner-event-policy.js");
-const os_1 = require("os");
-const path_1 = require("path");
-const crypto_1 = require("crypto");
-const types_js_1 = require("./types.js");
-const context_prompt_builder_js_1 = require("./context-prompt-builder.js");
-const telegram_format_js_1 = require("../gateways/telegram-format.js");
-const temporal_code_act_breaker_js_1 = require("./temporal-code-act-breaker.js");
-const post_tool_handler_js_1 = require("./post-tool-handler.js");
-const stop_continuation_handler_js_1 = require("./stop-continuation-handler.js");
-const pre_compact_handler_js_1 = require("./pre-compact-handler.js");
-const debugLogger = __importStar(require("@jungjaehoon/mama-core/debug-logger"));
-const { DebugLogger } = debugLogger;
-const logger = new DebugLogger('AgentLoop');
-const MODEL_RUNNER_AGENT_ERROR_CODES = {
-    timeout: 'NETWORK_ERROR',
-    crash: 'CLI_ERROR',
-    context_overflow: 'MAX_TOKENS',
-    auth_failure: 'AUTH_ERROR',
-    rate_limit: 'RATE_LIMIT',
-    unknown: 'CLI_ERROR',
-};
-/**
- * Default configuration
- */
-const DEFAULT_MAX_TURNS = 20; // Increased from 10 to allow more complex tool chains
-/**
- * Default tools configuration - all tools via Gateway (self-contained)
- */
-const DEFAULT_TOOLS_CONFIG = {
-    gateway: ['*'],
-    mcp: [],
-    mcp_config: '~/.mama/mama-mcp-config.json',
-};
-const DEFAULT_PRIVATE_CONNECTOR_POLICY = (0, private_connector_policy_js_1.resolvePrivateConnectorPolicy)({
-    ok: true,
-    config: {},
-    enabledNames: [],
-});
-// Sources without an entry stay on their per-session lane. Every owner stimulus
-// uses owner:runtime, so its session lane serializes chat, events, reports,
-// maintenance, and heartbeat before any global-lane choice is considered.
-exports.SOURCE_GLOBAL_LANES = {
-    viewer: 'viewer',
-    system: 'system',
-    // Non-owner trigger authoring/review still uses the operator global lane.
-    operator: 'operator',
-};
-function applyTemporalCodeActBreakerState(runScope, state) {
-    runScope.codeActCalls = state.codeActCalls;
-    runScope.lastDeterministicFingerprint = state.lastDeterministicFingerprint;
-    runScope.consecutiveDeterministicFailures = state.consecutiveDeterministicFailures;
-}
-function temporalCodeActTerminalResult(decision) {
-    return {
-        success: false,
-        code: 'TOOL_CONTRACT_REPEAT',
-        retryable: false,
-        abort: true,
-        failureClass: 'deterministic_contract',
-        ...(decision.fingerprintPrefix
-            ? { deterministicFingerprintPrefix: decision.fingerprintPrefix }
-            : {}),
-        error: decision.reason === 'outer_call_limit'
-            ? 'Temporal outer Code-Act call limit exceeded before host execution'
-            : 'Temporal deterministic host-tool contract failure repeated three times',
-    };
-}
-function historyToolResult(result) {
-    const { abort: _abort, terminalCode: _terminalCode, ...block } = result;
-    return block;
-}
-/**
- * Load CLAUDE.md system prompt
- * Tries multiple paths: project root, ~/.mama, /etc/mama
- */
-function loadSystemPrompt(verbose = false) {
-    const searchPaths = [
-        // User home - MAMA standalone config (priority)
-        (0, path_1.join)((0, os_1.homedir)(), '.mama/CLAUDE.md'),
-        // System config
-        '/etc/mama/CLAUDE.md',
-        // Project root (monorepo) - fallback only for development
-        (0, path_1.join)(__dirname, '../../../../CLAUDE.md'),
-    ];
-    for (const path of searchPaths) {
-        if ((0, fs_1.existsSync)(path)) {
-            if (verbose)
-                console.log(`[AgentLoop] Loaded system prompt from: ${path}`);
-            return (0, fs_1.readFileSync)(path, 'utf-8');
-        }
-    }
-    console.warn('[AgentLoop] CLAUDE.md not found, using default identity');
-    return "You are Claude Code, Anthropic's official CLI for Claude.";
-}
-/**
- * Load backend-specific AGENTS.md from ~/.mama/
- * Maps backend to file: 'claude' → AGENTS.claude.md, 'codex' → AGENTS.codex.md
- */
-function sanitizeLegacyCodexAgentsMd(content) {
-    const nativeGuidance = [
-        'MAMA exposes the tools permitted for this run as native host tools. Call those tools directly through the model tool interface.',
-        '',
-        'Do not print Markdown tool blocks or JavaScript as a substitute for a tool call. The available native tool set is injected for each run and already reflects the current role and channel permissions.',
-    ].join('\n');
-    const knownLegacySections = [
-        {
-            heading: '## Tool protocol',
-            nextHeading: '## Behavioural traits to know about yourself',
-            signature: 'Gateway tools via `tool_call` JSON blocks:',
-        },
-        {
-            heading: '## Tool Usage',
-            nextHeading: '### Skills',
-            signature: 'Use gateway tools via `tool_call` JSON blocks.',
-        },
-    ];
-    const knownLegacyLines = [
-        '### How to Call Tools',
-        '### Available Gateway Tools',
-        '### Important',
-        '- **mama_search**(query?, type?, limit?) — Search decisions in MAMA memory',
-        '- **mama_save**(type, topic?, decision?, reasoning?) — Save decision or checkpoint',
-        '- **mama_update**(id, outcome, reason?) — Update decision outcome',
-        '- **mama_load_checkpoint**() — Load last checkpoint',
-        '- **discord_send**(channel_id, message?) — Send message to Discord channel',
-        '- **slack_send**(channel_id, message?) — Send message to Slack channel',
-        '- **Read**(path) — Read file',
-        '- **Write**(path, content) — Write file',
-        '- **Bash**(command) — Execute shell command',
-        '- Do NOT use `exec_command` or `apply_patch` — use gateway tools instead',
-        '- Tool calls are executed automatically. No need to use curl or Bash for these.',
-        "Do NOT use `exec_command` or `apply_patch` — those are Codex defaults but bypass MAMA's gateway. Tool calls are executed automatically; do not wrap in `curl` or `Bash`.",
-        '## Available gateway tools',
-        '`mama_search`, `mama_save`, `mama_recall`, `mama_update`, `mama_load_checkpoint`, `discord_send`, `slack_send`, `Read`, `Write`, `Bash`. Check the skill `SKILL.md` for skill-provided extras.',
-    ];
-    const removeExactLine = (section, line) => section
-        .split(/(\r?\n)/)
-        .filter((part) => part !== line)
-        .join('');
-    let sanitized = content;
-    for (const legacy of knownLegacySections) {
-        const start = sanitized.indexOf(legacy.heading);
-        if (start === -1) {
-            continue;
-        }
-        const end = sanitized.indexOf(legacy.nextHeading, start + legacy.heading.length);
-        if (end === -1) {
-            continue;
-        }
-        const section = sanitized.slice(start, end);
-        if (!section.includes(legacy.signature) || !section.includes('```tool_call')) {
-            continue;
-        }
-        let transformed = section.replace(legacy.signature, nativeGuidance);
-        const toolCallExample = [
-            '```tool_call',
-            '{"name": "tool_name", "input": {"param1": "value1"}}',
-            '```',
-        ].join('\n');
-        transformed = transformed
-            .replaceAll(toolCallExample, '')
-            .replaceAll(toolCallExample.replaceAll('\n', '\r\n'), '');
-        for (const line of knownLegacyLines) {
-            transformed = removeExactLine(transformed, line);
-        }
-        sanitized = `${sanitized.slice(0, start)}${transformed}${sanitized.slice(end)}`;
-    }
-    return sanitized;
-}
-function loadBackendAgentsMd(backend, verbose = false) {
-    if (!backend) {
-        return '';
-    }
-    const keyMap = {
-        claude: 'claude',
-        codex: 'codex',
-    };
-    const key = keyMap[backend];
-    if (!key) {
-        return '';
-    }
-    const filePath = (0, path_1.join)((0, os_1.homedir)(), '.mama', `AGENTS.${key}.md`);
-    if ((0, fs_1.existsSync)(filePath)) {
-        if (verbose) {
-            console.log(`[AgentLoop] Loaded backend AGENTS.md: AGENTS.${key}.md`);
-        }
-        const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
-        return key === 'codex' ? sanitizeLegacyCodexAgentsMd(content) : content;
-    }
-    if (verbose) {
-        console.log(`[AgentLoop] Backend AGENTS.md not found: AGENTS.${key}.md`);
-    }
-    return '';
-}
-function loadComposedSystemPrompt(verbose = false, context) {
-    const layers = [];
-    // Load skill catalog (on-demand mode — full content injected per-message by PromptEnhancer)
-    const skillCatalog = (0, skill_loader_js_1.filterSkillCatalogForContext)((0, skill_loader_js_1.loadInstalledSkills)(verbose, { includePaths: context?.roleName === 'owner_console' }), context);
-    if (skillCatalog.length > 0) {
-        const skillDirective = [
-            '# Installed Skills',
-            '',
-            'Choose relevant skills from their descriptions and the current task; keywords are optional hints.',
-            'Read the selected instructions (source path when listed) before applying them. Learned procedures use procedure_list/read.',
-            '',
-            ...skillCatalog,
-        ].join('\n');
-        layers.push(skillDirective);
-        if (verbose)
-            console.log(`[AgentLoop] Skill catalog: ${skillCatalog.length} skills`);
-    }
-    // Add minimal context if AgentContext is provided (role awareness)
-    if (context) {
-        layers.push((0, context_prompt_builder_js_1.buildMinimalContext)(context));
-    }
-    // Load CLAUDE.md (base instructions)
-    const claudeMd = loadSystemPrompt(verbose);
-    layers.push(claudeMd);
-    const result = layers.join('\n\n---\n\n');
-    // Debug: log each layer's size to find what's consuming context
-    logger.debug(`[SystemPrompt] Total: ${result.length} chars, layers: ${layers.map((l, i) => `L${i}=${l.length}`).join(', ')}`);
-    return result;
-}
-/**
- * Load Gateway Tools prompt from MD file
- * These tools are executed by GatewayToolExecutor, NOT MCP
- */
-function getGatewayToolsPrompt(disallowed) {
-    return (0, gateway_tool_catalog_js_1.buildGatewayToolCatalog)({
-        surface: 'multi-agent-generic',
-        allowedTools: ['*'],
-        blockedTools: disallowed,
-        privateConnectorPolicy: DEFAULT_PRIVATE_CONNECTOR_POLICY,
-    }).prompt;
-}
-function getRunGatewayToolsPrompt(context, disallowed) {
-    return (0, gateway_tool_catalog_js_1.buildGatewayToolCatalog)({
-        surface: context
-            ? (0, private_connector_policy_js_1.resolvePrivatePrincipalSurface)({ agentContext: context })
-            : 'multi-agent-generic',
-        allowedTools: context?.role.allowedTools ?? ['*'],
-        blockedTools: [...(context?.role.blockedTools ?? []), ...(disallowed ?? [])],
-        privateConnectorPolicy: DEFAULT_PRIVATE_CONNECTOR_POLICY,
-    }).prompt;
-}
-/** Korean/English phrasings that assert a correction, save, update or send has happened. */
-const COMPLETION_CLAIM_PATTERN = /(?:반영|저장|기록|등록|갱신|적용|수정|전송|발송)\s*(?:완료|했습니다|됐습니다|되었습니다|하였습니다)|\b(?:saved|updated|applied|recorded|sent)\b/i;
-const CANONICAL_CODE_ACT_HEADING = '## Code-Act: Gateway Tool Execution via Sandbox';
-const CODE_ACT_MCP_COMPAT_NAME = 'mcp__code-act__code_act';
-const GENERATED_CODE_ACT_START = '<!-- MAMA_GENERATED_CODE_ACT_START -->';
-const GENERATED_CODE_ACT_END = '<!-- MAMA_GENERATED_CODE_ACT_END -->';
-const GENERATED_GATEWAY_TOOLS_START = '<!-- MAMA_GENERATED_GATEWAY_TOOLS_START -->';
-const GENERATED_GATEWAY_TOOLS_END = '<!-- MAMA_GENERATED_GATEWAY_TOOLS_END -->';
-function removePromptSection(systemPrompt, sectionStart, sectionEnd) {
-    const prefix = systemPrompt.slice(0, sectionStart);
-    const separator = prefix.match(/\r?\n\r?\n---[ \t]*\r?\n\r?\n$/);
-    const removalStart = separator?.index ?? sectionStart;
-    return `${systemPrompt.slice(0, removalStart)}${systemPrompt.slice(sectionEnd)}`;
-}
-function stripMarkedPromptSection(systemPrompt, startMarker, endMarker) {
-    let stripped = systemPrompt;
-    let sectionStart = stripped.lastIndexOf(startMarker);
-    while (sectionStart >= 0) {
-        const markerEnd = stripped.indexOf(endMarker, sectionStart + startMarker.length);
-        if (markerEnd < 0) {
-            return stripped;
-        }
-        stripped = removePromptSection(stripped, sectionStart, markerEnd + endMarker.length);
-        sectionStart = stripped.lastIndexOf(startMarker);
-    }
-    return stripped;
-}
-function wrapGeneratedPromptSection(kind, content) {
-    const [start, end] = kind === 'codeAct'
-        ? [GENERATED_CODE_ACT_START, GENERATED_CODE_ACT_END]
-        : [GENERATED_GATEWAY_TOOLS_START, GENERATED_GATEWAY_TOOLS_END];
-    return `${start}\n${content}\n${end}`;
-}
-function stripGenericGatewayToolsCatalog(systemPrompt) {
-    const withoutMarked = stripMarkedPromptSection(systemPrompt, GENERATED_GATEWAY_TOOLS_START, GENERATED_GATEWAY_TOOLS_END);
-    const generatedCatalog = getGatewayToolsPrompt();
-    const catalogStart = withoutMarked.lastIndexOf(generatedCatalog);
-    if (catalogStart < 0) {
-        return withoutMarked;
-    }
-    const catalogEnd = catalogStart + generatedCatalog.length;
-    const startsAtLayerBoundary = catalogStart === 0 ||
-        /\r?\n\r?\n---[ \t]*\r?\n\r?\n$/.test(withoutMarked.slice(0, catalogStart));
-    const endsAtLayerBoundary = catalogEnd === withoutMarked.length ||
-        /^\r?\n\r?\n---[ \t]*\r?\n\r?\n/.test(withoutMarked.slice(catalogEnd));
-    if (!startsAtLayerBoundary || !endsAtLayerBoundary) {
-        return withoutMarked;
-    }
-    return removePromptSection(withoutMarked, catalogStart, catalogEnd);
-}
-function stripTrailingCanonicalCodeActSection(systemPrompt) {
-    const withoutMarked = stripMarkedPromptSection(systemPrompt, GENERATED_CODE_ACT_START, GENERATED_CODE_ACT_END);
-    const sectionStart = withoutMarked.lastIndexOf(CANONICAL_CODE_ACT_HEADING);
-    if (sectionStart < 0) {
-        return withoutMarked;
-    }
-    const section = withoutMarked.slice(sectionStart);
-    const typeFenceStart = section.indexOf('```typescript');
-    if (typeFenceStart >= 0) {
-        const typeFenceEnd = section.indexOf('```', typeFenceStart + '```typescript'.length);
-        if (typeFenceEnd >= 0) {
-            return removePromptSection(withoutMarked, sectionStart, sectionStart + typeFenceEnd + 3);
-        }
-    }
-    const boundedSeparator = section.match(/\r?\n\r?\n---[ \t]*\r?\n\r?\n/);
-    const sectionEnd = boundedSeparator?.index ?? section.length;
-    return removePromptSection(withoutMarked, sectionStart, sectionStart + sectionEnd);
-}
-function stripDisabledCodeActGuidance(systemPrompt) {
-    return stripTrailingCanonicalCodeActSection(systemPrompt).replace(/^- \*\*(?:code_act|mcp__code-act__code_act)\*\*.*$/gm, '');
-}
-function combineCodeActSessionPolicyFingerprint(callerFingerprint, policy) {
-    return JSON.stringify({
-        version: 1,
-        callerFingerprint: callerFingerprint ?? null,
-        codeActPolicy: policy.fingerprintPayload,
-    });
-}
-function ownerRuntimeSessionPolicyFingerprint(role, model, supportsNativeSubagents, backend) {
-    return JSON.stringify({
-        version: 1,
-        subject: owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY,
-        // The fingerprint names the policy the session actually carries: a runner without
-        // native subagents is never told to delegate, so it must not be pinned to that text.
-        subagentPolicy: supportsNativeSubagents ? (0, owner_runtime_js_1.ownerSubagentInstructions)(backend) : null,
-        telegramFormatPolicy: telegram_format_js_1.TELEGRAM_FORMAT_GUIDE,
-        model: model ?? null,
-        allowedTools: [...(role?.allowedTools ?? [])].sort(),
-        blockedTools: [...(role?.blockedTools ?? [])].sort(),
-        allowedPaths: [...(role?.allowedPaths ?? [])].sort(),
-        systemControl: role?.systemControl === true,
-        sensitiveAccess: role?.sensitiveAccess === true,
-    });
-}
-function roleAllowsOuterCodeAct(role, disallowedTools) {
-    if (!role) {
-        return false;
-    }
-    return tool_registry_js_1.ToolRegistry.getHostToolDefinitions({
-        allowedTools: role.allowedTools,
-        blockedTools: role.blockedTools,
-        disallowedTools: disallowedTools ? [...disallowedTools] : undefined,
-    }).some((tool) => tool.name === index_js_1.CODE_ACT_MARKER);
-}
-function buildAgentToolExecutionContext(options) {
-    if (!options ||
-        (options.agentContext === undefined &&
-            options.source === undefined &&
-            options.channelId === undefined &&
-            options.envelope === undefined &&
-            options.sourceTurnId === undefined &&
-            options.sourceMessageRef === undefined &&
-            options.modelRunId === undefined &&
-            options.workorderAttemptId === undefined &&
-            options.temporalWorkContext === undefined &&
-            options.wikiTaskRange === undefined &&
-            options.ownerEventEffects === undefined)) {
-        return null;
-    }
-    const agentContext = options.agentContext;
-    const context = {
-        agentContext,
-        agentId: options.actorId ??
-            (agentContext
-                ? agentContext.source === 'viewer'
-                    ? 'os-agent'
-                    : agentContext.roleName
-                : undefined),
-        source: options.source,
-        channelId: options.channelId,
-        envelope: options.envelope,
-        executionSurface: 'model_tool',
-        channelGrantSnapshot: options.memberEffectiveScope?.channelGrant,
-        memberScopeRequired: options.memberScopeRequired,
-    };
-    if (options.sourceTurnId !== undefined) {
-        context.sourceTurnId = options.sourceTurnId;
-    }
-    if (options.sourceMessageRef !== undefined) {
-        context.sourceMessageRef = options.sourceMessageRef;
-    }
-    if (options.modelRunId !== undefined) {
-        context.modelRunId = options.modelRunId;
-    }
-    if (options.workorderAttemptId !== undefined) {
-        context.workorderAttemptId = options.workorderAttemptId;
-    }
-    if (options.causeEventIds !== undefined) {
-        context.causeEventIds = options.causeEventIds;
-    }
-    if (options.ownerEventEffects !== undefined) {
-        context.ownerEventEffects = options.ownerEventEffects;
-    }
-    if (options.temporalWorkContext !== undefined) {
-        context.temporalWorkContext = options.temporalWorkContext;
-    }
-    if (options.wikiTaskRange !== undefined) {
-        context.wikiTaskRange = options.wikiTaskRange;
-    }
-    return context;
-}
-function withExecutionSurface(executionContext, executionSurface) {
-    if (!executionContext) {
-        return null;
-    }
-    if (executionContext.executionSurface === executionSurface) {
-        return executionContext;
-    }
-    return {
-        ...executionContext,
-        executionSurface,
-    };
-}
-/** Normal coding tasks often need 10+ consecutive Bash calls; 5 was too low. */
-const MAX_CONSECUTIVE_SAME_HOST_TOOL = 15;
-/**
- * The parent run's shape, kept only so a child announced mid-run (or after it) can be
- * given an authority of its OWN: its own model run under the parent's, its own envelope,
- * its own bridge with its own counters.
- */
-/**
- * The options a native child of this run inherits. Everything is carried EXCEPT the role,
- * which is projected onto the unattended surface: the owner's 1:1 chat turn holds the
- * gateway shell and file writer, and a child answers to no one inside the turn.
- */
-function withUnattendedSubagentRole(options) {
-    const agentContext = options?.agentContext;
-    if (!agentContext) {
-        return { ...options };
-    }
-    const role = (0, owner_event_policy_js_1.projectUnattendedRole)(agentContext.role);
-    return {
-        ...options,
-        agentContext: {
-            ...agentContext,
-            role,
-            capabilities: [...role.allowedTools],
-            limitations: (role.blockedTools ?? []).map((tool) => `Cannot use ${tool}`),
-        },
-    };
-}
-class AgentLoop {
-    /**
-     * Construction-wide child-runtime tool capability.
-     *
-     * Claude's persistent CLI cannot narrow native or MCP tools per turn, so a
-     * public lane may run only when both surfaces were disabled at construction.
-     * Codex native multi-agent and Claude built-ins are construction-wide, so
-     * public lanes must use another tool-free runtime. Cline can gate spawn per role.
-     */
-    childRuntimeToolCapable;
-    probesDurableSession;
-    ownerRecoveryJournalEnabled;
-    agent;
-    /**
-     * Whether the ACTIVE runner can spawn a native subagent the host can observe.
-     *
-     * Read by the owner prompt path and forwarded to the scheduled work-order contract, so
-     * neither has to string-match a backend name. A mocked runner that predates this field
-     * is treated as incapable rather than silently promised delegation.
-     */
-    get supportsNativeSubagents() {
-        return this.agent.supportsNativeSubagents === true;
-    }
-    /**
-     * What a native child started by a run on this session needs to be given its own
-     * authority. Keyed by session key, overwritten by each run on that session, and dropped
-     * once the run finished and no child of it is still registered.
-     */
-    subagentRunContexts = new Map();
-    persistentCLI = null;
-    mcpExecutor;
-    maxTurns;
-    model;
-    onTurn;
-    onToolUse;
-    runTokenBudget;
-    onBudgetStop;
-    onTokenUsage;
-    onMetric;
-    laneManager;
-    useLanes;
-    sessionKey;
-    sessionPool;
-    toolsConfig;
-    isGatewayMode;
-    useCodeAct;
-    backend;
-    defaultSystemPrompt;
-    postToolHandler;
-    stopContinuationHandler;
-    preCompactHandler;
-    // Per-run state (stream callbacks, tier) lives in a RunScope threaded through
-    // runWithContentInternal -> executeTools, NEVER on the
-    // instance: concurrent runs on separate global lanes (operator report/worker
-    // overlapping owner chat) would steal each other's callbacks and leak tiers
-    // if these were instance fields.
-    disallowedTools;
-    clineNativeAllowedTools;
-    clineNativeDisallowedTools;
-    clineNativePolicyConfigured;
-    clineAllowSpawnAgent;
-    clineAllowAgentTeams;
-    ownerRuntimeJournal;
-    createNativeEffectObserver;
-    constructor(_oauthManager, options = {}, _clientOptions, executorOptions) {
-        // Initialize tools config (hybrid Gateway/MCP routing)
-        this.toolsConfig = {
-            ...DEFAULT_TOOLS_CONFIG,
-            ...options.toolsConfig,
-        };
-        const mcpConfigPath = this.toolsConfig.mcp_config?.replace('~', (0, os_1.homedir)()) ||
-            (0, path_1.join)((0, os_1.homedir)(), '.mama/mama-mcp-config.json');
-        const sessionId = (0, crypto_1.randomUUID)();
-        // Determine tool mode: Gateway, MCP, or Hybrid
-        // - gateway: ['*'] → Use internal GatewayToolExecutor for mama_*, discord_send, etc.
-        // - mcp: ['*'] or [...] → Use MCP servers for external tools (brave-devtools, etc.)
-        // - Both can be enabled for hybrid mode
-        const mcpTools = this.toolsConfig.mcp || [];
-        const gatewayTools = this.toolsConfig.gateway || [];
-        // Hybrid mode: Gateway + MCP both enabled
-        const useGatewayMode = gatewayTools.includes('*') || gatewayTools.length > 0;
-        const useMCPMode = mcpTools.includes('*') || mcpTools.length > 0;
-        this.useCodeAct = options.useCodeAct ?? false;
-        this.isGatewayMode =
-            useGatewayMode ||
-                ((options.backend === 'codex' || options.backend === 'cline') && this.useCodeAct);
-        this.disallowedTools = this.useCodeAct
-            ? options.disallowedTools
-            : [
-                ...new Set([
-                    ...(options.disallowedTools ?? []),
-                    index_js_1.CODE_ACT_MARKER,
-                    CODE_ACT_MCP_COMPAT_NAME,
-                ]),
-            ];
-        this.clineNativeAllowedTools = [...(options.clineNativeAllowedTools ?? [])];
-        this.clineNativeDisallowedTools = [...(options.clineNativeDisallowedTools ?? [])];
-        this.clineNativePolicyConfigured =
-            options.clineNativeAllowedTools !== undefined ||
-                options.clineNativeDisallowedTools !== undefined;
-        this.clineAllowSpawnAgent = options.clineAllowSpawnAgent ?? false;
-        this.clineAllowAgentTeams = options.clineAllowAgentTeams ?? false;
-        this.ownerRuntimeJournal = options.ownerRuntimeJournal;
-        this.ownerRecoveryJournalEnabled = this.ownerRuntimeJournal !== undefined;
-        if (useGatewayMode && useMCPMode) {
-            logger.debug('🔀 Hybrid mode: Gateway + MCP tools enabled');
-        }
-        else if (useMCPMode) {
-            logger.debug('🔌 MCP-only mode');
-        }
-        else {
-            logger.debug('⚙️ Gateway-only mode');
-        }
-        // Build system prompt with layered truncation support
-        const monitor = new prompt_size_monitor_js_1.PromptSizeMonitor();
-        let promptLayers;
-        if (options.systemPrompt) {
-            // Custom system prompt (e.g., multi-agent): treat as a single critical layer
-            promptLayers = [{ name: 'custom', content: options.systemPrompt, priority: 1 }];
-        }
-        else {
-            // Composed prompt: build layers with individual priorities for graceful truncation
-            // Priority 1 (never cut): CLAUDE.md base instructions
-            // Priority 2 (cut if extreme): personas (SOUL, IDENTITY, USER) + gateway tools
-            // Priority 3 (cut first): context prompt + skills + onboarding
-            const claudeMd = loadSystemPrompt();
-            const skillCatalog = (0, skill_loader_js_1.filterSkillCatalogForContext)((0, skill_loader_js_1.loadInstalledSkills)(false, {
-                includePaths: options.agentContext?.roleName === 'owner_console',
-            }), options.agentContext ?? null);
-            promptLayers = [
-                { name: 'claudeMd', content: claudeMd, priority: 1 },
-                ...(skillCatalog.length > 0
-                    ? [
-                        {
-                            name: 'skills',
-                            content: [
-                                '# Installed Skills',
-                                '',
-                                'Choose skills by their purpose and the current task, not only literal keywords.',
-                                '',
-                                ...skillCatalog,
-                            ].join('\n'),
-                            priority: 3,
-                        },
-                    ]
-                    : []),
-            ];
-        }
-        const backend = options.backend ?? 'claude';
-        this.probesDurableSession = backend === 'codex';
-        if (this.useCodeAct && options.systemPrompt) {
-            promptLayers = [
-                {
-                    name: 'custom',
-                    content: stripTrailingCanonicalCodeActSection(stripGenericGatewayToolsCatalog(options.systemPrompt)),
-                    priority: 1,
-                },
-            ];
-        }
-        if (this.isGatewayMode) {
-            if (this.useCodeAct &&
-                roleAllowsOuterCodeAct(options.agentContext?.role, this.disallowedTools)) {
-                // Code-Act mode: expose the compact progressive-discovery bootstrap.
-                const tierForTypeDefs = options.agentContext?.tier ?? 1;
-                const policy = (0, index_js_1.projectCodeActToolPolicy)({
-                    tier: tierForTypeDefs,
-                    roleName: options.agentContext?.roleName,
-                    role: options.agentContext?.role,
-                    disallowedTools: this.disallowedTools,
-                    envelopeDestinationKinds: options.envelope?.scope.allowed_destinations.map((destination) => destination.kind) ??
-                        [],
-                    envelopeRawConnectors: options.envelope?.scope.raw_connectors ?? [],
-                });
-                const codeActPrompt = wrapGeneratedPromptSection('codeAct', (0, index_js_1.getCodeActInstructions)(backend, policy.names));
-                promptLayers.push({
-                    name: 'codeAct',
-                    content: codeActPrompt,
-                    priority: 1,
-                    protectedPrefix: GENERATED_CODE_ACT_START,
-                    protectedSuffix: GENERATED_CODE_ACT_END,
-                });
-            }
-            else if (!this.useCodeAct && backend !== 'codex') {
-                const gatewayToolsPrompt = getRunGatewayToolsPrompt(options.agentContext, this.disallowedTools);
-                if (gatewayToolsPrompt) {
-                    promptLayers.push({
-                        name: 'gatewayTools',
-                        content: wrapGeneratedPromptSection('gatewayTools', gatewayToolsPrompt),
-                        priority: 2,
-                        protectedPrefix: GENERATED_GATEWAY_TOOLS_START,
-                        protectedSuffix: GENERATED_GATEWAY_TOOLS_END,
-                    });
-                }
-            }
-        }
-        const checkResult = monitor.check(promptLayers);
-        if (checkResult.warning) {
-            logger.warn(checkResult.warning);
-        }
-        // Enforce truncation if over budget (priority > 1 layers trimmed first)
-        if (!checkResult.withinBudget) {
-            const { layers: trimmedLayers, result: enforceResult } = monitor.enforce(promptLayers);
-            if (enforceResult.truncatedLayers.length > 0) {
-                logger.warn(`Truncated layers: ${enforceResult.truncatedLayers.join(', ')}`);
-            }
-            promptLayers = trimmedLayers;
-            logger.debug(`System prompt truncated: ${checkResult.totalChars} → ${enforceResult.totalChars} chars`);
-        }
-        const defaultSystemPrompt = promptLayers
-            .filter((l) => l.content.length > 0)
-            .map((l) => l.content)
-            .join('\n\n---\n\n');
-        this.defaultSystemPrompt = defaultSystemPrompt;
-        // Choose backend (default: claude)
-        this.backend = backend;
-        this.childRuntimeToolCapable =
-            backend === 'codex' || (backend === 'claude' && (useMCPMode || options.builtinTools !== ''));
-        if (this.backend === 'codex') {
-            // Codex app-server mode
-            const workspaceDir = options.codexCwd ?? (0, path_1.join)((0, os_1.homedir)(), '.mama', 'workspace');
-            // Ensure workspace directory exists
-            if (!(0, fs_1.existsSync)(workspaceDir)) {
-                (0, fs_1.mkdirSync)(workspaceDir, { recursive: true });
-            }
-            this.agent = new runtime_process_js_1.CodexRuntimeProcess({
-                model: options.model,
-                cwd: workspaceDir,
-                sandbox: options.codexSandbox ?? 'workspace-write',
-                systemPrompt: defaultSystemPrompt,
-                command: options.codexCommand,
-                requestTimeout: options.timeoutMs,
-                codexHome: options.codexHome,
-                isolatedHome: options.codexIsolatedHome,
-                registryRoot: options.codexRegistryRoot,
-                effort: options.codexEffort,
-                mcpConfigPath: this.useCodeAct
-                    ? undefined
-                    : (options.mcpConfigPath ?? (useMCPMode ? mcpConfigPath : undefined)),
-                // A Codex-native child outlives the parent turn. The host - not the child's
-                // parent bridge - issues its authority: own model run, own envelope, own counters.
-                createSubagentBridge: (info) => this.createSubagentBridge(info),
-            });
-            logger.debug('Codex app-server backend enabled');
-        }
-        else if (this.backend === 'cline') {
-            const workspaceDir = options.clineCwd ?? (0, path_1.join)((0, os_1.homedir)(), '.mama', 'workspace');
-            if (!(0, fs_1.existsSync)(workspaceDir)) {
-                (0, fs_1.mkdirSync)(workspaceDir, { recursive: true });
-            }
-            this.agent = new cline_cli_adapter_js_1.ClineCLIAdapter({
-                command: options.clineCommand,
-                provider: options.clineProvider ?? 'cline',
-                model: options.model,
-                systemPrompt: defaultSystemPrompt,
-                cwd: workspaceDir,
-                // Cline receives MAMA CodeAct as a session-bound Hub custom tool.
-                // Its shared daemon owns native MCP settings independently.
-                dataDir: options.clineDataDir,
-                requestTimeout: options.timeoutMs,
-                sessionId,
-            });
-            logger.debug('Cline CLI backend enabled');
-        }
-        else {
-            // Claude backend: always use PersistentCLI for fast responses (~2-3s vs ~16-30s)
-            this.persistentCLI = new persistent_cli_adapter_js_1.PersistentCLIAdapter({
-                model: options.model,
-                sessionId,
-                systemPrompt: defaultSystemPrompt,
-                // MCP config: only pass when MCP mode is enabled (gateway mode uses GatewayToolExecutor)
-                mcpConfigPath: useMCPMode ? mcpConfigPath : undefined,
-                // MAMA OS is a headless daemon (no TTY) — Claude CLI's interactive permission prompts
-                // cannot work. Security is enforced by MAMA's own RoleManager layer (config.yaml roles).
-                // DO NOT gate this on env vars — MAMA manages permissions via its config, not Claude CLI.
-                dangerouslySkipPermissions: options.dangerouslySkipPermissions ?? true,
-                // Gateway tools are processed by GatewayToolExecutor (hybrid with MCP)
-                useGatewayTools: useGatewayMode,
-                // Structurally disallow specific tools (e.g., Bash/Read for restricted agents)
-                disallowedTools: this.disallowedTools,
-                // Native built-ins cross with text-parsed gateway calls (hallucinated
-                // ToolSearch/Agent, native gathering that bypasses report verification).
-                // Callers opt in per loop; agent-loop-init locks down the main persona.
-                tools: options.builtinTools,
-                // agent.effort: the boot gate already proved it is a level this backend accepts.
-                effort: options.codexEffort,
-                // Pass configured timeout (default in PersistentCLI: 120s — too short for complex tasks)
-                requestTimeout: options.timeoutMs,
-            });
-            this.agent = this.persistentCLI;
-            logger.debug('🚀 Claude PersistentCLI mode enabled - faster responses');
-        }
-        logger.debug('Config: gateway=' +
-            JSON.stringify(this.toolsConfig.gateway) +
-            ' mcp=' +
-            JSON.stringify(this.toolsConfig.mcp));
-        // Root fix (2026-07-16): the daemon persona shares the boot-wired executor so
-        // every dependency wiring (task ledger, report publisher, event bus, gateways,
-        // wiki, obsidian, ...) reaches persona lanes by construction. Constructing a
-        // second instance here is allowed ONLY for deliberately isolated loops
-        // (memory agent, mama run CLI) that own their dep set.
-        this.mcpExecutor = options.executor ?? new gateway_tool_executor_js_1.GatewayToolExecutor(executorOptions);
-        // Persona tool blocks are per-call policy, not executor state - a shared
-        // executor must never inherit one caller's blocks (see buildToolExecutionContext).
-        this.maxTurns = options.maxTurns ?? DEFAULT_MAX_TURNS;
-        this.model = options.model;
-        this.onTurn = options.onTurn;
-        this.onToolUse = options.onToolUse;
-        this.createNativeEffectObserver = options.createNativeEffectObserver;
-        this.onTokenUsage = options.onTokenUsage;
-        this.runTokenBudget =
-            options.runTokenBudget && options.runTokenBudget > 0 ? options.runTokenBudget : 0;
-        this.onBudgetStop = options.onBudgetStop;
-        this.onMetric = options.onMetric;
-        this.laneManager = (0, index_js_2.getGlobalLaneManager)();
-        this.useLanes = options.useLanes ?? false;
-        this.sessionKey = options.sessionKey ?? 'default';
-        this.sessionPool = (0, session_pool_js_1.getSessionPool)();
-        // Initialize PostToolHandler (fire-and-forget after tool execution)
-        if (options.postToolUse?.enabled) {
-            this.postToolHandler = new post_tool_handler_js_1.PostToolHandler((name, input, executionContext) => this.mcpExecutor.execute(name, input, executionContext ?? undefined), { enabled: true, contractSaveLimit: options.postToolUse.contractSaveLimit });
-            console.log('[AgentLoop] PostToolHandler enabled');
-        }
-        else {
-            this.postToolHandler = null;
-        }
-        // Initialize PreCompactHandler (unsaved decision detection)
-        if (options.preCompact?.enabled) {
-            this.preCompactHandler = new pre_compact_handler_js_1.PreCompactHandler((name, input, executionContext) => this.mcpExecutor.execute(name, input, executionContext ?? undefined), { enabled: true, maxDecisionsToDetect: options.preCompact.maxDecisionsToDetect });
-            console.log('[AgentLoop] PreCompactHandler enabled');
-        }
-        else {
-            this.preCompactHandler = null;
-        }
-        // Initialize StopContinuationHandler (opt-in auto-resume)
-        if (options.stopContinuation?.enabled) {
-            this.stopContinuationHandler = new stop_continuation_handler_js_1.StopContinuationHandler({
-                enabled: true,
-                maxRetries: options.stopContinuation.maxRetries ?? 3,
-                completionMarkers: options.stopContinuation.completionMarkers ?? [
-                    'DONE',
-                    'FINISHED',
-                    '✅',
-                    'TASK_COMPLETE',
-                ],
-            });
-            console.log('[AgentLoop] StopContinuationHandler enabled');
-        }
-        else {
-            this.stopContinuationHandler = null;
-        }
-    }
-    setContextCompileService(service) {
-        this.mcpExecutor.setContextCompileService(service);
-    }
-    /**
-     * Set session key for lane-based concurrency
-     * Use format: "{source}:{channelId}:{userId}"
-     */
-    setSessionKey(key) {
-        this.sessionKey = key;
-    }
-    /**
-     * Get current session key
-     */
-    getSessionKey() {
-        return this.sessionKey;
-    }
-    resolveGlobalLaneForSession(sessionKey) {
-        const source = sessionKey.split(':', 1)[0]?.trim().toLowerCase();
-        if (!source) {
-            return undefined;
-        }
-        return exports.SOURCE_GLOBAL_LANES[source];
-    }
-    buildToolExecutionContext(options) {
-        const base = buildAgentToolExecutionContext(options);
-        if (!base) {
-            return null; // no context fields - out-of-scope loops keep today's semantics
-        }
-        return {
-            ...base,
-            // Persona blocks are per-call policy - never executor instance state.
-            disallowedGatewayTools: this.disallowedTools,
-            // Never let optional multi-agent persona calls inherit the code-act
-            // route's fallback identity. `conductor` remains the legacy persona
-            // fallback and is unrelated to the removed background event subject.
-            // (Persona lanes always pass source/channelId, so base is non-null for them
-            // and the disallowed list travels on every persona run.)
-            agentId: base.agentId || 'conductor',
-        };
-    }
-    /**
-     * Set system prompt override (for per-message context injection)
-     */
-    setSystemPrompt(prompt) {
-        this.agent.setSystemPrompt(prompt ?? this.defaultSystemPrompt);
-    }
-    /**
-     * Set Discord gateway for discord_send tool
-     */
-    setDiscordGateway(gateway) {
-        this.mcpExecutor.setDiscordGateway(gateway);
-    }
-    /**
-     * Set Telegram gateway for telegram_send tool
-     */
-    setTelegramGateway(gateway) {
-        this.mcpExecutor.setTelegramGateway(gateway);
-    }
-    /**
-     * Set shared sessions DB for agent management and validation-aware tools.
-     */
-    setSessionsDb(db) {
-        this.mcpExecutor.setSessionsDb(db);
-    }
-    /**
-     * Set validation service for agent validation flows.
-     */
-    setValidationService(svc) {
-        this.mcpExecutor.setValidationService(svc);
-    }
-    /**
-     * Set raw store for connector-backed agent_test input gathering.
-     */
-    setRawStore(store) {
-        this.mcpExecutor.setRawStore(store);
-    }
-    /**
-     * Set report publisher for report_publish tool (Dashboard Agent)
-     */
-    setReportPublisher(fn) {
-        this.mcpExecutor.setReportPublisher(fn);
-    }
-    /**
-     * Set wiki publisher for wiki_publish tool (Wiki Agent)
-     */
-    setWikiPublisher(fn) {
-        this.mcpExecutor.setWikiPublisher(fn);
-    }
-    /**
-     * Set AgentEventBus for agent_notices tool
-     */
-    setAgentEventBus(eventBus) {
-        this.mcpExecutor.setAgentEventBus(eventBus);
-    }
-    /**
-     * The model runner backing this loop, for host adapters that subscribe to runner
-     * lifecycle events (e.g. native subagent completion waking the standing owner).
-     * Returned as `unknown` on purpose: the runner surface differs per backend, so the
-     * caller must feature-detect rather than assume an emitter.
-     */
-    getModelRunner() {
-        return this.agent;
-    }
-    /**
-     * Run the agent loop with a user prompt
-     *
-     * Uses lane-based concurrency when useLanes is enabled:
-     * - Same session messages are processed in order
-     * - Different sessions can run in parallel
-     * - Global lane limits total concurrent API calls
-     *
-     * @param prompt - User prompt to process
-     * @param options - Execution options (systemPrompt, disableAutoRecall, etc.)
-     * @returns Agent loop result with final response and history
-     * @throws AgentError on errors
-     */
-    async run(prompt, options) {
-        // Convert string prompt to text content block
-        const content = [{ type: 'text', text: prompt }];
-        // Per-call session key wins over the instance default (same contract as
-        // runWithContent): overlapping runs on a shared AgentLoop must never
-        // depend on a mutated this.sessionKey to pick their lane.
-        const sessionKey = options?.sessionKey || this.sessionKey;
-        // Use lane-based queueing if enabled
-        if (this.useLanes) {
-            const globalLane = this.resolveGlobalLaneForSession(sessionKey);
-            return this.laneManager.enqueueWithSession(sessionKey, () => this.runWithContentInternal(content, options), globalLane, { priority: options?.lanePriority ?? 0 });
-        }
-        // Direct execution for backward compatibility
-        return this.runWithContentInternal(content, options);
-    }
-    /**
-     * Run the agent loop with multimodal content blocks
-     *
-     * Uses lane-based concurrency when useLanes is enabled.
-     *
-     * @param content - Array of content blocks (text, images, documents)
-     * @param options - Execution options (systemPrompt, disableAutoRecall, etc.)
-     * @returns Agent loop result with final response and history
-     * @throws AgentError on errors
-     */
-    async runWithContent(content, options) {
-        const sessionKey = options?.sessionKey || this.sessionKey;
-        // Use lane-based queueing if enabled
-        if (this.useLanes) {
-            const globalLane = this.resolveGlobalLaneForSession(sessionKey);
-            return this.laneManager.enqueueWithSession(sessionKey, () => this.runWithContentInternal(content, options), globalLane, { priority: options?.lanePriority ?? 0 });
-        }
-        // Direct execution for backward compatibility
-        return this.runWithContentInternal(content, options);
-    }
-    /**
-     * Internal implementation of runWithContent (without lane queueing)
-     */
-    async runWithContentInternal(content, options) {
-        if (this.stopped) {
-            throw new types_js_1.AgentError('Agent loop is stopping', 'AGENT_STOPPED', undefined, false);
-        }
-        // Queue wait consumes no execution authority. Never renew a signed envelope implicitly:
-        // only a host-supplied issuer can prepare the current grant after both lane waits.
-        if (options?.prepareEnvelope) {
-            const runEnvelopeIssuer = options.prepareEnvelope;
-            options = {
-                ...options,
-                envelope: await runEnvelopeIssuer(),
-                prepareEnvelope: undefined,
-                // A native child outlives this envelope and needs one of its OWN. The run's issuer
-                // is the fallback when the host supplied no dedicated subagent issuer, so it is kept
-                // reachable here instead of being lost with this rewrite - without it a child would
-                // silently get no authority at all.
-                prepareSubagentEnvelope: options.prepareSubagentEnvelope ?? (async () => await runEnvelopeIssuer()),
-            };
-            if (this.stopped) {
-                throw new types_js_1.AgentError('Agent loop is stopping', 'AGENT_STOPPED', undefined, false);
-            }
-        }
-        if (options?.prepareContent) {
-            const admitted = await options.prepareContent();
-            content = admitted.content;
-            options = { ...options, procedureRefs: admitted.procedureRefs, prepareContent: undefined };
-            if (this.stopped) {
-                throw new types_js_1.AgentError('Agent loop is stopping', 'AGENT_STOPPED', undefined, false);
-            }
-        }
-        if (options?.agentContext) {
-            options = {
-                ...options,
-                agentContext: this.mcpExecutor.projectPrivateAgentContext(options.agentContext),
-            };
-        }
-        const runScope = {
-            streamCallbacks: options?.streamCallbacks,
-            tier: 1,
-            onTurn: options?.onTurn ?? this.onTurn,
-            onToolUse: options?.onToolUse ?? this.onToolUse,
-            ...(0, temporal_code_act_breaker_js_1.createTemporalCodeActBreakerState)(),
-        };
-        const history = [];
-        const ownerJournalPrompt = options?.ownerJournalPrompt ??
-            content.map((block) => (block.type === 'text' ? block.text : `[${block.type}]`)).join('\n');
-        const totalUsage = { input_tokens: 0, output_tokens: 0 };
-        // Budget accounting is separate from totalUsage (a published field): it includes cache
-        // creation and cache reads, which are the bulk of a re-sent context and the cost being
-        // bounded - a budget that ignored them would not have stopped a 4.28M-token run.
-        let budgetTokens = 0;
-        let stoppedBy;
-        let turn = 0;
-        let stopReason = 'end_turn';
-        let ownedModelRunId = null;
-        let ownedModelRunCommitted = false;
-        let nativeEffects = new native_effect_observer_js_1.NativeEffectReplayBoundary();
-        const pendingBackgroundTasks = [];
-        const backgroundTasks = {
-            register(task) {
-                const observedTask = Promise.resolve(task);
-                observedTask.catch(() => {
-                    // Re-thrown later by drainBackgroundTasks; attach now to prevent unhandled rejections.
-                });
-                pendingBackgroundTasks.push(observedTask);
-            },
-        };
-        let toolExecutionContext = this.withBackgroundTaskRegistry(this.buildToolExecutionContext(options), backgroundTasks);
-        if (toolExecutionContext) {
-            toolExecutionContext = {
-                ...toolExecutionContext,
-                procedureStimulus: ownerJournalPrompt,
-                procedureRefs: options?.procedureRefs,
-            };
-        }
-        // Track this run's tier for code-act execution and prompt sizing.
-        if (options?.agentContext) {
-            const rawTier = options.agentContext.tier ?? 1;
-            runScope.tier = this.useCodeAct
-                ? (0, index_js_1.requireCodeActTier)(rawTier)
-                : rawTier === 1 || rawTier === 2 || rawTier === 3
-                    ? rawTier
-                    : 1;
-        }
-        // Infinite loop prevention
-        let consecutiveToolCalls = 0;
-        let lastToolName = '';
-        const MAX_CONSECUTIVE_SAME_TOOL = MAX_CONSECUTIVE_SAME_HOST_TOOL;
-        const EMERGENCY_MAX_TURNS = this.emergencyMaxCalls(); // Always above maxTurns
-        // Track channel key for session release
-        const channelKey = options?.sessionKey ??
-            (0, session_pool_js_1.buildChannelKey)(options?.source ?? 'default', (0, principal_js_1.laneChannelId)(options?.channelId ?? this.sessionKey, 'owner'));
-        // The context object THIS run created, compared by identity before the finally marks
-        // it finished: a later run on the same session key replaces the map entry.
-        let ownedSubagentRunContext;
-        // Use session pool for conversation continuity
-        // IMPORTANT: If caller passes cliSessionId, use it directly to avoid double-locking
-        // MessageRouter already calls getSession() and passes the result via options
-        let sessionIsNew = options?.resumeSession === undefined ? true : !options.resumeSession;
-        let ownedSession = false;
-        // Set session ID on the agent
-        // Claude PersistentCLI: process alive → CONTINUE (stdin message), process dead → NEW (spawn with --session-id)
-        // Codex/Cline: durable runtime session alive → CONTINUE, missing → NEW.
-        const isCodex = this.backend === 'codex';
-        const isCline = this.backend === 'cline';
-        const isDurableRuntime = isCodex || isCline;
-        const tracksSessionPolicy = isDurableRuntime || this.backend === 'claude';
-        const clineRole = options?.agentContext?.role;
-        // The main persona's gateway Bash/Write run through MAMA's executor; Cline's native
-        // shell/editor would bypass it, so they stay disallowed whatever the role grants.
-        const clineAllowedTools = this.clineNativePolicyConfigured
-            ? this.clineNativeAllowedTools
-            : (0, cline_native_tool_policy_js_1.projectClineNativeTools)(clineRole?.allowedTools).filter((tool) => !cline_native_tool_policy_js_1.CLINE_NATIVE_GUARD_BYPASS.includes(tool));
-        const clineDisallowedTools = this.clineNativePolicyConfigured
-            ? this.clineNativeDisallowedTools
-            : [
-                ...new Set([
-                    ...(0, cline_native_tool_policy_js_1.projectClineNativeTools)(clineRole?.blockedTools),
-                    ...cline_native_tool_policy_js_1.CLINE_NATIVE_GUARD_BYPASS,
-                ]),
-            ];
-        const clineDelegationGranted = clineRole?.allowedTools.some((pattern) => pattern === '*' || pattern === 'native_subagent') ??
-            false;
-        const clineDelegationBlocked = clineRole?.blockedTools?.some((pattern) => pattern === '*' || pattern === 'native_subagent') ?? false;
-        const clineAllowSpawnAgent = this.clineAllowSpawnAgent && clineDelegationGranted && !clineDelegationBlocked;
-        const clineAllowAgentTeams = this.clineAllowAgentTeams && clineDelegationGranted && !clineDelegationBlocked;
-        const ownerRuntime = channelKey === owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY;
-        const sessionPolicyRole = ownerRuntime
-            ? (options?.sessionPolicyRole ?? options?.agentContext?.role)
-            : options?.agentContext?.role;
-        const codeActPolicy = this.useCodeAct
-            ? (0, index_js_1.projectCodeActToolPolicy)({
-                tier: ownerRuntime ? 1 : runScope.tier,
-                roleName: ownerRuntime ? 'owner_console' : options?.agentContext?.roleName,
-                role: sessionPolicyRole,
-                disallowedTools: this.disallowedTools,
-                ...(ownerRuntime
-                    ? {}
-                    : {
-                        envelopeDestinationKinds: options?.envelope?.scope.allowed_destinations.map((destination) => destination.kind) ?? [],
-                        envelopeRawConnectors: options?.envelope?.scope.raw_connectors ?? [],
-                    }),
-            })
-            : undefined;
-        const outerCodeActAllowed = this.useCodeAct && roleAllowsOuterCodeAct(options?.agentContext?.role, this.disallowedTools);
-        const ownerPolicyFingerprint = ownerRuntime
-            ? ownerRuntimeSessionPolicyFingerprint(sessionPolicyRole, options?.model ?? this.model, this.supportsNativeSubagents, this.backend)
-            : undefined;
-        const effectiveSessionPolicyFingerprint = isDurableRuntime && codeActPolicy
-            ? combineCodeActSessionPolicyFingerprint(ownerPolicyFingerprint ?? options?.sessionPolicyFingerprint, codeActPolicy)
-            : (ownerPolicyFingerprint ?? options?.sessionPolicyFingerprint);
-        let resolvedCliSessionId = options?.cliSessionId ?? null;
-        const sessionLabel = (isNew) => {
-            if (isDurableRuntime) {
-                return isNew ? 'NEW thread' : 'CONTINUE thread';
-            }
-            return isNew ? 'NEW process' : 'CONTINUE session';
-        };
-        if (options?.cliSessionId) {
-            // Session routing travels per prompt() call via resolvedCliSessionId - no
-            // shared-adapter mutation (setSessionId re-pointed channelKey/currentProcess
-            // across awaits, cross-wiring concurrent lanes).
-            console.log(`[AgentLoop] [${this.backend}] ${channelKey} (${sessionLabel(sessionIsNew)})`);
-        }
-        else if (options?.freshSession) {
-            // Stateless lanes (operator reports): session context is a cache, not
-            // persistence - every run self-gathers and recalls; carrying prior runs'
-            // gather dumps only grows the context until runs outlive their envelope
-            // (measured 146s -> 521s over 3 days; owner decision 2026-07-16).
-            const cliSessionId = this.sessionPool.resetSession(channelKey);
-            sessionIsNew = true;
-            ownedSession = true;
-            resolvedCliSessionId = cliSessionId;
-            console.log(`[AgentLoop] [${this.backend}] ${channelKey} (FRESH session - stateless lane)`);
-        }
-        else {
-            // Fallback: get session from pool (for direct AgentLoop usage)
-            // getSession() returns immediately - if busy, we create a new session
-            const { sessionId: cliSessionId, isNew, busy } = this.sessionPool.getSession(channelKey);
-            if (busy) {
-                console.log(`[AgentLoop] Session busy for ${channelKey}, will be queued by Lane`);
-            }
-            sessionIsNew = isNew;
-            ownedSession = true;
-            resolvedCliSessionId = cliSessionId;
-            // Per-call routing via resolvedCliSessionId - no shared-adapter mutation.
-            console.log(`[AgentLoop] [${this.backend}] ${channelKey} (${sessionLabel(isNew)})`);
-        }
-        try {
-            if (this.shouldBeginModelRun(options)) {
-                const modelRun = await this.mcpExecutor.beginRuntimeModelRun(this.buildModelRunInput(options, resolvedCliSessionId));
-                ownedModelRunId = modelRun.model_run_id;
-                toolExecutionContext = this.withBackgroundTaskRegistry(this.buildToolExecutionContext({
-                    ...options,
-                    modelRunId: ownedModelRunId,
-                }), backgroundTasks);
-                if (toolExecutionContext) {
-                    toolExecutionContext = {
-                        ...toolExecutionContext,
-                        procedureStimulus: ownerJournalPrompt,
-                        procedureRefs: options?.procedureRefs,
-                    };
-                }
-            }
-            nativeEffects = new native_effect_observer_js_1.NativeEffectReplayBoundary(this.createNativeEffectObserver?.(toolExecutionContext));
-            // This run's bridge is ITS OWN: the loop guards, the emergency budget, the history
-            // writes and the turn observers all belong to this run. A Codex-native child gets a
-            // separate bridge from `createSubagentBridge` - sharing this closure let a child trip
-            // the parent's loop guard and append its traces to the parent's committed model run.
-            const hostToolDefinitions = this.hostToolDefinitionsFor(options, outerCodeActAllowed);
-            const hostToolBridge = isDurableRuntime && this.isGatewayMode
-                ? this.buildHostToolBridge({
-                    tools: hostToolDefinitions,
-                    runScope,
-                    executionContext: () => toolExecutionContext,
-                    stopAfterSuccessfulTools: options?.stopAfterSuccessfulTools ?? [],
-                    emergencyMaxCalls: EMERGENCY_MAX_TURNS,
-                    maxConsecutiveSameTool: MAX_CONSECUTIVE_SAME_TOOL,
-                    // Codex does not return completed host exchanges, so record them here. Cline
-                    // reports the paired custom-tool exchange from its Hub event stream and
-                    // AgentLoop appends it exactly once below.
-                    ...(isCodex
-                        ? {
-                            recordExchange: {
-                                assistant: (toolUse) => {
-                                    history.push({ role: 'assistant', content: [toolUse] });
-                                    runScope.onTurn?.({
-                                        turn,
-                                        role: 'assistant',
-                                        content: [toolUse],
-                                        stopReason: 'tool_use',
-                                    });
-                                },
-                                result: (toolResult) => {
-                                    const persistedToolResult = historyToolResult(toolResult);
-                                    history.push({ role: 'user', content: [persistedToolResult] });
-                                    runScope.onTurn?.({
-                                        turn,
-                                        role: 'user',
-                                        content: [persistedToolResult],
-                                    });
-                                },
-                            },
-                        }
-                        : {}),
-                })
-                : undefined;
-            if (hostToolBridge && isCodex) {
-                // A child can be announced during this run and outlive it, so what its authority
-                // needs is recorded now, per session key, and dropped when nothing needs it.
-                // A previous run's context object stays referenced by ITS still-live children, so
-                // this run starts its own count rather than inheriting one it can never settle.
-                // The child NEVER inherits this turn's role verbatim: an owner 1:1 chat turn holds
-                // the gateway shell and file writer, and a child is unattended by definition.
-                const childOptions = withUnattendedSubagentRole(options);
-                ownedSubagentRunContext = {
-                    options: childOptions,
-                    parentModelRunId: ownedModelRunId ?? options?.modelRunId ?? null,
-                    cliSessionId: resolvedCliSessionId,
-                    tools: this.hostToolDefinitionsFor(childOptions),
-                    tier: runScope.tier,
-                    activeChildren: 0,
-                    runFinished: false,
-                };
-                this.subagentRunContexts.set(channelKey, ownedSubagentRunContext);
-            }
-            const prepareSystemPrompt = (requestedSystemPrompt, isResumingSession, includeOwnerRecovery = false) => {
-                let baseSystemPrompt = requestedSystemPrompt ?? this.defaultSystemPrompt;
-                if (ownerRuntime &&
-                    this.supportsNativeSubagents &&
-                    !baseSystemPrompt.includes(owner_runtime_js_1.OWNER_SUBAGENT_INSTRUCTIONS)) {
-                    // Per-runner: the shared rule plus that runtime's own spawn mechanics.
-                    // On a runner with no native subagent (persistent Claude persona, Cline) the
-                    // delegation policy asks for something the runtime cannot do. It is omitted, and
-                    // nothing replaces it: the turn's own result contract already says what must exist.
-                    baseSystemPrompt = `${baseSystemPrompt}\n\n${(0, owner_runtime_js_1.ownerSubagentInstructions)(this.backend)}`;
-                }
-                if (ownerRuntime && !baseSystemPrompt.includes(telegram_format_js_1.TELEGRAM_FORMAT_GUIDE)) {
-                    baseSystemPrompt = `${baseSystemPrompt}\n\n${telegram_format_js_1.TELEGRAM_FORMAT_GUIDE}`;
-                }
-                if (ownerRuntime && !baseSystemPrompt.includes(owner_runtime_js_1.OWNER_RUNTIME_RULES)) {
-                    baseSystemPrompt = `${baseSystemPrompt}\n\n${owner_runtime_js_1.OWNER_RUNTIME_RULES}`;
-                }
-                let gatewayToolsPrompt = '';
-                if (this.isGatewayMode && this.useCodeAct) {
-                    baseSystemPrompt = stripTrailingCanonicalCodeActSection(stripGenericGatewayToolsCatalog(baseSystemPrompt));
-                    if (outerCodeActAllowed) {
-                        const policy = codeActPolicy;
-                        gatewayToolsPrompt = wrapGeneratedPromptSection('codeAct', (0, index_js_1.getCodeActInstructions)(this.backend, policy.names));
-                    }
-                }
-                else if (this.isGatewayMode && !isCodex) {
-                    baseSystemPrompt = stripDisabledCodeActGuidance(baseSystemPrompt);
-                    if (!isResumingSession) {
-                        if (options?.gatewayToolsPrompt !== undefined) {
-                            // A short-lived caller may carry a more specific final policy than
-                            // the process-wide default. Replace the host-generated constructor
-                            // catalog with that exact policy-keyed catalog for this run.
-                            baseSystemPrompt = stripGenericGatewayToolsCatalog(baseSystemPrompt);
-                            if (options.gatewayToolsPrompt) {
-                                gatewayToolsPrompt = wrapGeneratedPromptSection('gatewayTools', options.gatewayToolsPrompt);
-                            }
-                        }
-                        else {
-                            // Non-CodeAct callers may already embed the generic gateway catalog.
-                            const alreadyHasTools = baseSystemPrompt.includes('# Gateway Tools') ||
-                                baseSystemPrompt.includes('# Code Execution') ||
-                                baseSystemPrompt.includes('## Code-Act');
-                            if (!alreadyHasTools) {
-                                gatewayToolsPrompt = wrapGeneratedPromptSection('gatewayTools', getRunGatewayToolsPrompt(options?.agentContext, this.disallowedTools));
-                            }
-                        }
-                    }
-                }
-                const ownerRecovery = includeOwnerRecovery && ownerRuntime && this.ownerRuntimeJournal
-                    ? this.ownerRuntimeJournal.recoveryBlock()
-                    : '';
-                const joinLayers = (base, tools, recovery) => [base, tools, recovery].filter(Boolean).join('\n\n---\n\n');
-                const fullPrompt = joinLayers(baseSystemPrompt, gatewayToolsPrompt, ownerRecovery);
-                // Monitor and enforce prompt size
-                const monitor = new prompt_size_monitor_js_1.PromptSizeMonitor();
-                const runLayers = [
-                    { name: 'systemPrompt', content: baseSystemPrompt, priority: 1 },
-                    ...(gatewayToolsPrompt
-                        ? [
-                            {
-                                name: 'gatewayTools',
-                                content: gatewayToolsPrompt,
-                                priority: gatewayToolsPrompt.startsWith(GENERATED_CODE_ACT_START) ? 1 : 2,
-                                protectedPrefix: gatewayToolsPrompt.startsWith(GENERATED_CODE_ACT_START)
-                                    ? GENERATED_CODE_ACT_START
-                                    : GENERATED_GATEWAY_TOOLS_START,
-                                protectedSuffix: gatewayToolsPrompt.startsWith(GENERATED_CODE_ACT_START)
-                                    ? GENERATED_CODE_ACT_END
-                                    : GENERATED_GATEWAY_TOOLS_END,
-                            },
-                        ]
-                        : []),
-                    ...(ownerRecovery
-                        ? [{ name: 'ownerRecovery', content: ownerRecovery, priority: 3 }]
-                        : []),
-                ];
-                const checkResult = monitor.check(runLayers);
-                if (checkResult.warning) {
-                    console.warn(`[AgentLoop] ${checkResult.warning}`);
-                }
-                let effectivePrompt = fullPrompt;
-                if (!checkResult.withinBudget) {
-                    const { layers: trimmed, result: enforceResult } = monitor.enforce(runLayers);
-                    const truncatedLayers = enforceResult.truncatedLayers;
-                    if (truncatedLayers.length > 0) {
-                        console.warn(`[AgentLoop] Truncated layers: ${truncatedLayers.join(', ')}`);
-                    }
-                    const tBase = trimmed.find((l) => l.name === 'systemPrompt')?.content || baseSystemPrompt;
-                    const tTools = trimmed.find((l) => l.name === 'gatewayTools')?.content || '';
-                    const tRecovery = trimmed.find((l) => l.name === 'ownerRecovery')?.content || '';
-                    effectivePrompt = joinLayers(tBase, tTools, tRecovery);
-                    logger.debug(`[AgentLoop] System prompt truncated: ${fullPrompt.length} → ${effectivePrompt.length} chars`);
-                }
-                logger.debug(`[AgentLoop] Prepared systemPrompt for this call: ${effectivePrompt.length} chars ` +
-                    `(base: ${baseSystemPrompt.length}, tools: ${gatewayToolsPrompt.length}, recovery: ${ownerRecovery.length})`);
-                return effectivePrompt;
-            };
-            let perCallSystemPrompt;
-            if (isCline && this.isGatewayMode && this.useCodeAct && !sessionIsNew) {
-                // TG-05: a compatible Cline Hub session ignores the per-call system prompt.
-                // Keep the continuation stub cheap; missing/mismatched sessions rebuild the
-                // complete policy lazily through freshSessionSystemPrompt below.
-                perCallSystemPrompt = options?.systemPrompt ?? this.defaultSystemPrompt;
-            }
-            else if (ownerRuntime ||
-                options?.systemPrompt ||
-                options?.gatewayToolsPrompt !== undefined ||
-                (this.isGatewayMode && this.useCodeAct)) {
-                perCallSystemPrompt = prepareSystemPrompt(options?.systemPrompt, options?.resumeSession === true, false);
-            }
-            else {
-                perCallSystemPrompt = this.defaultSystemPrompt;
-                console.log(`[AgentLoop] No systemPrompt in options - using spawn default for this call`);
-            }
-            // Durable backends re-anchor a lost session with the complete current policy.
-            // A CONTINUE
-            // turn's per-call prompt is deliberately minimal (message-router
-            // buildMinimalResumePrompt), so resuming with it would REPLACE the thread's full
-            // policy with a stub - only freshSessionSystemPrompt rebuilds the complete one.
-            // That rebuild costs an embedding search, so hand the backend a lazy builder it
-            // invokes only inside the resume branch; a live thread never pays for it.
-            const freshSystemPromptBuilder = options?.freshSessionSystemPrompt;
-            // The owner-event and scheduled lanes carry no per-call systemPrompt at all: their
-            // perCallSystemPrompt IS the complete composed owner policy (the ownerRuntime branch
-            // above). Without a resume builder those lanes fell back to the turn-text
-            // <system-reminder> replay - the same full prompt, but billed as USER text on the
-            // first turn after every daemon restart. Re-anchor it through baseInstructions
-            // instead; the reminder is then never needed.
-            const resumeInstructions = !isDurableRuntime
-                ? undefined
-                : freshSystemPromptBuilder
-                    ? async () => prepareSystemPrompt(await freshSystemPromptBuilder(), false, false)
-                    : ownerRuntime
-                        ? async () => perCallSystemPrompt
-                        : undefined;
-            // Reset StopContinuation state for this channel to prevent leaking
-            // retry counts from previous invocations
-            if (this.stopContinuationHandler) {
-                this.stopContinuationHandler.resetChannel(channelKey);
-            }
-            // Add initial user message with content blocks
-            history.push({
-                role: 'user',
-                content,
-            });
-            while (turn < this.maxTurns) {
-                turn++;
-                // A run whose envelope is (about to be) expired cannot commit ANY write -
-                // every gateway call from here on is denied '[expired]' (enforcer.ts:73).
-                if (options?.envelope && (0, run_guard_js_1.envelopeExpired)(options.envelope, Date.now(), 30_000)) {
-                    const envId = String(options.envelope.instance_id ?? 'unknown');
-                    if (options?.source === 'operator') {
-                        // Non-interactive lane: abort loudly now instead of burning doomed turns.
-                        // The trigger loop keeps its digest buffer and retries next cadence.
-                        throw new types_js_1.AgentError(`Envelope ${envId} expired mid-run at turn ${turn}; aborting doomed run`, 'ENVELOPE_EXPIRED', undefined, false);
-                    }
-                    // Interactive lanes (chat): never abort a live conversation - deliver the
-                    // text; individual writes will be denied loudly by the enforcer as today.
-                    console.error(`[AgentLoop] envelope ${envId} expired mid-run (turn ${turn}, source ${options?.source ?? 'unknown'}); ` +
-                        `subsequent gateway writes will be denied`);
-                }
-                // Emergency brake: prevent infinite loops
-                if (turn >= EMERGENCY_MAX_TURNS) {
-                    throw new types_js_1.AgentError(`Emergency stop: Agent loop exceeded emergency maximum turns (${EMERGENCY_MAX_TURNS})`, 'EMERGENCY_MAX_TURNS', undefined, false);
-                }
-                let response;
-                const ext = runScope.streamCallbacks;
-                let attemptReportedError;
-                const callbacks = {
-                    onDelta: (text) => {
-                        ext?.onDelta?.(text);
-                    },
-                    onToolUse: (name, input) => {
-                        nativeEffects.started(name, input);
-                        ext?.onToolUse?.(name, input);
-                    },
-                    onToolComplete: (name, toolUseId, isError) => {
-                        nativeEffects.settled(name, toolUseId, isError);
-                        ext?.onToolComplete?.(name, toolUseId, isError);
-                    },
-                    // A spawn is an admission, not an external effect: forwarded verbatim with NO
-                    // nativeEffects call, so it never writes a `native_tool` ledger row and never
-                    // makes the occurrence unsafe to replay.
-                    onSubagentStart: (info) => {
-                        ext?.onSubagentStart?.(info);
-                    },
-                    onFinal: (finalResponse) => {
-                        ext?.onFinal?.(finalResponse);
-                    },
-                    onError: (error) => {
-                        // A model runner can emit onError before rejecting. Hold it until
-                        // AgentLoop knows whether the attempt is terminal so a successful
-                        // one-time session recovery does not leak a false failure event.
-                        attemptReportedError = error;
-                    },
-                };
-                let piResult;
-                // Claude: First turn → --session-id (inject system prompt), subsequent → --resume
-                // Codex/Cline: resumeSession controls durable session reset/continuation.
-                let shouldResume = isDurableRuntime
-                    ? turn > 1 || (options?.freshSession === true ? false : (options?.resumeSession ?? true))
-                    : !sessionIsNew || turn > 1 || (ownerRuntime && options?.resumeSession === true);
-                let requestSystemPrompt = perCallSystemPrompt;
-                let provisionalDurableSessionId;
-                // All three backends preserve context and receive only the new user message.
-                const basePromptText = this.formatLastMessageOnly(history);
-                let promptText = basePromptText;
-                const promptStart = Date.now();
-                const throwFinalCliError = (error) => {
-                    const normalizedError = error instanceof Error ? error : new Error(String(error));
-                    const modelRunnerErrorCode = normalizedError instanceof model_runner_js_1.ModelRunnerError
-                        ? MODEL_RUNNER_AGENT_ERROR_CODES[normalizedError.code]
-                        : undefined;
-                    const errorType = normalizedError instanceof types_js_1.McpResultMissingError ||
-                        normalizedError instanceof types_js_1.McpCompletedMutationInterruptedError ||
-                        normalizedError instanceof types_js_1.ClaudeToolStreamProtocolError
-                        ? normalizedError.code
-                        : normalizedError instanceof model_runner_js_1.HostToolTerminalError
-                            ? normalizedError.terminalCode
-                            : (modelRunnerErrorCode ?? 'CLI_ERROR');
-                    this.onMetric?.('prompt_error', 1, {
-                        backend: this.backend,
-                        error_type: errorType,
-                    });
-                    try {
-                        ext?.onError?.(attemptReportedError ?? normalizedError);
-                    }
-                    catch (callbackError) {
-                        logger.warn(`External onError callback failed: ${callbackError instanceof Error ? callbackError.message : String(callbackError)}`);
-                    }
-                    if (normalizedError instanceof model_runner_js_1.HostToolTerminalError) {
-                        throw new types_js_1.AgentError(normalizedError.message, normalizedError.terminalCode, normalizedError, false);
-                    }
-                    if (normalizedError instanceof model_runner_js_1.HostToolAbortError) {
-                        throw new types_js_1.AgentError(normalizedError.message, 'CLI_ERROR', normalizedError, false);
-                    }
-                    if (normalizedError instanceof types_js_1.McpResultMissingError ||
-                        normalizedError instanceof types_js_1.McpCompletedMutationInterruptedError ||
-                        normalizedError instanceof types_js_1.ClaudeToolStreamProtocolError) {
-                        throw new types_js_1.AgentError(normalizedError.message, normalizedError.code, normalizedError, false);
-                    }
-                    throw new types_js_1.AgentError(`CLI error: ${normalizedError.message}`, modelRunnerErrorCode ?? 'CLI_ERROR', normalizedError, normalizedError instanceof model_runner_js_1.ModelRunnerError ? normalizedError.retryable : true);
-                };
-                const appendCompletedToolExchanges = (exchanges) => {
-                    for (const exchange of exchanges) {
-                        history.push({ role: 'assistant', content: [exchange.toolUse] });
-                        runScope.onTurn?.({
-                            turn,
-                            role: 'assistant',
-                            content: [exchange.toolUse],
-                            stopReason: 'tool_use',
-                        });
-                        history.push({ role: 'user', content: [exchange.toolResult] });
-                        runScope.onTurn?.({
-                            turn,
-                            role: 'user',
-                            content: [exchange.toolResult],
-                        });
-                    }
-                };
-                try {
-                    const durablePolicyStatus = tracksSessionPolicy && turn === 1 && (shouldResume || ownerRuntime)
-                        ? this.agent.getSessionPolicyStatus?.({
-                            model: options?.model,
-                            resumeSession: true,
-                            systemPrompt: requestSystemPrompt,
-                            sessionKey: channelKey,
-                            sessionPolicyFingerprint: effectiveSessionPolicyFingerprint,
-                            sessionId: resolvedCliSessionId ?? undefined,
-                            requestTimeout: options?.requestTimeoutMs,
-                            // Enforced INSIDE the codex turn (usage events), see CodexAppServerProcess.
-                            runTokenBudget: this.runTokenBudget,
-                            hostToolBridge,
-                            ...(isCline
-                                ? {
-                                    allowedTools: clineAllowedTools,
-                                    disallowedTools: clineDisallowedTools,
-                                    allowSpawnAgent: clineAllowSpawnAgent,
-                                    allowAgentTeams: clineAllowAgentTeams,
-                                }
-                                : {}),
-                        })
-                        : undefined;
-                    if (durablePolicyStatus === 'mismatch' || durablePolicyStatus === 'missing') {
-                        console.log(`[AgentLoop] ${this.backend} durable session ${durablePolicyStatus}; ` +
-                            'opening the full policy before model request');
-                        if (this.backend === 'claude' && durablePolicyStatus === 'mismatch') {
-                            if (!this.agent.resetSession) {
-                                throw new Error('Claude model runner cannot retire a stale policy session');
-                            }
-                            await this.agent.resetSession(resolvedCliSessionId ?? undefined);
-                        }
-                        const newSessionId = this.sessionPool.resetSession(channelKey);
-                        options?.onCliSessionReset?.(newSessionId);
-                        resolvedCliSessionId = newSessionId;
-                        provisionalDurableSessionId = newSessionId;
-                        try {
-                            if (options?.freshSessionSystemPrompt) {
-                                requestSystemPrompt = prepareSystemPrompt(await options.freshSessionSystemPrompt(), false, true);
-                            }
-                            else if (ownerRuntime) {
-                                // Background stimuli use the standing base policy. Recover their journal only
-                                // after the backend proves replacement is required, never from host pool state.
-                                requestSystemPrompt = prepareSystemPrompt(options?.systemPrompt, false, true);
-                            }
-                        }
-                        catch (rebuildError) {
-                            this.sessionPool.invalidateSession(channelKey, newSessionId);
-                            provisionalDurableSessionId = undefined;
-                            attemptReportedError =
-                                rebuildError instanceof Error ? rebuildError : new Error(String(rebuildError));
-                            throw rebuildError;
-                        }
-                        shouldResume = false;
-                    }
-                    promptText = this.withProcedureHints(basePromptText, turn, {
-                        threadId: resolvedCliSessionId ?? channelKey,
-                        // A NEW pool session has no prior thread to carry procedures forward from, even
-                        // when the durable runtime is asked to resume: fresh is about the thread.
-                        fresh: !shouldResume || sessionIsNew,
-                        context: toolExecutionContext,
-                    });
-                    piResult = await this.agent.prompt(promptText, callbacks, {
-                        model: options?.model,
-                        resumeSession: shouldResume,
-                        systemPrompt: requestSystemPrompt,
-                        resumeInstructions,
-                        promptTelemetry: {
-                            kind: options?.promptKind ?? (options?.source === 'operator' ? 'scheduled' : 'chat'),
-                            brief: options?.promptBrief ?? 'omitted',
-                        },
-                        sessionKey: channelKey,
-                        sessionPolicyFingerprint: effectiveSessionPolicyFingerprint,
-                        sessionId: resolvedCliSessionId ?? undefined,
-                        // Per-run request timeout (operator worker runs); undefined leaves
-                        // the pool's construction-time default untouched (chat).
-                        requestTimeout: options?.requestTimeoutMs,
-                        runTokenBudget: this.runTokenBudget,
-                        hostToolBridge,
-                        toolExecutionContext,
-                        ...(isCline
-                            ? {
-                                allowedTools: clineAllowedTools,
-                                disallowedTools: clineDisallowedTools,
-                                allowSpawnAgent: clineAllowSpawnAgent,
-                                allowAgentTeams: clineAllowAgentTeams,
-                            }
-                            : {}),
-                    });
-                    provisionalDurableSessionId = undefined;
-                }
-                catch (error) {
-                    if (provisionalDurableSessionId) {
-                        this.sessionPool.invalidateSession(channelKey, provisionalDurableSessionId);
-                        provisionalDurableSessionId = undefined;
-                    }
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    console.error(`[AgentLoop] ${this.backend} CLI error:`, errorMessage);
-                    // A codex turn interrupted by the run budget is a host decision, not a failure:
-                    // stop here with what was collected and let the host record the receipt.
-                    if (error?.code === 'RUN_BUDGET_STOP' ||
-                        errorMessage.startsWith('run budget stop:')) {
-                        stoppedBy = 'budget';
-                        const stoppedUsage = error.usage;
-                        if (stoppedUsage) {
-                            totalUsage.input_tokens += stoppedUsage.input_tokens;
-                            totalUsage.output_tokens += stoppedUsage.output_tokens;
-                            budgetTokens += this.countBudgetTokens(stoppedUsage);
-                            try {
-                                this.onTokenUsage?.({
-                                    channel_key: channelKey,
-                                    agent_id: options?.agentContext?.roleName || this.model,
-                                    input_tokens: stoppedUsage.input_tokens,
-                                    output_tokens: stoppedUsage.output_tokens,
-                                    cache_read_tokens: stoppedUsage.cache_read_input_tokens || 0,
-                                    cost_usd: 0,
-                                });
-                            }
-                            catch {
-                                // Recording failures must never mask the stop itself.
-                            }
-                        }
-                        budgetTokens = Math.max(budgetTokens, this.runTokenBudget);
-                        try {
-                            this.onBudgetStop?.({
-                                channelKey,
-                                modelRunId: ownedModelRunId ?? options?.modelRunId ?? null,
-                                agentId: options?.agentContext?.roleName,
-                                budgetTokens,
-                                runTokenBudget: this.runTokenBudget,
-                                turns: turn,
-                            });
-                        }
-                        catch {
-                            // Receipt failures must never mask the stop itself.
-                        }
-                        break;
-                    }
-                    if (error instanceof types_js_1.McpCompletedMutationInterruptedError) {
-                        appendCompletedToolExchanges(error.completedToolExchanges);
-                        throwFinalCliError(error);
-                    }
-                    if (error instanceof model_runner_js_1.HostToolTerminalError && error.completedToolExchanges?.length) {
-                        appendCompletedToolExchanges(error.completedToolExchanges);
-                        throwFinalCliError(error);
-                    }
-                    if (error instanceof model_runner_js_1.HostToolAbortError && error.completedToolExchanges.length > 0) {
-                        appendCompletedToolExchanges(error.completedToolExchanges);
-                        throwFinalCliError(error);
-                    }
-                    // Check if this is a recoverable session error
-                    // 1. "No conversation found" - CLI session was lost (daemon restart, timeout)
-                    // 2. "Session ID already in use" - concurrent request conflict
-                    // 3. "Prompt is too long" - session context exceeded API limits
-                    const isSessionNotFound = errorMessage.includes('No conversation found with session ID');
-                    const isSessionInUse = errorMessage.includes('is already in use');
-                    const isPromptTooLong = (error instanceof model_runner_js_1.ModelRunnerError && error.code === 'context_overflow') ||
-                        errorMessage.includes('Prompt is too long') ||
-                        errorMessage.includes('prompt is too long') ||
-                        errorMessage.includes('request_too_large') ||
-                        errorMessage.includes('context window') ||
-                        errorMessage.includes('context_length_exceeded');
-                    const isCodexPolicyMismatch = errorMessage.includes('Codex app-server thread policy mismatch; reset the session explicitly');
-                    // 4. API 400 on a resumed session whose stored transcript carries an
-                    //    empty content block (live incident 2026-07-27: sonnet emitted an
-                    //    empty thinking block, the CLI persisted it, and every subsequent
-                    //    replay of that session died with this 400). The transcript is
-                    //    unrecoverable - only a fresh session heals it.
-                    const isCorruptTranscript = errorMessage.includes('text content blocks must be non-empty');
-                    const canRecoverSession = (isCodex && isCodexPolicyMismatch) ||
-                        (!isCodex &&
-                            (isSessionNotFound || isSessionInUse || isPromptTooLong || isCorruptTranscript));
-                    const nativeFailure = nativeEffects.failure(error, canRecoverSession);
-                    if (nativeFailure !== error) {
-                        throw nativeFailure;
-                    }
-                    if (canRecoverSession) {
-                        const reason = isCodexPolicyMismatch
-                            ? 'policy mismatch'
-                            : isSessionNotFound
-                                ? 'not found in CLI'
-                                : isSessionInUse
-                                    ? 'already in use'
-                                    : isCorruptTranscript
-                                        ? 'transcript corrupt (empty content block)'
-                                        : 'prompt too long (context overflow)';
-                        console.log(`[AgentLoop] Session ${reason}, retrying with new session`);
-                        // Reset session in pool so it creates a new one
-                        const newSessionId = this.sessionPool.resetSession(channelKey);
-                        options?.onCliSessionReset?.(newSessionId);
-                        // Per-call routing: hand the new id to this prompt() and update the
-                        // resolved id so later turns follow it - no shared-adapter mutation.
-                        resolvedCliSessionId = newSessionId;
-                        // A recoverable durable-session error can occur on a resumed
-                        // MessageRouter session whose per-call prompt is intentionally minimal.
-                        // Rebuild the full policy before opening every replacement session.
-                        let resetSystemPrompt = perCallSystemPrompt;
-                        try {
-                            // Discard the recoverable first-attempt error before any reset
-                            // preparation. A prompt rebuild or retry failure must surface
-                            // its own final error, never the mismatch that triggered it.
-                            attemptReportedError = undefined;
-                            if (options?.freshSessionSystemPrompt) {
-                                resetSystemPrompt = prepareSystemPrompt(await options.freshSessionSystemPrompt(), false, true);
-                            }
-                            else if (ownerRuntime) {
-                                resetSystemPrompt = prepareSystemPrompt(options?.systemPrompt, false, true);
-                            }
-                            promptText = this.withProcedureHints(basePromptText, turn, {
-                                threadId: newSessionId,
-                                fresh: true,
-                                context: toolExecutionContext,
-                            });
-                            piResult = await this.agent.prompt(promptText, callbacks, {
-                                model: options?.model,
-                                resumeSession: false, // Force new session
-                                systemPrompt: resetSystemPrompt,
-                                sessionKey: channelKey,
-                                sessionPolicyFingerprint: effectiveSessionPolicyFingerprint,
-                                sessionId: newSessionId,
-                                // Carry the per-run timeout onto the reset session too.
-                                requestTimeout: options?.requestTimeoutMs,
-                                runTokenBudget: this.runTokenBudget,
-                                hostToolBridge,
-                                toolExecutionContext,
-                                ...(isCline
-                                    ? {
-                                        allowedTools: clineAllowedTools,
-                                        disallowedTools: clineDisallowedTools,
-                                        allowSpawnAgent: clineAllowSpawnAgent,
-                                        allowAgentTeams: clineAllowAgentTeams,
-                                    }
-                                    : {}),
-                            });
-                        }
-                        catch (retryError) {
-                            console.error(`[AgentLoop] ${this.backend} reset retry failed:`, retryError instanceof Error ? retryError.message : String(retryError));
-                            // resetSession() creates and locks a replacement pool entry.
-                            // A failed rebuild/retry must remove it entirely; otherwise the
-                            // next MessageRouter turn sees isNew=false and can persist a
-                            // minimal resume prompt as the replacement thread's base policy.
-                            this.sessionPool.invalidateSession(channelKey, newSessionId);
-                            throwFinalCliError(retryError);
-                        }
-                        // Prepend reset notice so user knows context was lost
-                        if (isPromptTooLong && piResult?.response) {
-                            piResult.response = `⚠️ Session reset: The previous conversation was too long, starting a new session.\n\n${piResult.response}`;
-                        }
-                        console.log(`[AgentLoop] Retry successful with new session: ${newSessionId}`);
-                    }
-                    else {
-                        throwFinalCliError(error);
-                    }
-                }
-                if (!piResult) {
-                    return throwFinalCliError(new Error('Model runner returned no prompt result'));
-                }
-                // Emit one terminal metric per prompt turn, including recovered calls.
-                this.onMetric?.('prompt_latency_ms', Date.now() - promptStart, {
-                    backend: this.backend,
-                    turn: String(turn),
-                });
-                // After first successful call, mark session as not new for subsequent turns
-                if (turn === 1) {
-                    sessionIsNew = false;
-                }
-                // Build content blocks - include tool_use blocks if present
-                const contentBlocks = [];
-                let parsedToolCalls = [];
-                // Parse tool_call / code_act blocks from text response (Gateway Tools mode ONLY)
-                if (this.isGatewayMode && !isDurableRuntime) {
-                    parsedToolCalls = this.parseToolCallsFromText(piResult.response || '');
-                    // Code-Act: parse ```js blocks only if enabled
-                    if (this.useCodeAct) {
-                        const codeActCalls = this.parseCodeActBlocks(piResult.response || '');
-                        if (codeActCalls.length > 0) {
-                            parsedToolCalls.push(...codeActCalls);
-                        }
-                    }
-                    const textWithoutToolCalls = this.removeToolCallBlocks(piResult.response || '');
-                    if (textWithoutToolCalls.trim()) {
-                        contentBlocks.push({ type: 'text', text: textWithoutToolCalls });
-                    }
-                    // Add parsed tool_use blocks from text (Gateway Tools - prompt-based)
-                    if (parsedToolCalls.length > 0) {
-                        for (const toolCall of parsedToolCalls) {
-                            contentBlocks.push({
-                                type: 'tool_use',
-                                id: toolCall.id,
-                                name: toolCall.name,
-                                input: toolCall.input,
-                            });
-                        }
-                        console.log(`[AgentLoop] Parsed ${parsedToolCalls.length} tool calls from text (Gateway Tools mode)`);
-                    }
-                }
-                else {
-                    // MCP mode: use response text as-is
-                    if (piResult.response?.trim()) {
-                        contentBlocks.push({ type: 'text', text: piResult.response });
-                    }
-                }
-                // Add tool_use blocks from Claude CLI if present (MCP mode)
-                if ('toolUseBlocks' in piResult && Array.isArray(piResult.toolUseBlocks)) {
-                    const toolUseBlocks = piResult.toolUseBlocks;
-                    for (const toolUse of toolUseBlocks) {
-                        contentBlocks.push({
-                            type: 'tool_use',
-                            id: toolUse.id,
-                            name: toolUse.name,
-                            input: toolUse.input,
-                        });
-                    }
-                    console.log(`[AgentLoop] Detected ${toolUseBlocks.length} tool calls from MCP`);
-                }
-                // Both parsed gateway calls and native/MCP tool blocks share executeTools.
-                const hasToolUse = contentBlocks.some((block) => block.type === 'tool_use');
-                // eslint-disable-next-line prefer-const
-                response = {
-                    id: `msg_${Date.now()}`,
-                    type: 'message',
-                    role: 'assistant',
-                    content: contentBlocks,
-                    model: this.model,
-                    stop_reason: hasToolUse ? 'tool_use' : 'end_turn',
-                    stop_sequence: null,
-                    usage: piResult.usage,
-                };
-                // Update usage
-                totalUsage.input_tokens += response.usage.input_tokens;
-                totalUsage.output_tokens += response.usage.output_tokens;
-                budgetTokens += this.countBudgetTokens(response.usage);
-                // Record token usage
-                if (this.onTokenUsage) {
-                    try {
-                        this.onTokenUsage({
-                            channel_key: channelKey,
-                            agent_id: options?.agentContext?.roleName || this.model, // Use roleName if available, else model
-                            input_tokens: response.usage.input_tokens,
-                            output_tokens: response.usage.output_tokens,
-                            cache_read_tokens: response.usage.cache_read_input_tokens || 0, // No longer needs 'as any' cast
-                            cost_usd: piResult.cost_usd || 0,
-                        });
-                    }
-                    catch {
-                        // Ignore recording errors - never break the agent loop
-                    }
-                }
-                // Preserve the SessionPool usage-status contract. Billing telemetry is
-                // recorded above; durable runtimes own model-aware compaction.
-                const tokenStatus = this.sessionPool.updateTokens(channelKey, response.usage.input_tokens, this.backend);
-                // Claude's MCP server may already have executed these tool calls while the
-                // prompt was streaming. Preserve the observed exchange in conversation
-                // order, but never put the completed tool_use back into executeTools().
-                // Replaying a completed mutation would turn a transport observation into a
-                // second host-side effect.
-                if (Array.isArray(piResult.completedToolExchanges)) {
-                    appendCompletedToolExchanges(piResult.completedToolExchanges);
-                }
-                // The local MCP server can complete a mutation and still report an
-                // indeterminate terminal outcome. Preserve the paired exchange above
-                // for auditability, then fail this turn without sending it through the
-                // ordinary host-tool loop or retrying the prompt.
-                if (piResult.terminalError) {
-                    throwFinalCliError(new model_runner_js_1.HostToolTerminalError(piResult.terminalError.code, piResult.terminalError.message));
-                }
-                // PreCompact remains available for a future authoritative occupancy
-                // signal. Runtime-owned sessions do not infer one from usage telemetry.
-                if (tokenStatus.nearThreshold && this.preCompactHandler && !runScope.preCompactInjected) {
-                    runScope.preCompactInjected = true;
-                    try {
-                        const historyText = history.map((msg) => {
-                            if (typeof msg.content === 'string')
-                                return msg.content;
-                            return msg.content
-                                .filter((b) => b.type === 'text')
-                                .map((b) => b.text)
-                                .join('\n');
-                        });
-                        const compactResult = await this.preCompactHandler.process(historyText, withExecutionSurface(toolExecutionContext, 'reactive_internal'));
-                        if (compactResult.compactionPrompt) {
-                            history.push({
-                                role: 'user',
-                                content: [{ type: 'text', text: compactResult.compactionPrompt }],
-                            });
-                            console.log(`[AgentLoop] PreCompact: injected compaction summary (${compactResult.unsavedDecisions.length} unsaved decisions detected)`);
-                        }
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        console.error(`[AgentLoop] PreCompact error (non-blocking):`, message);
-                    }
-                }
-                // Add assistant response to history
-                history.push({
-                    role: 'assistant',
-                    content: response.content,
-                });
-                // Notify turn callback
-                runScope.onTurn?.({
-                    turn,
-                    role: 'assistant',
-                    content: response.content,
-                    stopReason: response.stop_reason,
-                    usage: response.usage,
-                });
-                stopReason = response.stop_reason;
-                // Per-run budget: checked after this turn's usage and before the next dispatch, so
-                // the budget is never exceeded by more than one turn. The partial response so far is
-                // returned, and the host records the receipt.
-                if (this.runTokenBudget > 0 && budgetTokens >= this.runTokenBudget) {
-                    stoppedBy = 'budget';
-                    console.warn(`[AgentLoop] run budget stop: ${budgetTokens} >= ${this.runTokenBudget} tokens after turn ${turn} (${channelKey})`);
-                    try {
-                        this.onBudgetStop?.({
-                            channelKey,
-                            modelRunId: ownedModelRunId ?? options?.modelRunId ?? null,
-                            agentId: options?.agentContext?.roleName,
-                            budgetTokens,
-                            runTokenBudget: this.runTokenBudget,
-                            turns: turn,
-                        });
-                    }
-                    catch {
-                        // Receipt failures must never mask the stop itself.
-                    }
-                    break;
-                }
-                // Check stop conditions
-                if (response.stop_reason === 'end_turn') {
-                    // StopContinuation: check if response looks incomplete before breaking
-                    if (this.stopContinuationHandler) {
-                        const finalText = this.extractTextFromContent(response.content);
-                        const decision = this.stopContinuationHandler.analyzeResponse(channelKey, finalText);
-                        if (decision.shouldContinue && decision.continuationPrompt) {
-                            console.log(`[AgentLoop] StopContinuation: auto-continuing (attempt ${decision.attempt}, reason: ${decision.reason})`);
-                            history.push({
-                                role: 'user',
-                                content: [{ type: 'text', text: decision.continuationPrompt }],
-                            });
-                            continue;
-                        }
-                    }
-                    break;
-                }
-                if (response.stop_reason === 'max_tokens') {
-                    throw new types_js_1.AgentError('Response truncated due to max tokens limit', 'MAX_TOKENS', undefined, false);
-                }
-                // Handle tool use
-                if (response.stop_reason === 'tool_use') {
-                    // Check for infinite loop patterns in tool usage
-                    const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
-                    if (toolUseBlocks.length > 0) {
-                        const currentToolName = toolUseBlocks[0].name;
-                        if (currentToolName === lastToolName) {
-                            consecutiveToolCalls++;
-                            if (consecutiveToolCalls >= MAX_CONSECUTIVE_SAME_TOOL) {
-                                throw new types_js_1.AgentError(`Infinite loop detected: Tool "${currentToolName}" called ${consecutiveToolCalls} times consecutively`, 'INFINITE_LOOP_DETECTED', undefined, false);
-                            }
-                        }
-                        else {
-                            consecutiveToolCalls = 1;
-                            lastToolName = currentToolName;
-                        }
-                    }
-                    const internalToolResults = await this.executeTools(response.content, options?.stopAfterSuccessfulTools ?? [], toolExecutionContext, runScope);
-                    const toolResults = internalToolResults.map(historyToolResult);
-                    // Add tool results to history
-                    history.push({
-                        role: 'user',
-                        content: toolResults,
-                    });
-                    // Notify turn callback for tool results
-                    runScope.onTurn?.({
-                        turn,
-                        role: 'user',
-                        content: toolResults,
-                    });
-                    const terminalToolResult = internalToolResults.find((result) => result.abort === true);
-                    if (terminalToolResult) {
-                        throw new types_js_1.AgentError(terminalToolResult.content, terminalToolResult.terminalCode ?? 'TOOL_ERROR', undefined, false);
-                    }
-                    const stopAfterSuccessfulTools = options?.stopAfterSuccessfulTools ?? [];
-                    const shouldStopAfterTool = stopAfterSuccessfulTools.length > 0 &&
-                        toolUseBlocks.some((toolUse) => stopAfterSuccessfulTools.includes(toolUse.name) &&
-                            toolResults.some((result) => result.tool_use_id === toolUse.id && !result.is_error));
-                    if (shouldStopAfterTool) {
-                        stopReason = 'end_turn';
-                        break;
-                    }
-                }
-            }
-            // Check if we hit max turns
-            // A budget stop on the last allowed turn is a budget stop, not MAX_TURNS.
-            if (turn >= this.maxTurns && stopReason === 'tool_use' && stoppedBy !== 'budget') {
-                throw new types_js_1.AgentError(`Agent loop exceeded maximum turns (${this.maxTurns})`, 'MAX_TURNS', undefined, false);
-            }
-            // Extract final text response
-            const finalResponse = this.extractTextResponse(history);
-            const result = {
-                ...(stoppedBy ? { stoppedBy } : {}),
-                response: finalResponse,
-                turns: turn,
-                history,
-                totalUsage,
-                stopReason,
-                modelRunId: ownedModelRunId ?? options?.modelRunId ?? null,
-                modelRunProvenance: ((ownedModelRunId ?? options?.modelRunId)
-                    ? 'available'
-                    : 'backend_no_run'),
-            };
-            // Draining background work and committing the run are separate failures and get
-            // separate catches. Sharing one meant a rejected background task skipped the commit
-            // and was then reported as `commit_failed` - naming a failure that was never even
-            // attempted, which is the exact habit this provenance state exists to break.
-            try {
-                await this.drainBackgroundTasks(pendingBackgroundTasks);
-            }
-            catch (backgroundError) {
-                logger.warn(`AgentLoop background task drain failed: ${backgroundError instanceof Error ? backgroundError.message : String(backgroundError)}`);
-            }
-            try {
-                if (ownedModelRunId) {
-                    await this.mcpExecutor.commitRuntimeModelRun(ownedModelRunId, 'agent_loop completed');
-                    ownedModelRunCommitted = true;
-                }
-            }
-            catch (commitError) {
-                logger.warn(`AgentLoop model run commit failed: ${commitError instanceof Error ? commitError.message : String(commitError)}`);
-            }
-            if (ownedModelRunId && !ownedModelRunCommitted) {
-                // The response still stands - the turn happened and the owner should get it.
-                // What does NOT stand is the handle: the run record may be left uncommitted, so
-                // returning its id would hand out provenance that cannot be resolved. Report the
-                // answer, withhold the claim, and say which kind of absence this is - an
-                // uncommitted record is a durability failure to repair, not the ordinary case of
-                // a backend that reports no run at all.
-                //
-                // Deliberately NOT marked failed. The run did not fail; writing its completion
-                // did. Relabelling a successful run as failed would tidy the state by recording
-                // something untrue, and an existing test pins that decision. The orphan stays
-                // visible, and the reason below is what a repair pass keys on.
-                result.modelRunId = null;
-                result.modelRunProvenance = 'commit_failed';
-                logger.error(`Model run ${ownedModelRunId} may remain uncommitted; provenance reported as commit_failed`);
-            }
-            if (ownerRuntime && finalResponse.trim()) {
-                // Observation only: a completion claim with no durable write in this run is the
-                // failure the owner sees as "corrected" work that never persisted (2026-09-09).
-                void this.observeCompletionClaim(ownedModelRunId, finalResponse);
-            }
-            if (ownerRuntime && this.ownerRuntimeJournal && finalResponse.trim()) {
-                try {
-                    this.ownerRuntimeJournal.append({
-                        trust: options?.ownerJournalTrust ?? 'untrusted',
-                        source: options?.source ?? 'owner',
-                        channelId: options?.channelId ?? owner_runtime_js_1.OWNER_RUNTIME_SESSION_KEY,
-                        prompt: ownerJournalPrompt,
-                        response: finalResponse,
-                        ...(options?.sourceMessageRef ? { sourceMessageRef: options.sourceMessageRef } : {}),
-                        committedAt: new Date().toISOString(),
-                    });
-                }
-                catch (journalError) {
-                    result.ownerJournalProvenance = 'commit_failed';
-                    logger.warn(`Owner runtime journal append failed: ${journalError instanceof Error ? journalError.message : String(journalError)}`);
-                }
-            }
-            if (stoppedBy) {
-                // Budget interruption is returned structurally; keep admission uncertain.
-                nativeEffects.failure(new Error('Native run stopped by token budget'));
-            }
-            else {
-                nativeEffects.finished();
-            }
-            return result;
-        }
-        catch (error) {
-            if (ownedModelRunId && !ownedModelRunCommitted) {
-                try {
-                    const summary = error instanceof Error ? error.message : String(error);
-                    await this.mcpExecutor.failRuntimeModelRun(ownedModelRunId, summary);
-                }
-                catch (failError) {
-                    logger.warn(`Failed to mark model run ${ownedModelRunId} failed: ${failError instanceof Error ? failError.message : String(failError)}`);
-                }
-            }
-            throw nativeEffects.failure(error);
-        }
-        finally {
-            this.mcpExecutor.releaseProcedureRun?.(toolExecutionContext);
-            // A child that outlives this run still needs its authority recipe, so the context is
-            // dropped only once the run finished AND no child of it is still registered.
-            if (ownedSubagentRunContext) {
-                ownedSubagentRunContext.runFinished = true;
-                if (ownedSubagentRunContext.activeChildren === 0 &&
-                    this.subagentRunContexts.get(channelKey) === ownedSubagentRunContext) {
-                    this.subagentRunContexts.delete(channelKey);
-                }
-            }
-            // Always release session lock, even on error
-            // BUT only if we own the session (not passed by caller)
-            if (ownedSession) {
-                this.sessionPool.releaseSession(channelKey);
-            }
-        }
-    }
-    shouldBeginModelRun(options) {
-        return this.isGatewayMode && !options?.modelRunId;
-    }
-    withBackgroundTaskRegistry(context, backgroundTasks) {
-        if (!context) {
-            return null;
-        }
-        return {
-            ...context,
-            backgroundTasks,
-        };
-    }
-    async drainBackgroundTasks(tasks) {
-        for (let index = 0; index < tasks.length; index += 1) {
-            await tasks[index];
-        }
-    }
-    buildModelRunInput(options, resolvedCliSessionId) {
-        const agentContext = options?.agentContext;
-        return {
-            model_id: options?.model ?? this.model ?? null,
-            model_provider: this.backend,
-            agent_id: options?.envelope?.agent_id ??
-                (agentContext?.source === 'viewer'
-                    ? 'os-agent'
-                    : (agentContext?.roleName ?? options?.source ?? 'agent')),
-            instance_id: options?.envelope?.instance_id ?? agentContext?.session?.sessionId ?? null,
-            envelope_hash: options?.envelope?.envelope_hash ?? null,
-            parent_model_run_id: options?.parentModelRunId ?? null,
-            status: 'running',
-            input_refs: {
-                source: options?.source ?? agentContext?.source ?? 'default',
-                channelId: options?.channelId ?? agentContext?.session?.channelId ?? this.sessionKey,
-                entrypoint: 'agent_loop',
-                ...(options?.sourceTurnId ? { sourceTurnId: options.sourceTurnId } : {}),
-                ...(options?.sourceMessageRef ? { sourceMessageRef: options.sourceMessageRef } : {}),
-                ...(resolvedCliSessionId ? { cliSessionId: resolvedCliSessionId } : {}),
-                ...(options?.workorderAttemptId !== undefined
-                    ? { workorderAttemptId: options.workorderAttemptId }
-                    : {}),
-            },
-        };
-    }
-    /** Always above maxTurns: the last-resort stop for a runaway native tool loop. */
-    emergencyMaxCalls() {
-        return Math.max(this.maxTurns + 10, 50);
-    }
-    /**
-     * The host tool surface the given options' role grants.
-     *
-     * The Code-Act gate is derived from THOSE options by default, never from the caller's
-     * own role: a child runs under a projected unattended role, so a parent that may hold
-     * outer Code-Act must not hand that marker to a child whose role forbids it.
-     */
-    hostToolDefinitionsFor(options, outerCodeActAllowed = this.useCodeAct &&
-        roleAllowsOuterCodeAct(options?.agentContext?.role, this.disallowedTools)) {
-        return this.useCodeAct
-            ? outerCodeActAllowed
-                ? tool_registry_js_1.ToolRegistry.getHostToolDefinitions({ allowedTools: [index_js_1.CODE_ACT_MARKER] })
-                : []
-            : tool_registry_js_1.ToolRegistry.getHostToolDefinitions({
-                allowedTools: options?.agentContext?.role.allowedTools,
-                blockedTools: options?.agentContext?.role.blockedTools,
-                disallowedTools: this.disallowedTools,
-                viewer: options?.agentContext?.platform === 'viewer',
-            });
-    }
-    /**
-     * One dynamic-tool bridge. Every guard it applies - the emergency call budget and the
-     * same-signature loop guard - is private to the bridge, so a parent and its children
-     * never share a counter. `recordExchange` is the ONLY way a bridge writes to a
-     * conversation: a child passes none and therefore cannot touch the parent's history.
-     */
-    buildHostToolBridge(params) {
-        let toolCallCount = 0;
-        let consecutiveToolCalls = 0;
-        let lastToolSignature = '';
-        return {
-            tools: params.tools,
-            execute: async (call) => {
-                const callSignal = call.signal ?? new AbortController().signal;
-                callSignal.throwIfAborted();
-                if (toolCallCount >= params.emergencyMaxCalls) {
-                    return {
-                        content: `Native tool call budget exceeded emergency maximum turns (${params.emergencyMaxCalls})`,
-                        isError: true,
-                        abort: true,
-                    };
-                }
-                const toolSignature = call.name === index_js_1.CODE_ACT_MARKER && typeof call.input.code === 'string'
-                    ? `${call.name}:${call.input.code.trim()}`
-                    : call.name;
-                const nextConsecutiveCount = toolSignature === lastToolSignature ? consecutiveToolCalls + 1 : 1;
-                if (nextConsecutiveCount >= params.maxConsecutiveSameTool) {
-                    return {
-                        content: `Infinite loop detected: Tool "${call.name}" called ${nextConsecutiveCount} times consecutively`,
-                        isError: true,
-                        abort: true,
-                    };
-                }
-                toolCallCount += 1;
-                consecutiveToolCalls = nextConsecutiveCount;
-                lastToolSignature = toolSignature;
-                const toolUse = {
-                    type: 'tool_use',
-                    id: call.callId,
-                    name: call.name,
-                    input: call.input,
-                };
-                params.recordExchange?.assistant(toolUse);
-                const executionContext = params.executionContext();
-                const callExecutionContext = executionContext
-                    ? {
-                        ...executionContext,
-                        gatewayCallId: call.callId,
-                        signal: callSignal,
-                    }
-                    : null;
-                const [toolResult] = await this.executeTools([toolUse], [...params.stopAfterSuccessfulTools], callExecutionContext, params.runScope);
-                if (!toolResult) {
-                    callSignal.throwIfAborted();
-                    return {
-                        content: `Native tool "${call.name}" returned no result`,
-                        isError: true,
-                        abort: true,
-                    };
-                }
-                if (!toolResult.terminalCode) {
-                    callSignal.throwIfAborted();
-                }
-                params.recordExchange?.result(toolResult);
-                return {
-                    content: toolResult.content,
-                    isError: toolResult.is_error === true,
-                    abort: toolResult.abort === true,
-                    terminalCode: toolResult.terminalCode,
-                    stop: toolResult.is_error !== true && params.stopAfterSuccessfulTools.includes(call.name),
-                };
-            },
-        };
-    }
-    /**
-     * Give one Codex-native child its OWN authority.
-     *
-     * The parent's bridge closes over an envelope issued for the PARENT's wall, which the
-     * child cannot renew - inheriting it meant a long delegated run losing every tool
-     * mid-flight and still reporting "done". So the child gets: its own model run under the
-     * parent's, its own envelope from a host issuer, its own execution context, and its own
-     * bridge counters. When no issuer is reachable it gets nothing and says so - the process
-     * refuses its calls with `subagent authority unavailable` rather than quietly borrowing.
-     */
-    async createSubagentBridge(info) {
-        const context = this.subagentRunContexts.get(info.sessionKey);
-        if (!context) {
-            console.warn(`[AgentLoop] subagent authority unavailable: no run context for session ${info.sessionKey} ` +
-                `(thread=${info.agentThreadId})`);
-            return null;
-        }
-        if (context.runFinished) {
-            // Only a child announced DURING the run inherits that run's issuer. A finished run
-            // stays reachable while a sibling is live; it must not mint authority hours later.
-            console.warn(`[AgentLoop] subagent authority refused: run for session ${info.sessionKey} already ended ` +
-                `(thread=${info.agentThreadId})`);
-            return null;
-        }
-        // Claimed synchronously: the parent's finally must not drop the context while this
-        // factory is still awaiting an envelope or a model run.
-        context.activeChildren += 1;
-        const abandon = (reason) => {
-            console.warn(reason);
-            this.releaseSubagentRunContext(info.sessionKey, context);
-            return null;
-        };
-        const issuer = context.options.prepareSubagentEnvelope ?? context.options.prepareEnvelope;
-        if (!issuer) {
-            return abandon(`[AgentLoop] subagent authority unavailable: no host envelope issuer for ${info.sessionKey} ` +
-                `(thread=${info.agentThreadId})`);
-        }
-        let envelope;
-        try {
-            envelope = await issuer();
-        }
-        catch (error) {
-            return abandon(`[AgentLoop] subagent authority issuance failed thread=${info.agentThreadId}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        if (!envelope) {
-            return abandon(`[AgentLoop] subagent authority unavailable: issuer returned no envelope ` +
-                `(thread=${info.agentThreadId})`);
-        }
-        const childOptions = {
-            ...context.options,
-            envelope,
-            prepareEnvelope: undefined,
-            parentModelRunId: context.parentModelRunId,
-            sourceMessageRef: `subagent:${info.agentThreadId}`,
-        };
-        let modelRunId;
-        try {
-            const modelRun = await this.mcpExecutor.beginRuntimeModelRun(this.buildModelRunInput(childOptions, context.cliSessionId));
-            modelRunId = modelRun.model_run_id;
-        }
-        catch (error) {
-            return abandon(`[AgentLoop] subagent model run could not begin thread=${info.agentThreadId}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        const childTasks = [];
-        const backgroundTasks = {
-            register(task) {
-                const observedTask = Promise.resolve(task);
-                observedTask.catch(() => {
-                    // Re-thrown later by the child's release drain.
-                });
-                childTasks.push(observedTask);
-            },
-        };
-        let childContext;
-        let bridge;
-        // The child's model run is already OPEN. Anything that throws while assembling its
-        // context or bridge must fail that run and release the parent's context, or the run
-        // stays `running` forever and the context stays pinned by a child that never existed.
-        try {
-            childContext = this.withBackgroundTaskRegistry(this.buildToolExecutionContext({ ...childOptions, modelRunId }), backgroundTasks);
-            if (childContext) {
-                childContext = { ...childContext, subagentThreadId: info.agentThreadId };
-            }
-            // The child's own run scope: no stream callbacks, no onTurn, no onToolUse. Its work
-            // is not this run's turns, and the parent's model run is already committed by then.
-            const runScope = { tier: context.tier, ...(0, temporal_code_act_breaker_js_1.createTemporalCodeActBreakerState)() };
-            bridge = this.buildHostToolBridge({
-                tools: context.tools,
-                runScope,
-                executionContext: () => childContext,
-                stopAfterSuccessfulTools: [],
-                emergencyMaxCalls: this.emergencyMaxCalls(),
-                maxConsecutiveSameTool: MAX_CONSECUTIVE_SAME_HOST_TOOL,
-            });
-        }
-        catch (error) {
-            const summary = error instanceof Error ? error.message : String(error);
-            try {
-                await this.mcpExecutor.failRuntimeModelRun(modelRunId, `subagent authority could not be assembled: ${summary}`);
-            }
-            catch (failError) {
-                logger.warn(`Failed to mark subagent model run ${modelRunId} failed: ${failError instanceof Error ? failError.message : String(failError)}`);
-            }
-            return abandon(`[AgentLoop] subagent authority could not be assembled thread=${info.agentThreadId}: ${summary}`);
-        }
-        let released = false;
-        return {
-            bridge,
-            release: async (outcome) => {
-                if (released) {
-                    return;
-                }
-                released = true;
-                try {
-                    await this.drainBackgroundTasks(childTasks);
-                }
-                catch (error) {
-                    logger.warn(`AgentLoop subagent background drain failed: ${error instanceof Error ? error.message : String(error)}`);
-                }
-                try {
-                    if (outcome.status === 'completed') {
-                        await this.mcpExecutor.commitRuntimeModelRun(modelRunId, `agent_loop subagent ${info.agentPath || info.agentThreadId} completed`);
-                    }
-                    else {
-                        // `unknown` is not success: the run is marked failed with the reason so the
-                        // ledger never carries a completion nobody confirmed.
-                        await this.mcpExecutor.failRuntimeModelRun(modelRunId, outcome.error ?? `subagent ${outcome.status}`);
-                    }
-                }
-                catch (error) {
-                    logger.warn(`AgentLoop subagent model run ${modelRunId} could not be closed: ${error instanceof Error ? error.message : String(error)}`);
-                }
-                this.mcpExecutor.releaseProcedureRun?.(childContext);
-                this.releaseSubagentRunContext(info.sessionKey, context);
-            },
-        };
-    }
-    /** Drop a run's subagent context once the run finished and no child still holds it. */
-    releaseSubagentRunContext(sessionKey, context) {
-        context.activeChildren = Math.max(0, context.activeChildren - 1);
-        if (context.runFinished &&
-            context.activeChildren === 0 &&
-            this.subagentRunContexts.get(sessionKey) === context) {
-            this.subagentRunContexts.delete(sessionKey);
-        }
-    }
-    /**
-     * Execute tools from response content blocks
-     */
-    async executeTools(content, stopAfterSuccessfulTools = [], executionContext = null, runScope = { tier: 1, ...(0, temporal_code_act_breaker_js_1.createTemporalCodeActBreakerState)() }) {
-        const modelToolContext = withExecutionSurface(executionContext, 'model_tool');
-        const reactiveInternalContext = withExecutionSurface(executionContext, 'reactive_internal');
-        const toolUseBlocks = content.filter((block) => block.type === 'tool_use');
-        const results = [];
-        for (const toolUse of toolUseBlocks) {
-            let result;
-            let isError = false;
-            let abort = false;
-            let terminalCode;
-            const executionToolName = toolUse.name === CODE_ACT_MCP_COMPAT_NAME ? index_js_1.CODE_ACT_MARKER : toolUse.name;
-            // Notify stream: tool execution starting
-            runScope.streamCallbacks?.onToolUse?.(executionToolName, toolUse.input);
-            const toolStart = Date.now();
-            try {
-                // PreToolUse: search MAMA for contracts before Write operations
-                let contractContext = '';
-                if (executionToolName === 'Write' && toolUse.input) {
-                    contractContext = await this.searchContractsForTool(executionToolName, toolUse.input, reactiveInternalContext);
-                }
-                const temporalCodeAct = executionToolName === index_js_1.CODE_ACT_MARKER &&
-                    modelToolContext?.temporalWorkContext !== undefined;
-                let codeActExecuted = false;
-                let toolResult;
-                if (temporalCodeAct) {
-                    const callDecision = (0, temporal_code_act_breaker_js_1.beginTemporalCodeActCall)(runScope);
-                    applyTemporalCodeActBreakerState(runScope, callDecision.state);
-                    if (callDecision.terminal) {
-                        toolResult = temporalCodeActTerminalResult(callDecision);
-                    }
-                    else {
-                        codeActExecuted = true;
-                        toolResult = await this.mcpExecutor.execute(executionToolName, toolUse.input, modelToolContext);
-                    }
-                }
-                else {
-                    toolResult = await this.mcpExecutor.execute(executionToolName, toolUse.input, modelToolContext ?? undefined);
-                }
-                let toolResultRecord = toolResult;
-                const existingTerminal = toolResultRecord.abort === true &&
-                    toolResultRecord.retryable === false &&
-                    (0, model_runner_js_1.isHostToolTerminalCode)(toolResultRecord.code);
-                if (temporalCodeAct && codeActExecuted && !existingTerminal) {
-                    const resultDecision = (0, temporal_code_act_breaker_js_1.observeTemporalCodeActResult)(runScope, {
-                        success: toolResult.success,
-                        hostToolExecutions: toolResultRecord.hostToolExecutions,
-                    });
-                    applyTemporalCodeActBreakerState(runScope, resultDecision.state);
-                    if (resultDecision.terminal) {
-                        toolResult = temporalCodeActTerminalResult(resultDecision);
-                        toolResultRecord = toolResult;
-                    }
-                }
-                result =
-                    executionToolName === index_js_1.CODE_ACT_MARKER
-                        ? (0, gateway_tool_executor_js_1.serializeCodeActModelResult)(toolResult)
-                        : JSON.stringify(toolResult, null, 2);
-                // Check if tool execution failed
-                const hasSuccess = 'success' in toolResult;
-                const toolFailed = hasSuccess && !toolResult.success;
-                if (toolFailed) {
-                    isError = true;
-                }
-                abort = toolResultRecord.abort === true;
-                terminalCode =
-                    abort &&
-                        toolResultRecord.retryable === false &&
-                        (0, model_runner_js_1.isHostToolTerminalCode)(toolResultRecord.code)
-                        ? toolResultRecord.code
-                        : undefined;
-                if (contractContext) {
-                    result = `${contractContext}\n\n---\n\n${result}`;
-                }
-                // Notify tool use callback
-                runScope.onToolUse?.(executionToolName, toolUse.input, toolResult);
-                // PostToolUse: auto-extract contracts (fire-and-forget)
-                this.postToolHandler?.processInBackground(executionToolName, toolUse.input, toolResult, reactiveInternalContext);
-                // Notify stream: tool completed (check actual status)
-                runScope.streamCallbacks?.onToolComplete?.(executionToolName, toolUse.id, isError);
-                // Emit tool execution metric
-                this.onMetric?.('tool_duration_ms', Date.now() - toolStart, {
-                    tool: executionToolName,
-                    error: String(isError),
-                });
-            }
-            catch (error) {
-                isError = true;
-                result = error instanceof Error ? error.message : String(error);
-                // Notify tool use callback with error
-                runScope.onToolUse?.(executionToolName, toolUse.input, { error: result });
-                this.onMetric?.('tool_duration_ms', Date.now() - toolStart, {
-                    tool: executionToolName,
-                    error: 'true',
-                });
-                // Notify stream: tool completed with error
-                runScope.streamCallbacks?.onToolComplete?.(executionToolName, toolUse.id, true);
-            }
-            results.push({
-                type: 'tool_result',
-                tool_use_id: toolUse.id,
-                content: result,
-                is_error: isError,
-                ...(abort ? { abort: true } : {}),
-                ...(terminalCode ? { terminalCode } : {}),
-            });
-            if (abort) {
-                break;
-            }
-            if (!isError && stopAfterSuccessfulTools.includes(executionToolName)) {
-                break;
-            }
-        }
-        return results;
-    }
-    /**
-     * Search MAMA for contracts related to a tool operation.
-     * Used as PreToolUse interceptor — searches for contract_* topics
-     * related to the file being written/edited.
-     *
-     * Non-blocking: returns empty string if search fails or no contracts found.
-     */
-    async searchContractsForTool(_toolName, input, executionContext = null) {
-        try {
-            const filePath = input.path;
-            if (!filePath) {
-                return '';
-            }
-            const fileName = filePath.split('/').pop() || filePath;
-            const searchQuery = `contract ${fileName}`;
-            const searchResult = await this.mcpExecutor.execute('mama_search', {
-                query: searchQuery,
-                limit: 3,
-            }, executionContext ?? undefined);
-            if (searchResult && typeof searchResult === 'object' && 'results' in searchResult) {
-                const typedResult = searchResult;
-                const contractResults = typedResult.results.filter((r) => r.topic?.startsWith('contract_'));
-                if (contractResults.length > 0) {
-                    const lines = contractResults.map((r) => `- **${r.topic}**: ${r.decision} (confidence: ${r.confidence ?? 'unknown'})`);
-                    return (`## PreToolUse: Related Contracts Found\n\n` +
-                        `Before writing to \`${fileName}\`, review these existing contracts:\n\n` +
-                        `${lines.join('\n')}\n\n` +
-                        `Ensure your changes are consistent with these contracts.`);
-                }
-            }
-            return '';
-        }
-        catch {
-            // Non-blocking: silently return empty on any error
-            return '';
-        }
-    }
-    /**
-     * Parse tool_call blocks from text response (Gateway Tools mode)
-     * Format: ```tool_call\n{"name": "...", "input": {...}}\n```
-     */
-    parseToolCallsFromText(text) {
-        const toolCalls = [];
-        const toolCallRegex = /```tool_call\s*\n([\s\S]*?)\n```/g;
-        let match;
-        while ((match = toolCallRegex.exec(text)) !== null) {
-            try {
-                const jsonStr = match[1].trim();
-                const parsed = JSON.parse(jsonStr);
-                if (parsed.name && typeof parsed.name === 'string') {
-                    toolCalls.push({
-                        type: 'tool_use',
-                        id: `gateway_tool_${(0, crypto_1.randomUUID)()}`,
-                        name: parsed.name,
-                        input: parsed.input || {},
-                    });
-                }
-            }
-            catch (e) {
-                console.warn(`[AgentLoop] Failed to parse tool_call block: ${e}`);
-            }
-        }
-        return toolCalls;
-    }
-    /**
-     * Parse ```js code blocks as code_act tool calls (Code-Act mode)
-     */
-    parseCodeActBlocks(text) {
-        const blocks = [];
-        const codeActRegex = /```(?:js|javascript)\s*\n([\s\S]*?)\n```/g;
-        let match;
-        while ((match = codeActRegex.exec(text)) !== null) {
-            const code = match[1].trim();
-            if (code) {
-                blocks.push({
-                    type: 'tool_use',
-                    id: `code_act_${(0, crypto_1.randomUUID)()}`,
-                    name: index_js_1.CODE_ACT_MARKER,
-                    input: { code },
-                });
-            }
-        }
-        return blocks;
-    }
-    /**
-     * Remove tool_call and code_act blocks from text (to avoid duplication in response)
-     */
-    removeToolCallBlocks(text) {
-        let result = text.replace(/```tool_call\s*\n[\s\S]*?\n```/g, '');
-        if (this.useCodeAct) {
-            result = result.replace(/```(?:js|javascript)\s*\n[\s\S]*?\n```/g, '');
-        }
-        return result.trim();
-    }
-    extractTextFromContent(content) {
-        return content
-            .filter((block) => block.type === 'text')
-            .map((block) => block.text)
-            .join('\n');
-    }
-    /**
-     * Extract text response from the last assistant message
-     */
-    /**
-     * Tokens a turn counts against the run budget. Anthropic reports cache reads and
-     * cache creation OUTSIDE input_tokens; codex (OpenAI usage) reports inputTokens
-     * inclusive of cachedInputTokens. Adding cache reads for codex doubled every count
-     * in 0.44.0 (a 2.8M wiki turn read as 5.5M and was stopped).
-     */
-    countBudgetTokens(usage) {
-        const base = usage.input_tokens + usage.output_tokens;
-        if (this.backend === 'codex') {
-            return base;
-        }
-        return base + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
-    }
-    extractTextResponse(history) {
-        // Find the last assistant message
-        for (let i = history.length - 1; i >= 0; i--) {
-            const message = history[i];
-            if (message.role === 'assistant') {
-                const content = message.content;
-                if (typeof content === 'string') {
-                    return content;
-                }
-                // Extract text blocks
-                const textBlocks = content.filter((block) => block.type === 'text');
-                return textBlocks.map((block) => block.text).join('\n');
-            }
-        }
-        return '';
-    }
-    /**
-     * Format only the last user message for persistent CLI
-     * Persistent CLI maintains context automatically, so we only send the new message
-     */
-    /**
-     * Turn 1 only, once the backend has said whether the thread is live: a fresh or re-opened
-     * thread is told the relevant procedures once, a live thread only what it has not been
-     * told (procedure-runtime.ts). Later turns of a run carry tool results, not hints.
-     */
-    withProcedureHints(basePromptText, turn, input) {
-        if (turn !== 1)
-            return basePromptText;
-        const hints = this.mcpExecutor.prepareProcedureContext?.(input.context, {
-            threadId: input.threadId,
-            fresh: input.fresh,
-        });
-        // Logged even when empty: with no procedures stored, this is the only sign the
-        // assembler ran and the thread decision it saw.
-        console.log(`[experience] thread=${input.threadId} fresh=${input.fresh} hints=${hints?.hints.length ?? 0}${hints?.hints.length ? `(${hints.hints.join(',')})` : ''} chars=${hints?.text.length ?? 0}`);
-        if (!hints?.text)
-            return basePromptText;
-        return `${hints.text}\n\n${basePromptText}`;
-    }
-    async observeCompletionClaim(modelRunId, finalResponse) {
-        const claim = finalResponse.match(COMPLETION_CLAIM_PATTERN)?.[0];
-        if (!claim || !modelRunId)
-            return;
-        try {
-            const wrote = await this.mcpExecutor.runHadDurableWrite?.(modelRunId);
-            if (wrote === false) {
-                console.warn(`[evidence] completion claim without a durable write: run=${modelRunId} claim="${claim}"`);
-            }
-        }
-        catch (error) {
-            console.warn(`[evidence] claim check unavailable: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    formatLastMessageOnly(history) {
-        const imageReaderTool = this.backend === 'cline' ? 'read_files' : this.backend === 'codex' ? 'view_image' : 'Read';
-        // Find the last user message in the history
-        for (let i = history.length - 1; i >= 0; i--) {
-            const msg = history[i];
-            if (msg.role === 'user') {
-                const content = msg.content;
-                let text;
-                if (typeof content === 'string') {
-                    text = content;
-                }
-                else if (Array.isArray(content)) {
-                    const parts = [];
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    for (const block of content) {
-                        if (block.type === 'text') {
-                            parts.push(block.text);
-                        }
-                        else if (block.type === 'image' && block.localPath) {
-                            parts.push(`⚠️ CRITICAL: The user has uploaded an image file.\n` +
-                                `Image path: ${block.localPath}\n` +
-                                `You MUST call the ${imageReaderTool} tool on "${block.localPath}" to view this image FIRST.\n` +
-                                `DO NOT describe or guess the image contents without reading it.\n` +
-                                `DO NOT say you cannot read images - ${imageReaderTool} supports image files.`);
-                        }
-                        else if (block.type === 'image' && block.source?.data) {
-                            // Base64-encoded image — save to disk so persistent CLI can read it
-                            // eslint-disable-next-line @typescript-eslint/no-require-imports
-                            const fs = require('fs');
-                            // eslint-disable-next-line @typescript-eslint/no-require-imports
-                            const path = require('path');
-                            const mediaDir = path.join((0, os_1.homedir)(), '.mama', 'workspace', 'media', 'inbound');
-                            fs.mkdirSync(mediaDir, { recursive: true });
-                            // Map MIME type to file extension (support PNG, JPEG, GIF, WebP)
-                            const mimeToExt = {
-                                'image/png': '.png',
-                                'image/jpeg': '.jpg',
-                                'image/jpg': '.jpg',
-                                'image/gif': '.gif',
-                                'image/webp': '.webp',
-                            };
-                            const ext = mimeToExt[block.source.media_type?.toLowerCase() || ''] || '.jpg';
-                            const imagePath = path.join(mediaDir, `${Date.now()}-${(0, crypto_1.randomUUID)().slice(0, 8)}${ext}`);
-                            try {
-                                fs.writeFileSync(imagePath, Buffer.from(block.source.data, 'base64'));
-                                parts.push(`⚠️ CRITICAL: The user has uploaded an image file.\n` +
-                                    `Image path: ${imagePath}\n` +
-                                    `You MUST call the ${imageReaderTool} tool on "${imagePath}" to view this image FIRST.\n` +
-                                    `DO NOT describe or guess the image contents without reading it.\n` +
-                                    `DO NOT say you cannot read images - ${imageReaderTool} supports image files.`);
-                            }
-                            catch {
-                                parts.push('[Image attached but could not be processed]');
-                            }
-                        }
-                        else if (block.type === 'tool_result') {
-                            const status = block.is_error ? 'ERROR' : 'SUCCESS';
-                            parts.push(`[Tool Result: ${status}]\n${block.content}`);
-                        }
-                        else if (block.type === 'tool_use') {
-                            parts.push(`[Tool Call: ${block.name}]\nInput: ${JSON.stringify(block.input, null, 2)}`);
-                        }
-                    }
-                    text = parts.join('\n');
-                }
-                else {
-                    text = '';
-                }
-                return text;
-            }
-        }
-        // Fallback: if no user message found, return empty string
-        return '';
-    }
-    /**
-     * Get the MAMA tool definitions
-     */
-    static getToolDefinitions() {
-        return [];
-    }
-    /**
-     * Get the default system prompt (verbose logging)
-     */
-    static getDefaultSystemPrompt() {
-        return loadSystemPrompt(true);
-    }
-    /**
-     * Stop and cleanup the AgentLoop resources
-     */
-    stopped = false;
-    async stop() {
-        if (this.stopped)
-            return;
-        this.stopped = true;
-        try {
-            // Stop the model runner
-            await this.agent.stop();
-            const waitUntil = Date.now() + 5000;
-            while (this.laneManager.getTotalQueueSize() > 0 && Date.now() < waitUntil) {
-                await new Promise((resolve) => setTimeout(resolve, 50));
-            }
-            // NOTE: sessionPool is a shared global singleton — do NOT dispose here.
-            // It will be cleaned up when the process exits or via a global shutdown handler.
-            // Lane manager doesn't have explicit stop method
-            // Let it be cleaned up by garbage collection
-        }
-        catch (error) {
-            console.error('Error during AgentLoop cleanup:', error);
-        }
-    }
-}
-exports.AgentLoop = AgentLoop;
-//# sourceMappingURL=agent-loop.js.map