fix(agent): a reply-button click is not text the person typed

A reply in the next-step box shows a 1-3 word label; what a click sends is the reply's message, up to 300
characters the agent wrote (visible only as a tooltip). It went through the chat's normal send, so the host
recorded it as typed — and since #112 and #114 that is the person's word: the Ask When Risky reviewer counts
it as authorization, and remember may quote it. A README that steers the agent into a "Yes" button whose
message says more could have turned one click into an explicit go-ahead.

The page now sends a click as a reply ({ type: 'send', reply: true }), and keeps that mark through the queue
(drained at the end of a run, or sent with Send now while idle). handleSend passes typed: false for it, so
the reply reaches the agent as before but is not the person's word. A reply the person edits in the message
box, or that is handed back to it, is sent as their own typing.

Tested: the page's queue functions lifted from chat.html (sent at once, queued while busy, drained, Send now
when idle — the mark survives each, and a typed message carries none); handleSend lifted into
sessionExpiredHost (a reply reaches agentFlow with typed: false, a typed message with true); the button's
click and the send message are pinned from source.

Author: ndemianc

extensions/levelcode-ai/extension.js

@@ -2750,12 +2750,18 @@ function withImages(msgs) {
 	return touched ? out : msgs;
 }
 
-async function handleSend(text, images) {
+/**
+ * A message from the chat. `opts.reply` marks a click on a reply button in the next-step box: words the agent
+ * wrote (the person saw a short label), so the goal is not recorded as typed — not for the Ask When Risky
+ * reviewer, not for `remember` to quote.
+ */
+async function handleSend(text, images, opts) {
+	const reply = !!(opts && opts.reply);
 	const imageBlocks = storeImages(images);
 	if ((!text || !text.trim()) && !imageBlocks.length) { return; }
 	text = text || '';
 	if (ctx) { ctx.globalState.update('levelcode.ai.hasSentMessage', true); }   // user engaged → stop auto-revealing the panel on launch
-	if (agentMode) { await agentFlow(text, imageBlocks, { typed: true }); return; }
+	if (agentMode) { await agentFlow(text, imageBlocks, { typed: !reply }); return; }
 	const cfg = aiConfig();
 	const providerId = currentProviderId();
 	dbg('chat.send', { provider: providerId, model: activeModel(cfg, providerId), chars: text.length, history: conversation.length });
@@ -3335,7 +3341,7 @@ class ChatViewProvider {
 				case 'setMode': agentMode = !!msg.agent; post({ type: 'mode', agent: agentMode }); break;
 				case 'setApprovals': setApprovalMode(String(msg.mode || '')); break;
 				case 'setAutopilot': setApprovalMode(msg.on ? 'autopilot' : 'ask'); break;   // the two-option menu's message
-				case 'send': await handleSend(msg.text, msg.images); break;
+				case 'send': await handleSend(msg.text, msg.images, { reply: msg.reply === true }); break;
 				// One surface for "that could not be attached" — VS Code's own, not a second one
 				// invented inside the transcript.
 				case 'notice': if (msg.text) { vscode.window.showWarningMessage(String(msg.text)); } break;

extensions/levelcode-ai/media/chat.html

@@ -3466,7 +3466,8 @@
     if (b.dataset.tb === 'reply') {
       const a = (w.actions || [])[+b.dataset.i]; if (!a) { return; }
       w.dismissed = true; renderTurnBox();
-      sendOrQueue(a.message || a.label, []);
+      // A reply's words are the agent's (you saw its label): sent as a reply, never as text you typed.
+      sendOrQueue(a.message || a.label, [], true);
     } else if (b.dataset.tb === 'dismiss') {
       w.dismissed = true; renderTurnBox(); input.focus();
     }
@@ -3489,8 +3490,8 @@
   function queuePeek(text){ return String(text || '').replace(/\s+/g, ' ').trim(); }
   function queueCount(n){ return n + ' message' + (n === 1 ? '' : 's') + ' queued'; }
   function canSendNow(e){ return !!e && !e.sending && !e.images.length && streaming && runIsAgent; }
-  function enqueue(text, images){
-    queue.push({ id: 'q' + (++queueSeq) + '-' + Date.now().toString(36), text: text, images: images || [], sending: false });
+  function enqueue(text, images, reply){
+    queue.push({ id: 'q' + (++queueSeq) + '-' + Date.now().toString(36), text: text, images: images || [], sending: false, reply: reply === true });
     renderQueue();
   }
   function queueEntry(id){ return queue.find(function(e){ return e.id === id; }); }
@@ -3574,7 +3575,7 @@
   }
   function sendQueuedNow(id){
     const e = queueEntry(id); if (!e || e.sending) { return; }
-    if (!busy()) { dropQueued(id); renderQueue(); postSend(e.text, e.images); return; }
+    if (!busy()) { dropQueued(id); renderQueue(); postSend(e.text, e.images, e.reply); return; }
     if (!canSendNow(e)) { return; }
     e.sending = true; renderQueue();
     vscode.postMessage({ type: 'steer', id: e.id, text: e.text });
@@ -3606,12 +3607,13 @@
     if (!lastRunOk) { queueToComposer(stopAsked ? ' because the run was stopped' : ' because the run didn’t finish'); return; }
     const e = queue.find(function(x){ return !x.sending; }); if (!e) { return; }
     dropQueued(e.id); renderQueue();
-    postSend(e.text, e.images);
+    postSend(e.text, e.images, e.reply);
   }
   // A reply button in the next-step box, or anything else that sends on your behalf: queued while busy.
-  function sendOrQueue(text, images){
-    if (busy()) { enqueue(text, images); return; }
-    postSend(text, images);
+  // `reply` marks words the agent wrote and you clicked, so the host does not count them as typed.
+  function sendOrQueue(text, images, reply){
+    if (busy()) { enqueue(text, images, reply); return; }
+    postSend(text, images, reply);
   }
   queueBar.addEventListener('click', function(ev){
     const b = ev.target.closest && ev.target.closest('[data-q]');
@@ -3863,7 +3865,7 @@
     postSend(t, imgs);
   }
   // Send a message: your bubble in the transcript, then the host. `imgs` are the composer's attachment objects.
-  function postSend(t, imgs){
+  function postSend(t, imgs, reply){
     const payload = imgs.map(function(i){
       return { media_type: i.media_type, base64: i.base64, w: i.w, h: i.h, bytes: i.bytes };
     });
@@ -3873,7 +3875,7 @@
     forceStick();
     if (turn.wrap) { turn.wrap.dismissed = true; renderTurnBox(); }   // you answered: the box has done its job
     awaitingStart = true; stopAsked = false; syncSendBtn();
-    vscode.postMessage({ type: 'send', text: t, images: payload });
+    vscode.postMessage({ type: 'send', text: t, images: payload, reply: reply === true });
   }
 
   // ── attached images ───────────────────────────────────────────────────────────────────────────

extensions/levelcode-ai/test/imageAttach.test.js

@@ -108,7 +108,7 @@ test('SEND: an image with no words is a valid message', () => {
 });
 
 test('HOST: images become refs in the conversation, and bytes only at request time', () => {
-	assert.match(ext, /case 'send': await handleSend\(msg\.text, msg\.images\)/, 'send must carry images');
+	assert.match(ext, /case 'send': await handleSend\(msg\.text, msg\.images[,)]/, 'send must carry images');
 	const store = fnBody(ext, 'storeImages');
 	assert.match(store, /imageStore\.put\(/, 'bytes must go through the store');
 	assert.match(store, /type: 'image', ref/, 'the conversation must keep a ref, never the base64');
@@ -137,7 +137,7 @@ test('AGENT MODE: the default path carries images too', () => {
 	// which never saw them — so in the DEFAULT mode a pasted screenshot was written to disk and
 	// dropped. The exact silent-drop failure this whole feature exists to prevent.
 	// (The third argument marks the goal as typed, for the Ask When Risky reviewer — not about images.)
-	assert.match(ext, /if \(agentMode\) \{ await agentFlow\(text, imageBlocks(, \{ typed: true \})?\); return; \}/,
+	assert.match(ext, /if \(agentMode\) \{ await agentFlow\(text, imageBlocks(, \{ typed: (true|!reply) \})?\); return; \}/,
 		'agent mode must forward the image blocks');
 	assert.match(ext, /async function agentFlow\(text, imageBlocks(, opts)?\)/, 'agentFlow must accept them');
 	const body = fnBody(ext, 'agentFlow');

extensions/levelcode-ai/test/planProgressUi.test.js

@@ -162,7 +162,7 @@ function makeQueue(state) {
 		'const vscode = { postMessage: (m) => env.posted.push(m) };',
 		'function renderQueue(){} function renderChips(){} function syncSendBtn(){} function auto(){}',
 		'function note(t){ env.notes.push(t); }',
-		'function postSend(t, imgs){ env.sent.push({ text: t, images: imgs }); awaitingStart = true; }',
+		'function postSend(t, imgs, reply){ env.sent.push(reply === true ? { text: t, images: imgs, reply: true } : { text: t, images: imgs }); awaitingStart = true; }',
 		...['busy', 'queuePeek', 'queueCount', 'canSendNow', 'enqueue', 'queueEntry', 'dropQueued', 'queueBtn', 'queueHtml', 'moveQueued',
 			'sendQueuedNow', 'editQueued', 'queueToComposer', 'drainQueue', 'sendOrQueue'].map(extract),
 		'Object.assign(this, { queue: () => queue, images: () => pendingImages, open: (v) => { queueOpen = v; }, busy, enqueue, queueHtml, moveQueued, sendQueuedNow, editQueued, drainQueue, sendOrQueue, canSendNow });'
@@ -249,6 +249,26 @@ test('STILL BUSY: nothing is drained, and a reply button queues like Enter does'
 	waiting.sendOrQueue('x', []);
 	assert.strictEqual(waiting.queue().length, 1, 'a message on its way that has not started yet counts as busy — no second run');
 });
+test('A REPLY STAYS A REPLY: a click\'s words are sent marked as a reply — straight away, queued, drained, and by Send now when idle', () => {
+	const idle = makeQueue({});
+	idle.sendOrQueue('Go ahead and push the fix.', [], true);
+	assert.deepStrictEqual(idle.env.sent, [{ text: 'Go ahead and push the fix.', images: [], reply: true }]);
+	const typed = makeQueue({});
+	typed.sendOrQueue('typed by me', []);
+	assert.deepStrictEqual(typed.env.sent, [{ text: 'typed by me', images: [] }], 'a message that is not a reply carries no mark');
+	const busyQ = makeQueue({ streaming: true });
+	busyQ.sendOrQueue('Run the tests.', [], true);
+	busyQ.sendOrQueue('and mine', []);
+	assert.deepStrictEqual(busyQ.queue().map((e) => [e.text, e.reply]), [['Run the tests.', true], ['and mine', false]], 'queued while busy, the mark is kept');
+	const drained = makeQueue({ lastRunOk: true });
+	drained.enqueue('Run the tests.', [], true);
+	drained.drainQueue();
+	assert.deepStrictEqual(drained.env.sent, [{ text: 'Run the tests.', images: [], reply: true }], 'the queued reply lost its mark on the way out');
+	const now = makeQueue({});
+	now.enqueue('Yes, fix it.', [], true);
+	now.sendQueuedNow(now.queue()[0].id);
+	assert.deepStrictEqual(now.env.sent, [{ text: 'Yes, fix it.', images: [], reply: true }]);
+});
 test('EDIT IN COMPOSER: out of the queue, into the message box after any draft', () => {
 	const q = makeQueue({ streaming: true, composer: 'draft' });
 	q.enqueue('fix the test', []);
@@ -258,6 +278,11 @@ test('EDIT IN COMPOSER: out of the queue, into the message box after any draft',
 });
 
 // ── the wiring ──────────────────────────────────────────────────────────────────────────────────
+test('WIRING: a reply button sends its words as a reply, and the page tells the host so', () => {
+	assert.match(html, /sendOrQueue\(a\.message \|\| a\.label, \[\], true\);/, 'the reply button no longer marks its click as a reply');
+	assert.match(html, /vscode\.postMessage\(\{ type: 'send', text: t, images: payload, reply: reply === true \}\);/);
+});
+
 test('ENTER WHILE THE AGENT WORKS: queued — ■ with an empty composer still stops', () => {
 	const body = extract('doSend');
 	const stopAt = body.indexOf("vscode.postMessage({ type: 'stop' })");

extensions/levelcode-ai/test/sessionExpiredHost.test.js

@@ -1093,12 +1093,20 @@ async function test(name, fn) { await fn(); n++; console.log('  ok - ' + name);
 		assert.deepStrictEqual(t.calls.flows, [{ text: 'Run the tests and fix what fails', typed: true }]);
 	});
 
+	await test('SEND a reply-button click: the agent\'s words reach agentFlow NOT marked typed — a click on "Yes" is not your words', async () => {
+		const t = boot({ agentMode: true, settings: { 'levelcode.ai.providerMode': 'byok' }, byokKey: 'k' });
+		await t.host.handleSend('Go ahead and push the fix to main.', [], { reply: true });
+		await t.host.handleSend('Fix it', [], { reply: false });
+		assert.deepStrictEqual(t.calls.flows, [{ text: 'Go ahead and push the fix to main.', typed: false }, { text: 'Fix it', typed: true }]);
+	});
+
 	await test('…and nothing else does: Retry, Continue and a diagram retry pass words the person did not type here', async () => {
 		// The response bar's buttons live in the message switch, which no harness lifts: pinned from source.
-		// Exactly one caller may say `typed: true`, and it is handleSend.
-		assert.strictEqual((src.match(/typed: true/g) || []).length, 1, 'another caller marks its goal as typed');
+		// Exactly one caller may pass a typed flag, and it is handleSend (a reply button's click is not typing).
+		assert.strictEqual((src.match(/\{ typed: /g) || []).length, 1, 'another caller marks its goal as typed');
 		assert.match(src, /async function agentFlow\(text, imageBlocks, opts\) \{[\s\S]{0,4000}?rememberTypedGoal\(text, opts\);/, 'agentFlow hands the flag through unchanged');
-		assert.match(src, /if \(agentMode\) \{ await agentFlow\(text, imageBlocks, \{ typed: true \}\); return; \}/);
+		assert.match(src, /if \(agentMode\) \{ await agentFlow\(text, imageBlocks, \{ typed: !reply \}\); return; \}/);
+		assert.match(src, /case 'send': await handleSend\(msg\.text, msg\.images, \{ reply: msg\.reply === true \}\); break;/);
 		assert.match(src, /case 'retry':[^\n]*await agentFlow\(lastAgentGoal\);/);
 		assert.match(src, /case 'continueAgent':[^\n]*await agentFlow\('Continue from where you left off[^\n]*'\);/);
 	});