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

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

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

@@ -0,0 +1,61 @@
+/**
+ * The assistant's page context: the part that reaches into the rest of the app.
+ *
+ * Every branch of it names something from another module, and a name that is not imported throws
+ * only when somebody asks a question from that page. That is not theoretical — after the module
+ * split the settings and workspace branches referenced `listSettingsFiles`, `CONFIG_DIR`,
+ * `findBuilderScripts` and `listBackups` without importing any of them, so the assistant worked on
+ * the home page and returned HTTP 500 on every workspace page and on settings.
+ *
+ * These tests call it for every context the dashboard can send. They cost nothing (no agent is
+ * spawned) and they fail on a missing import rather than leaving it for a person to find.
+ */
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const { pageContextFor } = require('../../assistant');
+const { loadWorkspaces, findBuilderScripts, commandFlags } = require('../../workspaces');
+
+test('every context the dashboard sends produces a context line', () => {
+  const keys = Object.keys(loadWorkspaces());
+  assert.ok(keys.length, 'there is at least one workspace to ask about');
+  const contexts = ['home', 'settings', 'commands',
+    ...keys.map((k) => `workspace:${k}`), ...keys.map((k) => `backups:${k}`)];
+  for (const ctx of contexts) {
+    const out = pageContextFor(ctx);
+    assert.equal(typeof out, 'string', `${ctx} should produce a string`);
+    assert.ok(out.length > 20, `${ctx} produced nothing useful: ${out}`);
+  }
+});
+
+test('the settings context names the files but never a secret', () => {
+  const out = pageContextFor('settings');
+  assert.match(out, /Settings page/);
+  assert.match(out, /settings\.yml/);
+  // It has to TELL the agent not to reveal a secret — that instruction is the safeguard.
+  assert.match(out, /NEVER print, echo, cat, grep/);
+});
+
+test('a workspace context names that workspace and its builders', () => {
+  // NOT `Object.keys(...)[0]`: the first workspace is whichever one the cards are ordered to put
+  // first, which is a setting somebody can drag. When `designs` was moved to the top this test began
+  // failing on a Penpot builder that has no --install — a true statement about the wrong workspace.
+  // Pick one that actually has a builder taking --install, which is what the assertion is about.
+  const all = loadWorkspaces();
+  const key = Object.keys(all).find((k) => {
+    const dir = all[k].dir;
+    return dir && findBuilderScripts(dir).some((b) => commandFlags(dir, b).some((f) => f.long === '--install'));
+  });
+  assert.ok(key, 'some workspace builds something with --install');
+  const out = pageContextFor(`workspace:${key}`);
+  assert.ok(out.includes(all[key].label), `should name ${all[key].label}`);
+  // The AI Context carries each command's real flag contract, not just names.
+  assert.match(out, /Command contract/);
+  assert.match(out, /--install \(-i\)/);
+});
+
+test('an unknown workspace falls back to the home context rather than throwing', () => {
+  assert.match(pageContextFor('workspace:no-such-workspace'), /home page/);
+  assert.match(pageContextFor('nonsense'), /home page/);
+});