create-pmos 0.38.1 → 0.38.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.38.1",
+  "version": "0.38.2",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@d1d47bf
+kernel-source: pmos@6270efe
 assembled: 2026-10-02
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-02T01:57:56Z"}
+generated: {by: process:create-pmos, at: "2026-10-02T03:08:00Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-02T01:57:56Z"}
+generated: {by: process:create-pmos, at: "2026-10-02T03:08:00Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-02T01:57:56Z"}
+generated: {by: process:create-pmos, at: "2026-10-02T03:08:00Z"}
 status: stable
 ---
 

package/workspace/lib/git-info.js

@@ -123,14 +123,30 @@ function worktreePath(root, branch) {
   return path.join(path.dirname(top), path.basename(top) + '-worktrees', branch.replace(/\//g, '-'));
 }
 
+// The start point of a NEW branch: an existing branch name or a commit id, nothing else. A name that
+// passes validBranchName cannot begin with `-`, so it cannot be read by git as an option; it must
+// also resolve to a commit, so a typo is refused here with a reason and not by git's own message.
+// No base means "where this tree is now" — git's default.
+function baseRef(root, from) {
+  if (from === null || from === undefined || from === '') return { ok: true, ref: null };
+  const ref = String(from);
+  if (!validBranchName(ref) && !/^[0-9a-f]{7,40}$/i.test(ref)) return { ok: false, error: 'invalid base' };
+  const r = git(root, ['rev-parse', '--verify', '--quiet', ref + '^{commit}']);
+  if (r.failed) return { ok: false, error: 'git not available' };
+  if (r.code !== 0) return { ok: false, error: `base '${ref}' does not exist` };
+  return { ok: true, ref };
+}
+
 // Check out an existing branch, or create one with -b. THIS MOVES THE WHOLE REPO — every session
 // in every workspace under it. Confined to `root` by cwd; the name is validated first so nothing
 // malformed reaches git. On any failure returns { ok:false, error } and leaves the caller to NOT
 // spawn a session on the wrong branch (a failed checkout must never spawn).
-function checkout(root, branch, { create = false } = {}) {
+function checkout(root, branch, { create = false, from = null } = {}) {
   if (!isRepo(root)) return { ok: false, error: 'not a git repository' };
   if (!validBranchName(branch)) return { ok: false, error: 'invalid branch name' };
-  const args = create ? ['checkout', '-b', branch, '--'] : ['checkout', branch, '--'];
+  const base = baseRef(root, from);
+  if (!base.ok) return base;
+  const args = create ? ['checkout', '-b', branch, ...(base.ref ? [base.ref] : []), '--'] : ['checkout', branch, '--'];
   const r = git(root, args);
   if (r.failed) return { ok: false, error: 'git not available' };
   if (r.code !== 0) return { ok: false, error: (r.err || r.out || 'checkout failed').split('\n')[0].slice(0, 200) };
@@ -142,10 +158,12 @@ function checkout(root, branch, { create = false } = {}) {
 // session stays untouched. `create` makes the branch (`-b`); otherwise the branch must exist and
 // must not already be checked out somewhere else (git refuses — we return that plainly).
 // Returns { ok, dir, branch, reused } or { ok:false, error }.
-function addWorktree(root, branch, { create = false } = {}) {
+function addWorktree(root, branch, { create = false, from = null } = {}) {
   const top = repoRoot(root);
   if (!top) return { ok: false, error: 'not a git repository' };
   if (!validBranchName(branch)) return { ok: false, error: 'invalid branch name' };
+  const base = baseRef(top, from);
+  if (!base.ok) return base;
 
   // Already checked out somewhere? Say where, rather than letting git's message be the first the
   // PM sees — and if it is exactly the worktree we would have made, reuse it instead of failing.
@@ -161,7 +179,7 @@ function addWorktree(root, branch, { create = false } = {}) {
   try { fs.mkdirSync(path.dirname(dir), { recursive: true }); }
   catch (e) { return { ok: false, error: `cannot create ${path.dirname(dir)}: ${e.code || e.message}` }; }
 
-  const args = create ? ['worktree', 'add', '-b', branch, dir] : ['worktree', 'add', dir, branch];
+  const args = create ? ['worktree', 'add', '-b', branch, dir, ...(base.ref ? [base.ref] : [])] : ['worktree', 'add', dir, branch];
   const r = git(top, args);
   if (r.failed) return { ok: false, error: 'git not available' };
   if (r.code !== 0) {

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.38.1",
+  "version": "0.38.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.38.1",
+  "version": "0.38.2",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",
@@ -15,7 +15,7 @@
     "test:parity": "node design-parity.js --states",
     "test:all": "npm test && npm run test:panels && npm run test:ui && npm run test:parity && npm run test:offline",
     "doctor": "node doctor.js",
-    "test:panels": "node pm-shell-test.js && node pm-repos-test.js && node pm-initiatives-test.js && node pm-detail-test.js && node pm-tabs-test.js && node pm-term-test.js && node pm-modes-test.js && node pm-r1-test.js && node pm-r2-test.js && node pm-r3-test.js && node pm-r4-test.js && node pm-r5-test.js && node pm-r6-test.js && node pm-r7-test.js && node pm-r8-test.js && node pm-r9-test.js && node pm-r10-test.js && node pm-r11-test.js && node pm-r12-test.js && node pm-r13-test.js",
+    "test:panels": "node pm-shell-test.js && node pm-repos-test.js && node pm-initiatives-test.js && node pm-detail-test.js && node pm-tabs-test.js && node pm-term-test.js && node pm-modes-test.js && node pm-r1-test.js && node pm-r2-test.js && node pm-r3-test.js && node pm-r4-test.js && node pm-r5-test.js && node pm-r6-test.js && node pm-r7-test.js && node pm-r8-test.js && node pm-r9-test.js && node pm-r10-test.js && node pm-r11-test.js && node pm-r12-test.js && node pm-r13-test.js && node pm-r14-test.js",
     "test:offline": "node offline-tarball.test.js"
   },
   "engines": {

package/workspace/public/pm/data.js

@@ -997,7 +997,7 @@ export function productTrees(name) {
   const key = p.root;
   return p.trees.map((t) => {
     const m = /^initiative\/(.+)$/.exec(t.branch || '');
-    return { ws: t.id, branch: t.branch || null, main: t.root === key, sessions: t.sessions || 0,
+    return { ws: t.id, dir: t.tree || t.root, branch: t.branch || null, main: t.root === key, sessions: t.sessions || 0,
       initiative: m ? m[1] : null, by: m ? 'branch' : null };
   }).sort((a, b) => (b.main - a.main));
 }
@@ -1202,6 +1202,36 @@ export async function preferProfile(agent, profile) {
   return postJson('/api/profiles/prefer', { agent, profile });
 }
 
+/** Re-read the registered trees only — no boards. A worktree created or removed anywhere (a spawn, the
+ * branch form, a terminal) reaches panel 1 through this, instead of waiting for a reload. */
+export async function refreshTrees() {
+  if (FIXTURE) return;
+  const out = await getJson('/api/workspaces');
+  if (!out || !Array.isArray(out.workspaces)) return;
+  const rows = foldWorkspaces(out.workspaces);
+  for (const r of rows) products.set(r.name, Object.assign(products.get(r.name) || {}, r));
+  publishBoards();
+}
+
+/** Create a branch with no session. `worktree` false = a checkout in the shared tree (the server
+ * refuses it while sessions run there). */
+export async function createBranch({ ws, name, from, worktree }) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode creates no branch' };
+  return postJson('/api/git/branch', { ws, name, from: from || null, worktree: worktree !== false });
+}
+
+/** End a session and remove it, with an answer. */
+export async function removeSessionById(id) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode has no sessions' };
+  return postJson('/api/session/remove', { id });
+}
+
+/** Remove a linked worktree folder. The server refuses a busy or unsaved one and says why. */
+export async function removeWorktree(ws, dir) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode has no worktrees' };
+  return postJson('/api/git/worktrees/remove', { ws, dir });
+}
+
 /** Every working tree of this workspace's repo. The pre-flight reads it for ONE purpose: a branch
  * checked out elsewhere is a branch git will refuse, and the PM should read that in the picker
  * rather than as an error after the click. */

package/workspace/public/pm/panel-newsess.js

@@ -33,6 +33,7 @@ import { el } from './dom.js';
 import { state, setState, FIXTURE } from './state.js';
 import * as FX from './fixture.js';
 import { openTerm as openTermTab } from './panel-initiatives.js';
+import { startHere } from './panel-trees.js';
 
 /* Both are another module's file, loaded lazily for the reason panel-tabs.js gives: a static import
  * of a file that fails to load takes this whole module down with it, and a panel that cannot draw
@@ -214,7 +215,7 @@ function branchSection() {
     return out;
   }
 
-  const current = info.branch || null;
+  const current = info.current || info.branch || null;
   const branches = Array.isArray(info.branches) ? info.branches : [];
   /* A branch checked out in ANOTHER working tree is a branch git will refuse to check out here.
    * Offering it and letting the server say no would be technically honest and practically rude:
@@ -237,11 +238,22 @@ function branchSection() {
   for (const b of branches) {
     if (b === current) continue;
     const taken = elsewhere.get(b);
+    /* A branch already open in another working tree cannot be checked out twice, but it CAN be worked
+     * in: the chip starts a session in that tree. It used to be a disabled chip, so the folder the PM
+     * already had was the one place they could not start. */
+    const treeOf = taken && dataMod && typeof dataMod.productTrees === 'function'
+      ? dataMod.productTrees(state.product).find((t) => t.branch === b && !t.main) : null;
     chips.push(taken
-      ? el('button', {
-          disabled: true, title: 'git will not check this out twice — it is already in ' + taken,
-          style: CHIP_DEAD,
-        }, iv(b + ' — in ' + shortPath(taken)))
+      ? (treeOf
+        ? el('button', {
+            onClick: () => { closeNewSession(); startHere(state.product, treeOf); },
+            title: 'this branch is already open in ' + taken + ' — start the session there',
+            style: CHIP, hover: HOVER, 'data-r14': 'open-worktree',
+          }, iv(b + ' — open that worktree'))
+        : el('button', {
+            disabled: true, title: 'git will not check this out twice — it is already in ' + taken,
+            style: CHIP_DEAD,
+          }, iv(b + ' — in ' + shortPath(taken))))
       : el('button', {
           onClick: () => pick(b),
           style: state.newSessBranch === b && !state.newSessBranchMode ? CHIP_ON : CHIP, hover: HOVER,
@@ -435,6 +447,7 @@ async function onStart() {
     name,
     agent: state.newSessAgent || 'shell',
     ws: state.wsId || null,
+    initiative: slug || undefined,
     branch: branch || null,
     createBranch,
     // Sent explicitly, ALWAYS, and only when a branch is in play — the server defaults an omitted

package/workspace/public/pm/panel-repos.js

@@ -25,6 +25,7 @@
 
 import { el, setChildren } from './dom.js';
 import { syncButton } from './lifecycle.js';
+import { treesBlock, branchForm, openBranchForm, treeNoteFor } from './panel-trees.js';
 import { state, setState, FIXTURE } from './state.js';
 import {
   productsList, repoRow, firstSlugOf, MODE_META, SETTINGS_GROUPS, ADDABLE_PRODUCTS,
@@ -282,17 +283,18 @@ function repoEntry(tuple, product) {
   if (FIXTURE || !dataMod) return row;
   const name = tuple[0];
   const trees = treesOf(name);
-  const linked = trees.filter((t) => !t.main);
-  const open = !!(state.treesOpen || {})[name];
+  /* The trees list is always available — the main tree is a line of work too, and a repository with
+   * one tree still has branches to create. The active repository opens it by default; others on a
+   * click of the chip. */
+  const stored = (state.treesOpen || {})[name];
+  const open = stored === undefined ? product === name : !!stored;
   const tools = [];
-  if (linked.length) {
-    tools.push(el('button', {
-      onClick: () => setState((s) => ({ treesOpen: { ...(s.treesOpen || {}), [name]: !open } })),
-      style: chipStyle, hover: 'color:var(--foreground)',
-      title: linked.length + ' linked worktree' + (linked.length === 1 ? '' : 's') + ' — show the lines of work',
-      'data-r1': 'trees-chip',
-    }, ip('⑂ ' + linked.length)));
-  }
+  tools.push(el('button', {
+    onClick: () => setState((s) => ({ treesOpen: { ...(s.treesOpen || {}), [name]: !open } })),
+    style: chipStyle, hover: 'color:var(--foreground)',
+    title: trees.length + ' working tree' + (trees.length === 1 ? '' : 's') + ' — show the lines of work, their sessions and branches',
+    'data-r1': 'trees-chip', 'data-repo': name,
+  }, ip('⑂ ' + trees.length)));
   if (product === name) {
     { const sb = syncButton(name); if (sb) tools.push(sb); }
     tools.push(el('button', { onClick: () => renameRepo(name), style: actStyle, hover: 'color:var(--foreground)', title: 'rename this repository', 'data-r1': 'rename' }, '✎'));
@@ -301,18 +303,9 @@ function repoEntry(tuple, product) {
   const kids = [el('div', { style: 'display:flex;align-items:center' },
     el('div', { style: 'flex:1;min-width:0' }, row),
     tools.length ? el('div', { style: 'display:flex;align-items:center;gap:2px;padding-right:8px' }, tools) : null)];
-  if (open && trees.length) {
-    kids.push(el('div', { style: 'padding:2px 14px 8px 39px', 'data-r1': 'trees' },
-      trees.map((t) => el('div', {
-        style: 'display:flex;gap:8px;font-family:var(--mono);font-size:10.5px;color:var(--muted-foreground);padding:2px 0',
-        title: t.initiative ? 'initiative read from the branch name (initiative/<id>) — not a recorded attribution' : '',
-      },
-        el('span', { style: 'color:var(--foreground)' }, ip((t.main ? '⎇ ' : '⑂ ') + (t.branch || '(detached)'))),
-        el('span', null, ip(t.sessions + ' session' + (t.sessions === 1 ? '' : 's'))),
-        t.initiative ? el('span', null, ip('#' + t.initiative)) : null,
-      )),
-    ));
-  }
+  { const bf = branchForm(name); if (bf) kids.push(bf); }
+  if (open && trees.length) kids.push(treesBlock(name, trees, product === name));
+  { const tn = treeNoteFor(name); if (tn) kids.push(tn); }
   const n = state.repoNotice;
   if (n && n.name === name) {
     kids.push(el('div', {

package/workspace/public/pm/panel-trees.js

@@ -0,0 +1,176 @@
+/* panel-trees.js — the working trees of a repository, as things you can use (workspace-branch-sessions).
+ *
+ * Panel 1 used to list a repository's trees as plain text behind a chip that existed only when a
+ * linked worktree did. A branch could not be clicked, its sessions could not be seen, a session
+ * could not be started in it, and a branch could not be made without starting a session. This module
+ * is that surface:
+ *
+ *   treesBlock(name)    every tree, main first. A row opens to show that tree's sessions and its
+ *                       actions: start a session HERE, remove the folder (linked trees only).
+ *   branchForm(name)    `＋ branch` — a name, a base and an own-folder toggle. Creates the branch and
+ *                       starts nothing; then offers a session on it.
+ *
+ * Every action states its outcome in the panel. A refusal says why and the repository is unchanged.
+ * Live mode only: the fixture has no server, and panel-repos.js never calls this there.
+ */
+import { el } from './dom.js';
+import { state, setState, subscribe } from './state.js';
+
+const ip = (v) => el('span', null, v);
+const MONO = 'font-family:var(--mono);font-size:10.5px';
+const BTN = MONO + ';padding:2px 8px;border:1px solid var(--border);color:var(--muted-foreground);min-height:24px';
+const MUTED = 'color:var(--muted-foreground)';
+
+let dataMod = null; let termMod = null; let iniMod = null;
+import('./data.js').then((m) => { dataMod = m; }).catch(() => { dataMod = null; });
+import('./tab-term.js').then((m) => { termMod = m; }).catch(() => { termMod = null; });
+import('./panel-initiatives.js').then((m) => { iniMod = m; }).catch(() => { iniMod = null; });
+
+const note = (name, text, tone) => setState({ treeNote: { name, text, tone: tone || null } });
+const refresh = () => (dataMod && dataMod.refreshTrees ? dataMod.refreshTrees() : Promise.resolve());
+
+/* A tree was registered, removed or renamed somewhere (the server's `workspaces` push, a branch
+ * change in a terminal): re-read the tree list. Guarded by the push stamp so the repaint this causes
+ * does not ask again. */
+let lastPush = 0;
+subscribe(() => {
+  if (state.treesPush && state.treesPush !== lastPush) { lastPush = state.treesPush; refresh(); }
+});
+
+/** The server's sessions that run in this tree, from the list the page already polls. */
+export function sessionsIn(ws) {
+  return (Array.isArray(state.sessions) ? state.sessions : []).filter((s) => s && s.ws === ws);
+}
+const isEnded = (s) => s.state === 'exited' || s.shown === 'exited';
+
+/** Open a session's terminal. The row carries the server's id, so the tab attaches to that exact PTY. */
+function openSession(s) {
+  if (!iniMod) return;
+  iniMod.openTerm(null, { id: s.id, name: s.name, st: isEnded(s) ? 'exited' : 'working', profile: s.profile_id || null });
+}
+
+/** Start a session in THIS tree: the workspace id is the tree's, so the server runs it in that folder. */
+export async function startHere(name, t) {
+  if (!termMod || !iniMod) { note(name, 'the terminal module has not loaded — nothing was started', 'bad'); return; }
+  const label = (t.branch || 'tree').replace(/^initiative\//, '');
+  const res = await termMod.requestSpawn({ name: 'shell · ' + label, agent: 'shell', ws: t.ws, branch: null, createBranch: false, isolate: null, profile: null });
+  if (!res || !res.ok) { note(name, (res && res.error) || 'the workspace server refused, without saying why', 'bad'); return; }
+  note(name, 'started in ' + (t.branch || 'this tree'));
+  openSession({ id: res.id, name: 'shell · ' + label, profile_id: null });
+}
+
+async function endSession(name, s) {
+  const out = dataMod ? await dataMod.removeSessionById(s.id) : null;
+  setState({ treeConfirm: null });
+  if (!out || out.ok === false) { note(name, (out && out.error) || 'the session could not be removed', 'bad'); return; }
+  note(name, out.removed === false ? (out.note || 'asked it to end') : 'session removed');
+}
+
+async function removeTree(name, t) {
+  const ok = typeof window === 'undefined' || !window.confirm ? true
+    : window.confirm('Remove the folder for “' + t.branch + '”?\n\n' + t.dir + '\n\nThe branch is kept. A folder with unsaved work or a running session is refused.');
+  if (!ok) return;
+  const out = dataMod ? await dataMod.removeWorktree(t.ws, t.dir) : null;
+  if (!out || out.ok === false) { note(name, (out && out.error) || 'the folder could not be removed', 'bad'); return; }
+  setState((s) => ({ treeSel: { ...(s.treeSel || {}), [name]: null } }));
+  note(name, 'removed the folder for ' + t.branch + ' — the branch is kept');
+  refresh();
+}
+
+function sessionRow(name, s) {
+  const armed = state.treeConfirm === s.id;
+  return el('div', { style: 'display:flex;align-items:center;gap:6px;padding:1px 0', 'data-r14': 'tree-session', 'data-id': s.id },
+    el('button', { onClick: () => openSession(s), style: MONO + ';flex:1;min-width:0;text-align:left;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--foreground)', hover: 'text-decoration:underline', title: 'open this session' },
+      ip(s.name + ' · ' + (isEnded(s) ? 'ended' : (s.shown || s.state || 'running')))),
+    el('button', {
+      onClick: () => (armed ? endSession(name, s) : setState({ treeConfirm: s.id })),
+      style: BTN + (armed ? ';color:var(--destructive);border-color:var(--destructive)' : ''), hover: 'color:var(--destructive)',
+      title: isEnded(s) ? 'remove this ended session' : 'end this session and remove it', 'data-r14': 'tree-end',
+    }, armed ? 'sure?' : (isEnded(s) ? 'remove' : 'end')));
+}
+
+function treeRow(name, t) {
+  const sel = (state.treeSel || {})[name] === t.ws;
+  const sess = sessionsIn(t.ws);
+  const live = sess.filter((s) => !isEnded(s)).length;
+  const head = el('button', {
+    onClick: () => setState((s) => ({ treeSel: { ...(s.treeSel || {}), [name]: sel ? null : t.ws }, treeConfirm: null })),
+    style: MONO + ';display:flex;gap:8px;width:100%;text-align:left;padding:3px 0;min-height:26px;align-items:baseline', hover: 'background:var(--accent)',
+    title: t.initiative ? 'initiative read from the branch name (initiative/<id>) — not a recorded attribution' : 'show this tree’s sessions',
+    'data-r14': 'tree', 'data-ws': t.ws,
+  },
+    el('span', { style: MUTED }, ip(sel ? '▾' : '▸')),
+    el('span', { style: 'color:var(--foreground)' }, ip((t.main ? '⎇ ' : '⑂ ') + (t.branch || '(detached)'))),
+    el('span', { style: MUTED }, ip(live + ' live' + (sess.length > live ? ' · ' + (sess.length - live) + ' ended' : ''))),
+    t.initiative ? el('span', { style: MUTED }, ip('#' + t.initiative)) : null);
+  if (!sel) return head;
+  return el('div', null, head, el('div', { style: 'padding:2px 0 6px 14px', 'data-r14': 'tree-open' },
+    sess.length ? sess.map((s) => sessionRow(name, s)) : el('div', { style: MONO + ';' + MUTED + ';padding:2px 0' }, 'no sessions in this tree'),
+    el('div', { style: 'display:flex;gap:6px;padding-top:4px;flex-wrap:wrap' },
+      el('button', { onClick: () => startHere(name, t), style: BTN, hover: 'color:var(--foreground)', title: 'start a shell session in ' + (t.dir || 'this tree'), 'data-r14': 'tree-start' }, '＋ session here'),
+      t.main ? null : el('button', { onClick: () => removeTree(name, t), style: BTN, hover: 'color:var(--destructive)', title: 'remove this worktree folder (the branch is kept)', 'data-r14': 'tree-remove' }, 'remove folder'))));
+}
+
+/** The trees of one repository, main first. `name` is the repository's name in the data layer. */
+export function treesBlock(name, trees, addable) {
+  return el('div', { style: 'padding:2px 14px 8px 39px', 'data-r1': 'trees', 'data-repo': name }, trees.map((t) => treeRow(name, t)),
+    addable ? el('button', { onClick: () => openBranchForm(name, trees), style: BTN + ';margin-top:4px', hover: 'color:var(--foreground)',
+      title: 'create a branch — with or without its own folder — without starting a session', 'data-r14': 'branch-add' }, '＋ branch') : null);
+}
+
+/* ── ＋ branch ───────────────────────────────────────────────────────────────────────────────── */
+const INPUT = MONO + ';width:100%;padding:4px 6px;background:var(--secondary);border:1px solid var(--border);color:var(--foreground);min-height:26px';
+
+export function openBranchForm(name, trees) {
+  const main = (trees || []).find((t) => t.main) || (trees || [])[0];
+  setState({ branchForm: { repo: name, name: '', from: '', folder: true, busy: false, error: null, ws: main ? main.ws : null, current: main ? main.branch : null } });
+}
+
+async function submitBranch() {
+  const f = state.branchForm;
+  if (!f || f.busy || !dataMod) return;
+  const name = String(f.name || '').trim();
+  if (!name) { setState({ branchForm: { ...f, error: 'name the new branch' } }); return; }
+  setState({ branchForm: { ...f, busy: true, error: null } });
+  const out = await dataMod.createBranch({ ws: f.ws, name, from: String(f.from || '').trim() || null, worktree: f.folder });
+  if (!out || out.ok === false) { setState({ branchForm: { ...f, busy: false, error: (out && out.error) || 'the server refused, without saying why' } }); return; }
+  setState((s) => ({ branchForm: null, treesOpen: { ...(s.treesOpen || {}), [f.repo]: true }, treeSel: { ...(s.treeSel || {}), [f.repo]: out.ws }, treeNote: { name: f.repo, text: '“' + name + '” created' + (f.folder ? ' in its own folder — ' + out.dir : ' in the shared folder'), tone: null } }));
+  refresh();
+}
+
+/* The panel repaints on every state change, which replaces the input the PM is typing in. The value
+ * survives (it lives on the form record); the focus and caret are restored here so typing is not cut. */
+function keepFocus(f, which) {
+  return (n) => {
+    if ((f.focus || 'name') !== which) return;
+    setTimeout(() => { try { n.focus(); n.setSelectionRange(n.value.length, n.value.length); } catch { /* detached */ } }, 0);
+  };
+}
+
+/** The `＋ branch` form for the repository it was opened on, or null. */
+export function branchForm(name) {
+  const f = state.branchForm;
+  if (!f || f.repo !== name) return null;
+  const upd = (patch) => setState((s) => ({ branchForm: { ...s.branchForm, ...patch } }));
+  return el('div', { style: 'padding:6px 14px 10px 39px;display:grid;gap:5px', 'data-r14': 'branch-form' },
+    el('input', { value: f.name, placeholder: 'initiative/my-branch', style: INPUT, 'data-r14': 'branch-name',
+      ref: keepFocus(f, 'name'), onFocus: () => { f.focus = 'name'; },
+      onInput: (e) => { f.name = e.target.value; }, onKeydown: (e) => { if (e.key === 'Enter') submitBranch(); if (e.key === 'Escape') setState({ branchForm: null }); } }),
+    el('input', { value: f.from, placeholder: 'start from: ' + (f.current || 'the current branch') + ' (or another branch)', style: INPUT, 'data-r14': 'branch-from',
+      ref: keepFocus(f, 'from'), onFocus: () => { f.focus = 'from'; },
+      onInput: (e) => { f.from = e.target.value; }, onKeydown: (e) => { if (e.key === 'Enter') submitBranch(); } }),
+    el('button', { onClick: () => upd({ folder: !f.folder }), style: MONO + ';text-align:left;' + MUTED, hover: 'color:var(--foreground)', 'data-r14': 'branch-folder',
+      title: f.folder ? 'the branch gets its own folder; sessions already running are untouched' : 'the branch is checked out in the shared folder; refused while a session runs there' },
+    ip((f.folder ? '☑' : '☐') + ' its own folder (worktree)')),
+    f.error ? el('div', { style: 'font-size:11px;color:var(--destructive)', 'data-r14': 'branch-error' }, ip(f.error)) : null,
+    el('div', { style: 'display:flex;gap:6px' },
+      el('button', { onClick: submitBranch, disabled: f.busy ? 'disabled' : null, style: BTN, hover: 'color:var(--foreground)', 'data-r14': 'branch-create' }, f.busy ? 'creating…' : 'create branch'),
+      el('button', { onClick: () => setState({ branchForm: null }), style: BTN, hover: 'color:var(--foreground)' }, 'cancel')));
+}
+
+/** The outcome line of the last tree action for this repository. */
+export function treeNoteFor(name) {
+  const n = state.treeNote;
+  if (!n || n.name !== name) return null;
+  return el('div', { style: 'padding:4px 14px 8px 39px;font-size:11px;overflow-wrap:anywhere;color:' + (n.tone === 'bad' ? 'var(--destructive)' : 'var(--muted-foreground)'), 'data-r14': 'tree-note' }, ip(n.text));
+}

package/workspace/public/pm/tab-term.js

@@ -244,6 +244,9 @@ export function requestSpawn(opts) {
         name: o.name,
         agent: o.agent || 'shell',
         ws: o.ws,
+        // The initiative the session is FOR, when the caller knows it (workspace-branch-sessions R8):
+        // the `⋯ options` path used to drop it, so a session started with a branch carried none.
+        ...(o.initiative ? { initiative: o.initiative } : {}),
         /* Sent even when the PM chose nothing, and that is deliberate on two of them. `isolate` has
          * a server-side default (`server.js` liveSessionCount) whose own comment says the client
          * should state what the PM actually saw; `profile: null` is a DELIBERATE "no profile",
@@ -429,9 +432,12 @@ function handle(m) {
      * cache of the server's last word about a workspace, and a reader that is not open ignores it.
      * The `ws` is carried so a reader can tell whether the news is about the repository it is
      * asking about. */
-    setState({ branchInfo: { ...m, at: Date.now() } });
+    setState({ branchInfo: { ...m, at: Date.now() }, treesPush: Date.now() });
     return;
   }
+  /* A tree was registered, removed or renamed. Panel 1 re-reads the tree list on `treesPush`
+   * (panel-repos.js); without this the new folder appeared only after a reload. */
+  if (m.t === 'workspaces') { setState({ treesPush: Date.now() }); return; }
 }
 
 const recFor = (sessionId) => {

package/workspace/server.js

@@ -3044,6 +3044,40 @@ function spawnWithBranch({ name, agent, cwd, ws, branch, createBranch, isolate,
   return { ok: true, session: s, notice: treeShare.joinNotices(notice, shared) };
 }
 
+// Create a branch WITHOUT starting a session (workspace-branch-sessions R5). Two shapes, as in the
+// spawn path: its own folder (a worktree, registered as a workspace so the page can start sessions in
+// it) or a checkout in the shared tree. The shared checkout moves every session in that tree, so it is
+// refused while any are running — the spawn path may do that on a PM's explicit choice, but a control
+// that only creates a branch must not move other people's work as a side effect.
+function createBranchOnly({ ws, name, from, worktree }) {
+  const w = ws ? workspaces.get(ws) : null;
+  if (!w) return { ok: false, error: 'no such workspace' };
+  if (!gitInfo.isRepo(w.root)) return { ok: false, error: `“${w.name}” is not a git repository` };
+  const branch = String(name == null ? '' : name).trim();
+  if (!branch) return { ok: false, error: 'name the new branch' };
+  if (worktree) {
+    const r = gitInfo.addWorktree(w.root, branch, { create: true, from });
+    if (!r.ok) return { ok: false, error: r.error };
+    const info = gitInfo.branchInfo(w.root);
+    const mirrored = info.ok && info.subdir ? path.join(r.dir, info.subdir) : r.dir;
+    const dir = isDir(mirrored) ? mirrored : r.dir;
+    const nw = registerWorkspace(dir, `${w.name} ⑂ ${branch}`);
+    if (!nw) return { ok: false, error: `worktree created at ${r.dir} but could not be registered as a workspace` };
+    broadcast({ t: 'branch', ws: nw.id, ...gitInfo.branchInfo(nw.root) });
+    pushWorkspaces();
+    return { ok: true, ws: nw.id, dir: r.dir, branch };
+  }
+  const live = treeTenants(treeForWs(w.id), null).length;
+  if (live > 0) {
+    return { ok: false, error: `${live} session${live === 1 ? ' is' : 's are'} running in this folder, and a checkout would move ${live === 1 ? 'it' : 'them'} — create the branch in its own folder instead` };
+  }
+  const r = gitInfo.checkout(w.root, branch, { create: true, from });
+  if (!r.ok) return { ok: false, error: r.error };
+  broadcast({ t: 'branch', ws: w.id, ...gitInfo.branchInfo(w.root) });
+  pushWorkspaces();
+  return { ok: true, ws: w.id, dir: w.root, branch };
+}
+
 /* ── workspace-repo-first · start work in one click (PRD R1 · R3) ───────────────────────────────
  * The composer asked six questions to open a terminal, and the one question the PM actually has —
  * "which initiative am I working on?" — was not among them. It asked for a BRANCH instead, plus an
@@ -4290,6 +4324,27 @@ async function handleRequest(req, res) {
     w.label = name; saveWorkspaces(); pushWorkspaces();
     return json(res, { ok: true, workspace: { id: w.id, name, label: name } });
   }
+  if (p === '/api/git/branch' && req.method === 'POST') {
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const out = createBranchOnly({ ws: body.ws, name: body.name, from: body.from || null, worktree: body.worktree !== false });
+    return json(res, out, out.ok ? 200 : 400);
+  }
+  // End a session and remove it, with an answer. The WebSocket kill/remove messages return nothing,
+  // so a refusal or a slow exit left the PM clicking a control that seemed to do nothing.
+  if (p === '/api/session/remove' && req.method === 'POST') {
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const sess = sessions.get(String(body.id || ''));
+    if (!sess) return json(res, { ok: false, error: 'no such session' }, 404);
+    if (sess.pty) {
+      if (sess.tmux) tmuxKillSession(sess.tmux);
+      try { sess.pty.kill(); } catch {}
+      for (let i = 0; i < 30 && sess.pty; i++) await new Promise((r) => setTimeout(r, 100));
+      if (sess.pty) return json(res, { ok: true, removed: false, note: 'asked it to end; it has not exited yet — press again to remove it' });
+    }
+    return json(res, { ok: removeSession(sess.id), removed: true });
+  }
   if (p === '/api/git/worktrees/remove' && req.method === 'POST') {
     // Reclaim a worktree's folder. `dir` comes from a client, so it is checked against git's own
     // list of THIS repo's linked worktrees before anything is removed — the main tree is