feat(transcript): the collapsed activity header says what happened, not how many things

Reported against the Claude Code reference: a finished run collapsed to "3 steps", which
tells nobody anything, where the reference says "Ran 2 commands".

THE CAUSE was narrower than it looked. groupAggregate already builds a real sentence for
file work and commands — "Read and edited extension.js, ran a command". What it could not
describe were the SETUP steps: project rules, project memory, recall, skills, MCP. Those
arrive as pre-baked emoji chips, chipStep dropped every one of them into `note`, `note`
contributes no phrase, and a run made only of setup fell through to the bare count.

So they are classified now — rules / memory / recall / skill / mcp / mcpcall / preview —
and each contributes a phrase. The screenshot's run goes from

    3 steps
to
    Loaded project rules and memory, connected MCP tools

Two distinctions worth having:

  - An MCP tool CALL (🔌 github · search_code) is different work from setup chatter about
    servers (🔌 mcp · github (26) · 2/26 allow-listed). The first says "Called github", the
    second "connected MCP tools". Collapsing them would let a run that actually used a
    tool read as if it had only connected one.
  - Setup is named LAST, so what changed still leads the sentence. A run that edited a file
    and loaded rules reads "Edited a.ts, ran a command, loaded project rules" — a test pins
    that ordering.

And the last-resort fallback names the first step and counts the rest ("Something unusual
happened and 1 more") rather than emitting a bare number. Sentence-cased like every other
path, which the first version was not.

The expanded steps now sit in one hairline container instead of loose rows under a heading
— closer to the reference, and it replaces a vertical cue rather than adding one: the group
already had a rail and a chevron, and a third was what made the expanded state look busy.

Bypass-verified: rules unrecognised; setup contributing no phrase; an MCP call lumped in
with setup; the fallback not sentence-cased; no setup kind detected at all.

groupAggregate and chipStep are now exposed on the test harness's api — they were extracted
into the sandbox but not reachable, so neither had ever been called directly by a test.

20 tests in groupReducer (was 16), 37 suites green.

Author: ndemianc

extensions/levelcode-ai/media/chat.html

@@ -558,7 +558,17 @@
   .tl-group .groupstop[hidden] { display: none; }
   .tl-group .groupstop:hover { color: var(--vscode-errorForeground, #f14c4c); }
   .tl-group .groupstop .ci { width: 12px; height: 12px; }
-  .tl-group .groupbody { padding: 2px 0 0 4px; }
+  /* The expanded steps read as ONE unit, not as loose rows under a heading. A hairline container
+     does that with less weight than the rail it replaces — the group already has a rail and a
+     chevron, and a third vertical cue was the thing that made the expanded state look busy. */
+  .tl-group .groupbody {
+    padding: 3px 2px; margin: 4px 0 2px;
+    border: 1px solid var(--border); border-radius: 7px;
+    background: var(--vscode-editorWidget-background, rgba(127,127,127,.045));
+  }
+  .tl-group .groupbody:empty { display: none; }
+  /* Rows sit flush inside the container and separate by hairline rather than by gap. */
+  .tl-group .groupbody > .tl + .tl { border-top: 1px solid var(--line-soft, rgba(127,127,127,.16)); }
   .tl-group.collapsed .groupbody { display: none; }
   .tl-group .groupbody > .tl > .tl-rail { display: none; }
   .tl-group .groupbody > .tl { margin: 0; }
@@ -2054,7 +2064,37 @@
     if (lists){ parts.push('listed files'); }
     if (cmds){ parts.push('ran ' + (cmds === 1 ? 'a command' : cmds + ' commands')); }
     if (steps.some((s) => s.kind === 'verify')){ parts.push('verified the edits'); }
-    if (!parts.length){ return steps.length === 1 ? '1 step' : steps.length + ' steps'; }
+
+    // Setup. Named LAST so real work still leads the sentence, but named — a run whose only steps
+    // were setup should say what it set up, not how many things it did.
+    const kinds = new Set(steps.map((s) => s.kind));
+    const ctxBits = [];
+    if (kinds.has('rules')) { ctxBits.push('project rules'); }
+    if (kinds.has('memory') || kinds.has('recall')) { ctxBits.push('memory'); }
+    if (ctxBits.length) { parts.push('loaded ' + ctxBits.join(' and ')); }
+    if (kinds.has('skill')) {
+      const names = uniq(steps.filter((s) => s.kind === 'skill').map((s) => s.path).filter(Boolean));
+      parts.push(names.length ? ('used the ' + files(names) + ' skill' + (names.length > 1 ? 's' : '')) : 'used a skill');
+    }
+    const calls = steps.filter((s) => s.kind === 'mcpcall');
+    if (calls.length) {
+      const servers = uniq(calls.map((s) => s.path).filter(Boolean));
+      parts.push('called ' + (servers.length ? files(servers) : (calls.length + ' MCP tools')));
+    } else if (kinds.has('mcp')) {
+      parts.push('connected MCP tools');
+    }
+    if (kinds.has('preview')) { parts.push('opened a preview'); }
+
+    if (!parts.length){
+      // Last resort: name the FIRST thing rather than count. "3 steps" tells no one anything.
+      const first = steps.find((s) => s.base && s.base.trim());
+      if (first){
+        const rest = steps.length - 1;
+        const one = first.base.trim() + (rest > 0 ? (' and ' + rest + ' more') : '');
+        return one.charAt(0).toUpperCase() + one.slice(1);   // same sentence-casing as the built path
+      }
+      return steps.length === 1 ? '1 step' : steps.length + ' steps';
+    }
     const sentence = parts.join(', ');
     return sentence.charAt(0).toUpperCase() + sentence.slice(1);
   }
@@ -2072,6 +2112,20 @@
     }
     if (kind === 'search' || icon === 'search'){ return { kind: 'search', base: titled || 'Search the workspace' }; }
     if (icon === 'list-tree'){ return { kind: 'list', base: titled || 'List files' }; }
+    // The run's SETUP steps. These arrive as pre-baked emoji chips and used to fall through to
+    // `note`, which contributes no phrase — so a run that loaded rules, memory and an MCP server
+    // summarised as the useless "3 steps". They describe real work and should say so.
+    if (/^📋 project rules/.test(t)){ return { kind: 'rules', base: titled || t, path: t.replace(/^📋 project rules · /, '') }; }
+    if (/^🧠 project memory/.test(t)){ return { kind: 'memory', base: titled || t }; }
+    if (/^🧠 recalling:/.test(t)){ return { kind: 'recall', base: titled || t }; }
+    if (/^🧩 using skill:/.test(t)){ return { kind: 'skill', base: titled || t, path: t.replace(/^🧩 using skill: /, '') }; }
+    if (/^🔌 /.test(t)){
+      // A tool CALL through a server (🔌 name · tool) is different work from setup chatter.
+      const call = /^🔌 (?!mcp · )([^·]+) · (.+)$/.exec(t);
+      return call ? { kind: 'mcpcall', base: titled || t, path: call[1].trim() }
+                  : { kind: 'mcp', base: titled || t };
+    }
+    if (/^🌐 preview/.test(t)){ return { kind: 'preview', base: titled || t }; }
     return { kind: 'note', base: titled || t };
   }
   // The label for a command step: the model's explanation (imperative, per the system prompt), or

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

@@ -101,7 +101,7 @@ function newHarness(groupsOn) {
 			'collapseMember', 'groupAppend', 'refreshGroupHead', 'finalizeGroup', 'closeGroup',
 			'groupStepDone', 'groupStepCounts', 'addAgentLine', 'add'
 		].map(extract).join('\n')
-		+ '\nthis.api = { openGroup, groupAppend, closeGroup, groupStepDone, groupStepCounts, addAgentLine, add, get curGroup(){ return curGroup; } };';
+		+ '\nthis.api = { openGroup, groupAppend, closeGroup, groupStepDone, groupStepCounts, addAgentLine, add, groupAggregate, chipStep, get curGroup(){ return curGroup; } };';
 	new Function('document', 'log', src).call(sandbox, { createElement: (t) => new El(t) }, log);
 	return { log, api: /** @type {any} */ (sandbox).api };
 }
@@ -317,4 +317,61 @@ test('a new user message re-arms the label', () => {
 	assert.strictEqual(roleOf(h.log.children[4]), 'LevelCode AI', 'the next turn is labelled again');
 });
 
+
+// ── the collapsed header must SAY something (the "3 steps" problem) ─────────────────────────────
+
+test('SETUP STEPS: a run that only loaded context says so, instead of counting', () => {
+	// This was the reported UX gap: rules + memory + MCP summarised as "3 steps", which tells nobody
+	// anything. They fell through chipStep into `note`, which contributes no phrase.
+	const S = newHarness().api;
+	const chip = (icon, text) => S.chipStep(icon, text, '', undefined, undefined);
+	const steps = [
+		chip('file', '📋 project rules · CLAUDE.md'),
+		chip('history', '🧠 project memory'),
+		chip('sparkle', '🔌 mcp · github (26) · 2/26 allow-listed')
+	];
+	const out = S.groupAggregate(steps);
+	assert.ok(!/^\d+ steps$/.test(out), 'must not fall back to a bare count: ' + out);
+	assert.match(out, /project rules/, 'should name the rules it loaded');
+	assert.match(out, /memory/, 'and the memory');
+	assert.match(out, /MCP/, 'and the MCP connection');
+});
+
+test('SETUP STEPS: each kind is recognised, not lumped into note', () => {
+	const S = newHarness().api;
+	const chip = (icon, text) => S.chipStep(icon, text, '', undefined, undefined);
+	const kindOf = (icon, text) => chip(icon, text).kind;
+	assert.strictEqual(kindOf('file', '📋 project rules · CLAUDE.md'), 'rules');
+	assert.strictEqual(kindOf('history', '🧠 project memory'), 'memory');
+	assert.strictEqual(kindOf('history', '🧠 recalling: how auth works'), 'recall');
+	assert.strictEqual(kindOf('sparkle', '🧩 using skill: pdf'), 'skill');
+	assert.strictEqual(kindOf('globe', '🌐 preview · http://localhost:3000'), 'preview');
+	// A tool CALL through a server is different work from setup chatter about servers.
+	assert.strictEqual(kindOf('sparkle', '🔌 github · search_code'), 'mcpcall');
+	assert.strictEqual(kindOf('sparkle', '🔌 mcp · github (26) · 2/26 allow-listed'), 'mcp');
+});
+
+test('SETUP STEPS: real work still leads the sentence', () => {
+	// Setup is named, but never at the expense of what actually changed.
+	const S = newHarness().api;
+	const chip = (icon, text) => S.chipStep(icon, text, '', undefined, undefined);
+	const out = S.groupAggregate([
+		chip('file', '📋 project rules · CLAUDE.md'),
+		{ kind: 'cmd' },
+		{ kind: 'edit', path: 'src/a.ts' }
+	]);
+	assert.ok(out.indexOf('a.ts') < out.indexOf('project rules'),
+		'what changed must come before what was loaded: ' + out);
+});
+
+test('FALLBACK: an unrecognised step is named, not counted', () => {
+	const S = newHarness().api;
+	const out = S.groupAggregate([
+		S.chipStep('info', 'something unusual happened', '', undefined, undefined),
+		S.chipStep('info', 'and another', '', undefined, undefined)
+	]);
+	assert.match(out, /^Something unusual happened and 1 more$/,
+		'name the first and count the rest, sentence-cased like every other path: ' + out);
+});
+
 console.log('groupReducer: ' + n + ' tests passed');