@hncode/hncode 0.6.7 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hncode/hncode",
-  "version": "0.6.7",
+  "version": "0.7.1",
   "description": "hncode — A cyan-blue TUI AI coding agent with zero runtime dependencies.",
   "type": "module",
   "main": "src/index.js",

package/src/config.js

@@ -370,6 +370,27 @@ const b = baseUrl.replace(/\/+$/, '');
     || root.max_output_size
     || (modelMaxOutput > 0 ? modelMaxOutput : DEFAULTS.maxOutputTokens),
   );
+  // A NUMBER OR NOTHING: an unparseable value falls back to "not set", which means the provider decides.
+  const numOrNull = (v, min, max) => {
+    if (v == null || v === '') return null;
+    const n = Number(v);
+    if (!Number.isFinite(n)) return null;
+    return Math.max(min, Math.min(max, n));
+  };
+  // `sampling` gates the whole group. A provider that rejects `temperature` outright — several refuse it for
+  // reasoning models — needs a switch, not a magic value nobody can find.
+  const samplingOn = process.env.HNCODE_SAMPLING
+    ? !/^(0|false|no|off)$/i.test(process.env.HNCODE_SAMPLING)
+    : root.sampling !== false;
+  const temperature = samplingOn
+    ? numOrNull(process.env.HNCODE_TEMPERATURE ?? root.temperature, 0, 2)
+    : null;
+  const topP = samplingOn
+    ? numOrNull(process.env.HNCODE_TOP_P ?? root.top_p, 0, 1)
+    : null;
+  const presencePenalty = samplingOn
+    ? numOrNull(process.env.HNCODE_PRESENCE_PENALTY ?? root.presence_penalty, -2, 2)
+    : null;
   const reasoning = process.env.HNCODE_REASONING ? /^(1|true|yes)$/i.test(process.env.HNCODE_REASONING) : !!root.reasoning;
   const allowExternal = process.env.HNCODE_ALLOW_EXTERNAL === '1' || !!root.tool_allow_external_paths;
 
@@ -377,6 +398,11 @@ const b = baseUrl.replace(/\/+$/, '');
     model, provider: providerName, innerModel,
     baseUrl: b, endpoint, apiKey, protocol,
     maxContextTokens: maxContext, maxOutputTokens: maxOutput, reasoning,
+    // Sampling. `undefined`/null means "do not send it", which is what lets a provider apply its own
+    // default — and what keeps a rejection from becoming a hard failure.
+    temperature: temperature == null ? undefined : temperature,
+    topP: topP == null ? undefined : topP,
+    presencePenalty: presencePenalty == null ? undefined : presencePenalty,
     workspace: process.env.HNCODE_WORKSPACE || root.workspace || DEFAULTS.workspace,
     allowExternal,
     // Standing permission rules (see permissions.js). `[permissions]` in config.toml:

package/src/llm.js

@@ -233,6 +233,8 @@ function authHeaders(cfg) {
 function buildBody(cfg, messages, streaming = true, opts = {}) {
   const common = { stream: streaming, max_tokens: cfg.maxOutputTokens };
   if (cfg.temperature != null) common.temperature = cfg.temperature;
+  if (cfg.topP != null) common.top_p = cfg.topP;
+  if (cfg.presencePenalty != null) common.presence_penalty = cfg.presencePenalty;
   // Ask for the token accounting on the FINAL stream frame. Without this the
   // OpenAI-compatible stream carries no `usage` at all, so the only token numbers
   // available were our own estimates (see /usage, which divided the transcript's
@@ -265,6 +267,9 @@ function buildBody(cfg, messages, streaming = true, opts = {}) {
       ...common, ...wire,
     };
     if (!body.tools || !body.tools.length) delete body.tools;
+    // NO PRESENCE PENALTY ON THIS PROTOCOL: it has no equivalent, and an unknown field is an error
+    // here rather than something quietly ignored.
+    delete body.presence_penalty;
     // Prompt caching: mark the stable prefix (tools + system + conversation head)
     // so the provider bills it as a cache READ instead of fresh input. The key is
     // the SESSION id, so it stays identical across turns and never thrashes.
@@ -287,6 +292,8 @@ function buildBody(cfg, messages, streaming = true, opts = {}) {
     };
     if (instructions) rbody.instructions = instructions;
     if (cfg.temperature != null) rbody.temperature = cfg.temperature;
+    if (cfg.topP != null) rbody.top_p = cfg.topP;
+    // No presence penalty on this protocol: sending it is an unknown-parameter error, not a hint.
     if (!opts.noTools) {
       const defsR = Object.prototype.hasOwnProperty.call(opts, 'tools')
         ? responsesToolDefs(opts.tools) : responsesToolDefs(llmToolsList);

package/src/ptc-worker.js

@@ -0,0 +1,120 @@
+// The PTC executor's WORKER SIDE — what actually runs the model's code.
+//
+// This file is loaded as a `worker_threads` entry, never imported by the main process. Everything it can reach is
+// what `parentPort` hands it and the globals below: no `require`, no `process` access beyond what is passed in,
+// and no filesystem. The model's code is compiled inside a `vm` context whose only interesting binding is
+// `callTool`, which messages the main thread and waits.
+//
+// WHY A WORKER AND NOT vm ALONE: `vm` is not a security boundary — code in a context can still reach the host
+// through a prototype it was handed. The thread is what makes a runaway loop killable: `worker.terminate()` stops
+// it without the main process ever yielding, which a `while(true)` in `vm.runInContext` would not.
+//
+// The code runs as an ASYNC body, so `await callTool(...)` works exactly as it reads.
+import { parentPort, workerData } from 'node:worker_threads';
+import vm from 'node:vm';
+
+const TOOL_NAMES = Array.isArray(workerData && workerData.toolNames) ? workerData.toolNames : [];
+const TIMEOUT_MS = Number(workerData && workerData.timeoutMs) > 0 ? workerData.timeoutMs : 120000;
+
+let seq = 0;
+const pending = new Map();
+
+/** Ask the main thread to run a tool, and wait for its answer. */
+function callTool(name, args) {
+  const id = ++seq;
+  parentPort.postMessage({ type: 'tool', id, name, args: args == null ? {} : args });
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+  });
+}
+
+parentPort.on('message', (m) => {
+  if (!m || m.type !== 'tool_result') return;
+  const p = pending.get(m.id);
+  if (!p) return;
+  pending.delete(m.id);
+  if (m.ok) p.resolve(m.result);
+  else p.reject(new Error(String(m.error || 'tool failed')));
+});
+
+// ---- the sandbox ---------------------------------------------------------------------------------------------
+
+/** Collect printed lines. `print` is what the model reaches for. */
+const out = [];
+const write = (...parts) => {
+  const line = parts.map((p) => {
+    if (typeof p === 'string') return p;
+    try { return JSON.stringify(p); } catch { return String(p); }
+  }).join(' ');
+  // A single line cap keeps a runaway from filling memory before the byte cap is checked.
+  out.push(line.length > 8000 ? line.slice(0, 8000) + '…' : line);
+};
+
+const sandbox = {
+  callTool,
+  print: write,
+  console: { log: write, error: write, warn: write, info: write },
+  JSON,
+  Math,
+  Date,
+  Promise,
+  Array,
+  Object,
+  String,
+  Number,
+  Boolean,
+  Map,
+  Set,
+  RegExp,
+  Error,
+  TypeError,
+  RangeError,
+  isNaN,
+  isFinite,
+  parseInt,
+  parseFloat,
+  // `sleep` is the one timer worth exposing: pacing between calls is a real need, and `setTimeout` would let the
+  // code keep the thread alive past the point where the caller wants an answer.
+  sleep: (ms) => new Promise((r) => setTimeout(r, Math.max(0, Math.min(Number(ms) || 0, 10000)))),
+};
+
+const context = vm.createContext(sandbox, {
+  // No `codeGeneration` from strings inside the sandbox: a `new Function` there would be a second, unreviewed way
+  // in — and the body the model writes is already compiled below.
+  codeGeneration: { strings: false, wasm: false },
+});
+
+async function run(code) {
+  let script;
+  try {
+    script = new vm.Script(`(async () => {\n${code}\n})()`, { filename: 'ptc-sandbox.js' });
+  } catch (e) {
+    return { ok: false, error: `Syntax error: ${e.message}`, output: '' };
+  }
+
+  const timer = setTimeout(() => {
+    parentPort.postMessage({ type: 'timeout', ms: TIMEOUT_MS });
+    process.exit(0);
+  }, TIMEOUT_MS);
+  if (timer.unref) timer.unref();
+
+  try {
+    const value = await script.runInContext(context, { timeout: TIMEOUT_MS });
+    clearTimeout(timer);
+    // The returned value is what `return` produced, if anything; `print` already captured stdout.
+    let returned;
+    if (value !== undefined) {
+      try { returned = typeof value === 'string' ? value : JSON.stringify(value); } catch { returned = String(value); }
+    }
+    return { ok: true, output: out.join('\n'), returned };
+  } catch (e) {
+    clearTimeout(timer);
+    return { ok: false, error: `${e && e.name ? e.name + ': ' : ''}${e && e.message || e}`, output: out.join('\n') };
+  }
+}
+
+parentPort.on('message', async (m) => {
+  if (!m || m.type !== 'run') return;
+  const result = await run(String(m.code || ''));
+  parentPort.postMessage({ type: 'done', result });
+});

package/src/ptc.js

@@ -0,0 +1,141 @@
+// The PTC executor's MAIN side.
+//
+// Owns a worker, forwards the tool calls it makes to the real tool layer, and enforces the limits the sandbox
+// cannot enforce about itself: output size, tool count, and a wall-clock deadline that survives a wedged await.
+//
+// WHY THE TOOL CALLS COME BACK HERE AT ALL: the tools need `ctx` — the workspace, the approval hook, the session
+// — none of which may exist inside the sandbox. The worker sends `{type:'tool', name, args}`, this side runs the
+// real tool through `getTool`, and the result crosses back as data. The model's code never holds a function that
+// can reach the filesystem; it holds a promise that the host fulfils.
+import { Worker } from 'node:worker_threads';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+/** Tools whose results are safe and useful to hand to code, and whose invocation needs no UI. */
+const CALLABLE = new Set([
+  'Read', 'FileLines', 'Glob', 'Grep', 'Git', 'FetchURL', 'WebSearch',
+  'TodoList', 'TaskList', 'TaskOutput', 'Memory', 'ListTeammates', 'TeamTaskList',
+  'ActivateSkill', 'Goal', 'Diagnostics',
+]);
+
+export const DEFAULT_LIMITS = {
+  // A code body that orchestrates twenty calls is already unusual; five hundred is a loop that has gone wrong.
+  maxToolCalls: 500,
+  // What comes back is the whole point of PTC — a cap keeps a runaway `print` from eating the context it saved.
+  maxOutputBytes: 32000,
+  timeoutMs: 120000,
+};
+
+export const CALLABLE_TOOLS = [...CALLABLE];
+
+/**
+ * Run `code` in a sandbox, letting it call the tools in `CALLABLE`.
+ *
+ * @param {string} code An async function BODY. `await callTool(name, args)` is available.
+ * @param {object} ctx The tool context, passed straight through to each tool.
+ * @param {object} [limits] Overrides for `DEFAULT_LIMITS`.
+ * @returns {Promise<{ok: boolean, output: string, returned?: string, error?: string, calls: string[], truncated?: boolean}>}
+ */
+export function runProgrammatic(code, ctx, limits = {}) {
+  const lim = { ...DEFAULT_LIMITS, ...limits };
+  return new Promise((resolve) => {
+    let settled = false;
+    const calls = [];
+    const lines = [];
+    let bytes = 0;
+    let truncated = false;
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(wall);
+      try { worker.terminate(); } catch { /* already gone */ }
+      resolve(result);
+    };
+
+    const worker = new Worker(path.join(here, 'ptc-worker.js'), {
+      workerData: { toolNames: [...CALLABLE], timeoutMs: lim.timeoutMs },
+      // The sandbox needs no stdio and no shared memory.
+      stdout: true,
+      stderr: true,
+    });
+
+    // The wall clock is the OUTER guarantee: if the worker is stuck in a `while(true)` the inner vm timeout can
+    // still fire, but if the main thread is waiting on a tool that never answers, only this one saves us.
+    const wall = setTimeout(() => {
+      finish({ ok: false, error: `timed out after ${lim.timeoutMs}ms`, output: lines.join('\n'), calls });
+    }, lim.timeoutMs + 5000);
+
+    worker.on('message', async (m) => {
+      if (!m) return;
+
+      if (m.type === 'tool') {
+        if (calls.length >= lim.maxToolCalls) {
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: false, error: `tool-call limit reached (${lim.maxToolCalls})` });
+          return;
+        }
+        const name = String(m.name || '');
+        if (!CALLABLE.has(name)) {
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: false, error: `${name} is not callable from code` });
+          return;
+        }
+        // Imported here, not at the top: tools/index.js imports the PTC TOOL, which imports this module — a static
+        // import would close that cycle and read `spec` before it exists.
+        const { getTool } = await import('./tools/index.js');
+        const tool = getTool(name);
+        if (!tool || typeof tool.execute !== 'function') {
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: false, error: `no such tool: ${name}` });
+          return;
+        }
+        calls.push(name);
+        try {
+          const raw = await tool.execute(m.args || {}, ctx);
+          // A media result is structured blocks, not text; code cannot do anything useful with it.
+          const value = (raw && typeof raw === 'object' && Array.isArray(raw.media))
+            ? '[media result omitted]'
+            : (typeof raw === 'string' ? raw : JSON.stringify(raw));
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: true, result: value });
+        } catch (e) {
+          worker.postMessage({ type: 'tool_result', id: m.id, ok: false, error: String((e && e.message) || e) });
+        }
+        return;
+      }
+
+      if (m.type === 'timeout') {
+        finish({ ok: false, error: `timed out after ${lim.timeoutMs}ms`, output: lines.join('\n'), calls });
+        return;
+      }
+
+      if (m.type === 'done') {
+        const r = m.result || {};
+        let output = String(r.output == null ? '' : r.output);
+        // Cap by BYTES, not characters: the model pays for tokens, and a megabyte of ASCII is the worst case.
+        if (Buffer.byteLength(output, 'utf8') > lim.maxOutputBytes) {
+          output = output.slice(0, lim.maxOutputBytes);
+          truncated = true;
+        }
+        finish({
+          ok: !!r.ok,
+          output,
+          returned: r.returned,
+          error: r.error,
+          calls,
+          truncated: truncated || undefined,
+        });
+      }
+    });
+
+    worker.on('error', (e) => {
+      finish({ ok: false, error: String((e && e.message) || e), output: lines.join('\n'), calls });
+    });
+    worker.on('exit', (code) => {
+      // An exit without a `done` is the worker dying: report it rather than hanging the caller for ever.
+      if (!settled) finish({ ok: false, error: `sandbox exited with code ${code}`, output: lines.join('\n'), calls });
+    });
+
+    worker.postMessage({ type: 'run', code: String(code || '') });
+    void bytes;
+  });
+}

package/src/settings-schema.js

@@ -125,6 +125,18 @@ export const SETTINGS_SCHEMA = [
     ui: { tab: 'model', group: 'Thinking', label: 'Context window', hint: 'Override the model window when the catalog is wrong; 0 means use it' } },
   { key: 'prompt_cache', ...bool(true),
     ui: { tab: 'model', group: 'Provider', label: 'Prompt caching', hint: 'Ask the provider to cache the request prefix' } },
+  { key: 'sampling', ...bool(true),
+    label: 'Send sampling parameters',
+    help: 'Off sends no temperature/top_p at all, for a provider that rejects them (several do, for reasoning models).' },
+  { key: 'temperature', ...str(''),
+    label: 'Temperature',
+    help: '0 is deterministic, 2 is wild. Empty leaves the provider default. Accepts 0-2 with one decimal.' },
+  { key: 'top_p', ...str(''),
+    label: 'Top P',
+    help: 'Nucleus sampling 0-1. Empty leaves the provider default. Usually set INSTEAD of temperature, not both.' },
+  { key: 'presence_penalty', ...str(''),
+    label: 'Presence penalty',
+    help: 'OpenAI-compatible only: -2 to 2, positive discourages repeating topics. Anthropic has no equivalent and never receives it.' },
 
   // ---- context ------------------------------------------------------------
   { key: 'auto_compact', ...bool(true),

package/src/tools/index.js

@@ -24,6 +24,7 @@ import { spec as diagnosticsSpec } from './diagnostics.js';
 import * as memoryMod from './memory.js';
 import * as goalMod from './goal.js';
 import * as activateSkillMod from './activate-skill.js';
+import * as ptcMod from './ptc.js';
 import { pluginTools, pluginToolGeneration } from '../plugin.js';
 
 
@@ -59,6 +60,7 @@ const builtinTools = [
   memoryMod.spec,
   goalMod.spec,
   activateSkillMod.spec,
+  ptcMod.spec,
   ...TEAM_TOOL_SPECS,
 ];
 

package/src/tools/ptc.js

@@ -0,0 +1,91 @@
+/**
+ * ProgrammaticToolCall — let the model orchestrate tools with code instead of one round trip each.
+ *
+ * THE PROBLEM IT SOLVES: a task like "which of these forty files reference the removed symbol" is forty calls,
+ * each with its own inference pass, and every one of those results then sits in the context whether or not it
+ * mattered. The reading is mechanical; only the conclusion is worth the tokens.
+ *
+ * With this tool the model writes the LOOP, and only what it prints comes back. The sandbox holds the forty
+ * results, the filtering and the joining; the conversation holds the six files that matched.
+ *
+ * WHY A SEPARATE TOOL AND NOT `Bash`: a shell would give the model the whole machine and no structure. Here every
+ * call goes back through the tool layer — the same approval rules, the same workspace guard, the same tools —
+ * and the code can only reach the ones on the allowlist. See src/ptc.js for that list, and ptc-worker.js for the
+ * sandbox itself.
+ */
+import { runProgrammatic, CALLABLE_TOOLS } from '../ptc.js';
+
+const DESCRIPTION = [
+  'Orchestrate tools with JavaScript instead of calling them one at a time.',
+  '',
+  'WHEN TO USE IT: work that is a LOOP over tool results, or that needs intermediate data the model should not',
+  'have to read. Reading twenty files to find the three that mention a symbol; checking every changed file for a',
+  'pattern; collecting values from many calls and printing only the ones that matter. The intermediate results',
+  'stay inside the sandbox and never enter the conversation — that is the point.',
+  '',
+  'WHEN NOT TO USE IT: one or two calls, or when you need to READ a result and decide what to do next. Then an',
+  'ordinary tool call is shorter and clearer.',
+  '',
+  'HOW TO WRITE IT: the body of an async function. `await callTool(name, args)` runs a tool and resolves to its',
+  'text result. `print(...)` writes a line to the output; `console.log` is the same. Whatever you `return` is',
+  'appended. Nothing reaches the conversation except what you print or return.',
+  '',
+  'Example:',
+  '```',
+  "const hits = [];",
+  "for (const f of (await callTool('Glob', { pattern: 'src/**/*.js' })).split('\\n').filter(Boolean)) {",
+  "  const text = await callTool('Grep', { pattern: 'oldSymbol', path: f });",
+  "  if (text && !/No matches/.test(text)) hits.push(f);",
+  '}',
+  'print(`${hits.length} files still reference it`);',
+  'print(hits.join(\'\\n\'));',
+  '```',
+  '',
+  `CALLABLE TOOLS: ${CALLABLE_TOOLS.join(', ')}.`,
+  'Anything else is refused — a shell or a write would escape the sandbox\'s purpose.',
+].join('\n');
+
+export const spec = {
+  name: 'ProgrammaticToolCall',
+  description: DESCRIPTION,
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description: [
+          'The body of an async function. `await callTool(name, args)` calls a tool; `print(x)` emits a line.',
+          'Only what is printed or returned reaches the conversation.',
+        ].join(' '),
+      },
+      purpose: {
+        type: 'string',
+        description: 'One line naming what the code is for, shown in the transcript.',
+      },
+    },
+    required: ['code'],
+  },
+  async execute(args, ctx) {
+    const code = String((args && args.code) || '');
+    if (!code.trim()) return 'Error: `code` is empty.';
+
+    const r = await runProgrammatic(code, ctx);
+    const parts = [];
+
+    if (r.output) parts.push(r.output);
+    if (r.returned != null && String(r.returned).trim()) parts.push(String(r.returned));
+    if (r.truncated) parts.push('[output truncated]');
+
+    if (!r.ok) {
+      // The error goes LAST, after whatever the code managed to print: a partial result plus the reason it
+      // stopped is more useful than the reason alone.
+      parts.push(`Error: ${r.error}`);
+    }
+
+    // How many tools ran is worth stating — it is the saving this feature exists for, and a model that sees 0 is
+    // being told its code never reached a tool.
+    if (r.calls.length) parts.push(`(${r.calls.length} tool call${r.calls.length === 1 ? '' : 's'})`);
+
+    return parts.join('\n') || '(no output)';
+  },
+};

package/src/tui.js

@@ -187,6 +187,7 @@ export const COMMANDS = [
   { name: 'permission', desc: 'Select permission mode', priority: 100 },
   { name: 'settings', aliases: ['config'], desc: 'Browse and change every setting, grouped by area', priority: 100, argumentHint: '[tab|filter]' },
   { name: 'set', desc: 'Set one config value by key, or list what differs from the default', priority: 100, argumentHint: '[<key> [value]]' },
+  { name: 'sampling', desc: 'Show or set temperature, top_p and presence_penalty', priority: 100, argumentHint: '[on|off|temperature <n>|top_p <n>|presence_penalty <n>]' },
   { name: 'plan', desc: 'Toggle plan mode', priority: 100, argumentHint: '[on|off|clear]' },
   { name: 'websearch-api', desc: 'Edit the WebSearch API keys (one per line, tried in order)', priority: 96 },
   { name: 'focus', desc: 'Toggle Focus mode (minimal tools first, full tools after)', priority: 98, argumentHint: '[on|off]' },
@@ -8688,12 +8689,26 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
       if (key === 'calm_mode') cfg.calmMode = v;
       if (key === 'swarm_mode') cfg.swarm = v;
       if (key === 'tool_allow_external_paths') cfg.allowExternal = v;
+      if (key === 'sampling' && !v) {
+        // Off means NONE of them is sent — not their defaults, which is what a provider rejecting them
+        // would receive otherwise.
+        cfg.temperature = undefined; cfg.topP = undefined; cfg.presencePenalty = undefined;
+      }
     } else {
       cfg[key] = raw; cfg.raw[key] = raw;
       if (key === 'compact_threshold') cfg.compactThreshold = Number(raw) / 100;
       if (key === 'compact_keep_ratio') cfg.compactKeepRatio = Number(raw) / 100;
       if (key === 'trim_threshold') cfg.trimThreshold = Number(raw) / 100;
       if (key === 'trim_keep_ratio') cfg.trimKeepRatio = Number(raw) / 100;
+      // SAMPLING: a NUMBER, or gone. The generic writer stores the typed string, and `llm.js` sends it
+      // straight into the request — a provider given `"0.3"` rejects it or ignores it.
+      if (key === 'temperature' || key === 'top_p' || key === 'presence_penalty') {
+        const field = { temperature: 'temperature', top_p: 'topP', presence_penalty: 'presencePenalty' }[key];
+        const n = raw === '' ? null : Number(raw);
+        // Clearing the field removes the parameter, so the provider applies its own default — which is not
+        // the same thing as sending 0.
+        cfg[field] = n == null || !Number.isFinite(n) ? undefined : n;
+      }
       if (key === 'max_context_tokens') cfg.maxContextTokens = Number(raw) || cfg.maxContextTokens;
       if (key === 'provider') cfg.provider = raw;
       if (key === 'model') { cfg.model = raw; state.modelLabel = raw; }
@@ -8942,6 +8957,42 @@ export async function dispatch(cmdRaw, arg, state, cfg, session, h, submit, stdo
     }
 
 
+
+    case 'sampling': {
+      const parts = String(raw || '').trim().split(/\s+/).filter(Boolean);
+      const show = () => {
+        const row = (label, v, note) => `  ${label.padEnd(18)} ${v == null ? '(provider default)' : v}${note ? '   ' + note : ''}`;
+        sayPanel([
+          'Sampling parameters',
+          '',
+          row('send them', cfg.sampling === false ? 'off' : 'on', cfg.sampling === false ? 'nothing is sent' : ''),
+          row('temperature', cfg.temperature),
+          row('top_p', cfg.topP),
+          row('presence_penalty', cfg.presencePenalty, 'OpenAI-compatible only'),
+          '',
+          'Set with /sampling temperature 0.3, /sampling top_p 0.9, /sampling off',
+        ].join('\n'));
+      };
+      if (!parts.length) { show(); return; }
+      if (parts[0] === 'on' || parts[0] === 'off') {
+        applySetting('sampling', parts[0] === 'on' ? 'true' : 'false');
+        app(`Sampling: ${parts[0]}`);
+        show();
+        return;
+      }
+      const key = parts[0] === 'top-p' ? 'top_p' : parts[0] === 'presence-penalty' ? 'presence_penalty' : parts[0];
+      if (!['temperature', 'top_p', 'presence_penalty'].includes(key)) {
+        appErr('Usage: /sampling [on|off] | temperature <0-2> | top_p <0-1> | presence_penalty <-2-2>');
+        return;
+      }
+      if (parts.length === 1) { show(); return; }
+      // An empty value clears it: the field means "let the provider decide", and `0` is a real temperature.
+      const value = parts.slice(1).join(' ').trim();
+      if (!applySetting(key, value)) return;
+      app(value === '' ? `${key} cleared` : `${key} = ${value}`);
+      show();
+      return;
+    }
     case 'set': {
       // `/set <key> <value>` — the direct path, so any setting is reachable without
       // remembering which command owns it. `/set` alone lists what is changed.
@@ -14140,7 +14191,7 @@ const agents = readAgentsMd(state.cwd || state.workspace || cfg.workspace, state
       // Tools that act ONLY inside the session: the roster, the mailbox, the task list, the memories.
       // `isInsideWorkspace` answers `false` for any tool it does not know, so without this they all asked for
       // approval in yolo — the one mode whose point is not asking.
-      const safeTools = ['Read', 'Grep', 'Glob', 'FetchURL', 'WebSearch', 'TaskOutput', 'TaskList', 'TaskStop', 'TaskWait', 'TodoList', 'Goal', 'ActivateSkill', 'FileLines', 'AgentList', 'AgentMessage', 'AgentInterrupt', 'AgentClose', 'TaskInput', 'SendMessage', 'TeamTaskCreate', 'TeamTaskUpdate', 'TeamTaskList', 'ListTeammates', 'Memory', 'AskUserQuestion'];
+      const safeTools = ['Read', 'Grep', 'Glob', 'FetchURL', 'WebSearch', 'TaskOutput', 'TaskList', 'TaskStop', 'TaskWait', 'TodoList', 'Goal', 'ActivateSkill', 'ProgrammaticToolCall', 'FileLines', 'AgentList', 'AgentMessage', 'AgentInterrupt', 'AgentClose', 'TaskInput', 'SendMessage', 'TeamTaskCreate', 'TeamTaskUpdate', 'TeamTaskList', 'ListTeammates', 'Memory', 'AskUserQuestion'];
       if (rule !== 'ask' && safeTools.includes(toolName)) return true;
       // A read-only SHELL COMMAND (ls/git status/rg/cat …) is as safe as a
       // read-only TOOL, so it runs without a prompt in Ask mode too — the user
@@ -20567,6 +20618,7 @@ function wheelStep(state, family) {
     hub.actions.setConfig = async (key, value) => {
       const ALLOWED = new Set([
         'calm_mode', 'auto_update', 'auto_compact', 'prompt_cache',
+        'temperature', 'top_p', 'presence_penalty', 'sampling',
         'tool_allow_external_paths', 'subagent_model', 'swarm_mode', 'theme',
       ]);
       const k = String(key || '');