@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/heart/migrate-config.js

@@ -0,0 +1,100 @@
+"use strict";
+// v1 → v2 agent.json migration.
+// Creates explicit humanFacing/agentFacing blocks from the legacy provider.
+// Uses raw fs and provider-model defaults — NO import from config.ts.
+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.migrateAgentConfigV1ToV2 = migrateAgentConfigV1ToV2;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../nerves/runtime");
+const provider_models_1 = require("./provider-models");
+function isAgentProvider(value) {
+    return value === "azure" ||
+        value === "minimax" ||
+        value === "anthropic" ||
+        value === "openai-codex" ||
+        value === "github-copilot";
+}
+function migrateAgentConfigV1ToV2(agentRoot) {
+    const configPath = path.join(agentRoot, "agent.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, "utf-8");
+    }
+    catch {
+        return; // No agent.json — nothing to migrate
+    }
+    let config;
+    try {
+        config = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Cannot parse agent.json at ${configPath} — invalid JSON`);
+    }
+    const version = typeof config.version === "number" ? config.version : 1;
+    if (version >= 2) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "config/identity",
+            event: "config_identity.migrate_skip",
+            message: "agent config already v2, skipping migration",
+            meta: { agentRoot },
+        });
+        return;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_start",
+        message: "migrating agent config v1 → v2",
+        meta: { agentRoot },
+    });
+    const provider = isAgentProvider(config.provider) ? config.provider : "anthropic";
+    const model = (0, provider_models_1.getDefaultModelForProvider)(provider);
+    // Write v2 config
+    const { provider: _removed, ...rest } = config;
+    const v2Config = {
+        ...rest,
+        version: 2,
+        humanFacing: { provider, model },
+        agentFacing: { provider, model },
+    };
+    fs.writeFileSync(configPath, JSON.stringify(v2Config, null, 2) + "\n", "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "config/identity",
+        event: "config_identity.migrate_end",
+        message: "agent config migration complete",
+        meta: { agentRoot, provider, model },
+    });
+}

package/dist/heart/model-capabilities.js

@@ -8,30 +8,41 @@ exports.MODEL_CAPABILITIES = {
         reasoningEffort: ["low", "medium", "high", "max"],
         thinkingFormat: "anthropic",
         maxOutputTokens: 128000,
+        vision: true,
     },
     "claude-sonnet-4-6": {
         reasoningEffort: ["low", "medium", "high"],
         thinkingFormat: "anthropic",
         maxOutputTokens: 64000,
+        vision: true,
     },
     "claude-opus-4.6": {
         reasoningEffort: ["low", "medium", "high", "max"],
         maxOutputTokens: 128000,
+        vision: true,
     },
     "claude-sonnet-4.6": {
         reasoningEffort: ["low", "medium", "high"],
         maxOutputTokens: 64000,
+        vision: true,
     },
     "gpt-5.4": {
         reasoningEffort: ["low", "medium", "high"],
         phase: true,
         maxOutputTokens: 100000,
+        vision: true,
     },
     "gpt-5.3-codex": {
         reasoningEffort: ["low", "medium", "high"],
         phase: true,
         maxOutputTokens: 100000,
     },
+    "MiniMax-Text-01": {
+        vision: true,
+    },
+    "MiniMax-VL-01": {
+        vision: true,
+    },
 };
 const EMPTY_CAPABILITIES = Object.freeze({});
 function getModelCapabilities(modelId) {

package/dist/heart/orientation-frame.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPLICIT_PRIOR_WORK_RESUME_INSTRUCTION = exports.BACKGROUND_ONLY_INSTRUCTION = void 0;
+exports.priorWorkInstruction = priorWorkInstruction;
+exports.labelPriorWorkSurface = labelPriorWorkSurface;
+exports.extractMessageText = extractMessageText;
+exports.extractOrderedListReferents = extractOrderedListReferents;
+exports.buildOrientationFrame = buildOrientationFrame;
+exports.renderOrientationFrame = renderOrientationFrame;
+const runtime_1 = require("../nerves/runtime");
+const structured_output_1 = require("./structured-output");
+exports.BACKGROUND_ONLY_INSTRUCTION = "Background only; do not execute.";
+exports.EXPLICIT_PRIOR_WORK_RESUME_INSTRUCTION = "Prior work explicitly resumed by the current trigger.";
+function priorWorkInstruction(resumePriorWork) {
+    return resumePriorWork
+        ? exports.EXPLICIT_PRIOR_WORK_RESUME_INSTRUCTION
+        : exports.BACKGROUND_ONLY_INSTRUCTION;
+}
+/**
+ * Put the prior-work authority label directly under a section heading when one
+ * exists, otherwise before the surface. This keeps the label adjacent to the
+ * exact stale-work surface it governs instead of relying on a distant prompt
+ * preamble.
+ */
+function labelPriorWorkSurface(surface, resumePriorWork) {
+    if (!surface)
+        return "";
+    const instruction = priorWorkInstruction(resumePriorWork);
+    const inlineBoldHeading = /^(\*\*[^*]+:\*\*)\s+([\s\S]+)$/.exec(surface);
+    if (inlineBoldHeading) {
+        return `${inlineBoldHeading[1]}\n${instruction}\n${inlineBoldHeading[2]}`;
+    }
+    const newlineIndex = surface.indexOf("\n");
+    const firstLine = newlineIndex === -1 ? surface : surface.slice(0, newlineIndex);
+    if (firstLine.startsWith("## ") || /^\*\*[^*]+:\*\*$/.test(firstLine)) {
+        const remainder = newlineIndex === -1 ? "" : surface.slice(newlineIndex + 1);
+        return [firstLine, instruction, remainder].filter((part) => part.length > 0).join("\n");
+    }
+    return `${instruction}\n${surface}`;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function extractMessageText(message) {
+    if (!message)
+        return "";
+    const content = message.content;
+    const toolText = message.role === "assistant"
+        ? (0, structured_output_1.extractVisibleTextFromAssistantToolCalls)(message.tool_calls)
+        : "";
+    if (typeof content === "string")
+        return [content, toolText].filter((part) => part.trim().length > 0).join("\n").trim();
+    if (!Array.isArray(content))
+        return toolText.trim();
+    const parts = [];
+    for (const part of content) {
+        if (!isRecord(part))
+            continue;
+        const text = part.text;
+        if (typeof text === "string") {
+            parts.push(text.trim());
+        }
+    }
+    if (toolText)
+        parts.push(toolText);
+    return parts.filter(Boolean).join("\n").trim();
+}
+function currentUserMessagesFrom(messages) {
+    const collected = [];
+    let firstIndex = messages.length;
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message?.role !== "user") {
+            if (collected.length > 0)
+                break;
+            continue;
+        }
+        collected.unshift(message);
+        firstIndex = index;
+    }
+    return { messages: collected, firstIndex };
+}
+function latestAssistantBefore(messages, beforeIndex) {
+    for (let index = Math.min(beforeIndex - 1, messages.length - 1); index >= 0; index--) {
+        const message = messages[index];
+        if (message?.role === "assistant")
+            return message;
+    }
+    return undefined;
+}
+function extractOrderedListReferents(text) {
+    const referents = [];
+    for (const line of text.split(/\r?\n/)) {
+        const match = line.match(/^\s*(\d+)[.)]\s+(.+?)\s*$/);
+        if (!match)
+            continue;
+        referents.push({
+            kind: "ordered_list_item",
+            label: match[1],
+            text: match[2].trim(),
+        });
+        if (referents.length >= 12)
+            break;
+    }
+    return referents;
+}
+/**
+ * Returns the marker that fired, not just a boolean: when the hold blocks an action
+ * the agent has to be able to see *which* word triggered it. In the 2026-07-27
+ * incident it guessed wrong twice ("it's because of the word 'useful'") because the
+ * block message named no trigger.
+ */
+function correctionMarkerIn(text) {
+    const phrase = /\b(hang on|wait|actually|not that|not this|wrong|misunderstood|you(?:'re| are) right|correct)\b/i.exec(text);
+    if (phrase)
+        return phrase[0].toLowerCase();
+    return /^\s*no[\s,]/i.test(text) ? "no" : undefined;
+}
+function isTerseReferent(text) {
+    const normalized = text.trim().toLowerCase().replace(/[.!?]+$/g, "");
+    return /^(same|correct|exactly|yes|no|that one|this one|the first one|the second one|the third one|first|second|third|option \d+|number \d+|item \d+|\d+)$/.test(normalized);
+}
+function hasNumericStructuredReferent(text) {
+    return /\b(?:number|item|option|#)\s*\d+\b/i.test(text) || /^\s*\d+\b/.test(text.trim());
+}
+function latestStructuredOutputFrom(outputs) {
+    if (!outputs || outputs.length === 0)
+        return undefined;
+    return outputs.at(-1);
+}
+function shouldAttachStructuredOutput(combinedSpeech, signals) {
+    if (hasNumericStructuredReferent(combinedSpeech))
+        return true;
+    return signals.some((signal) => signal === "terse_referent" || signal === "correction_marker");
+}
+function deriveSignals(currentUserSpeech, priorAssistantReferents, latestStructuredOutput, speechKind) {
+    const combined = currentUserSpeech.join("\n").trim();
+    // A reaction is an acknowledgement of an existing message, not new speech. Its
+    // text is synthesised by the sense from the message being reacted to, so scanning
+    // it would read the *quoted* message's words as the human's correction — and a
+    // positive tapback is approval, which must never gate outbound work.
+    if (!combined || speechKind === "reaction")
+        return [];
+    const signals = [];
+    if (correctionMarkerIn(combined))
+        signals.push("correction_marker");
+    if (priorAssistantReferents.length > 0 && isTerseReferent(combined))
+        signals.push("terse_referent");
+    if (latestStructuredOutput && hasNumericStructuredReferent(combined))
+        signals.push("structured_referent");
+    return [...new Set(signals)];
+}
+/**
+ * The hold exists for corrections that are terse or ambiguous ("no, not that one").
+ * A correction word buried in a long, self-contained instruction is neither: on
+ * 2026-07-27 the word "actually" — in "Do NOT claim a hotel has AC unless you
+ * actually saw evidence" — armed the hold inside a 195-word directive that had zero
+ * prior referents and no structured output, and blocked five consecutive
+ * `send_message` calls. The same directive was what authorised the send, and with
+ * nothing to disambiguate the remedy the block named could not be performed.
+ */
+const TERSE_CORRECTION_MAX_WORDS = 12;
+const CORRECTION_HOLD_CLEARED_BY = "Resolve the referent (orientation_get lists the candidates) or restate the request as a standalone, correction-free instruction. The policy is recomputed from each user turn, so it never carries past this turn.";
+function countWords(text) {
+    return text.trim().split(/\s+/).filter(Boolean).length;
+}
+function correctionMarkerArmsHold(combinedSpeech, priorAssistantReferents, latestStructuredOutput) {
+    if (countWords(combinedSpeech) <= TERSE_CORRECTION_MAX_WORDS)
+        return true;
+    // Long speech still holds when there is something concrete to disambiguate.
+    return priorAssistantReferents.length > 0 || Boolean(latestStructuredOutput);
+}
+function deriveActionPolicy(signals, combinedSpeech, priorAssistantReferents, latestStructuredOutput) {
+    const holdSignals = signals.filter((signal) => signal !== "correction_marker"
+        || correctionMarkerArmsHold(combinedSpeech, priorAssistantReferents, latestStructuredOutput));
+    if (holdSignals.length === 0)
+        return { mode: "normal" };
+    const triggeredBy = holdSignals.includes("correction_marker")
+        ? correctionMarkerIn(combinedSpeech)
+        : undefined;
+    return {
+        mode: "correction_hold",
+        reason: holdSignals.includes("terse_referent")
+            ? "Current user speech appears referent-dependent; inspect orientation before mutating durable state."
+            : "Current user speech appears to correct or revise prior understanding; inspect orientation before mutating durable state.",
+        blockedMutationKinds: ["durable_state_write", "external_side_effect"],
+        ...(triggeredBy ? { triggeredBy } : {}),
+        clearedBy: CORRECTION_HOLD_CLEARED_BY,
+    };
+}
+function buildOrientationFrame(input) {
+    const derivedCurrent = input.currentUserMessages
+        ? { messages: input.currentUserMessages, firstIndex: input.messages.length }
+        : currentUserMessagesFrom(input.messages);
+    const currentUserSpeech = derivedCurrent.messages
+        .map((message) => extractMessageText(message))
+        .filter((text) => text.length > 0);
+    const previousAssistant = latestAssistantBefore(input.messages, derivedCurrent.firstIndex);
+    const priorAssistantReferents = extractOrderedListReferents(extractMessageText(previousAssistant));
+    const candidateStructuredOutput = latestStructuredOutputFrom(input.structuredOutputs);
+    const speechKind = input.speechKind ?? "utterance";
+    const signals = deriveSignals(currentUserSpeech, priorAssistantReferents, candidateStructuredOutput, speechKind);
+    const combinedSpeech = currentUserSpeech.join("\n").trim();
+    const latestStructuredOutput = candidateStructuredOutput && shouldAttachStructuredOutput(combinedSpeech, signals)
+        ? candidateStructuredOutput
+        : undefined;
+    const actionPolicy = deriveActionPolicy(signals, combinedSpeech, priorAssistantReferents, candidateStructuredOutput);
+    const frame = {
+        schemaVersion: 1,
+        channel: input.channel,
+        currentUserSpeech,
+        priorAssistantReferents,
+        ...(latestStructuredOutput ? { latestStructuredOutput } : {}),
+        signals,
+        actionPolicy,
+        ...(input.source ? { source: input.source } : {}),
+        ...(speechKind === "utterance" ? {} : { speechKind }),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "orientation.frame_built",
+        message: "orientation frame built",
+        meta: {
+            channel: input.channel,
+            signalCount: signals.length,
+            referentCount: priorAssistantReferents.length,
+            structuredOutput: latestStructuredOutput?.id ?? null,
+            policy: actionPolicy.mode,
+        },
+    });
+    if (actionPolicy.mode === "correction_hold") {
+        // Distinct + greppable: a hold that blocks an explicitly requested action must
+        // leave a trace naming what it blocks and what releases it.
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "engine",
+            event: "orientation.correction_hold_armed",
+            message: "orientation correction hold armed",
+            meta: {
+                channel: input.channel,
+                speechKind,
+                signals,
+                blockedMutationKinds: actionPolicy.blockedMutationKinds,
+                triggeredBy: actionPolicy.triggeredBy ?? null,
+                referentCount: priorAssistantReferents.length,
+                structuredOutput: candidateStructuredOutput?.id ?? null,
+                speechWordCount: countWords(combinedSpeech),
+                clearedBy: actionPolicy.clearedBy,
+            },
+        });
+    }
+    return frame;
+}
+function renderOrientationFrame(frame) {
+    const lines = [
+        "## Current trigger (authoritative)",
+        `channel: ${frame.channel}`,
+        `action policy: ${frame.actionPolicy.mode}`,
+    ];
+    if (frame.actionPolicy.mode === "correction_hold") {
+        lines.push(`policy reason: ${frame.actionPolicy.reason}`);
+        lines.push(`policy blocks: ${frame.actionPolicy.blockedMutationKinds.join(", ")}`);
+        if (frame.actionPolicy.triggeredBy) {
+            lines.push(`policy trigger: correction marker "${frame.actionPolicy.triggeredBy}" in current user speech`);
+        }
+        if (frame.actionPolicy.clearedBy)
+            lines.push(`policy clears when: ${frame.actionPolicy.clearedBy}`);
+    }
+    if (frame.speechKind) {
+        lines.push(`speech kind: ${frame.speechKind}`);
+    }
+    if (frame.source) {
+        lines.push("source:");
+        lines.push(`- kind: ${frame.source.kind}`);
+        if (frame.source.authority === "presentation_only") {
+            lines.push("- source authority: presentation only; never tool authority");
+        }
+        if (frame.source.conversationKind) {
+            lines.push(`- conversation kind: ${frame.source.conversationKind}`);
+        }
+        if (frame.source.event) {
+            lines.push(`- event: ${frame.source.event.kind} (${frame.source.event.sourceEventType}; from me: ${String(frame.source.event.fromMe)})`);
+        }
+        if (frame.source.actor) {
+            const actorLabel = frame.source.actor.displayName?.trim() || frame.source.actor.externalId;
+            lines.push(`- observed actor: ${actorLabel} [${frame.source.actor.provider}:${frame.source.actor.externalId}]`);
+        }
+        if (frame.source.participants) {
+            for (const participant of frame.source.participants) {
+                const participantLabel = participant.displayName?.trim() || participant.externalId;
+                lines.push(`- group participant only: ${participantLabel} [${participant.provider}:${participant.externalId}]`);
+            }
+        }
+        if (frame.source.conversationKind === "group") {
+            lines.push("- participant membership is not evidence that someone spoke, read, requested, or authored a reaction target.");
+        }
+        if (frame.source.target) {
+            lines.push(`- target: ${frame.source.target.messageGuid} (authorship: ${frame.source.target.authorship})`);
+        }
+        if (frame.source.lane)
+            lines.push(`- lane: ${frame.source.lane}`);
+        if (frame.source.defaultReplyTarget)
+            lines.push(`- default reply target: ${frame.source.defaultReplyTarget}`);
+        if (frame.source.threadId)
+            lines.push(`- thread id: ${frame.source.threadId}`);
+        if (frame.source.replyingToText)
+            lines.push(`- replying to: ${frame.source.replyingToText}`);
+        if (frame.source.repairNotice)
+            lines.push(`- repair notice: ${frame.source.repairNotice}`);
+        if (frame.source.routingHint)
+            lines.push(`- routing hint: ${frame.source.routingHint}`);
+        if (frame.source.recentLanes && frame.source.recentLanes.length > 0) {
+            lines.push("- recent lanes:");
+            for (const lane of frame.source.recentLanes) {
+                lines.push(`  - ${lane.label || lane.key}: ${lane.snippet}`);
+            }
+        }
+    }
+    lines.push("current user speech:");
+    if (frame.currentUserSpeech.length === 0) {
+        lines.push("- (none)");
+    }
+    else {
+        for (const speech of frame.currentUserSpeech)
+            lines.push(`- ${speech}`);
+    }
+    if (frame.signals.length > 0) {
+        lines.push(`signals: ${frame.signals.join(", ")}`);
+    }
+    if (frame.priorAssistantReferents.length > 0) {
+        lines.push("prior assistant referents:");
+        for (const item of frame.priorAssistantReferents) {
+            lines.push(`${item.label}. ${item.text}`);
+        }
+    }
+    if (frame.latestStructuredOutput) {
+        lines.push(`latest structured output: ${frame.latestStructuredOutput.id}`);
+        if (frame.latestStructuredOutput.heading)
+            lines.push(`heading: ${frame.latestStructuredOutput.heading}`);
+        for (const item of frame.latestStructuredOutput.items) {
+            lines.push(`${item.label}. ${item.text}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/heart/platform.js

@@ -0,0 +1,81 @@
+"use strict";
+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.detectPlatform = detectPlatform;
+const fs = __importStar(require("fs"));
+const runtime_1 = require("../nerves/runtime");
+function detectPlatform(deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const env = deps.env ?? process.env;
+    const readFile = deps.readFileSync ?? ((p) => fs.readFileSync(p, "utf-8"));
+    let result;
+    if (platform === "darwin") {
+        result = "macos";
+    }
+    else if (platform === "win32") {
+        result = "windows-native";
+    }
+    else if (platform === "linux") {
+        result = detectLinuxOrWsl(env, readFile);
+    }
+    else {
+        // Unknown platform — treat as linux
+        result = "linux";
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.platform_detected",
+        message: "detected platform",
+        meta: { platform, result },
+    });
+    return result;
+}
+function detectLinuxOrWsl(env, readFile) {
+    // Primary: WSL_DISTRO_NAME env var
+    if (env.WSL_DISTRO_NAME && env.WSL_DISTRO_NAME.length > 0) {
+        return "wsl";
+    }
+    // Fallback: /proc/version containing "microsoft" (case-insensitive)
+    try {
+        const procVersion = readFile("/proc/version");
+        if (/microsoft/i.test(procVersion)) {
+            return "wsl";
+        }
+    }
+    catch {
+        // /proc/version not readable — not WSL
+    }
+    return "linux";
+}

package/dist/heart/primitives.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HARNESS_BOOTSTRAP_PHASES = void 0;
-exports.HARNESS_BOOTSTRAP_PHASES = ["bundle", "psyche", "inner-dialog"];
+exports.HARNESS_BOOTSTRAP_PHASES = ["bundle", "psyche", "private-runtime"];