fix(agent): #102 review — stacked marks count, and a lone mark is not emphasis

Two findings, both on saysDone(), both right.

1. One mark was taken off a line start, where a model may stack several.
   "> ## **Done:** …" and "- > **Done:** …" were still read as unfinished, and
   with a "next " in the answer still nudged — the bug this branch is for, in
   another shape. Reproduced on the reviewed code through the loop: a second
   turn is requested for both.

   The line-start strip now takes every mark stacked there.

2. Every `*`, `_`, backtick and `~` was deleted before the line was looked
   for, and a lone mark is not emphasis: it is part of a name. A turn that
   said "Let me write config.yaml:" and then pasted

       ```yaml
       _done: false
       ```

   was read as finished. develop nudges that turn; the reviewed code ended the
   run without the write it promised. So this was a regression the first
   commit made, and it reached further than YAML: a Python field,
   `_done: bool = False`, and a JS key, `_done: false,`, were read the same
   way.

   Emphasis is now unwrapped only as a pair, and only where it opens the line:
   an opening run of marks before a non-space, a closing run after one, and no
   word character after the closing run — so the `_` inside `default_factory`
   closes nothing. **Done:**, **Done**:, a whole sentence in bold or italics,
   `Done:` as code and **_Done:_** are all still found: 520 combinations of
   stacked marks, emphasis and where it closes were checked, and none is
   missed. Nine lone-mark lines that the reviewed code took for a Done line no
   longer are.

Found while doing it: the line test could take seconds to say no.
/(^|\n)\s*done/ lets the whitespace run across lines, so from every line start
it read on through all the blank lines below. The work grows with the square
of their number — 64,000 blank lines took 1.8 seconds on a quiet machine,
128,000 took 7 — and that is on develop, for a turn that degenerates into line
breaks. This branch had widened it: once marks are stripped, a line of nothing
but marks is a blank line too.

The whitespace now stays on its line, /(^|\n)[^\S\n]*done/. It is the same
test: over 5.6 million strings, exhaustive to six tokens and random beyond,
the two never disagree. The same inputs now answer in milliseconds.

The last-word test still reads the text as written, as decided. Its comment
gave a reason that no longer holds — with pairs only, a fence's backticks are
not taken away, so the pasted shell loop is nudged either way — and now gives
the one that does: a turn whose last line is the quoted keyword, `done`.

test/agentDone.test.js goes from 7 to 10 cases: stacked marks and every way a
pair can close; lone marks, the pasted file among them; that pasted file
through the real loop, still nudged; and the line test's pattern read out of
the source, because no verdict can tell the two patterns apart and a clock in
a test is a flake. It fails 4 cases on the reviewed commit. Thirteen mutations
of the new code each fail a case.

50 suites, 972 cases, 0 failing (scripts/test-extensions.sh) on this commit's
tree, on macOS with Node 24 and in a Linux container with Node 20. With the
checkout's tsc, agent.js still reports develop's 94 diagnostics.

Unchanged: a "- Done: parser" bullet in a progress list ends a run that also
promises more work, and so does a YAML list item, "- done: false", in a pasted
file. develop nudges both. They come with the list case, which reads a mark,
not emphasis. A Done line behind an emoji is still not recognised.

Not run in the editor against a live model.

Author: ndemianc

extensions/levelcode-ai/agent.js

@@ -719,7 +719,7 @@ async function setupMcp(ctx, wsFolders, dbg) {
  * Did the model say it is finished — a line starting with "Done:" (what SYSTEM_BASE asks for), or
  * text that simply ends in "done"?
  *
- * The LINE is looked for with markdown marks stripped. A model that writes it as `**Done:** …`,
+ * The LINE is looked for with its markdown marks taken off. A model that writes it as `**Done:** …`,
  * `## Done: …` or `- Done: …` has still said it; read literally, the marks sit between the line start
  * and the word, so a finished run was taken for an unfinished one and — when the answer also read as
  * a promise of more work, for which one "next " is enough — nudged until the model said Done a second
@@ -728,13 +728,20 @@ async function setupMcp(ctx, wsFolders, dbg) {
  * @returns {boolean}
  */
 function saysDone(text) {
-	// Strip quote, heading and list marks at line starts, then emphasis marks, before the line test.
 	const plain = text
-		.replace(/^[ \t]*(?:[>#]+|[-*+]|\d+\.)[ \t]+/gm, '')
-		.replace(/[*_`~]+/g, '');
-	// The last-word test reads the text AS WRITTEN. With the backticks gone, a turn that ends in a fenced
-	// shell loop ends in "done" as well — and a command pasted where a tool call belonged is a stall.
-	return /(^|\n)\s*done\s*:/i.test(plain) || /\bdone\.?\s*$/i.test(text.trim());
+		// Quote, heading and list marks at a line start — as many as are stacked there (`> ## Done:`).
+		.replace(/^[ \t]*(?:(?:[>#]+|[-*+]|\d+\.)[ \t]+)+/gm, '')
+		// Then the emphasis that opens the line, and only as a PAIR: `**Done:** …`, `_Done: shipped._`.
+		// A lone mark is part of a name. Deleting every `_` made a Done line of `_done: false` in a pasted
+		// file, and the turn that pasted it instead of writing it was no longer nudged.
+		.replace(/^[ \t]*[*_~`]+(?=\S)(.*?\S)[*_~`]+(?!\w)/gm, '$1');
+	// `[^\S\n]` is whitespace that stays on its line — the same test as `\s*` there, at a different cost.
+	// With `\s*` each line start read on through every blank line below it, and a line of nothing but
+	// marks is blank by now: the work grew with the square of their number, and 64,000 took seconds.
+	if (/(^|\n)[^\S\n]*done\s*:/i.test(plain)) { return true; }
+	// The last-word test reads the text AS WRITTEN, as it always has. The marks come off to find a line;
+	// taken off the last word too, a turn that ends by quoting a loop's `done` would pass for a finish.
+	return /\bdone\.?\s*$/i.test(text.trim());
 }
 
 async function runAgent(ctx) {

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

@@ -106,6 +106,12 @@ const PASTED_LOOP = 'Let me run this to rename them:\n'
 	+ 'done\n'
 	+ '```';
 
+// And a file pasted where a write_file call belonged. `_done` is a key: one mark, and nothing closes it.
+const PASTED_FILE = 'Let me write config.yaml:\n'
+	+ '```yaml\n'
+	+ '_done: false\n'
+	+ '```';
+
 (async () => {
 	try {
 		// ---- 1. the verdict --------------------------------------------------------------------------
@@ -126,6 +132,39 @@ const PASTED_LOOP = 'Let me run this to rename them:\n'
 			}
 		});
 
+		test('VERDICT: the marks may be stacked, and the emphasis may hold the word or the whole sentence', () => {
+			const done = [
+				// #102 review: one mark was taken off the line start, where a model may stack several.
+				'> ## **Done:** quote, heading and bold',
+				'- > **Done:** list, quote and bold',
+				'> - Done: a quoted list item',
+				// Emphasis is unwrapped as a pair, so every way of closing it has to be found.
+				'**Done**: the colon outside the bold',
+				'**Done: the whole sentence in bold.**',
+				'_Done: the whole sentence in italics._',
+				'**_Done:_** two kinds at once',
+				// And the line may still sit below blank ones, indented — with marks or without.
+				'The suite passes.\n\n\n\t Done: after blank lines, behind a tab and a space.',
+				'The suite passes.\n\n   **Done:** indented, and in no list.'
+			];
+			for (const text of done) {
+				assert.strictEqual(saysDone(text), true, 'not read as finished: ' + JSON.stringify(text));
+			}
+		});
+
+		test('VERDICT: a lone mark belongs to a name — it is not emphasis', () => {
+			// #102 review: every `_` used to be deleted, and that made a Done line of a key in a pasted file.
+			// The second text is here for its later `_`: inside a word, it closes nothing.
+			const names = [
+				PASTED_FILE,
+				'_done: bool = field(default_factory=bool)',
+				'*done: x'
+			];
+			for (const text of names) {
+				assert.strictEqual(saysDone(text), false, 'read as finished: ' + JSON.stringify(text));
+			}
+		});
+
 		test('VERDICT: the word alone, or no word at all, is not a Done line', () => {
 			// Stripping marks must not turn "done" somewhere in a sentence into the line the prompt asks for.
 			const notDone = [
@@ -143,10 +182,12 @@ const PASTED_LOOP = 'Let me run this to rename them:\n'
 			assert.strictEqual(saysDone('The diagram is in docs/flow.html and it renders. All done.'), true);
 		});
 
-		test('VERDICT: the "done" that closes a shell loop is not the model saying it', () => {
-			// Why that second clause reads the text as written, and only the Done LINE is looked for with the
-			// marks stripped: take the fence's backticks away and this turn ends in the word.
+		test('VERDICT: a "done" that is code is not the model saying it', () => {
+			// The shell's own keyword, closing a pasted loop — and the same keyword quoted on a turn's last
+			// line. The second is why that clause reads the text as written: the marks come off to find a
+			// LINE, and taken off here as well they would leave this turn ending in the word.
 			assert.strictEqual(saysDone(PASTED_LOOP), false);
+			assert.strictEqual(saysDone('Let me check how the loop is closed. Its last line is:\n`done`'), false);
 		});
 
 		// ---- 2. the loop asks it ---------------------------------------------------------------------
@@ -171,11 +212,28 @@ const PASTED_LOOP = 'Let me run this to rename them:\n'
 			assert.deepStrictEqual(r.end, ['done']);
 		});
 
-		await testAsync('LOOP: a command pasted in a fence is still nudged, though its last word is "done"', async () => {
-			const r = await run([PASTED_LOOP, 'Done: renamed the files.']);
-			assert.strictEqual(r.nudges, 1, 'a pasted command passed for a finished run');
-			assert.strictEqual(r.asked, 2);
-			assert.deepStrictEqual(r.end, ['done']);
+		await testAsync('LOOP: code pasted in a fence is still nudged, whatever word or key it holds', async () => {
+			for (const pasted of [PASTED_LOOP, PASTED_FILE]) {
+				const r = await run([pasted, 'Done: it is on disk now.']);
+				assert.strictEqual(r.nudges, 1, 'pasted code passed for a finished run: ' + JSON.stringify(pasted));
+				assert.strictEqual(r.asked, 2);
+				assert.deepStrictEqual(r.end, ['done']);
+			}
+		});
+
+		// ---- 3. the cost of asking -------------------------------------------------------------------
+
+		test('SOURCE: the line test does not read on across blank lines', () => {
+			// `(^|\n)\s*done` and `(^|\n)[^\S\n]*done` accept exactly the same texts. The first one reads from
+			// every line start through all the blank lines below it, so its work grows with the square of
+			// their number: a turn that is mostly line breaks — or mostly lines of bare marks, once those are
+			// stripped — took seconds at 64,000 lines. No verdict can tell the two apart, and a clock in a
+			// test is a flake; so the pattern itself is read out of the source, as agentNoWorkspace.test.js
+			// reads NEEDS_ROOT.
+			const src = fs.readFileSync(path.join(__dirname, '..', 'agent.js'), 'utf8');
+			const m = /\/\(\^\|\\n\)(.*?)done\\s\*:\/i\.test\(plain\)/.exec(src);
+			assert.ok(m, 'agent.js no longer tests for the Done line where this suite looks');
+			assert.ok(!m[1].includes('\\s'), 'the line test may match whitespace across lines again: ' + m[1]);
 		});
 	} finally {
 		fs.rmSync(root, { recursive: true, force: true });