@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.636

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,22 +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,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+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;
+}
+function hasCorrectionMarker(text) {
+    return /\b(hang on|wait|actually|not that|not this|wrong|misunderstood|you(?:'re| are) right|correct|exactly)\b/i.test(text)
+        || /^\s*no[\s,]/i.test(text);
+}
+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) {
+    const combined = currentUserSpeech.join("\n").trim();
+    if (!combined)
+        return [];
+    const signals = [];
+    if (hasCorrectionMarker(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)];
+}
+function deriveActionPolicy(signals) {
+    if (signals.length === 0)
+        return { mode: "normal" };
+    return {
+        mode: "correction_hold",
+        reason: signals.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"],
+    };
+}
+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 signals = deriveSignals(currentUserSpeech, priorAssistantReferents, candidateStructuredOutput);
+    const combinedSpeech = currentUserSpeech.join("\n").trim();
+    const latestStructuredOutput = candidateStructuredOutput && shouldAttachStructuredOutput(combinedSpeech, signals)
+        ? candidateStructuredOutput
+        : undefined;
+    const actionPolicy = deriveActionPolicy(signals);
+    const frame = {
+        schemaVersion: 1,
+        channel: input.channel,
+        currentUserSpeech,
+        priorAssistantReferents,
+        ...(latestStructuredOutput ? { latestStructuredOutput } : {}),
+        signals,
+        actionPolicy,
+        ...(input.source ? { source: input.source } : {}),
+    };
+    (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,
+        },
+    });
+    return frame;
+}
+function renderOrientationFrame(frame) {
+    const lines = [
+        "## orientation frame",
+        `channel: ${frame.channel}`,
+        `action policy: ${frame.actionPolicy.mode}`,
+    ];
+    if (frame.actionPolicy.mode === "correction_hold") {
+        lines.push(`policy reason: ${frame.actionPolicy.reason}`);
+    }
+    if (frame.source) {
+        lines.push("source:");
+        lines.push(`- kind: ${frame.source.kind}`);
+        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/provider-attempt.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROVIDER_ATTEMPT_POLICY = exports.ProviderAttemptAbortError = void 0;
+exports.runProviderAttempt = runProviderAttempt;
+const runtime_1 = require("../nerves/runtime");
+class ProviderAttemptAbortError extends Error {
+    constructor(message = "provider attempt aborted") {
+        super(message);
+        this.name = "ProviderAttemptAbortError";
+    }
+}
+exports.ProviderAttemptAbortError = ProviderAttemptAbortError;
+exports.DEFAULT_PROVIDER_ATTEMPT_POLICY = {
+    maxAttempts: 3,
+    baseDelayMs: 2_000,
+    backoffMultiplier: 2,
+};
+function sleep(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function normalizePolicy(policy) {
+    return {
+        ...exports.DEFAULT_PROVIDER_ATTEMPT_POLICY,
+        ...policy,
+    };
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function classify(error, classifyError) {
+    if (!(error instanceof Error))
+        return "unknown";
+    try {
+        return classifyError(error);
+    }
+    catch {
+        return "unknown";
+    }
+}
+function httpStatus(error) {
+    const status = error.status;
+    return typeof status === "number" ? status : null;
+}
+function delayForAttempt(policy, attempt) {
+    return policy.baseDelayMs * Math.pow(policy.backoffMultiplier, attempt - 1);
+}
+async function runProviderAttempt(input) {
+    const policy = normalizePolicy(input.policy);
+    const maxAttempts = Math.max(1, Math.floor(policy.maxAttempts));
+    const wait = input.sleep ?? sleep;
+    const attempts = [];
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            await input.onAttemptStart?.(attempt, maxAttempts);
+            const value = await input.run();
+            attempts.push({
+                attempt,
+                provider: input.provider,
+                model: input.model,
+                operation: input.operation,
+                ok: true,
+                willRetry: false,
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.provider_attempt_succeeded",
+                message: "provider attempt succeeded",
+                meta: { provider: input.provider, model: input.model, operation: input.operation, attempt, maxAttempts },
+            });
+            return { ok: true, value, attempts };
+        }
+        catch (caught) {
+            if (caught instanceof ProviderAttemptAbortError)
+                throw caught;
+            const error = toError(caught);
+            const classification = classify(caught, input.classifyError);
+            const willRetry = attempt < maxAttempts;
+            const delayMs = willRetry ? delayForAttempt(policy, attempt) : undefined;
+            const record = {
+                attempt,
+                provider: input.provider,
+                model: input.model,
+                operation: input.operation,
+                ok: false,
+                classification,
+                errorMessage: error.message,
+                httpStatus: httpStatus(error),
+                willRetry,
+                ...(delayMs !== undefined ? { delayMs } : {}),
+            };
+            attempts.push(record);
+            if (!willRetry) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "engine",
+                    event: "engine.provider_attempt_failed",
+                    message: "provider attempt failed",
+                    meta: {
+                        provider: input.provider,
+                        model: input.model,
+                        operation: input.operation,
+                        attempt,
+                        maxAttempts,
+                        classification,
+                        errorMessage: error.message.slice(0, 200),
+                        httpStatus: httpStatus(error),
+                    },
+                });
+                return { ok: false, error, classification, attempts };
+            }
+            const retryDelayMs = delayMs;
+            (0, runtime_1.emitNervesEvent)({
+                component: "engine",
+                event: "engine.provider_attempt_retry",
+                message: "provider attempt failed; retrying",
+                meta: {
+                    provider: input.provider,
+                    model: input.model,
+                    operation: input.operation,
+                    attempt,
+                    maxAttempts,
+                    classification,
+                    errorMessage: error.message.slice(0, 200),
+                    httpStatus: httpStatus(error),
+                    delayMs: retryDelayMs,
+                },
+            });
+            await input.onRetry?.(record, maxAttempts);
+            await wait(retryDelayMs);
+        }
+    }
+    /* v8 ignore next 2 -- defensive: loop always returns on success or final failure @preserve */
+    return { ok: false, error: new Error("provider attempt loop ended unexpectedly"), classification: "unknown", attempts };
+}