@webship.co/workspace 1.0.0-beta1 → 1.0.0-rc1

package/core/workspace-app/tests/unit/ai-inventory.test.js

@@ -0,0 +1,64 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { descriptionOf, suggestFor, aiInventory, TRIGGERS } = require('../../ai-inventory');
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-inv-'));
+const write = (name, body) => { const f = path.join(tmp, name); fs.writeFileSync(f, body); return f; };
+
+test('a plain frontmatter description is read', () => {
+  const f = write('a.md', '---\nname: a\ndescription: Build a Drupal project.\n---\n\n# body\n');
+  assert.equal(descriptionOf(f), 'Build a Drupal project.');
+});
+
+test('a FOLDED description is joined back into one line', () => {
+  // YAML lets a long description continue on indented lines, and real agents use it —
+  // reading only the first line would cut the sentence that decides whether to use them.
+  const f = write('b.md', '---\nname: b\ndescription: Use this agent when\n  the workspace needs a\n  new builder script.\nmodel: opus\n---\n');
+  assert.equal(descriptionOf(f), 'Use this agent when the workspace needs a new builder script.');
+});
+
+test('a following key does not get swallowed into the description', () => {
+  const f = write('c.md', '---\nname: c\ndescription: Short one.\nmodel: opus\ncolor: green\n---\n');
+  assert.equal(descriptionOf(f), 'Short one.');
+});
+
+test('quotes are stripped, and a file with no frontmatter has no description', () => {
+  assert.equal(descriptionOf(write('d.md', '---\ndescription: "Quoted."\n---\n')), 'Quoted.');
+  assert.equal(descriptionOf(write('e.md', '# Just a heading\n')), '');
+  assert.equal(descriptionOf(path.join(tmp, 'missing.md')), '');
+});
+
+test('each kind is offered by the right trigger', () => {
+  // The contract the popup and the Ace completer both rely on.
+  assert.deepEqual(TRIGGERS.agent, ['@']);
+  assert.deepEqual(TRIGGERS.command, ['/']);
+  assert.deepEqual(TRIGGERS.skill, ['@', '/'], 'a skill is both named and invoked');
+});
+
+test('the inventory reads this machine and every item is well formed', () => {
+  const all = aiInventory();
+  assert.ok(all.length > 0, 'no items found at all');
+  for (const i of all.slice(0, 40)) {
+    assert.match(i.kind, /^(agent|skill|command)$/);
+    assert.ok(i.name && !i.name.endsWith('.md'), `bad name: ${i.name}`);
+    assert.ok(Array.isArray(i.triggers) && i.triggers.length, `no triggers: ${i.name}`);
+    assert.ok(i.where, `no provenance: ${i.name}`);
+  }
+});
+
+test('a "/" query never returns an agent, and "@" never returns a command', () => {
+  assert.equal(suggestFor('/', '').filter((i) => i.kind === 'agent').length, 0);
+  assert.equal(suggestFor('@', '').filter((i) => i.kind === 'command').length, 0);
+});
+
+test('a name that starts with what was typed ranks above one that merely contains it', () => {
+  const hits = suggestFor('@', 'workspace');
+  const starts = hits.findIndex((i) => i.name.toLowerCase().startsWith('workspace'));
+  const contains = hits.findIndex((i) => !i.name.toLowerCase().startsWith('workspace')
+    && i.name.toLowerCase().includes('workspace'));
+  if (starts !== -1 && contains !== -1) assert.ok(starts < contains, 'prefix match must come first');
+});

package/core/workspace-app/tests/unit/app-docs.test.js

@@ -0,0 +1,64 @@
+/**
+ * The illustrated guide, and its images.
+ *
+ * A screenshot that has been renamed or moved leaves a broken image, and a broken
+ * image in a guide is invisible to whoever wrote it and obvious to everybody else.
+ * Thirty-six screenshots sat in this folder referenced by nothing at all before the
+ * guide existed, which is the other half of the same problem.
+ */
+
+const assert = require('node:assert');
+const { test } = require('node:test');
+const fs = require('fs');
+const path = require('path');
+
+const DOCS = path.join(__dirname, '..', '..', 'docs');
+const GUIDE = path.join(DOCS, 'README.md');
+
+test('every image the guides link to is actually there', () => {
+  const md = [GUIDE, path.join(DOCS, 'USER-GUIDE.md')].map((f) => fs.readFileSync(f, 'utf8')).join('\n');
+  const links = [...md.matchAll(/!\[[^\]]*\]\(([^)]+)\)/g)].map((m) => m[1]);
+  assert.ok(links.length >= 10, `expected the guide to be illustrated, found ${links.length} images`);
+  for (const rel of links) {
+    assert.ok(fs.existsSync(path.join(DOCS, rel)), `missing image: ${rel}`);
+  }
+});
+
+test('every image has alt text', () => {
+  // The guide is read on GitHub, in the repository, and by people who cannot see
+  // the picture. An empty alt is a picture that says nothing to them.
+  const md = fs.readFileSync(GUIDE, 'utf8');
+  for (const m of md.matchAll(/!\[([^\]]*)\]\(([^)]+)\)/g)) {
+    assert.ok(m[1].trim().length > 3, `no alt text for ${m[2]}`);
+  }
+});
+
+test('the guide links to the other docs, and they exist', () => {
+  const md = fs.readFileSync(GUIDE, 'utf8');
+  const root = path.join(__dirname, '..', '..', '..', '..');
+  for (const rel of ['docs/workspace-tips-and-rules.md', 'README.md']) {
+    assert.match(md, new RegExp(rel.replace(/[/.]/g, '\\$&')), `the guide never points at ${rel}`);
+    assert.ok(fs.existsSync(path.join(root, rel)), `${rel} does not exist`);
+  }
+  // The three documents point at each other, or the set is three orphans.
+  for (const f of ['USER-GUIDE.md', 'DEVELOPER-GUIDE.md']) {
+    assert.ok(fs.existsSync(path.join(DOCS, f)), `${f} is missing`);
+    assert.match(md, new RegExp(f), `the index never points at ${f}`);
+  }
+});
+
+test('/help reads the guide from the app docs, and can serve its images', () => {
+  const src = fs.readFileSync(path.join(__dirname, '..', '..', 'server.js'), 'utf8');
+  assert.match(src, /APP_DOCS, 'USER-GUIDE\.md'/);
+  // Relative image paths work in the repository; over HTTP they need the route.
+  assert.match(src, /\/help\/screenshots\//);
+  // And the route must be contained: this is a docs folder, not a second static root.
+  assert.match(src, /realpathSync\(path\.join\(APP_DOCS, 'screenshots'\)\)/);
+});
+
+test('the README points at the guide, and says what it is', () => {
+  const md = fs.readFileSync(path.join(__dirname, '..', '..', '..', '..', 'README.md'), 'utf8');
+  assert.match(md, /core\/workspace-app\/docs/);
+  // One "New here" callout, not two: the second was a duplicate of the first.
+  assert.strictEqual((md.match(/New here/g) || []).length, 1);
+});

package/core/workspace-app/tests/unit/assistant-avatar.test.js

@@ -0,0 +1,110 @@
+/**
+ * The assistant's avatar. What must never drift: every move the assistant is told it may write exists in
+ * the avatar; the 3D part is fetched only when the avatar is on (an import map, a module loaded on
+ * demand); `assistant.avatar: none` takes the control and the stage away; and the avatar's lines are
+ * asked for only while it is shown.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const app = (f) => fs.readFileSync(path.join(__dirname, '../..', f), 'utf8');
+const { AVATAR_GESTURES } = require('../../assistant');
+
+test('every move the assistant may write is one the avatar can do', () => {
+  const avatar = app('public/assistant-avatar.js');
+  const moves = [...avatar.matchAll(/^ {2}([a-z]+): \{ duration:/gm)].map((m) => m[1]);
+  for (const g of AVATAR_GESTURES) assert.ok(moves.includes(g), `[${g}] is offered but the avatar has no such move`);
+});
+
+test('the libraries and the model are vendored, and fetched only when the avatar is shown', () => {
+  for (const f of ['public/vendor/three/three.module.min.js', 'public/vendor/three/three.core.min.js', 'public/vendor/three/LICENSE',
+    'public/vendor/three/addons/loaders/GLTFLoader.js', 'public/vendor/three-vrm/three-vrm.module.min.js', 'public/vendor/three-vrm/LICENSE',
+    'public/avatar/druplicon.vrm']) {
+    assert.ok(fs.existsSync(path.join(__dirname, '../..', f)), f);
+  }
+  const ui = app('public/assistant-avatar-ui.js');
+  assert.ok(ui.includes("import('/assistant-avatar.js')"), 'the 3D module is imported on demand');
+  const server = app('server.js');
+  assert.ok(server.includes('<script type="importmap">'), 'the import map that resolves three and three-vrm');
+  assert.ok(/\$\{avatarOn \? `<script src="\$\{assetUrl\('\/assistant-avatar-ui\.js'\)\}" defer>/.test(server), 'the wiring loads only when the avatar is on');
+});
+
+test('the avatar lines are asked for only while it is shown, and never left in the reply', () => {
+  const assistant = app('assistant.js');
+  assert.ok(assistant.includes('...(avatar ? ['), 'the avatar instructions are conditional');
+  for (const line of ['BOARD', 'DRAW', 'SHOW', 'VIDEO', 'BROWSE', 'SEARCH', 'MOVE', 'SIZE']) {
+    assert.ok(assistant.includes(`/^\\s*${line}:\\s*`), `${line}: is taken out of the reply text`);
+  }
+  assert.ok(app('public/ui.js').includes("avatar: Boolean(window.wsAssistantAvatarOn && window.wsAssistantAvatarOn()), avatarName: window.wsAvatarName ? window.wsAvatarName() : '', avatarId: window.wsAvatarId ? window.wsAvatarId() : '', page: window.wsAvatarContext ? window.wsAvatarContext() : null"));
+});
+
+test('every control is on the assistant side, and nothing is drawn on the avatar itself', () => {
+  const server = app('server.js');
+  const stage = server.slice(server.indexOf('<div class="assistant-avatar-stage"'), server.indexOf('<div class="assistant-avatar-chips"'));
+  assert.ok(stage.includes('<canvas'), 'the stage is the character');
+  assert.ok(!/<button/.test(stage), 'and carries no button: they are all in the panel bar');
+  for (const c of ['assistant-dock', 'dock-voice', 'dock-talk', 'dock-mic', 'data-kit="board"', 'data-pop="windows"', 'data-pop="settings"', 'assistant-avatar-chips']) {
+    assert.ok(server.includes(c), c);
+  }
+  assert.ok(!server.includes('data-pop="moves"'), 'the moves are the reply\'s to choose, not a list in the menu');
+  assert.ok(!server.includes('data-pop="open"'), 'no box for typing links in the panel: Druplicon opens pages when asked');
+  const menu = server.slice(server.indexOf('<div class="uk-inline assistant-avatar-menu">'), server.indexOf('<div class="uk-inline assistant-menu">'));
+  for (const c of ['assistant-avatar-toggle', 'data-kit="board"', 'data-pop="settings"', 'assistant-avatar-pops']) assert.ok(menu.includes(c), `${c} is in the robot button's menu`);
+});
+
+test('an empty saved volume never silences the voice', () => {
+  const ui = app('public/ui.js');
+  assert.ok(ui.includes("if (raw !== '' && raw !== null && Number.isFinite(v) && v >= min && v <= max) narrationParams[key] = v;"),
+    'volume, speed and pitch: an empty cookie means not chosen, never 0');
+});
+
+test('every big move the assistant may write is one the page can do, and spin, walk and leap exist', () => {
+  const { AVATAR_BIG_MOVES } = require('../../assistant');
+  const ui = app('public/assistant-avatar-ui.js');
+  const big = ui.slice(ui.indexOf('const BIG = {'), ui.indexOf('};', ui.indexOf('const BIG = {')));
+  for (const m of Object.keys(AVATAR_BIG_MOVES)) assert.match(big, new RegExp(`(async )?${m}(\\(\\)|:)`), `[${m}] is offered but the page has no such big move`);
+  const avatar = app('public/assistant-avatar.js');
+  for (const m of ['walk', 'spin', 'leap']) assert.match(avatar, new RegExp(`^  ${m}: \\{ duration:`, 'm'), m);
+  assert.ok(/if \(reduced\(\)\) return still/.test(big), 'reduced motion keeps it on the spot');
+});
+
+test('the avatar scripts parse: a clash in one leaves the page with no avatar at all', () => {
+  for (const f of ['public/assistant-avatar.js', 'public/assistant-avatar-moves.js', 'public/assistant-avatar-ui.js']) {
+    // Modules: their imports and exports taken off, the rest must compile as a function body.
+    const body = app(f).replace(/^import .*$/gm, '').replace(/^export (const|function|async function|let|class) /gm, '$1 ');
+    assert.doesNotThrow(() => new Function(body), f);
+  }
+});
+
+test('every avatar may speak in an ElevenLabs voice, and none does by default', () => {
+  const ui = app('public/assistant-avatar-ui.js');
+  assert.ok(ui.includes("voice().set('voiceName', String(getPref(`ws-voice-name-${a.id}`, '') || ''))"), 'a voice per avatar, free until one is picked');
+  assert.ok(app('public/ui.js').includes("if (/^elevenlabs:/i.test(String(narrationParams.voiceName || ''))) delete narrationParams.voiceName;"),
+    'settings.yml cannot make a paid voice the default');
+});
+
+test('the interface glyphs are vendored and used, never a temporary Figma link', () => {
+  const dir = path.join(__dirname, '../../public/vendor/webship-icons');
+  for (const f of ['ui/sound-on.svg', 'ui/sound-off.svg', 'ui/play.svg', 'ui/pause.svg', 'ui/stop.svg', 'ui/headset.svg', 'ui/share.svg', 'ui/menu.svg',
+    'ui/bookmark-outlined.svg']) {
+    const svg = fs.readFileSync(path.join(dir, f), 'utf8');
+    assert.match(svg, /^<svg[^>]*width="[\d.]+" height="[\d.]+"/, `${f} is an SVG with its own size`);
+  }
+  const ui = app('public/assistant-avatar-ui.js');
+  for (const name of ['sound-on', 'sound-off', 'play', 'pause', 'stop', 'headset', 'share', 'bookmark-outlined']) assert.ok(ui.includes(`'${name}'`), `${name} is used`);
+  for (const f of ['public/assistant-avatar-ui.js', 'server.js', 'public/css/components/assistant-avatar.css']) assert.ok(!/figma\.com\/api\/mcp\/asset/.test(app(f)), `${f} links no temporary Figma asset`);
+});
+
+test('while it works the avatar shows a status as the Claude Code CLI does, and acts each one out', () => {
+  const ui = app('public/assistant-avatar-ui.js');
+  const list = ui.slice(ui.indexOf('const STATUSES = ['), ui.indexOf('];', ui.indexOf('const STATUSES = [')));
+  const moves = [...list.matchAll(/\['([A-Z][a-z]+)', '([a-z]+)'\]/g)];
+  assert.ok(moves.length >= 6 && moves.some(([, v]) => v === 'Tempering'), 'Thinking, Tempering and the rest');
+  const avatar = app('public/assistant-avatar.js');
+  for (const [, , m] of moves) assert.match(avatar, new RegExp(`^  ${m}: \\{ duration:`, 'm'), `${m} is a shared move, so every avatar can do it`);
+  assert.ok(ui.includes("avatar.gesture(failed ? 'shrug' : 'thumbsup')"), 'Done or Stopped, with a move');
+  assert.ok(app('public/ui.js').includes("el.onError = () => setWorking(false, true);"), 'a failed request says so');
+});

package/core/workspace-app/tests/unit/assistant-cast.test.js

@@ -0,0 +1,105 @@
+/**
+ * Who the avatar can be and which voices it speaks in (assistant-cast.js). What must never drift: only
+ * the avatars settings.yml names are offered, a model is only ever served from inside the avatars
+ * workspace, the ElevenLabs key stays a placeholder until a real one is set, and a sentence already
+ * spoken is never paid for twice.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { avatarCast, findAvatar, elevenKey, elevenSpeak, elevenVoices } = require('../../assistant-cast');
+const { assistantSettings, workspaceLanguage } = require('../../speech');
+
+function tree() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cast-'));
+  const p = path.join(root, 'avatars', 'scratch');
+  fs.mkdirSync(path.join(p, 'characters'), { recursive: true });
+  fs.mkdirSync(path.join(p, 'public', 'models'), { recursive: true });
+  fs.writeFileSync(path.join(p, 'public', 'models', 'osa-coffee.vrm'), 'glTF');
+  fs.writeFileSync(path.join(p, 'public', 'models', 'labiba-meme.vrm'), 'glTF');
+  fs.writeFileSync(path.join(p, 'characters', 'osa-coffee.json'), JSON.stringify({ name: 'Coffee', model: '/models/osa-coffee.vrm', credit: 'Coffee by Polygonal-Mind. CC0.' }));
+  fs.writeFileSync(path.join(p, 'characters', 'escape.json'), JSON.stringify({ name: 'Out', model: '/models/../../../../etc/passwd' }));
+  fs.writeFileSync(path.join(root, 'secret.vrm'), 'no');
+  fs.symlinkSync(path.join(root, 'secret.vrm'), path.join(p, 'public', 'models', 'linked.vrm'));
+  return root;
+}
+
+test('only the avatars settings.yml names are offered, each found in the avatars workspace', () => {
+  const root = tree();
+  const cast = avatarCast({ assistant: { avatars: ['druplicon', 'coffee', 'labiba-meme', 'missing', '../x', 'escape', 'linked'] } }, root);
+  assert.deepStrictEqual(cast.map((a) => a.id), ['druplicon', 'coffee', 'labiba-meme']);
+  assert.strictEqual(cast[1].name, 'Coffee');
+  assert.match(cast[1].credit, /CC0/);
+  assert.match(cast[1].model, /^\/avatar\/model\/coffee\.vrm\?v=[0-9a-z]+$/, 'the link carries the file time, so a rebuilt model is fetched');
+  assert.ok(cast[2].credit, 'a bare model still says where its licence is');
+  assert.strictEqual(findAvatar('linked', root), null, 'a link out of the avatars workspace is never served');
+  assert.deepStrictEqual(avatarCast({}, root).map((a) => a.id), ['druplicon'], 'the built-in one by default');
+  assert.ok(fs.existsSync(path.join(__dirname, '../../public/avatar/druplicon.vrm')), 'Druplicon ships with the dashboard');
+});
+
+test('the avatar it starts as is one of the list, or none', () => {
+  assert.strictEqual(assistantSettings({ assistant: { avatar: 'coffee', avatars: ['druplicon', 'coffee'] } }).avatar, 'coffee');
+  assert.strictEqual(assistantSettings({ assistant: { avatar: 'coffee' } }).avatar, 'druplicon', 'Druplicon when the one named is not listed');
+  assert.strictEqual(assistantSettings({ assistant: { avatar: 'none', avatars: ['coffee'] } }).avatar, 'none');
+});
+
+test('the Workspace language sets the voice and the microphone unless they are pinned', () => {
+  assert.strictEqual(workspaceLanguage({ language: 'ar-JO' }), 'ar-JO');
+  assert.strictEqual(workspaceLanguage({ language: 'klingon' }), 'en-US');
+  assert.strictEqual(assistantSettings({ language: 'ar-JO' }).speechLanguage, 'ar-JO');
+  assert.strictEqual(assistantSettings({ language: 'ar-JO', assistant: { speech_language: 'en-GB' } }).speechLanguage, 'en-GB');
+});
+
+test('ElevenLabs stays off until a real key is set, and the key never reaches the page', async () => {
+  assert.strictEqual(elevenKey({ elevenlabs: { api_key: 'sk-change-this' } }), '');
+  assert.strictEqual(elevenKey({ elevenlabs: { api_key: 'CHANGE_ME' } }), '');
+  assert.deepStrictEqual(await elevenVoices({}), { connected: false, voices: [] });
+  const ui = fs.readFileSync(path.join(__dirname, '../../public/assistant-avatar-ui.js'), 'utf8');
+  assert.ok(!/xi-api-key|api_key/.test(ui), 'the page only posts words to /actions/assistant/speak');
+});
+
+test('a sentence already spoken is played from the cache, never paid for twice', async () => {
+  const settings = { elevenlabs: { api_key: 'a'.repeat(32) } };
+  const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), 'voice-'));
+  let calls = 0;
+  const fetchImpl = async (url, opts) => {
+    calls += 1;
+    assert.match(url, /\/v1\/text-to-speech\/EXAVITQu4vr4xnSDxMaL\?/);
+    assert.strictEqual(opts.headers['xi-api-key'], 'a'.repeat(32));
+    return { ok: true, status: 200, arrayBuffer: async () => Buffer.from('mp3') };
+  };
+  const ask = { voice: 'EXAVITQu4vr4xnSDxMaL', text: 'Hello team.' };
+  assert.strictEqual(String(await elevenSpeak(settings, ask, { fetchImpl, cacheDir })), 'mp3');
+  assert.strictEqual(String(await elevenSpeak(settings, ask, { fetchImpl, cacheDir })), 'mp3');
+  assert.strictEqual(calls, 1);
+  await assert.rejects(elevenSpeak(settings, { voice: '../v1/user', text: 'x' }, { fetchImpl, cacheDir }), /voice/);
+});
+
+test("an avatar's own moves exist, and the set is for work: no headscarf, nothing meant for children", async () => {
+  const { AVATAR_MOVE_SETS } = require('../../assistant');
+  const src = fs.readFileSync(path.join(__dirname, '../../public/assistant-avatar-moves.js'), 'utf8');
+  const defined = [...src.matchAll(/^ {4}([a-z]+): \{$/gm)].map((m) => m[1]);
+  for (const m of Object.keys(AVATAR_MOVE_SETS.labiba)) assert.ok(defined.includes(m), `[${m}] is offered but Labiba has no such move`);
+  for (const m of ['hijab', 'kiss', 'hug', 'dab', 'peekaboo', 'love']) assert.ok(!defined.includes(m), `${m} is not a move for work`);
+  assert.strictEqual(require('../../assistant-cast').moveSetOf('labiba-meme'), 'labiba');
+  assert.strictEqual(require('../../assistant-cast').moveSetOf('druplicon'), '', 'Druplicon has the shared moves and no set of its own');
+  for (const [set, moves] of Object.entries(AVATAR_MOVE_SETS)) {
+    for (const m of Object.keys(moves)) assert.ok(defined.includes(m), `[${m}] is offered but the ${set} set has no such move`);
+  }
+});
+
+test('hair colours and agents come from settings, checked', () => {
+  const { hairOf, agentOf } = require('../../assistant-cast');
+  assert.strictEqual(hairOf({ assistant: { avatar_hair: { 'labiba-meme': '"#0074E0"' } } }, 'labiba-meme'), '#0074e0');
+  assert.strictEqual(hairOf({ assistant: { avatar_hair: { x: 'url(evil)' } } }, 'x'), '');
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'home-'));
+  fs.mkdirSync(path.join(home, '.claude', 'agents'), { recursive: true });
+  fs.writeFileSync(path.join(home, '.claude', 'agents', 'avatar-druplicon.md'), '---\nname: avatar-druplicon\n---\n');
+  const s = { assistant: { avatar_agents: { druplicon: 'avatar-druplicon', coffee: 'not-installed', bot: '../../etc' } } };
+  assert.strictEqual(agentOf(s, 'druplicon', home), 'avatar-druplicon');
+  assert.strictEqual(agentOf(s, 'coffee', home), '', 'an agent that is not installed is not used');
+  assert.strictEqual(agentOf(s, 'bot', home), '');
+});

package/core/workspace-app/tests/unit/assistant-send-animation.test.js

@@ -0,0 +1,15 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const ui = fs.readFileSync(path.join(__dirname, '../..', 'public/ui.js'), 'utf8');
+
+test('the send button animates when a message is sent, by click or Enter, unless motion is reduced', () => {
+  assert.ok(ui.includes('.input-button.inside-end.ws-sent svg { animation: ws-send-fly'));
+  assert.ok(ui.includes('@keyframes ws-send-fly'));
+  const frames = ui.slice(ui.indexOf('@keyframes ws-send-fly'), ui.indexOf('@keyframes ws-send-fly') + 400);
+  assert.ok(frames.includes('translate:') && !frames.includes('transform:'), 'transform on the arrow is forced to none, so the individual properties are used');
+  assert.ok(ui.includes('@media (prefers-reduced-motion: reduce) { .input-button.inside-end.ws-sent svg { animation: none; } }'));
+  assert.ok(ui.includes('narrator.cancel(); playSendAnimation(); setWorking(true); }'), 'it is tied to the message being sent, not to a click');
+});

package/core/workspace-app/tests/unit/assistant-suggestions.test.js

@@ -0,0 +1,112 @@
+/**
+ * Suggested prompts in the assistant panel.
+ *
+ * What matters is what they are NOT: they never name a project, a branch, a command or a key, because
+ * a name in a suggestion goes stale the day the thing is renamed, and a list that points at things
+ * that are gone teaches the reader to skip the list. They are made from what a workspace states about
+ * itself, so a new workspace gets sensible ones with no code change.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const { suggestionsFor, defaultSuggestions, cleanSuggestions, MAX_SUGGESTIONS, MAX_LENGTH } = require('../../assistant-suggestions');
+const { loadWorkspaces } = require('../../workspaces');
+
+const app = (f) => fs.readFileSync(path.join(__dirname, '../..', f), 'utf8');
+// The pronoun is the one capital a plain sentence may carry besides its first letter.
+const plain = (s) => s.replace(/\bI\b/g, 'i');
+const meta = (over) => ({ noun: 'project', nounPlural: 'projects', kind: 'projects', typeActions: new Set(['ddev', 'build', 'backup', 'tests', 'clone']), ...over });
+
+test('every real workspace gets a short, general list', () => {
+  const all = loadWorkspaces();
+  assert.ok(Object.keys(all).length > 5, 'there are workspaces to check');
+  for (const [key, ws] of Object.entries(all)) {
+    const list = suggestionsFor({ context: `workspace:${key}`, meta: ws });
+    assert.ok(list.length >= 3 && list.length <= MAX_SUGGESTIONS, `${key} has ${list.length}`);
+    // Plain words only: a capital to start, lowercase after, and a question mark. That is what keeps a
+    // project name, a script name, a key or a number out of every one of them.
+    for (const s of list) assert.match(plain(s), /^[A-Z][a-z ,']*\?$/, `${key}: "${s}" names something or is not a question`);
+  }
+});
+
+test('the pages that belong to no workspace get general ones too', () => {
+  for (const context of ['home', 'assistant', 'settings', 'commands']) {
+    const list = suggestionsFor({ context, meta: null });
+    assert.ok(list.length >= 3, context);
+    for (const s of list) assert.match(plain(s), /^[A-Z][a-z ,']*\?$/, `${context}: "${s}"`);
+  }
+});
+
+test('a workspace is asked about its own kind of thing', () => {
+  const dev = defaultSuggestions('workspace:dev', meta());
+  assert.ok(dev.some((s) => /projects/.test(s)));
+  const agents = defaultSuggestions('workspace:ai-agents', meta({ noun: 'agent', nounPlural: 'agents', kind: 'files', typeActions: new Set() }));
+  assert.ok(agents.every((s) => /agent/.test(s)), 'every one is about agents');
+  assert.ok(agents.some((s) => /add an agent/.test(s)), 'an agent, not a agent');
+  const skill = defaultSuggestions('workspace:ai-skills', meta({ noun: 'skill', nounPlural: 'skills', kind: 'files', typeActions: new Set() }));
+  assert.ok(skill.some((s) => /add a skill/.test(s)));
+});
+
+test('it never offers what the workspace cannot do', () => {
+  const clones = defaultSuggestions('workspace:modules', meta({ noun: 'module', nounPlural: 'modules', typeActions: new Set(['build', 'graphify']) }));
+  assert.ok(!clones.some((s) => /running\?$/.test(s) && /which are running/.test(s)), 'a folder of git clones has nothing "running"');
+  assert.ok(!clones.some((s) => /back up/.test(s)), 'and cannot back anything up');
+  assert.ok(clones.some((s) => /not committed/.test(s)));
+  const site = defaultSuggestions('workspace:dev', meta());
+  assert.ok(site.some((s) => /which are running/.test(s)));
+  assert.ok(site.some((s) => /back up/.test(s)));
+  const bare = defaultSuggestions('workspace:x', meta({ typeActions: new Set(['ddev']) }));
+  assert.ok(!bare.some((s) => /build a new/.test(s)) && !bare.some((s) => /back up/.test(s)));
+});
+
+test('the backups page asks about backups', () => {
+  const list = defaultSuggestions('backups:dev', meta());
+  assert.ok(list.every((s) => /back ?up/.test(s)));
+});
+
+test('a workspace can say its own, and an empty list switches them off', () => {
+  const m = meta();
+  assert.deepStrictEqual(suggestionsFor({ context: 'workspace:dev', meta: m, own: ['What is in here?', 'How do I start?'] }), ['What is in here?', 'How do I start?']);
+  assert.deepStrictEqual(suggestionsFor({ context: 'workspace:dev', meta: m, own: [] }), [], 'none, not the defaults');
+  assert.strictEqual(suggestionsFor({ context: 'workspace:dev', meta: m, own: undefined }).length >= 3, true, 'absent means the defaults');
+});
+
+test('settings.yml gives one list to every page that has none of its own', () => {
+  const m = meta();
+  assert.deepStrictEqual(suggestionsFor({ context: 'workspace:dev', meta: m, global: ['Where is it?'] }), ['Where is it?']);
+  assert.deepStrictEqual(suggestionsFor({ context: 'workspace:dev', meta: m, own: ['Mine?'], global: ['Where is it?'] }), ['Mine?'], 'the workspace wins');
+  assert.deepStrictEqual(suggestionsFor({ context: 'home', meta: null, global: [] }), [], 'an empty global list switches it off');
+});
+
+test('what a person writes is cleaned the way the defaults are made', () => {
+  assert.strictEqual(cleanSuggestions('not a list'), null);
+  assert.strictEqual(cleanSuggestions(undefined), null);
+  assert.deepStrictEqual(cleanSuggestions(['  spaced   out  ', '', '   ', 42, null, { a: 1 }, 'Spaced out']), ['spaced out'], 'trimmed, one line, deduplicated, strings only');
+  assert.strictEqual(cleanSuggestions(Array.from({ length: 12 }, (_, i) => `Question ${i}?`)).length, MAX_SUGGESTIONS);
+  assert.strictEqual(cleanSuggestions(['x'.repeat(500)])[0].length, MAX_LENGTH);
+  assert.deepStrictEqual(cleanSuggestions(['one\ntwo']), ['one two'], 'one line each');
+});
+
+test('the page hands the list to the panel, and a workspace file can carry its own', () => {
+  const server = app('server.js');
+  assert.ok(server.includes("require('./assistant-suggestions')"));
+  assert.ok(server.includes('suggestions });') || server.includes('suggestions };'), 'it is part of the settings the panel is given');
+  assert.ok(server.includes('own: meta ? meta.assistantSuggestions : undefined'));
+  assert.ok(app('workspaces.js').includes('assistantSuggestions: (wsSettings.assistant || {}).suggestions'));
+});
+
+test('the panel shows them only on an empty conversation, and a click fills the composer without sending', () => {
+  const ui = app('public/ui.js');
+  assert.ok(ui.includes('else showSuggestions();'), 'a thread with turns in it never sees them');
+  assert.ok(ui.includes('deep-chat-temporary-message'), 'gone once anything is sent, never saved to the thread');
+  assert.ok(ui.includes("'ws-suggestion':"));
+  // The handler that runs on a click must not be able to send: the assistant has a shell.
+  const handler = ui.slice(ui.indexOf("'ws-suggestion':"), ui.indexOf("'ws-suggestion':") + 500);
+  assert.ok(handler.includes('fillComposer('));
+  assert.ok(!handler.includes('submitUserMessage'));
+  assert.ok(ui.includes('escapeHtml(s)'), 'text goes into the markup escaped');
+  assert.ok(ui.includes('suggestTries += 1) < 8'), 'the retry is bounded');
+});

package/core/workspace-app/tests/unit/assistant-switches.test.js

@@ -0,0 +1,53 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+
+const app = (f) => fs.readFileSync(path.join(__dirname, '../..', f), 'utf8');
+const server = app('server.js');
+const ui = app('public/ui.js');
+const menu = server.slice(server.indexOf('function assistantMenuItemsHtml'), server.indexOf('const AI_MARK'));
+
+test('the assistant options offer a check button for each part of the prompt', () => {
+  for (const key of ['voice', 'mic', 'mode', 'suggest']) assert.ok(menu.includes(`['${key}', `), key);
+  assert.ok(menu.includes('class="uk-checkbox assistant-switch" type="checkbox" data-switch="${key}"'));
+});
+
+test('every switch in the menu has a handler on the page', () => {
+  const keys = [...menu.matchAll(/\['(voice|mic|mode|suggest)', '/g)].map((m) => m[1]);
+  for (const key of keys) assert.match(ui, new RegExp(`\\n    ${key}: \\{`), `no handler for ${key}`);
+});
+
+test('the choice is kept per browser and the setting is only where it starts', () => {
+  for (const name of ['ws-mic', 'ws-mode', 'ws-suggest']) assert.ok(ui.includes(`'${name}'`), name);
+  assert.ok(ui.includes("prefSwitch('ws-mic', cfg.voiceInput !== false"));
+  assert.ok(ui.includes("prefSwitch('ws-mode', true"));
+  assert.ok(ui.includes("prefSwitch('ws-suggest', true"));
+});
+
+test('the microphone is hidden by an attribute on the panel, and only when it exists at all', () => {
+  assert.ok(ui.includes(':host([data-assistant-mic="off"]) #microphone-button { display: none !important; }'));
+  assert.ok(ui.includes("el.setAttribute('data-assistant-mic', 'off')"));
+  assert.ok(ui.includes('show: cfg.speechToText !== false'));
+});
+
+test('prompt mode is hidden on the selector itself', () => {
+  assert.ok(ui.includes("picker.style.display = on ? '' : 'none'"));
+  assert.ok(ui.includes('show: !!picker'));
+});
+
+test('suggestions honour the switch when loaded, can be removed, and are not shown over a conversation', () => {
+  assert.ok(ui.includes("'ws-suggest', null) : null) !== '0'"));
+  assert.ok(ui.includes('!suggestOn()) return;'));
+  assert.ok(ui.includes('if (conversationEmpty) showSuggestions()'));
+  assert.ok(ui.includes("closest('[class*=\"outer-message-container\"]')"));
+  assert.ok(ui.includes('init: null'), 'the switch must not show them before the history has loaded');
+});
+
+test('a switch with nothing to switch is hidden, not offered', () => {
+  assert.ok(ui.includes("if (!sw || !sw.show) { box.closest('li').hidden = true; return; }"));
+});
+
+test('the copies of the menu for each way of showing the assistant stay in step', () => {
+  assert.ok(ui.includes('.assistant-switch[data-switch="${box.dataset.switch}"]'));
+});