@pellux/goodvibes-tui 1.7.0 → 1.9.1

package/src/input/commands/planning-runtime.ts

@@ -8,12 +8,15 @@ import type { CommandRegistry } from '../command-registry.ts';
 import { openModalCommand, requirePlanManager, requireSessionLineageTracker } from './runtime-services.ts';
 
 /**
- * Single-token verbs that look like a `/plan` subcommand but are not real ones
- * (some, like `dismiss`, were dispatched by UI that assumed a subcommand that
- * never existed). A lone one of these is refused rather than seeded as a goal,
- * so a stray verb can never overwrite the project goal with itself.
+ * Single-token verbs that look like a `/plan` subcommand but are not real ones.
+ * A lone one of these is refused rather than seeded as a goal, so a stray verb
+ * can never overwrite the project goal with itself.
+ *
+ * DEBT-3: `dismiss` and `answer` are now REAL subcommands (handled above this
+ * guard), so they were removed from the refuse-list. `pause`/`stop`/`cancel`
+ * remain here — they still have no backing verb and must not seed a goal.
  */
-const PSEUDO_SUBCOMMAND_VERBS = new Set(['dismiss', 'answer', 'pause', 'stop', 'cancel']);
+const PSEUDO_SUBCOMMAND_VERBS = new Set(['pause', 'stop', 'cancel']);
 
 function recordNextQuestion(
   state: Partial<ProjectPlanningState>,
@@ -59,7 +62,7 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
   registry.register({
     name: 'plan',
     description: 'Inspect or seed TUI-owned project planning state',
-    usage: '[panel | approve | list | show <id> | mode | explain | override <strategy> | status | clear | <planning goal>]',
+    usage: '[panel | approve | dismiss | answer <n> <text> | list | show <id> | mode | explain | override <strategy> | status | clear | <planning goal>]',
     argsHint: '[panel|approve|status|<goal>]',
     async handler(args, ctx) {
       const planManager = requirePlanManager(ctx);
@@ -173,6 +176,92 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
+      // DEBT-3: /plan dismiss — archive the current plan. Dismisses the active
+      // execution plan (ExecutionPlanManager.dismiss, honest per-state) AND
+      // deactivates the project-planning interview state shown in the modal so a
+      // later /plan <goal> starts fresh. Mid-execution is refused outright.
+      if (args[0] === 'dismiss') {
+        const dismissal = planManager.dismiss(ctx.session.runtime.sessionId);
+        if (dismissal.outcome === 'requires-cancel') {
+          ctx.print(
+            `Plan "${dismissal.blockedBy?.title ?? 'active plan'}" is mid-execution and was not dismissed. ` +
+            `Run /workstream cancel to stop it first, then /plan dismiss.`,
+          );
+          return;
+        }
+        let planningNote = '';
+        if (projectPlanningService && projectId) {
+          const current = await projectPlanningService.getState({ projectId });
+          if (current.state && current.state.metadata?.['active'] === true) {
+            await projectPlanningService.upsertState({
+              projectId,
+              state: {
+                ...current.state,
+                metadata: {
+                  ...(current.state.metadata ?? {}),
+                  active: false,
+                  dismissedAt: Date.now(),
+                  dismissedFrom: 'plan-command',
+                },
+              },
+            });
+            planningNote = ' Project planning interview marked inactive.';
+          }
+        }
+        if (dismissal.outcome === 'dismissed') {
+          ctx.print(
+            `Dismissed plan "${dismissal.plan?.title ?? 'active plan'}" ` +
+            `(archived as dismissed; retained in /plan list; /plan <goal> starts fresh).${planningNote}`,
+          );
+        } else if (planningNote) {
+          ctx.print(`No active execution plan to dismiss.${planningNote}`);
+        } else {
+          ctx.print('No active plan or planning state to dismiss.');
+        }
+        return;
+      }
+
+      // DEBT-3: /plan answer <n|question-id> <text> — record a real answer to an
+      // open planning question (moves open → answered, consumed on next refine).
+      if (args[0] === 'answer') {
+        if (!projectPlanningService || !projectId) {
+          ctx.print('Project planning service is not available in this runtime.');
+          return;
+        }
+        const ref = args[1];
+        const answerText = args.slice(2).join(' ').trim();
+        if (!ref || !answerText) {
+          ctx.print('Usage: /plan answer <question-number|question-id> <your answer>');
+          return;
+        }
+        const asNum = Number(ref);
+        const selector = Number.isInteger(asNum) && asNum >= 1
+          ? { questionIndex: asNum - 1 }
+          : { questionId: ref };
+        const answerResult = await projectPlanningService.answerQuestion({ projectId, ...selector, answer: answerText });
+        if (!answerResult.answered) {
+          if (answerResult.reason === 'no-state') {
+            ctx.print('No project planning state exists yet. Seed it with /plan <goal>.');
+          } else if (answerResult.reason === 'question-not-found') {
+            const open = answerResult.openQuestions;
+            const listing = open.length > 0
+              ? open.map((question, index) => `  ${index + 1}. ${question.prompt} (${question.id})`).join('\n')
+              : '  (no open questions)';
+            ctx.print(`No open question matched "${ref}". Open questions:\n${listing}`);
+          } else {
+            ctx.print('Usage: /plan answer <question-number|question-id> <your answer>');
+          }
+          return;
+        }
+        openProjectPlanningPanel();
+        ctx.print(
+          `Recorded answer to: ${answerResult.question?.prompt ?? 'question'}\n` +
+          `Readiness: ${answerResult.evaluation.readiness}\n` +
+          formatNextQuestion(answerResult.evaluation.nextQuestion),
+        );
+        return;
+      }
+
       // Defense (Wave 6 review): a single verb-looking token is almost never a
       // real planning goal — it is a mistyped or removed subcommand. The
       // Planning modal used to dispatch `/plan dismiss`, which has no

package/src/input/commands/qrcode-runtime.ts

@@ -1,18 +1,38 @@
+import { join } from 'node:path';
 import type { CommandRegistry } from '../command-registry.ts';
-import { openModalCommand } from './runtime-services.ts';
+import { openModalCommand, requireShellPaths } from './runtime-services.ts';
+import { regenerateCompanionToken } from '@pellux/goodvibes-sdk/platform/pairing';
 
 /**
  * Register the /qrcode command.
  *
- * Opens the QR Code panel which displays a scannable QR code for
- * companion app pairing, along with connection URL, token, and username.
+ * `/qrcode` (no args) opens the companion-app pairing modal (QR code + URL/
+ * token/username). `/qrcode regenerate` rotates the companion pairing token:
+ * it re-keys the shared operator-token store, so the previously-issued token is
+ * rejected on the next auth and a fresh QR must be scanned to reconnect.
  */
 export function registerQrcodeRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'qrcode',
     aliases: ['qr', 'pair'],
-    description: 'Open the companion-app pairing modal (QR code)',
-    handler(_args, ctx) {
+    description: 'Open the companion-app pairing modal (QR code), or regenerate the pairing token',
+    usage: '[regenerate]',
+    argsHint: '[regenerate]',
+    handler(args, ctx) {
+      if (args[0]?.toLowerCase() === 'regenerate') {
+        const shellPaths = requireShellPaths(ctx);
+        const daemonHomeDir = join(shellPaths.homeDirectory, '.goodvibes', 'daemon');
+        try {
+          const rotated = regenerateCompanionToken({ daemonHomeDir });
+          ctx.print(
+            'Pairing token rotated. The previous token is now rejected — ' +
+            `re-scan the QR (new peer ${rotated.peerId.slice(0, 8)}…) to reconnect the companion app.`,
+          );
+        } catch (error) {
+          ctx.print(`Could not regenerate the pairing token: ${String(error)}`);
+        }
+        return;
+      }
       openModalCommand(ctx, 'pairing-modal');
     },
   });

package/src/input/commands/remote-runtime-setup.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { getDefaultAcpAgentCommand } from '@pellux/goodvibes-sdk/platform/acp';
+import { resolveDaemonEnabled } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandContext, RemoteCommandService } from '../command-registry.ts';
 import type { RemoteSessionBundle } from '@/runtime/index.ts';
 import { requireShellPaths } from './runtime-services.ts';
@@ -37,10 +38,11 @@ export async function handleRemoteSetupCommand(
   if (subcommand === 'setup') {
     const command = getDefaultAcpAgentCommand();
     const danger = ctx.platform.configManager.getCategory('danger');
+    const daemonEnabled = resolveDaemonEnabled(ctx.platform.configManager);
     const lines = [
       'Remote Setup Review',
       `  acp agent command: ${command.join(' ')}`,
-      `  daemon enabled: ${danger.daemon ? 'yes' : 'no'}`,
+      `  daemon enabled: ${daemonEnabled ? 'yes' : 'no'}`,
       `  http listener enabled: ${danger.httpListener ? 'yes' : 'no'}`,
       `  remote runner contracts: ${remoteRegistry.listContracts().length}`,
       `  active acp connections: ${activeConnections.length}`,
@@ -48,7 +50,7 @@ export async function handleRemoteSetupCommand(
       '  guidance:',
       '    - set ACP_AGENT_CMD to override the spawned remote agent command',
       '    - use /remote env to export a reusable shell snippet',
-      '    - enable danger.daemon / danger.httpListener only when you actually need those remote surfaces',
+      '    - the daemon runs by default (daemon.enabled); enable danger.httpListener only when you actually need that remote surface',
     ];
     if (args[1]?.toLowerCase() === 'export') {
       const pathArg = args[2];
@@ -62,7 +64,7 @@ export async function handleRemoteSetupCommand(
       writeFileSync(targetPath, `${JSON.stringify({
         exportedAt: Date.now(),
         acpAgentCommand: command,
-        daemonEnabled: Boolean(danger.daemon),
+        daemonEnabled,
         httpListenerEnabled: Boolean(danger.httpListener),
         remoteRunnerContracts: remoteRegistry.listContracts().length,
       }, null, 2)}\n`, 'utf-8');

package/src/input/commands/session-content.ts

@@ -384,9 +384,20 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
     },
   });
 
+  // W6-C3 (Wave 6 core-verb pass, MEMORY fragmentation — worst-class
+  // collision #2): this command used to be named /memory, colliding with
+  // the agent's /memory (an alias that forwards to /recall, the durable
+  // cross-session MemoryStore) — same command name, two unrelated features.
+  // Renamed to /note (this feature manages EPHEMERAL, session-scoped sticky
+  // notes pinned across context compaction — an entirely different resource
+  // from /recall's durable records). /memory is now registered as an alias
+  // of /recall below (memory.ts), matching the agent, so the word means the
+  // same thing on both surfaces. See
+  // docs/decisions/2026-07-06-core-verb-spec.md (in the SDK repo) for the
+  // full writeup.
   registry.register({
-    name: 'memory',
-    description: 'Manage session memories (pinned across context compaction)',
+    name: 'note',
+    description: 'Manage session notes (pinned across context compaction)',
     usage: '[list|add <text>|remove <id>]',
     argsHint: '[list|add|remove]',
     handler(args, ctx) {
@@ -394,26 +405,26 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
       if (sub === 'list' || args.length === 0) {
         const memories = requireSessionMemoryStore(ctx).list();
         ctx.print(memories.length === 0
-          ? 'No session memories. Use !# prefix or /memory add <text> to create one.'
-          : [`Session Memories (${memories.length}):`, ...memories.map(m => `  [${m.id}] ${m.text}`)].join('\n'));
+          ? 'No session notes. Use !# prefix or /note add <text> to create one.'
+          : [`Session Notes (${memories.length}):`, ...memories.map(m => `  [${m.id}] ${m.text}`)].join('\n'));
       } else if (sub === 'add') {
         const text = args.slice(1).join(' ').trim();
         if (!text) {
-          ctx.print('Usage: /memory add <text>');
+          ctx.print('Usage: /note add <text>');
           return;
         }
         const id = requireSessionMemoryStore(ctx).add(text);
-        ctx.print(`Memory added: [${id}] ${text}`);
+        ctx.print(`Note added: [${id}] ${text}`);
       } else if (sub === 'remove') {
         const id = args[1];
         if (!id) {
-          ctx.print('Usage: /memory remove <id>');
+          ctx.print('Usage: /note remove <id>');
           return;
         }
         const store = requireSessionMemoryStore(ctx);
-        ctx.print(store.remove(id) ? `Memory removed: [${id}]` : `Memory not found: ${id}`);
+        ctx.print(store.remove(id) ? `Note removed: [${id}]` : `Note not found: ${id}`);
       } else {
-        ctx.print('Usage: /memory [list|add <text>|remove <id>]\n  /memory              — list all session memories\n  /memory list         — list all session memories\n  /memory add <text>   — add a memory without sending a message\n  /memory remove <id>  — remove a specific memory');
+        ctx.print('Usage: /note [list|add <text>|remove <id>]\n  /note              — list all session notes\n  /note list         — list all session notes\n  /note add <text>   — add a note without sending a message\n  /note remove <id>  — remove a specific note');
       }
     },
   });

package/src/input/commands/settings-sync-runtime.ts

@@ -26,16 +26,28 @@ export function registerSettingsSyncRuntimeCommands(registry: CommandRegistry):
   registry.register({
     name: 'settings-sync',
     aliases: ['settingssync'],
-    description: 'Review sync posture, export/import settings-sync bundles, and open the settings sync workspace',
-    usage: '[review|panel|show <key>|staged|conflicts|resolve <key> <local|synced>|failures|rollback-history|export <path>|inspect <path>|pull <path>|push <path>|lock <key> <source> <reason...>|unlock <key>]',
+    description: 'Open the settings sync modal (bare); review posture, export/import bundles, or resolve conflicts by subcommand',
+    usage: '[panel|report|review|show <key>|staged|conflicts|resolve <key> <local|synced>|failures|rollback-history|export <path>|inspect <path>|pull <path>|push <path>|lock <key> <source> <reason...>|unlock <key>] — bare opens the modal',
     handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
       const controlPlaneConfigDir = ctx.platform.configManager.getControlPlaneConfigDir();
-      const sub = (args[0] ?? 'review').toLowerCase();
+      const sub = (args[0] ?? '').toLowerCase();
+      // DEBT-5 item 3 (report-vs-modal front doors): settings-sync has a full
+      // modal surface (settings-sync-modal), so the bare command now opens it
+      // — the old bare/`review` transcript report moved to an explicit
+      // `report` subcommand (scriptability preserved: /settings-sync report).
+      if (sub === '') {
+        ctx.openModal?.('settings-sync-modal');
+        return;
+      }
       if (sub === 'panel' || sub === 'open') {
         ctx.openModal?.('settings-sync-modal'); // W6.1: settings-sync panel -> config modal
         return;
       }
+      if (sub === 'report' || sub === 'review') {
+        ctx.print(formatSettingsControlPlaneReview(ctx.platform.configManager).join('\n'));
+        return;
+      }
       if (sub === 'show') {
         const key = args[1] as ConfigKey | undefined;
         if (!key || !CONFIG_KEYS.has(key)) {

package/src/input/commands/shell-core.ts

@@ -163,7 +163,10 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/quit', label: '/quit', detail: 'Exit', category: 'Tools & System' },
           { id: '/wq', label: '/wq', detail: 'Commit all git changes and then exit', category: 'Tools & System' },
         ];
-        ctx.openSelection('Help  —  Commands', items, { allowSearch: true }, (result) => {
+        // UX-C: every item here is a command, and picking one RUNS it — label
+        // the verb "Run" (matching the slash-command palette) instead of the
+        // generic "Select" default.
+        ctx.openSelection('Help  —  Commands', items, { allowSearch: true, primaryVerbLabel: 'Run' }, (result) => {
           if (!result) return;
           const command = result.item.id;
           if (command.startsWith('/')) {
@@ -294,6 +297,12 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
     handler(_args, ctx) {
       ctx.session.runtime.debugMode = !ctx.session.runtime.debugMode;
       ctx.print(`Debug mode: ${ctx.session.runtime.debugMode ? 'ON' : 'OFF'}`);
+      // Honest quiet counter for direct terminal writes the guard intercepted
+      // (routed here instead of spamming the transcript). (UX-B item 1a.)
+      const intercepted = ctx.session.runtime.terminalWritesIntercepted ?? 0;
+      if (intercepted > 0) {
+        ctx.print(`Terminal writes intercepted this session: ${intercepted} (details in the activity log)`);
+      }
     },
   });
 

package/src/input/commands/workstream-runtime.ts

@@ -20,8 +20,8 @@
 // ---------------------------------------------------------------------------
 
 import { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core';
-import type { PhaseKind, PhaseRole, WorkItemState, Workstream } from '@pellux/goodvibes-sdk/platform/orchestration';
-import type { WorkstreamCommandService, WorkstreamDraft } from '../../runtime/workstream-services.ts';
+import type { CreateWorkstreamInput, PhaseKind, PhaseRole, WorkItem, WorkItemState, Workstream, WorkstreamIsolation } from '@pellux/goodvibes-sdk/platform/orchestration';
+import type { WorkstreamCommandService, WorkstreamDraft, WorkstreamDraftProvenance } from '../../runtime/workstream-services.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 
 // ---------------------------------------------------------------------------
@@ -70,27 +70,140 @@ function formatPhaseLabel(phase: { readonly kind: PhaseKind; readonly role: Phas
   return `${phase.kind} — ${phase.role}`;
 }
 
+/**
+ * Extracts an optional `--isolation shared|worktree` flag from anywhere in
+ * `args` (create/edit both accept it ahead of, or interleaved with, the task
+ * text). Returns the flag stripped out so the remaining tokens are the task
+ * text exactly as before this flag existed. An unrecognized value is a hard
+ * error (never silently ignored or defaulted) — a typo'd isolation mode
+ * must never quietly launch in the wrong one.
+ */
+function extractIsolationFlag(args: readonly string[]): { isolation?: WorkstreamIsolation; rest: string[]; error?: string } {
+  const rest: string[] = [];
+  let isolation: WorkstreamIsolation | undefined;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--isolation') {
+      const value = args[i + 1];
+      if (value !== 'shared' && value !== 'worktree') {
+        return { rest, error: `--isolation must be "shared" or "worktree" (got: ${value ?? '<nothing>'})` };
+      }
+      isolation = value;
+      i += 1; // consume the value token too
+      continue;
+    }
+    rest.push(args[i]!);
+  }
+  return { isolation, rest };
+}
+
+/**
+ * Per-item merge-state text for `/workstream status` (worktree isolation
+ * only — see formatItemMergeState's caller). Distinct from `item.state` (the
+ * pipeline verdict): an item can be terminally 'passed' while its branch is
+ * still 'merge pending' in the integration lane, or stuck at
+ * 'merge-conflict' with its worktree deliberately kept for inspection.
+ */
+function formatItemMergeState(item: WorkItem): string {
+  switch (item.mergeState) {
+    case 'merged':
+      return item.mergeHash ? `merged ${shortId(item.mergeHash)}` : 'merged (no changes)';
+    case 'conflict':
+      return 'merge-conflict (worktree kept for inspection)';
+    case 'pending':
+      return 'merge pending';
+    case 'n-a':
+    default:
+      return item.worktreeKept ? 'worktree kept' : 'not yet integrated';
+  }
+}
+
+/**
+ * Per-item dependency truth for `/workstream status` (BIG-3 item 2). A
+ * dependency-blocked item shows its honest, engine-set reason verbatim
+ * ('waiting on: X' or 'dependency failed: X'); an item that HAS dependencies
+ * but is no longer blocked shows the static 'after: X, Y' provenance so the
+ * ordering constraint stays visible even once satisfied. An item with no
+ * dependencies contributes nothing.
+ */
+function formatItemDependencyNote(item: WorkItem, ws: Workstream): string {
+  if (item.state === 'blocked-dependency' && item.blockedReason) return `  — ${item.blockedReason}`;
+  if (item.dependsOn && item.dependsOn.length > 0) {
+    const titleById = new Map(ws.items.map((i) => [i.id, i.title]));
+    return `  — after: ${item.dependsOn.map((d) => titleById.get(d) ?? shortId(d)).join(', ')}`;
+  }
+  return '';
+}
+
+/**
+ * Compact item + dependency graph for the draft-approval view (BIG-3 item 4):
+ * items in ordinal order (the spec preserves the proposal's order), each with
+ * an honest text 'after: X, Y' clause when it depends on siblings — no fake DAG
+ * art. Dependency ids are resolved back to titles from the spec itself.
+ */
+function formatDraftItems(spec: CreateWorkstreamInput): string[] {
+  const titleById = new Map(spec.items.map((it) => [it.id ?? it.title, it.title] as const));
+  return spec.items.map((it, i) => {
+    const deps = it.dependsOn ?? [];
+    const after = deps.length > 0 ? ` (after: ${deps.map((d) => titleById.get(d) ?? d).join(', ')})` : '';
+    return `  ${i + 1}. ${it.title}${after}`;
+  });
+}
+
 function summarizeItemStates(ws: Workstream): string {
   const counts = new Map<string, number>();
   for (const item of ws.items) counts.set(item.state, (counts.get(item.state) ?? 0) + 1);
   return Array.from(counts.entries()).map(([state, n]) => `${n} ${state}`).join(', ') || 'no items';
 }
 
-/** The engine's own PlanProposal is deliberately not rendered — see workstream-services.ts's buildSpec doc. This renders the REAL launchable spec instead, so the proposal and the launch are always the same plan. */
+/**
+ * Honest one-line provenance for how the goal was decomposed. Three shapes,
+ * mirroring the SDK decomposition service's outcomes:
+ *   - a planning agent decomposed it (with item count + cost/tokens + elapsed)
+ *   - the heuristic path ran because the agent path failed (fallback + reason)
+ *   - the heuristic path ran deliberately (configured, or the gate declined)
+ */
+function formatProvenance(p: WorkstreamDraftProvenance): string {
+  if (p.kind === 'agent') {
+    const bits: string[] = [`${p.itemCount} item${p.itemCount === 1 ? '' : 's'}`];
+    if (p.agentCostUsd !== undefined) bits.push(`$${p.agentCostUsd.toFixed(4)}`);
+    else if (p.agentTokens !== undefined) bits.push(`${p.agentTokens} tok`);
+    if (p.elapsedMs !== undefined) bits.push(`${Math.round(p.elapsedMs / 1000)}s`);
+    return `Decomposition: planning agent (${bits.join(', ')})`;
+  }
+  if (p.kind === 'fallback') {
+    return `Decomposition: heuristic (agent fallback: ${p.fallbackReason ?? 'unknown'})`;
+  }
+  if (p.kind === 'gate-declined') {
+    return 'Decomposition: heuristic (single item; planner declined to decompose)';
+  }
+  return 'Decomposition: heuristic (configured)';
+}
+
+/** The engine's own PlanProposal is deliberately not rendered as the launchable spec — see workstream-services.ts's buildSpec doc. This renders the REAL launchable spec (so the proposal and the launch are always the same plan) plus an honest provenance line describing how the goal was decomposed. */
 function renderDraftProposal(draft: WorkstreamDraft): string {
   const lines: string[] = [];
   lines.push(`Workstream proposal ${draft.id} — "${draft.task}"`);
+  lines.push(`Isolation: ${draft.spec.isolation ?? 'shared (default)'}`);
   lines.push(
     `Planner: strategy=${draft.gate.strategy} (${draft.gate.reasonCode}) — ${AdaptivePlanner.explainReasonCode(draft.gate.reasonCode)}`,
   );
+  lines.push(formatProvenance(draft.provenance));
+  // Honest mapping boundary (BIG-3 item 4): a multi-item proposal launches as
+  // the REAL dependency-scheduled workstream (fromPlanProposal); a single-item
+  // one launches as the compat engineer→review chain (fromChainSpec). State
+  // which, so the preview never overstates what launch will do.
+  const multiItem = draft.spec.items.length > 1;
+  lines.push(
+    multiItem
+      ? `Mapping: multi-item plan — ${draft.spec.items.length} items run the engineer→review pipeline, dependency-scheduled.`
+      : 'Mapping: single-item compat chain (engineer→review) — no multi-item structure to schedule.',
+  );
   lines.push('Phases:');
   draft.spec.phases.forEach((phase, i) => {
     lines.push(`  ${i + 1}. ${formatPhaseLabel(phase)} (capacity ${phase.capacity})`);
   });
-  lines.push('Work items:');
-  for (const item of draft.spec.items) {
-    lines.push(`  - ${item.title}`);
-  }
+  lines.push('Work items (ordinal order):');
+  lines.push(...formatDraftItems(draft.spec));
   lines.push(
     draft.approved
       ? `Approved. Launch with: /workstream launch ${draft.id}`
@@ -107,15 +220,42 @@ function renderDraftProposal(draft: WorkstreamDraft): string {
 }
 
 function renderWorkstreamStatus(ws: Workstream): string {
+  const isolated = ws.isolation === 'worktree';
   const lines: string[] = [];
   lines.push(`Workstream ${ws.id} — "${ws.title}"`);
+  lines.push(`Isolation: ${ws.isolation ?? 'shared'}`);
+  // Origin provenance (BIG-3 item 1) — only present on workstreams assembled
+  // from a decomposition proposal; absent for compat/authored ones.
+  if (ws.provenance) {
+    const pv = ws.provenance;
+    const bits: string[] = [];
+    if (pv.decomposedBy) bits.push(`${pv.decomposedBy}-decomposed`);
+    if (pv.proposalId) bits.push(`plan ${pv.proposalId}`);
+    if (pv.strategy) bits.push(pv.strategy);
+    if (bits.length > 0) lines.push(`Origin: ${bits.join(', ')}`);
+  }
   lines.push('Phases:');
   for (const phase of ws.phases) {
     lines.push(`  [${phase.ordinal}] ${formatPhaseLabel(phase)} (capacity ${phase.capacity})`);
   }
   lines.push('Items:');
   for (const item of ws.items) {
-    lines.push(`  ${shortId(item.id)}  [${item.state}]  ${item.title}  — phase: ${item.currentPhaseId ?? '—'}`);
+    const mergeNote = isolated ? `  — ${formatItemMergeState(item)}` : '';
+    const depNote = formatItemDependencyNote(item, ws);
+    lines.push(`  ${shortId(item.id)}  [${item.state}]  ${item.title}  — phase: ${item.currentPhaseId ?? '—'}${depNote}${mergeNote}`);
+  }
+  if (isolated) {
+    // Honest terminal-summary truth (never inferred from item.state alone —
+    // an item can be terminally 'passed' with its branch still unmerged):
+    // an item counts as unmerged the instant it enters the integration lane
+    // (mergeState 'pending') and stays counted through a conflict or any
+    // KEPT worktree, until a clean merge clears it.
+    const unmerged = ws.items.filter((item) => item.mergeState === 'pending' || item.mergeState === 'conflict' || item.worktreeKept);
+    lines.push(
+      unmerged.length > 0
+        ? `Unmerged items: ${unmerged.length} (${unmerged.map((item) => shortId(item.id)).join(', ')}) — this run is NOT fully integrated yet.`
+        : 'Unmerged items: none — every terminated item is merged (or had nothing to merge).',
+    );
   }
   return lines.join('\n');
 }
@@ -167,8 +307,8 @@ export function registerWorkstreamRuntimeCommands(registry: CommandRegistry): vo
   registry.register({
     name: 'workstream',
     description: 'Author and oversee multi-phase agent workstreams (orchestration engine)',
-    usage: 'create <task...> | list | status [id] | insert-phase <id> <description...> | approve <id> | edit <id> <task...> | launch <id> | cancel <id>',
-    argsHint: 'create <task> | list | status [id] | approve | edit | launch | cancel',
+    usage: 'create [--isolation shared|worktree] <task...> | list | status [id] | insert-phase <id> <description...> | approve <id> | edit <id> [--isolation shared|worktree] <task...> | launch <id> | cancel <id>',
+    argsHint: 'create [--isolation worktree] <task> | list | status [id] | approve | edit | launch | cancel',
     handler: async (args, ctx: CommandContext) => {
       const service = ctx.session.workstreamEngine;
       if (!service) {
@@ -184,12 +324,17 @@ export function registerWorkstreamRuntimeCommands(registry: CommandRegistry): vo
       }
 
       if (sub === 'create') {
-        const task = args.slice(1).join(' ').trim();
+        const { isolation, rest, error } = extractIsolationFlag(args.slice(1));
+        if (error) {
+          ctx.print(`Usage: /workstream create [--isolation shared|worktree] <task...>\n${error}`);
+          return;
+        }
+        const task = rest.join(' ').trim();
         if (!task) {
-          ctx.print('Usage: /workstream create <task...>');
+          ctx.print('Usage: /workstream create [--isolation shared|worktree] <task...>');
           return;
         }
-        const draft = service.proposeDraft(task);
+        const draft = await service.proposeDraft(task, isolation);
         ctx.print(renderDraftProposal(draft));
         return;
       }
@@ -255,12 +400,17 @@ export function registerWorkstreamRuntimeCommands(registry: CommandRegistry): vo
 
       if (sub === 'edit') {
         const id = args[1];
-        const task = args.slice(2).join(' ').trim();
+        const { isolation, rest, error } = extractIsolationFlag(args.slice(2));
+        if (error) {
+          ctx.print(`Usage: /workstream edit <id> [--isolation shared|worktree] <new task...>\n${error}`);
+          return;
+        }
+        const task = rest.join(' ').trim();
         if (!id || !task) {
-          ctx.print('Usage: /workstream edit <id> <new task...>');
+          ctx.print('Usage: /workstream edit <id> [--isolation shared|worktree] <new task...>');
           return;
         }
-        const draft = service.editDraft(id, task);
+        const draft = await service.editDraft(id, task, isolation);
         if (!draft) {
           ctx.print(draftNotFoundMessage(service, id));
           return;
@@ -324,12 +474,12 @@ export function registerWorkstreamRuntimeCommands(registry: CommandRegistry): vo
 
       ctx.print(
         'Usage:\n'
-        + '  /workstream create <task...>\n'
+        + '  /workstream create [--isolation shared|worktree] <task...>\n'
         + '  /workstream list\n'
         + '  /workstream status [id]\n'
         + '  /workstream insert-phase <id> <description...>\n'
         + '  /workstream approve <id>\n'
-        + '  /workstream edit <id> <new task...>\n'
+        + '  /workstream edit <id> [--isolation shared|worktree] <new task...>\n'
         + '  /workstream launch <id>\n'
         + '  /workstream cancel <id>',
       );

package/src/input/config-modal-types.ts

@@ -89,6 +89,17 @@ export interface ConfigModalActionContext {
    *  services surface jumping to the subscription surface). Swaps the active
    *  surface in place — the same seam ctx.openModal uses. */
   readonly openModal?: (name: string) => void;
+  /**
+   * Submit text to the chat/model as a real user turn — the same composer
+   * submission seam `handleUserInput` uses (threaded from CommandContext.submitInput).
+   * Generic across surfaces (any modal may hand free-form input to the model).
+   *
+   * ORDERING GUARD: a turn must never start while a modal owns the keyboard —
+   * that is the modal-liveness hazard (a live turn painting under a modal that
+   * still captures keys). Callers MUST `close()` the modal BEFORE invoking
+   * `submitInput`. The planning modal's free-form submit follows this ordering.
+   */
+  readonly submitInput?: (text: string) => void;
   /** Request a re-render. */
   readonly requestRender: () => void;
   /** Set the modal's transient status line (e.g. a result or error message). */
@@ -102,7 +113,10 @@ export interface ConfigModalAction {
   /**
    * Trigger key: a single printable char ('r', 'd') or a named key ('enter').
    * Must not collide with the host-reserved nav keys (up/down/left/right/tab/
-   * j/k/escape) — those are consumed by the host before actions are consulted.
+   * j/k/escape/'/') — those are consumed by the host before actions are
+   * consulted. '/' arms the host's type-to-filter (DEBT-5 item 1); while
+   * filtering, EVERY printable key (not just j/k) is captured by the query
+   * instead of firing an action — see handleConfigModalToken.
    */
   readonly key: string;
   /** Action id passed to `onAction`. */