@intent-systems/nexus 2026.1.5-3

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

@@ -0,0 +1,626 @@
+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 { 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 { 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 formatPath = (value) => shortenHomePath(value);
+const activeAgentId = DEFAULT_AGENT_ID;
+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) => {
+    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 lines = [];
+    lines.push(`elevated is not available right now (runtime=${params.runtimeSandboxed ? "sandboxed" : "direct"}).`);
+    const failures = params.failures ?? [];
+    if (failures.length > 0) {
+        lines.push(`Failing gates: ${failures.map((f) => `${f.gate} (${f.key})`).join(", ")}`);
+    }
+    else {
+        lines.push("Fix-it keys: tools.elevated.enabled, tools.elevated.allowFrom.<provider>, agents.list[].tools.elevated.*");
+    }
+    if (params.sessionKey) {
+        lines.push(`See: nexus sandbox explain --session ${params.sessionKey}`);
+    }
+    return lines.join("\n");
+}
+const maskApiKey = (value) => {
+    const trimmed = (value ?? "").trim();
+    if (!trimmed)
+        return "stored";
+    if (trimmed.length <= 16)
+        return trimmed;
+    return `${trimmed.slice(0, 8)}...${trimmed.slice(-8)}`;
+};
+const resolveAuthLabel = async (provider, cfg, modelsPath) => {
+    const formatPath = (value) => shortenHomePath(value);
+    const store = ensureAuthProfileStore();
+    const order = resolveAuthProfileOrder({ cfg, store, provider });
+    if (order.length > 0) {
+        const labels = order.map((profileId) => {
+            const profile = store.profiles[profileId];
+            const configProfile = cfg.auth?.profiles?.[profileId];
+            if (!profile ||
+                (configProfile?.provider &&
+                    configProfile.provider !== profile.provider) ||
+                (configProfile?.mode && configProfile.mode !== profile.type)) {
+                return `${profileId}=missing`;
+            }
+            if (profile.type === "api_key") {
+                return `${profileId}=${maskApiKey(profile.key)}`;
+            }
+            const display = resolveAuthProfileDisplayLabel({
+                cfg,
+                store,
+                profileId,
+            });
+            const suffix = display === profileId
+                ? ""
+                : display.startsWith(profileId)
+                    ? display.slice(profileId.length).trim()
+                    : `(${display})`;
+            return `${profileId}=OAuth${suffix ? ` ${suffix}` : ""}`;
+        });
+        return {
+            label: labels.join(", "),
+            source: `credentials index: ${formatPath(resolveAuthStorePathForDisplay())}`,
+        };
+    }
+    const envKey = resolveEnvApiKey(provider);
+    if (envKey) {
+        const isOAuthEnv = envKey.source.includes("ANTHROPIC_OAUTH_TOKEN") ||
+            envKey.source.toLowerCase().includes("oauth");
+        const label = isOAuthEnv ? "OAuth (env)" : maskApiKey(envKey.apiKey);
+        return { label, source: envKey.source };
+    }
+    const customKey = getCustomProviderApiKey(cfg, provider);
+    if (customKey) {
+        return {
+            label: maskApiKey(customKey),
+            source: `models.json: ${formatPath(modelsPath)}`,
+        };
+    }
+    return { label: "missing", source: "missing" };
+};
+const formatAuthLabel = (auth) => {
+    if (!auth.source || auth.source === auth.label || auth.source === "missing") {
+        return auth.label;
+    }
+    return `${auth.label} (${auth.source})`;
+};
+const resolveProfileOverride = (params) => {
+    const raw = params.rawProfile?.trim();
+    if (!raw)
+        return {};
+    const store = ensureAuthProfileStore();
+    const profile = store.profiles[raw];
+    if (!profile) {
+        return { error: `Auth profile "${raw}" not found.` };
+    }
+    if (profile.provider !== params.provider) {
+        return {
+            error: `Auth profile "${raw}" is for ${profile.provider}, not ${params.provider}.`,
+        };
+    }
+    return { profileId: raw };
+};
+const MODEL_PICK_PROVIDER_PREFERENCE = [
+    "anthropic",
+    "openai",
+    "openai-codex",
+    "minimax",
+    "google",
+    "zai",
+    "openrouter",
+    "opencode",
+    "github-copilot",
+    "groq",
+    "cerebras",
+    "mistral",
+    "xai",
+    "lmstudio",
+];
+function normalizeModelFamilyId(id) {
+    const trimmed = id.trim();
+    if (!trimmed)
+        return trimmed;
+    const parts = trimmed.split("/").filter(Boolean);
+    return parts.length > 0 ? (parts[parts.length - 1] ?? trimmed) : trimmed;
+}
+function sortProvidersForPicker(providers) {
+    const pref = new Map(MODEL_PICK_PROVIDER_PREFERENCE.map((provider, idx) => [provider, idx]));
+    return providers.sort((a, b) => {
+        const pa = pref.get(a);
+        const pb = pref.get(b);
+        if (pa !== undefined && pb !== undefined)
+            return pa - pb;
+        if (pa !== undefined)
+            return -1;
+        if (pb !== undefined)
+            return 1;
+        return a.localeCompare(b);
+    });
+}
+function buildModelPickerItems(catalog) {
+    const byModel = new Map();
+    for (const entry of catalog) {
+        const provider = normalizeProviderId(entry.provider);
+        const model = normalizeModelFamilyId(entry.id);
+        if (!provider || !model)
+            continue;
+        const existing = byModel.get(model);
+        if (existing) {
+            existing.providerModels[provider] = entry.id;
+            continue;
+        }
+        byModel.set(model, { providerModels: { [provider]: entry.id } });
+    }
+    const out = [];
+    for (const [model, data] of byModel.entries()) {
+        const providers = sortProvidersForPicker(Object.keys(data.providerModels));
+        out.push({ model, providers, providerModels: data.providerModels });
+    }
+    out.sort((a, b) => a.model.toLowerCase().localeCompare(b.model.toLowerCase()));
+    return out;
+}
+function pickProviderForModel(params) {
+    const preferred = params.preferredProvider
+        ? normalizeProviderId(params.preferredProvider)
+        : undefined;
+    if (preferred && params.item.providerModels[preferred]) {
+        return {
+            provider: preferred,
+            model: params.item.providerModels[preferred],
+        };
+    }
+    const first = params.item.providers[0];
+    if (!first)
+        return null;
+    return {
+        provider: first,
+        model: params.item.providerModels[first] ?? params.item.model,
+    };
+}
+function resolveProviderEndpointLabel(provider, cfg) {
+    const normalized = normalizeProviderId(provider);
+    const providers = (cfg.models?.providers ?? {});
+    const entry = providers[normalized];
+    const endpoint = entry?.baseUrl?.trim();
+    const api = entry?.api?.trim();
+    return {
+        endpoint: endpoint || undefined,
+        api: api || undefined,
+    };
+}
+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: elevatedCleaned, elevatedLevel, rawLevel: rawElevatedLevel, hasDirective: hasElevatedDirective, } = extractElevatedDirective(verboseCleaned);
+    const { cleaned: statusCleaned, hasDirective: hasStatusDirective } = extractStatusDirective(elevatedCleaned);
+    const { cleaned: modelCleaned, rawModel, rawProfile, hasDirective: hasModelDirective, } = extractModelDirective(statusCleaned);
+    const { cleaned: queueCleaned, queueMode, queueReset, rawMode, debounceMs, cap, dropPolicy, rawDebounce, rawCap, rawDrop, hasDirective: hasQueueDirective, hasOptions: hasQueueOptions, } = extractQueueDirective(modelCleaned);
+    return {
+        cleaned: queueCleaned,
+        hasThinkDirective,
+        thinkLevel,
+        rawThinkLevel,
+        hasVerboseDirective,
+        verboseLevel,
+        rawVerboseLevel,
+        hasElevatedDirective,
+        elevatedLevel,
+        rawElevatedLevel,
+        hasStatusDirective,
+        hasModelDirective,
+        rawModelDirective: rawModel,
+        rawModelProfile: rawProfile,
+        hasQueueDirective,
+        queueMode,
+        queueReset,
+        rawQueueMode: rawMode,
+        debounceMs,
+        cap,
+        dropPolicy,
+        rawDebounce,
+        rawCap,
+        rawDrop,
+        hasQueueOptions,
+    };
+}
+export function isDirectiveOnly(params) {
+    const { directives, cleanedBody, ctx, cfg, isGroup } = params;
+    if (!directives.hasThinkDirective &&
+        !directives.hasVerboseDirective &&
+        !directives.hasElevatedDirective &&
+        !directives.hasModelDirective &&
+        !directives.hasQueueDirective)
+        return false;
+    const stripped = stripStructuralPrefixes(cleanedBody ?? "");
+    const noMentions = isGroup ? stripMentions(stripped, ctx, cfg) : stripped;
+    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;
+    if (directives.hasModelDirective) {
+        const modelDirective = directives.rawModelDirective?.trim().toLowerCase();
+        const isModelListAlias = modelDirective === "status" || modelDirective === "list";
+        if (!directives.rawModelDirective || isModelListAlias) {
+            if (allowedModelCatalog.length === 0) {
+                return { text: "No models available." };
+            }
+            const agentDir = resolveNexusAgentDir();
+            const modelsPath = `${agentDir}/models.json`;
+            const authByProvider = 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));
+            }
+            const current = `${params.provider}/${params.model}`;
+            const defaultLabel = `${defaultProvider}/${defaultModel}`;
+            const lines = [
+                `Current: ${current}`,
+                `Default: ${defaultLabel}`,
+                `Agent: ${activeAgentId}`,
+                `Auth file: ${formatPath(resolveAuthStorePathForDisplay())}`,
+            ];
+            if (resetModelOverride) {
+                lines.push(`(previous selection reset to default)`);
+            }
+            for (const entry of allowedModelCatalog) {
+                const label = `${entry.provider}/${entry.id}`;
+                const aliases = aliasIndex.byKey.get(label);
+                const aliasSuffix = aliases && aliases.length > 0
+                    ? ` (alias: ${aliases.join(", ")})`
+                    : "";
+                const nameSuffix = entry.name && entry.name !== entry.id ? ` — ${entry.name}` : "";
+                const authLabel = authByProvider.get(entry.provider) ?? "missing";
+                const authSuffix = ` — auth: ${authLabel}`;
+                lines.push(`- ${label}${aliasSuffix}${nameSuffix}${authSuffix}`);
+            }
+            return { text: lines.join("\n") };
+        }
+        if (directives.rawModelProfile && !modelDirective) {
+            throw new Error("Auth profile override requires a model selection.");
+        }
+    }
+    if (directives.hasThinkDirective && !directives.thinkLevel) {
+        return {
+            text: `Unrecognized thinking level "${directives.rawThinkLevel ?? ""}". Valid levels: off, minimal, low, medium, high.`,
+        };
+    }
+    if (directives.hasVerboseDirective && !directives.verboseLevel) {
+        return {
+            text: `Unrecognized verbose level "${directives.rawVerboseLevel ?? ""}". Valid levels: off, on.`,
+        };
+    }
+    if (directives.hasElevatedDirective && !directives.elevatedLevel) {
+        return {
+            text: `Unrecognized elevated level "${directives.rawElevatedLevel ?? ""}". Valid levels: off, on.`,
+        };
+    }
+    if (directives.hasElevatedDirective &&
+        (!elevatedEnabled || !elevatedAllowed)) {
+        return { text: "elevated is not available right now." };
+    }
+    const queueModeInvalid = directives.hasQueueDirective &&
+        !directives.queueMode &&
+        !directives.queueReset &&
+        Boolean(directives.rawQueueMode);
+    const queueDebounceInvalid = directives.hasQueueDirective &&
+        directives.rawDebounce !== undefined &&
+        typeof directives.debounceMs !== "number";
+    const queueCapInvalid = directives.hasQueueDirective &&
+        directives.rawCap !== undefined &&
+        typeof directives.cap !== "number";
+    const queueDropInvalid = directives.hasQueueDirective &&
+        directives.rawDrop !== undefined &&
+        !directives.dropPolicy;
+    if (queueModeInvalid ||
+        queueDebounceInvalid ||
+        queueCapInvalid ||
+        queueDropInvalid) {
+        const errors = [];
+        if (queueModeInvalid) {
+            errors.push(`Unrecognized queue mode "${directives.rawQueueMode ?? ""}". Valid modes: steer, followup, collect, steer+backlog, interrupt.`);
+        }
+        if (queueDebounceInvalid) {
+            errors.push(`Invalid debounce "${directives.rawDebounce ?? ""}". Use ms/s/m (e.g. debounce:1500ms, debounce:2s).`);
+        }
+        if (queueCapInvalid) {
+            errors.push(`Invalid cap "${directives.rawCap ?? ""}". Use a positive integer (e.g. cap:10).`);
+        }
+        if (queueDropInvalid) {
+            errors.push(`Invalid drop policy "${directives.rawDrop ?? ""}". Use drop:old, drop:new, or drop:summarize.`);
+        }
+        return { text: errors.join(" ") };
+    }
+    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 };
+        }
+        modelSelection = resolved.selection;
+        if (modelSelection) {
+            if (directives.rawModelProfile) {
+                const profileResolved = resolveProfileOverride({
+                    rawProfile: directives.rawModelProfile,
+                    provider: modelSelection.provider,
+                    cfg: params.cfg,
+                });
+                if (profileResolved.error) {
+                    return { text: profileResolved.error };
+                }
+                profileOverride = profileResolved.profileId;
+            }
+            const nextLabel = `${modelSelection.provider}/${modelSelection.model}`;
+            if (nextLabel !== initialModelLabel) {
+                enqueueSystemEvent(formatModelSwitchEvent(nextLabel, modelSelection.alias), {
+                    contextKey: `model:${nextLabel}`,
+                });
+            }
+        }
+    }
+    if (directives.rawModelProfile && !modelSelection) {
+        return { text: "Auth profile override requires a model selection." };
+    }
+    if (sessionEntry && sessionStore && sessionKey) {
+        if (directives.hasThinkDirective && directives.thinkLevel) {
+            if (directives.thinkLevel === "off")
+                delete sessionEntry.thinkingLevel;
+            else
+                sessionEntry.thinkingLevel = directives.thinkLevel;
+        }
+        if (directives.hasVerboseDirective && directives.verboseLevel) {
+            if (directives.verboseLevel === "off")
+                delete sessionEntry.verboseLevel;
+            else
+                sessionEntry.verboseLevel = directives.verboseLevel;
+        }
+        if (directives.hasElevatedDirective && directives.elevatedLevel) {
+            if (directives.elevatedLevel === "off")
+                delete sessionEntry.elevatedLevel;
+            else
+                sessionEntry.elevatedLevel = directives.elevatedLevel;
+        }
+        if (modelSelection) {
+            if (modelSelection.isDefault) {
+                delete sessionEntry.providerOverride;
+                delete sessionEntry.modelOverride;
+            }
+            else {
+                sessionEntry.providerOverride = modelSelection.provider;
+                sessionEntry.modelOverride = modelSelection.model;
+            }
+            if (profileOverride) {
+                sessionEntry.authProfileOverride = profileOverride;
+            }
+            else if (directives.hasModelDirective) {
+                delete sessionEntry.authProfileOverride;
+            }
+        }
+        if (directives.hasQueueDirective && directives.queueReset) {
+            delete sessionEntry.queueMode;
+            delete sessionEntry.queueDebounceMs;
+            delete sessionEntry.queueCap;
+            delete sessionEntry.queueDrop;
+        }
+        else if (directives.hasQueueDirective) {
+            if (directives.queueMode)
+                sessionEntry.queueMode = directives.queueMode;
+            if (typeof directives.debounceMs === "number") {
+                sessionEntry.queueDebounceMs = directives.debounceMs;
+            }
+            if (typeof directives.cap === "number") {
+                sessionEntry.queueCap = directives.cap;
+            }
+            if (directives.dropPolicy) {
+                sessionEntry.queueDrop = directives.dropPolicy;
+            }
+        }
+        sessionEntry.updatedAt = Date.now();
+        sessionStore[sessionKey] = sessionEntry;
+        if (storePath) {
+            await saveSessionStore(storePath, sessionStore);
+        }
+    }
+    const parts = [];
+    if (directives.hasThinkDirective && directives.thinkLevel) {
+        parts.push(directives.thinkLevel === "off"
+            ? "Thinking disabled."
+            : `Thinking level set to ${directives.thinkLevel}.`);
+    }
+    if (directives.hasVerboseDirective && directives.verboseLevel) {
+        parts.push(directives.verboseLevel === "off"
+            ? `${SYSTEM_MARK} Verbose logging disabled.`
+            : `${SYSTEM_MARK} Verbose logging enabled.`);
+    }
+    if (directives.hasElevatedDirective && directives.elevatedLevel) {
+        parts.push(directives.elevatedLevel === "off"
+            ? `${SYSTEM_MARK} Elevated mode disabled.`
+            : `${SYSTEM_MARK} Elevated mode enabled.`);
+    }
+    if (modelSelection) {
+        const label = `${modelSelection.provider}/${modelSelection.model}`;
+        const labelWithAlias = modelSelection.alias
+            ? `${modelSelection.alias} (${label})`
+            : label;
+        parts.push(modelSelection.isDefault
+            ? `Model reset to default (${labelWithAlias}).`
+            : `Model set to ${labelWithAlias}.`);
+        if (profileOverride) {
+            parts.push(`Auth profile set to ${profileOverride}.`);
+        }
+    }
+    if (directives.hasQueueDirective && directives.queueMode) {
+        parts.push(`${SYSTEM_MARK} Queue mode set to ${directives.queueMode}.`);
+    }
+    else if (directives.hasQueueDirective && directives.queueReset) {
+        parts.push(`${SYSTEM_MARK} Queue mode reset to default.`);
+    }
+    if (directives.hasQueueDirective &&
+        typeof directives.debounceMs === "number") {
+        parts.push(`${SYSTEM_MARK} Queue debounce set to ${directives.debounceMs}ms.`);
+    }
+    if (directives.hasQueueDirective && typeof directives.cap === "number") {
+        parts.push(`${SYSTEM_MARK} Queue cap set to ${directives.cap}.`);
+    }
+    if (directives.hasQueueDirective && directives.dropPolicy) {
+        parts.push(`${SYSTEM_MARK} Queue drop set to ${directives.dropPolicy}.`);
+    }
+    const ack = parts.join(" ").trim();
+    return { text: ack || "OK." };
+}
+export async function persistInlineDirectives(params) {
+    const { directives, cfg, sessionEntry, sessionStore, sessionKey, storePath, elevatedEnabled, elevatedAllowed, defaultProvider, defaultModel, aliasIndex, allowedModelKeys, initialModelLabel, formatModelSwitchEvent, agentCfg, } = params;
+    let { provider, model } = params;
+    if (sessionEntry && sessionStore && sessionKey) {
+        let updated = false;
+        if (directives.hasThinkDirective && directives.thinkLevel) {
+            if (directives.thinkLevel === "off") {
+                delete sessionEntry.thinkingLevel;
+            }
+            else {
+                sessionEntry.thinkingLevel = directives.thinkLevel;
+            }
+            updated = true;
+        }
+        if (directives.hasVerboseDirective && directives.verboseLevel) {
+            if (directives.verboseLevel === "off") {
+                delete sessionEntry.verboseLevel;
+            }
+            else {
+                sessionEntry.verboseLevel = directives.verboseLevel;
+            }
+            updated = true;
+        }
+        if (directives.hasElevatedDirective &&
+            directives.elevatedLevel &&
+            elevatedEnabled &&
+            elevatedAllowed) {
+            if (directives.elevatedLevel === "off") {
+                delete sessionEntry.elevatedLevel;
+            }
+            else {
+                sessionEntry.elevatedLevel = directives.elevatedLevel;
+            }
+            updated = true;
+        }
+        const modelDirective = directives.hasModelDirective && params.effectiveModelDirective
+            ? params.effectiveModelDirective
+            : undefined;
+        if (modelDirective) {
+            const resolved = resolveModelRefFromString({
+                raw: modelDirective,
+                defaultProvider,
+                aliasIndex,
+            });
+            if (resolved) {
+                const key = modelKey(resolved.ref.provider, resolved.ref.model);
+                if (allowedModelKeys.size === 0 || allowedModelKeys.has(key)) {
+                    let profileOverride;
+                    if (directives.rawModelProfile) {
+                        const profileResolved = resolveProfileOverride({
+                            rawProfile: directives.rawModelProfile,
+                            provider: resolved.ref.provider,
+                            cfg,
+                        });
+                        if (profileResolved.error) {
+                            throw new Error(profileResolved.error);
+                        }
+                        profileOverride = profileResolved.profileId;
+                    }
+                    const isDefault = resolved.ref.provider === defaultProvider &&
+                        resolved.ref.model === defaultModel;
+                    if (isDefault) {
+                        delete sessionEntry.providerOverride;
+                        delete sessionEntry.modelOverride;
+                    }
+                    else {
+                        sessionEntry.providerOverride = resolved.ref.provider;
+                        sessionEntry.modelOverride = resolved.ref.model;
+                    }
+                    if (profileOverride) {
+                        sessionEntry.authProfileOverride = profileOverride;
+                    }
+                    else if (directives.hasModelDirective) {
+                        delete sessionEntry.authProfileOverride;
+                    }
+                    provider = resolved.ref.provider;
+                    model = resolved.ref.model;
+                    const nextLabel = `${provider}/${model}`;
+                    if (nextLabel !== initialModelLabel) {
+                        enqueueSystemEvent(formatModelSwitchEvent(nextLabel, resolved.alias), {
+                            contextKey: `model:${nextLabel}`,
+                        });
+                    }
+                    updated = true;
+                }
+            }
+        }
+        if (directives.hasQueueDirective && directives.queueReset) {
+            delete sessionEntry.queueMode;
+            delete sessionEntry.queueDebounceMs;
+            delete sessionEntry.queueCap;
+            delete sessionEntry.queueDrop;
+            updated = true;
+        }
+        if (updated) {
+            sessionEntry.updatedAt = Date.now();
+            sessionStore[sessionKey] = sessionEntry;
+            if (storePath) {
+                await saveSessionStore(storePath, sessionStore);
+            }
+        }
+    }
+    return {
+        provider,
+        model,
+        contextTokens: agentCfg?.contextTokens ??
+            lookupContextTokens(model) ??
+            DEFAULT_CONTEXT_TOKENS,
+    };
+}
+export function resolveDefaultModel(params) {
+    const mainModel = resolveConfiguredModelRef({
+        cfg: params.cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const defaultProvider = mainModel.provider;
+    const defaultModel = mainModel.model;
+    const aliasIndex = buildModelAliasIndex({
+        cfg: params.cfg,
+        defaultProvider,
+    });
+    return { defaultProvider, defaultModel, aliasIndex };
+}

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

@@ -0,0 +1,59 @@
+import { normalizeElevatedLevel, 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 thinkLevel = normalizeThinkLevel(match?.[1]);
+    const cleaned = match
+        ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+        : body.trim();
+    return {
+        cleaned,
+        thinkLevel,
+        rawLevel: match?.[1],
+        hasDirective: !!match,
+    };
+}
+export function extractVerboseDirective(body) {
+    if (!body)
+        return { cleaned: "", hasDirective: false };
+    const match = body.match(/(?:^|\s)\/(?:verbose|v)(?=$|\s|:)\s*:?\s*([a-zA-Z-]+)\b/i);
+    const verboseLevel = normalizeVerboseLevel(match?.[1]);
+    const cleaned = match
+        ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+        : body.trim();
+    return {
+        cleaned,
+        verboseLevel,
+        rawLevel: match?.[1],
+        hasDirective: !!match,
+    };
+}
+export function extractElevatedDirective(body) {
+    if (!body)
+        return { cleaned: "", hasDirective: false };
+    const match = body.match(/(?:^|\s)\/(?:elevated|elev)(?=$|\s|:)\s*:?\s*([a-zA-Z-]+)\b/i);
+    const elevatedLevel = normalizeElevatedLevel(match?.[1]);
+    const cleaned = match
+        ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+        : body.trim();
+    return {
+        cleaned,
+        elevatedLevel,
+        rawLevel: match?.[1],
+        hasDirective: !!match,
+    };
+}
+export function extractStatusDirective(body) {
+    if (!body)
+        return { cleaned: "", hasDirective: false };
+    const match = body.match(/(?:^|\s)\/status(?=$|\s|:)\b/i);
+    const cleaned = match
+        ? body.replace(match[0], "").replace(/\s+/g, " ").trim()
+        : body.trim();
+    return {
+        cleaned,
+        hasDirective: !!match,
+    };
+}