nubos-pilot 1.2.4 → 1.3.1

package/lib/runtime/agent-loop.test.cjs

@@ -0,0 +1,240 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { runAgentLoop, DEFAULT_MAX_ITERATIONS } = require('./agent-loop.cjs');
+const { toolsetFor } = require('./tools/index.cjs');
+const elision = require('../elision.cjs');
+
+function _bigLog() {
+  const lines = [];
+  for (let i = 0; i < 300; i++) {
+    if (i % 73 === 0) lines.push('ERROR: boom at module_' + i);
+    else lines.push('[info] step ' + i + ' ok processed record ' + (i * 7) + ' ' + 'x'.repeat(30));
+  }
+  return lines.join('\n');
+}
+
+const _dirs = [];
+function _ws(files) {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'np-loop-')));
+  for (const [rel, content] of Object.entries(files || {})) {
+    const abs = path.join(root, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, content, 'utf-8');
+  }
+  _dirs.push(root);
+  return root;
+}
+afterEach(() => { while (_dirs.length) { try { fs.rmSync(_dirs.pop(), { recursive: true, force: true }); } catch {} } });
+
+function _scriptedChat(turns) {
+  let i = 0;
+  const seen = [];
+  const fn = async ({ messages }) => {
+    seen.push(JSON.parse(JSON.stringify(messages)));
+    const t = turns[Math.min(i, turns.length - 1)];
+    i++;
+    if (t.toolCalls) {
+      return { content: t.content || '', toolCalls: t.toolCalls, finishReason: 'tool_calls', raw: { role: 'assistant', content: t.content || '', tool_calls: t.toolCalls.map((c) => ({ id: c.id, function: { name: c.name, arguments: c.arguments } })) } };
+    }
+    return { content: t.content, toolCalls: [], finishReason: 'stop', raw: { role: 'assistant', content: t.content } };
+  };
+  fn.seen = seen;
+  return fn;
+}
+
+test('AL-1: a final-answer turn returns immediately, stopped=final', async () => {
+  const chatImpl = _scriptedChat([{ content: 'done' }]);
+  const out = await runAgentLoop({
+    systemPrompt: 'you are x', task: 'do it',
+    toolset: toolsetFor(['Read']), provider: { baseUrl: 'http://x/v1', model: 'm' }, chatImpl,
+  });
+  assert.equal(out.content, 'done');
+  assert.equal(out.stopped, 'final');
+  assert.equal(out.iterations, 1);
+});
+
+test('AL-2: a tool call is executed in the workspace and fed back, then a final answer', async () => {
+  const cwd = _ws({ 'data.txt': 'hello' });
+  const chatImpl = _scriptedChat([
+    { toolCalls: [{ id: 't1', name: 'Read', arguments: '{"path":"data.txt"}' }] },
+    { content: 'the file says hello' },
+  ]);
+  const out = await runAgentLoop({
+    systemPrompt: 's', task: 'read data.txt', cwd,
+    toolset: toolsetFor(['Read']), provider: { baseUrl: 'http://x/v1', model: 'm' }, chatImpl,
+  });
+  assert.equal(out.stopped, 'final');
+  assert.equal(out.iterations, 2);
+  assert.deepEqual(out.toolLog, [{ name: 'Read', ok: true }]);
+  const lastTurnMsgs = chatImpl.seen[1];
+  const toolMsg = lastTurnMsgs.find((m) => m.role === 'tool');
+  assert.equal(toolMsg.tool_call_id, 't1');
+  assert.equal(toolMsg.content, '1\thello');
+});
+
+test('AL-3: a failing tool call returns an error string, ok=false, loop continues', async () => {
+  const cwd = _ws({});
+  const chatImpl = _scriptedChat([
+    { toolCalls: [{ id: 't1', name: 'Read', arguments: '{"path":"missing.txt"}' }] },
+    { content: 'could not read' },
+  ]);
+  const out = await runAgentLoop({
+    systemPrompt: 's', task: 't', cwd,
+    toolset: toolsetFor(['Read']), provider: { baseUrl: 'http://x/v1', model: 'm' }, chatImpl,
+  });
+  assert.equal(out.toolLog[0].ok, false);
+  assert.equal(out.stopped, 'final');
+});
+
+test('AL-4: a model that never stops hits the iteration cap', async () => {
+  const cwd = _ws({ 'a.txt': 'x' });
+  const chatImpl = _scriptedChat([{ toolCalls: [{ id: 't', name: 'Read', arguments: '{"path":"a.txt"}' }] }]);
+  const out = await runAgentLoop({
+    systemPrompt: 's', task: 't', cwd, maxIterations: 3,
+    toolset: toolsetFor(['Read']), provider: { baseUrl: 'http://x/v1', model: 'm' }, chatImpl,
+  });
+  assert.equal(out.stopped, 'max-iterations');
+  assert.equal(out.iterations, 3);
+  assert.equal(out.toolLog.length, 3);
+});
+
+test('AL-5: missing toolset / provider throw loud', async () => {
+  let a = null; try { await runAgentLoop({ provider: { model: 'm' } }); } catch (e) { a = e; }
+  assert.equal(a.code, 'agent-loop-no-toolset');
+  let b = null; try { await runAgentLoop({ toolset: toolsetFor(['Read']) }); } catch (e) { b = e; }
+  assert.equal(b.code, 'agent-loop-no-provider');
+});
+
+test('AL-6: DEFAULT_MAX_ITERATIONS is a sane positive cap', () => {
+  assert.ok(DEFAULT_MAX_ITERATIONS >= 1 && DEFAULT_MAX_ITERATIONS <= 100);
+});
+
+test('AL-8: compression default OFF — tool result enters history verbatim, no blocks compressed', async () => {
+  const cwd = _ws({ 'log.txt': _bigLog() });
+  const chatImpl = _scriptedChat([
+    { toolCalls: [{ id: 't1', name: 'Read', arguments: '{"path":"log.txt"}' }] },
+    { content: 'done' },
+  ]);
+  const out = await runAgentLoop({
+    systemPrompt: 's', task: 't', cwd,
+    toolset: toolsetFor(['Read']), provider: { baseUrl: 'http://x/v1', model: 'm' }, chatImpl,
+  });
+  const toolMsg = chatImpl.seen[1].find((m) => m.role === 'tool');
+  assert.ok(!toolMsg.content.includes('⟦elided:'), 'no marker when compression off');
+  assert.equal(out.compression.blocks_compressed, 0);
+  assert.equal(out.compression.bytes_after, out.compression.bytes_before);
+});
+
+test('AL-9: compression ON — large tool result is crushed in history, original retrievable from Elision store', async () => {
+  const cwd = _ws({
+    'log.txt': _bigLog(),
+    '.nubos-pilot/config.json': JSON.stringify({ compression: { enabled: true } }),
+  });
+  const chatImpl = _scriptedChat([
+    { toolCalls: [{ id: 't1', name: 'Read', arguments: '{"path":"log.txt"}' }] },
+    { content: 'done' },
+  ]);
+  const out = await runAgentLoop({
+    systemPrompt: 's', task: 't', cwd,
+    toolset: toolsetFor(['Read']), provider: { baseUrl: 'http://x/v1', model: 'm' }, chatImpl,
+  });
+  const toolMsg = chatImpl.seen[1].find((m) => m.role === 'tool');
+  assert.equal(out.compression.blocks_compressed, 1);
+  assert.ok(out.compression.bytes_after < out.compression.bytes_before, 'history shrank');
+  const m = toolMsg.content.match(/⟦elided:([a-f0-9]{12})/);
+  assert.ok(m, 'marker with hash present in history');
+  const back = elision.retrieve(m[1], cwd);
+  assert.equal(back.status, 'ok');
+  assert.ok(back.original.includes('ERROR: boom at module_0'), 'original recoverable byte-for-byte');
+});
+
+test('AL-10: end-to-end — model retrieves an elided original mid-loop via context-expand', async () => {
+  const cwd = _ws({
+    'log.txt': _bigLog(),
+    '.nubos-pilot/config.json': JSON.stringify({ compression: { enabled: true } }),
+  });
+  let expanded = null;
+  const chat = async ({ messages }) => {
+    chat.n = (chat.n || 0) + 1;
+    if (chat.n === 1) {
+      return { content: '', finishReason: 'tool_calls', toolCalls: [{ id: 'r1', name: 'Read', arguments: '{"path":"log.txt"}' }] };
+    }
+    if (chat.n === 2) {
+      const toolMsg = messages.filter((m) => m.role === 'tool').pop();
+      const hash = toolMsg.content.match(/⟦elided:([a-f0-9]{12})/)[1];
+      return { content: '', finishReason: 'tool_calls', toolCalls: [{ id: 'r2', name: 'context-expand', arguments: JSON.stringify({ hash }) }] };
+    }
+    expanded = messages.filter((m) => m.role === 'tool').pop().content;
+    return { content: 'done', finishReason: 'stop', toolCalls: [] };
+  };
+  const out = await runAgentLoop({
+    systemPrompt: 's', task: 't', cwd,
+    toolset: toolsetFor(['Read'], { withExpand: true }), provider: { baseUrl: 'http://x/v1', model: 'm' }, chatImpl: chat,
+  });
+  assert.equal(out.stopped, 'final');
+  assert.ok(expanded.includes('ERROR: boom at module_0'), 'model recovered the full original byte-for-byte');
+  assert.ok(!expanded.includes('⟦elided:'), 'the expanded original carries no marker');
+});
+
+test('AL-7: assistant echo is rebuilt in OpenAI wire shape; ids round-trip even if provider omits them', async () => {
+  const cwd = _ws({ 'a.txt': 'A', 'b.txt': 'B' });
+  const chatImpl = async ({ messages }) => {
+    chatImpl.seen = (chatImpl.seen || []).concat([JSON.parse(JSON.stringify(messages))]);
+    if (!chatImpl.called) {
+      chatImpl.called = true;
+      return {
+        content: '', finishReason: 'tool_calls',
+        toolCalls: [
+          { id: 'call_0', name: 'Read', arguments: '{"path":"a.txt"}' },
+          { id: 'call_1', name: 'Read', arguments: '{"path":"b.txt"}' },
+        ],
+        raw: { role: 'assistant', content: '', tool_calls: [{ function: { name: 'Read' } }] },
+      };
+    }
+    return { content: 'done', toolCalls: [], finishReason: 'stop', raw: { role: 'assistant', content: 'done' } };
+  };
+  const out = await runAgentLoop({
+    systemPrompt: 's', task: 't', cwd,
+    toolset: toolsetFor(['Read']), provider: { baseUrl: 'http://x/v1', model: 'm' }, chatImpl,
+  });
+  assert.equal(out.stopped, 'final');
+  const secondTurn = chatImpl.seen[1];
+  const assistant = secondTurn.find((m) => m.role === 'assistant' && m.tool_calls);
+  assert.equal(assistant.tool_calls[0].type, 'function');
+  assert.equal(assistant.tool_calls[0].function.name, 'Read');
+  assert.deepEqual(assistant.tool_calls.map((c) => c.id), ['call_0', 'call_1']);
+  const toolMsgs = secondTurn.filter((m) => m.role === 'tool');
+  assert.deepEqual(toolMsgs.map((m) => m.tool_call_id), ['call_0', 'call_1']);
+});
+
+test('AL-12: output_steering ON — system prompt is enriched and mechanical turns downgrade effort', async () => {
+  const cwd = _ws({
+    'a.txt': 'A',
+    '.nubos-pilot/config.json': JSON.stringify({
+      compression: {
+        enabled: true,
+        output_steering: { enabled: true, verbosity_profile: 'terse', effort_routing: { enabled: true, base_effort: 'high', mechanical_effort: 'low' } },
+      },
+    }),
+  });
+  const seen = [];
+  const chatImpl = async (args) => {
+    seen.push({ effort: args.effort, system: (args.messages.find((m) => m.role === 'system') || {}).content });
+    if (seen.length === 1) {
+      return { content: '', finishReason: 'tool_calls', toolCalls: [{ id: 'c0', name: 'Read', arguments: '{"path":"a.txt"}' }], raw: { role: 'assistant', content: '' } };
+    }
+    return { content: 'done', toolCalls: [], finishReason: 'stop', raw: { role: 'assistant', content: 'done' } };
+  };
+  const out = await runAgentLoop({
+    systemPrompt: 'you are x', task: 't', cwd,
+    toolset: toolsetFor(['Read']), provider: { baseUrl: 'http://x/v1', model: 'm', effort: 'high' }, chatImpl,
+  });
+  assert.equal(out.stopped, 'final');
+  assert.match(seen[0].system, /<nubos_output_shaping>[\s\S]*<\/nubos_output_shaping>$/, 'system prompt carries the shaping block');
+  assert.equal(seen[0].effort, 'high', 'first turn (new user ask) keeps full effort');
+  assert.equal(seen[1].effort, 'low', 'second turn (clean tool result) downgrades to low');
+});

package/lib/runtime/dispatch.cjs

@@ -0,0 +1,174 @@
+'use strict';
+
+const path = require('node:path');
+const { NubosPilotError } = require('../core.cjs');
+const { loadAgentSource } = require('../agents.cjs');
+const { resolveFromConfig } = require('../../bin/np-tools/resolve-model.cjs');
+const { assertPreflight } = require('./preflight.cjs');
+const { runAgentLoop } = require('./agent-loop.cjs');
+const { toolsetFor } = require('./tools/index.cjs');
+const elision = require('../elision.cjs');
+const { AUDITED_AGENTS, auditToolUse } = require('../nubosloop-audit.cjs');
+const { TASK_ID_RE } = require('../ids.cjs');
+const metrics = require('../metrics.cjs');
+
+function _lintOutput(content, schemaName) {
+  if (!schemaName) return null;
+  try {
+    const { getSchema } = require('../schemas/index.cjs');
+    const { lintContent } = require('../output-lint.cjs');
+    const res = lintContent(String(content == null ? '' : content), getSchema(schemaName));
+    return { ok: !!res.ok, schema: schemaName, violations: res.violations || [] };
+  } catch (err) {
+    return { ok: false, schema: schemaName, error: (err && err.code) || 'output-lint-failed' };
+  }
+}
+
+function _defaultInWorktree(cwd) {
+  try {
+    const { listSliceWorktrees } = require('../worktree.cjs');
+    return listSliceWorktrees(cwd).some((w) => cwd === w.path || cwd.startsWith(w.path + path.sep));
+  } catch { return false; }
+}
+
+function _parseTools(toolsField) {
+  if (Array.isArray(toolsField)) return toolsField.map((s) => String(s).trim()).filter(Boolean);
+  if (typeof toolsField === 'string') return toolsField.split(',').map((s) => s.trim()).filter(Boolean);
+  return [];
+}
+
+async function dispatchOffHost(o) {
+  const opts = o || {};
+  const cwd = opts.cwd || process.cwd();
+  const deps = opts.deps || {};
+  const resolve = deps.resolve || resolveFromConfig;
+  const preflight = deps.preflight || assertPreflight;
+  const loadSource = deps.loadSource || loadAgentSource;
+  const runLoop = deps.runLoop || runAgentLoop;
+  const isInWorktree = deps.isInWorktree || _defaultInWorktree;
+  const now = deps.now || (() => new Date().toISOString());
+
+  if (typeof opts.agent !== 'string' || !opts.agent) {
+    throw new NubosPilotError('dispatch-no-agent', 'dispatchOffHost requires an agent name', {});
+  }
+
+  const res = resolve({ agentOrTier: opts.agent, cwd });
+  if (res.kind !== 'openai-compat') {
+    throw new NubosPilotError(
+      'dispatch-not-offhost',
+      'agent "' + opts.agent + '" resolves to provider "' + res.provider + '" (kind ' + res.kind
+        + ') — dispatchOffHost only runs openai-compat providers',
+      { provider: res.provider, kind: res.kind },
+    );
+  }
+  const audited = AUDITED_AGENTS.includes(opts.agent);
+  const hasTaskCtx = typeof opts.taskId === 'string' && TASK_ID_RE.test(opts.taskId);
+  if (audited && !hasTaskCtx) {
+    throw new NubosPilotError(
+      'offhost-audited-agent-unsupported',
+      'agent "' + opts.agent + '" is Rule-9-audited and needs a task context off-host — pass --task-id '
+        + 'M<NNN>-S<NNN>-T<NNNN> so the search-evidence ledger + audit apply. (Wired into execute-phase in ADR-0021 Slice 4b.)',
+      { agent: opts.agent, audited: AUDITED_AGENTS.slice() },
+    );
+  }
+
+  if (opts.allowBash && !isInWorktree(cwd)) {
+    throw new NubosPilotError(
+      'offhost-bash-requires-sandbox',
+      'off-host Bash needs worktree isolation — run inside a slice worktree (workflow.worktree_isolation) so model-driven shell is confined. Refused outside one.',
+      { cwd: path.basename(cwd) },
+    );
+  }
+
+  const src = loadSource(opts.agent, cwd);
+  const declared = _parseTools(src.frontmatter && src.frontmatter.tools);
+  const cx = elision.compressionContext(cwd);
+  const toolset = toolsetFor(declared, {
+    readOnly: !!opts.readOnly,
+    allowBash: !!opts.allowBash,
+    withSearch: audited,
+    withExpand: cx.enabled,
+    ctx: { taskId: hasTaskCtx ? opts.taskId : null, customRulesPath: opts.customRulesPath },
+  });
+  const provider = { baseUrl: res.baseUrl, apiKeyEnv: res.apiKeyEnv, model: res.model };
+  const _os = cx.outputSteering;
+  if (_os && _os.effortRouting && _os.baseEffort) provider.effort = _os.baseEffort;
+
+  await preflight(provider);
+
+  const started = now();
+  let result = null;
+  let status = 'ok';
+  let errObj = null;
+  try {
+    result = await runLoop({
+      systemPrompt: src.body,
+      task: opts.task,
+      toolset,
+      provider,
+      cwd,
+      maxIterations: opts.maxIterations,
+    });
+  } catch (err) {
+    status = 'error';
+    errObj = { code: (err && err.code) || 'dispatch-loop-failed', message: (err && err.message) || 'loop failed' };
+  }
+  const ended = now();
+
+  let metricsRecorded = false;
+  try {
+    const record = metrics.buildRecord({
+      agent: opts.agent,
+      tier: res.tier,
+      resolved_model: res.model,
+      phase: opts.phase || '',
+      plan: opts.plan || 'offhost',
+      task: opts.taskId || 'adhoc',
+      started_at: started,
+      ended_at: ended,
+      status,
+      runtime: res.provider,
+      error: errObj,
+    });
+    metrics.appendRecord(record, { cwd });
+    metricsRecorded = true;
+  } catch {}
+
+  if (status === 'error') {
+    throw new NubosPilotError(errObj.code, errObj.message, { agent: opts.agent, provider: res.provider });
+  }
+
+  let rule9 = null;
+  if (audited && hasTaskCtx && !opts.skipAudit) {
+    try {
+      rule9 = auditToolUse(opts.taskId, opts.agent, (result.toolLog || []).map((t) => t.name), cwd);
+    } catch (err) { rule9 = { ok: false, error: (err && err.code) || 'audit-failed' }; }
+  }
+
+  const toolsAdvertised = (toolset.schemas || []).length;
+  const toolCalls = (result.toolLog || []).length;
+  const capability = {
+    toolsAdvertised,
+    toolCalls,
+    mutating: toolset.names.some((n) => n === 'Write' || n === 'Edit' || n === 'Bash'),
+    ok: !(toolsAdvertised > 0 && toolCalls === 0),
+  };
+
+  return {
+    agent: opts.agent,
+    provider: res.provider,
+    model: res.model,
+    content: result.content,
+    stopped: result.stopped,
+    iterations: result.iterations,
+    toolLog: result.toolLog,
+    tools: toolset.names,
+    rule9,
+    capability,
+    output_lint: _lintOutput(result.content, opts.outputSchema),
+    metrics_recorded: metricsRecorded,
+    compression: result.compression || null,
+  };
+}
+
+module.exports = { dispatchOffHost, _parseTools };

package/lib/runtime/dispatch.test.cjs

@@ -0,0 +1,207 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { dispatchOffHost, _parseTools } = require('./dispatch.cjs');
+
+const _dirs = [];
+function _root() {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'np-dispatch-')));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  _dirs.push(root);
+  return root;
+}
+afterEach(() => { while (_dirs.length) { try { fs.rmSync(_dirs.pop(), { recursive: true, force: true }); } catch {} } });
+
+const NOW = () => '2026-06-16T00:00:00.000Z';
+
+function _deps(over) {
+  return Object.assign({
+    resolve: () => ({ kind: 'openai-compat', provider: 'ollama', model: 'qwen2.5-coder:32b', baseUrl: 'http://localhost:11434/v1', apiKeyEnv: null, tier: 'sonnet' }),
+    preflight: async () => ({ ok: true }),
+    loadSource: () => ({ frontmatter: { name: 'np-executor', tier: 'sonnet', tools: 'Read, Write, Bash, Grep' }, body: 'You are the executor.' }),
+    runLoop: async () => ({ content: 'done', stopped: 'final', iterations: 2, toolLog: [{ name: 'Read', ok: true }] }),
+    now: NOW,
+  }, over || {});
+}
+
+test('DSP-1: happy path returns the envelope and records a metrics row', async () => {
+  const cwd = _root();
+  const out = await dispatchOffHost({ agent: 'np-architect', task: 'do it', cwd, deps: _deps() });
+  assert.equal(out.provider, 'ollama');
+  assert.equal(out.model, 'qwen2.5-coder:32b');
+  assert.equal(out.content, 'done');
+  assert.equal(out.stopped, 'final');
+  assert.equal(out.metrics_recorded, true);
+  const meta = fs.readFileSync(path.join(cwd, '.nubos-pilot', 'metrics', 'meta.jsonl'), 'utf-8');
+  const rec = JSON.parse(meta.trim().split('\n').pop());
+  assert.equal(rec.runtime, 'ollama');
+  assert.equal(rec.resolved_model, 'qwen2.5-coder:32b');
+  assert.equal(rec.status, 'ok');
+});
+
+test('DSP-1c: provider.effort is seeded from base_effort only when effort routing is opted in', async () => {
+  const bare = _root();
+  let seenBare;
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd: bare,
+    deps: _deps({ runLoop: async ({ provider }) => { seenBare = provider; return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; } }) });
+  assert.equal(seenBare.effort, undefined, 'no effort field absent opt-in (providers without support unaffected)');
+
+  const on = _root();
+  fs.writeFileSync(path.join(on, '.nubos-pilot', 'config.json'), JSON.stringify({
+    compression: { enabled: true, output_steering: { enabled: true, effort_routing: { enabled: true, base_effort: 'high', mechanical_effort: 'low' } } },
+  }));
+  let seenOn;
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd: on,
+    deps: _deps({ runLoop: async ({ provider }) => { seenOn = provider; return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; } }) });
+  assert.equal(seenOn.effort, 'high', 'base_effort seeds the provider effort');
+});
+
+test('DSP-2: a native-kind agent is refused (dispatch-not-offhost)', async () => {
+  const cwd = _root();
+  const deps = _deps({ resolve: () => ({ kind: 'native', provider: 'claude', model: null, tier: 'opus' }) });
+  await assert.rejects(
+    dispatchOffHost({ agent: 'np-planner', task: 't', cwd, deps }),
+    (e) => e.code === 'dispatch-not-offhost',
+  );
+});
+
+test('DSP-3: Bash is excluded by default; opt-in (inside a worktree) includes it', async () => {
+  const cwd = _root();
+  let seen = null;
+  const deps = _deps({
+    isInWorktree: () => true,
+    runLoop: async ({ toolset }) => { seen = toolset.names.slice(); return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; },
+  });
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps });
+  assert.deepEqual(seen, ['Read', 'Write', 'Grep']);
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps, allowBash: true });
+  assert.deepEqual(seen, ['Read', 'Write', 'Bash', 'Grep']);
+});
+
+test('DSP-3b: readOnly restricts the toolset to read tools', async () => {
+  const cwd = _root();
+  let seen = null;
+  const deps = _deps({ runLoop: async ({ toolset }) => { seen = toolset.names.slice(); return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; } });
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps, readOnly: true });
+  assert.deepEqual(seen, ['Read', 'Grep']);
+});
+
+test('DSP-4: a loop error records an error metrics row and rethrows the loop code', async () => {
+  const cwd = _root();
+  const { NubosPilotError } = require('../core.cjs');
+  const deps = _deps({ runLoop: async () => { throw new NubosPilotError('provider-http-error', 'HTTP 500', {}); } });
+  await assert.rejects(dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps }), (e) => e.code === 'provider-http-error');
+  const rec = JSON.parse(fs.readFileSync(path.join(cwd, '.nubos-pilot', 'metrics', 'meta.jsonl'), 'utf-8').trim().split('\n').pop());
+  assert.equal(rec.status, 'error');
+});
+
+test('DSP-5: preflight runs before the loop and a failure aborts before any tool call', async () => {
+  const cwd = _root();
+  let looped = false;
+  const { NubosPilotError } = require('../core.cjs');
+  const deps = _deps({
+    preflight: async () => { throw new NubosPilotError('preflight-failed', 'unreachable', {}); },
+    runLoop: async () => { looped = true; return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; },
+  });
+  await assert.rejects(dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps }), (e) => e.code === 'preflight-failed');
+  assert.equal(looped, false);
+});
+
+test('DSP-6: missing agent throws dispatch-no-agent', async () => {
+  await assert.rejects(dispatchOffHost({ task: 't', deps: _deps() }), (e) => e.code === 'dispatch-no-agent');
+});
+
+test('DSP-8: a Rule-9-audited agent without a task context is refused off-host', async () => {
+  const cwd = _root();
+  await assert.rejects(
+    dispatchOffHost({ agent: 'np-executor', task: 't', cwd, deps: _deps() }),
+    (e) => e.code === 'offhost-audited-agent-unsupported',
+  );
+  await assert.rejects(
+    dispatchOffHost({ agent: 'np-researcher', task: 't', cwd, deps: _deps() }),
+    (e) => e.code === 'offhost-audited-agent-unsupported',
+  );
+});
+
+test('DSP-9: an audited agent WITH a valid --task-id is allowed; Rule-9 audit rides the envelope', async () => {
+  const cwd = _root();
+  let seen = null;
+  const deps = _deps({ runLoop: async ({ toolset }) => { seen = toolset.names.slice(); return { content: 'x', stopped: 'final', iterations: 1, toolLog: [{ name: 'knowledge-search', ok: true }] }; } });
+  const out = await dispatchOffHost({ agent: 'np-executor', task: 't', cwd, deps, taskId: 'M001-S001-T0001' });
+  assert.ok(seen.includes('knowledge-search'), 'knowledge-search must be injected for an audited agent');
+  assert.ok(out.rule9 && typeof out.rule9 === 'object', 'audit result must ride the envelope');
+});
+
+test('DSP-9b: with recorded search evidence the Rule-9 audit passes', async () => {
+  const cwd = _root();
+  const taskId = 'M001-S001-T0002';
+  require('../nubosloop-audit.cjs').recordSearchEvidence(taskId, 'auth', cwd);
+  const deps = _deps({ runLoop: async () => ({ content: 'x', stopped: 'final', iterations: 1, toolLog: [{ name: 'knowledge-search', ok: true }] }) });
+  const out = await dispatchOffHost({ agent: 'np-executor', task: 't', cwd, deps, taskId });
+  assert.equal(out.rule9.ok, true);
+  assert.equal(out.rule9.violation, null);
+});
+
+test('DSP-12: skipAudit defers Rule-9 to the orchestrator (rule9 not run by dispatch)', async () => {
+  const cwd = _root();
+  const deps = _deps({ runLoop: async () => ({ content: 'x', stopped: 'final', iterations: 1, toolLog: [{ name: 'knowledge-search', ok: true }] }) });
+  const out = await dispatchOffHost({ agent: 'np-executor', task: 't', cwd, deps, taskId: 'M001-S001-T0003', skipAudit: true });
+  assert.equal(out.rule9, null, 'dispatch must not audit when skipAudit is set');
+});
+
+test('DSP-10: --allow-bash outside a worktree is refused (offhost-bash-requires-sandbox)', async () => {
+  const cwd = _root();
+  const deps = _deps({ isInWorktree: () => false });
+  await assert.rejects(
+    dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps, allowBash: true }),
+    (e) => e.code === 'offhost-bash-requires-sandbox',
+  );
+});
+
+test('DSP-11: --allow-bash inside a worktree includes Bash in the toolset', async () => {
+  const cwd = _root();
+  let seen = null;
+  const deps = _deps({
+    isInWorktree: () => true,
+    runLoop: async ({ toolset }) => { seen = toolset.names.slice(); return { content: 'x', stopped: 'final', iterations: 1, toolLog: [] }; },
+  });
+  await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps, allowBash: true });
+  assert.ok(seen.includes('Bash'), 'Bash must be available inside a worktree');
+});
+
+test('DSP-13: outputSchema lints the result and rides the envelope (null when unset)', async () => {
+  const cwd = _root();
+  const out1 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: _deps() });
+  assert.equal(out1.output_lint, null, 'no schema ⇒ no lint');
+  const out2 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: _deps(), outputSchema: 'researcher-output' });
+  assert.ok(out2.output_lint && out2.output_lint.schema === 'researcher-output', 'lint result rides the envelope');
+  assert.equal(typeof out2.output_lint.ok, 'boolean');
+});
+
+test('DSP-14: capability flags zero tool-calls despite an advertised toolset (tool-calling unsupported signal)', async () => {
+  const cwd = _root();
+  const noTools = _deps({ runLoop: async () => ({ content: 'just text', stopped: 'final', iterations: 1, toolLog: [] }) });
+  const out1 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: noTools });
+  assert.equal(out1.capability.ok, false);
+  assert.equal(out1.capability.toolCalls, 0);
+  assert.ok(out1.capability.toolsAdvertised > 0);
+  assert.equal(out1.capability.mutating, true);
+
+  const usedTool = _deps({ runLoop: async () => ({ content: 'x', stopped: 'final', iterations: 2, toolLog: [{ name: 'Read', ok: true }] }) });
+  const out2 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: usedTool });
+  assert.equal(out2.capability.ok, true);
+
+  const ro = _deps({ runLoop: async () => ({ content: 'x', stopped: 'final', iterations: 1, toolLog: [] }) });
+  const out3 = await dispatchOffHost({ agent: 'np-architect', task: 't', cwd, deps: ro, readOnly: true });
+  assert.equal(out3.capability.ok, false);
+  assert.equal(out3.capability.mutating, false);
+});
+
+test('DSP-7: _parseTools accepts a comma string or an array', () => {
+  assert.deepEqual(_parseTools('Read, Write , Bash'), ['Read', 'Write', 'Bash']);
+  assert.deepEqual(_parseTools(['Read', 'Grep']), ['Read', 'Grep']);
+  assert.deepEqual(_parseTools(undefined), []);
+});