@intent-systems/nexus 2026.1.5-4 → 2026.1.5-5

package/dist/agents/tools/image-tool.js

@@ -1,18 +1,92 @@
 import { complete, } from "@mariozechner/pi-ai";
 import { discoverAuthStorage, discoverModels, } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
+import { listCredentialEntriesSync } from "../../credentials/store.js";
 import { resolveUserPath } from "../../utils.js";
 import { loadWebMedia } from "../../web/media.js";
-import { getApiKeyForModel } from "../model-auth.js";
+import { DEFAULT_PROVIDER } from "../defaults.js";
+import { getApiKeyForModel, getCustomProviderApiKey, resolveEnvApiKey, } from "../model-auth.js";
 import { runWithImageModelFallback } from "../model-fallback.js";
+import { normalizeProviderId, parseModelRef } from "../model-selection.js";
 import { ensureNexusModelsJson } from "../models-config.js";
 import { extractAssistantText } from "../pi-embedded-utils.js";
 const DEFAULT_PROMPT = "Describe the image.";
-function ensureImageToolConfigured(cfg) {
-    const imageModel = cfg?.agent?.imageModel;
-    const primary = typeof imageModel === "string" ? imageModel.trim() : imageModel?.primary;
-    const fallbacks = typeof imageModel === "object" ? (imageModel?.fallbacks ?? []) : [];
-    return Boolean(primary?.trim() || fallbacks.length > 0);
+const DEFAULT_IMAGE_MODELS = {
+    minimax: "minimax-vl-01",
+    openai: "gpt-5-mini",
+    anthropic: "claude-opus-4-5",
+};
+function normalizeImageModelConfig(value) {
+    if (typeof value === "string") {
+        const primary = value.trim();
+        return primary ? { primary } : null;
+    }
+    if (!value || typeof value !== "object")
+        return null;
+    const primary = typeof value.primary === "string" ? value.primary.trim() : "";
+    const fallbacks = Array.isArray(value.fallbacks)
+        ? value.fallbacks.map((raw) => String(raw ?? "").trim()).filter(Boolean)
+        : [];
+    if (!primary && fallbacks.length === 0)
+        return null;
+    return fallbacks.length > 0 ? { primary, fallbacks } : { primary };
+}
+function hasAuthForProvider(provider, cfg) {
+    const normalized = normalizeProviderId(provider);
+    if (resolveEnvApiKey(normalized))
+        return true;
+    if (getCustomProviderApiKey(cfg, normalized))
+        return true;
+    const entries = listCredentialEntriesSync();
+    return entries.some((entry) => normalizeProviderId(entry.service) === normalized);
+}
+function resolveImageModelFromConfig(cfg, provider) {
+    const providers = cfg?.models?.providers ?? {};
+    const entry = providers[provider];
+    for (const model of entry?.models ?? []) {
+        if (!model?.id)
+            continue;
+        if (Array.isArray(model.input) && model.input.includes("image")) {
+            return model.id;
+        }
+    }
+    return null;
+}
+export function resolveImageModelConfigForTool(params) {
+    void params.agentDir;
+    const explicit = normalizeImageModelConfig(params.cfg?.agent?.imageModel);
+    if (explicit)
+        return explicit;
+    const rawPrimary = typeof params.cfg?.agent?.model === "string"
+        ? params.cfg?.agent?.model
+        : params.cfg?.agent?.model?.primary;
+    if (!rawPrimary?.trim())
+        return null;
+    const parsed = parseModelRef(rawPrimary, DEFAULT_PROVIDER);
+    if (!parsed)
+        return null;
+    const provider = normalizeProviderId(parsed.provider);
+    const configImageModel = resolveImageModelFromConfig(params.cfg, provider);
+    const mapped = DEFAULT_IMAGE_MODELS[provider];
+    const primaryModelId = configImageModel ?? mapped;
+    if (!primaryModelId)
+        return null;
+    if (!hasAuthForProvider(provider, params.cfg))
+        return null;
+    const fallbacks = [];
+    for (const fallbackProvider of ["openai", "anthropic"]) {
+        if (fallbackProvider === provider)
+            continue;
+        const fallbackModelId = DEFAULT_IMAGE_MODELS[fallbackProvider];
+        if (!fallbackModelId)
+            continue;
+        if (hasAuthForProvider(fallbackProvider, params.cfg)) {
+            fallbacks.push(`${fallbackProvider}/${fallbackModelId}`);
+        }
+    }
+    return fallbacks.length > 0
+        ? { primary: `${provider}/${primaryModelId}`, fallbacks }
+        : { primary: `${provider}/${primaryModelId}` };
 }
 function pickMaxBytes(cfg, maxBytesMb) {
     if (typeof maxBytesMb === "number" &&
@@ -80,12 +154,23 @@ async function runImagePrompt(params) {
     };
 }
 export function createImageTool(options) {
-    if (!ensureImageToolConfigured(options?.config))
+    const resolvedConfig = resolveImageModelConfigForTool({
+        cfg: options?.config,
+        agentDir: options?.agentDir,
+    });
+    if (!resolvedConfig)
         return null;
     const agentDir = options?.agentDir;
     if (!agentDir?.trim()) {
         throw new Error("createImageTool requires agentDir when enabled");
     }
+    const cfgWithImageModel = (() => {
+        const cfg = options?.config ?? {};
+        const agent = cfg.agent ?? {};
+        if (normalizeImageModelConfig(agent.imageModel))
+            return cfg;
+        return { ...cfg, agent: { ...agent, imageModel: resolvedConfig } };
+    })();
     return {
         label: "Image",
         name: "image",
@@ -121,7 +206,7 @@ export function createImageTool(options) {
             const mimeType = media.contentType ?? "image/png";
             const base64 = media.buffer.toString("base64");
             const result = await runImagePrompt({
-                cfg: options?.config,
+                cfg: cfgWithImageModel,
                 agentDir,
                 modelOverride,
                 prompt: promptRaw,

package/dist/agents/tools/sessions-announce-target.js

@@ -20,7 +20,11 @@ export async function resolveAnnounceTarget(params) {
         const sessions = Array.isArray(list?.sessions) ? list.sessions : [];
         const match = sessions.find((entry) => entry?.key === params.sessionKey) ??
             sessions.find((entry) => entry?.key === params.displayKey);
-        const provider = typeof match?.lastProvider === "string" ? match.lastProvider : undefined;
+        const provider = typeof match?.lastChannel === "string"
+            ? match.lastChannel
+            : typeof match?.lastProvider === "string"
+                ? match.lastProvider
+                : undefined;
         const to = typeof match?.lastTo === "string" ? match.lastTo : undefined;
         const accountId = typeof match?.lastAccountId === "string"
             ? match.lastAccountId

package/dist/agents/workspace.js

@@ -2,8 +2,8 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolveStateDir } from "../config/paths.js";
-import { NEXUS_ROOT, resolveUserPath } from "../utils.js";
+import { resolveBootstrapPath, resolveStateDir } from "../config/paths.js";
+import { MANAGED_SKILLS_DIR, NEXUS_ROOT, resolveUserPath } from "../utils.js";
 export function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
     const profile = env.NEXUS_PROFILE?.trim();
     if (profile && profile.toLowerCase() !== "default") {
@@ -68,47 +68,36 @@ It does not define which tools exist; Nexus provides built-in tools internally.
 
 Add whatever else you want the assistant to know about your local toolchain.
 `;
-const DEFAULT_BOOTSTRAP_TEMPLATE = `# BOOTSTRAP.md - First Run Ritual
+const DEFAULT_BOOTSTRAP_TEMPLATE = `# BOOTSTRAP.md - Welcome to Nexus
 
-Hello. I was just born.
+This workspace needs identity setup before agents can help.
 
-## Your mission
-Start a short, playful conversation and learn:
-- Who am I?
-- What am I?
-- Who are you?
-- How should I call you?
+## For humans
+Start a short conversation with your AI assistant. Share:
+- Your name (and how you'd like to be addressed)
+- What you're hoping to accomplish with AI
+- Any preferences for tone, boundaries, or style
 
-## How to ask (cute + helpful)
-Say:
-"Hello! I was just born. Who am I? What am I? Who are you? How should I call you?"
+The agent will write identity files as you chat (takes ~5 min).
 
-Then offer suggestions:
-- 3-5 name ideas.
-- 3-5 creature/vibe combos.
-- 5 emoji ideas.
+## For agents
+You are beginning the bootstrap conversation. Goals:
 
-## Write these files
-After the user chooses, update:
+1) Learn the user's name
+   → Write: state/user/identity/PROFILE.md
 
-1) state/agents/{agent}/identity/IDENTITY.md
-- Name
-- Creature
-- Vibe
-- Emoji
+2) Let the user name you
+   → Write: state/agents/{agent}/identity/IDENTITY.md
 
-2) state/user/identity/PROFILE.md
-- Name
-- Preferred address
-- Pronouns (optional)
-- Timezone (optional)
-- Notes
+3) Define personality and boundaries
+   → Write: state/agents/{agent}/identity/SOUL.md
 
-3) state/agents/{agent}/identity/SOUL.md
-- Values, boundaries, personality
+4) Initialize long-term memory
+   → Write: state/agents/{agent}/identity/MEMORY.md
 
-4) state/nexus/config.json
-Set identity.name, identity.theme, identity.emoji to match IDENTITY.md.
+Be warm, curious, and conversational. Don't rush a checklist.
+
+When complete, run \`nexus status\` to show what's unlocked.
 `;
 const DEFAULT_IDENTITY_TEMPLATE = `# IDENTITY.md - Agent Identity
 
@@ -125,6 +114,11 @@ const DEFAULT_USER_TEMPLATE = `# PROFILE.md - User Profile
 - Timezone (optional):
 - Notes:
 `;
+const DEFAULT_MEMORY_TEMPLATE = `# MEMORY.md - Long-Term Memory
+
+This file stores distilled, long-term insights about the user and context.
+Keep it concise and updated as you learn important facts.
+`;
 const TEMPLATE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../docs/templates");
 function stripFrontMatter(content) {
     if (!content.startsWith("---"))
@@ -165,42 +159,52 @@ export async function ensureAgentWorkspace(params) {
         ? params.dir.trim()
         : DEFAULT_AGENT_WORKSPACE_DIR;
     const dir = resolveUserPath(rawDir);
+    const createHomeLayout = params?.createHomeLayout ?? false;
     await fs.mkdir(dir, { recursive: true });
-    await fs.mkdir(path.join(dir, "memory"), { recursive: true });
-    await fs.mkdir(path.join(dir, "projects"), { recursive: true });
+    if (createHomeLayout) {
+        await fs.mkdir(path.join(dir, "memory"), { recursive: true });
+        await fs.mkdir(path.join(dir, "projects"), { recursive: true });
+    }
+    await fs.mkdir(NEXUS_ROOT, { recursive: true });
     const stateDir = resolveStateDir();
     const nexusStateDir = path.join(stateDir, "nexus");
     const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
     const agentIdentityDir = path.join(stateDir, "agents", agentId, "identity");
     const userIdentityDir = path.join(stateDir, "user", "identity");
-    const skillsStateDir = path.join(nexusStateDir, "skills");
-    const onboardingDir = path.join(nexusStateDir, "onboarding");
+    const skillsStateDir = MANAGED_SKILLS_DIR;
     const credentialsDir = path.join(stateDir, "credentials");
     await fs.mkdir(nexusStateDir, { recursive: true });
     await fs.mkdir(agentIdentityDir, { recursive: true });
     await fs.mkdir(userIdentityDir, { recursive: true });
     await fs.mkdir(skillsStateDir, { recursive: true });
-    await fs.mkdir(onboardingDir, { recursive: true });
     await fs.mkdir(credentialsDir, { recursive: true });
     const agentsPath = path.join(NEXUS_ROOT, DEFAULT_AGENTS_FILENAME);
     const soulPath = path.join(agentIdentityDir, DEFAULT_SOUL_FILENAME);
     const toolsPath = path.join(dir, DEFAULT_TOOLS_FILENAME);
     const identityPath = path.join(agentIdentityDir, DEFAULT_IDENTITY_FILENAME);
+    const memoryPath = path.join(agentIdentityDir, "MEMORY.md");
     const userPath = path.join(userIdentityDir, DEFAULT_USER_FILENAME);
-    const bootstrapPath = path.join(onboardingDir, DEFAULT_BOOTSTRAP_FILENAME);
+    const bootstrapPath = resolveBootstrapPath();
     const agentsTemplate = await loadTemplate(DEFAULT_AGENTS_FILENAME, DEFAULT_AGENTS_TEMPLATE);
     await writeFileIfMissing(agentsPath, agentsTemplate);
     if (params?.ensureBootstrapFiles) {
+        const bootstrapMode = params.bootstrapMode ?? "full";
         const soulTemplate = await loadTemplate(DEFAULT_SOUL_FILENAME, DEFAULT_SOUL_TEMPLATE);
         const toolsTemplate = await loadTemplate(DEFAULT_TOOLS_FILENAME, DEFAULT_TOOLS_TEMPLATE);
         const identityTemplate = await loadTemplate(DEFAULT_IDENTITY_FILENAME, DEFAULT_IDENTITY_TEMPLATE);
         const userTemplate = await loadTemplate(DEFAULT_USER_FILENAME, DEFAULT_USER_TEMPLATE);
+        const memoryTemplate = DEFAULT_MEMORY_TEMPLATE;
         const bootstrapTemplate = await loadTemplate(DEFAULT_BOOTSTRAP_FILENAME, DEFAULT_BOOTSTRAP_TEMPLATE);
-        await writeFileIfMissing(soulPath, soulTemplate);
-        await writeFileIfMissing(toolsPath, toolsTemplate);
-        await writeFileIfMissing(identityPath, identityTemplate);
-        await writeFileIfMissing(userPath, userTemplate);
+        if (createHomeLayout) {
+            await writeFileIfMissing(toolsPath, toolsTemplate);
+        }
         await writeFileIfMissing(bootstrapPath, bootstrapTemplate);
+        await writeFileIfMissing(soulPath, soulTemplate);
+        if (bootstrapMode === "full") {
+            await writeFileIfMissing(identityPath, identityTemplate);
+            await writeFileIfMissing(memoryPath, memoryTemplate);
+            await writeFileIfMissing(userPath, userTemplate);
+        }
     }
     return {
         dir,
@@ -208,6 +212,7 @@ export async function ensureAgentWorkspace(params) {
         soulPath,
         toolsPath,
         identityPath,
+        memoryPath,
         userPath,
         bootstrapPath,
     };
@@ -218,7 +223,7 @@ export async function loadWorkspaceBootstrapFiles(dir) {
     const agentId = process.env.NEXUS_AGENT_ID?.trim() || "default";
     const agentIdentityDir = path.join(stateDir, "agents", agentId, "identity");
     const userIdentityDir = path.join(stateDir, "user", "identity");
-    const onboardingDir = path.join(stateDir, "nexus", "onboarding");
+    const bootstrapPath = resolveBootstrapPath();
     const entries = [
         {
             name: DEFAULT_AGENTS_FILENAME,
@@ -236,13 +241,17 @@ export async function loadWorkspaceBootstrapFiles(dir) {
             name: DEFAULT_IDENTITY_FILENAME,
             filePath: path.join(agentIdentityDir, DEFAULT_IDENTITY_FILENAME),
         },
+        {
+            name: "MEMORY.md",
+            filePath: path.join(agentIdentityDir, "MEMORY.md"),
+        },
         {
             name: DEFAULT_USER_FILENAME,
             filePath: path.join(userIdentityDir, DEFAULT_USER_FILENAME),
         },
         {
             name: DEFAULT_BOOTSTRAP_FILENAME,
-            filePath: path.join(onboardingDir, DEFAULT_BOOTSTRAP_FILENAME),
+            filePath: bootstrapPath,
         },
     ];
     const result = [];

package/dist/auto-reply/command-detection.js

@@ -1,10 +1,11 @@
-const CONTROL_COMMAND_RE = /(?:^|\s)\/(?:status|help|thinking|think|t|verbose|v|elevated|elev|model|queue|activation|send|restart|reset|new|compact)(?=$|\s|:)\b/i;
+const CONTROL_COMMAND_RE = /(?:^|\s)\/(?:status|help|thinking|think|t|reasoning|reason|verbose|v|elevated|elev|model|queue|activation|send|restart|reset|new|compact)(?=$|\s|:)\b/i;
 const CONTROL_COMMAND_EXACT = new Set([
     "/help",
     "/status",
     "/restart",
     "/activation",
     "/send",
+    "/reasoning",
     "/reset",
     "/new",
     "/compact",

package/dist/auto-reply/reply/directive-handling.js

@@ -1,35 +1,45 @@
+import { resolveNexusAgentDir } from "../../agents/agent-paths.js";
+import { loadModelCatalog } from "../../agents/model-catalog.js";
 import { resolveAuthProfileDisplayLabel, resolveAuthStorePathForDisplay, } from "../../agents/auth-profiles.js";
 import { lookupContextTokens } from "../../agents/context.js";
 import { DEFAULT_CONTEXT_TOKENS, DEFAULT_MODEL, DEFAULT_PROVIDER, } from "../../agents/defaults.js";
 import { ensureAuthProfileStore, getCustomProviderApiKey, resolveAuthProfileOrder, resolveEnvApiKey, } from "../../agents/model-auth.js";
-import { buildModelAliasIndex, modelKey, normalizeProviderId, resolveConfiguredModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
-import { resolveNexusAgentDir } from "../../agents/agent-paths.js";
+import { buildModelAliasIndex, modelKey, normalizeProviderId, resolveConfiguredModelRef, resolveModelRefFromString, resolveThinkingDefault, } from "../../agents/model-selection.js";
 import { saveSessionStore } from "../../config/sessions.js";
 import { enqueueSystemEvent } from "../../infra/system-events.js";
 import { DEFAULT_AGENT_ID } from "../../routing/session-key.js";
 import { shortenHomePath } from "../../utils.js";
 import { extractModelDirective } from "../model.js";
-import { extractElevatedDirective, extractStatusDirective, extractThinkDirective, extractVerboseDirective, } from "./directives.js";
+import { extractElevatedDirective, extractReasoningDirective, extractStatusDirective, extractThinkDirective, extractVerboseDirective, } from "./directives.js";
 import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
 import { resolveModelDirectiveSelection, } from "./model-selection.js";
 import { extractQueueDirective, } from "./queue.js";
 const SYSTEM_MARK = "⚙️";
 const formatOptionsLine = (options) => `Options: ${options}.`;
-const withOptions = (line, options) => `${line}\n${formatOptionsLine(options)}`;
-const formatElevatedRuntimeHint = () => `${SYSTEM_MARK} Runtime is direct; sandboxing does not apply.`;
+const _withOptions = (line, options) => `${line}\n${formatOptionsLine(options)}`;
+const _formatElevatedRuntimeHint = () => `${SYSTEM_MARK} Runtime is direct; sandboxing does not apply.`;
 const formatPath = (value) => shortenHomePath(value);
 const activeAgentId = DEFAULT_AGENT_ID;
-const formatElevatedEvent = (level) => level === "on"
+const _formatElevatedEvent = (level) => level === "on"
     ? "Elevated ON — exec runs on host; set elevated:false to stay sandboxed."
     : "Elevated OFF — exec stays in sandbox.";
-const formatReasoningEvent = (level) => {
+const _formatReasoningEvent = (level) => {
     if (level === "stream")
         return "Reasoning STREAM — emit live <think>.";
     if (level === "on")
         return "Reasoning ON — include <think>.";
     return "Reasoning OFF — hide <think>.";
 };
-function formatElevatedUnavailableText(params) {
+const _formatListWithOr = (items) => {
+    if (items.length === 0)
+        return "";
+    if (items.length === 1)
+        return items[0] ?? "";
+    if (items.length === 2)
+        return `${items[0]} or ${items[1]}`;
+    return `${items.slice(0, -1).join(", ")} or ${items[items.length - 1]}`;
+};
+function _formatElevatedUnavailableText(params) {
     const lines = [];
     lines.push(`elevated is not available right now (runtime=${params.runtimeSandboxed ? "sandboxed" : "direct"}).`);
     const failures = params.failures ?? [];
@@ -140,6 +150,15 @@ const MODEL_PICK_PROVIDER_PREFERENCE = [
     "xai",
     "lmstudio",
 ];
+const XHIGH_THINKING_MODELS = [
+    "openai/gpt-5.2",
+    "openai-codex/gpt-5.2-codex",
+    "openai-codex/gpt-5.1-codex",
+];
+function isXhighThinkingAllowed(provider, model) {
+    const key = `${normalizeProviderId(provider)}/${model}`;
+    return XHIGH_THINKING_MODELS.includes(key);
+}
 function normalizeModelFamilyId(id) {
     const trimmed = id.trim();
     if (!trimmed)
@@ -161,7 +180,7 @@ function sortProvidersForPicker(providers) {
         return a.localeCompare(b);
     });
 }
-function buildModelPickerItems(catalog) {
+function _buildModelPickerItems(catalog) {
     const byModel = new Map();
     for (const entry of catalog) {
         const provider = normalizeProviderId(entry.provider);
@@ -183,7 +202,7 @@ function buildModelPickerItems(catalog) {
     out.sort((a, b) => a.model.toLowerCase().localeCompare(b.model.toLowerCase()));
     return out;
 }
-function pickProviderForModel(params) {
+function _pickProviderForModel(params) {
     const preferred = params.preferredProvider
         ? normalizeProviderId(params.preferredProvider)
         : undefined;
@@ -201,7 +220,7 @@ function pickProviderForModel(params) {
         model: params.item.providerModels[first] ?? params.item.model,
     };
 }
-function resolveProviderEndpointLabel(provider, cfg) {
+function _resolveProviderEndpointLabel(provider, cfg) {
     const normalized = normalizeProviderId(provider);
     const providers = (cfg.models?.providers ?? {});
     const entry = providers[normalized];
@@ -214,7 +233,8 @@ function resolveProviderEndpointLabel(provider, cfg) {
 }
 export function parseInlineDirectives(body) {
     const { cleaned: thinkCleaned, thinkLevel, rawLevel: rawThinkLevel, hasDirective: hasThinkDirective, } = extractThinkDirective(body);
-    const { cleaned: verboseCleaned, verboseLevel, rawLevel: rawVerboseLevel, hasDirective: hasVerboseDirective, } = extractVerboseDirective(thinkCleaned);
+    const { cleaned: reasoningCleaned, reasoningLevel, rawLevel: rawReasoningLevel, hasDirective: hasReasoningDirective, } = extractReasoningDirective(thinkCleaned);
+    const { cleaned: verboseCleaned, verboseLevel, rawLevel: rawVerboseLevel, hasDirective: hasVerboseDirective, } = extractVerboseDirective(reasoningCleaned);
     const { cleaned: elevatedCleaned, elevatedLevel, rawLevel: rawElevatedLevel, hasDirective: hasElevatedDirective, } = extractElevatedDirective(verboseCleaned);
     const { cleaned: statusCleaned, hasDirective: hasStatusDirective } = extractStatusDirective(elevatedCleaned);
     const { cleaned: modelCleaned, rawModel, rawProfile, hasDirective: hasModelDirective, } = extractModelDirective(statusCleaned);
@@ -224,6 +244,9 @@ export function parseInlineDirectives(body) {
         hasThinkDirective,
         thinkLevel,
         rawThinkLevel,
+        hasReasoningDirective,
+        reasoningLevel,
+        rawReasoningLevel,
         hasVerboseDirective,
         verboseLevel,
         rawVerboseLevel,
@@ -250,6 +273,7 @@ export function parseInlineDirectives(body) {
 export function isDirectiveOnly(params) {
     const { directives, cleanedBody, ctx, cfg, isGroup } = params;
     if (!directives.hasThinkDirective &&
+        !directives.hasReasoningDirective &&
         !directives.hasVerboseDirective &&
         !directives.hasElevatedDirective &&
         !directives.hasModelDirective &&
@@ -260,22 +284,37 @@ export function isDirectiveOnly(params) {
     return noMentions.length === 0;
 }
 export async function handleDirectiveOnly(params) {
-    const { directives, sessionEntry, sessionStore, sessionKey, storePath, elevatedEnabled, elevatedAllowed, defaultProvider, defaultModel, aliasIndex, allowedModelKeys, allowedModelCatalog, resetModelOverride, initialModelLabel, formatModelSwitchEvent, } = params;
+    const { directives, sessionEntry, sessionStore, sessionKey, storePath, elevatedEnabled, elevatedAllowed, defaultProvider, defaultModel, aliasIndex, allowedModelKeys, allowedModelCatalog, resetModelOverride, provider, model, initialModelLabel, formatModelSwitchEvent, } = params;
     if (directives.hasModelDirective) {
-        const modelDirective = directives.rawModelDirective?.trim().toLowerCase();
-        const isModelListAlias = modelDirective === "status" || modelDirective === "list";
-        if (!directives.rawModelDirective || isModelListAlias) {
+        const rawModelDirective = directives.rawModelDirective?.trim();
+        const modelDirective = rawModelDirective?.toLowerCase();
+        const isModelStatus = modelDirective === "status";
+        const isModelList = modelDirective === "list";
+        if (!rawModelDirective || isModelList) {
+            if (allowedModelCatalog.length === 0) {
+                return { text: "No models available." };
+            }
+            const items = _buildModelPickerItems(allowedModelCatalog);
+            const lines = ["Pick: /model <#> or /model <provider/model>"];
+            for (const [idx, item] of items.entries()) {
+                lines.push(`${idx + 1}) ${item.model} — ${item.providers.join(", ")}`);
+            }
+            return { text: lines.join("\n") };
+        }
+        if (isModelStatus) {
             if (allowedModelCatalog.length === 0) {
                 return { text: "No models available." };
             }
             const agentDir = resolveNexusAgentDir();
             const modelsPath = `${agentDir}/models.json`;
             const authByProvider = new Map();
+            const endpointByProvider = new Map();
             for (const entry of allowedModelCatalog) {
                 if (authByProvider.has(entry.provider))
                     continue;
                 const auth = await resolveAuthLabel(entry.provider, params.cfg, modelsPath);
                 authByProvider.set(entry.provider, formatAuthLabel(auth));
+                endpointByProvider.set(entry.provider, _resolveProviderEndpointLabel(entry.provider, params.cfg));
             }
             const current = `${params.provider}/${params.model}`;
             const defaultLabel = `${defaultProvider}/${defaultModel}`;
@@ -288,6 +327,16 @@ export async function handleDirectiveOnly(params) {
             if (resetModelOverride) {
                 lines.push(`(previous selection reset to default)`);
             }
+            const providers = Array.from(authByProvider.keys()).sort((a, b) => a.localeCompare(b));
+            for (const provider of providers) {
+                const authLabel = authByProvider.get(provider) ?? "missing";
+                const endpoint = endpointByProvider.get(provider);
+                const endpointSuffix = endpoint?.endpoint
+                    ? ` endpoint: ${endpoint.endpoint}`
+                    : "";
+                const apiSuffix = endpoint?.api ? ` api: ${endpoint.api}` : "";
+                lines.push(`[${provider}]${endpointSuffix}${apiSuffix} auth: ${authLabel}`);
+            }
             for (const entry of allowedModelCatalog) {
                 const label = `${entry.provider}/${entry.id}`;
                 const aliases = aliasIndex.byKey.get(label);
@@ -305,9 +354,41 @@ export async function handleDirectiveOnly(params) {
             throw new Error("Auth profile override requires a model selection.");
         }
     }
-    if (directives.hasThinkDirective && !directives.thinkLevel) {
+    if (directives.hasThinkDirective &&
+        directives.rawThinkLevel &&
+        !directives.thinkLevel) {
+        return {
+            text: `Unrecognized thinking level "${directives.rawThinkLevel ?? ""}". Valid levels: off, minimal, low, medium, high, xhigh.`,
+        };
+    }
+    if (directives.hasThinkDirective && !directives.rawThinkLevel) {
+        const catalog = allowedModelCatalog.length > 0
+            ? allowedModelCatalog
+            : await loadModelCatalog({ config: params.cfg });
+        const current = sessionEntry?.thinkingLevel ??
+            resolveThinkingDefault({
+                cfg: params.cfg,
+                provider,
+                model,
+                catalog,
+            });
+        const options = isXhighThinkingAllowed(provider, model)
+            ? "off, minimal, low, medium, high, xhigh"
+            : "off, minimal, low, medium, high";
+        return {
+            text: `Current thinking level: ${current}.\n${formatOptionsLine(options)}`,
+        };
+    }
+    if (directives.hasThinkDirective && directives.thinkLevel === "xhigh") {
+        if (!isXhighThinkingAllowed(provider, model)) {
+            return {
+                text: `Thinking level "xhigh" is only supported for ${_formatListWithOr(XHIGH_THINKING_MODELS)}.`,
+            };
+        }
+    }
+    if (directives.hasReasoningDirective && !directives.reasoningLevel) {
         return {
-            text: `Unrecognized thinking level "${directives.rawThinkLevel ?? ""}". Valid levels: off, minimal, low, medium, high.`,
+            text: `Unrecognized reasoning level "${directives.rawReasoningLevel ?? ""}". Valid levels: off, on, stream.`,
         };
     }
     if (directives.hasVerboseDirective && !directives.verboseLevel) {
@@ -359,17 +440,44 @@ export async function handleDirectiveOnly(params) {
     let modelSelection;
     let profileOverride;
     if (directives.hasModelDirective && directives.rawModelDirective) {
-        const resolved = resolveModelDirectiveSelection({
-            raw: directives.rawModelDirective,
-            defaultProvider,
-            defaultModel,
-            aliasIndex,
-            allowedModelKeys,
-        });
-        if (resolved.error) {
-            return { text: resolved.error };
+        const rawDirective = directives.rawModelDirective.trim();
+        const parsedIndex = Number.parseInt(rawDirective, 10);
+        if (Number.isFinite(parsedIndex) && String(parsedIndex) === rawDirective) {
+            const items = _buildModelPickerItems(allowedModelCatalog);
+            const item = items[parsedIndex - 1];
+            if (!item) {
+                return {
+                    text: `Unrecognized model "${rawDirective}". Use /model to list available models.`,
+                };
+            }
+            const picked = _pickProviderForModel({
+                item,
+                preferredProvider: provider,
+            });
+            if (picked) {
+                const alias = aliasIndex.byKey.get(modelKey(picked.provider, picked.model))?.[0];
+                modelSelection = {
+                    provider: picked.provider,
+                    model: picked.model,
+                    isDefault: picked.provider === defaultProvider &&
+                        picked.model === defaultModel,
+                    ...(alias ? { alias } : undefined),
+                };
+            }
+        }
+        if (!modelSelection) {
+            const resolved = resolveModelDirectiveSelection({
+                raw: rawDirective,
+                defaultProvider,
+                defaultModel,
+                aliasIndex,
+                allowedModelKeys,
+            });
+            if (resolved.error) {
+                return { text: resolved.error };
+            }
+            modelSelection = resolved.selection;
         }
-        modelSelection = resolved.selection;
         if (modelSelection) {
             if (directives.rawModelProfile) {
                 const profileResolved = resolveProfileOverride({
@@ -453,6 +561,20 @@ export async function handleDirectiveOnly(params) {
             await saveSessionStore(storePath, sessionStore);
         }
     }
+    if (directives.hasElevatedDirective && directives.elevatedLevel && sessionKey) {
+        enqueueSystemEvent(_formatElevatedEvent(directives.elevatedLevel), {
+            contextKey: `elevated:${directives.elevatedLevel}`,
+            sessionKey,
+        });
+    }
+    if (directives.hasReasoningDirective &&
+        directives.reasoningLevel &&
+        sessionKey) {
+        enqueueSystemEvent(_formatReasoningEvent(directives.reasoningLevel), {
+            contextKey: `reasoning:${directives.reasoningLevel}`,
+            sessionKey,
+        });
+    }
     const parts = [];
     if (directives.hasThinkDirective && directives.thinkLevel) {
         parts.push(directives.thinkLevel === "off"
@@ -469,6 +591,9 @@ export async function handleDirectiveOnly(params) {
             ? `${SYSTEM_MARK} Elevated mode disabled.`
             : `${SYSTEM_MARK} Elevated mode enabled.`);
     }
+    if (directives.hasReasoningDirective && directives.reasoningLevel) {
+        parts.push(`${SYSTEM_MARK} Reasoning ${directives.reasoningLevel.toUpperCase()}.`);
+    }
     if (modelSelection) {
         const label = `${modelSelection.provider}/${modelSelection.model}`;
         const labelWithAlias = modelSelection.alias