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

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}"]'));
+});

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

@@ -0,0 +1,146 @@
+/**
+ * How the assistant is shown: sidebar, wide, floating, full page — plus the switch that closes it.
+ *
+ * Modelled on Drupal AI's own chatbot (a toggle in the admin toolbar, a menu in the panel header
+ * carrying Clear history and Close, an expand control, and the state on the document element), so
+ * what is checked here is the part that would break quietly: the state must be applied BEFORE first
+ * paint, the view must be a default rather than an override, and the full-page view must not leave
+ * two copies of one conversation on the screen.
+ */
+
+const assert = require('node:assert');
+const { test } = require('node:test');
+const fs = require('fs');
+const path = require('path');
+
+const app = path.join(__dirname, '..', '..');
+const server = fs.readFileSync(path.join(app, 'server.js'), 'utf8');
+const ui = fs.readFileSync(path.join(app, 'public', 'ui.js'), 'utf8');
+const css = fs.readFileSync(path.join(app, 'public', 'css', 'components', 'assistant-views.css'), 'utf8');
+const { styleSettings } = require(path.join(app, 'workspaces'));
+
+test('the view and the open state are settings, with a fallback rather than a blank panel', () => {
+  const s = styleSettings();
+  assert.ok(['sidebar', 'wide', 'float', 'full'].includes(s.assistantView), s.assistantView);
+  assert.ok(['yes', 'no'].includes(s.assistantOpen), s.assistantOpen);
+});
+
+test('the state is applied before first paint, and a stored choice wins over the setting', () => {
+  const head = server.slice(server.indexOf("var d=document.documentElement"), server.indexOf('</script>'));
+  // Read through wsPref: the stored choice is a cookie on the hub domain, so it is the same choice on
+  // every workspace subdomain rather than one per origin.
+  assert.match(head, /wsPref\('ws-assistant-view',null\)\|\|'\$\{style\.assistantView\}'/,
+    'the setting is the default, the stored choice wins — as with style.mode');
+  assert.match(head, /indexOf\(v\)<0\)v='sidebar'/, 'an unknown view must fall back, not render nothing');
+  assert.match(head, /d\.dataset\.assistantView=v/);
+  assert.match(head, /classList\.add\('assistant-closed'\)/);
+  // The panel is 25rem of the layout: deciding this in the deferred ui.js would draw the page one
+  // way and reflow it a frame later, which is the bug the rail's own pre-paint line exists for. So
+  // ui.js may only CHANGE the class, from the one function a click reaches.
+  const setsClosed = ui.match(/classList\.toggle\('assistant-closed'/g) || [];
+  assert.strictEqual(setsClosed.length, 1, 'only setAssistantOpen may write that class');
+  const fn = ui.slice(ui.indexOf('function setAssistantOpen'), ui.indexOf('function setAssistantOpen') + 400);
+  assert.match(fn, /classList\.toggle\('assistant-closed', !open\)/, 'and that is where it lives');
+});
+
+test('the panel header carries the menu, wider and close — and the menu carries the rest', () => {
+  // Up to the close button: the avatar's own menu (when it is on) comes first and is long.
+  const from = server.indexOf('class="assistant-controls"');
+  const head = server.slice(from, server.indexOf('assistant-hide', from) + 200);
+  assert.match(head, /assistant-ctl[^>]*Assistant options/, 'the kebab');
+  assert.match(head, /assistant-wider/, 'wider');
+  assert.match(head, /assistant-hide/, 'close');
+  // The items themselves are one function, since the toolbar hangs the same menu.
+  const menu = server.slice(server.indexOf('function assistantMenuItemsHtml'), server.indexOf('const AI_MARK'));
+  assert.match(menu, /hx-post="\/actions\/chat-reset"[\s\S]*?hx-trigger="confirmed-remove"/,
+    'New chat must ask first, like every other action that throws something away');
+  assert.match(menu, /class="assistant-view-pick" data-view="\$\{v\}"/, 'the views are rendered from a list');
+  assert.match(menu, /assistant-close-pick/, 'and closing it is offered where the views are');
+  for (const [v, label] of [['sidebar', 'Sidebar'], ['wide', 'Wide'], ['float', 'Floating'], ['full', 'Full page']]) {
+    assert.match(menu, new RegExp(`\\['${v}', '${label}'`), `no way to choose ${v}`);
+  }
+});
+
+test('the control is in the rail, not in the toolbar', () => {
+  // The toolbar is the corner the brand and the page identity own. The rail is where the things that
+  // apply to whatever page you are on live, which is exactly what this is.
+  const left = server.slice(server.indexOf('<div class="uk-navbar-left">'), server.indexOf('<div class="uk-navbar-right">'));
+  assert.ok(!/assistant-toggle|assistant-switch/.test(left), 'the toolbar must not carry the switch');
+  const rail = server.slice(server.indexOf("label: 'Go'"), server.indexOf("] });", server.indexOf("label: 'Go'")));
+  assert.match(rail, /<button type="button" class="action-btn actions-assistant/,
+    'the rail row is the control, and a real button — UIKit puts aria-haspopup on whatever precedes the '
+    + 'dropdown, and that attribute is not allowed on a span');
+  assert.match(rail, /\$\{assistantMenuItemsHtml\(\)\}/, 'and it carries the whole menu');
+});
+
+test('show and hide are two items the stylesheet picks between', () => {
+  const menu = server.slice(server.indexOf('function assistantMenuItemsHtml'), server.indexOf('const AI_MARK'));
+  assert.match(menu, /assistant-when-closed[\s\S]*?assistant-open-pick/, 'Show, for when it is hidden');
+  assert.match(menu, /assistant-when-open[\s\S]*?assistant-close-pick/, 'Hide, for when it is not');
+  // Neither needs a script to rename itself: which applies is a state the stylesheet already knows.
+  assert.match(css, /html\.assistant-closed \.assistant-when-open,\s*\n\s*html:not\(\.assistant-closed\) \.assistant-when-closed \{ display: none; \}/);
+});
+
+test('the full-page view is a place, not a layout', () => {
+  assert.match(ui, /if \(view === 'full'\)[\s\S]*?window\.location\.href = '\/assistant'/,
+    'choosing it must go there');
+  assert.match(ui, /window\.location\.pathname === '\/assistant'[\s\S]*?referrer/,
+    'leaving it must leave the page too — /assistant has no sidebar to become');
+  assert.match(server, /pathname === '\/assistant'/, 'the page itself');
+  // Two panels on one screen would be two views of one conversation, both live.
+  assert.match(server, /context === 'assistant' \? '' : `<aside class="assistant-side">/,
+    'the page must not also carry the docked panel');
+  assert.match(css, /html\[data-assistant-view="full"\] \.assistant-side \{ display: none; \}/);
+});
+
+test('the full-page view is escapable from an ordinary page', () => {
+  // In that view no page but /assistant draws a panel, so the panel's own menu is not there to use.
+  // The toolbar carries the same menu, or picking Full page and then navigating anywhere would leave
+  // no way back to a sidebar — the tile alone only leads back to /assistant.
+  assert.match(server, /function assistantMenuItemsHtml\(\)/, 'one menu, hung from two places');
+  // To the end of the control, not a fixed window: the comments around it grow, and a slice that is
+  // one character short reads as the menu having been taken away.
+  const railStart = server.indexOf('class="uk-inline actions-assistant-wrap"');
+  const rail = server.slice(railStart, server.indexOf('</div>`', railStart));
+  assert.match(rail, /\$\{assistantMenuItemsHtml\(\)\}/, 'the rail carries the menu, so any page can change the view');
+  const header = server.slice(server.indexOf('class="uk-inline assistant-menu"'), server.indexOf('class="uk-inline assistant-menu"') + 600);
+  assert.match(header, /\$\{assistantMenuItemsHtml\(\)\}/, 'and it must be the same menu, not a second copy');
+});
+
+test('showing it does not pretend to open a page that is already open', () => {
+  // On /assistant the assistant IS the page: writing a closed/open state there set something nobody
+  // could see, which then decided the panel on the next ordinary page for no reason the user gave.
+  const handler = ui.slice(ui.indexOf("e.target.closest('.assistant-open-pick')"), ui.indexOf("e.target.closest('.assistant-open-pick')") + 500);
+  assert.match(handler, /if \(window\.location\.pathname === '\/assistant'\) return;/);
+  assert.ok(handler.indexOf("pathname === '/assistant'") < handler.indexOf('setAssistantOpen'),
+    'it must return before writing the open state');
+  assert.match(handler, /assistantView\(\) === 'full'[\s\S]*?window\.location\.href = '\/assistant'/,
+    'and in the full-page view showing it means going there');
+});
+
+test('the floating panel can be moved, and only that one', () => {
+  // Where a floating panel should sit depends on what is under it, and that changes page by page.
+  assert.match(ui, /function draggableAssistant/);
+  assert.match(ui, /dataset\.assistantView !== 'float'\) return;/, 'only the floating view is draggable');
+  // A drag that began on the close button would close the panel on release.
+  assert.match(ui, /e\.target\.closest\('button, a, input, select, \.assistant-dropdown'\)\) return;/,
+    'the header is the handle, minus its controls');
+  assert.match(ui, /const maxX = Math\.max\(0, window\.innerWidth - r\.width\)/, 'it is clamped into the viewport');
+  assert.match(ui, /window\.addEventListener\('resize', applyStored\)/,
+    'a window that got smaller must not leave it off-screen');
+  // Leftover inline positions would fight the stylesheet in every other view.
+  assert.match(ui, /el\.style\.left = el\.style\.top = el\.style\.bottom = el\.style\.right = '';/);
+  assert.match(css, /html\[data-assistant-view="float"\] \.assistant-side \.assistant-head \{\s*\n\s*cursor: grab;/,
+    'and it has to say it can be dragged');
+});
+
+test('the launcher is the way back in, in every view', () => {
+  // The control lives in the rail now, and a collapsed rail is an icon strip a newcomer has no reason
+  // to search — so a closed assistant must leave something on the page that opens it.
+  assert.match(css, /\.assistant-launcher \{ display: none; \}/, 'not while the panel is open');
+  assert.match(css, /html\.assistant-closed \.assistant-launcher \{/, 'and in every view when it is closed');
+  assert.ok(!/html\[data-assistant-view="float"\]\.assistant-closed \.assistant-launcher \{/.test(css),
+    'not the floating view alone any more');
+  assert.match(ui, /closest\('\.assistant-launcher'\)[\s\S]*?assistantView\(\) === 'full'[\s\S]*?'\/assistant'/,
+    'and in the full-page view it leads to the page, since there is no panel to show');
+});

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

@@ -0,0 +1,49 @@
+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 ui = app('public/ui.js');
+const css = app('public/css/components/working-indicators.css');
+
+test('the Send button shows three animated dots while the assistant works, in place of the arrow', () => {
+  assert.ok(ui.includes(':host([data-assistant-working]) .input-button.inside-end::after'));
+  assert.ok(ui.includes('animation: ws-dots 1.2s ease-in-out infinite;'));
+  assert.ok(ui.includes(':host([data-assistant-working]) .input-button.inside-end svg { opacity: 0; }'));
+  assert.equal((ui.match(/radial-gradient\(circle, var\(--text-inverse\) 2\.4px/g) || []).length, 3, 'three dots, in the theme token and not a colour');
+});
+
+test('deep-chat\'s own dots on the button are hidden so only one animation shows', () => {
+  assert.ok(ui.includes(':host([data-assistant-working]) .loading-submit-button { display: none !important; }'));
+});
+
+test('the dots bounce one after another', () => {
+  const frames = ui.slice(ui.indexOf('@keyframes ws-dots'), ui.indexOf('@keyframes ws-dots') + 500);
+  const raised = [...frames.matchAll(/(\d+)% \{ background-position: ([^;]+);/g)].filter((m) => m[1] !== '0').map((m) => m[2].split(',').map((p) => p.trim()).findIndex((p) => p.endsWith('30%')));
+  assert.deepEqual(raised.filter((i) => i >= 0), [0, 1, 2]);
+});
+
+test('the panel header pulses the avatar and sweeps a light while it works', () => {
+  assert.ok(css.includes('.assistant-panel[data-working] .assistant-head::after'));
+  assert.ok(css.includes('.assistant-panel[data-working] .assistant-avatar { animation: assistant-pulse'));
+  assert.ok(css.includes('@keyframes assistant-sweep') && css.includes('@keyframes assistant-pulse'));
+});
+
+test('motion is switched off for people who prefer reduced motion', () => {
+  assert.ok(ui.includes('@media (prefers-reduced-motion: reduce) { :host([data-assistant-working]) .input-button.inside-end::after { animation: none; } }'));
+  assert.match(css, /prefers-reduced-motion: reduce\) \{\s*\.assistant-panel\[data-working\] \.assistant-head::after,\s*\.assistant-panel\[data-working\] \.assistant-avatar \{ animation: none; \}/);
+});
+
+test('working starts when a message is sent and ends on the answer, a reply of any kind, an error, or after a time limit', () => {
+  assert.ok(ui.includes("if (message.role === 'user') { conversationEmpty = false; narrator.cancel(); playSendAnimation(); setWorking(true); }"));
+  assert.ok(ui.includes('else setWorking(false);'), 'an assistant message ends it');
+  assert.ok(ui.includes('el.onError = () => setWorking(false, true);'), 'an error ends it, and says it failed');
+  assert.ok(ui.includes('    setWorking(false);\n    if (response && response.html)'), 'the response interceptor ends it');
+  assert.ok(ui.includes('setTimeout(() => setWorking(false), 16 * 60 * 1000)'), 'a request that never answers cannot leave it running for ever');
+});
+
+test('the state is on the panel and the chat, so both the page and the shadow styles can read it', () => {
+  assert.ok(ui.includes("el.toggleAttribute('data-assistant-working', on)"));
+  assert.ok(ui.includes("document.querySelectorAll('.assistant-panel').forEach((p) => p.toggleAttribute('data-working', on))"));
+});