pi-odd-worktree 0.0.0-stage → 0.1.0

package/tools/package-surface.test.js

@@ -0,0 +1,138 @@
+'use strict';
+// S2/S4 surface: the standalone package registers exactly three commands
+// (/warp, /odd-list and /issues) and the four agent worktree tools, loads
+// without any Herdr binary, and ships none of the removed functionality
+// (customize panel, plugin-tools toggles, worktree mode file, perf tracing).
+// The issues reader, preview formatter and view are the migrated T2 units and
+// are shipped; `/issues` is the T3 command that mounts them, without any
+// worktree↔issue association.
+//
+// Everything here reads the observable surface: the registered command and
+// tool objects, the manifest, the files on disk. No internal state is read.
+const { test, describe, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { LIB_DIR, SRC, loadExtension, stubbedSource } = require('./fixtures/load-extension.js');
+
+const ROOT = path.resolve(__dirname, '..');
+const PKG = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8'));
+
+const savedEnv = { ...process.env };
+after(() => {
+  for (const key of Object.keys(process.env)) {
+    if (!(key in savedEnv)) delete process.env[key];
+  }
+  for (const [key, value] of Object.entries(savedEnv)) process.env[key] = value;
+});
+
+// A nonexistent absolute path is provably not a live Herdr binary, so the
+// shared resolver returns it and every Herdr call fails instead of reaching a
+// real workspace.
+const NO_HERDR = path.join(os.tmpdir(), 'odd-worktree-no-such-herdr-binary');
+
+describe('manifest', () => {
+  test('declares one Pi extension entry point and ships only that surface', () => {
+    assert.equal(PKG.name, 'pi-odd-worktree');
+    assert.ok(PKG.keywords.includes('pi-package'), 'keywords name the pi-package kind');
+    assert.deepEqual(PKG.pi.extensions, ['./extensions/odd-worktree-tools.ts']);
+    for (const entry of ['extensions', 'lib', 'tools', 'README.md']) {
+      assert.ok(PKG.files.includes(entry), `files ships ${entry}`);
+    }
+    assert.equal(PKG.peerDependencies['@earendil-works/pi-coding-agent'], '*');
+    assert.equal(PKG.peerDependencies['@earendil-works/pi-tui'], '*');
+    assert.ok(!('dependencies' in PKG), 'no runtime dependencies are installed');
+    assert.ok(!JSON.stringify(PKG).includes('herdr'), 'the manifest never requires Herdr');
+  });
+
+  test('ships no module for the removed commands', () => {
+    const shipped = fs.readdirSync(path.join(ROOT, 'lib')).sort();
+    for (const gone of [
+      'issues-cache.js',
+      'herdr-plugin-check.js',
+      'gentle-sidebar.js',
+      'perf-trace.js',
+      'perf-analyze.js',
+      'host-settings.js',
+      'worktree-mode.js',
+      'moshi-prereq.js',
+      'live-session-changes.js',
+    ]) {
+      assert.equal(shipped.includes(gone), false, `lib/${gone} is not shipped`);
+    }
+    // The issue reader, preview formatter and view are the migrated units (T2
+    // S1,S3): the per-tab cache is still gone, but the `gh` client, the
+    // formatter and the issues view `/issues` mounts are shipped, so their
+    // presence is asserted rather than forbidden.
+    for (const kept of ['gh-issues.js', 'issue-preview.js', 'issues-view.js', 'warp-selector-view.js', 'odd-view.js', 'worktree-git.js', 'worktree-registry.js', 'worktree-session-guard.js']) {
+      assert.ok(shipped.includes(kept), `lib/${kept} is shipped`);
+    }
+  });
+});
+
+describe('registration', () => {
+  test('registers /warp, /odd-list, /issues and the four worktree tools', async () => {
+    process.env.HERDR_BIN_PATH = NO_HERDR;
+    delete process.env.GENTLE_WORKTREE_THREAD;
+    const { commands, tools, messageRenderers } = await loadExtension({});
+    assert.deepEqual([...commands.keys()].sort(), ['issues', 'odd-list', 'warp']);
+    assert.deepEqual([...tools.keys()].sort(), ['worktree_close', 'worktree_create', 'worktree_list', 'worktree_warp']);
+    assert.deepEqual([...messageRenderers.keys()], ['worktree-warp']);
+  });
+
+  test('every tool keeps its declared name and description', async () => {
+    const { tools } = await loadExtension({});
+    const summary = (name) => {
+      const tool = tools.get(name);
+      return { name: tool.name, label: tool.label };
+    };
+    assert.deepEqual(summary('worktree_create'), { name: 'worktree_create', label: 'Worktree Create' });
+    assert.deepEqual(summary('worktree_list'), { name: 'worktree_list', label: 'Worktree List' });
+    assert.deepEqual(summary('worktree_close'), { name: 'worktree_close', label: 'Worktree Close' });
+    assert.deepEqual(summary('worktree_warp'), { name: 'worktree_warp', label: 'Worktree Warp' });
+  });
+
+  test('the close help text names the active-session refusal and no Herdr workspace', async () => {
+    const { tools } = await loadExtension({});
+    const description = tools.get('worktree_close').description;
+    assert.match(description, /live Pi session working in that checkout/);
+    assert.match(description, /warp to another checkout first/i);
+    assert.match(description, /git/);
+    assert.equal(/and its Herdr workspace/i.test(description), false, 'no Herdr workspace removal is promised');
+    assert.match(description, /no Herdr workspace is closed, opened or removed/);
+  });
+});
+
+describe('removed surface', () => {
+  test('the extension names no customize or Herdr-panel surface', () => {
+    const source = stubbedSource();
+    assert.equal(/herdr-gentle:/.test(source), false, 'no herdr-gentle: command name survives');
+    for (const gone of ['registerCustomizeCommand', 'executeWorktreeSessionOpen', 'startAgentSessionWatcher', 'customizePluginToolEnabled']) {
+      assert.equal(source.includes(gone), false, `${gone} is gone`);
+    }
+    for (const lib of ['worktree-mode.js', 'herdr-plugin-check.js', 'perf-trace.js']) {
+      assert.equal(source.includes(`libRequire("${lib}")`), false, `${lib} is not required`);
+    }
+  });
+
+  test('the /issues command keeps its migrated client and view', () => {
+    const source = stubbedSource();
+    assert.ok(source.includes('pi.registerCommand("issues"'), 'the /issues command is registered');
+    assert.ok(source.includes('function registerIssuesCommand'), 'its registration is a named step');
+    assert.ok(source.includes('libRequire("gh-issues.js")'), 'the reader uses the migrated gh client');
+    assert.ok(source.includes('libRequire("issues-view.js")'), 'the reader mounts the migrated view');
+  });
+
+  test('the loaded extension holds no reference to the removed packages', async () => {
+    const { commands } = await loadExtension({});
+    for (const gone of ['customize', 'odd', 'herdr-gentle:warp']) {
+      assert.equal(commands.has(gone), false, `no /${gone} command`);
+    }
+    assert.equal(commands.has('issues'), true, '/issues is the migrated command');
+    for (const file of fs.readdirSync(path.join(ROOT, 'lib'))) {
+      const text = fs.readFileSync(path.join(LIB_DIR, file), 'utf8');
+      assert.equal(/require\(['"]\.\/gh-issues\.js['"]\)/.test(text), false, `lib/${file} does not pull the issues reader`);
+    }
+  });
+});

package/tools/t5-session-identity.test.js

@@ -0,0 +1,306 @@
+'use strict';
+// T5 durability regressions (verification blocker S7): a deletion refusal must
+// name the REAL active session id, not a hash prefix and not a label.
+//
+// The identity is a JOIN across two published Gentle Shell stores:
+//   - the presence header, keyed by `sessionHash` = sha256(sessionId)
+//     (lib/orchestrator-presence.ts), which carries label, heartbeat and the
+//     session's workspace;
+//   - the transport activation record
+//     `<agent home>/gentle-agents/transport/presence/<sessionId>.<token>.json`
+//     (lib/agents-session-transport.ts), the only published place the raw id
+//     appears.
+// A validated transport record whose id hashes to the header's sessionHash
+// names that session. Nothing else may: no label, no prefix, no saved history.
+//
+// These cases are written against the PUBLIC surfaces only — the two exported
+// guard functions and the registered `worktree_close` tool — so they keep
+// working if internals move. Every fixture is a throwaway repository and agent
+// home under the system temp directory; no real worktree, presence store or
+// session is touched.
+
+const { test, describe, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { loadExtension } = require('./fixtures/load-extension.js');
+
+const guard = require('../lib/worktree-session-guard.js');
+
+const NOW = 1_800_000_000_000;
+const TOKEN_A = 'AbCdEfGhIjKlMnOpQrStUv';
+const TOKEN_B = 'ZbCdEfGhIjKlMnOpQrStUv';
+const roots = [];
+
+after(() => {
+  for (const dir of roots) {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
+  }
+});
+
+function track(dir) {
+  roots.push(dir);
+  return dir;
+}
+
+function agentHome() {
+  return track(fs.mkdtempSync(path.join(os.tmpdir(), 't5-identity-home-')));
+}
+
+function checkout(tag) {
+  return fs.realpathSync(track(fs.mkdtempSync(path.join(os.tmpdir(), `t5-identity-${tag}-`))));
+}
+
+const digest = (id) => crypto.createHash('sha256').update(id).digest('hex');
+const incarnation = (n) => `3000000${n}-0000-4000-8000-00000000000${n}`;
+
+function publishPresence(home, {
+  sessionId, label = 'Worker', workspace = null, heartbeat = NOW, incarnationIndex = 1, discovery = true,
+} = {}) {
+  const dir = path.join(home, 'gentle-agents', 'presence');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(dir, 0o700); } catch { /* best effort */ }
+  const sessionHash = digest(sessionId);
+  const inc = incarnation(incarnationIndex);
+  fs.writeFileSync(path.join(dir, `${sessionHash}.${inc}.header.json`), JSON.stringify({
+    schema: 1,
+    sessionHash,
+    incarnation: inc,
+    label,
+    heartbeat,
+    generation: 1,
+    counts: { running: 0, queued: 0, waiting: 0, finished: 0 },
+    digest: 'a'.repeat(64),
+    unavailable: null,
+  }));
+  if (discovery) {
+    fs.writeFileSync(path.join(dir, `${sessionHash}.${inc}.discovery.json`), JSON.stringify({
+      schema: 1,
+      sessionHash,
+      incarnation: inc,
+      generation: 1,
+      metadata: { activation: 'b'.repeat(64), workspace: workspace ?? '', tasks: [], omitted: 0 },
+    }));
+  }
+  return sessionHash;
+}
+
+function publishTransport(home, { sessionId, token = TOKEN_A, createdAt = NOW - 1000, endpoint = null } = {}) {
+  const base = path.join(home, 'gentle-agents');
+  const dir = path.join(base, 'transport', 'presence');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  for (const owned of [base, path.join(base, 'transport'), dir]) {
+    try { fs.chmodSync(owned, 0o700); } catch { /* best effort */ }
+  }
+  const file = path.join(dir, `${sessionId}.${token}.json`);
+  fs.writeFileSync(file, JSON.stringify({
+    version: 1,
+    sessionId,
+    endpoint: endpoint ?? `/tmp/gentle-pi-1000/0123456789abcdef0123456789abcdef/${token}.sock`,
+    createdAt,
+  }), { mode: 0o600 });
+  try { fs.chmodSync(file, 0o600); } catch { /* best effort */ }
+  return file;
+}
+
+async function readStores(home) {
+  const env = { PI_CODING_AGENT_DIR: home };
+  return {
+    presence: await guard.readGentlePresence({ env, now: NOW }),
+    transport: await guard.readTransportSessions({ env }),
+  };
+}
+
+async function evaluate(target, home, extra = {}) {
+  const { presence, transport } = await readStores(home);
+  return guard.evaluateCheckoutSessions({
+    targetPath: target, presence, transport, now: NOW, ...extra,
+  });
+}
+
+describe('S7 identity join: hash -> raw session id', () => {
+  test('the raw id is resolved deterministically from its own transport record', async () => {
+    const home = agentHome();
+    const target = checkout('resolve');
+    const sessionHash = publishPresence(home, { sessionId: 'worker-alpha', label: 'Alpha', workspace: target });
+    publishTransport(home, { sessionId: 'worker-alpha' });
+    assert.equal(digest('worker-alpha'), sessionHash, 'the presence hash is sha256 of the published id');
+
+    const result = await evaluate(target, home);
+    assert.equal(result.verdict, 'foreign');
+    assert.equal(result.blockers.length, 1);
+    assert.equal(result.blockers[0].rawSessionId, 'worker-alpha');
+    assert.ok(result.text.includes('id worker-alpha'), result.text);
+    assert.equal(result.text.includes(sessionHash.slice(0, 12)), false, 'never the hash when the id resolves');
+    assert.equal(result.evidence.resolved, 1);
+    assert.equal(result.evidence.unresolved, 0);
+  });
+
+  test('another session never lends its id to this hash', async () => {
+    const home = agentHome();
+    const target = checkout('cross');
+    publishPresence(home, { sessionId: 'worker-alpha', label: 'Alpha', workspace: target });
+    publishTransport(home, { sessionId: 'worker-beta', token: TOKEN_B });
+    const result = await evaluate(target, home);
+    assert.equal(result.verdict, 'foreign');
+    assert.equal(result.blockers[0].rawSessionId, null);
+    assert.equal(result.text.includes('worker-beta'), false);
+    assert.match(result.text, /could not be resolved/);
+  });
+
+  test('no transport record means the refusal DISCLOSES the unresolved id', async () => {
+    const home = agentHome();
+    const target = checkout('nojoin');
+    const sessionHash = publishPresence(home, { sessionId: 'worker-alpha', label: 'Alpha', workspace: target });
+    const result = await evaluate(target, home);
+    assert.equal(result.verdict, 'foreign');
+    assert.equal(result.blockers[0].rawSessionId, null);
+    assert.ok(result.text.includes(`presence ${sessionHash.slice(0, 12)}`), result.text);
+    assert.match(result.text, /published no transport record/);
+    assert.match(result.text, /could not be resolved/);
+    assert.equal(result.evidence.unresolved, 1);
+  });
+
+  test('the record body and the endpoint are never read beyond the published keys', async () => {
+    const home = agentHome();
+    const target = checkout('no-secret');
+    publishPresence(home, { sessionId: 'worker-alpha', label: 'Alpha', workspace: target });
+    // A readable file where the endpoint string points: nothing may open it.
+    const endpointDir = track(fs.mkdtempSync(path.join(os.tmpdir(), 't5-identity-endpoint-')));
+    const secretFile = path.join(endpointDir, 'transcript.jsonl');
+    fs.writeFileSync(secretFile, '{"secret":"must-not-be-read"}\n');
+    publishTransport(home, { sessionId: 'worker-alpha', endpoint: secretFile });
+    const result = await evaluate(target, home);
+    assert.equal(result.verdict, 'foreign');
+    assert.equal(result.blockers[0].rawSessionId, 'worker-alpha', 'the join only needs sessionId');
+    assert.equal(JSON.stringify(result).includes('must-not-be-read'), false);
+  });
+
+  test('the current session keeps its warp-first refusal, joined or not', async () => {
+    const home = agentHome();
+    const target = checkout('self');
+    publishPresence(home, { sessionId: 'mine', label: 'Me', workspace: target });
+    publishTransport(home, { sessionId: 'mine' });
+    const result = await evaluate(target, home, { currentSessionId: 'mine' });
+    assert.equal(result.verdict, 'current');
+    assert.match(result.text, /this session is working in that checkout/);
+    assert.match(result.text, /\/warp/);
+  });
+});
+
+describe('S7 identity join through the registered tool', () => {
+  const savedEnv = { ...process.env };
+  const NO_HERDR = path.join(os.tmpdir(), 't5-identity-no-such-herdr');
+  const HOOK_BIN = track(fs.mkdtempSync(path.join(os.tmpdir(), 't5-identity-hookbin-')));
+  fs.writeFileSync(path.join(HOOK_BIN, 'codegraph'), '#!/bin/sh\nexit 0\n', { mode: 0o755 });
+  const AGENT_HOME = agentHome();
+
+  let tools;
+  before(async () => {
+    process.env.HERDR_BIN_PATH = NO_HERDR;
+    process.env.GENTLE_WORKTREE_THREAD = 't5-thread';
+    delete process.env.GENTLE_PI_AGENT_HOME;
+    process.env.PI_CODING_AGENT_DIR = AGENT_HOME;
+    process.env.PATH = `${HOOK_BIN}${path.delimiter}${process.env.PATH || ''}`;
+    ({ tools } = await loadExtension({}));
+  });
+
+  after(() => {
+    for (const key of Object.keys(process.env)) {
+      if (!(key in savedEnv)) delete process.env[key];
+    }
+    for (const [key, value] of Object.entries(savedEnv)) process.env[key] = value;
+  });
+
+  function git(cwd, args) {
+    const out = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    if (out.status !== 0) throw new Error(`git ${args.join(' ')} failed: ${out.stderr}`);
+    return out.stdout.trim();
+  }
+
+  function makeRepo(tag) {
+    const dir = track(fs.mkdtempSync(path.join(os.tmpdir(), `t5-identity-repo-${tag}-`)));
+    git(dir, ['init', '-b', 'main']);
+    git(dir, ['config', 'user.email', 'test@example.test']);
+    git(dir, ['config', 'user.name', 'Test']);
+    fs.writeFileSync(path.join(dir, 'README.md'), '# fixture\n');
+    git(dir, ['add', 'README.md']);
+    git(dir, ['commit', '-m', 'init']);
+    return dir;
+  }
+
+  function makeCtx(repoRoot) {
+    return {
+      cwd: repoRoot,
+      hasUI: false,
+      mode: 'tui',
+      sessionManager: { getSessionId: () => 't5-session' },
+      ui: { confirm: async () => true, notify: () => {} },
+    };
+  }
+
+  function resultText(result) {
+    return (result.content || []).map((part) => (part && part.text) || '').join('\n');
+  }
+
+  test('the tool refusal shows the raw id and leaves the checkout, branch and registry intact', async () => {
+    const repo = makeRepo('joined');
+    const ctx = makeCtx(repo);
+    const created = await tools.get('worktree_create').execute('t5-c1', { branch: 'feat/t5-joined', changes: 'none' }, undefined, undefined, ctx);
+    assert.notEqual(created.isError, true, resultText(created));
+    const target = path.join(path.dirname(repo), `${path.basename(repo)}-worktrees`, 'feat-t5-joined');
+    const sessionHash = publishPresence(AGENT_HOME, { sessionId: 'raw-session-7', label: 'Worker', workspace: target, heartbeat: Date.now(), incarnationIndex: 4 });
+    publishTransport(AGENT_HOME, { sessionId: 'raw-session-7' });
+
+    const closed = await tools.get('worktree_close').execute('t5-c2', { name: 'feat-t5-joined' }, undefined, undefined, ctx);
+    assert.equal(closed.isError, true);
+    const text = resultText(closed);
+    assert.ok(text.includes('id raw-session-7'), text);
+    assert.equal(text.includes(sessionHash.slice(0, 12)), false);
+    assert.equal(closed.details.sessionCheck.resolved, 1);
+    assert.equal(closed.details.sessionCheck.unresolved, 0);
+    // Nothing was mutated: the checkout, git's listing, the branch and the row.
+    assert.ok(fs.existsSync(target), 'the checkout survives');
+    assert.ok(git(repo, ['worktree', 'list', '--porcelain']).includes(target), 'git still lists it');
+    assert.ok(git(repo, ['branch', '--format=%(refname:short)']).split('\n').includes('feat/t5-joined'), 'the branch survives');
+    const listed = await tools.get('worktree_list').execute('t5-c3', {}, undefined, undefined, ctx);
+    assert.equal(resultText(listed).split('\n').length, 3, 'the registry row survives');
+  });
+
+  test('the tool refusal discloses an unresolved id instead of inventing one', async () => {
+    const repo = makeRepo('unjoined');
+    const ctx = makeCtx(repo);
+    await tools.get('worktree_create').execute('t5-c4', { branch: 'feat/t5-unjoined', changes: 'none' }, undefined, undefined, ctx);
+    const target = path.join(path.dirname(repo), `${path.basename(repo)}-worktrees`, 'feat-t5-unjoined');
+    const sessionHash = publishPresence(AGENT_HOME, { sessionId: 'raw-session-8', label: 'Worker', workspace: target, heartbeat: Date.now(), incarnationIndex: 5 });
+
+    const closed = await tools.get('worktree_close').execute('t5-c5', { name: 'feat-t5-unjoined' }, undefined, undefined, ctx);
+    assert.equal(closed.isError, true);
+    const text = resultText(closed);
+    assert.ok(text.includes(`presence ${sessionHash.slice(0, 12)}`), text);
+    assert.match(text, /could not be resolved/);
+    assert.equal(closed.details.sessionCheck.unresolved, 1);
+    assert.ok(fs.existsSync(target), 'the checkout survives');
+  });
+
+  test('the clear path shows the best-effort notices and still removes the checkout', async () => {
+    const repo = makeRepo('notices');
+    const ctx = makeCtx(repo);
+    await tools.get('worktree_create').execute('t5-c6', { branch: 'feat/t5-notice', changes: 'none' }, undefined, undefined, ctx);
+    const target = path.join(path.dirname(repo), `${path.basename(repo)}-worktrees`, 'feat-t5-notice');
+    // A live peer whose discovery sidecar never published a workspace: it can
+    // never be attributed to this checkout, and it must never block.
+    publishPresence(AGENT_HOME, { sessionId: 'legacy-peer', label: 'Legacy', heartbeat: Date.now(), incarnationIndex: 6, discovery: false });
+
+    const closed = await tools.get('worktree_close').execute('t5-c7', { name: 'feat-t5-notice' }, undefined, undefined, ctx);
+    assert.notEqual(closed.isError, true, resultText(closed));
+    const text = resultText(closed);
+    assert.match(text, /published no workspace/);
+    assert.match(text, /best effort/);
+    assert.ok(Array.isArray(closed.details.warnings) && closed.details.warnings.length > 0, 'the notice travels in details');
+    assert.equal(fs.existsSync(target), false, 'the notice never blocks the removal');
+  });
+});

package/tools/warp-create-panel.test.js

@@ -0,0 +1,185 @@
+'use strict';
+// The create panel's live preview: the branch and the target path it derives
+// from the two fields the form asks for.
+//
+// A human picking a change type wants to see WHICH type they picked before
+// typing anything: `preview branch: feat/` and the checkout directory it will
+// occupy (`…/odd-worktree-worktrees/feat-`), completed as the name is typed.
+// The preview is DISPLAY ONLY while the name is empty — an untouched form is
+// still not submittable — so the refusal keeps its own words while the two
+// preview rows stay neutral. Picking another type moves both rows on the same
+// keystroke.
+//
+// Every test renders headlessly against a real temporary repository (the path
+// derivation reads the real repository identity through the same helpers the
+// create path uses) and asserts each line is exactly the requested width.
+// The temporary repository is removed when the suite ends.
+
+const { test, describe, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const panel = require('../lib/warp-create-panel.js');
+const realGit = require('../lib/worktree-git.js');
+
+const scratch = [];
+after(() => {
+  for (const dir of scratch) {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+  }
+});
+
+function scratchDir(tag) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `wt-panel-${tag}-`));
+  scratch.push(dir);
+  return dir;
+}
+
+const REPO = scratchDir('repo');
+execFileSync('git', ['init', '-q', REPO], { stdio: 'ignore' });
+
+// The worktree root the panel derives its target from: `<repo-parent>` +
+// `<repo-name>-worktrees`, exactly what lib/worktree-git.js lays out.
+const WORKTREE_ROOT = path.join(path.dirname(REPO), `${path.basename(REPO)}-worktrees`);
+
+function stripAnsi(text) {
+  return String(text)
+    .replace(/\x1b\[[0-9;]*m/g, '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b_[^\x07\x1b]*\x07/g, '');
+}
+
+function renderedLines(view, width = 120) {
+  const lines = view.render(width);
+  assert.ok(lines.length > 0, 'the panel renders something');
+  for (const line of lines) {
+    assert.equal([...stripAnsi(line)].length, width, `line is not ${width} wide: ${JSON.stringify(line)}`);
+  }
+  return lines;
+}
+
+function findLine(lines, needle) {
+  const line = lines.find((entry) => stripAnsi(entry).includes(needle));
+  assert.ok(line !== undefined, `no line contains ${JSON.stringify(needle)}\n${lines.map(stripAnsi).join('\n')}`);
+  return stripAnsi(line);
+}
+
+function allText(lines) {
+  return lines.map(stripAnsi).join('\n');
+}
+
+// A rendered row is padded to the panel width, so the comparison drops that
+// padding and keeps the derived value itself.
+function previewText(view, which) {
+  return findLine(renderedLines(view), `preview ${which}:`).replace(`preview ${which}: `, '').trimEnd();
+}
+
+function openPanel(overrides = {}) {
+  const finished = [];
+  const view = panel.createWarpCreatePanel({
+    cwd: REPO,
+    git: realGit,
+    helpers: null,
+    hostTui: null,
+    theme: null,
+    rowsAvailable: () => 24,
+    done: (value) => { finished.push(value); },
+    ...overrides,
+  });
+  return { view, finished };
+}
+
+function focusName(view) {
+  view.handleInput('\t'); // type -> name
+}
+
+function typeText(view, text) {
+  for (const char of text) view.handleInput(char);
+}
+
+function createNow(view) {
+  if (view.state.focus !== 'name') view.handleInput('\t');
+  view.handleInput('enter');
+}
+
+describe('the preview shows the selected type before any name is typed', { concurrency: false }, () => {
+  test('an untouched form previews the type branch prefix and its checkout directory', () => {
+    const { view } = openPanel();
+    assert.equal(previewText(view, 'branch'), 'feat/', 'the branch preview names the picked type');
+    assert.equal(previewText(view, 'path'), path.join(WORKTREE_ROOT, 'feat-'), 'the path preview names the directory that type starts');
+    const text = allText(renderedLines(view));
+    assert.ok(!text.includes('preview branch: -'), 'the branch preview is never blank once the type is known');
+    assert.ok(!text.includes('preview path: -'), 'the path preview is never blank once the type is known');
+  });
+
+  test('every change type previews its own prefix', () => {
+    for (const type of panel.CHANGE_TYPES) {
+      const { view } = openPanel({ initialType: type.id });
+      assert.equal(previewText(view, 'branch'), `${type.id}/`, `${type.id} previews its branch prefix`);
+      assert.equal(previewText(view, 'path'), path.join(WORKTREE_ROOT, `${type.id}-`), `${type.id} previews its checkout directory`);
+    }
+  });
+
+  test('typing the name completes both previews as it goes', () => {
+    const { view } = openPanel();
+    focusName(view);
+    typeText(view, 'my');
+    assert.equal(previewText(view, 'branch'), 'feat/my', 'the branch preview follows the first typed characters');
+    assert.equal(previewText(view, 'path'), path.join(WORKTREE_ROOT, 'feat-my'), 'the path preview follows them too');
+    typeText(view, '-name');
+    assert.equal(previewText(view, 'branch'), 'feat/my-name');
+    assert.equal(previewText(view, 'path'), path.join(WORKTREE_ROOT, 'feat-my-name'));
+  });
+
+  test('switching the type moves both previews on the same keystroke, typed name included', () => {
+    const { view, finished } = openPanel();
+    assert.equal(previewText(view, 'branch'), 'feat/');
+    view.handleInput('\x1b[B'); // down: Bug fix
+    assert.equal(previewText(view, 'branch'), 'fix/', 'both rows follow the picked type immediately');
+    assert.equal(previewText(view, 'path'), path.join(WORKTREE_ROOT, 'fix-'));
+
+    focusName(view);
+    typeText(view, 'my-name');
+    view.handleInput('\t'); // back to the type
+    assert.equal(view.state.focus, 'type');
+    view.handleInput('\x1b[A'); // up: back to feat
+    assert.equal(previewText(view, 'branch'), 'feat/my-name', 'the typed name survives the type change');
+    assert.equal(previewText(view, 'path'), path.join(WORKTREE_ROOT, 'feat-my-name'));
+    view.handleInput('\x1b[B'); // down: fix again
+    assert.equal(previewText(view, 'branch'), 'fix/my-name');
+    assert.equal(previewText(view, 'path'), path.join(WORKTREE_ROOT, 'fix-my-name'));
+    assert.deepEqual(finished, [], 'changing the type never submits the form');
+  });
+
+  test('the prefix preview never submits: an empty name still refuses with its own words', () => {
+    const { view, finished } = openPanel();
+    createNow(view);
+    assert.deepEqual(finished, [], 'an empty name creates nothing');
+    const text = allText(renderedLines(view));
+    assert.match(text, /cannot create: name is empty/, 'the refusal keeps its own words');
+    assert.ok(!text.includes('preview branch: -'), 'the preview rows stay neutral, not blank');
+    assert.equal(previewText(view, 'branch'), 'feat/');
+  });
+
+  test('a name with nothing slug-worthy still previews nothing', () => {
+    const { view, finished } = openPanel();
+    focusName(view);
+    typeText(view, '!!!');
+    assert.equal(previewText(view, 'branch'), '-', 'an underivable name previews no branch');
+    assert.equal(previewText(view, 'path'), '-', 'and no path');
+    createNow(view);
+    assert.deepEqual(finished, [], 'an invalid name still never creates');
+    assert.match(allText(renderedLines(view)), /cannot create: name has no letters or digits/);
+  });
+
+  test('a complete form previews and creates the same branch and path', () => {
+    const { view, finished } = openPanel({ initialName: 'new-change' });
+    assert.equal(previewText(view, 'branch'), 'feat/new-change');
+    assert.equal(previewText(view, 'path'), path.join(WORKTREE_ROOT, 'feat-new-change'));
+    createNow(view);
+    assert.deepEqual(finished, [{ ok: true, type: 'feat', name: 'new-change' }], 'the completed form creates with the type id and the typed name');
+  });
+});