@semalt-ai/code 1.19.0 → 1.20.1

package/test/stream-parser.test.js

@@ -87,6 +87,30 @@ test('reasoning_content is collected separately from content', async () => {
   assert.strictEqual(res.reasoning, 'let me think');
 });
 
+test('onReasoning fires once, before content, when reasoning_content is first seen', async () => {
+  // Live-narration safety signal (a): the UI eager-open gate needs to know the
+  // structured reasoning channel is in use BEFORE the first content token.
+  const order = [];
+  const srv = await startSseServer({ chunks: [
+    sse({ choices: [{ delta: { reasoning_content: 'thinking a' } }] }),
+    sse({ choices: [{ delta: { reasoning_content: ' thinking b' } }] }),
+    sse({ choices: [{ delta: { content: 'answer' } }] }),
+    DONE,
+  ] });
+  try {
+    const api = clientFor(srv.base);
+    await api.chatStream([{ role: 'user', content: 'hi' }], {
+      silent: true,
+      onReasoning: () => order.push('reasoning'),
+      onToken: (t) => order.push(`token:${t}`),
+    });
+  } finally {
+    await srv.close();
+  }
+  // Exactly one onReasoning, and it precedes the first content token.
+  assert.deepStrictEqual(order, ['reasoning', 'token:answer']);
+});
+
 test('native tool_calls deltas accumulate by index into structured calls', async () => {
   const { res } = await run([
     sse({ choices: [{ delta: { tool_calls: [{ index: 0, id: 'call_1', type: 'function', function: { name: 'read_file', arguments: '' } }] } }] }),

package/test/theme-palette.test.js

@@ -0,0 +1,166 @@
+'use strict';
+
+// Output Refactor — Phase 2.5: saturated palette + one theme table + NO_COLOR.
+//
+// These tests pin the INTENT of the phase (not just bytes): colour resolves
+// through a single table (theme.js), the palette is saturated + differentiated,
+// statuses are vivid, the gratuitous dim is gone, and NO_COLOR / non-TTY emit
+// no ANSI. The byte-level characterization lives in render-operation.test.js.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+// Colour is gated on `isTTY && !NO_COLOR`. Force colour ON for the palette
+// assertions; the NO_COLOR test flips it back off explicitly.
+process.stdout.isTTY = true;
+delete process.env.NO_COLOR;
+
+const theme = require('../lib/ui/theme');
+const ansi = require('../lib/ui/ansi');
+const { resolveLineColors, categoryForTag, colorEnabled, UI_THEME } = theme;
+const { formatToolLine } = require('../lib/ui/format');
+const { FullStatusBar } = require('../lib/ui/status-bar');
+
+const fg = (n) => `\x1b[38;5;${n}m`;
+
+// ---------------------------------------------------------------------------
+// One table — colour is defined in theme.js; ansi.js only re-exports it.
+// ---------------------------------------------------------------------------
+test('one table: ansi.js re-exports the palette from theme.js (same object refs)', () => {
+  // Same references prove ansi.js no longer DEFINES a competing palette — it
+  // hands back exactly what theme.js owns.
+  assert.strictEqual(ansi.THEME, theme.THEME, 'THEME is the same object on both surfaces');
+  assert.strictEqual(ansi.FG_RED, theme.FG_RED);
+  assert.strictEqual(ansi.FG_DARK, theme.FG_DARK);
+  assert.strictEqual(ansi.FG_CODE_BG, theme.FG_CODE_BG);
+  // theme.js is the home of the resolver + category map (the chrome seam).
+  assert.strictEqual(typeof theme.resolveLineColors, 'function');
+  assert.strictEqual(typeof theme.categoryForTag, 'function');
+});
+
+// ---------------------------------------------------------------------------
+// Saturation applied — categories distinct and vivid; git/mcp first-class.
+// ---------------------------------------------------------------------------
+test('saturation: category labels use the new saturated codes', () => {
+  assert.strictEqual(resolveLineColors('shell', 'ok').label, fg(214));
+  assert.strictEqual(resolveLineColors('file', 'ok').label,  fg(77));
+  assert.strictEqual(resolveLineColors('net', 'ok').label,   fg(39));
+  assert.strictEqual(resolveLineColors('web', 'ok').label,   fg(44));
+  assert.strictEqual(resolveLineColors('git', 'ok').label,   fg(170));
+  assert.strictEqual(resolveLineColors('mcp', 'ok').label,   fg(141));
+});
+
+test('saturation: git, mcp and the tool fallback are three DISTINCT colours (gap closed)', () => {
+  const git  = resolveLineColors('git', 'ok').label;
+  const mcp  = resolveLineColors('mcp', 'ok').label;
+  const tool = resolveLineColors('tool', 'ok').label;
+  assert.notStrictEqual(git, mcp);
+  assert.notStrictEqual(mcp, tool);
+  assert.notStrictEqual(git, tool);
+});
+
+test('saturation: the operation text is painted in the category colour, not terminal default', () => {
+  const c = resolveLineColors('shell', 'ok');
+  assert.strictEqual(c.op, fg(214));
+  assert.notStrictEqual(c.op, UI_THEME.default);
+});
+
+test('category map: git_* and mcp__* resolve to their own categories', () => {
+  assert.strictEqual(categoryForTag('git_commit'), 'git');
+  assert.strictEqual(categoryForTag('git_status'), 'git');
+  assert.strictEqual(categoryForTag('mcp__server__lookup'), 'mcp');
+  assert.strictEqual(categoryForTag('read'), 'file');
+  assert.strictEqual(categoryForTag('exec'), 'shell');
+  assert.strictEqual(categoryForTag('spawn_agent'), 'tool');
+});
+
+// ---------------------------------------------------------------------------
+// Status colours — saturated; the running glyph is never gray.
+// ---------------------------------------------------------------------------
+test('status: ok glyph 40, error glyph 203', () => {
+  assert.strictEqual(resolveLineColors('shell', 'ok').glyph, fg(40));
+  assert.strictEqual(resolveLineColors('shell', 'error').glyph, fg(203));
+  assert.strictEqual(resolveLineColors('shell', 'success').glyph, fg(40));
+  assert.strictEqual(resolveLineColors('shell', 'failure').glyph, fg(203));
+});
+
+test('status: the running/pending glyph is never gray (240) — category-tinted, or cyan for fallbacks', () => {
+  // A vivid category tints its own running glyph…
+  assert.strictEqual(resolveLineColors('file', 'pending').glyph, fg(77));
+  assert.strictEqual(resolveLineColors('shell', 'running').glyph, fg(214));
+  // …and the gray fallback categories use cyan 39 instead of their gray tint.
+  assert.strictEqual(resolveLineColors('tool', 'pending').glyph, fg(39));
+  assert.strictEqual(resolveLineColors('debug', 'running').glyph, fg(39));
+  // Never the old muted gray.
+  for (const cat of ['file', 'shell', 'tool', 'debug', 'net']) {
+    assert.notStrictEqual(resolveLineColors(cat, 'pending').glyph, fg(240));
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Dim removed — durations are subtle (244), not muted (240).
+// ---------------------------------------------------------------------------
+test('dim removed: duration/meta resolve to subtle 244 on success, red 203 on error', () => {
+  const ok = resolveLineColors('shell', 'ok');
+  assert.strictEqual(ok.dur, fg(244));
+  assert.strictEqual(ok.meta, fg(244));
+  assert.notStrictEqual(ok.dur, fg(240));
+  const err = resolveLineColors('shell', 'error');
+  assert.strictEqual(err.dur, fg(203));
+  assert.strictEqual(err.meta, fg(203));
+});
+
+test('dim removed: a pending tool line glyph is not the old muted gray', () => {
+  // Phase 3: the running (pending, non-blocking) glyph is an animated spinner
+  // frame (tool SPINNER_DEF), not the static dot. At durationMs 10 the frame is
+  // index 0 ('⣾'). The colour is still category-tinted (214), never gray.
+  const { SPINNER_DEFS } = require('../lib/ui/ansi');
+  const frame0 = SPINNER_DEFS.tool.frames[0];
+  const line = formatToolLine({ status: 'pending', tag: 'shell', arg: 'x', attrs: { command: 'x' }, durationMs: 10 });
+  assert.ok(!line.includes(fg(240)), 'no muted-240 anywhere in a pending line');
+  assert.ok(line.startsWith(`  ${fg(214)}${frame0}`), 'pending glyph is category-tinted (214) spinner frame, not gray');
+});
+
+// ---------------------------------------------------------------------------
+// NO_COLOR + non-TTY — the resolver emits no ANSI; lines render as plain text.
+// ---------------------------------------------------------------------------
+test('NO_COLOR: the resolver emits no ANSI and formatToolLine is plain text', () => {
+  process.env.NO_COLOR = '1';
+  try {
+    assert.strictEqual(colorEnabled(), false);
+    const c = resolveLineColors('shell', 'ok');
+    for (const k of ['glyph', 'label', 'op', 'dur', 'meta']) {
+      assert.strictEqual(c[k], '', `resolver.${k} is empty under NO_COLOR`);
+    }
+    const line = formatToolLine({ status: 'success', tag: 'shell', arg: 'npm install', attrs: { command: 'npm install' }, durationMs: 2300, meta: { exit_code: 0 } });
+    assert.ok(!line.includes('\x1b'), 'no ANSI escapes leak under NO_COLOR');
+    assert.strictEqual(line, '  ✓ shell · npm install · 2.3s · exit 0');
+  } finally {
+    delete process.env.NO_COLOR;
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Dim removed — the status-bar right fields are no longer wholesale-DIM.
+// ---------------------------------------------------------------------------
+test('status bar: the model field renders in accent, not a wholesale DIM wrap', () => {
+  process.stdout.isTTY = true;
+  const bar = new FullStatusBar({ cols: 200 }, () => {});
+  bar.setModel('claude-opus-4-8');
+  const line = bar.renderLine();
+  assert.ok(line.includes('claude-opus-4-8'), 'model name is present');
+  assert.ok(line.includes(`${UI_THEME.accent}claude-opus-4-8`), 'model rendered in accent');
+  assert.ok(!line.includes('\x1b[2mclaude'), 'model is not DIM-wrapped');
+});
+
+test('non-TTY: with stdout not a TTY, colour is off and lines are plain', () => {
+  const orig = process.stdout.isTTY;
+  process.stdout.isTTY = false;
+  try {
+    assert.strictEqual(colorEnabled(), false);
+    const line = formatToolLine({ status: 'success', tag: 'file', arg: 'x', attrs: { path: 'x' }, durationMs: 5 });
+    assert.ok(!line.includes('\x1b'), 'no ANSI escapes in non-TTY output');
+  } finally {
+    process.stdout.isTTY = orig;
+  }
+});

package/test/truncate-visible.test.js

@@ -0,0 +1,78 @@
+'use strict';
+
+// Direct unit tests for truncateVisible's trailing-reset decision and width
+// math. The trailing `\x1b[0m` must be CONTENT-conditional: appended only when
+// the (possibly truncated) output actually contains an escape, so escape-free
+// output stays escape-free (no NO_COLOR leak) while a cut-open SGR span is
+// still defensively closed (no color bleed).
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const { truncateVisible, termWidth } = require('../lib/ui/utils');
+
+const RST = '\x1b[0m';
+const RED = '\x1b[31m';
+
+test('escape-free string within budget has no trailing reset', () => {
+  const out = truncateVisible('hello world', 80);
+  assert.strictEqual(out, 'hello world');
+  assert.strictEqual(out.indexOf('\x1b'), -1);
+});
+
+test('escape-free string truncated mid-string has no trailing reset', () => {
+  const out = truncateVisible('hello world', 5);
+  assert.strictEqual(out, 'hello');
+  assert.strictEqual(out.indexOf('\x1b'), -1);
+});
+
+test('SGR cut mid-span ends with a reset (bleed-safe)', () => {
+  // Opening SGR is copied through (0 width); the next over-budget glyph breaks
+  // the loop BEFORE that span's own reset → unclosed color span → RST required.
+  const out = truncateVisible(RED + 'colored text', 4);
+  assert.ok(out.indexOf('\x1b') !== -1, 'opener should survive');
+  assert.ok(out.endsWith(RST), 'cut-open span must be closed with a reset');
+  assert.strictEqual(out, RED + 'colo' + RST);
+});
+
+test('fully-paired SGR within budget round-trips, reset present from content', () => {
+  // opener + content + closer all fit. Because an escape is present we append a
+  // trailing RST (defensive — idempotent on already-reset content).
+  const input = RED + 'hi' + RST;
+  const out = truncateVisible(input, 80);
+  assert.ok(out.startsWith(RED + 'hi' + RST), 'full span preserved');
+  assert.ok(out.endsWith(RST));
+  assert.strictEqual(out, input + RST);
+});
+
+test('max === 0 returns empty string (no bare reset)', () => {
+  assert.strictEqual(truncateVisible('anything', 0), '');
+  assert.strictEqual(truncateVisible(RED + 'x', 0), '');
+});
+
+test('empty / falsy input returns empty string', () => {
+  assert.strictEqual(truncateVisible('', 10), '');
+  assert.strictEqual(truncateVisible(null, 10), '');
+  assert.strictEqual(truncateVisible(undefined, 10), '');
+});
+
+test('CJK glyphs count as width 2 in the truncation column math', () => {
+  // Three ideographs (U+65E5 U+672C U+8A9E), each 2 cols. Budget 4 fits exactly
+  // two; output is escape-free → no trailing reset.
+  const cjk = '日本語';
+  const out = truncateVisible(cjk, 4);
+  assert.strictEqual(out, '日本');
+  assert.strictEqual(out.indexOf('\x1b'), -1);
+  assert.strictEqual(termWidth('日本'), 4);
+});
+
+test('combining marks count as width 0', () => {
+  // 'e' + combining acute (U+0301): 1 visible column total. Budget 1 keeps both
+  // the base glyph and the zero-width mark. Built from explicit codepoints so
+  // the test does not depend on the source file's Unicode normalization.
+  const input = 'é';
+  assert.strictEqual(termWidth(input), 1);
+  const out = truncateVisible(input, 1);
+  assert.strictEqual(out, input);
+  assert.strictEqual(out.indexOf('\x1b'), -1);
+});

package/test/view-image.test.js

@@ -0,0 +1,199 @@
+'use strict';
+
+// Coverage for the model-callable view_image tool: it stages a LOCAL image into
+// the model's vision context via the SAME readImage→images[]→buildProviderMessages
+// path the /image slash command uses — no parallel encoder. Asserts:
+//   (a) a valid PNG staged through the real agent loop reaches buildProviderMessages
+//   (b) both transport rails converge on the same ['view_image', path] tuple
+//   (c) unsupported / missing / oversized inputs return a clean text error (no crash)
+//   (d) an out-of-sandbox path is refused like any other file read
+//   (e) minimax now resolves vision-capable (true, not null)
+//   (f) view_image needs NO permission gate, while an effectful tool still does
+
+const { test, before, after } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const ui = require('../lib/ui');
+const { createApiClient } = require('../lib/api');
+const {
+  createToolExecutor, extractToolCalls, mapInvokeToCall,
+} = require('../lib/tools');
+const { createPermissionManager } = require('../lib/permissions');
+const { createAgentRunner } = require('../lib/agent');
+const { buildProviderMessages, resolveVisionCapability } = require('../lib/images');
+const { startMockLLM } = require('./harness/mock-llm');
+
+// Minimal valid PNG (magic bytes + ≥12 bytes so detectMediaType locks on).
+const PNG = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0, 0, 0, 13]);
+
+let prevKey;
+before(() => { prevKey = process.env.SEMALT_API_KEY; process.env.SEMALT_API_KEY = 'test-key'; });
+after(() => {
+  if (prevKey === undefined) delete process.env.SEMALT_API_KEY;
+  else process.env.SEMALT_API_KEY = prevKey;
+});
+
+// view_image reads through the real isPathSafe (CWD-confined), so test images must
+// live inside process.cwd(). Create a unique throwaway file there and clean it up.
+async function withCwdFile(name, buf, fn) {
+  const p = path.join(process.cwd(), `._vimg_test_${process.pid}_${name}`);
+  fs.writeFileSync(p, buf);
+  try { return await fn(p); } finally { try { fs.unlinkSync(p); } catch {} }
+}
+
+function buildRunner(base, extraConfig = {}) {
+  const config = {
+    api_base: base, api_key: 'test-key', default_model: 'test-model',
+    temperature: 0.5, request_timeout_ms: 5000, stream: true, models: [],
+    image_max_bytes: 5 * 1024 * 1024,
+    sandbox: { mode: 'off' },
+    ...extraConfig,
+  };
+  const getConfig = () => config;
+  const saveConfig = (c) => Object.assign(config, c);
+  const api = createApiClient({ getConfig, saveConfig, ui });
+  const pm = createPermissionManager(ui, { skipPermissions: true });
+  pm.setUICallbacks({ onAddMessage: () => {}, onShowModal: () => {}, onCloseModal: () => {}, onCaptureNavigation: () => () => {} });
+  const { agentExecShell, agentExecFile, describePermission } = createToolExecutor(pm, ui, getConfig);
+  const runner = createAgentRunner({
+    chatStream: api.chatStream, extractToolCalls, agentExecShell, agentExecFile,
+    describePermission, permissionManager: pm, ui, getConfig,
+  });
+  return { runner, agentExecFile, describePermission };
+}
+
+const noopCb = {
+  onToken: () => {}, onToolStart: () => {}, onToolEnd: () => {},
+  onError: () => {}, onRetry: () => {}, onAssistantMessage: () => {},
+};
+
+// ---------------------------------------------------------------------------
+// (a) Valid PNG staged through the real loop reaches buildProviderMessages.
+// ---------------------------------------------------------------------------
+test('view_image stages a valid PNG into vision context via the /image wire path', async () => {
+  const mock = await startMockLLM();
+  await withCwdFile('a.png', PNG, async (imgPath) => {
+    mock.replyWith(`<view_image>${imgPath}</view_image>`);
+    mock.replyWith('It is a red square.');
+    try {
+      const { runner } = buildRunner(mock.base);
+      const messages = [{ role: 'user', content: 'what is in the image?' }];
+      await runner.runAgentLoop(messages, 'test-model', 10, null, { callbacks: noopCb });
+
+      // The encoded image is attached to a message's images[] (same field /image sets).
+      const imgMsg = messages.find((m) => Array.isArray(m.images) && m.images.length);
+      assert.ok(imgMsg, 'a message carries the staged image');
+      assert.strictEqual(imgMsg.images[0].media_type, 'image/png');
+      assert.ok(typeof imgMsg.images[0].data === 'string' && imgMsg.images[0].data.length > 0, 'base64 bytes present');
+
+      // The model-facing text confirms attach without claiming the user can see it.
+      const toolMsg = messages.find((m) => typeof m.content === 'string' && /attached to your vision context/.test(m.content));
+      assert.ok(toolMsg, 'tool result text confirms the vision attach');
+      assert.match(toolMsg.content, /NOT displayed to the user/);
+
+      // buildProviderMessages (the api.js wire transform) turns it into an OpenAI image_url part.
+      const wire = buildProviderMessages(messages, 'openai');
+      const wireImg = wire.find((m) => Array.isArray(m.content) && m.content.some((p) => p.type === 'image_url'));
+      assert.ok(wireImg, 'buildProviderMessages produced an image_url content part');
+      const part = wireImg.content.find((p) => p.type === 'image_url');
+      assert.match(part.image_url.url, /^data:image\/png;base64,/);
+    } finally {
+      await mock.close();
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// (b) Both rails converge on the same tuple.
+// ---------------------------------------------------------------------------
+test('view_image: native params and XML tags converge on ["view_image", path]', () => {
+  // Native function-calling rail.
+  assert.deepStrictEqual(mapInvokeToCall('view_image', { path: '/a/b.png' }), ['view_image', '/a/b.png']);
+  // XML inline form.
+  assert.deepStrictEqual(extractToolCalls('<view_image>/a/b.png</view_image>'), [['view_image', '/a/b.png']]);
+  // XML attribute form (self-closing and paired).
+  assert.deepStrictEqual(extractToolCalls('<view_image path="/a/b.png"/>'), [['view_image', '/a/b.png']]);
+  assert.deepStrictEqual(extractToolCalls('<view_image path="/a/b.png"></view_image>'), [['view_image', '/a/b.png']]);
+  // Missing path → no call (native), like every other tool.
+  assert.strictEqual(mapInvokeToCall('view_image', {}), null);
+});
+
+// ---------------------------------------------------------------------------
+// (c) Unsupported / missing / oversized → clean text error, loop not crashed.
+// ---------------------------------------------------------------------------
+test('view_image: unsupported/missing/oversized return a clean error, never crash', async () => {
+  const { agentExecFile } = buildRunner('http://127.0.0.1:1'); // base unused here
+
+  // Missing file.
+  const missing = await agentExecFile('view_image', path.join(process.cwd(), 'definitely-not-here.png'));
+  assert.ok(missing.error && /not found|unreadable/i.test(missing.error), 'missing file → error');
+  assert.ok(!missing.image, 'no image staged on error');
+
+  // Unsupported format (a .txt with no image magic bytes, inside CWD).
+  await withCwdFile('notimg.txt', Buffer.from('hello, not an image'), async (p) => {
+    const bad = await agentExecFile('view_image', p);
+    assert.ok(bad.error && /Unsupported image format/i.test(bad.error), 'non-image → unsupported error');
+  });
+
+  // Oversized: a valid PNG under a deliberately tiny cap.
+  await withCwdFile('big.png', PNG, async (p) => {
+    const { agentExecFile: execTiny } = buildRunner('http://127.0.0.1:1', { image_max_bytes: 4 });
+    const big = await execTiny('view_image', p);
+    assert.ok(big.error && /too large/i.test(big.error), 'oversized → too-large error');
+  });
+});
+
+test('view_image: a missing-file call inside the loop ends cleanly without crashing', async () => {
+  const mock = await startMockLLM();
+  mock.replyWith(`<view_image>${path.join(process.cwd(), 'nope.png')}</view_image>`);
+  mock.replyWith('Could not load the image; stopping.');
+  try {
+    const { runner } = buildRunner(mock.base);
+    const messages = [{ role: 'user', content: 'view it' }];
+    const out = await runner.runAgentLoop(messages, 'test-model', 10, null, { callbacks: noopCb });
+    assert.ok(out && out.messages, 'loop returned normally (no crash)');
+    const toolMsg = messages.find((m) => typeof m.content === 'string' && /Tool execution results/.test(m.content));
+    assert.match(toolMsg.content, /Error —/);
+    assert.ok(!messages.some((m) => Array.isArray(m.images) && m.images.length), 'no image staged when the read failed');
+    assert.ok(messages.some((m) => m.role === 'assistant' && /stopping/i.test(m.content)), 'final answer recorded');
+  } finally {
+    await mock.close();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// (d) Path safety: out-of-sandbox path refused like any file read.
+// ---------------------------------------------------------------------------
+test('view_image: an out-of-sandbox path is refused', async () => {
+  const { agentExecFile } = buildRunner('http://127.0.0.1:1');
+  const res = await agentExecFile('view_image', '/etc/hostname');
+  assert.ok(res.error && /outside allowed area/i.test(res.error), 'path outside CWD refused');
+  assert.ok(!res.image, 'no image staged for a refused path');
+});
+
+// ---------------------------------------------------------------------------
+// (e) minimax now resolves vision-capable; unconfirmed qwen coder stays null.
+// ---------------------------------------------------------------------------
+test('resolveVisionCapability: minimax is now true; plain qwen coder stays null', () => {
+  assert.strictEqual(resolveVisionCapability({}, 'minimax-m3'), true);
+  assert.strictEqual(resolveVisionCapability({}, 'MiniMax-M3'), true);
+  // Unconfirmed model families must NOT be silently marked vision-capable.
+  assert.strictEqual(resolveVisionCapability({}, 'qwen2.5-coder-32b'), null);
+  // The pre-existing VL signal is unaffected.
+  assert.strictEqual(resolveVisionCapability({}, 'qwen2-vl-7b'), true);
+});
+
+// ---------------------------------------------------------------------------
+// (f) No permission gate for view_image; an effectful tool still gates.
+// ---------------------------------------------------------------------------
+test('view_image is read-only (no permission descriptor); an effectful tool still gates', async () => {
+  const { describePermission } = buildRunner('http://127.0.0.1:1');
+  const viewDesc = await describePermission(['view_image', '/x.png']);
+  assert.strictEqual(viewDesc, null, 'view_image resolves to no permission gate (read-only)');
+
+  // Isolation: an effectful network tool still produces a gate descriptor.
+  const dlDesc = await describePermission(['download', 'https://example.com/a.png']);
+  assert.ok(dlDesc && dlDesc.actionType, 'download still requires a permission descriptor');
+});

package/test/web-activity-ordering.test.js

@@ -26,8 +26,10 @@ const { createTurnHandler } = require('../lib/commands/chat-turn');
 // A fake writer + chatHistory that push into ONE shared ordered log. The web
 // summary commits via writerModule.endActivity (from webTracker.flush); the
 // answer commits via chatHistory.finalizeLastMessage. A non-web tool line also
-// commits via endActivity — distinguished by content (formatToolLine is mocked
-// to a recognizable "TOOL:<tag>" string).
+// commits via endActivity — distinguished by content. As of Phase 1 (Output
+// Refactor) the core tool line renders via the real descriptor→renderer (no
+// longer the injected formatToolLine seam), so web vs tool lines are told apart
+// by the web summary's wording, not a synthetic marker.
 function harness() {
   const events = [];
   const writerModule = {
@@ -47,6 +49,10 @@ function harness() {
     addMessage() {},
     streamToken() {},
     clearStreamingContent() {},
+    // Phase 7b boundary calls (chat-turn onToolStart / turn-end finally). No
+    // output-preview deferral is driven in these web-ordering scenarios, so a
+    // no-op keeps the harness focused on the web-summary ordering it tests.
+    deferToolOutput() {}, commitDeferredDetail() {},
     // An empty finalize (the suppressed intermediate iteration) commits no
     // visible answer bubble — only record the non-empty terminal answer, which
     // is what must land below the web summary.
@@ -187,7 +193,10 @@ test('non-web tool after web ops: summary flushed before the non-web tool line',
   const summaries = h.events.filter((e) => e.kind === 'web-summary');
   assert.strictEqual(summaries.length, 1, 'one web summary');
   const iSummary = indexOfKind(h.events, 'web-summary');
-  const iToolLine = h.events.findIndex((e) => e.kind === 'tool-line' && /read_file/.test(e.line));
+  // Phase 1 (Output Refactor): the core tool line now renders via the real
+  // descriptor→renderer (read_file → "read /x"), not the injected formatToolLine
+  // marker — match the rendered operation rather than the tag name.
+  const iToolLine = h.events.findIndex((e) => e.kind === 'tool-line' && /read \/x/.test(e.line));
   const iAnswer = indexOfKind(h.events, 'answer');
   assert.ok(iSummary < iToolLine, 'web summary precedes the non-web tool line (flushed by onToolStart)');
   assert.ok(iToolLine < iAnswer, 'and both precede the answer');

package/path

@@ -1 +0,0 @@
-contenttext