pi-odd-worktree 1.1.0 → 1.1.1

package/README.md

@@ -15,7 +15,7 @@ alone; Herdr is optional.
 | `worktree_create` | tool | Creates a branch and its checkout from the **local** `main`, registers it, runs the creation hooks, and copies the pending changes you name. |
 | `worktree_warp` | tool | Queues the session move to another checkout as a `/warp` handoff; the command performs the move when the turn ends. |
 | `worktree_close` | tool | Removes a registered checkout with `git worktree remove`, keeping the branch, and refuses while a live Pi session is working in it. |
-| `/warp` | panel | Moves this session to another checkout: no argument opens the selector (list, create, delete, extended list); `/warp <name>` jumps straight there. |
+| `/warp` | panel | Moves this session to another checkout: no argument opens the selector (list, create, delete, extended list); `/warp <name>` jumps straight there. A session with no conversation yet changes checkout **silently** — no fork, no `Warp · moved` card, nothing to carry — and warping back from it is the same empty case. |
 | `/odd-list` | panel | Two-pane reader of this checkout's `odd/tasks/*.md`: list on the left, styled markdown on the right. |
 | `/issues` | panel | Full-screen reader of this checkout's repository issues — My issues / Assigned / Involved / All — with preview, comments, labels, assignees and close, gated on your repository role. |
 | `/codegraph-hook` | command | **Only when the CodeGraph CLI is installed.** Turns the edit/write sync on or off for the session. |

package/extensions/odd-worktree-tools.ts

@@ -4244,6 +4244,16 @@ function warpNoticeText(targetCwd, branch) {
   return `Worktree warp: now in ${to} (branch '${cleanBranch}').`;
 }
 
+// S1 (warp-empty-session): what an EMPTY session's warp reports. It names
+// WHERE the session now is and never a move: nothing was carried, so the
+// `moved:`/`to:` compact — and the card that accompanies it — would claim a
+// transition that did not happen.
+function warpEmptyText(name, targetCwd) {
+  const toName = warpClean(name, 'worktree');
+  const to = warpClean(targetCwd, '(unknown checkout)');
+  return `worktree warp: ${toName} (empty session, nothing to carry; now at ${to})`;
+}
+
 // Deepest live checkout containing a cwd, by resolved identity — the one
 // rule the listing, the selector title and the already-there check share.
 // `extraIds` lets the already-there check keep its target-cwd candidate
@@ -4813,6 +4823,18 @@ async function executeWorktreeWarp(rawName, ctx, opts) {
     }
     if (handoff) await warpConfirm(r, warpHandoffNotice, true);
   };
+  // S1/S3 (warp-empty-session): the switched-to session of an EMPTY warp is
+  // told nothing — no card, and no handoff continuation either, because the
+  // session carries no task yet (the already-there no-op answers a handoff
+  // with text only, for the same reason). The status line stays: it says
+  // WHERE the session is, not what it carried.
+  const warpSilentWithSession = async (r) => {
+    try {
+      r.ui.setStatus("worktree", `${displayName} (${targetCwd})`);
+    } catch {
+      // Status is cosmetic; the silence is the point.
+    }
+  };
   // S43 records. The POINT of a session is its ACTIVE branch (the live
   // leaf's parentId path, never all append-only entries) filtered to
   // entries that are NOT our own bookkeeping — the custom marker, the
@@ -4855,6 +4877,16 @@ async function executeWorktreeWarp(rawName, ctx, opts) {
   const currentPoint = warpSessions.sessionPoint(
     currentEntriesList, typeof currentLeaf === "string" ? currentLeaf : undefined,
   );
+  // S1/S5 (warp-empty-session): an EMPTY session is one whose active branch
+  // carries no conversation — no `message` entry with role user or assistant
+  // outside the warp bookkeeping, so a rename, the session-worktree
+  // registration or a transition marker never counts as content. It has
+  // nothing to carry, so its warp changes PATH instead of moving work: never
+  // a fork (the host refuses a conversation-less source), never a card, never
+  // a "moved:" claim.
+  const sessionEmpty = !warpSessions.hasConversation(
+    currentEntriesList, typeof currentLeaf === "string" ? currentLeaf : undefined,
+  );
   const warpFileOpen = options && typeof options.warpSessionFileOpen === "function"
     ? options.warpSessionFileOpen
     : undefined;
@@ -5023,7 +5055,13 @@ async function executeWorktreeWarp(rawName, ctx, opts) {
           // cached fingerprint. An unreadable destination never resumes.
           // Never throws: any comparison failure reads as "fork".
           const freshDestPoint = warpFreshPoint(recorded.sessionFile);
-          if (freshDestPoint !== null && warpSessions.samePoint(currentPoint, freshDestPoint)) {
+          // An empty source has no point to compare (its own point is empty
+          // by definition), so it RESUMES the destination session whenever
+          // that file is readable — the conversation it already holds (S4)
+          // or its own emptiness — instead of allocating a copy of nothing. A
+          // session with conversation keeps the same-point gate.
+          if (freshDestPoint !== null
+            && (sessionEmpty || warpSessions.samePoint(currentPoint, freshDestPoint))) {
             recordedSession = recorded;
             recordedFreshPoint = freshDestPoint;
           }
@@ -5039,7 +5077,9 @@ async function executeWorktreeWarp(rawName, ctx, opts) {
   if (recordedSessionFile !== null) {
     let resumed;
     try {
-      resumed = await ctx.switchSession(recordedSessionFile, { withSession: warpResumeWithSession });
+      resumed = await ctx.switchSession(recordedSessionFile, {
+        withSession: sessionEmpty ? warpSilentWithSession : warpResumeWithSession,
+      });
     } catch (err) {
       return failAfterCopy(
         `worktree warp: the session switch to ${targetCwd} failed: ${(err && err.message) || err}; the recorded warp session was kept`,
@@ -5066,8 +5106,12 @@ async function executeWorktreeWarp(rawName, ctx, opts) {
     );
     emitOsc7(options.oscStream || process.stdout, targetCwd);
     return {
-      text: moveText,
-      details: { name: displayName, path: targetCwd, branch: displayBranch, kind: resolved.kind, alreadyThere: false, cancelled: false, ...handoffCopyDetails() },
+      text: sessionEmpty ? warpEmptyText(name, targetCwd) : moveText,
+      details: {
+        name: displayName, path: targetCwd, branch: displayBranch, kind: resolved.kind,
+        alreadyThere: false, cancelled: false,
+        ...(sessionEmpty ? { emptySession: true } : {}), ...handoffCopyDetails(),
+      },
     };
   }
   const sm = ctx.sessionManager || {};
@@ -5082,7 +5126,11 @@ async function executeWorktreeWarp(rawName, ctx, opts) {
   const leaf = typeof sm.getLeafId === "function" ? safe(() => sm.getLeafId()) : null;
   const sessionDir = typeof sm.getSessionDir === "function" ? safe(() => sm.getSessionDir()) : undefined;
   let carried = [];
-  if (!warpSourceUsable(file, warpFileOpen)) {
+  // S1: an empty session is allowed through without a persisted file or
+  // in-memory entries — the refusal below exists because a session with
+  // nothing to carry had nothing to warp FOR, and the empty path now changes
+  // its path instead of carrying anything.
+  if (!sessionEmpty && !warpSourceUsable(file, warpFileOpen)) {
     const entries = typeof sm.getEntries === "function" ? safe(() => sm.getEntries()) : undefined;
     carried = Array.isArray(entries) ? entries : [];
     if (carried.length === 0) {
@@ -5093,6 +5141,82 @@ async function executeWorktreeWarp(rawName, ctx, opts) {
     }
   }
   const SM = options.sessionManagerClass || await sessionManagerClassFor(ctx);
+  // S3 (warp-empty-session): an empty session changes PATH. There is nothing
+  // to carry, so nothing is forked (`forkFrom` refuses a conversation-less
+  // source anyway) and the in-place move the host would need does not exist —
+  // `switchSession(file)` is the only mount, and a session's cwd comes from
+  // its own header. So the equivalent is used: a FRESH session allocated at
+  // the target cwd through the same create/switch machinery the non-persisted
+  // path uses, with only its header written (`wx`, never clobbering) so the
+  // mount and the record both have a real file. The switch is silent: no
+  // card, no transition entry, no rename — bookkeeping this flow did not earn.
+  if (sessionEmpty) {
+    if (!SM || typeof SM.create !== "function") {
+      return failAfterCopy(
+        "worktree warp is unavailable here: the host SessionManager has no create",
+        { name, path: targetCwd, branch: displayBranch, kind: resolved.kind, alreadyThere: false, cancelled: false },
+      );
+    }
+    let emptyFile = null;
+    try {
+      const allocated = SM.create(targetCwd, sessionDir);
+      const allocatedFile = allocated && typeof allocated.getSessionFile === "function" ? allocated.getSessionFile() : undefined;
+      if (typeof allocatedFile !== "string" || allocatedFile.length === 0) {
+        throw new Error("the host allocated no session file for the target");
+      }
+      const header = typeof allocated.getHeader === "function" ? allocated.getHeader() : null;
+      if (!header) throw new Error("the allocated session has no header");
+      // The file is the header alone: there is no entry to carry, and a file
+      // naming the target cwd is what makes the mount and the fresh point
+      // real. `wx` never clobbers an existing file.
+      fs.writeFileSync(allocatedFile, `${JSON.stringify(header)}\n`, { flag: "wx" });
+      emptyFile = allocatedFile;
+    } catch (err) {
+      return failAfterCopy(
+        `worktree warp: could not change this session's path to ${targetCwd}: ${(err && err.message) || err}`,
+        { name, path: targetCwd, branch: displayBranch, kind: resolved.kind, alreadyThere: false, cancelled: false },
+      );
+    }
+    let changed;
+    try {
+      changed = await ctx.switchSession(emptyFile, { withSession: warpSilentWithSession });
+    } catch (err) {
+      return failAfterCopy(
+        `worktree warp: the session switch to ${targetCwd} failed: ${(err && err.message) || err}; the new session file was kept at ${emptyFile}`,
+        { name, path: targetCwd, branch: displayBranch, kind: resolved.kind, alreadyThere: false, cancelled: false },
+      );
+    }
+    if (changed && changed.cancelled === true) {
+      try {
+        fs.unlinkSync(emptyFile);
+      } catch {
+        // Best effort: the report below is what matters.
+      }
+      return failAfterCopy(
+        `worktree warp: ${name} cancelled (the session stays in ${fromCwd}; the new session file was removed)`,
+        { name, path: targetCwd, branch: displayBranch, kind: resolved.kind, alreadyThere: false, cancelled: true },
+      );
+    }
+    // Recording is unchanged: both sides are recorded at their own points, so
+    // a later warp finds this destination session again (S2: warping back
+    // from an empty session is the same empty case).
+    try {
+      recordBothSides(
+        targetCwd, emptyFile, warpFreshPoint(emptyFile),
+        sourceIdentity, currentFile, currentPoint,
+      );
+    } catch {
+      // Best effort: the warp already switched.
+    }
+    emitOsc7(options.oscStream || process.stdout, targetCwd);
+    return {
+      text: warpEmptyText(name, targetCwd),
+      details: {
+        name: displayName, path: targetCwd, branch: displayBranch, kind: resolved.kind,
+        alreadyThere: false, cancelled: false, emptySession: true, ...handoffCopyDetails(),
+      },
+    };
+  }
   if (!SM || typeof SM.forkFrom !== "function") {
     return failAfterCopy(
       "worktree warp is unavailable here: the host SessionManager has no forkFrom",

package/lib/worktree-warp-sessions.js

@@ -158,6 +158,33 @@ function sessionPoint(entries, leafId) {
   return { tipId, count };
 }
 
+// Does the ACTIVE branch carry a CONVERSATION? The host's own notion of
+// content is a `message` entry whose role is user or assistant
+// (SessionManager._persist only flushes a session file once an assistant
+// message exists), and everything the warp appends — the transition marker,
+// the confirmation notice, the session-worktree registration, a rename — is
+// bookkeeping, so a session that holds only those is still an empty one: it
+// has nothing to carry and therefore changes PATH instead of forking. The
+// branch is the same filtered walk `sessionPoint` uses, so an abandoned leg
+// never counts. The role is read from the persisted `entry.message.role` and
+// from a bare `entry.role` alike, because reading an entry as content must
+// not depend on one spelling. A read that throws answers `true`: an
+// unreadable session keeps the ordinary move (fork) instead of silently
+// dropping context it may hold.
+function hasConversation(entries, leafId) {
+  try {
+    for (const entry of activeBranch(entries, leafId)) {
+      if (!entry || isWarpBookkeepingEntry(entry) || entry.type !== 'message') continue;
+      const role = typeof entry.role === 'string' ? entry.role
+        : entry.message && typeof entry.message === 'object' ? entry.message.role : null;
+      if (role === 'user' || role === 'assistant') return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+
 // Point evidence for the R3 fork-vs-resume rule: the source session's
 // FILTERED position (S23 sessionPoint) when the record was written. Older
 // records carry {leafId, entryCount} from the raw-leaf comparison; they
@@ -559,6 +586,7 @@ module.exports = {
   recordWarpSession,
   isWarpBookkeepingEntry,
   sessionPoint,
+  hasConversation,
   samePoint,
   asPoint,
   pointOfSessionFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-odd-worktree",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Pi package for odd-worktree: the Agent Worktree tools (create, list, close, warp), the /warp worktree panel, the /odd-list ODD viewer, and the /issues GitHub issue reader. Works in Pi alone; Herdr is optional.",
   "keywords": [
     "pi-package",

package/tools/warp-empty-session.test.js

@@ -0,0 +1,495 @@
+'use strict';
+// warp-empty-session T1/T2 (S1-S5): a session with no conversation does not
+// "move" — it changes PATH silently.
+//
+// S1: an empty session warps silently — no `worktree-warp` message, no
+// transition card, no "moved:/to:" wording in the returned text.
+// S2: warping back after writing nothing is the same case, in both directions
+// and any number of times.
+// S3: no in-place path change exists in the host, so the equivalent is a fresh
+// session at the target cwd through the create/switch machinery — never
+// `forkFrom` (the host refuses a conversation-less source).
+// S4: branching semantics stay untouched for a session WITH conversation; an
+// empty source RESUMES a destination that already holds a conversation.
+// S5: empty means "the active branch carries no `message` entry with role user
+// or assistant once the warp bookkeeping is excluded".
+//
+// Everything is injected: the SessionManager statics (`forkFrom`/`create`/
+// `open`), the command context, and the OSC stream. The repositories and the
+// session files live in throwaway directories under the system temp dir; no
+// live host, no network, and no real Pi session is touched.
+
+const { test, describe, before, 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 { pathToFileURL } = require('node:url');
+const { spawnSync } = require('node:child_process');
+const { LIB_DIR, stubbedSource } = require('./fixtures/load-extension.js');
+const warpSessionsLib = require('../lib/worktree-warp-sessions.js');
+
+const STAMP = '2026-01-01T00:00:00.000Z';
+const savedEnv = { ...process.env };
+const roots = [];
+
+function track(dir) {
+  roots.push(dir);
+  return dir;
+}
+
+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;
+  for (const dir of roots) {
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
+  }
+});
+
+function runGit(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();
+}
+
+let mod;
+
+before(async () => {
+  const dir = track(fs.mkdtempSync(path.join(os.tmpdir(), 'odd-empty-ext-')));
+  const copy = path.join(dir, 'odd-worktree-tools.mjs');
+  fs.writeFileSync(copy, stubbedSource());
+  process.env.GENTLE_WORKTREE_LIB_DIR = LIB_DIR;
+  process.env.HERDR_BIN_PATH = path.join(dir, 'no-such-herdr-binary');
+  process.env.GENTLE_WORKTREE_THREAD = 'thread-1';
+  mod = await import(pathToFileURL(copy).href);
+  mod.default({
+    registerCommand() {},
+    registerTool() {},
+    registerMessageRenderer() {},
+    on() { return () => {}; },
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Entry fixtures: the shapes the host persists, chained so the active branch
+// is the whole list (each entry's parentId is the previous id).
+// ---------------------------------------------------------------------------
+
+const message = (role, text) => (id, parentId) => ({
+  type: 'message', id, parentId, timestamp: STAMP, message: { role, content: [{ type: 'text', text }] },
+});
+const userSays = (text) => message('user', text);
+const assistantSays = (text) => message('assistant', text);
+const toolResult = (text) => message('toolResult', text);
+// The four warp bookkeeping shapes (lib/worktree-warp-sessions.js): none of
+// them is conversation.
+const registration = () => (id, parentId) => ({
+  type: 'custom', id, parentId, timestamp: STAMP,
+  customType: 'gentle-pi.session-worktree/v1', data: { sessionId: 'thread-1', cwd: '/' },
+});
+const rename = (name) => (id, parentId) => ({ type: 'session_info', id, parentId, timestamp: STAMP, name });
+const transition = (from, to) => (id, parentId) => ({
+  type: 'custom', id, parentId, timestamp: STAMP, customType: 'worktree-warp', data: { from, to },
+});
+const warpNotice = (text) => (id, parentId) => ({
+  type: 'custom_message', id, parentId, timestamp: STAMP, customType: 'worktree-warp', content: text, display: true,
+});
+
+function chain(builders) {
+  const entries = [];
+  let parentId = null;
+  builders.forEach((build, index) => {
+    const entry = build(`e${index + 1}`, parentId);
+    entries.push(entry);
+    parentId = entry.id;
+  });
+  return entries;
+}
+
+function readJsonl(file) {
+  const raw = fs.readFileSync(file, 'utf8');
+  return raw.split('\n').filter((line) => line.length > 0).map((line) => JSON.parse(line));
+}
+
+function writeJsonl(file, lines) {
+  fs.writeFileSync(file, `${lines.map((line) => JSON.stringify(line)).join('\n')}\n`);
+}
+
+function sessionHeader(name, cwd) {
+  return { type: 'session', version: 3, id: `id-${name}`, timestamp: STAMP, cwd };
+}
+
+// ---------------------------------------------------------------------------
+// The injected host: a repository pair, a session directory, the
+// SessionManager double and the command context.
+// ---------------------------------------------------------------------------
+
+function makeRepoPair() {
+  const parent = track(fs.mkdtempSync(path.join(os.tmpdir(), 'odd-empty-repo-')));
+  const repo = path.join(parent, 'project');
+  fs.mkdirSync(repo);
+  runGit(repo, ['init', '-b', 'main']);
+  runGit(repo, ['config', 'user.email', 'test@example.test']);
+  runGit(repo, ['config', 'user.name', 'Test']);
+  fs.writeFileSync(path.join(repo, 'README.md'), '# fixture\n');
+  runGit(repo, ['add', 'README.md']);
+  runGit(repo, ['commit', '-m', 'init']);
+  const worktree = path.join(parent, 'project-worktrees', 'feat-login');
+  runGit(repo, ['worktree', 'add', worktree, '-b', 'feat/login']);
+  return {
+    repo: fs.realpathSync(repo),
+    target: fs.realpathSync(worktree),
+    targetName: 'feat-login',
+  };
+}
+
+function makeWorld() {
+  const sessionDir = track(fs.mkdtempSync(path.join(os.tmpdir(), 'odd-empty-sessions-')));
+  const calls = {
+    forkFrom: [], create: [], open: [], switches: [], messages: [],
+    statuses: [], customEntries: [], renames: [],
+  };
+  const osc = [];
+  let created = 0;
+
+  class FakeSession {
+    constructor({ file = null, cwd = null, header = null, entries = [], name = '' }) {
+      this.file = file;
+      this.cwd = cwd;
+      this.header = header;
+      this.entries = entries.slice();
+      this.name = name;
+      const last = this.entries[this.entries.length - 1];
+      this.leafId = last ? last.id : null;
+    }
+
+    getSessionFile() { return this.file; }
+    getSessionDir() { return sessionDir; }
+    getSessionId() { return 'thread-1'; }
+    getSessionName() { return this.name; }
+    getHeader() { return this.header; }
+    getEntries() { return this.entries.slice(); }
+    getLeafId() { return this.leafId; }
+    branch(id) { this.leafId = id; }
+    resetLeaf() { this.leafId = null; }
+
+    appendCustomEntry(customType, data) {
+      calls.customEntries.push({ file: this.file, customType, data });
+      this.push({ type: 'custom', customType, data });
+    }
+
+    appendSessionInfo(name) {
+      calls.renames.push({ file: this.file, name });
+      this.push({ type: 'session_info', name });
+    }
+
+    push(partial) {
+      const entry = { ...partial, id: `${this.file || 'memory'}#${this.entries.length + 1}`, parentId: this.leafId, timestamp: STAMP };
+      this.entries.push(entry);
+      this.leafId = entry.id;
+    }
+  }
+
+  // The host allocates a session file for the target cwd and writes nothing to
+  // it yet: the file only appears once the manager flushes an assistant turn.
+  FakeSession.create = (cwd, dir) => {
+    calls.create.push({ cwd, sessionDir: dir === undefined ? null : dir });
+    created += 1;
+    const header = sessionHeader(`created-${created}`, cwd);
+    return new FakeSession({ file: path.join(dir || sessionDir, `created-${created}.jsonl`), cwd, header });
+  };
+
+  FakeSession.open = (file, dir) => {
+    calls.open.push({ file, sessionDir: dir === undefined ? null : dir });
+    return load(file);
+  };
+
+  // forkFrom copies the source entries VERBATIM under a new header pointing at
+  // the source, exactly like the installed SessionManager.
+  FakeSession.forkFrom = (sourcePath, targetCwd, dir) => {
+    calls.forkFrom.push({ sourcePath, targetCwd, sessionDir: dir === undefined ? null : dir });
+    created += 1;
+    const file = path.join(dir || sessionDir, `fork-${created}.jsonl`);
+    const lines = readJsonl(sourcePath);
+    const header = { ...sessionHeader(`fork-${created}`, targetCwd), parentSession: sourcePath };
+    const entries = lines.filter((entry) => entry.type !== 'session');
+    writeJsonl(file, [header, ...entries]);
+    return new FakeSession({ file, cwd: targetCwd, header, entries });
+  };
+
+  function load(file) {
+    if (!file || !fs.existsSync(file)) return new FakeSession({ file });
+    const lines = readJsonl(file);
+    const header = lines.length > 0 && lines[0].type === 'session' ? lines[0] : null;
+    return new FakeSession({
+      file,
+      cwd: header ? header.cwd : null,
+      header,
+      entries: lines.filter((entry) => entry.type !== 'session'),
+    });
+  }
+
+  function current(file) {
+    const manager = load(file);
+    manager.name = 'Test session';
+    return manager;
+  }
+
+  // A session Pi has not written to disk yet: no file, only memory.
+  function bare(entries = []) {
+    const manager = new FakeSession({ entries });
+    manager.name = 'Test session';
+    return manager;
+  }
+
+  function ctx({ cwd, manager }) {
+    return {
+      cwd,
+      hasUI: false,
+      mode: 'tui',
+      sessionManager: manager,
+      ui: { notify: () => {}, setStatus: (key, text) => calls.statuses.push([key, text]) },
+      waitForIdle: async () => {},
+      switchSession: async (file, options) => {
+        calls.switches.push({ file, withSession: !!(options && options.withSession) });
+        if (options && typeof options.withSession === 'function') {
+          await options.withSession({
+            ui: { setStatus: (key, text) => calls.statuses.push([key, text]) },
+            sendMessage: (textOrMessage, sendOptions) => {
+              calls.messages.push({ message: textOrMessage, options: sendOptions });
+            },
+          });
+        }
+        return undefined;
+      },
+    };
+  }
+
+  function writeSession(name, cwd, builders) {
+    const file = path.join(sessionDir, `${name}.jsonl`);
+    writeJsonl(file, [sessionHeader(name, cwd), ...chain(builders)]);
+    return file;
+  }
+
+  function sessionFiles() {
+    return fs.readdirSync(sessionDir).filter((entry) => entry.endsWith('.jsonl')).sort();
+  }
+
+  return {
+    sessionDir, calls, osc, SM: FakeSession,
+    stream: { isTTY: true, write: (chunk) => osc.push(chunk) },
+    ctx, current, bare, load, writeSession, sessionFiles,
+  };
+}
+
+function warpOptions(world) {
+  return { sessionManagerClass: world.SM, oscStream: world.stream };
+}
+
+function worktreeWarpMessages(world) {
+  return world.calls.messages.filter(({ message }) => message && message.customType === 'worktree-warp');
+}
+
+// ---------------------------------------------------------------------------
+// S5: the predicate itself.
+// ---------------------------------------------------------------------------
+
+describe('hasConversation (S5)', () => {
+  test('a session that holds only warp bookkeeping carries no conversation', () => {
+    const entries = chain([registration(), rename('New session'), transition('/a', '/b'), warpNotice('warped')]);
+    assert.equal(warpSessionsLib.hasConversation(entries), false);
+    assert.equal(warpSessionsLib.hasConversation([]), false);
+    assert.equal(warpSessionsLib.hasConversation(undefined), false);
+  });
+
+  test('a user or assistant message is conversation, a tool result alone is not', () => {
+    assert.equal(warpSessionsLib.hasConversation(chain([registration(), userSays('hi')])), true);
+    assert.equal(warpSessionsLib.hasConversation(chain([assistantSays('hello')])), true);
+    assert.equal(warpSessionsLib.hasConversation(chain([registration(), toolResult('ok')])), false);
+  });
+
+  test('only the ACTIVE branch decides: an abandoned leg never makes it non-empty', () => {
+    const abandoned = { type: 'message', id: 'leg-1', parentId: 'e1', timestamp: STAMP, message: { role: 'user', content: [] } };
+    const entries = [{ ...chain([registration()])[0] }, abandoned];
+    // The abandoned entry IS the last entry, so it is also the leaf; point the
+    // leaf at the bookkeeping entry instead to model a rewind onto the root leg.
+    assert.equal(warpSessionsLib.hasConversation(entries, 'e1'), false);
+    assert.equal(warpSessionsLib.hasConversation(entries), true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// S1/S3: an empty session changes path, silently.
+// ---------------------------------------------------------------------------
+
+describe('an empty session warps silently', () => {
+  test('no fork, no card, no transition entry, and it continues at the target cwd', async () => {
+    const { repo, target, targetName } = makeRepoPair();
+    const world = makeWorld();
+    const source = world.writeSession('empty-source', repo, [registration(), rename('New session')]);
+
+    const out = await mod.executeWorktreeWarp(targetName, world.ctx({ cwd: repo, manager: world.current(source) }), warpOptions(world));
+
+    assert.notEqual(out.isError, true, out.text);
+    assert.deepEqual(world.calls.forkFrom, [], 'an empty session never forks');
+    assert.deepEqual(worktreeWarpMessages(world), [], 'no worktree-warp card is sent');
+    assert.deepEqual(world.calls.messages, [], 'nothing at all is sent to the empty session');
+    assert.deepEqual(world.calls.customEntries, [], 'no transition entry is appended');
+
+    assert.equal(world.calls.switches.length, 1);
+    const switchedFile = world.calls.switches[0].file;
+    const header = readJsonl(switchedFile)[0];
+    assert.equal(header.cwd, target, 'the session continues in the target checkout');
+    assert.equal(world.calls.switches[0].withSession, true);
+
+    // Where the session IS still travels: the status line and the OSC-7 hint.
+    assert.equal(world.calls.statuses.length > 0, true);
+    assert.equal(world.calls.statuses[world.calls.statuses.length - 1][0], 'worktree');
+    assert.equal(world.calls.statuses[world.calls.statuses.length - 1][1].endsWith(`(${target})`), true);
+    assert.deepEqual(world.osc, [`\x1b]7;${pathToFileURL(target).href}\x1b\\`]);
+
+    // The returned text names the position, never a move.
+    assert.doesNotMatch(out.text, /moved/i);
+    assert.doesNotMatch(out.text, /(^|\n)to: /);
+    assert.doesNotMatch(out.text, /\bfrom: /);
+    assert.match(out.text, /empty session/);
+
+    // Recording is unchanged: both sides are recorded, so a later warp finds
+    // the destination session again.
+    assert.equal(warpSessionsLib.getWarpSession(repo, target).sessionFile, switchedFile);
+    assert.equal(warpSessionsLib.getWarpSession(repo, repo).sessionFile, source);
+  });
+
+  test('a brand-new session with no file and no entries changes path instead of refusing', async () => {
+    const { repo, target, targetName } = makeRepoPair();
+    const world = makeWorld();
+
+    const out = await mod.executeWorktreeWarp(targetName, world.ctx({ cwd: repo, manager: world.bare() }), warpOptions(world));
+
+    assert.notEqual(out.isError, true, out.text);
+    assert.deepEqual(world.calls.forkFrom, []);
+    assert.deepEqual(world.calls.messages, []);
+    assert.equal(world.calls.switches.length, 1);
+    assert.equal(readJsonl(world.calls.switches[0].file)[0].cwd, target);
+    assert.equal(warpSessionsLib.getWarpSession(repo, target).sessionFile, world.calls.switches[0].file);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// S2: warping back, and repeating, keeps it empty.
+// ---------------------------------------------------------------------------
+
+describe('warping back from an empty session is the same case', () => {
+  test('a round trip warps silently both ways and accumulates nothing', async () => {
+    const { repo, target, targetName } = makeRepoPair();
+    const world = makeWorld();
+    const source = world.writeSession('empty-source', repo, [registration()]);
+
+    let cwd = repo;
+    let file = source;
+    const rounds = [
+      { name: targetName, expect: target },
+      { name: 'principal', expect: repo },
+      { name: targetName, expect: target },
+      { name: 'principal', expect: repo },
+    ];
+    for (const round of rounds) {
+      const out = await mod.executeWorktreeWarp(round.name, world.ctx({ cwd, manager: world.current(file) }), warpOptions(world));
+      assert.notEqual(out.isError, true, out.text);
+      assert.match(out.text, /empty session/);
+      assert.doesNotMatch(out.text, /moved/i);
+      const switched = world.calls.switches[world.calls.switches.length - 1].file;
+      assert.equal(readJsonl(switched)[0].cwd, round.expect);
+      cwd = round.expect;
+      file = switched;
+      // Exactly one session file per checkout: the empty warp never allocates a
+      // second one for the same destination.
+      assert.deepEqual(world.sessionFiles(), ['created-1.jsonl', 'empty-source.jsonl']);
+    }
+
+    assert.deepEqual(world.calls.forkFrom, [], 'no round of the round trip forks');
+    assert.deepEqual(world.calls.messages, [], 'no round of the round trip sends a card');
+    assert.deepEqual(world.calls.customEntries, [], 'no round of the round trip appends a transition');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// S4: an empty source resumes a destination that holds a conversation.
+// ---------------------------------------------------------------------------
+
+describe('an empty source and a destination with conversation', () => {
+  test('resumes the recorded destination session, with no fork and no card', async () => {
+    const { repo, target, targetName } = makeRepoPair();
+    const world = makeWorld();
+    const source = world.writeSession('empty-source', repo, [registration()]);
+    const destination = world.writeSession('written-earlier', target, [userSays('do the thing'), assistantSays('done')]);
+    warpSessionsLib.recordWarpSession(repo, target, {
+      sessionFile: destination, tipId: 'e2', count: 2,
+    });
+
+    const out = await mod.executeWorktreeWarp(targetName, world.ctx({ cwd: repo, manager: world.current(source) }), warpOptions(world));
+
+    assert.notEqual(out.isError, true, out.text);
+    assert.deepEqual(world.calls.forkFrom, [], 'a conversation is resumed, never forked over');
+    assert.deepEqual(world.calls.messages, [], 'nothing was carried from the source, so nothing is announced');
+    assert.deepEqual(world.calls.customEntries, []);
+    assert.equal(world.calls.switches.length, 1);
+    assert.equal(world.calls.switches[0].file, destination);
+    assert.match(out.text, /empty session/);
+    assert.doesNotMatch(out.text, /moved/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// PRESERVE: a session WITH conversation keeps today's behaviour.
+// ---------------------------------------------------------------------------
+
+describe('a session with conversation keeps today behaviour', () => {
+  test('it forks once and sends exactly one Warp card', async () => {
+    const { repo, target, targetName } = makeRepoPair();
+    const world = makeWorld();
+    const source = world.writeSession('with-conversation', repo, [registration(), userSays('hi'), assistantSays('hello')]);
+
+    const out = await mod.executeWorktreeWarp(targetName, world.ctx({ cwd: repo, manager: world.current(source) }), warpOptions(world));
+
+    assert.notEqual(out.isError, true, out.text);
+    assert.equal(world.calls.forkFrom.length, 1);
+    assert.equal(world.calls.forkFrom[0].sourcePath, source);
+    assert.equal(world.calls.forkFrom[0].targetCwd, target);
+    assert.equal(world.calls.customEntries.length, 1);
+    assert.equal(world.calls.customEntries[0].customType, 'worktree-warp');
+    const cards = worktreeWarpMessages(world);
+    assert.equal(cards.length, 1, 'exactly one card');
+    assert.equal(cards[0].message.details.to, target);
+    assert.equal(cards[0].message.details.fromName, 'principal');
+    assert.equal(cards[0].options.triggerTurn, false);
+    assert.match(cards[0].message.content, /Worktree warp: now in /);
+    assert.equal(world.calls.switches.length, 1);
+    assert.equal(readJsonl(world.calls.switches[0].file)[0].cwd, target);
+    // The returned text is still the two-line compact that names the move.
+    assert.match(out.text, /^moved: /);
+    assert.match(out.text, /\nto: /);
+  });
+
+  test('a destination at the same point is still resumed silently', async () => {
+    const { repo, target, targetName } = makeRepoPair();
+    const world = makeWorld();
+    const source = world.writeSession('with-conversation', repo, [userSays('hi'), assistantSays('hello')]);
+    // Same filtered point: the recorded destination holds the same entries.
+    const destination = path.join(world.sessionDir, 'same-point.jsonl');
+    writeJsonl(destination, [sessionHeader('same-point', target), ...readJsonl(source).filter((entry) => entry.type !== 'session')]);
+    warpSessionsLib.recordWarpSession(repo, target, { sessionFile: destination, tipId: 'e2', count: 2 });
+
+    const out = await mod.executeWorktreeWarp(targetName, world.ctx({ cwd: repo, manager: world.current(source) }), warpOptions(world));
+
+    assert.notEqual(out.isError, true, out.text);
+    assert.deepEqual(world.calls.forkFrom, []);
+    assert.deepEqual(world.calls.messages, [], 'a resume re-enters silently');
+    assert.deepEqual(world.calls.customEntries, []);
+    assert.equal(world.calls.switches.length, 1);
+    assert.equal(world.calls.switches[0].file, destination);
+    assert.match(out.text, /^moved: /);
+  });
+});