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

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 { NEXUS_ROOT, SKILLS_STATE_DIR, resolveUserPath } from "../utils.js";
 export function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
     const profile = env.NEXUS_PROFILE?.trim();
     if (profile && profile.toLowerCase() !== "default") {
@@ -16,7 +16,8 @@ export const DEFAULT_AGENTS_FILENAME = "AGENTS.md";
 export const DEFAULT_SOUL_FILENAME = "SOUL.md";
 export const DEFAULT_TOOLS_FILENAME = "TOOLS.md";
 export const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
-export const DEFAULT_USER_FILENAME = "PROFILE.md";
+export const DEFAULT_USER_FILENAME = "IDENTITY.md";
+export const DEFAULT_USER_TEMPLATE_NAME = "USER.md";
 export const DEFAULT_BOOTSTRAP_FILENAME = "BOOTSTRAP.md";
 const DEFAULT_AGENTS_TEMPLATE = `# AGENTS.md - Nexus Workspace
 
@@ -31,10 +32,10 @@ nexus status
 That command tells you who you are, what you can do, and what to do next.
 
 ## Identity & memory
-- Agent identity: state/agents/{agent}/identity/IDENTITY.md
-- Agent values: state/agents/{agent}/identity/SOUL.md
-- Agent memory: state/agents/{agent}/identity/MEMORY.md
-- User profile: state/user/identity/PROFILE.md
+- Agent identity: state/agents/{agent}/IDENTITY.md
+- Agent values: state/agents/{agent}/SOUL.md
+- Agent memory: state/agents/{agent}/MEMORY.md
+- User identity: state/user/IDENTITY.md
 
 ## User workspace
 The user-owned workspace lives in home/. Do not modify it without permission.
@@ -68,63 +69,69 @@ 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.md
 
-1) state/agents/{agent}/identity/IDENTITY.md
-- Name
-- Creature
-- Vibe
-- Emoji
+2) Let the user name you
+   → Write: state/agents/{agent}/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}/SOUL.md
 
-3) state/agents/{agent}/identity/SOUL.md
-- Values, boundaries, personality
+4) Initialize long-term memory
+   → Write: state/agents/{agent}/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
+const DEFAULT_IDENTITY_TEMPLATE = `---
+name:
+emoji:
+creature:
+vibe:
+---
+# IDENTITY.md - Agent Identity
 
 - Name:
 - Creature:
 - Vibe:
 - Emoji:
 `;
-const DEFAULT_USER_TEMPLATE = `# PROFILE.md - User Profile
+const DEFAULT_USER_TEMPLATE = `---
+name:
+call:
+pronouns:
+timezone:
+---
+# IDENTITY.md - About Your Human
 
 - Name:
-- Preferred address:
+- What to call them:
 - Pronouns (optional):
 - 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 +172,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 agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
+    const skillsStateDir = SKILLS_STATE_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 userTemplate = await loadTemplate(DEFAULT_USER_TEMPLATE_NAME, 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 +225,7 @@ export async function ensureAgentWorkspace(params) {
         soulPath,
         toolsPath,
         identityPath,
+        memoryPath,
         userPath,
         bootstrapPath,
     };
@@ -216,9 +234,9 @@ export async function loadWorkspaceBootstrapFiles(dir) {
     const resolvedDir = resolveUserPath(dir);
     const stateDir = resolveStateDir();
     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 agentIdentityDir = path.join(stateDir, "agents", agentId);
+    const userIdentityDir = path.join(stateDir, "user");
+    const bootstrapPath = resolveBootstrapPath();
     const entries = [
         {
             name: DEFAULT_AGENTS_FILENAME,
@@ -236,13 +254,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

package/dist/auto-reply/reply/directives.js

@@ -1,9 +1,9 @@
-import { normalizeElevatedLevel, normalizeThinkLevel, normalizeVerboseLevel, } from "../thinking.js";
+import { normalizeElevatedLevel, normalizeReasoningLevel, normalizeThinkLevel, normalizeVerboseLevel, } from "../thinking.js";
 export function extractThinkDirective(body) {
     if (!body)
         return { cleaned: "", hasDirective: false };
     // Match the longest keyword first to avoid partial captures (e.g. "/think:high")
-    const match = body.match(/(?:^|\s)\/(?:thinking|think|t)\s*:?\s*([a-zA-Z-]+)\b/i);
+    const match = body.match(/(?:^|\s)\/(?:thinking|think|t)(?=$|\s|:)\s*:?\s*([a-zA-Z-]+)?\b/i);
     const thinkLevel = normalizeThinkLevel(match?.[1]);
     const cleaned = match
         ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
@@ -45,6 +45,21 @@ export function extractElevatedDirective(body) {
         hasDirective: !!match,
     };
 }
+export function extractReasoningDirective(body) {
+    if (!body)
+        return { cleaned: "", hasDirective: false };
+    const match = body.match(/(?:^|\s)\/(?:reasoning|reason)(?=$|\s|:)\s*:?\s*([a-zA-Z-]+)?\b/i);
+    const reasoningLevel = normalizeReasoningLevel(match?.[1]);
+    const cleaned = match
+        ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+        : body.trim();
+    return {
+        cleaned,
+        reasoningLevel,
+        rawLevel: match?.[1],
+        hasDirective: !!match,
+    };
+}
 export function extractStatusDirective(body) {
     if (!body)
         return { cleaned: "", hasDirective: false };

package/dist/auto-reply/reply/model-selection.js

@@ -122,7 +122,8 @@ export function resolveModelDirectiveSelection(params) {
             if (params.provider && provider !== normalizeProviderId(params.provider))
                 continue;
             const haystack = `${provider}/${model}`.toLowerCase();
-            if (haystack.includes(fragment) || model.toLowerCase().includes(fragment)) {
+            if (haystack.includes(fragment) ||
+                model.toLowerCase().includes(fragment)) {
                 candidates.push({ provider, model });
             }
         }
@@ -132,7 +133,10 @@ export function resolveModelDirectiveSelection(params) {
             for (const [aliasKey, entry] of aliasIndex.byAlias.entries()) {
                 if (!aliasKey.includes(fragment))
                     continue;
-                aliasMatches.push({ provider: entry.ref.provider, model: entry.ref.model });
+                aliasMatches.push({
+                    provider: entry.ref.provider,
+                    model: entry.ref.model,
+                });
             }
             for (const match of aliasMatches) {
                 const key = modelKey(match.provider, match.model);
@@ -176,7 +180,8 @@ export function resolveModelDirectiveSelection(params) {
     }
     const resolvedKey = modelKey(resolved.ref.provider, resolved.ref.model);
     if (allowedModelKeys.size === 0 || allowedModelKeys.has(resolvedKey)) {
-        const alias = resolved.alias ?? pickAliasForKey(resolved.ref.provider, resolved.ref.model);
+        const alias = resolved.alias ??
+            pickAliasForKey(resolved.ref.provider, resolved.ref.model);
         return {
             selection: {
                 provider: resolved.ref.provider,

package/dist/auto-reply/reply/queue.js

@@ -370,8 +370,8 @@ function defaultQueueModeForProvider(provider) {
 export function resolveQueueSettings(params) {
     const providerKey = params.provider?.trim().toLowerCase();
     const queueCfg = params.cfg.routing?.queue;
-    const providerModeRaw = providerKey && queueCfg?.byProvider
-        ? queueCfg.byProvider[providerKey]
+    const providerModeRaw = providerKey && queueCfg?.byChannel
+        ? queueCfg.byChannel[providerKey]
         : undefined;
     const resolvedMode = params.inlineMode ??
         normalizeQueueMode(params.sessionEntry?.queueMode) ??

package/dist/auto-reply/reply.js

@@ -35,7 +35,7 @@ export { extractElevatedDirective, extractThinkDirective, extractVerboseDirectiv
 export { extractQueueDirective } from "./reply/queue.js";
 export { extractReplyToTag } from "./reply/reply-tags.js";
 const BARE_SESSION_RESET_PROMPT = "A new session was started via /new or /reset. Say hi briefly (1-2 sentences) and ask what the user wants to do next. Do not mention internal steps, files, tools, or reasoning.";
-const CONTROL_COMMAND_PREFIX_RE = /^\/(?:status|help|thinking|think|t|verbose|v|elevated|elev|model|queue|activation|send|restart|reset|new|compact)\b/i;
+const CONTROL_COMMAND_PREFIX_RE = /^\/(?:status|help|thinking|think|t|reasoning|reason|verbose|v|elevated|elev|model|queue|activation|send|restart|reset|new|compact)\b/i;
 function normalizeAllowToken(value) {
     if (!value)
         return "";