@webship.co/workspace 0.0.0-stage → 1.0.0-beta1

package/actions/screens.js

@@ -0,0 +1,270 @@
+/**
+ * The screen-session actions: watch a session's log live, or stop it. The
+ * domain lives in ../screens, shared with the modal and the Screens page.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { esc } = require('../html');
+const { run, startJob, stopJob, jobFragment, runningJobKey, hostRunnerUp, hostRunnerRequest } = require('../jobs');
+const { screenLogFor, screensGridHtml, screenTargetDir, defaultSessionName } = require('../screens');
+const claudeSessions = require('../claude-sessions');
+const claudeArgs = require('../claude-args');
+const { ROOT } = require('../workspaces');
+
+// A new session: named by the user, started detached in a directory the
+// server resolves from a target token (never a path from the browser), with
+// its output teed to the workspace's own log store.
+const shq = (v) => `'${String(v).replace(/'/g, `'\\''`)}'`;
+
+/** The prompt of a session, kept beside its log with this user's permissions only. */
+function writePromptFile(session, text) {
+  const dir = path.join(ROOT, '.screens', 'prompts');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const file = path.join(dir, `${session}.txt`);
+  fs.writeFileSync(file, text, { mode: 0o600 });
+  return file;
+}
+
+async function screen_new({ form, send, res }) {
+  // An empty name is not a mistake: it means "call it after where it runs", which is what the form
+  // pre-fills anyway. Refusing it made the one field nobody wants to think about the one that fails.
+  const session = String(form.session || '').trim() || defaultSessionName(form.target);
+  if (!/^[a-z0-9][a-zA-Z0-9_.-]*$/.test(session) || session.length > 60) {
+    return send('<div class="msg error">A session name starts with a lowercase letter or digit and holds only letters, digits, - _ and . (60 max).</div>', 400);
+  }
+  const dir = screenTargetDir(form.target);
+  if (!dir) return send('<div class="msg error">Unknown place to run in.</div>', 400);
+  // The name says where it runs, exactly like the sessions the row's commands
+  // start: <workspace>--<project>--<name>. A target of the workspace root or a
+  // folder contributes only what it has.
+  const target = String(form.target || '');
+  const pm = target.match(/^p:([a-z0-9_-]+):(.+)$/);
+  const wm = target.match(/^ws:([a-z0-9_-]+)$/);
+  const prefix = pm ? `${pm[1]}--${pm[2]}--` : wm ? `${wm[1]}--` : '';
+  // The form pre-fills the name with where it runs, so a name that already says it is not said twice:
+  // `dev--ha1x00b1` must not become `dev--ha1x00b1--dev--ha1x00b1`.
+  const said = prefix && (`${session}--` === prefix || session.startsWith(prefix));
+  const fullSession = `${said ? '' : prefix}${session}`.toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-').replace(/-{3,}/g, '--').slice(0, 60);
+  const logDir = path.join(ROOT, '.screens');
+  try { fs.mkdirSync(logDir, { recursive: true }); } catch (_) { /* exists */ }
+  const logFile = path.join(logDir, `${fullSession}.log`);
+  const command = String(form.command || '').trim();
+  const kind = String(form.kind || (command ? 'command' : 'shell'));
+  let inner;
+  if (kind === 'claude') {
+    // Claude Code interactively, in the real PTY screen provides. The field is
+    // the prompt it opens with; a prompt template brings its own flags along,
+    // so the session runs the same command that prompt file documents
+    // (typically --permission-mode bypassPermissions).
+    // The flags are the CLI's own, read from `claude --help` (claude-args.js) rather than typed into a
+    // free-text box: every one that arrives has to be an option that help printed, and every value has
+    // to fit the shape that option documented. A value that does not is REFUSED by name — a flag that
+    // silently did nothing is worse than one that says why.
+    const { options, error } = await claudeArgs.claudeOptions();
+    if (error) {
+      return send(`<div class="msg error">The Claude Code options could not be read on this machine: ${esc(error.slice(0, 200))}</div>`, 503);
+    }
+    const { words, problems } = claudeArgs.flagsFromForm(options, form);
+    if (problems.length) {
+      return send(`<div class="msg error">${problems.map((x) => esc(x)).join('<br>')}</div>`, 400);
+    }
+    const flags = words.join(' ');
+    // Resuming an existing conversation, by id: `claude --resume <id>` from the same directory. The id
+    // is checked against the uuid shape before it reaches a shell line, and only a session that really
+    // exists for THIS directory is accepted — an id from another project would resume nothing and say
+    // so far from here.
+    // The checkbox is what turns it on; the select only says which one. Without the checkbox a select
+    // that was left on its default would resume a session nobody asked to resume.
+    const wanted = form.resume_on ? String(form.resume || '').trim() : '';
+    const resumable = wanted && claudeSessions.isSessionId(wanted)
+      && claudeSessions.sessionsFor(dir, { limit: 200 }).some((x) => x.id === wanted)
+      ? wanted : '';
+    if (wanted && !resumable) {
+      return send(`<div class="msg error">No Claude session <code>${esc(wanted.slice(0, 40))}</code> in <code>${esc(dir)}</code> to resume.</div>`, 400);
+    }
+    const resumeFlag = resumable ? `--resume ${resumable}` : '';
+    // The opening prompt is free text, so it reaches claude through a private file and `$(cat …)`, never as
+    // a double-quoted word in the line: there `$(…)` and backticks in it would be RUN by the shell.
+    const promptFile = command ? writePromptFile(fullSession, command) : '';
+    inner = (command
+      ? `exec claude ${resumeFlag} ${flags} "$(cat ${shq(promptFile)})"`
+      : `exec claude ${resumeFlag} ${flags}`).replace(/ {2,}/g, ' ').trim();
+  } else if (kind === 'shell' || !command) {
+    inner = 'exec bash -l';
+  } else {
+    // Braces group the WHOLE command before the pipe: without them only the
+    // last segment of `a; b` is logged.
+    inner = `{ ${command} ; } 2>&1 | tee -a ${JSON.stringify(logFile)}`;
+  }
+  // The session knows where it was started without being told: the workspace, the project and the folder
+  // are in its environment, so a shell, a command or the agent never has to ask which workspace this is.
+  const sq = shq;
+  const known = { WEBSHIP_WORKSPACE: pm ? pm[1] : wm ? wm[1] : '', WEBSHIP_PROJECT: pm ? pm[2] : '', WEBSHIP_WORKSPACE_DIR: dir };
+  const vars = Object.entries(known).map(([k, v]) => `${k}=${sq(v)}`).join(' ');
+  // The runner keeps a command that starts with `exec ` interactive and pipes anything else through tee,
+  // which turns claude into --print and a shell into a pipe, so the variables go INSIDE the exec.
+  inner = /^exec /.test(inner) ? `exec env ${vars} ${inner.slice(5)}` : `export ${vars}; ${inner}`;
+  // Sessions run on the machine, not in this container — so `screen -r` in the
+  // user's own terminal reaches them, and a browser an agent opens is a window
+  // on their desktop.
+  if (!(await hostRunnerUp())) return send(runnerDownHtml(), 503);
+  const answer = await hostRunnerRequest('start', { session: fullSession, dir, owner: dir, cmd: inner });
+  if (!answer) return send(runnerDownHtml(), 503);
+  if (answer.already) return send(`<div class="msg error">A session called <strong>${esc(fullSession)}</strong> is already running.</div>`, 409);
+  if (!answer.ok) return send(`<div class="msg error">Could not start it: <pre>${esc(String(answer.error || '').slice(-250))}</pre></div>`, 500);
+
+  // Started for a work item (the form's `work_key`): the plugins note the run and say so on the item
+  // if that was asked for. The dashboard itself keeps no record of what a key means.
+  const workKey = String(form.work_key || '').toUpperCase();
+  let posted = '';
+  if (/^[A-Z][A-Z0-9]+-[0-9]+$/.test(workKey)) {
+    const wm = String(form.target || '').match(/^p:([a-z0-9_-]+):(.+)$/);
+    posted = await require('../plugin-loader').pluginScreenStarted({ session: fullSession, workKey,
+      workspace: wm ? wm[1] : '', project: wm ? wm[2] : '', dir, form });
+  }
+  // A session that exists now should show up now: the badge in the topbar, the row's SCREENS menu and
+  // the screens page all listen for this, so none of them waits out its own poll to admit that the
+  // thing you just started is running.
+  try { res.setHeader('HX-Trigger', JSON.stringify({ 'screens-changed': { session: fullSession } })); } catch (_) { /* headers already sent */ }
+  return send(posted + await screensGridHtml());
+}
+
+// The rest of the screen(1) verbs the page offers, each one command:
+//   detach    screen -S <s> -X detach     — drop every other client
+//   interrupt screen -S <s> -X stuff ^C   — interrupt what runs inside
+//   wipe      screen -wipe                — forget dead sessions
+// The dashboard's container has no screen sessions of its own any more, so a
+// screen(1) verb is asked of the machine — falling back to the container only
+// for the sessions started before the move.
+async function onHostScreen(session, args) {
+  const live = await require('../screens').listScreens();
+  const row = live.find((s) => s.session === session);
+  // Stopping goes through the host runner when the runner owns the session: it started the process
+  // group and is the one that can take the whole thing down.
+  if (row && row.where === 'host' && args.includes('quit')) {
+    const answer = await hostRunnerRequest('stop', { session });
+    if (answer && answer.ok) return { ok: true, stdout: '', stderr: '' };
+  }
+  // Everything else is screen's own, and screen IN HERE can reach it: `/run/screen` is shared with
+  // this container, which is the same reason `screen -x` attaches at all.
+  //
+  // This used to refuse every verb but quit for any session marked `host` — which is every session,
+  // since that is what listScreens labels them — and answer with "run it in your terminal" instead. So
+  // the terminal window's Ctrl-C and Detach buttons did nothing but print a command to go and type,
+  // for a session this process could drive all along. Verified from the container: `screen -S <s> -X
+  // stuff` is accepted.
+  const out = await run('screen', args, process.env.HOME, { timeoutMs: 10 * 1000 });
+  if (out.ok) return out;
+  // Only when it really fails is there something for a person to do, and then the command is the one
+  // that was actually attempted rather than a reconstruction of it.
+  const verb = args.slice(3).join(' ');
+  return { ok: false,
+    stdout: out.stdout,
+    stderr: `${String(out.stderr || out.stdout || '').trim()}\nIf this keeps failing, run it in your terminal: screen -S ${session} -X ${verb}` };
+}
+
+function runnerDownHtml() {
+  return '<div class="msg error">Sessions run on your machine, not in this container, and its runner is not up. '
+    + 'Start it once with: <code>bash ~/workspace/core/workspace-app/scripts/screen-host.sh --start</code></div>';
+}
+
+// The modes a program turns on and does not always turn off again.
+//
+// A TUI asks the terminal to report the mouse (1000/1002/1003, SGR 1006/1015), to bracket pastes
+// (2004) and for its own screen (1049). screen remembers the window's state and REPLAYS it to every
+// display that attaches afterwards — so when the program dies without putting them back, the next
+// terminal to attach has mouse reporting on with nothing consuming it, and the wheel writes
+// coordinates like `<35;80;10M` into the shell instead of scrolling. It looks like a broken terminal
+// and it is a mode nobody can see.
+//
+// There is no screen command that writes to a window's terminal: `-X echo` goes to the status line,
+// and `-X stuff` goes to the program's INPUT. So the reset is what a person would type — a printf of
+// the disable sequences — which is why this asks first and says so: it types a line into the session,
+// and that is only harmless at a shell prompt.
+const MODE_RESETS = ['?1000l', '?1001l', '?1002l', '?1003l', '?1005l', '?1006l', '?1015l', '?2004l']
+  .map((m) => `\\\\033[${m}`).join('');
+
+async function screen_verb({ form, send, pathname }) {
+  const session = String(form.session || '');
+  if (pathname === '/actions/screen-wipe') {
+    await run('screen', ['-wipe'], process.env.HOME, { timeoutMs: 10 * 1000 });
+    return send(await screensGridHtml());
+  }
+  if (!/^[a-z0-9][a-zA-Z0-9_.-]*$/.test(session)) return send('<div class="msg error">Not a screen session name.</div>', 400);
+  if (pathname === '/actions/screen-reset-modes') {
+    if (form.confirm !== 'yes') return send('<div class="msg error">Resetting types a command into the session, so it asks first.</div>', 400);
+    const out = await onHostScreen(session, ['-S', session, '-X', 'stuff', `printf "${MODE_RESETS}"\n`]);
+    return send(out.ok
+      ? `<div class="msg assistant">Cleared the mouse and paste modes on <strong>${esc(session)}</strong>.
+         Every terminal attached to it, here and in a real terminal, scrolls normally again.
+         <p class="uk-text-meta">It typed <code>printf</code> at the session's prompt — if a full-screen program was running
+         rather than a shell, that line went to the program instead and nothing was reset.</p></div>`
+      : `<div class="msg error">Could not reach ${esc(session)}: ${esc(String(out.stderr || out.stdout).slice(-200))}</div>`, out.ok ? 200 : 500);
+  }
+  const args = pathname === '/actions/screen-detach'
+    ? ['-S', session, '-X', 'detach']
+    : ['-S', session, '-X', 'stuff', '\x03'];
+  const out = await onHostScreen(session, args);
+  const what = pathname === '/actions/screen-detach' ? 'Detached every other client from' : 'Sent Ctrl-C to';
+  return send(out.ok
+    ? `<div class="msg assistant">${what} <strong>${esc(session)}</strong>.</div>`
+    : `<div class="msg error">Could not reach ${esc(session)}: ${esc(String(out.stderr || out.stdout).slice(-200))}</div>`, out.ok ? 200 : 500);
+}
+
+async function screen_watch_or_stop({ form, send, pathname, res }) {
+  const session = String(form.session || '');
+  if (!/^[a-z0-9][a-zA-Z0-9_.-]*$/.test(session)) return send('<div class="msg error">Not a screen session name.</div>', 400);
+  if (pathname === '/actions/screen-stop') {
+    if (form.confirm !== 'yes') return send('<div class="msg error">Stopping requires confirmation.</div>', 400);
+    const out = await onHostScreen(session, ['-S', session, '-X', 'quit']);
+    if (!out.ok) {
+      // A dead socket has no process to quit — `screen -wipe` is what clears it.
+      await run('screen', ['-wipe'], process.env.HOME, { timeoutMs: 10 * 1000 });
+      const still = (await require('../screens').listScreens()).some((s) => s.session === session);
+      if (still) return send(`<div class="msg error">Could not stop ${esc(session)}: ${esc(String(out.stderr || out.stdout).slice(-200))}</div>`, 500);
+    }
+    // Answer with the refreshed manager so the killed row disappears at once — and say which session
+    // went, so a terminal open on it closes itself. A pane left open on a dead session is a terminal
+    // you can still type into, and nothing on the other end.
+    try { res.setHeader('HX-Trigger', JSON.stringify({ 'screen-killed': { session }, 'screens-changed': { session } })); } catch (_) { /* headers already sent */ }
+    return send(await screensGridHtml());
+  }
+  const log = screenLogFor(session);
+  if (!log) return send('<div class="msg error">No known log for this session — reattach in a terminal instead.</div>', 404);
+  const shellLine = [
+    `tail -n +1 -F ${JSON.stringify(log)} 2>/dev/null & TP=$!`,
+    `while screen -ls 2>/dev/null | grep -q "[.]${session}[[:space:]]"; do sleep 3; done`,
+    `sleep 1; kill $TP 2>/dev/null`,
+    `echo; echo "--- the session ended; full log: ${path.basename(log)} ---"`,
+  ].join('; ');
+  // Keyed, so clicking Watch twice re-shows the running tail instead of
+  // stacking another one against the same log.
+  const key = `watch:${session}`;
+  const existing = runningJobKey(key);
+  if (existing) return send(jobFragment(existing).html);
+  const id = startJob(`📺 Watch <strong>${esc(session)}</strong>`, 'bash', ['-c', shellLine], process.env.HOME,
+    { timeoutMs: 12 * 60 * 60 * 1000, inline: true, key });
+  return send(jobFragment(id).html);
+}
+
+async function job_stop({ form, send }) {
+  const id = String(form.id || '');
+  if (!/^[0-9]+-[a-z0-9]+$/.test(id)) return send('<div class="msg error">Not a job id.</div>', 400);
+  stopJob(id);
+  return send(jobFragment(id).html);
+}
+
+module.exports = {
+  '/actions/job-stop': job_stop,
+  '/actions/screen-new': screen_new,
+  '/actions/screen-detach': screen_verb,
+  '/actions/screen-reset-modes': screen_verb,
+  '/actions/screen-interrupt': screen_verb,
+  '/actions/screen-wipe': screen_verb,
+  '/actions/screen-watch': screen_watch_or_stop,
+  '/actions/screen-stop': screen_watch_or_stop,
+  onHostScreen,
+};

package/actions/testing.js

@@ -0,0 +1,121 @@
+/**
+ * Setting a project's testing environment up, running its suite, and deleting what a run left.
+ *
+ * One module per area of the dashboard, each exporting the handlers it owns keyed by the path that
+ * reaches them. server.js merges the maps and dispatches; nothing here knows about routing, and
+ * adding an action is adding an entry rather than another branch in a 1,250-line function.
+ *
+ * Every handler takes the same context: the parsed form, the response, a `send` that writes an HTML
+ * fragment, and the workspace the request named.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { esc } = require('../html');
+const { humanSize, humanTime } = require('../format');
+const { ROOT, loadWorkspaces, workspaceDir } = require('../workspaces');
+const {
+  run, jobFragment, runningJobKey, startJob, ddevProjectName, listProjects,
+  startInScreen, screenStartedHtml,
+} = require('../jobs');
+const { graphStoreDir } = require('../graphs');
+const {
+  milvusProjectName, ragInstances, ragBindings, ragInstanceFor, ragWriteBinding,
+  ragCollectionName, milvusPost, ragCollections, ragInvalidate,
+} = require('../rag');
+const {
+  findTestReports, testReportFor, invalidateTestReports, testMediaHtml, testingStackOf,
+} = require('../test-reports');
+const { NAME_RE, SCRIPT_RE } = require('../validate');
+const { commandBlock } = require('../command-block');
+const { wsUrl } = require('../urls');
+const { findGraphifyScript, findRagifyScript } = require('../workspaces');
+const { DDEV_ACTIONS } = require('../ddev');
+
+  // Delete one screenshot/recording, or all of a report's.
+  //
+  // Evidence from a finished run, and the next run writes its own — so it is deletable, unlike
+  // anything else in a project. Three things keep it safe:
+  //   * no path ever comes from the request. The name is looked up in the report's OWN file list,
+  //     the same rule the viewer uses, so a crafted name resolves to nothing.
+  //   * every resolved file is realpath-checked to be inside the project directory.
+  //   * a screenshot takes its DOM dump with it: the dump is written per failed step and is
+  //     meaningless once the picture is gone.
+async function test_media_delete({ form, res, send, workspace, pathname }) {
+    const dir = workspaceDir(workspace);
+    const projectName = String(form.projectName || '');
+    const kind = String(form.kind || '') === 'videos' ? 'videos' : 'shots';
+    if (form.confirm !== 'yes') return send('<div class="msg error">Deleting requires confirmation.</div>', 400);
+    if (!NAME_RE.test(projectName) || !fs.existsSync(path.join(dir, projectName))) {
+      return send('<div class="msg error">Unknown project.</div>', 400);
+    }
+    const t = testReportFor(dir, projectName);
+    if (!t) return send('<div class="msg error">No report for this project.</div>', 404);
+
+    const listed = kind === 'videos' ? t.report.videos : t.report.shots;
+    const wanted = String(form.name || '');
+    const picked = form.all === 'yes' ? listed : listed.filter((f) => f.name === wanted);
+    if (!picked.length) return send('<div class="msg error">That file is not in the report.</div>', 404);
+
+    // A screenshot's DOM dump shares its stem.
+    const stem = (n) => n.replace(/\.(png|jpe?g|html?)$/i, '');
+    const doms = kind === 'shots'
+      ? t.report.doms.filter((d) => picked.some((f) => stem(d.name) === stem(f.name)))
+      : [];
+
+    const root = fs.realpathSync(path.join(dir, projectName));
+    let removed = 0;
+    let bytes = 0;
+    for (const f of [...picked, ...doms]) {
+      const full = path.join(dir, projectName, f.file);
+      let real;
+      try {
+        real = fs.realpathSync(full);
+        if (!real.startsWith(root + path.sep)) continue;   // outside the project: not ours to delete
+      } catch (_) { continue; }                            // already gone
+      try {
+        bytes += fs.statSync(real).size;
+        fs.unlinkSync(real);
+        removed += 1;
+      } catch (_) { /* raced with something else */ }
+    }
+    invalidateTestReports();
+    res.setHeader('HX-Trigger', 'refresh-projects');
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+    return res.end(`<div class="msg assistant test-media-flash">🗑️ Deleted ${removed} file${removed === 1 ? '' : 's'} (${esc(humanSize(bytes))}).</div>`
+      + testMediaHtml(workspace, projectName, kind, 1));
+}
+
+  // Set up a project's testing environment, and run its suite. Both are the workspace command,
+  // run as a job — they take minutes (an add-on install pulls browsers; a Webship suite is
+  // hundreds of scenarios) and both must not overlap on one project: two configures race on the
+  // same scaffold, and two runs write the same report.
+async function testing_configure({ form, res, send, workspace, pathname }) {
+    const dir = workspaceDir(workspace);
+    const projectName = String(form.projectName || '');
+    const script = 'cmd-tools-testing.sh';
+    const isRun = pathname.endsWith('-run');
+    if (!fs.existsSync(path.join(dir, script))) return send('<div class="msg error">No testing script in this workspace.</div>', 400);
+    if (!NAME_RE.test(projectName) || !listProjects(dir).includes(projectName)) {
+      return send('<div class="msg error">Unknown project.</div>', 400);
+    }
+    if (isRun && testingStackOf(dir, projectName) === 'none') {
+      return send('<div class="msg error">No testing stack in this project yet — set the environment up first.</div>', 409);
+    }
+    const jobKey = `testing:${workspace}/${projectName}`;
+    if (runningJobKey(jobKey)) {
+      return send('<div class="msg error">A testing job is already running for this project.</div>', 409);
+    }
+    const args = isRun ? [script, projectName, '--run'] : [script, projectName];
+    const started = await startInScreen({ workspace, project: projectName, projectDir: dir, ownerDir: path.join(dir, projectName),
+      verb: isRun ? 'tests' : 'tests-setup', cmdLine: `bash ${JSON.stringify(script)} ${JSON.stringify(projectName)}${isRun ? ' --run' : ''}`,
+      label: isRun ? 'run the tests' : 'set up testing' });
+    return send(screenStartedHtml(started, isRun ? 'run the tests' : 'set up testing', projectName), started.ok ? 200 : (started.already ? 409 : 500));
+}
+
+module.exports = {
+  '/actions/test-media-delete': test_media_delete,
+  '/actions/testing-configure': testing_configure,
+  '/actions/testing-run': testing_configure,
+};

package/actions/video-edit.js

@@ -0,0 +1,54 @@
+/**
+ * Edit a video into a new version: the tabs of the Edit modal post here.
+ *
+ * The form is `video-edit.js`; the work is `videos/cmd-tools-video-edit.sh`, run on the host in a screen
+ * session like every other long action. Only a new section spoken with ElevenLabs spends credits, and that
+ * needs `confirm=yes`, which only the confirm dialog's button sends.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { esc } = require('../html');
+const { workspaceDir } = require('../workspaces');
+const { startInScreen, screenStartedHtml } = require('../jobs');
+const voice = require('../audio-voice');
+const videoEdit = require('../video-edit');
+
+async function video_edit({ form, send, workspace }) {
+  if (workspace !== 'videos') return send('<div class="msg error">Videos are edited in the videos workspace.</div>', 400);
+  const found = form.mode === 'sections' ? await voice.loadEngines() : { engines: [] };
+  const p = videoEdit.plan(form, found.engines);
+  if (p.error) return send(`<div class="msg error">${esc(p.error)}</div>`, 400);
+  if (p.spends && form.confirm !== 'yes') return send(videoEdit.spendHtml(p));
+  const stringsFile = Object.keys(p.strings).length ? videoEdit.writeStrings(p.strings) : null;
+  const opts = { workspace, project: path.basename(p.out, '.mp4'), projectDir: workspaceDir('videos'), verb: 'edit',
+    cmdLine: videoEdit.commandLine(p, stringsFile, true), label: `video edit ${p.out}` };
+  const started = await startInScreen(opts);
+  if (!started.ok) {
+    if (stringsFile) fs.rmSync(path.dirname(stringsFile), { recursive: true, force: true });
+    return send(screenStartedHtml(started, opts.label, opts.project), started.already ? 409 : 500);
+  }
+  return send(voice.progressHtml({ kind: 'video', file: p.out, session: started.session, t0: Date.now(), engine: '', edit: '1' }, null));
+}
+
+// Ask the AI to make the change: a Claude Code screen in the videos folder, briefed with the video, its script,
+// the tools, the rules, the settings already chosen on the tab, and the person's own words.
+async function video_edit_ai({ form, send, res }) {
+  const brief = videoEdit.askBrief(form);
+  if (brief.error) return send(`<div class="msg error">${esc(brief.error)}</div>`, 400);
+  let out = null;
+  await require('./screens')['/actions/screen-new']({
+    form: { target: brief.target, kind: 'claude', session: brief.session, command: brief.prompt },
+    send: (html, status = 200) => { out = { html, status }; },
+    res,
+  });
+  if (!out || out.status >= 400) return send((out && out.html) || '<div class="msg error">The session did not start.</div>', (out && out.status) || 500);
+  const sessionName = `${brief.target.startsWith('p:') ? brief.target.slice(2).replace(':', '--') : 'videos'}--${brief.session}`.toLowerCase();
+  return send(`<div class="msg assistant">
+      <p>The AI (Claude Code) is working on <strong>${esc(brief.file)}</strong> in the session <code>${esc(sessionName)}</code>.</p>
+      <p class="uk-text-meta">Watch it, answer it and approve its steps on <a href="/screens">Screens</a>, or <code>screen -r ${esc(sessionName)}</code> in your own terminal.
+        The new version appears in the list when it is done; the original is not touched.</p></div>`);
+}
+
+module.exports = { '/actions/video-edit': video_edit, '/actions/video-edit-ai': video_edit_ai };

package/ai-inventory.js

@@ -0,0 +1,182 @@
+/**
+ * What "@" and "/" can offer, and what the AI Assistant is told it has.
+ *
+ * ONE inventory, read by three callers that used to disagree or not know at all:
+ *
+ *   - the suggestion popup in any prompt field (@ for agents and skills, / for commands),
+ *   - the Ace completer on the New screen form,
+ *   - the assistant's own system prompt, which never listed these at all — so it could
+ *     not use a skill it had, and would improvise instead of invoking one.
+ *
+ * The DESCRIPTION is why this is not just a directory listing. Claude Code chooses an
+ * agent or a skill by its frontmatter `description`, and a picker that shows only names
+ * makes the reader guess between `webship-workspace-build` and `webship-workspace-backups`.
+ * The same line is what lets the assistant pick correctly, so both read it from the file
+ * rather than from a hand-kept table that would drift.
+ *
+ * Three places hold items, and precedence runs the same way Claude Code resolves them:
+ * a project's own .claude/ wins over ~/.claude, which wins over the workspace draft
+ * folders (ai-agents/, ai-skills/, ai-commands/, ai-prompts/). `where` says which, so
+ * the list can show it and the assistant knows whether an item is actually installed.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { ROOT } = require('./workspaces');
+
+/**
+ * The workspace tooling itself: `webship-workspace` and its skills (-build, -backups,
+ * -graphify, -dashboard, -authoring, -site-templates, -upsun, -linux-install).
+ *
+ * These are BUILT IN to the AI Assistant — it already operates this workspace, and its
+ * system prompt carries these rules whether anybody names them or not. So offering them
+ * in the picker is noise at best and misleading at worst: it implies that building a
+ * project needs you to remember `@webship-workspace-build` first, when asking for a build
+ * is enough. Nine rows out of 135, and they crowd the top of the list because they share
+ * a prefix with the product's own name.
+ *
+ * They stay in the inventory — the assistant is still told it has them, so it can say
+ * which one it is following — and are filtered out of the SUGGESTIONS only.
+ */
+const BUILT_IN = /^webship-workspace(-|$)/;
+
+// Kind -> which trigger character offers it.
+//
+// This mirrors the CLI rather than inventing a scheme: in Claude Code a slash command is
+// typed as `/name`, and an agent is named in prose. Skills appear under BOTH here on
+// purpose — a skill is a capability you name (@) and also the thing you most often want
+// to invoke directly (/) — and prompts under neither, because a prompt is a whole
+// `claude …` launch command for a NEW session, so it cannot be dropped into a message
+// that is already running. The New screen form offers those in its own template picker.
+const TRIGGERS = {
+  agent: ['@'],
+  skill: ['@', '/'],
+  command: ['/'],
+};
+
+// A frontmatter description, as one line.
+//
+// Read from the head of the file only: a skill can be hundreds of lines and none of the
+// rest is frontmatter. The value may be folded over several lines in YAML, so a
+// continuation (indented, no `key:` of its own) is joined back on.
+const HEAD_BYTES = 4096;
+function descriptionOf(file) {
+  let head = '';
+  try {
+    const fd = fs.openSync(file, 'r');
+    const buf = Buffer.alloc(HEAD_BYTES);
+    const read = fs.readSync(fd, buf, 0, HEAD_BYTES, 0);
+    fs.closeSync(fd);
+    head = buf.slice(0, read).toString('utf8');
+  } catch (_) { return ''; }
+  if (!/^---\s*$/m.test(head.split('\n')[0] || '')) return '';
+  const lines = head.split('\n').slice(1);
+  let out = '';
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (/^---\s*$/.test(line)) break;
+    const m = line.match(/^description:\s*(.*)$/);
+    if (!m) continue;
+    out = m[1].trim().replace(/^["']|["']$/g, '');
+    // A folded value: following lines that are indented and are not themselves a key.
+    for (let j = i + 1; j < lines.length; j += 1) {
+      if (/^---\s*$/.test(lines[j])) break;
+      if (/^\s+\S/.test(lines[j]) && !/^\s*[a-zA-Z_-]+:/.test(lines[j])) {
+        out += ` ${lines[j].trim()}`;
+      } else break;
+    }
+    break;
+  }
+  return out.replace(/\s+/g, ' ').trim();
+}
+
+/** Items of one kind in one directory. Skills are directories with a SKILL.md. */
+function readKind(dir, kind, where, out) {
+  let entries = [];
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+  for (const e of entries) {
+    let name = '';
+    let file = '';
+    if (kind === 'skill') {
+      if (!e.isDirectory()) continue;
+      file = path.join(dir, e.name, 'SKILL.md');
+      if (!fs.existsSync(file)) continue;
+      name = e.name;
+    } else {
+      if (!e.isFile() || !e.name.endsWith('.md')) continue;
+      // A folder's own documentation is not an item in it.
+      if (['README.md', 'AGENTS.md', 'CLAUDE.md'].includes(e.name)) continue;
+      name = e.name.replace(/\.md$/, '');
+      file = path.join(dir, e.name);
+    }
+    const key = `${kind}:${name}`;
+    // First writer wins, and callers add in precedence order: a project's own copy of an
+    // item is the one that would actually run there, so it must not be overwritten by
+    // the global one found later.
+    if (out.has(key)) continue;
+    out.set(key, { name, kind, where, file, description: descriptionOf(file),
+      triggers: TRIGGERS[kind] || [], builtIn: BUILT_IN.test(name) });
+  }
+}
+
+// The filesystem is walked per request otherwise, and a keystroke in the composer asks
+// for this list. Short enough that installing a skill shows up while you are looking.
+const TTL = 5000;
+const _cache = new Map();
+
+/**
+ * Everything "@" and "/" can offer here.
+ * @param {string} [workspace] the workspace key, when a page is scoped to one
+ * @param {string} [project]   a project inside it, whose own .claude/ takes precedence
+ */
+function aiInventory(workspace, project) {
+  const ck = `${workspace || ''}/${project || ''}`;
+  const hit = _cache.get(ck);
+  if (hit && Date.now() - hit.at < TTL) return hit.items;
+
+  const home = process.env.HOME || '';
+  const items = new Map();
+
+  // Precedence, highest first.
+  if (workspace && project) {
+    const pDir = path.join(ROOT, workspace, project, '.claude');
+    readKind(path.join(pDir, 'agents'), 'agent', 'this project', items);
+    readKind(path.join(pDir, 'skills'), 'skill', 'this project', items);
+    readKind(path.join(pDir, 'commands'), 'command', 'this project', items);
+  }
+  readKind(path.join(home, '.claude', 'agents'), 'agent', 'installed', items);
+  readKind(path.join(home, '.claude', 'skills'), 'skill', 'installed', items);
+  readKind(path.join(home, '.claude', 'commands'), 'command', 'installed', items);
+  // The workspace drafts. Anything only here is NOT loaded by a session yet, which the
+  // label has to say — otherwise a draft reads as available and silently does nothing.
+  readKind(path.join(ROOT, 'ai-agents'), 'agent', 'workspace draft', items);
+  readKind(path.join(ROOT, 'ai-skills'), 'skill', 'workspace draft', items);
+  readKind(path.join(ROOT, 'ai-commands'), 'command', 'workspace draft', items);
+
+  const list = [...items.values()].sort((a, b) => a.name.localeCompare(b.name));
+  _cache.set(ck, { at: Date.now(), items: list });
+  return list;
+}
+
+/** Just the items a trigger character offers, optionally filtered by what is typed. */
+function suggestFor(trigger, typed, workspace, project) {
+  const q = String(typed || '').toLowerCase();
+  return aiInventory(workspace, project)
+    // The assistant's own tooling is not something to pick — see BUILT_IN above.
+    .filter((i) => !i.builtIn)
+    .filter((i) => i.triggers.includes(trigger))
+    .filter((i) => !q || i.name.toLowerCase().includes(q)
+      || (i.description || '').toLowerCase().includes(q))
+    .sort((a, b) => {
+      // What the user is typing, first: a name that STARTS with it beats one that
+      // merely contains it, and a description match comes last.
+      const rank = (i) => (i.name.toLowerCase().startsWith(q) ? 0
+        : i.name.toLowerCase().includes(q) ? 1 : 2)
+        // then by how close to hand it is
+        + (i.where === 'this project' ? 0 : i.where === 'installed' ? 0.1 : 0.2);
+      return rank(a) - rank(b) || a.name.localeCompare(b.name);
+    });
+}
+
+module.exports = { aiInventory, suggestFor, descriptionOf, TRIGGERS, BUILT_IN };