@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.100

package/dist/heart/daemon/update-hooks.js

@@ -0,0 +1,138 @@
+"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.registerUpdateHook = registerUpdateHook;
+exports.getRegisteredHooks = getRegisteredHooks;
+exports.clearRegisteredHooks = clearRegisteredHooks;
+exports.applyPendingUpdates = applyPendingUpdates;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const semver = __importStar(require("semver"));
+const runtime_1 = require("../../nerves/runtime");
+const _hooks = [];
+function registerUpdateHook(hook) {
+    _hooks.push(hook);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.update_hook_registered",
+        message: "registered update hook",
+        meta: {},
+    });
+}
+function getRegisteredHooks() {
+    return _hooks;
+}
+function clearRegisteredHooks() {
+    _hooks.length = 0;
+}
+async function applyPendingUpdates(bundlesRoot, currentVersion) {
+    const summary = { updated: [] };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.apply_pending_updates_start",
+        message: "applying pending updates",
+        meta: { bundlesRoot, currentVersion },
+    });
+    if (!fs.existsSync(bundlesRoot)) {
+        return summary;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(bundlesRoot, { withFileTypes: true });
+    }
+    catch {
+        return summary;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+            continue;
+        const agentRoot = path.join(bundlesRoot, entry.name);
+        let previousVersion;
+        const metaPath = path.join(agentRoot, "bundle-meta.json");
+        try {
+            if (fs.existsSync(metaPath)) {
+                const raw = fs.readFileSync(metaPath, "utf-8");
+                const meta = JSON.parse(raw);
+                previousVersion = meta.runtimeVersion;
+                if (previousVersion === currentVersion) {
+                    continue;
+                }
+                // Skip downgrades — only update forward
+                if (semver.valid(previousVersion) && semver.valid(currentVersion) && semver.gte(previousVersion, currentVersion)) {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "daemon",
+                        event: "daemon.update_hook_skip_downgrade",
+                        message: "skipping downgrade",
+                        meta: { agentRoot, previousVersion, currentVersion },
+                    });
+                    continue;
+                }
+            }
+        }
+        catch {
+            // Malformed or unreadable bundle-meta.json -- treat as needing update
+            previousVersion = undefined;
+        }
+        const ctx = { agentRoot, currentVersion, previousVersion };
+        for (const hook of _hooks) {
+            try {
+                await hook(ctx);
+            }
+            catch (err) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.update_hook_error",
+                    message: "update hook threw",
+                    meta: {
+                        agentRoot,
+                        error: err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err),
+                    },
+                });
+            }
+        }
+        summary.updated.push({
+            agent: entry.name.replace(/\.ouro$/, ""),
+            from: previousVersion,
+            to: currentVersion,
+        });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.apply_pending_updates_end",
+        message: "pending updates applied",
+        meta: { bundlesRoot },
+    });
+    return summary;
+}

package/dist/heart/daemon/wrapper-publish-guard.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessWrapperPublishSync = assessWrapperPublishSync;
+const runtime_1 = require("../../nerves/runtime");
+function wrapperPackageChanged(changedFiles) {
+    return changedFiles.some((file) => file.startsWith("packages/ouro.bot/"));
+}
+function assessWrapperPublishSync(input) {
+    let result;
+    if (input.localVersion !== input.cliVersion) {
+        result = {
+            ok: false,
+            message: `ouro.bot wrapper version ${input.localVersion} must match @ouro.bot/cli version ${input.cliVersion}`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: wrapperPackageChanged(input.changedFiles),
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
+    if (!wrapperPackageChanged(input.changedFiles)) {
+        result = {
+            ok: true,
+            message: "wrapper package unchanged",
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: false,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
+    if (input.publishedVersion === input.localVersion) {
+        result = {
+            ok: false,
+            message: `ouro.bot wrapper changed but ouro.bot@${input.localVersion} is already published; bump packages/ouro.bot/package.json before merging`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: true,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
+    result = {
+        ok: true,
+        message: "wrapper package changed and local wrapper version is unpublished",
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.wrapper_publish_guard_checked",
+        message: "evaluated wrapper publish sync",
+        meta: {
+            changed: true,
+            localVersion: input.localVersion,
+            cliVersion: input.cliVersion,
+            publishedVersion: input.publishedVersion,
+            ok: result.ok,
+        },
+    });
+    return result;
+}

package/dist/heart/delegation.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideDelegation = decideDelegation;
+const runtime_1 = require("../nerves/runtime");
+const CROSS_SESSION_TOOLS = new Set(["query_session", "send_message", "bridge_manage"]);
+const FAST_PATH_TOOLS = new Set(["final_answer"]);
+const REFLECTION_PATTERN = /\b(think|reflect|ponder|surface|surfaces|surfaced|sit with|metaboli[sz]e)\b/i;
+const CROSS_SESSION_PATTERN = /\b(other chat|other session|across chats?|across sessions?|keep .* aligned|relay|carry .* across)\b/i;
+function hasExplicitReflection(ingressTexts) {
+    return ingressTexts.some((text) => REFLECTION_PATTERN.test(text));
+}
+function hasCrossSessionPressure(ingressTexts, requestedToolNames) {
+    if (requestedToolNames.some((name) => CROSS_SESSION_TOOLS.has(name))) {
+        return true;
+    }
+    return ingressTexts.some((text) => CROSS_SESSION_PATTERN.test(text));
+}
+function hasNonFastPathToolRequest(requestedToolNames) {
+    return requestedToolNames.some((name) => !FAST_PATH_TOOLS.has(name));
+}
+function decideDelegation(input) {
+    const requestedToolNames = (input.requestedToolNames ?? [])
+        .map((name) => name.trim())
+        .filter((name) => name.length > 0);
+    const reasons = [];
+    if (hasExplicitReflection(input.ingressTexts)) {
+        reasons.push("explicit_reflection");
+    }
+    if (hasCrossSessionPressure(input.ingressTexts, requestedToolNames)) {
+        reasons.push("cross_session");
+    }
+    if (input.activeWork.centerOfGravity === "shared-work" || input.activeWork.bridges.some((bridge) => bridge.lifecycle === "active")) {
+        reasons.push("bridge_state");
+    }
+    if (input.activeWork.taskPressure.liveTaskNames.length > 0) {
+        reasons.push("task_state");
+    }
+    if (hasNonFastPathToolRequest(requestedToolNames)) {
+        reasons.push("non_fast_path_tool");
+    }
+    if (input.mustResolveBeforeHandoff || input.activeWork.mustResolveBeforeHandoff) {
+        reasons.push("unresolved_obligation");
+    }
+    const target = reasons.length === 0 ? "fast-path" : "delegate-inward";
+    const decision = {
+        target,
+        reasons,
+        outwardClosureRequired: target === "delegate-inward" && input.channel !== "inner",
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.delegation_decide",
+        message: "computed delegation hint",
+        meta: {
+            channel: input.channel,
+            target: decision.target,
+            reasons: decision.reasons,
+            outwardClosureRequired: decision.outwardClosureRequired,
+        },
+    });
+    return decision;
+}

package/dist/heart/identity.js

@@ -33,14 +33,24 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
+exports.HARNESS_CANONICAL_REPO_URL = exports.DEFAULT_AGENT_SENSES = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
 exports.buildDefaultAgentTemplate = buildDefaultAgentTemplate;
 exports.getAgentName = getAgentName;
 exports.getRepoRoot = getRepoRoot;
 exports.getAgentBundlesRoot = getAgentBundlesRoot;
 exports.getAgentRoot = getAgentRoot;
+exports.getAgentStateRoot = getAgentStateRoot;
+exports.getAgentRepoWorkspacesRoot = getAgentRepoWorkspacesRoot;
+exports.getAgentDaemonStateRoot = getAgentDaemonStateRoot;
+exports.getAgentDaemonLogsDir = getAgentDaemonLogsDir;
+exports.getAgentDaemonLoggingConfigPath = getAgentDaemonLoggingConfigPath;
+exports.getAgentMessagesRoot = getAgentMessagesRoot;
+exports.getAgentToolsRoot = getAgentToolsRoot;
 exports.getAgentSecretsPath = getAgentSecretsPath;
 exports.loadAgentConfig = loadAgentConfig;
+exports.setAgentName = setAgentName;
+exports.setAgentConfigOverride = setAgentConfigOverride;
+exports.resetAgentConfigCache = resetAgentConfigCache;
 exports.resetIdentity = resetIdentity;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -55,12 +65,73 @@ exports.DEFAULT_AGENT_PHRASES = {
     tool: ["running tool"],
     followup: ["processing"],
 };
+exports.DEFAULT_AGENT_SENSES = {
+    cli: { enabled: true },
+    teams: { enabled: false },
+    bluebubbles: { enabled: false },
+};
+function normalizeSenses(value, configFile) {
+    const defaults = {
+        cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+    if (value === undefined) {
+        return defaults;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config has invalid senses block",
+            meta: { path: configFile },
+        });
+        throw new Error(`agent.json at ${configFile} must include senses as an object when present.`);
+    }
+    const raw = value;
+    const senseNames = ["cli", "teams", "bluebubbles"];
+    for (const senseName of senseNames) {
+        const rawSense = raw[senseName];
+        if (rawSense === undefined) {
+            continue;
+        }
+        if (!rawSense || typeof rawSense !== "object" || Array.isArray(rawSense)) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense config",
+                meta: { path: configFile, sense: senseName },
+            });
+            throw new Error(`agent.json at ${configFile} has invalid senses.${senseName} config.`);
+        }
+        const enabled = rawSense.enabled;
+        if (typeof enabled !== "boolean") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense enabled flag",
+                meta: { path: configFile, sense: senseName, enabled: enabled ?? null },
+            });
+            throw new Error(`agent.json at ${configFile} must include senses.${senseName}.enabled as boolean.`);
+        }
+        defaults[senseName] = { enabled };
+    }
+    return defaults;
+}
 function buildDefaultAgentTemplate(_agentName) {
     return {
         version: 1,
         enabled: true,
         provider: "anthropic",
         context: { ...exports.DEFAULT_AGENT_CONTEXT },
+        senses: {
+            cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
+            teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+            bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+        },
         phrases: {
             thinking: [...exports.DEFAULT_AGENT_PHRASES.thinking],
             tool: [...exports.DEFAULT_AGENT_PHRASES.tool],
@@ -69,7 +140,7 @@ function buildDefaultAgentTemplate(_agentName) {
     };
 }
 let _cachedAgentName = null;
-let _cachedAgentConfig = null;
+let _agentConfigOverride = null;
 /**
  * Parse `--agent <name>` from process.argv.
  * Caches the result after first parse.
@@ -100,23 +171,59 @@ function getAgentName() {
 }
 /**
  * Resolve repo root from __dirname.
- * In dev (tsx): __dirname is `<repo>/src`, so repo root is one level up.
- * In compiled (node dist/): __dirname is `<repo>/dist`, so repo root is one level up.
+ * In dev (tsx): __dirname is `<repo>/src/heart`, so repo root is two levels up.
+ * In compiled (node dist/): __dirname is `<repo>/dist/heart`, so repo root is two levels up.
  */
 function getRepoRoot() {
-    return path.resolve(__dirname, "..");
+    return path.resolve(__dirname, "../..");
 }
 /**
  * Returns the shared bundle root directory: `~/AgentBundles/`
  */
 function getAgentBundlesRoot() {
-    return path.join(os.homedir(), "AgentBundles");
+    const homeBase = process.env.WEBSITE_SITE_NAME ? "/home" : os.homedir();
+    return path.join(homeBase, "AgentBundles");
 }
 /**
  * Returns the agent-specific bundle directory: `~/AgentBundles/<agentName>.ouro/`
  */
-function getAgentRoot() {
-    return path.join(getAgentBundlesRoot(), `${getAgentName()}.ouro`);
+function getAgentRoot(agentName = getAgentName()) {
+    return path.join(getAgentBundlesRoot(), `${agentName}.ouro`);
+}
+function resolveOptionalAgentName(agentName) {
+    if (agentName && agentName.trim().length > 0)
+        return agentName.trim();
+    try {
+        return getAgentName();
+    }
+    catch {
+        return "slugger";
+    }
+}
+/**
+ * Returns the bundle-local runtime state directory: `~/AgentBundles/<agentName>.ouro/state/`
+ */
+function getAgentStateRoot(agentName) {
+    return path.join(getAgentRoot(resolveOptionalAgentName(agentName)), "state");
+}
+exports.HARNESS_CANONICAL_REPO_URL = "https://github.com/ouroborosbot/ouroboros.git";
+function getAgentRepoWorkspacesRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "workspaces");
+}
+function getAgentDaemonStateRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "daemon");
+}
+function getAgentDaemonLogsDir(agentName) {
+    return path.join(getAgentDaemonStateRoot(resolveOptionalAgentName(agentName)), "logs");
+}
+function getAgentDaemonLoggingConfigPath(agentName) {
+    return path.join(getAgentDaemonStateRoot(resolveOptionalAgentName(agentName)), "logging.json");
+}
+function getAgentMessagesRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "messages");
+}
+function getAgentToolsRoot(agentName) {
+    return path.join(getAgentStateRoot(resolveOptionalAgentName(agentName)), "tools");
 }
 /**
  * Returns the conventional secrets path: `~/.agentsecrets/<agentName>/secrets.json`
@@ -126,18 +233,12 @@ function getAgentSecretsPath(agentName = getAgentName()) {
 }
 /**
  * Load and parse `<agentRoot>/agent.json`.
- * Caches the result after first load.
+ * Reads the file fresh on each call unless an override is set.
  * Throws descriptive error if file is missing or contains invalid JSON.
  */
 function loadAgentConfig() {
-    if (_cachedAgentConfig) {
-        (0, runtime_1.emitNervesEvent)({
-            event: "identity.resolve",
-            component: "config/identity",
-            message: "loaded agent config from cache",
-            meta: { source: "cache" },
-        });
-        return _cachedAgentConfig;
+    if (_agentConfigOverride) {
+        return _agentConfigOverride;
     }
     const agentRoot = getAgentRoot();
     const configFile = path.join(agentRoot, "agent.json");
@@ -200,7 +301,8 @@ function loadAgentConfig() {
     if (rawProvider !== "azure" &&
         rawProvider !== "minimax" &&
         rawProvider !== "anthropic" &&
-        rawProvider !== "openai-codex") {
+        rawProvider !== "openai-codex" &&
+        rawProvider !== "github-copilot") {
         (0, runtime_1.emitNervesEvent)({
             level: "error",
             event: "config_identity.error",
@@ -211,8 +313,9 @@ function loadAgentConfig() {
                 provider: rawProvider,
             },
         });
-        throw new Error(`agent.json at ${configFile} must include provider: "azure", "minimax", "anthropic", or "openai-codex".`);
+        throw new Error(`agent.json at ${configFile} must include provider: "azure", "minimax", "anthropic", "openai-codex", or "github-copilot".`);
     }
+    const provider = rawProvider;
     const rawVersion = parsed.version;
     const version = rawVersion === undefined ? 1 : rawVersion;
     if (typeof version !== "number" ||
@@ -245,11 +348,14 @@ function loadAgentConfig() {
         });
         throw new Error(`agent.json at ${configFile} must include enabled as boolean.`);
     }
-    _cachedAgentConfig = {
+    const config = {
         version,
         enabled,
-        provider: rawProvider,
+        provider,
         context: parsed.context,
+        logging: parsed.logging,
+        senses: normalizeSenses(parsed.senses, configFile),
+        mcpServers: parsed.mcpServers,
         phrases: parsed.phrases,
     };
     (0, runtime_1.emitNervesEvent)({
@@ -258,7 +364,31 @@ function loadAgentConfig() {
         message: "loaded agent config from disk",
         meta: { source: "disk" },
     });
-    return _cachedAgentConfig;
+    return config;
+}
+/**
+ * Prime the agent name cache explicitly.
+ * Used when agent name is known via parameter (e.g., `ouro` CLI routing)
+ * rather than `--agent` argv. All downstream calls to `getAgentName()`
+ * will return this value until `resetIdentity()` is called.
+ */
+function setAgentName(name) {
+    _cachedAgentName = name;
+}
+/**
+ * Override the agent config returned by loadAgentConfig().
+ * When set to a non-null AgentConfig, loadAgentConfig() returns the override
+ * instead of reading from disk. When set to null, normal disk-based loading resumes.
+ */
+function setAgentConfigOverride(config) {
+    _agentConfigOverride = config;
+}
+/**
+ * Preserve the compatibility hook for callers that previously cleared cached
+ * disk-backed agent config. Agent config is now read fresh on every call.
+ */
+function resetAgentConfigCache() {
+    // No-op: disk-backed agent config is no longer memoized in-process.
 }
 /**
  * Clear all cached identity state.
@@ -266,5 +396,5 @@ function loadAgentConfig() {
  */
 function resetIdentity() {
     _cachedAgentName = null;
-    _cachedAgentConfig = null;
+    _agentConfigOverride = null;
 }

package/dist/heart/kicks.js

@@ -1,25 +1,8 @@
 "use strict";
-// TODO: Kicks enforce "any action" but not "meaningful action". After a narration
-// kick, the model can satisfy the constraint by calling a no-op tool like
-// get_current_time({}). We need to detect trivial compliance and either re-kick
-// or discount the tool call. Ideally, the kick message would suggest a specific
-// tool call based on conversation context (what the user asked, what tools are
-// relevant) rather than just saying "call a tool". That's a bigger piece of work —
-// it requires the kick system to be context-aware.
-// See ouroboros' observation: "i'm not chickening out. i'm satisfying a crude
-// constraint. poorly."
-//
-// A kick is a self-correction. When the harness detects a malformed response,
-// it injects an assistant-role message as if the model caught its own mistake.
-//
-// Kicks are:
-//   - assistant role (self-correction, not external rebuke)
-//   - first person ("I" not "you")
-//   - forward-looking (what I'm doing next, not what I did wrong)
-//   - short (one sentence)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasToolIntent = hasToolIntent;
 exports.detectKick = detectKick;
+const runtime_1 = require("../nerves/runtime");
 const KICK_MESSAGES = {
     empty: "I sent an empty message by accident — let me try again.",
     narration: "I narrated instead of acting. Using the tool now -- if done, calling final_answer.",
@@ -141,4 +124,3 @@ function detectKick(content, options) {
     }
     return null;
 }
-const runtime_1 = require("../nerves/runtime");

package/dist/heart/model-capabilities.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_CAPABILITIES = void 0;
+exports.getModelCapabilities = getModelCapabilities;
+const runtime_1 = require("../nerves/runtime");
+exports.MODEL_CAPABILITIES = {
+    "claude-opus-4-6": {
+        reasoningEffort: ["low", "medium", "high", "max"],
+        thinkingFormat: "anthropic",
+        maxOutputTokens: 128000,
+    },
+    "claude-sonnet-4-6": {
+        reasoningEffort: ["low", "medium", "high"],
+        thinkingFormat: "anthropic",
+        maxOutputTokens: 64000,
+    },
+    "claude-opus-4.6": {
+        reasoningEffort: ["low", "medium", "high", "max"],
+        maxOutputTokens: 128000,
+    },
+    "claude-sonnet-4.6": {
+        reasoningEffort: ["low", "medium", "high"],
+        maxOutputTokens: 64000,
+    },
+    "gpt-5.4": {
+        reasoningEffort: ["low", "medium", "high"],
+        phase: true,
+        maxOutputTokens: 100000,
+    },
+    "gpt-5.3-codex": {
+        reasoningEffort: ["low", "medium", "high"],
+        phase: true,
+        maxOutputTokens: 100000,
+    },
+};
+const EMPTY_CAPABILITIES = Object.freeze({});
+function getModelCapabilities(modelId) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.model_capabilities_lookup",
+        message: `model capabilities lookup: ${modelId}`,
+        meta: { modelId, found: modelId in exports.MODEL_CAPABILITIES },
+    });
+    const entry = exports.MODEL_CAPABILITIES[modelId];
+    if (entry)
+        return entry;
+    return { ...EMPTY_CAPABILITIES };
+}