@webship.co/workspace 1.0.0-beta2 → 1.0.0

package/core/workspace-app/tests/features/assistant-speech.feature

@@ -57,7 +57,7 @@ Feature: Talking to the assistant
   # A browser with no synthesis voices accepts speak(), fires error: synthesis-failed, and is silent.
   # Nothing reported it, so "read replies aloud" looked switched on and did nothing at all — the worst
   # state a setting can be in.
-  Scenario: The settings page says which voices this browser actually has
-    Given I am on "/settings"
+  Scenario: The settings file editor says which voices this browser actually has
+    Given I am on "/settings/settings.yml"
      Then "[data-voice-name]" should be attached
       And the voice list should report what this browser has

package/core/workspace-app/tests/features/checks.feature

@@ -3,37 +3,54 @@ Feature: The checks a project already declares
 
   # One quality menu, not two. On a packages workspace there is no browser suite at all, and on a
   # site there was no checks control — a separate button would have been the only one present in
-  # each case. They live together under Tests, with the checks nested inside it.
+  # each case. They live together under Tests, with the checks nested inside it. The menu's items
+  # arrive when it opens (/fragments/row-menu/tests/…), so each scenario that reads one opens the
+  # first row's menu first; the caption under the button is on the page before that.
   Scenario: A package row offers its checks inside the Tests menu
     Given I am on "/products"
      Then the element ".project-row .act-menu-tests" should be displayed
-      And ".act-menu-tests .act-menu-checks" should be attached
       And I should see "Tests"
+     When I click on the element ".project-row >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
+      And ".act-menu-tests .act-menu-checks" should be attached
 
   Scenario: The button says what the package covers without running anything
     Given I am on "/products"
      Then the element ".act-menu-tests + .act-status" should be displayed
-      And "[hx-post='/actions/checks-plan']" should be attached
+     When I click on the element ".project-row >> nth=0 >> .act-menu-tests button"
+     Then "[hx-post='/actions/checks-plan']" should be attached
 
   # The pair is the point: the canonical name is what you type (--only js), the code beside it is
   # the script the package itself declared. Listing them together is how the mapping is checkable.
+  # Opened on a row whose caption says the package declares checks, since a package that declares
+  # none lists none.
   Scenario: The nested menu lists each alias against the script it runs
     Given I am on "/products"
-     Then ".checks-sub" should be attached
+     When I click on the element ".project-row:has(.act-menu-tests + .act-status:has-text('declared')), .project-row:has(.act-menu-tests + .act-status:has-text('deps missing')), .project-row:has(.act-menu-tests + .act-status:has-text('passed')), .project-row:has(.act-menu-tests + .act-status:has-text('failed')) >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
+      And ".checks-sub" should be attached
       And ".checks-sub .checks-alias" should be attached
       And ".checks-sub .checks-script" should be attached
 
+  # Opened on a row whose caption says its checks are declared with their dependencies there — the
+  # alias control renders only for an alias that is READY, and "deps missing" says none is.
   @needs-check-aliases
   Scenario: Each alias can be run on its own, and so can all of them
     Given I am on "/products"
-     Then "[hx-post='/actions/checks']" should be attached
+     When I click on the element ".project-row:has(.act-menu-tests + .act-status:has-text('declared')), .project-row:has(.act-menu-tests + .act-status:has-text('passed')), .project-row:has(.act-menu-tests + .act-status:has-text('failed')) >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
+      And "[hx-post='/actions/checks']" should be attached
       And "[hx-vals*='only']" should be attached
 
   # A site gets the same nested list: its package.json declares the same vocabulary, and its
-  # ddev-dev-tools add-on adds the PHP and Twig checks on top.
+  # ddev-dev-tools add-on adds the PHP and Twig checks on top. Opened on a row whose caption says a
+  # stack is there, since "Run the tests" is only offered where there is a suite to run.
+  @needs-testing-stack
   Scenario: A site keeps its testing verbs and gains the checks beside them
     Given I am on "/dev"
      Then the element ".project-row .act-menu-tests" should be displayed
+     When I click on the element ".project-row:has(.act-menu-tests + .act-status:text-is('ready to test')), .project-row:has(.act-menu-tests + .act-status:text-is('not ready')), .project-row:has(.act-menu-tests + .act-status:text-is('running now')) >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
       And "[hx-post='/actions/testing-configure']" should be attached
       And "[hx-post='/actions/testing-run']" should be attached
       And ".act-menu-tests .act-menu-checks" should be attached

package/core/workspace-app/tests/features/clone-project.feature

@@ -4,17 +4,18 @@ Feature: Cloning a project
 
   Scenario: The DDEV menu offers the clone
     Given I am on "/dev"
+     When I click on the element ".project-row >> nth=0 >> .act-menu-ddev button"
      Then "[hx-get^='/fragments/projects/clone-form/dev/']" should be attached
 
   Scenario: The form arrives prefilled, with the live check wired
-    Given I am on "/fragments/projects/clone-form/dev/v11x00b1i18n"
-     Then "input[name='to'][value='v11x00b1i18n-copy']" should be attached
+    When I open the clone form of the first project in "dev"
+     Then the clone form proposes a copy of that project
       And "select[name='toWorkspace']" should be attached
       And "[hx-get='/fragments/projects/clone-check']" should be attached
       And "textarea[name='prompt']" should be attached
 
   Scenario: The live check refuses an existing project
-    Given I am on "/fragments/projects/clone-check?to=v11x00b1i18n&toWorkspace=dev"
+    When I ask the live check about the name of the first project in "dev"
      Then I should see "already exists"
 
   Scenario: The live check blesses a free name
@@ -22,7 +23,7 @@ Feature: Cloning a project
      Then I should see "is free"
 
   Scenario: Cloning over an existing project is refused server-side too
-    When I post "/actions/clone-project" with '{"workspace":"dev","projectName":"v11x00b1i18n","to":"v11x00b1i18n","toWorkspace":"dev"}'
+    When I post a clone of the first project in "dev" over itself
     Then the action response should contain "already exists"
 
   Scenario: A source that does not exist is refused

package/core/workspace-app/tests/features/project-actions.feature

@@ -2,9 +2,10 @@ Feature: What a project row can actually do
   The verbs on a row, asserted where they are rather than by opening every menu.
 
   # Each menu carries the name of the verb it opens (act-menu-ddev, act-menu-tests, …). A page of
-  # thirteen projects has thirteen of each, so these assert that the control and its items EXIST
-  # rather than clicking one — a test that has to say "the third one" breaks the moment a project
-  # is built. The one click test lives on /rag, which holds exactly one row.
+  # thirteen projects has thirteen of each, so these assert that the control EXISTS rather than
+  # clicking one — a test that has to say "the third one" breaks the moment a project is built. A
+  # menu's items are not on the page until it opens (its body comes from /fragments/row-menu/…), so
+  # a scenario that needs an item opens one menu first, by `nth=0` or on /rag, which holds one row.
 
   Scenario: A row carries a menu for each thing it can do
     Given I am on "/dev"
@@ -14,10 +15,16 @@ Feature: What a project row can actually do
       And the element ".project-row .act-menu-more" should be displayed
 
   # These two are the whole testing feature as far as the interface is concerned: one sets the
-  # environment up, the other runs the suite. Both post to their own action.
+  # environment up, the other runs the suite. Both post to their own action. The menu's items arrive
+  # when it opens (/fragments/row-menu/tests/…), so the menu is opened first — on a row whose caption
+  # says a stack is there (ready to test, not ready, running now), since "Run the tests" is only
+  # offered where there is a suite to run.
+  @needs-testing-stack
   Scenario: The Tests menu offers setting the environment up and running the suite
     Given I am on "/dev"
-     Then "[hx-post='/actions/testing-configure']" should be attached
+     When I click on the element ".project-row:has(.act-menu-tests + .act-status:text-is('ready to test')), .project-row:has(.act-menu-tests + .act-status:text-is('not ready')), .project-row:has(.act-menu-tests + .act-status:text-is('running now')) >> nth=0 >> .act-menu-tests button"
+     Then ".uk-dropdown.uk-open" should be visible
+      And "[hx-post='/actions/testing-configure']" should be attached
       And "[hx-post='/actions/testing-run']" should be attached
 
   # The state under the button is the answer to "is there anything to look at yet" — it says
@@ -34,7 +41,7 @@ Feature: What a project row can actually do
       And I should see "Describe (URLs, services)"
 
   # Launch belongs with the hostname it opens, not in the row of things you DO to a project.
-  Scenario: A running project offers its own URL beside the Launch button
+  @needs-running-project
+  Scenario: A running project shows its own host on its card
     Given I am on "/dev"
-     Then the element ".proj-launch-line" should be displayed
-      And the element ".proj-launch-line .proj-alias" should be displayed
+     Then ".project-row .pcard-host-name" should be attached

package/core/workspace-app/tests/step-definitions/assistant-speech.steps.js

@@ -39,12 +39,17 @@ Then(/^the assistant should offer voice input$/, async function () {
 });
 
 Then(/^the assistant should read its replies aloud$/, async function () {
-  const cfg = await speechConfig(this.page);
+  // The replies are read by the panel's own narrator, not by deep-chat (whose textToSpeech the panel
+  // sets to false on purpose: it would speak the HTML). What must hold is that the panel was handed
+  // narration that is switched on and resolved: a voice with a rate.
+  const cfg = await this.page.evaluate(() => {
+    const el = document.querySelector('deep-chat');
+    if (!el) return null;
+    try { return JSON.parse(el.dataset.settings || '{}'); } catch (_) { return {}; }
+  });
   assert.ok(cfg, 'there is no deep-chat element on this page');
-  assert.notStrictEqual(cfg.textToSpeech, 'unset', 'deep-chat was never given a textToSpeech config');
-  assert.notStrictEqual(cfg.textToSpeech, false, 'voice output is switched off');
-  // Its presence IS the read-aloud behaviour; there is no separate switch to check.
-  assert.ok(Number.isFinite(cfg.textToSpeech.rate), 'no speech rate, so the config is not the resolved one');
+  assert.notStrictEqual(cfg.voiceOutput, false, 'voice output is switched off');
+  assert.ok(cfg.narration && Number.isFinite(cfg.narration.rate), 'no narration voice with a speech rate, so the config is not the resolved one');
 });
 
 /**

package/core/workspace-app/tests/step-definitions/clone-project.steps.js

@@ -0,0 +1,47 @@
+/**
+ * The clone action, exercised on whatever project the dev workspace holds first, so the scenarios
+ * name no project of one machine (#89). The project is read from the tree the dashboard serves.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+
+const APP = path.join(__dirname, '..', '..');
+const BASE = () => process.env.LAUNCH_URL || 'https://workspace.ddev.site';
+
+function firstProject(wsKey) {
+  const { loadWorkspaces } = require(path.join(APP, 'workspaces'));
+  const dir = loadWorkspaces()[wsKey].dir;
+  const first = fs.readdirSync(dir).filter((p) => !p.startsWith('.') && fs.statSync(path.join(dir, p)).isDirectory()).sort()[0];
+  assert.ok(first, `the ${wsKey} workspace holds no project to clone`);
+  return first;
+}
+
+Given('{string} is the first project of the {string} workspace', function (alias, wsKey) {
+  this.cloneProject = firstProject(wsKey); this.cloneWorkspace = wsKey;
+});
+
+When('I open the clone form of the first project in {string}', async function (wsKey) {
+  this.cloneProject = firstProject(wsKey); this.cloneWorkspace = wsKey;
+  await this.page.goto(`${BASE()}/fragments/projects/clone-form/${wsKey}/${encodeURIComponent(this.cloneProject)}`, { waitUntil: 'domcontentloaded' });
+});
+
+Then('the clone form proposes a copy of that project', async function () {
+  await this.page.locator(`input[name='to'][value='${this.cloneProject}-copy']`).waitFor({ state: 'attached', timeout: 10000 });
+});
+
+When('I ask the live check about the name of the first project in {string}', async function (wsKey) {
+  this.cloneProject = firstProject(wsKey); this.cloneWorkspace = wsKey;
+  await this.page.goto(`${BASE()}/fragments/projects/clone-check?to=${encodeURIComponent(this.cloneProject)}&toWorkspace=${wsKey}`, { waitUntil: 'domcontentloaded' });
+});
+
+When('I post a clone of the first project in {string} over itself', async function (wsKey) {
+  this.cloneProject = firstProject(wsKey); this.cloneWorkspace = wsKey;
+  const form = { workspace: wsKey, projectName: this.cloneProject, to: this.cloneProject, toWorkspace: wsKey };
+  const response = await this.page.request.post(`${BASE()}/actions/clone-project`, { form });
+  this.lastActionResponse = await response.text();
+});

package/core/workspace-app/tests/step-definitions/preconditions.steps.js

@@ -97,4 +97,72 @@ Before({ tags: '@needs-check-aliases' }, function () {
   return undefined;
 });
 
-module.exports = { settingValue, APP };
+Before({ tags: '@needs-testing-stack' }, function () {
+  // A row offers "Run the tests" only when the project has a testing stack (a webship-js project,
+  // or the init-full-automated-testing command); the Tests menu of a bare site has nothing to run.
+  let any = false;
+  try {
+    const { testingStackOf } = require(path.join(APP, 'test-reports'));
+    const { loadWorkspaces } = require(path.join(APP, 'workspaces'));
+    const dir = loadWorkspaces().dev.dir;
+    any = fs.readdirSync(dir).some((p) => {
+      try { return fs.statSync(path.join(dir, p)).isDirectory() && testingStackOf(dir, p) !== 'none'; } catch (_) { return false; }
+    });
+  } catch (_) { any = false; }
+  if (!any) {
+    this.attach('SKIPPED: no project in dev/ has a testing stack (a cucumber.js, tests/step-definitions, '
+      + 'or the init-full-automated-testing command), so no row offers "Run the tests". Set one up and '
+      + 'this becomes a real test again.');
+    return 'skipped';
+  }
+  return undefined;
+});
+
+Before({ tags: '@needs-running-project' }, function () {
+  // The card shows a project's host only while DDEV reports it running.
+  let any = false;
+  try {
+    const { execFileSync } = require('child_process');
+    const { loadWorkspaces } = require(path.join(APP, 'workspaces'));
+    const dir = fs.realpathSync(loadWorkspaces().dev.dir);
+    const out = JSON.parse(execFileSync('ddev', ['list', '--json-output'], { encoding: 'utf8', timeout: 60000 }));
+    any = (out.raw || []).some((p) => p.status === 'running' && String(p.approot || '').startsWith(dir + path.sep));
+  } catch (_) { any = false; }
+  if (!any) {
+    this.attach('SKIPPED: no project in dev/ is running (ddev list), so no card shows a host. Start one '
+      + 'and this becomes a real test again.');
+    return 'skipped';
+  }
+  return undefined;
+});
+
+/** A scalar out of a plugin's own settings file (core/config/plugin.<name>.settings.yml), or ''. */
+function pluginSettingValue(plugin, key) {
+  try {
+    const yml = fs.readFileSync(path.join(ROOT, 'core', 'config', `plugin.${plugin}.settings.yml`), 'utf8');
+    const m = yml.match(new RegExp(`^\\s*${key}:\\s*(.+)$`, 'm'));
+    return m ? m[1].trim().replace(/^["']|["']$/g, '').replace(/\s+#.*$/, '') : '';
+  } catch (_) { return ''; }
+}
+
+// A plugin ships features into this suite but no hooks, so it states a precondition in its tag:
+// `@needs-setting-<plugin>-<key>` skips the scenario, with the reason, while that key has no value in
+// the plugin's settings file. The plugin name ends at the first hyphen that is followed by the key,
+// so a plugin named with hyphens tags `@needs-setting-google-drive-folder_id` and the key is the part
+// after the last plugin-name hyphen: the key itself never contains a hyphen (settings keys are snake_case).
+const NEEDS_SETTING = /^@needs-setting-(.+)-([a-z0-9_]+)$/;
+Before(function (scenario) {
+  for (const t of scenario.pickle.tags || []) {
+    const m = NEEDS_SETTING.exec(t.name);
+    if (!m) continue;
+    const [, plugin, key] = m;
+    if (!pluginSettingValue(plugin, key)) {
+      this.attach(`SKIPPED: core/config/plugin.${plugin}.settings.yml has no ${key} on this machine; `
+        + `set it and this becomes a real test again.`);
+      return 'skipped';
+    }
+  }
+  return undefined;
+});
+
+module.exports = { settingValue, pluginSettingValue, APP };

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

@@ -8,13 +8,53 @@
 
 'use strict';
 
-const test = require('node:test');
+const { test, before, after } = require('node:test');
 const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { copyConfig } = require('./_isolated-config');
+
+// The walk is tested on a tree built here, not on whatever this checkout holds: a fresh clone has no
+// built site and no changelog in it, and a test that passed only on a full machine said nothing about
+// the code. The module reads its root once, at load, so the root is set before it is required.
+const REPO = path.join(__dirname, '../../../..');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-changelog-root-'));
+process.env.WORKSPACE_ROOT = root;
 
 const {
   parseChangelog, kindOf, looksLikeVersion, listChangelogs, changelogFor, releasesFor, changelogIndex,
 } = require('../../changelog');
 
+const write = (rel, text) => {
+  fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+  fs.writeFileSync(path.join(root, rel), text);
+};
+
+before(() => {
+  fs.mkdirSync(path.join(root, 'core'), { recursive: true });
+  copyConfig(path.join(REPO, 'core/config'), path.join(root, 'core/config'));
+  // A product with a Keep a Changelog file (Unreleased on top, as they are written), a built site in
+  // dev/ with the old Drupal .txt, and a project that keeps none.
+  write('products/starter/CHANGELOG.md', `# Changelog
+
+## [Unreleased]
+### Added
+- Something that is not out yet
+
+## [1.0.3] - 2026-09-14
+### Added
+- Add a Newsletter Canvas page at \`/newsletter\`
+`);
+  write('dev/blog1/CHANGELOG.txt', `Blog 7.x-1.1, 2012-02-22
+------------------------
+- #1 by someone: a fix
+`);
+  write('dev/plain/README.md', 'No changelog here.\n');
+});
+
+after(() => fs.rmSync(root, { recursive: true, force: true }));
+
 /* ---------------- the formats ---------------- */
 
 test('Keep a Changelog: version, date, and the kind from the section', () => {
@@ -138,7 +178,7 @@ test('an empty file, and a file of nothing but prose, are no releases rather tha
   assert.deepEqual(parseChangelog('# Changelog\n\nAll notable changes are documented here.\n'), []);
 });
 
-/* ---------------- against the real tree ---------------- */
+/* ---------------- against the tree built above ---------------- */
 
 test('a changelog anywhere in the tree is found, not only in products/', () => {
   const found = listChangelogs();
@@ -151,7 +191,9 @@ test('a changelog anywhere in the tree is found, not only in products/', () => {
   // The point of the change: it is a walk of every workspace, not a list of one.
   const workspaces = new Set(found.map((c) => c.workspace));
   assert.ok(workspaces.size > 1,
-    `only ${[...workspaces]} was walked — a built site in dev/ keeps one too`);
+    `only ${[...workspaces]} was walked, and a built site in dev/ keeps one too`);
+  assert.deepEqual(found.map((c) => `${c.workspace}/${c.item}`).sort(), ['dev/blog1', 'products/starter'],
+    'both files, and nothing for the project that keeps none');
 });
 
 test('a name that climbs out of its workspace is refused', () => {
@@ -174,4 +216,8 @@ test('the index summarises everything without throwing on any of it', () => {
     // The newest release is the first in the file, never "Unreleased" — a version people can install.
     assert.ok(!/^unreleased$/i.test(r.latest), `${r.label} reports Unreleased as its latest`);
   }
+  const starter = rows.find((r) => r.item === 'starter');
+  assert.equal(starter.latest, '1.0.3', 'the Unreleased block on top is passed over');
+  assert.equal(starter.unreleasedEntries, 1);
+  assert.equal(rows.find((r) => r.item === 'blog1').latest, 'Blog 7.x-1.1');
 });

package/core/workspace-app/tests/unit/claude-code-here.test.js

@@ -6,7 +6,7 @@ const path = require('path');
 const server = fs.readFileSync(path.join(__dirname, '..', '..', 'server.js'), 'utf8');
 
 test('the SCREENS menu offers Claude Code in the same folder, beside New screen here', () => {
-  assert.match(server, /screen-new-form\?workspace=\$\{encodeURIComponent\(sm\[1\]\)\}&project=\$\{encodeURIComponent\(sm\[2\]\)\}&kind=claude/);
+  assert.match(server, /screen-new-form\?workspace=\$\{encodeURIComponent\(ws\)\}&project=\$\{encodeURIComponent\(project\)\}&kind=claude/);
   assert.match(server, /Claude Code here…/);
 });
 

package/core/workspace-app/tests/unit/ddev-domains.test.js

@@ -9,14 +9,39 @@
 
 'use strict';
 
-const test = require('node:test');
+const { test, before, after } = require('node:test');
 const assert = require('node:assert');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { copyConfig } = require('./_isolated-config');
+
+// The walk over the workspaces runs on a tree built here, not on this checkout: a fresh clone holds no
+// project at all. The workspaces module reads its root once, at load, so it is set before the require.
+const REPO = path.join(__dirname, '../../../..');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-ddev-domains-root-'));
+process.env.WORKSPACE_ROOT = root;
 
 const { ddevHostnames, ddevExtraDomains } = require('../../ddev-domains');
-const { ROOT } = require('../../workspaces');
+const { loadWorkspaces } = require('../../workspaces');
+
+/** A DDEV project inside a workspace of the built tree. */
+function inTree(workspace, name, yaml) {
+  const dir = path.join(root, workspace, name);
+  fs.mkdirSync(path.join(dir, '.ddev'), { recursive: true });
+  if (yaml !== null) fs.writeFileSync(path.join(dir, '.ddev', 'config.yaml'), yaml);
+}
+
+before(() => {
+  fs.mkdirSync(path.join(root, 'core'), { recursive: true });
+  copyConfig(path.join(REPO, 'core/config'), path.join(root, 'core/config'));
+  inTree('dev', 'blog', 'name: blog\nadditional_fqdns:\n  - storybook.blog.ddev.site\n');
+  inTree('dev', 'plain', 'name: plain\nadditional_hostnames:\n  - plain-dev\n');
+  inTree('products', 'shop', 'name: shop\nadditional_fqdns:\n  - mail.shop.ddev.site\n');
+  inTree('products', 'bare', null);
+});
+
+after(() => fs.rmSync(root, { recursive: true, force: true }));
 
 /** A throwaway project directory holding one .ddev/config.yaml. */
 function project(yaml) {
@@ -130,11 +155,10 @@ additional_fqdns:
     'only a host whose FIRST label is storybook is the component library');
 });
 
-/* ---------------- against the real tree ---------------- */
+/* ---------------- against the tree built above ---------------- */
 
 test('the projects in this tree that ship a Storybook are found', () => {
   // The regression in one line: before this parsed additional_fqdns, every one of these was absent.
-  const { loadWorkspaces } = require('../../workspaces');
   const found = [];
   for (const w of Object.values(loadWorkspaces())) {
     if (!w.dir) continue;
@@ -148,6 +172,8 @@ test('the projects in this tree that ship a Storybook are found', () => {
     }
   }
   assert.ok(found.length > 0,
-    'no project in the tree declares a Storybook domain — either the tree changed or the fqdn key stopped being read');
+    'no project in the tree declares a Storybook domain: the fqdn key stopped being read');
   for (const p of found) assert.ok(p.includes('/'), p);
+  assert.deepEqual(found, ['dev/blog'],
+    'the one with a storybook fqdn, and not the label-only, the mail-only or the project with no config');
 });

package/core/workspace-app/tests/unit/plugin-system.test.js

@@ -61,11 +61,14 @@ function tree() {
   fs.writeFileSync(path.join(dir, 'index.js'), `
     module.exports.register = (api) => {
       api.addRowMenu('x-cloud', { label: 'X CLOUD', row: 0 }, ({ key, project, allowed }) => allowed.has('x-cloud') ? '<div class="act-menu-x-cloud">' + key + '/' + project + '</div>' : null);
+      // The lazy form: the button and the URL of the body, which the fragment below answers.
+      api.addRowMenu('x-lazy', { label: 'X LAZY', row: 0 }, ({ key, project, allowed }) => allowed.has('x-cloud')
+        ? { html: '<button class="x-lazy-button">X LAZY</button>', body: '/fragments/p/x-cloud/menu/' + key + '/' + project, caption: 'not linked', classes: 'act-menu-hosting x-family' } : null);
       api.addPage(/^\\/x-cloud\\/([a-z]+)$/, ({ send, match }) => send('page:' + match[1]));
       api.addProjectChip(({ project }) => '<span class="x-chip">' + project + '</span>');
       api.addFolderSetup({ html: () => '<div class="x-setup"></div>', steps: (ws, name, form) => form.x === '1' ? ['echo x ' + name] : [], prompt: () => ['x prompt'], problem: (ws, form) => form.x === 'bad' ? 'bad x' : '' });
       api.addAction('ping', ({ send }) => send('pong'));
-      api.addFragment(({ send, rest }) => send('frag:' + rest));
+      api.addFragment(({ send, rest }) => send(rest.startsWith('menu/') ? '<ul class="uk-nav uk-dropdown-nav"><li class="uk-nav-header">Menu for ' + rest.slice(5) + '</li><li><a href="#" class="x-lazy-item">Deploy</a></li></ul>' : 'frag:' + rest));
       api.addLabels({ region: { label: 'Region' } });
       api.addForge('forge.test', { label: 'X Forge', env: () => ({ X_TOKEN: 'secret' }), auth: () => ({ username: 'me', how: 'token' }) });
       api.addWorkspaceView('x-store', { listHtml: (state) => '<div class="x-list">' + (state.q || '') + '</div>', count: () => 7, noNewForm: true });
@@ -128,6 +131,40 @@ test('a plugin reaches every hook, and what it registers is what the dashboard d
   assert.strictEqual(r.noView, null);
 });
 
+test('a row menu that answers { html, body } is drawn as its button and an empty shell; the body is fetched, through the core, when it opens', async () => {
+  const t = tree();
+  const out = node(`
+    const l = require('./plugin-loader');
+    const vals = () => '';
+    const menus = l.pluginRowMenus({ key: 'dev', project: 'site1', dir: '${t.root}/dev', meta: {}, allowed: new Set(['x-cloud']), vals });
+    const none = l.pluginRowMenus({ key: 'modules', project: 'm', dir: '${t.root}/modules', meta: {}, allowed: new Set(), vals });
+    const bad = l.rowMenuHtml('x-lazy', { html: '<button>x</button>', body: 'https://elsewhere.test/menu' }, { key: 'dev', project: 'site1' });
+    const noCaption = l.rowMenuHtml('x-lazy', { html: '<button>x</button>', body: '/fragments/p/x-cloud/menu/dev/site1' }, { key: 'dev', project: 'site1' });
+    Promise.all([
+      l.pluginRowMenuBody('/fragments/p/x-cloud/menu/dev/site1', { headers: {} }),
+      l.pluginRowMenuBody('/fragments/p/nobody/menu/dev/site1', { headers: {} }),
+    ]).then(([body, missing]) => {
+      console.log(JSON.stringify({ lazy: menus['x-lazy'], inline: menus['x-cloud'], none: none['x-lazy'], bad, noCaption, body, missing,
+        slot: l.pluginRowMenuSlot('x-lazy'), noSlot: l.pluginRowMenuSlot('x-other'), capability: l.loadedPlugins.length > 0 }));
+    });`, env(t));
+  const r = JSON.parse(out);
+  const lazy = r.lazy;
+  assert.ok(lazy.startsWith('<span class="act-with-status"><div class="uk-inline act-menu act-menu-x-lazy act-menu-hosting x-family">'), 'the wrapper the row layout expects, with the slot and the plugin\'s classes');
+  assert.ok(lazy.includes('<button class="x-lazy-button">X LAZY</button>'), 'the button as the plugin drew it');
+  assert.ok(lazy.includes('hx-get="/fragments/row-menu/x-lazy/dev/site1?body=%2Ffragments%2Fp%2Fx-cloud%2Fmenu%2Fdev%2Fsite1"'), 'the shell asks the core for the body, naming the plugin\'s URL');
+  assert.ok(lazy.includes('hx-trigger="menu-opened" hx-target="this" hx-swap="innerHTML"'), 'fetched when the menu opens, into the dropdown');
+  assert.ok(lazy.includes('<div uk-dropdown="mode: click; pos: bottom-right" class="act-menu-lazy"'), 'an ordinary UIkit dropdown shell');
+  assert.ok(lazy.endsWith('<span class="act-status uk-text-meta">not linked</span></span>'), 'the caption beside the button');
+  assert.ok(!lazy.includes('Menu for') && !lazy.includes('x-lazy-item'), 'the page carries no menu body');
+  assert.strictEqual(r.inline, '<div class="act-menu-x-cloud">dev/site1</div>', 'a string return is drawn inline, as before');
+  assert.strictEqual(r.none, '', 'null is an empty slot, in either form');
+  assert.strictEqual(r.bad, '', 'a body outside /fragments/p/<plugin>/ is not a menu');
+  assert.ok(!r.noCaption.includes('act-status'), 'no caption, no caption span');
+  assert.deepStrictEqual(r.body, { status: 200, html: '<ul class="uk-nav uk-dropdown-nav"><li class="uk-nav-header">Menu for dev/site1</li><li><a href="#" class="x-lazy-item">Deploy</a></li></ul>' }, 'the body is the plugin\'s fragment, answered as a value');
+  assert.strictEqual(r.missing.status, 404, 'a URL no plugin serves is 404');
+  assert.ok(r.slot && !r.noSlot, 'the core knows which slots are plugin menus');
+});
+
 test('a dotted legacy key names a nested settings.yml block, for the reader and the installer', () => {
   const t = tree();
   const dir = path.join(t.plugins, 'x-forge');

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

@@ -0,0 +1,21 @@
+'use strict';
+// The precondition helpers read the machine's settings files the way the hooks do.
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+test('a plugin setting is read from the plugin\'s own file, and is empty when the file or the key is absent', () => {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ws-precond-'));
+  fs.mkdirSync(path.join(tmp, 'core', 'config'), { recursive: true });
+  fs.writeFileSync(path.join(tmp, 'core', 'config', 'plugin.jira.settings.yml'), 'site: "https://example.atlassian.net"\ndefault_project: WEBSHIP  # the key folders inherit\nallow_writes: false\n');
+  // The hooks resolve ROOT from their own location; the helper is exercised through the same regex on a copy.
+  const src = fs.readFileSync(path.join(__dirname, '..', 'step-definitions', 'preconditions.steps.js'), 'utf8');
+  const fn = new Function('fs', 'path', 'ROOT', src.match(/function pluginSettingValue[\s\S]*?\n}\n/)[0] + '; return pluginSettingValue;')(fs, path, tmp);
+  assert.strictEqual(fn('jira', 'default_project'), 'WEBSHIP');
+  assert.strictEqual(fn('jira', 'site'), 'https://example.atlassian.net');
+  assert.strictEqual(fn('jira', 'missing_key'), '');
+  assert.strictEqual(fn('nope', 'default_project'), '');
+  fs.rmSync(tmp, { recursive: true, force: true });
+});

package/core/workspace-app/tests/unit/row-layout.test.js

@@ -514,7 +514,10 @@ test('the row, the SCREENS fragment and the Commands page are wired to rows mana
   assert.match(src, /const extraRows = rowLines\.extra\.filter\(Boolean\);/);
   assert.match(src, /\$\{extraRows\.join\(''\)\}/);
   assert.match(src, /const ddevItems = rowLayout\.arrangeNavInner\('ddev', ddevMenuItems, rowCtx\);/);
-  assert.match(src, /return res\.end\(rowLayout\.arrangeNavInner\('screens', screensNav,/);
+  // The SCREENS body is arranged where it is served: the legacy fragment, and the row-menu route every
+  // core menu (DDEV, COMPOSER, Tests, SCREENS) loads its body through when it opens — arranged, then columns.
+  assert.match(src, /return res\.end\(rowLayout\.arrangeNavInner\('screens', nav,/);
+  assert.match(src, /rowLayout\.columnizeButtonHtml\(slot, rowLayout\.arrangeButtonHtml\(slot, html, ctx\), layout\)/);
   assert.match(src, /'\/settings\/buttons'[\s\S]{0,400}settingsPage\('buttons'/);
   assert.match(src, /\.\.\.require\('\.\/actions\/row-actions'\)/);
   const ui = fs.readFileSync(path.join(__dirname, '..', '..', 'public', 'ui.js'), 'utf8');