fix(agent): only a goal the person typed is their word to the reviewer

agentFlow recorded every goal it was handed as the person's, but not every caller passes typed text: a
diagram retry sends a request built from the model's spec and the repair report, and Retry after a resume
re-runs lastAgentGoal read back from the session file — the very text resumeSession keeps out of the
person's words. Both landed in the reviewer's PERSON section.

agentFlow now takes { typed }, which only handleSend sets (the chat's send message, from the input box);
the goal is recorded only then. A typed goal that Retry repeats is already recorded; Continue's fixed
instruction and a diagram retry stay activity. Run, not regexed, where a harness lifts the call site
(handleSend in sessionExpiredHost, retryDiagram in diagramHost); the response bar's Retry/Continue lines
are pinned from source, with exactly one caller allowed to say typed: true.

Author: ndemianc

extensions/levelcode-ai/extension.js

@@ -2240,7 +2240,12 @@ async function compactAgentMemory() {
 }
 
 let lastAgentGoal = null;   // remembered so the response bar's Retry can re-run it
-async function agentFlow(text, imageBlocks) {
+/**
+ * Run the agent on a goal. `opts.typed` says the person typed `text` into the chat just now (handleSend);
+ * every other caller — a diagram retry, Retry and Continue on the response bar — passes words the person
+ * did not type here, some of them read back from a session file or written by the model.
+ */
+async function agentFlow(text, imageBlocks, opts) {
 	if (text && text.trim()) { lastAgentGoal = text; }
 	const cfg = aiConfig();
 	const providerId = currentProviderId();
@@ -2269,7 +2274,10 @@ async function agentFlow(text, imageBlocks) {
 	checkpoints.push(currentCheckpoint);
 	post({ type: 'checkpointOpened', turnId: currentCheckpoint.turnId });
 	agentMessages.push(goalMsg);
-	if (text && text.trim()) { humanGoals.push(text.trim()); if (humanGoals.length > 20) { humanGoals.splice(0, humanGoals.length - 20); } }
+	// Only what the person typed becomes their word to the Ask When Risky reviewer. A retried or generated goal
+	// stays activity: a typed goal Retry repeats is already on this list, and one from a resumed session must
+	// not be (see resumeSession).
+	if (opts && opts.typed && text && text.trim()) { humanGoals.push(text.trim()); if (humanGoals.length > 20) { humanGoals.splice(0, humanGoals.length - 20); } }
 	trimAgentMemory();
 	// Sessions: mark where THIS turn's messages begin (the goal, post-trim). agentMessages is a trimmed
 	// live window, but a persisted session is the FULL append-only history — so after the run we persist
@@ -2578,7 +2586,7 @@ async function handleSend(text, 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); return; }
+	if (agentMode) { await agentFlow(text, imageBlocks, { typed: true }); return; }
 	const cfg = aiConfig();
 	const providerId = currentProviderId();
 	dbg('chat.send', { provider: providerId, model: activeModel(cfg, providerId), chars: text.length, history: conversation.length });

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

@@ -131,7 +131,7 @@ const makeHost = new Function('env', [
 
 function boot(over) {
 	const { vscode, ui } = makeVscode();
-	const stats = [], logs = [], flows = [], posted = [];
+	const stats = [], logs = [], flows = [], typedFlows = [], posted = [];
 	const settings = Object.assign({ 'diagrams.enabled': true }, over && over.settings);
 	const diagrams = createDiagrams({ resolveLink: (link) => diagramLinks.resolveLink(link, [{ name: 'app', root: ws }]), onStat: (ev) => stats.push(ev) });
 	const env = {
@@ -144,7 +144,7 @@ function boot(over) {
 		aiConfig: () => ({ get: (k, d) => (k in settings ? settings[k] : d) }),
 		dbg: (label, data) => logs.push({ label, data }),
 		recordDiagramStat: (ev) => stats.push(ev),
-		agentFlow: async (text) => { flows.push(text); host.setGoal(text); },
+		agentFlow: async (text, _img, opts) => { flows.push(text); if (opts && opts.typed) { typedFlows.push(text); } host.setGoal(text); },
 		findCompactionCut, estimateMsgTokens, meterModel: () => 'm',
 		prepProviderRequest: async () => ({ ok: true, providerId: 'claude', model: 'm' }),
 		authRetry: async (req, fn) => fn(req),
@@ -157,7 +157,7 @@ function boot(over) {
 		replaySessionExpired: async () => { }, postContextFiles: () => { }, refreshSessions: () => { }, focusChatView: () => { }
 	};
 	const host = makeHost(env);
-	return { host, ui, diagrams, stats, logs, flows, posted };
+	return { host, ui, diagrams, stats, logs, flows, typedFlows, posted };
 }
 const jev = () => ({
 	title: 'Jev classifies; your code decides the action',
@@ -490,6 +490,9 @@ function drawn(b, input, key) { b.diagrams.beginRun(); const out = b.diagrams.re
 			assert.ok(b.flows[0].includes('/edges/2/to: unknown node "ghost". Known ids: in, jev, bill.'), 'the model is told what was wrong');
 			assert.ok(b.flows[0].includes('1 edge dropped: unknown nodes'));
 			assert.strictEqual(b.host.goal(), 'the user\'s real goal', 'Retry/Continue on the response bar still mean what the user asked');
+			// The redraw request is written from the model's spec and the repair report — never the person's
+			// word to the Ask When Risky reviewer.
+			assert.deepStrictEqual(b.typedFlows, [], 'a diagram retry was passed off as typed');
 		});
 
 		// ── context budget: stubbed at compaction, never turn by turn ───────────────────────────────

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

@@ -133,9 +133,10 @@ test('AGENT MODE: the default path carries images too', () => {
 	// I shipped this broken. handleSend stored the bytes and then early-returned into agentFlow(text),
 	// 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.
-	assert.match(ext, /if \(agentMode\) \{ await agentFlow\(text, imageBlocks\); return; \}/,
+	// (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; \}/,
 		'agent mode must forward the image blocks');
-	assert.match(ext, /async function agentFlow\(text, imageBlocks\)/, 'agentFlow must accept them');
+	assert.match(ext, /async function agentFlow\(text, imageBlocks(, opts)?\)/, 'agentFlow must accept them');
 	const body = fnBody(ext, 'agentFlow');
 	assert.match(body, /imageBlocks && imageBlocks\.length/, 'and use them when present');
 	assert.match(body, /\[\.\.\.labelImages\(imageBlocks\), \{ type: 'text', text \}\]/, 'images lead the goal');

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

@@ -108,7 +108,7 @@ const makeHost = new Function('env', [
 	'  sealLiveSession, resetConversationState, postContextFiles, postMemoryDigest, sessionsManager, currentContextLimit,',
 	'  refreshSessions, focusChatView, review, checkpoints } = env;',
 	"const SYSTEM_PROMPT = 'system';",
-	'let activeWebview = env.webview, cloudSignedIn = env.signedIn, agentMode = false, conversation = [], pendingContext = null, conversationEpoch = 0, abort = null;',
+	'let activeWebview = env.webview, cloudSignedIn = env.signedIn, agentMode = !!env.agentMode, conversation = [], pendingContext = null, conversationEpoch = 0, abort = null;',
 	'let agentMessages = [], currentCheckpoint = null, lastAgentGoal = null;',
 	// resumeSession starts the Ask When Risky reviewer's record of the person's goals over (agentReview.js).
 	'let humanGoals = [], humanAnswers = [];',
@@ -184,7 +184,7 @@ function boot(over) {
 	for (const k of Object.keys(o.settings)) { if (o.settings[k] === null) { delete settings[k]; } else { settings[k] = o.settings[k]; } }
 
 	const secrets = new Map(), state = new Map(), posted = [], ops = [];
-	const calls = { refresh: [], stream: [], keyPrompts: 0 };
+	const calls = { refresh: [], stream: [], keyPrompts: 0, flows: [] };
 	const vscode = { workspace: { getConfiguration: (section) => ({ get: (k, d) => (settings[section + '.' + k] === undefined ? d : settings[section + '.' + k]) }) } };
 	const webview = { postMessage: (m) => { posted.push(m); } };
 	const t = {
@@ -214,7 +214,7 @@ function boot(over) {
 		last: (type) => posted.filter((m) => m.type === type).pop()
 	};
 	const env = {
-		vscode, resolveGateway, webview: o.webview ? webview : undefined, signedIn: !!o.access,
+		vscode, resolveGateway, webview: o.webview ? webview : undefined, signedIn: !!o.access, agentMode: !!o.agentMode,
 		session: o.refreshTimeoutMs ? Object.assign({}, session, { REFRESH_TIMEOUT_MS: o.refreshTimeoutMs }) : session,
 		ctx: {
 			secrets: {
@@ -275,7 +275,7 @@ function boot(over) {
 		aiConfig: () => vscode.workspace.getConfiguration('levelcode.ai'),
 		dbg: () => { }, refreshCloudProfile: async () => { }, fetchCloudRoster: () => { }, sendConfigToWebview: () => { },
 		gatewayModel: () => 'cloud-model', maxOutputTokens: () => 4096, currentProviderId: () => 'claude',
-		baseUrlFor: () => '', activeModel: () => t.activeModelId || 'claude-model', storeImages: () => [], agentFlow: async () => { },
+		baseUrlFor: () => '', activeModel: () => t.activeModelId || 'claude-model', storeImages: () => [], agentFlow: async (text, _img, opts) => { calls.flows.push({ text, typed: !!(opts && opts.typed) }); },
 		listWorkspaceFiles: async () => [], workspaceMapBlock: () => '', activeFileBlock: () => '',
 		contextFileBlocks: async () => [], gatherAutoContext: async () => ({ blocks: [], names: [] }),
 		labelImages: (b) => b, withImages: (m) => m,
@@ -1084,6 +1084,21 @@ async function test(name, fn) { await fn(); n++; console.log('  ok - ' + name);
 		assert.strictEqual(t.calls.refresh.length, 1);
 	});
 
+	await test('SEND in agent mode: the goal reaches agentFlow marked as typed — the Ask When Risky reviewer\'s only source of the person\'s word', async () => {
+		const t = boot({ agentMode: true, settings: { 'levelcode.ai.providerMode': 'byok' }, byokKey: 'k' });
+		await t.host.handleSend('Run the tests and fix what fails', []);
+		assert.deepStrictEqual(t.calls.flows, [{ text: 'Run the tests and fix what fails', 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');
+		assert.match(src, /if \(agentMode\) \{ await agentFlow\(text, imageBlocks, \{ typed: true \}\); return; \}/);
+		assert.match(src, /case 'retry':[^\n]*await agentFlow\(lastAgentGoal\);/);
+		assert.match(src, /case 'continueAgent':[^\n]*await agentFlow\('Continue from where you left off[^\n]*'\);/);
+	});
+
 	await test('`ready` does not say it twice: the handler has just read the same token, and the card is replayed last', async () => {
 		const t = boot({ expired: true, profile: { name: 'Ada' } });
 		await t.host.checkCloudSession('ready');