@otto-code/brain 0.8.8 → 0.8.10

package/dist/commands/bench.js

@@ -1,12 +1,14 @@
 /**
  * `otto brain bench` - score a model's agentic coding ability on this machine.
  * Either benchmarks an endpoint that is already serving (`--endpoint`) or loads
- * each requested model itself. A long streaming run, so it prints a formatted
- * report directly rather than going through the output layer.
+ * each requested model itself. Locally loaded runs use the router scheduler, so
+ * their requests receive the same profile system addendum as normal serving. A
+ * long streaming run, so it prints a formatted report directly rather than going
+ * through the output layer.
  */
 import http from "node:http";
 import path from "node:path";
-import { forModel, getCalibration, loadBrainConfig, loadProfilesStore } from "../config/index.js";
+import { forModel, getCalibration, loadBrainConfig, loadProfilesStore, resolveBrainPaths, } from "../config/index.js";
 import { query as queryGpu } from "../gpu.js";
 import { pickModel, scanModels } from "../models/index.js";
 import { CommandError } from "../output/types.js";
@@ -190,9 +192,21 @@ async function runBenchSuite(options, _command) {
             profile = fit.profile;
         }
         process.stdout.write(`\n${"=".repeat(74)}\n${model.displayName}\n${"=".repeat(74)}\n`);
-        const supervisor = new Supervisor({ runtime, internalPort: port });
+        const supervisor = new Supervisor({
+            runtime,
+            internalPort: port,
+            paths: resolveBrainPaths(),
+            getProfilesStore: () => store,
+        });
         const telemetry = new Telemetry();
-        const server = http.createServer(createRouter({ supervisor, telemetry, getCatalog: () => catalog }));
+        const server = http.createServer(createRouter({
+            supervisor,
+            telemetry,
+            getCatalog: () => catalog,
+            loadModel: async (target) => {
+                await supervisor.start(target, forModel(store, target, config.defaults));
+            },
+        }));
         await new Promise((resolve, reject) => {
             server.once("error", reject);
             server.listen(port + 1, "127.0.0.1", resolve);

package/dist/commands/catalog.d.ts

@@ -13,6 +13,7 @@ import type { AnyCommandResult, OutputSchema } from "../output/index.js";
 export interface CatalogRow {
     id: string;
     name: string;
+    family: string | null;
     installed: boolean;
     publisher: string;
     repo: string;

package/dist/commands/catalog.js

@@ -29,6 +29,7 @@ export async function runCatalogCommand(_options, _command) {
     const rows = catalog.models.map((model) => ({
         id: model.id,
         name: model.name,
+        family: model.family ?? null,
         installed: installedCatalogIds.has(model.id),
         publisher: model.publisher ?? "",
         repo: model.hfRepo,

package/dist/commands/pull.js

@@ -1,8 +1,9 @@
 import { loadBrainConfig, loadCatalog } from "../config/index.js";
-import { downloadRepoFiles, bundleDownloadPlan, listRepoQuants, managedModelsDir, pullModel, resolveHfToken, } from "../models/index.js";
+import { bundleDownloadPlan, listRepoQuants, managedModelsDir, pullModel, resolveHfToken, } from "../models/index.js";
 import { CommandError } from "../output/types.js";
 import { formatBytes } from "../models/scan.js";
 import { withActivity } from "../service/activity.js";
+import { downloadRepoFilesWithProgress } from "./repo-download.js";
 const pullSchema = {
     idField: "model",
     columns: [
@@ -67,30 +68,16 @@ export async function runPullCommand(modelArg, options, _command) {
             });
         }
         const plan = bundleDownloadPlan(model, options.component ?? [], choice?.files, choice?.sizeBytes);
-        let lastPct = -1;
-        const written = await withActivity("download", { target: model.name }, (activity) => downloadRepoFiles({
+        const progressLabel = `${model.name}${choice ? ` ${choice.quant}` : ""}`;
+        const written = await downloadRepoFilesWithProgress({
+            activityTarget: model.name,
+            progressLabel,
+            totalBytes: plan.totalBytes,
             repo: plan.repo,
             files: plan.files,
             destRoot: managedModelsDir(config),
             token,
-            onProgress: (progress) => {
-                activity.update(plan.totalBytes ? progress.receivedBytes / plan.totalBytes : null);
-                // The daemon owns the UI job record and only sees this child's
-                // stdout/stderr. Activity also feeds the host status, but emitting
-                // here is what keeps the Library's bundle progress ring live.
-                const pct = plan.totalBytes
-                    ? Math.floor((progress.receivedBytes / plan.totalBytes) * 100)
-                    : 0;
-                // Network chunks do not land exactly on 5% boundaries. Emit every
-                // new integer so the daemon receives continuous progress instead of
-                // often seeing only the initial and final updates.
-                if (pct > lastPct) {
-                    lastPct = pct;
-                    process.stderr.write(`  ${model.name}${choice ? ` ${choice.quant}` : ""}: ${pct}%\r`);
-                }
-            },
-        }));
-        process.stderr.write("\n");
+        });
         return {
             type: "single",
             data: {
@@ -130,22 +117,15 @@ export async function runPullCommand(modelArg, options, _command) {
         }
         const files = [...choice.files, ...(mmproj ? mmproj.files : [])];
         const total = choice.sizeBytes + (mmproj?.sizeBytes ?? 0);
-        let lastPct = -1;
-        const written = await withActivity("download", { target: `${model.name} (${choice.quant})` }, (activity) => downloadRepoFiles({
+        const written = await downloadRepoFilesWithProgress({
+            activityTarget: `${model.name} (${choice.quant})`,
+            progressLabel: `${model.name} ${choice.quant}`,
+            totalBytes: total,
             repo: model.hfRepo,
             files,
             destRoot: managedModelsDir(config),
             token,
-            onProgress: (p) => {
-                activity.update(total ? p.receivedBytes / total : null);
-                const pct = total ? Math.floor((p.receivedBytes / total) * 100) : 0;
-                if (pct > lastPct) {
-                    lastPct = pct;
-                    process.stderr.write(`  ${model.name} ${choice.quant}: ${pct}%\r`);
-                }
-            },
-        }));
-        process.stderr.write("\n");
+        });
         return {
             type: "single",
             data: {
@@ -177,6 +157,7 @@ export async function runPullCommand(modelArg, options, _command) {
             }
         },
     }));
+    process.stderr.write(`  ${model.name}: 100%\r`);
     process.stderr.write("\n");
     return {
         type: "single",

package/dist/commands/repo-download.d.ts

@@ -0,0 +1,14 @@
+/** Shared CLI progress and activity reporting for Hugging Face repo downloads. */
+import { type DownloadFilesOptions } from "../models/index.js";
+export interface RepoDownloadOptions extends DownloadFilesOptions {
+    activityTarget: string;
+    progressLabel: string;
+    totalBytes: number | null;
+}
+/**
+ * Download a repo selection while keeping the daemon job ring and host-status
+ * activity record in lockstep. Repository size metadata is advisory, so a
+ * successful transfer is the only authoritative completion signal.
+ */
+export declare function downloadRepoFilesWithProgress({ activityTarget, progressLabel, totalBytes, ...options }: RepoDownloadOptions): Promise<string[]>;
+//# sourceMappingURL=repo-download.d.ts.map

package/dist/commands/repo-download.js

@@ -0,0 +1,29 @@
+/** Shared CLI progress and activity reporting for Hugging Face repo downloads. */
+import { downloadRepoFiles, } from "../models/index.js";
+import { withActivity } from "../service/activity.js";
+/**
+ * Download a repo selection while keeping the daemon job ring and host-status
+ * activity record in lockstep. Repository size metadata is advisory, so a
+ * successful transfer is the only authoritative completion signal.
+ */
+export async function downloadRepoFilesWithProgress({ activityTarget, progressLabel, totalBytes, ...options }) {
+    let lastPct = -1;
+    const written = await withActivity("download", { target: activityTarget }, (activity) => downloadRepoFiles({
+        ...options,
+        onProgress: (progress) => {
+            activity.update(totalBytes ? progress.receivedBytes / totalBytes : null);
+            const pct = totalBytes ? Math.floor((progress.receivedBytes / totalBytes) * 100) : 0;
+            // A download chunk can jump straight over a five-percent boundary.
+            // Report each new integer percent so the UI ring never stalls until
+            // completion simply because no chunk hit an exact multiple of five.
+            if (pct > lastPct) {
+                lastPct = pct;
+                process.stderr.write(`  ${progressLabel}: ${pct}%\r`);
+            }
+        },
+    }));
+    process.stderr.write(`  ${progressLabel}: 100%\r`);
+    process.stderr.write("\n");
+    return written;
+}
+//# sourceMappingURL=repo-download.js.map

package/dist/commands/search.js

@@ -1,7 +1,8 @@
 import { loadBrainConfig } from "../config/index.js";
-import { downloadRepoFiles, listRepoQuants, managedModelsDir, repoOfModel, resolveHfToken, scanModels, searchModels, } from "../models/index.js";
+import { listRepoQuants, managedModelsDir, repoOfModel, resolveHfToken, scanModels, searchModels, } from "../models/index.js";
 import { formatBytes } from "../models/scan.js";
 import { CommandError } from "../output/types.js";
+import { downloadRepoFilesWithProgress } from "./repo-download.js";
 /** What is already on disk, so search + quant listings can mark installed rows. */
 function installedIndex(config) {
     const repos = new Set();
@@ -132,24 +133,15 @@ export async function runAddCommand(repo, options, _command) {
             (!options.primaryOnly && options.component === undefined));
     const files = [...choice.files, ...(includeProjector ? mmproj.files : [])];
     const total = choice.sizeBytes + (includeProjector ? mmproj.sizeBytes : 0);
-    let lastPct = -1;
-    const written = await downloadRepoFiles({
+    const written = await downloadRepoFilesWithProgress({
+        activityTarget: `${repo} (${choice.quant})`,
+        progressLabel: `${repo} ${choice.quant}`,
+        totalBytes: total,
         repo,
         files,
         destRoot: managedModelsDir(config),
         token,
-        onProgress: (p) => {
-            const pct = total ? Math.floor((p.receivedBytes / total) * 100) : 0;
-            // A download chunk can jump straight over a five-percent boundary.
-            // Report each new integer percent so the UI ring never stalls until
-            // completion simply because no chunk hit an exact multiple of five.
-            if (pct > lastPct) {
-                lastPct = pct;
-                process.stderr.write(`  ${repo} ${choice.quant}: ${pct}%\r`);
-            }
-        },
     });
-    process.stderr.write("\n");
     return {
         type: "single",
         data: {

package/dist/config/builtin-hosting-profiles.d.ts

@@ -0,0 +1,8 @@
+import type { ProfilesStore } from "./schema.js";
+/**
+ * Product-owned ids are upgraded wholesale, while records with unknown ids remain
+ * user-owned. Do not merge profile fields: stale template bytes or prose must not
+ * survive an Otto upgrade.
+ */
+export declare function seedBuiltinHostingProfiles(store: ProfilesStore): boolean;
+//# sourceMappingURL=builtin-hosting-profiles.d.ts.map

package/dist/config/builtin-hosting-profiles.js

@@ -0,0 +1,32 @@
+/**
+ * Curated Brain-owned hosting profiles. Source: Apache-2.0
+ * https://huggingface.co/peculiar-ragdoll/Qwen-Sharp-Chat-Templates
+ */
+import { Buffer } from "node:buffer";
+const QWEN_SHARP_TEMPLATE_BASE64 = "{%- set template_version = "qwen3.6-froggeric-v21.3" %}
{%- set _tool_format = tool_call_format if tool_call_format is defined else 'xml' %}
{%- set image_count = namespace(value=0) %}
{%- set video_count = namespace(value=0) %}
{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}
{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}
{%- set auto_disable_thinking_with_tools = auto_disable_thinking_with_tools if auto_disable_thinking_with_tools is defined else false %}
{%- set _preserve_thinking = preserve_thinking if preserve_thinking is defined else true %}
{%- set max_tool_arg_chars = max_tool_arg_chars if max_tool_arg_chars is defined else 0 %}
{%- set max_tool_response_chars = max_tool_response_chars if max_tool_response_chars is defined else 0 %}
{%- set _has_tools = (tools is defined and tools and tools is iterable and tools is not mapping) %}
{%- set ns_state = namespace(thinking=enable_thinking) %}
{%- if auto_disable_thinking_with_tools and _has_tools %}
    {%- set ns_state.thinking = false %}
{%- endif %}
{%- macro render_content(content, do_vision_count, is_system_content=false) %}
    {%- if content is string %}
        {{- content }}
    {%- elif content is iterable and content is not mapping %}
        {%- for item in content %}
            {%- if item is mapping %}
                {%- if item.type == 'image' or 'image' in item or 'image_url' in item %}
                    {%- if is_system_content %}
                        {{- raise_exception('System message cannot contain images.') }}
                    {%- endif %}
                    {%- if do_vision_count %}
                        {%- set image_count.value = image_count.value + 1 %}
                    {%- endif %}
                    {%- if add_vision_id %}
                        {{- 'Picture ' ~ image_count.value ~ ': ' }}
                    {%- endif %}
                    {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
                {%- elif item.type == 'video' or 'video' in item %}
                    {%- if is_system_content %}
                        {{- raise_exception('System message cannot contain videos.') }}
                    {%- endif %}
                    {%- if do_vision_count %}
                        {%- set video_count.value = video_count.value + 1 %}
                    {%- endif %}
                    {%- if add_vision_id %}
                        {{- 'Video ' ~ video_count.value ~ ': ' }}
                    {%- endif %}
                    {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
                {%- elif 'text' in item %}
                    {{- item.text }}
                {%- else %}
                    {{- raise_exception('Unexpected item type in content.') }}
                {%- endif %}
            {%- else %}
                {{- item | string }}
            {%- endif %}
        {%- endfor %}
    {%- elif content is none or content is undefined %}
        {{- '' }}
    {%- else %}
        {{- raise_exception('Unexpected content type.') }}
    {%- endif %}
{%- endmacro %}
{%- if not messages %}
    {{- raise_exception('No messages provided.') }}
{%- endif %}
{%- set _first_role = messages[0].role %}
{%- if _first_role == 'system' or _first_role == 'developer' %}
    {%- set _sys_msg = messages[0] %}
    {%- set _msgs = messages[1:] %}
{%- else %}
    {%- set _sys_msg = none %}
    {%- set _msgs = messages %}
{%- endif %}
{%- set _sc = '' %}
{%- if _sys_msg is not none %}
    {%- set _sc = render_content(_sys_msg.content, false, true) | trim %}
    {%- if '<|think_off|>' in _sc %}
        {%- set ns_state.thinking = false %}
        {%- set _sc = _sc.split('<|think_off|>') | join('') | trim %}
    {%- elif '<|think_on|>' in _sc %}
        {%- set ns_state.thinking = true %}
        {%- set _sc = _sc.split('<|think_on|>') | join('') | trim %}
    {%- endif %}
{%- endif %}
{%- set _terse %}
Answer directly, after thinking. Lead with the answer, then only what it needs to be correct and usable.
Never: open with preamble or pleasantries; restate the question; add filler transitions; hedge with niceties; or repeat a point you've already made.
Always: keep essential steps, caveats, uncertainties, and specifics — never drop correctness or a needed warning for brevity. Keep the final answer lean. Use the least structure that conveys it (plain prose when short; lists or code only when they earn their place). If genuinely uncertain, say so and explain why — never omit uncertainty for the sake of brevity.
If a user request is genuinely ambiguous, ask a sharp question, don't guess.
{%- endset %}
{%- if not _sc %}
    {%- set _sc = _terse | trim %}
{%- else %}
    {%- set _sc = (_sc | trim) ~ '\n\n' ~ (_terse | trim) %}
{%- endif %}
{%- if _has_tools %}
    {{- '<|im_start|>system\n' }}
    {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}
    {%- for tool in tools %}
        {{- '\n' }}
        {{- tool | tojson }}
    {%- endfor %}
    {{- '\n</tools>' }}
    {%- set tool_instructions %}
If you choose to call a function ONLY reply in the following format with NO suffix:

{%- if _tool_format == 'json' %}
<think>
Brief explanation of tool call
</think>
<tool_call>
{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}
</tool_call>
{%- else %}
<think>
Brief explanation of tool call
</think>
<tool_call>
<function=example_function_name>
<parameter=example_parameter_1>
value_1
</parameter>
<parameter=example_parameter_2>
This is the value for the second parameter
that can span
multiple lines
</parameter>
</function>
</tool_call>
{%- endif %}

<IMPORTANT>
Reminder:
- You can use the <think></think> block to plan your next tool call OR to synthesize data and formulate your final response to the user.
- ALL explanation and reasoning MUST be placed strictly inside the <think></think> block.
{%- if _tool_format == 'json' %}
- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys inside <tool_call></tool_call> XML tags.
{%- else %}
- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags.
{%- endif %}
- If you choose to call a tool, you MUST output the <tool_call> block IMMEDIATELY after thinking, with NO conversational text before it.
{%- if _tool_format == 'json' %}
- The <tool_call> tag MUST be at the very beginning of a new line, with NO spaces or indentation before it.
{%- else %}
- The <tool_call> and <function> tags MUST be at the very beginning of a new line, with NO spaces or indentation before them.
{%- endif %}
- To call multiple functions, output a separate, completely closed <tool_call></tool_call> block for EACH function. Do NOT nest <tool_call> blocks.
- If you have all necessary data, provide your final answer directly to the user without any tool call.
</IMPORTANT>
    {%- endset %}
    {{- '\n\n' ~ tool_instructions | trim }}
    {%- if _sc %}
        {{- '\n\n' + _sc }}
    {%- endif %}
    {{- '<|im_end|>\n' }}
{%- else %}
    {%- if _sc %}
        {{- '<|im_start|>system\n' + _sc + '<|im_end|>\n' }}
    {%- endif %}
{%- endif %}
{%- set _last_idx = _msgs | length - 1 %}
{%- set ns = namespace(multi_step_tool=true, last_query_index=_last_idx) %}
{%- for message in _msgs[::-1] %}
    {%- set index = (_msgs | length - 1) - loop.index0 %}
    {%- if ns.multi_step_tool and message.role == 'user' %}
        {%- set _rc = render_content(message.content, false) | trim %}
        {%- if not (_rc.startswith('<tool_response>') and _rc.endswith('</tool_response>')) %}
            {%- set ns.multi_step_tool = false %}
            {%- set ns.last_query_index = index %}
        {%- endif %}
    {%- endif %}
{%- endfor %}
{%- if ns.multi_step_tool %}
    {%- if _last_idx > 50 %}
        {%- set ns.last_query_index = _last_idx %}
    {%- else %}
        {%- set ns.last_query_index = 0 %}
    {%- endif %}
{%- endif %}
{%- set ns2 = namespace(prev_role='', consecutive_failures=0) %}
{%- for message in _msgs %}
    {%- set is_system = (message.role == "system" or message.role == "developer") %}
    {%- set content = render_content(message.content, true, is_system) | trim %}
    {%- if is_system or message.role == 'user' %}
        {%- if '<|think_off|>' in content %}
            {%- set ns_state.thinking = false %}
            {%- set content = content.split('<|think_off|>') | join('') | trim %}
        {%- elif '<|think_on|>' in content %}
            {%- set ns_state.thinking = true %}
            {%- set content = content.split('<|think_on|>') | join('') | trim %}
        {%- endif %}
    {%- endif %}
    {%- if is_system %}
        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
    {%- elif message.role == 'user' %}
        {%- set ns2.consecutive_failures = 0 %}
        {{- '<|im_start|>user\n' + content + '<|im_end|>\n' }}
    {%- elif message.role == 'assistant' %}
        {%- set reasoning_content = '' %}
        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
            {%- if message.reasoning_content is string %}
                {%- set reasoning_content = message.reasoning_content %}
            {%- else %}
                {%- set reasoning_content = message.reasoning_content | string %}
            {%- endif %}
        {%- elif message.thinking is defined and message.thinking is not none %}
            {%- if message.thinking is string %}
                {%- set reasoning_content = message.thinking %}
            {%- else %}
                {%- set reasoning_content = message.thinking | string %}
            {%- endif %}
        {%- else %}
            {%- set _think_end = '' %}
            {%- if content.startswith('</think>') %}
                {%- set _think_end = '</think>' %}
            {%- elif content.startswith('</thinking>') %}
                {%- set _think_end = '</thinking>' %}
            {%- elif '\n</think>' in content %}
                {%- set _think_end = '\n</think>' %}
            {%- elif '\n</thinking>' in content %}
                {%- set _think_end = '\n</thinking>' %}
            {%- elif '\n</ think>' in content %}
                {%- set _think_end = '\n</ think>' %}
            {%- elif '\n</think >' in content %}
                {%- set _think_end = '\n</think >' %}
            {%- endif %}
            {%- if _think_end %}
                {%- if 'thinking' in _think_end %}
                    {%- set _think_start = '<thinking>' %}
                {%- else %}
                    {%- set _think_start = '<think>' %}
                {%- endif %}
                {%- set reasoning_content = content.split(_think_end)[0].rstrip('\n') %}
                {%- if _think_start in reasoning_content %}
                    {%- set reasoning_content = reasoning_content.split(_think_start)[-1].lstrip('\n') %}
                {%- endif %}
                {%- set content = content.split(_think_end)[-1].lstrip('\n') %}
            {%- endif %}
        {%- endif %}
        {%- set reasoning_content = reasoning_content | trim %}
        {%- if (_preserve_thinking or loop.index0 > ns.last_query_index) and reasoning_content %}
            {{- '<|im_start|>assistant\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
        {%- else %}
            {{- '<|im_start|>assistant\n' + content }}
        {%- endif %}
        {%- if message.tool_calls is defined and message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
            {%- for tool_call in message.tool_calls %}
                {%- if tool_call.function is defined and tool_call.function is not none %}
                    {%- set tc = tool_call.function %}
                {%- else %}
                    {%- set tc = tool_call %}
                {%- endif %}
                {%- if _tool_format == 'json' %}
                    {%- if not loop.first or content | trim %}
                        {{- '\n\n' }}
                    {%- endif %}
                    {%- set _args = '{}' %}
                    {%- if tc.arguments is defined and tc.arguments is not none %}
                        {%- if tc.arguments is mapping %}
                            {%- set _args = tc.arguments | tojson %}
                        {%- elif tc.arguments is string and tc.arguments %}
                            {%- set _args = tc.arguments %}
                        {%- endif %}
                    {%- endif %}
                    {{- '<tool_call>\n{"name": ' }}{{- tc.name | tojson }}{{- ', "arguments": ' }}{{- _args }}{{- '}\n</tool_call>' }}
                {%- else %}
                    {%- if loop.first %}
                        {%- if content | trim %}
                            {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}
                        {%- else %}
                            {{- '<tool_call>\n<function=' + tc.name + '>\n' }}
                        {%- endif %}
                    {%- else %}
                        {{- '\n\n<tool_call>\n<function=' + tc.name + '>\n' }}
                    {%- endif %}
                    {%- if tc.arguments is defined and tc.arguments is not none %}
                        {%- if tc.arguments is mapping %}
                            {%- for args_name, args_value in tc.arguments.items() %}
                                {{- '<parameter=' + args_name + '>\n' }}
                                {%- if args_value is mapping or (args_value is sequence and args_value is not string) %}
                                    {%- set _av = args_value | tojson %}
                                {%- else %}
                                    {%- set _av = args_value | string %}
                                {%- endif %}
                                {%- if max_tool_arg_chars > 0 and _av | length > max_tool_arg_chars %}
                                    {{- _av[:max_tool_arg_chars] + '\n[TRUNCATED — original length ' ~ (_av | length | string) ~ ' chars]' }}
                                {%- else %}
                                    {{- _av }}
                                {%- endif %}
                                {{- '\n</parameter>\n' }}
                            {%- endfor %}
                        {%- elif tc.arguments is string and tc.arguments %}
                            {{- tc.arguments }}
                        {%- endif %}
                    {%- endif %}
                    {{- '</function>\n</tool_call>' }}
                {%- endif %}
            {%- endfor %}
        {%- endif %}
        {{- '<|im_end|>\n' }}
    {%- elif message.role == 'tool' %}
        {%- set _content_lower = content | lower %}
        {%- set _content_head = _content_lower[:80] %}
        {%- if content | length < 500 and '$ ' not in content and 'took ' not in _content_lower and ('"error":' in _content_head or 'error:' in _content_head or 'err!' in _content_head or 'fatal:' in _content_head or 'exception:' in _content_head or 'traceback' in _content_head or 'command not found' in _content_head or 'invalid syntax' in _content_head or 'failed to' in _content_head) %}
            {%- set ns2.consecutive_failures = ns2.consecutive_failures + 1 %}
        {%- else %}
            {%- set ns2.consecutive_failures = 0 %}
        {%- endif %}
        {%- if ns2.prev_role != 'tool' %}
            {{- '<|im_start|>user' }}
        {%- endif %}
        {%- if max_tool_response_chars > 0 and content | length > max_tool_response_chars %}
            {%- set content = content[:max_tool_response_chars] + '\n[TRUNCATED — original length ' ~ (content | length | string) ~ ' chars]' %}
        {%- endif %}
        {{- '\n<tool_response>\n' + content }}
        {%- if ns2.consecutive_failures >= 2 %}
            {{- '\n\n⚠️ SYSTEM WARNING: ' ~ ns2.consecutive_failures ~ ' consecutive tool errors detected. Your previous approach is incorrect. You MUST use a fundamentally different approach or corrected arguments.' }}
        {%- elif ns2.consecutive_failures == 1 %}
            {{- '\n\n⚠️ SYSTEM WARNING: The previous tool call returned an error. Diagnose the failure and retry with completely corrected arguments.' }}
        {%- endif %}
        {{- '\n</tool_response>' }}
        {%- if loop.last %}
            {{- '<|im_end|>\n' }}
        {%- else %}
            {%- set _next_role = _msgs[loop.index0 + 1].role %}
            {%- if _next_role != 'tool' %}
                {{- '<|im_end|>\n' }}
            {%- endif %}
        {%- endif %}
    {%- else %}
        {{- '<|im_start|>user\n[' + message.role + ']: ' + content + '<|im_end|>\n' }}
    {%- endif %}
    {%- set ns2.prev_role = message.role %}
{%- endfor %}
{%- if add_generation_prompt %}
    {{- '<|im_start|>assistant\n' }}
    {%- if not ns_state.thinking %}
        {{- '<think>\n\n</think>\n\n' }}
    {%- elif ns2.consecutive_failures >= 2 %}
        {{- '<think>\n\n</think>\n\n' }}
    {%- else %}
        {{- '<think>\n' }}
    {%- endif %}
{%- endif %}";
+const QWEN_SHARP = {
+    id: "qwen-sharp-v21.3",
+    name: "Qwen Sharp — concise, tool-safe",
+    family: "qwen",
+    description: "froggeric fixed Qwen v21.3 template with peculiar-ragdoll's terse system prompt. Agentic default disables retained thinking to avoid multi-turn context/prefill growth.",
+    template: Buffer.from(QWEN_SHARP_TEMPLATE_BASE64, "base64").toString("utf8"),
+    systemPromptAddendum: null,
+    templateKwargs: { preserve_thinking: false },
+};
+const BUILTIN_HOSTING_PROFILES = [QWEN_SHARP];
+/**
+ * Product-owned ids are upgraded wholesale, while records with unknown ids remain
+ * user-owned. Do not merge profile fields: stale template bytes or prose must not
+ * survive an Otto upgrade.
+ */
+export function seedBuiltinHostingProfiles(store) {
+    let changed = false;
+    for (const profile of BUILTIN_HOSTING_PROFILES) {
+        if (JSON.stringify(store.hostingProfiles[profile.id]) === JSON.stringify(profile))
+            continue;
+        store.hostingProfiles[profile.id] = profile;
+        changed = true;
+    }
+    return changed;
+}
+//# sourceMappingURL=builtin-hosting-profiles.js.map

package/dist/config/hosting-profiles.d.ts

@@ -0,0 +1,33 @@
+import type { BrainPaths } from "./paths.js";
+import type { HostingProfile, Profile, ProfilesStore } from "./schema.js";
+/**
+ * The bucket a model's hosting profiles live in. Families are catalog-authoritative
+ * when available, otherwise discovery derives them from GGUF metadata; models
+ * with neither use one real bucket rather than each being unaddressable. This
+ * must be the single definition: a writer that stored under "generic" while a
+ * reader looked up `null` was why a family default could be set on an unfamilied
+ * model and never take effect.
+ */
+export declare const GENERIC_HOSTING_FAMILY = "generic";
+export declare function hostingFamily(family: string | null | undefined): string;
+export declare function familyHostingProfileId(store: ProfilesStore, family: string | null | undefined): string | null;
+export declare function effectiveHostingProfile(store: ProfilesStore, profile: Profile, family: string | null | undefined): HostingProfile | null;
+/**
+ * Materialize a selected profile immediately before launch: the template as a
+ * file llama-server reads, the system addendum as a string the router injects
+ * into each completion request.
+ *
+ * The addendum is deliberately *not* spliced into the Jinja template, which was
+ * the first design. Doing that means rewriting the `messages` list from inside
+ * the template, and there is no portable way to do it: minja's support for list
+ * mutation differs from Jinja2's, every model family's template consumes the
+ * system turn differently, and a message's `content` is an array of parts for
+ * multimodal requests rather than a string to concatenate onto. Injecting into
+ * the parsed request body is the same composition (it appends to the agent's
+ * existing system message instead of replacing it) done where the shape is
+ * known and testable.
+ */
+export declare function resolveHostingProfileForLaunch(paths: BrainPaths, store: ProfilesStore, profile: Profile, family: string | null | undefined): Profile;
+/** Remove a deleted profile's generated template. Missing or locked files are non-fatal. */
+export declare function removeHostingProfileMaterialization(paths: BrainPaths, id: string): void;
+//# sourceMappingURL=hosting-profiles.d.ts.map

package/dist/config/hosting-profiles.js

@@ -0,0 +1,71 @@
+/** Brain-owned named chat-template compositions for llama-server. */
+import { rmSync } from "node:fs";
+import path from "node:path";
+import { writePrivateFileAtomicSync } from "./private-files.js";
+const SAFE_FILE = /[^a-zA-Z0-9_-]/gu;
+function materializedTemplatePath(paths, id) {
+    return path.join(paths.templatesDir, `${id.replace(SAFE_FILE, "_")}.jinja`);
+}
+/**
+ * The bucket a model's hosting profiles live in. Families are catalog-authoritative
+ * when available, otherwise discovery derives them from GGUF metadata; models
+ * with neither use one real bucket rather than each being unaddressable. This
+ * must be the single definition: a writer that stored under "generic" while a
+ * reader looked up `null` was why a family default could be set on an unfamilied
+ * model and never take effect.
+ */
+export const GENERIC_HOSTING_FAMILY = "generic";
+export function hostingFamily(family) {
+    return family || GENERIC_HOSTING_FAMILY;
+}
+export function familyHostingProfileId(store, family) {
+    return store.familyHostingProfileIds[hostingFamily(family)] ?? null;
+}
+export function effectiveHostingProfile(store, profile, family) {
+    const selected = profile.hostingProfileMode === "inherit"
+        ? familyHostingProfileId(store, family)
+        : profile.hostingProfileMode === "custom"
+            ? profile.hostingProfileId
+            : null;
+    return selected ? (store.hostingProfiles[selected] ?? null) : null;
+}
+/**
+ * Materialize a selected profile immediately before launch: the template as a
+ * file llama-server reads, the system addendum as a string the router injects
+ * into each completion request.
+ *
+ * The addendum is deliberately *not* spliced into the Jinja template, which was
+ * the first design. Doing that means rewriting the `messages` list from inside
+ * the template, and there is no portable way to do it: minja's support for list
+ * mutation differs from Jinja2's, every model family's template consumes the
+ * system turn differently, and a message's `content` is an array of parts for
+ * multimodal requests rather than a string to concatenate onto. Injecting into
+ * the parsed request body is the same composition (it appends to the agent's
+ * existing system message instead of replacing it) done where the shape is
+ * known and testable.
+ */
+export function resolveHostingProfileForLaunch(paths, store, profile, family) {
+    const selected = effectiveHostingProfile(store, profile, family);
+    const chatSystemAddendum = selected?.systemPromptAddendum?.trim() || null;
+    if (!selected?.template) {
+        return { ...profile, chatTemplateFile: null, chatTemplateKwargs: {}, chatSystemAddendum };
+    }
+    const file = materializedTemplatePath(paths, selected.id);
+    writePrivateFileAtomicSync(file, selected.template);
+    return {
+        ...profile,
+        chatTemplateFile: file,
+        chatTemplateKwargs: selected.templateKwargs,
+        chatSystemAddendum,
+    };
+}
+/** Remove a deleted profile's generated template. Missing or locked files are non-fatal. */
+export function removeHostingProfileMaterialization(paths, id) {
+    try {
+        rmSync(materializedTemplatePath(paths, id), { force: true });
+    }
+    catch {
+        // Profile deletion must not fail because a previous launch left a file locked.
+    }
+}
+//# sourceMappingURL=hosting-profiles.js.map

package/dist/config/index.d.ts

@@ -5,6 +5,7 @@ export { resolveBrainPaths, packageRoot, type BrainPaths } from "./paths.js";
 export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
 export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
 export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, hasStaleCalibration, } from "./profiles.js";
+export { effectiveHostingProfile, resolveHostingProfileForLaunch } from "./hosting-profiles.js";
 export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, type CalibrationInfo, type CalibrationState, type ProfileFieldDescriptor, type ProfileWarning, } from "./profile-edit.js";
 export * from "./schema.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/config/index.js

@@ -5,6 +5,7 @@ export { resolveBrainPaths, packageRoot } from "./paths.js";
 export { parseBooleanEnv, applyEnvOverrides } from "./env.js";
 export { loadBrainConfig, loadPersistedConfig, saveBrainConfig, loadProfilesStore, saveProfilesStore, loadCatalog, } from "./store.js";
 export { defaultProfile, forModel, put, calibrationKey, geometryKey, getCalibration, putCalibration, hasStaleCalibration, } from "./profiles.js";
+export { effectiveHostingProfile, resolveHostingProfileForLaunch } from "./hosting-profiles.js";
 export { calibrationInfo, nativeContextLimit, profileFieldDescriptors, profileWarnings, sanitizeProfilePatch, formatReasoningBudget, CACHE_TYPE_CYCLE, REASONING_BUDGET_CYCLE, UNRESTRICTED_REASONING_BUDGET, } from "./profile-edit.js";
 export * from "./schema.js";
 //# sourceMappingURL=index.js.map

package/dist/config/paths.d.ts

@@ -12,6 +12,8 @@ export interface BrainPaths {
     logFile: string;
     logsDir: string;
     resultsDir: string;
+    /** Brain-owned Jinja files materialized from named hosting profiles. */
+    templatesDir: string;
 }
 export declare function resolveBrainPaths(env?: NodeJS.ProcessEnv): BrainPaths;
 /**

package/dist/config/paths.js

@@ -26,6 +26,7 @@ export function resolveBrainPaths(env = process.env) {
         logFile: path.join(root, "otto-brain.log"),
         logsDir: path.join(root, "logs"),
         resultsDir: path.join(root, "results"),
+        templatesDir: path.join(root, "templates"),
     };
 }
 /**

package/dist/config/profile-edit.d.ts

@@ -45,10 +45,12 @@ export declare const MAX_PARALLEL_SLOTS = 16;
 export declare const MAX_GPU_LAYERS = 999;
 export declare const MIN_CONTEXT_SIZE = 1024;
 export declare const CONTEXT_STEP = 8192;
+export declare const CONTEXT_MULTIPLIERS: number[];
 /** The context ceiling: the model's native window, or a generous bound if unknown. */
 export declare function nativeContextLimit(model: Model | null): number;
+export declare function contextLimit(model: Model | null, multiplier?: number): number;
 /** The editable fields, resolved against one model's capabilities. */
-export declare function profileFieldDescriptors(model: Model | null): ProfileFieldDescriptor[];
+export declare function profileFieldDescriptors(model: Model | null, profile?: Profile | null): ProfileFieldDescriptor[];
 /** A note attached to a field, or to the profile as a whole when `field` is null. */
 export interface ProfileWarning {
     field: string | null;
@@ -90,5 +92,5 @@ export interface SanitizeResult {
  * CLI-only: they have no measured effect worth exposing and `extraArgs` is
  * arbitrary process arguments.
  */
-export declare function sanitizeProfilePatch(current: Profile, patch: unknown, model: Model | null): SanitizeResult;
+export declare function sanitizeProfilePatch(current: Profile, patch: unknown, model: Model | null, runtimeBuild?: number | null): SanitizeResult;
 //# sourceMappingURL=profile-edit.d.ts.map