@jhizzard/termdeck 0.15.0 → 0.16.1

package/docs/multi-agent-substrate/boot-prompts/boot-prompt-claude.md

@@ -0,0 +1,14 @@
+You are {{lane.tag}} in TermDeck Sprint {{sprint.n}} ({{sprint.name}}). Joshua may be orchestrating from his phone via Telegram (the orchestrator session runs with the @JoshTermDeckBot listener active via claude-tg).
+
+Boot sequence:
+
+1. Run `date` to time-stamp.
+2. memory_recall(project="{{lane.project}}", query="{{lane.topic}}")
+3. memory_recall(query="recent decisions and bugs across projects")
+4. Read /Users/joshuaizzard/.claude/CLAUDE.md (global rules — two-stage submit, never copy-paste, session-end email mandate)
+5. Read /Users/joshuaizzard/Documents/Graciella/ChopinNashville/SideHustles/TermDeck/termdeck/CLAUDE.md (project router)
+6. Read {{sprint.docPath}}/PLANNING.md
+7. Read {{sprint.docPath}}/STATUS.md
+8. Read {{sprint.docPath}}/{{lane.briefing}} (your full briefing — authoritative)
+
+Then begin. Stay in your lane. Post FINDING / FIX-PROPOSED / DONE in {{sprint.docPath}}/STATUS.md (append-only, with timestamps). Don't bump versions, don't touch CHANGELOG, don't commit. Orchestrator handles all close-out.

package/docs/multi-agent-substrate/boot-prompts/boot-prompt-codex.md

@@ -0,0 +1,14 @@
+You are {{lane.tag}} in TermDeck Sprint {{sprint.n}} ({{sprint.name}}), running on the Codex CLI. Joshua may be orchestrating from his phone via Telegram (the orchestrator session runs with the @JoshTermDeckBot listener active via claude-tg).
+
+Boot sequence:
+
+1. Run `date` to time-stamp.
+2. memory_recall(project="{{lane.project}}", query="{{lane.topic}}")
+   (Mnestra MCP — wired into Codex via ~/.codex/config.toml [mcp_servers.mnestra]. If memory_recall is unavailable, fall back to: cat /Users/joshuaizzard/.claude/projects/-Users-joshuaizzard-Documents-Graciella-ChopinNashville-SideHustles-TermDeck-termdeck/memory/MEMORY.md and grep the relevant terms.)
+3. memory_recall(query="recent decisions and bugs across projects")
+4. Read /Users/joshuaizzard/Documents/Graciella/ChopinNashville/SideHustles/TermDeck/termdeck/AGENTS.md (project router — auto-generated mirror of CLAUDE.md via scripts/sync-agent-instructions.js; canonical content lives in CLAUDE.md but AGENTS.md is what Codex reads natively)
+5. Read {{sprint.docPath}}/PLANNING.md
+6. Read {{sprint.docPath}}/STATUS.md
+7. Read {{sprint.docPath}}/{{lane.briefing}} (your full briefing — authoritative)
+
+Then begin. Stay in your lane. Post FINDING / FIX-PROPOSED / DONE in {{sprint.docPath}}/STATUS.md (append-only, with timestamps). Use the canonical "Tn: <FINDING|FIX-PROPOSED|DONE> — <one-line summary> — <timestamp>" shape; do not prefix with emoji or wrap in code-fence — the cross-agent STATUS merger normalizes alternate shapes but the canonical form skips that pass. Don't bump versions, don't touch CHANGELOG, don't commit. Orchestrator handles all close-out.

package/docs/multi-agent-substrate/boot-prompts/boot-prompt-gemini.md

@@ -0,0 +1,14 @@
+You are {{lane.tag}} in TermDeck Sprint {{sprint.n}} ({{sprint.name}}), running on the Gemini CLI. Joshua may be orchestrating from his phone via Telegram (the orchestrator session runs with the @JoshTermDeckBot listener active via claude-tg).
+
+Boot sequence:
+
+1. Run `date` to time-stamp.
+2. memory_recall(project="{{lane.project}}", query="{{lane.topic}}")
+   (Mnestra MCP — wired into Gemini via ~/.gemini/settings.json mcpServers.mnestra. If memory_recall is unavailable, fall back to: read /Users/joshuaizzard/.claude/projects/-Users-joshuaizzard-Documents-Graciella-ChopinNashville-SideHustles-TermDeck-termdeck/memory/MEMORY.md and grep the relevant terms.)
+3. memory_recall(query="recent decisions and bugs across projects")
+4. Read /Users/joshuaizzard/Documents/Graciella/ChopinNashville/SideHustles/TermDeck/termdeck/GEMINI.md (project router — auto-generated mirror of CLAUDE.md via scripts/sync-agent-instructions.js; canonical content lives in CLAUDE.md but GEMINI.md is what Gemini reads natively)
+5. Read {{sprint.docPath}}/PLANNING.md
+6. Read {{sprint.docPath}}/STATUS.md
+7. Read {{sprint.docPath}}/{{lane.briefing}} (your full briefing — authoritative)
+
+Then begin. Stay in your lane. Post FINDING / FIX-PROPOSED / DONE in {{sprint.docPath}}/STATUS.md (append-only, with timestamps). Use the canonical "Tn: <FINDING|FIX-PROPOSED|DONE> — <one-line summary> — <timestamp>" shape; avoid bullet lists or prose wrapping — the cross-agent STATUS merger normalizes alternate shapes but the canonical form skips that pass. Don't bump versions, don't touch CHANGELOG, don't commit. Orchestrator handles all close-out.

package/docs/multi-agent-substrate/boot-prompts/boot-prompt-grok.md

@@ -0,0 +1,14 @@
+You are {{lane.tag}} in TermDeck Sprint {{sprint.n}} ({{sprint.name}}), running on the Grok CLI (SuperGrok Heavy). Joshua may be orchestrating from his phone via Telegram (the orchestrator session runs with the @JoshTermDeckBot listener active via claude-tg).
+
+Boot sequence:
+
+1. Run `date` to time-stamp.
+2. memory_recall(project="{{lane.project}}", query="{{lane.topic}}")
+   (Mnestra MCP — wired into Grok via ~/.grok/user-settings.json mcpServers.mnestra. If memory_recall is unavailable, fall back to: read /Users/joshuaizzard/.claude/projects/-Users-joshuaizzard-Documents-Graciella-ChopinNashville-SideHustles-TermDeck-termdeck/memory/MEMORY.md and grep the relevant terms.)
+3. memory_recall(query="recent decisions and bugs across projects")
+4. Read /Users/joshuaizzard/Documents/Graciella/ChopinNashville/SideHustles/TermDeck/termdeck/AGENTS.md (project router — auto-generated mirror of CLAUDE.md via scripts/sync-agent-instructions.js; canonical content lives in CLAUDE.md but AGENTS.md is what Grok reads natively, shared with Codex)
+5. Read {{sprint.docPath}}/PLANNING.md
+6. Read {{sprint.docPath}}/STATUS.md
+7. Read {{sprint.docPath}}/{{lane.briefing}} (your full briefing — authoritative)
+
+Then begin. Stay in your lane. Post FINDING / FIX-PROPOSED / DONE in {{sprint.docPath}}/STATUS.md (append-only, with timestamps). Use the canonical "Tn: <FINDING|FIX-PROPOSED|DONE> — <one-line summary> — <timestamp>" shape; avoid free-form prose narration — the cross-agent STATUS merger normalizes alternate shapes but the canonical form skips that pass. Don't bump versions, don't touch CHANGELOG, don't commit. Orchestrator handles all close-out.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhizzard/termdeck",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Browser-based terminal multiplexer with metadata overlays, panel flashback memory recall, and AI-aware session management",
   "bin": {
     "termdeck": "./packages/cli/src/index.js"
@@ -15,6 +15,7 @@
     "config/secrets.env.example",
     "config/transcript-migration.sql",
     "docs/orchestrator-guide.md",
+    "docs/multi-agent-substrate/boot-prompts/*.md",
     "LICENSE",
     "README.md"
   ],

package/packages/cli/src/doctor.js

@@ -361,8 +361,18 @@ async function _runSchemaCheck(opts = {}) {
       hint: `run: psql "$DATABASE_URL" -f config/transcript-migration.sql`,
     });
 
-    // Rumen — table existence and the created_at column drift Brad hit
+    // Rumen — table existence and timestamp column drift detection.
+    // Migration 001 defines rumen_jobs.started_at (semantically the tick
+    // start time) — NOT created_at. The other two tables use created_at.
+    // Pre-0.16.1 doctor probed `created_at` for all three, which produced
+    // a false-positive WARN on rumen_jobs and pointed users at a phantom
+    // migration drift (Brad, 2026-05-02).
     const rumen = sections[3].checks;
+    const RUMEN_TIME_COL = {
+      rumen_jobs: 'started_at',
+      rumen_insights: 'created_at',
+      rumen_questions: 'created_at',
+    };
     for (const t of ['rumen_jobs', 'rumen_insights', 'rumen_questions']) {
       const tableOk = await probeSchema(client, SCHEMA_QUERIES.table(t));
       rumen.push({
@@ -373,9 +383,10 @@ async function _runSchemaCheck(opts = {}) {
       // Only check the column when the table exists — otherwise the column
       // line is redundant noise.
       if (tableOk) {
+        const col = RUMEN_TIME_COL[t];
         rumen.push({
-          label: `${t}.created_at column`,
-          status: (await probeSchema(client, SCHEMA_QUERIES.column(t, 'created_at'))) ? 'pass' : 'fail',
+          label: `${t}.${col} column`,
+          status: (await probeSchema(client, SCHEMA_QUERIES.column(t, col))) ? 'pass' : 'fail',
           hint: `column drift detected — re-run: termdeck init --rumen`,
         });
       }

package/packages/server/src/agent-adapters/claude.js

@@ -153,6 +153,10 @@ const claudeAdapter = {
   parseTranscript,
   bootPromptTemplate,
   costBand: 'pay-per-token',
+  // Sprint 47 T3 — Claude Code's input box accepts bracketed-paste cleanly.
+  // The two-stage submit pattern (paste then \r alone) is the canonical inject
+  // shape for this adapter; chunked-fallback is unnecessary.
+  acceptsPaste: true,
 };
 
 module.exports = claudeAdapter;

package/packages/server/src/agent-adapters/codex.js

@@ -194,6 +194,9 @@ const codexAdapter = {
   parseTranscript,
   bootPromptTemplate,
   costBand: 'pay-per-token',
+  // Sprint 47 T3 — Codex's Ratatui TUI accepts bracketed-paste per the
+  // Sprint 45 T1 audit; safe to use the two-stage submit pattern unchanged.
+  acceptsPaste: true,
 };
 
 module.exports = codexAdapter;

package/packages/server/src/agent-adapters/gemini.js

@@ -153,6 +153,9 @@ const geminiAdapter = {
   parseTranscript,
   bootPromptTemplate,
   costBand: 'pay-per-token',
+  // Sprint 47 T3 — Gemini's CLI is paste-friendly per the single-JSON-object
+  // session shape captured in Sprint 45 T2; bracketed-paste injects cleanly.
+  acceptsPaste: true,
 };
 
 module.exports = geminiAdapter;

package/packages/server/src/agent-adapters/grok.js

@@ -53,10 +53,16 @@ const { chooseModel } = require('./grok-models');
 // than false positives (badge flapping or spurious 'errored' status).
 // ──────────────────────────────────────────────────────────────────────────
 
-// Prompt indicator — the TUI's empty-state placeholder. Weak signal but the
-// only stable string that appears reliably in TUI output. Sprint 46 T4 may
-// refine if a more precise marker is observed.
-const PROMPT = /Message Grok[….]/;
+// Prompt indicator — Sprint 45 T3 anchored on the empty-state placeholder
+// "Message Grok…" assuming it was the only stable string in TUI output.
+// That assumption was wrong: the TUI rotates placeholders ("What are we
+// building?", "Bring me a problem", etc.). Sprint 47 orchestrator side-task
+// extends to also match the model-mode footer line ("Grok 4.20 Reasoning",
+// "Grok 4.20 Heavy", "Grok 4.20 Code", "Grok 4.20 Auto", "Grok 4.20
+// Planning") which renders on every frame regardless of which placeholder
+// the TUI surfaced. Version number digits stay open-ended so future Grok
+// versions don't regress detection.
+const PROMPT = /Message Grok[….]|Grok\s+\d+(?:\.\d+)?\s+(?:Reasoning|Heavy|Code|Auto|Planning)/;
 
 // Thinking — Grok's three known "isProcessing" shimmer states. Hits any of
 // the literal labels. The trailing variants on "Generating" / "Answering"
@@ -248,6 +254,12 @@ const grokAdapter = {
   parseTranscript,
   bootPromptTemplate,
   costBand: 'subscription',
+  // Sprint 47 T3 — Grok's Bun+OpenTUI input box hasn't been empirically
+  // pasted-against yet (Sprint 45 T3 prep notes flagged this for verification).
+  // Default to true so the helper uses the bracketed-paste fast path; if a
+  // lane-time test shows the OpenTUI input handler eats the paste markers,
+  // flip this to false and the inject helper falls back to chunked stdin.
+  acceptsPaste: true,
 };
 
 module.exports = grokAdapter;

package/packages/server/src/boot-prompt-resolver.js

@@ -0,0 +1,81 @@
+'use strict';
+
+// Per-agent boot-prompt resolver — Sprint 47 T2.
+//
+// Reads a Mustache-style template from
+// docs/multi-agent-substrate/boot-prompts/boot-prompt-<agent>.md, interpolates
+// {{var.path}} placeholders against the provided `vars` object, and returns
+// the final paste-ready string for the 4+1 inject script.
+//
+// Sprint 47 T3 wires the inject helper to read `lane.agent` from the lane
+// definition and call resolveBootPrompt(agent, vars) per lane — that's how
+// mixed 4+1 (Sprint 48+) gets agent-correct boot prompts when a sprint
+// declares e.g. T1=codex / T2=gemini / T3=grok / T4=claude.
+//
+// Contract:
+//   resolveBootPrompt(agentName, vars) -> string
+//     agentName ∈ {claude, codex, gemini, grok}
+//     vars    : { lane: {tag, project, topic, briefing}, sprint: {n, name, docPath} }
+//   Throws on unknown agent (with the four valid options listed) or any
+//   missing placeholder variable (with the dotted path reported, e.g.
+//   "Missing variable: lane.tag"). No template-engine dependency — hand-rolled
+//   regex interpolation, ~10 LOC. Project is no-build vanilla JS.
+//
+// Pure read-only: re-reads the template file on each call so authors can edit
+// templates without restarting the server. The Sprint-47 templates are <1KB
+// each so the disk hit is negligible.
+
+const fs = require('fs');
+const path = require('path');
+
+const VALID_AGENTS = ['claude', 'codex', 'gemini', 'grok'];
+
+// Resolve template directory relative to this file. __dirname is
+// packages/server/src; the templates live at <repo-root>/docs/multi-agent-substrate/boot-prompts.
+const DEFAULT_TEMPLATE_DIR = path.join(
+  __dirname, '..', '..', '..',
+  'docs', 'multi-agent-substrate', 'boot-prompts'
+);
+
+function _resolveDotted(vars, dotPath) {
+  const parts = dotPath.split('.');
+  let cur = vars;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== 'object' || !Object.prototype.hasOwnProperty.call(cur, p)) {
+      return undefined;
+    }
+    cur = cur[p];
+  }
+  return cur;
+}
+
+function _interpolate(template, vars) {
+  return template.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_match, dotPath) => {
+    const value = _resolveDotted(vars, dotPath);
+    if (value === undefined || value === null) {
+      throw new Error(`Missing variable: ${dotPath}`);
+    }
+    return String(value);
+  });
+}
+
+function resolveBootPrompt(agentName, vars, options) {
+  if (!VALID_AGENTS.includes(agentName)) {
+    throw new Error(
+      `Unknown agent: ${agentName}. Valid agents are: ${VALID_AGENTS.join(', ')}`
+    );
+  }
+  const dir = (options && options.templateDir) || DEFAULT_TEMPLATE_DIR;
+  const filePath = path.join(dir, `boot-prompt-${agentName}.md`);
+  const template = fs.readFileSync(filePath, 'utf8');
+  return _interpolate(template, vars || {});
+}
+
+module.exports = {
+  resolveBootPrompt,
+  VALID_AGENTS,
+  DEFAULT_TEMPLATE_DIR,
+  // Exported for unit tests; not part of the public contract.
+  _interpolate,
+  _resolveDotted,
+};

package/packages/server/src/sprint-frontmatter.js

@@ -0,0 +1,151 @@
+// Sprint 47 T1 — YAML-subset frontmatter parser for sprint PLANNING.md and
+// per-lane briefs, plus a lane→adapter resolver.
+//
+// Convention this lane establishes (Sprint 48+ uses it):
+//   ---
+//   sprint: 48
+//   lanes:
+//     - tag: T1
+//       agent: codex
+//     - tag: T2
+//       agent: gemini
+//   ---
+//
+// Sprint 45/46/47 docs have no frontmatter — `parseFrontmatter` returns `{}`
+// and `getLaneAgent` falls back to the Claude adapter. Forward-only, no
+// rewriting of historical PLANNING.md files. No third-party YAML dependency:
+// hand-rolled subset (top-level scalars + a sequence of string-scalar
+// mappings) keeps the no-build vanilla-JS architecture intact.
+
+const fs = require('fs');
+const { AGENT_ADAPTERS } = require('./agent-adapters');
+
+const VALID_AGENTS = Object.keys(AGENT_ADAPTERS);
+
+function parseFrontmatter(filePath) {
+  const lines = fs.readFileSync(filePath, 'utf8').split(/\r?\n/);
+  if (!lines.length || lines[0].trim() !== '---') return {};
+  let end = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') { end = i; break; }
+  }
+  if (end === -1) {
+    throw new Error(`${filePath}: unclosed frontmatter block (no trailing '---')`);
+  }
+  const result = {};
+  let i = 1;
+  while (i < end) {
+    const line = lines[i];
+    if (line.trim() === '' || line.trim().startsWith('#')) { i++; continue; }
+    if (_indent(line, filePath, i) !== 0) {
+      throw new Error(`${filePath}:${i + 1}: top-level key must start at column 0`);
+    }
+    const colon = line.indexOf(':');
+    if (colon === -1) {
+      throw new Error(`${filePath}:${i + 1}: expected 'key: value' or 'key:'`);
+    }
+    const key = line.slice(0, colon).trim();
+    const rest = line.slice(colon + 1).trim();
+    if (rest !== '') {
+      result[key] = _scalar(rest, filePath, i);
+      i++;
+    } else {
+      const [items, consumed] = _sequence(lines, i + 1, end, filePath);
+      result[key] = items;
+      i = i + 1 + consumed;
+    }
+  }
+  if (Array.isArray(result.lanes)) {
+    for (const lane of result.lanes) {
+      if (lane.agent !== undefined && !VALID_AGENTS.includes(lane.agent)) {
+        throw new Error(
+          `${filePath}: invalid agent '${lane.agent}' on lane ${lane.tag || '(unknown)'}. ` +
+          `Valid: ${VALID_AGENTS.join(', ')}`
+        );
+      }
+    }
+  }
+  return result;
+}
+
+function _sequence(lines, start, end, filePath) {
+  const items = [];
+  let baseIndent = null;
+  let mapIndent = null;
+  let current = null;
+  let i = start;
+  while (i < end) {
+    const line = lines[i];
+    if (line.trim() === '' || line.trim().startsWith('#')) { i++; continue; }
+    const ind = _indent(line, filePath, i);
+    if (baseIndent === null) baseIndent = ind;
+    if (ind < baseIndent) break;
+    const trimmed = line.slice(ind);
+    if (ind === baseIndent && trimmed.startsWith('- ')) {
+      if (current) items.push(current);
+      current = {};
+      mapIndent = ind + 2;
+      const after = trimmed.slice(2);
+      const c = after.indexOf(':');
+      if (c === -1) {
+        throw new Error(`${filePath}:${i + 1}: sequence item must start with 'key: value'`);
+      }
+      current[after.slice(0, c).trim()] = _scalar(after.slice(c + 1).trim(), filePath, i);
+    } else if (ind === mapIndent && current) {
+      const c = line.indexOf(':');
+      if (c === -1) {
+        throw new Error(`${filePath}:${i + 1}: mapping continuation must be 'key: value'`);
+      }
+      current[line.slice(0, c).trim()] = _scalar(line.slice(c + 1).trim(), filePath, i);
+    } else {
+      throw new Error(
+        `${filePath}:${i + 1}: unexpected indentation (got ${ind} spaces; ` +
+        `expected ${baseIndent} for new item or ${mapIndent} for continuation)`
+      );
+    }
+    i++;
+  }
+  if (current) items.push(current);
+  return [items, i - start];
+}
+
+function _scalar(s, filePath, idx) {
+  if (s === '') return null;
+  const q = s[0];
+  if (q === '"' || q === "'") {
+    if (s.length < 2 || s[s.length - 1] !== q) {
+      throw new Error(`${filePath}:${idx + 1}: unclosed quote`);
+    }
+    return s.slice(1, -1);
+  }
+  if (/^-?\d+$/.test(s)) return parseInt(s, 10);
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  return s;
+}
+
+function _indent(line, filePath, idx) {
+  let n = 0;
+  while (n < line.length && line[n] === ' ') n++;
+  if (line[n] === '\t') {
+    throw new Error(`${filePath}:${idx + 1}: tab indentation not supported (use spaces)`);
+  }
+  return n;
+}
+
+function getLaneAgent(briefPath, laneTag) {
+  const fm = parseFrontmatter(briefPath);
+  if (!Array.isArray(fm.lanes)) return AGENT_ADAPTERS.claude;
+  const lane = fm.lanes.find((l) => l.tag === laneTag);
+  if (!lane || !lane.agent) return AGENT_ADAPTERS.claude;
+  const adapter = AGENT_ADAPTERS[lane.agent];
+  if (!adapter) {
+    throw new Error(
+      `sprint-frontmatter: unknown agent '${lane.agent}' for lane ${laneTag} ` +
+      `(valid: ${VALID_AGENTS.join(', ')})`
+    );
+  }
+  return adapter;
+}
+
+module.exports = { parseFrontmatter, getLaneAgent };

package/packages/server/src/sprint-inject.js

@@ -1,8 +1,20 @@
 'use strict';
 
-// Two-stage submit pattern for the in-dashboard 4+1 sprint runner (Sprint 37 T4).
+// Two-stage submit pattern for the in-dashboard 4+1 sprint runner.
 //
-// The cardinal rule from the global 4+1 inject mandate:
+// Sprint 37 T4 baseline: Claude-only, bracketed-paste + lone-CR.
+// Sprint 47 T3 extension: per-lane agent dispatch via the adapter registry.
+//   Each lane may declare an `agent` name (claude/codex/gemini/grok). The
+//   helper looks up the adapter and selects the inject shape:
+//     • acceptsPaste: true  → bracketed-paste payload (`\x1b[200~…\x1b[201~`)
+//                              followed by a lone `\r` after the settle window.
+//     • acceptsPaste: false → chunked stdin fallback (line + `\r` per chunk
+//                              with `chunkedDelayMs` between). Chunked lanes
+//                              self-submit on their last line; the stage-2
+//                              `\r` is skipped for them so we don't fire a
+//                              duplicate empty submit.
+//
+// The cardinal rule from the global 4+1 inject mandate (paste path):
 //
 //   Stage 1: write `\x1b[200~<prompt>\x1b[201~` to each session in turn,
 //            with a small inter-session gap. NO trailing CR.
@@ -23,24 +35,65 @@
 // Pure logic — caller injects writeBytes/getStatus/sleep so tests don't need
 // a live PTY. Wired in by sprint-routes.js.
 
+const { AGENT_ADAPTERS } = require('./agent-adapters');
+
 const DEFAULTS = {
   gapMs: 250,
   settleMs: 400,
   verifyTimeoutMs: 8000,
   verifyPollMs: 500,
   postPokeWaitMs: 500,
+  chunkedDelayMs: 20,
 };
 
-async function injectSprintPrompts({
-  sessionIds,
-  prompts,
-  writeBytes,
-  getStatus,
-  sleep,
-  options,
-}) {
+// Resolve the per-lane inject shape from the adapter registry.
+// Returns a discriminated payload:
+//   { kind: 'paste',   bytes: string }
+//   { kind: 'chunked', lines: string[] }
+// When `agent` is null/undefined or the adapter is absent from the registry,
+// defaults to bracketed-paste (the Sprint 37 baseline). Unknown agent names
+// are not an error here — they just fall through to the bracketed-paste path
+// so a typo in a lane brief degrades to "works for Claude-shaped TUIs"
+// rather than throwing mid-inject. Validation belongs at lane-frontmatter
+// parse time (Sprint 47 T1).
+function buildPayload(prompt, agent, adapters) {
+  const registry = adapters || AGENT_ADAPTERS;
+  const adapter = agent ? registry[agent] : null;
+  const acceptsPaste = adapter ? adapter.acceptsPaste !== false : true;
+  if (acceptsPaste) {
+    return { kind: 'paste', bytes: `\x1b[200~${prompt}\x1b[201~` };
+  }
+  return { kind: 'chunked', lines: prompt.split('\n') };
+}
+
+// Normalize the three accepted input shapes into a single internal lane list.
+//   1. { sessionIds, prompts }                    — Sprint 37 baseline (claude only)
+//   2. { sessionIds, prompts, agents }            — parallel agents array
+//   3. { lanes: [{ sessionId, prompt, agent }] }  — Sprint 47 lanes shape
+function normalizeLanes({ sessionIds, prompts, agents, lanes }) {
+  if (Array.isArray(lanes)) {
+    if (lanes.length === 0) {
+      throw new Error('at least one lane required');
+    }
+    return lanes.map((l, i) => {
+      if (!l || typeof l !== 'object') {
+        throw new Error(`lanes[${i}] must be an object`);
+      }
+      if (typeof l.sessionId !== 'string' || !l.sessionId) {
+        throw new Error(`lanes[${i}].sessionId must be a non-empty string`);
+      }
+      if (typeof l.prompt !== 'string') {
+        throw new Error(`lanes[${i}].prompt must be a string`);
+      }
+      return {
+        sessionId: l.sessionId,
+        prompt: l.prompt,
+        agent: l.agent || null,
+      };
+    });
+  }
   if (!Array.isArray(sessionIds) || !Array.isArray(prompts)) {
-    throw new Error('sessionIds and prompts must be arrays');
+    throw new Error('sessionIds and prompts must be arrays (or pass lanes[])');
   }
   if (sessionIds.length !== prompts.length) {
     throw new Error('sessionIds and prompts must be the same length');
@@ -48,6 +101,28 @@ async function injectSprintPrompts({
   if (sessionIds.length === 0) {
     throw new Error('at least one session required');
   }
+  if (agents !== undefined && agents !== null) {
+    if (!Array.isArray(agents) || agents.length !== sessionIds.length) {
+      throw new Error('agents must be an array of the same length as sessionIds');
+    }
+  }
+  return sessionIds.map((sessionId, i) => ({
+    sessionId,
+    prompt: prompts[i],
+    agent: agents ? agents[i] || null : null,
+  }));
+}
+
+async function injectSprintPrompts({
+  sessionIds,
+  prompts,
+  agents,
+  lanes,
+  writeBytes,
+  getStatus,
+  sleep,
+  options,
+}) {
   if (typeof writeBytes !== 'function') {
     throw new Error('writeBytes(sessionId, bytes) callback required');
   }
@@ -56,10 +131,15 @@ async function injectSprintPrompts({
   }
 
   const opts = { ...DEFAULTS, ...(options || {}) };
+  const registry = (options && options.adapters) || AGENT_ADAPTERS;
 
-  const lanes = sessionIds.map((sessionId, i) => ({
-    sessionId,
-    prompt: prompts[i],
+  const internal = normalizeLanes({ sessionIds, prompts, agents, lanes });
+
+  const enriched = internal.map((l) => ({
+    sessionId: l.sessionId,
+    prompt: l.prompt,
+    agent: l.agent,
+    dispatch: buildPayload(l.prompt, l.agent, registry),
     paste: null,
     submit: null,
     verified: false,
@@ -67,17 +147,48 @@ async function injectSprintPrompts({
     finalStatus: null,
   }));
 
-  // Stage 1: paste-only across all lanes, gapMs between each.
-  for (let i = 0; i < lanes.length; i++) {
-    const lane = lanes[i];
-    const payload = `\x1b[200~${lane.prompt}\x1b[201~`;
-    try {
-      const r = await writeBytes(lane.sessionId, payload);
-      lane.paste = { ok: true, bytes: (r && r.bytes) || payload.length };
-    } catch (err) {
-      lane.paste = { ok: false, error: err && err.message ? err.message : String(err) };
+  // Stage 1: per-lane payload. Paste lanes get one PTY write; chunked lanes
+  // get N writes (one per line) with `chunkedDelayMs` between. `gapMs`
+  // separates lanes from each other so stages stay deterministically ordered.
+  for (let i = 0; i < enriched.length; i++) {
+    const lane = enriched[i];
+    if (lane.dispatch.kind === 'paste') {
+      try {
+        const r = await writeBytes(lane.sessionId, lane.dispatch.bytes);
+        lane.paste = {
+          ok: true,
+          bytes: (r && r.bytes) || lane.dispatch.bytes.length,
+          mode: 'paste',
+        };
+      } catch (err) {
+        lane.paste = {
+          ok: false,
+          error: err && err.message ? err.message : String(err),
+          mode: 'paste',
+        };
+      }
+    } else {
+      // chunked
+      let totalBytes = 0;
+      let firstError = null;
+      for (let j = 0; j < lane.dispatch.lines.length; j++) {
+        const chunk = lane.dispatch.lines[j] + '\r';
+        try {
+          const r = await writeBytes(lane.sessionId, chunk);
+          totalBytes += (r && r.bytes) || chunk.length;
+        } catch (err) {
+          firstError = err && err.message ? err.message : String(err);
+          break;
+        }
+        if (j < lane.dispatch.lines.length - 1) {
+          await sleep(opts.chunkedDelayMs);
+        }
+      }
+      lane.paste = firstError
+        ? { ok: false, error: firstError, mode: 'chunked' }
+        : { ok: true, bytes: totalBytes, mode: 'chunked' };
     }
-    if (i < lanes.length - 1) await sleep(opts.gapMs);
+    if (i < enriched.length - 1) await sleep(opts.gapMs);
   }
 
   // Settle window — long enough for the PTY to flush each paste to the TUI's
@@ -85,19 +196,25 @@ async function injectSprintPrompts({
   await sleep(opts.settleMs);
 
   // Stage 2: submit-only (\r alone, guaranteed its own PTY write).
-  for (let i = 0; i < lanes.length; i++) {
-    const lane = lanes[i];
+  // Chunked-mode lanes already self-submitted on their last line — skip.
+  for (let i = 0; i < enriched.length; i++) {
+    const lane = enriched[i];
     if (!lane.paste || !lane.paste.ok) {
       lane.submit = { ok: false, skipped: 'paste-failed' };
       continue;
     }
+    if (lane.paste.mode === 'chunked') {
+      lane.submit = { ok: true, bytes: 0, skipped: 'chunked-already-submitted' };
+      if (i < enriched.length - 1) await sleep(opts.gapMs);
+      continue;
+    }
     try {
       const r = await writeBytes(lane.sessionId, '\r');
       lane.submit = { ok: true, bytes: (r && r.bytes) || 1 };
     } catch (err) {
       lane.submit = { ok: false, error: err && err.message ? err.message : String(err) };
     }
-    if (i < lanes.length - 1) await sleep(opts.gapMs);
+    if (i < enriched.length - 1) await sleep(opts.gapMs);
   }
 
   // Verify: poll each lane's status until it reads `thinking` or we hit the
@@ -106,7 +223,7 @@ async function injectSprintPrompts({
     const deadline = Date.now() + opts.verifyTimeoutMs;
     while (Date.now() < deadline) {
       let anyPending = false;
-      for (const lane of lanes) {
+      for (const lane of enriched) {
         if (lane.verified) continue;
         try {
           const s = await getStatus(lane.sessionId);
@@ -126,7 +243,7 @@ async function injectSprintPrompts({
 
     // Auto-poke (cr-flood) any lane that didn't reach `thinking`. Best-effort —
     // never page the user; the orchestrator dashboard surfaces the result.
-    for (const lane of lanes) {
+    for (const lane of enriched) {
       if (lane.verified) continue;
       try {
         await writeBytes(lane.sessionId, '\r\r\r');
@@ -146,11 +263,13 @@ async function injectSprintPrompts({
     }
   }
 
-  const ok = lanes.every((l) => l.paste && l.paste.ok && l.submit && l.submit.ok);
-  return { ok, lanes };
+  const ok = enriched.every((l) => l.paste && l.paste.ok && l.submit && l.submit.ok);
+  return { ok, lanes: enriched };
 }
 
 module.exports = {
   injectSprintPrompts,
+  buildPayload,
+  normalizeLanes,
   DEFAULTS,
 };

package/packages/server/src/status-merger.js

@@ -0,0 +1,141 @@
+'use strict';
+
+// Sprint 47 T4 — Cross-agent STATUS.md merger.
+//
+// Each lane agent (Claude / Codex / Gemini / Grok) posts FINDING /
+// FIX-PROPOSED / DONE differently. Claude has the canonical shape nailed:
+//   `- Tn: STAGE — one-line summary — YYYY-MM-DD HH:MM ET`
+// The others may emit emoji prefixes, generic bullet lists, or free-form
+// prose. mergeStatusLine() takes a raw line in any of those shapes and
+// returns the canonical form, so the dashboard's STATUS.md regex parser and
+// human readers see one consistent shape regardless of CLI.
+//
+// Sprint 47 ships this as infrastructure. Sprint 48 (or whenever the mixed
+// 4+1 dogfood lands) is when it actually runs over real cross-agent posts.
+
+const STAGES = new Set(['FINDING', 'FIX-PROPOSED', 'DONE']);
+
+// Codex idiom: emoji prefix, optionally followed by `Found:`/`Fixed:`/etc.
+// 🛠️ (with VS-16) and 🛠 (without) both round to FIX-PROPOSED — terminals
+// disagree about the variation selector and we don't care which one came in.
+const EMOJI_STAGES = [
+  ['🛠️', 'FIX-PROPOSED'],
+  ['🛠', 'FIX-PROPOSED'],
+  ['🔍', 'FINDING'],
+  ['✅', 'DONE'],
+  ['🔧', 'FIX-PROPOSED'],
+];
+const EMOJI_LEADIN_RE = /^(?:Found|Fixed|Proposed|Proposing|Note|Status)\s*[:—\-]?\s*/i;
+
+// Gemini idiom: bullet-pointed list with stage keyword.
+const BULLET_FINDING_RE = /^[-*]\s+(?:found(?:\s+that)?|finding|noticed|observation)\s*[:—\-]?\s*(.+)$/i;
+const BULLET_FIX_RE = /^[-*]\s+(?:propos(?:ing|ed)\s+fix(?:ing)?|fix[\s-]proposed|proposed\s+fix)\s*[:—\-]?\s*(.+)$/i;
+const BULLET_DONE_RE = /^[-*]\s+(?:done|completed|finished|shipped)\s*[:—\-]?\s*(.+)$/i;
+
+// Grok idiom: free-form first-person prose.
+const PROSE_DONE_RE = /^(?:Done|Completed|Finished|Shipped)\s*[:—\-]?\s*(.+)$/i;
+const PROSE_FIX_RE = /^(?:I'?ll\s+fix|I\s+will\s+fix|I'?m\s+fixing|Fixing|Proposing\s+(?:a\s+)?fix|Proposed\s+fix)\b\s*(?:this\s+by\s+|by\s+|[:—\-]\s*)?(.+)$/i;
+const PROSE_FINDING_RE = /^(?:I\s+noticed|I\s+observed|I\s+found|I\s+saw|Noticed|Observed)\b\s*(?:that\s+)?(.+)$/i;
+
+// Canonical Claude — timestamped. Greedy backtracking: we anchor the
+// timestamp to a YYYY-MM-DD prefix so bodies that contain stray ` — ` (very
+// common in real Sprint 46 lines) split at the right boundary.
+const CANONICAL_TS_RE =
+  /^[-*]?\s*(T\d+):\s*(FINDING|FIX-PROPOSED|DONE)\s+[—\-]\s+(.+?)\s+[—\-]\s+(\d{4}-\d{2}-\d{2}\b.*)$/;
+// Canonical Claude without a trailing timestamp — we'll add one.
+const CANONICAL_NO_TS_RE =
+  /^[-*]?\s*(T\d+):\s*(FINDING|FIX-PROPOSED|DONE)\s+[—\-]\s+(.+)$/;
+
+// Markdown section header — never a status line.
+const HEADER_RE = /^#{1,6}\s/;
+// Bare bracket-like meta lines: `_(no entries yet)_`, `> note`, etc.
+const META_RE = /^[_>(]/;
+
+const SUMMARY_MAX = 120;
+
+function trimSummary(s) {
+  s = String(s).trim().replace(/\s+/g, ' ');
+  if (s.length > SUMMARY_MAX) {
+    s = s.slice(0, SUMMARY_MAX - 1).replace(/\s+\S*$/, '') + '…';
+  }
+  return s;
+}
+
+function pad2(n) {
+  return String(n).padStart(2, '0');
+}
+
+// Matches the real STATUS.md convention `YYYY-MM-DD HH:MM ET`. The ET tag is
+// decorative (Joshua's tz); we don't try to convert from UTC because the
+// surrounding harness already runs in his local clock.
+function formatTimestamp(date) {
+  return (
+    `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}` +
+    ` ${pad2(date.getHours())}:${pad2(date.getMinutes())} ET`
+  );
+}
+
+function detectEmojiStage(text) {
+  for (const [emoji, stage] of EMOJI_STAGES) {
+    if (text.startsWith(emoji)) {
+      const after = text.slice(emoji.length).replace(/^[\s️]+/, '');
+      return { stage, summary: after.replace(EMOJI_LEADIN_RE, '') };
+    }
+  }
+  return null;
+}
+
+function detectBulletStage(text) {
+  let m;
+  if ((m = BULLET_FINDING_RE.exec(text))) return { stage: 'FINDING', summary: m[1] };
+  if ((m = BULLET_FIX_RE.exec(text))) return { stage: 'FIX-PROPOSED', summary: m[1] };
+  if ((m = BULLET_DONE_RE.exec(text))) return { stage: 'DONE', summary: m[1] };
+  return null;
+}
+
+function detectProseStage(text) {
+  let m;
+  // Order matters: PROSE_DONE before PROSE_FIX before PROSE_FINDING because
+  // "Done: foo" would otherwise also match nothing later, and "I'll fix" is
+  // distinct from "I noticed" so order between them is safe.
+  if ((m = PROSE_DONE_RE.exec(text))) return { stage: 'DONE', summary: m[1] };
+  if ((m = PROSE_FIX_RE.exec(text))) return { stage: 'FIX-PROPOSED', summary: m[1] };
+  if ((m = PROSE_FINDING_RE.exec(text))) return { stage: 'FINDING', summary: m[1] };
+  return null;
+}
+
+function mergeStatusLine(rawLine, opts = {}) {
+  if (typeof rawLine !== 'string') return null;
+  const line = rawLine.replace(/\r?\n$/, '').trim();
+  if (!line) return null;
+  if (HEADER_RE.test(line)) return null;
+  if (META_RE.test(line)) return null;
+
+  // 1. Canonical with timestamp — pass through unchanged, normalize only the
+  // leading bullet. The body is never trimmed here: real Sprint 46 lines are
+  // routinely well over 120 chars and the brief mandates "same line out".
+  let m = CANONICAL_TS_RE.exec(line);
+  if (m) {
+    const [, tag, stage, summary, ts] = m;
+    return `- ${tag}: ${stage} — ${summary.trim()} — ${ts.trim()}`;
+  }
+  // 2. Canonical without timestamp — synthesize one. Body still untrimmed:
+  // the author wrote a canonical-shape line, we trust its length.
+  m = CANONICAL_NO_TS_RE.exec(line);
+  if (m) {
+    const [, tag, stage, summary] = m;
+    const ts = formatTimestamp(opts.now || new Date());
+    return `- ${tag}: ${stage} — ${summary.trim()} — ${ts}`;
+  }
+
+  // 3. Variant idioms — emoji, bullet, prose.
+  const detected =
+    detectEmojiStage(line) || detectBulletStage(line) || detectProseStage(line);
+  if (!detected || !STAGES.has(detected.stage)) return null;
+
+  const tag = opts.laneTag || 'T?';
+  const ts = formatTimestamp(opts.now || new Date());
+  return `- ${tag}: ${detected.stage} — ${trimSummary(detected.summary)} — ${ts}`;
+}
+
+module.exports = { mergeStatusLine };