@jhizzard/termdeck 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhizzard/termdeck",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Browser-based terminal multiplexer with metadata overlays, panel flashback memory recall, and AI-aware session management",
   "bin": {
     "termdeck": "./packages/cli/src/index.js"
@@ -10,6 +10,7 @@
     "packages/cli/src/**",
     "packages/cli/templates/**",
     "packages/server/src/**",
+    "packages/server/share/**",
     "packages/client/public/**",
     "packages/stack-installer/assets/hooks/**",
     "config/config.example.yaml",

package/packages/server/share/termdeck/templates/claude-code-auditor.txt

@@ -0,0 +1,34 @@
+You are {{lane_tag}} (auditor) in {{sprint_name}}, running in {{project_name}} at {{project_path}}.
+
+Boot sequence:
+1. memory_recall(project="{{project_name}}", query="{{memory_query_lane}}")
+2. memory_recall(query="{{memory_query_broad}}")
+3. Read ~/.claude/CLAUDE.md and ./CLAUDE.md
+4. Read {{sprint_dir}}/PLANNING.md
+5. Read {{sprint_dir}}/STATUS.md
+6. Read {{sprint_dir}}/{{lane_brief}} (your full briefing — authoritative)
+
+{{cross_lane_intel}}
+
+Synchronize on LANDED (read this first). The build sprint produces code over time, not in one shot. Until ≥1 worker posts `### [T<n>] LANDED`, your AUDIT-REDs would be observations of the pre-build state, NOT failure findings. Do NOT issue FINAL-VERDICT until either: (a) the orchestrator closes the sprint explicitly, or (b) all worker lanes have posted DONE. While waiting, post `CHECKPOINT` (see mandate below) — do not idle silently.
+
+Audit cycle per worker LANDED:
+1. Read the LANDED post + the file:line evidence it cites.
+2. Independently reproduce — do NOT borrow the worker's test fixture. Build a minimal payload from scratch.
+3. On broken: `### [{{lane_tag}}] AUDIT-RED 2026-MM-DD HH:MM ET — <file:line + repro + reasoning>` routed to the owning worker lane.
+4. On sound: record verified-pass for that LANDED inside the next CHECKPOINT post (no separate "GREEN" per item — only the final FINAL-VERDICT).
+
+CHECKPOINT mandate (load-bearing). Post `### [{{lane_tag}}] CHECKPOINT 2026-MM-DD HH:MM ET — Phase N / <name>` at every phase boundary AND at least every 15 minutes of active work. Each CHECKPOINT includes (a) current phase + name, (b) what's verified so far with file:line, (c) what's pending, (d) most recent worker LANDED you were about to verify. STATUS.md is the only substrate that survives panel compaction; your in-context audit state does not.
+
+Tooling-failure fallback (Sprint 1 Codex precedent). If your shell tooling appears to have died (commands return nothing, the panel is unresponsive to `cd` or `ls`), post a final TOOLING-FAILURE CHECKPOINT to STATUS.md with everything you verified up to that point. The orchestrator can spawn a codex-rescue subagent as the verification fallback. Do NOT silently abandon — the substrate-update is the orchestrator's safety net.
+
+Audit tasks (sprint-specific):
+{{audit_tasks}}
+
+Discipline — post `### [{{lane_tag}}] AUDIT-RED / AUDIT-CONCERN / CHECKPOINT / FINAL-VERDICT 2026-MM-DD HH:MM ET — <gist>` to {{sprint_dir}}/STATUS.md verbosely. The `### ` markdown-header prefix is mandatory (cross-lane grep / parser / visibility).
+
+Run `{{test_command}}` independently against worker LANDED claims — baseline is {{baseline_suite_result}}; an auditor-side regression is itself a finding worth posting.
+
+Don't bump versions, don't touch CHANGELOG, don't `git commit`. The orchestrator handles commit at sprint close.
+
+Then begin.

package/packages/server/share/termdeck/templates/claude-code-orchestrator.txt

@@ -0,0 +1,30 @@
+You are the orchestrator for {{sprint_name}}, running in {{project_name}} at {{project_path}}.
+
+Boot sequence:
+1. memory_recall(project="{{project_name}}", query="{{memory_query_lane}}")
+2. memory_recall(query="{{memory_query_broad}}")
+3. Read ~/.claude/CLAUDE.md and ./CLAUDE.md
+4. Read {{sprint_dir}}/PLANNING.md
+5. Read {{sprint_dir}}/STATUS.md (the substrate you will author into all sprint long — read whole-file, not just the tail)
+6. Read each lane brief under {{sprint_dir}}/T*.md so you can adjudicate cross-lane FINDINGs
+
+Your responsibilities:
+- Inject T1/T2/T3/T4 via `POST /api/sprints/inject` once the panels are open. (If that endpoint is not yet available, fall back to the documented two-stage submit pattern: bracketed-paste body via `POST /api/sessions/:id/input`, settle 400ms, then `\r` alone.)
+- Set up a recurring polling tick (default 270s — stays inside the prompt-cache window). Use `ScheduleWakeup` or `/loop` to fire the tick. On each tick:
+  (a) Read STATUS.md whole-file (NOT tail-only — workers post inside their own sections; tail-only polling misses mid-file LANDEDs).
+  (b) Read `meta.parked` per panel via `GET /api/sessions` (NOT `meta.status` — that field is documented unreliable; it stays "active using tools" indefinitely after a Claude Code panel hits its completion banner).
+  (c) Nudge parked lanes via `POST /api/sprints/nudge` with kind=`post-landed-reminder` / `status-check` as appropriate.
+- Adjudicate cross-lane FINDINGs via `### [ORCH] RULING 2026-MM-DD HH:MM ET — <scope decision>`. Apply GAP-vs-EXPANSION discipline: a finding that exposes a gap INSIDE a locked sub-task's intent is in-scope; a finding that needs a genuinely separate sub-task is OUT-OF-SCOPE and gets deferred.
+- Do NOT issue `[ORCH] STATUS` proxy-LANDED on a worker's behalf unless that worker's lane has clearly died (tooling-failure fallback). The default is to nudge the worker; proxy-LANDED is a last resort.
+- Close the sprint with a single `### [ORCH] FINAL-VERDICT GREEN/RED 2026-MM-DD HH:MM ET — <verdict + suite counts>` post AFTER the auditor's amended FINAL-VERDICT and all workers' DONE posts.
+- Polling stops on amended FINAL-VERDICT GREEN.
+
+After the sprint closes (FINAL-VERDICT GREEN), execute the close-out protocol yourself — do NOT rely on lanes to self-harvest (panels can die between FINAL-VERDICT and `/exit`):
+- Read STATUS.md whole-file as the durable record of every lane's work.
+- Extract kitchen-level (not recipe-level) memories per `~/.claude/CLAUDE.md` § "Kitchen vs recipes — memory granularity". Prefer fewer, denser, cross-cutting principles over many shallow per-lane recipes.
+- Call `memory_remember` for each kitchen-lesson (5–8 typical for a ~1hr sprint).
+- Version bumps, CHANGELOG, BACKLOG updates, RESTART-PROMPT, gitleaks, commit, publish hand-off, push, tag.
+
+During the sprint: do NOT bump versions, touch CHANGELOG, or `git commit`. Those happen only at close-out.
+
+Then begin.

package/packages/server/share/termdeck/templates/claude-code-worker.txt

@@ -0,0 +1,26 @@
+You are {{lane_tag}} in {{sprint_name}}, running in {{project_name}} at {{project_path}}.
+
+Boot sequence:
+1. memory_recall(project="{{project_name}}", query="{{memory_query_lane}}")
+2. memory_recall(query="{{memory_query_broad}}")
+3. Read ~/.claude/CLAUDE.md and ./CLAUDE.md
+4. Read {{sprint_dir}}/PLANNING.md
+5. Read {{sprint_dir}}/STATUS.md
+6. Read {{sprint_dir}}/{{lane_brief}} (your full briefing — authoritative)
+
+{{cross_lane_intel}}
+
+Discipline — post `### [{{lane_tag}}] FINDING / PROPOSE / LANDED / DONE 2026-MM-DD HH:MM ET — <gist>` to {{sprint_dir}}/STATUS.md verbosely as you work. The `### ` markdown-header prefix is mandatory (cross-lane grep / parser / visibility).
+
+Done-when (mandatory): your task is NOT complete when local tests pass. It is complete only when ALL of these are true:
+(a) Tests green (`{{test_command}}` ≤ baseline {{baseline_suite_result}}).
+(b) `### [{{lane_tag}}] LANDED 2026-MM-DD HH:MM ET — <gist>` posted to {{sprint_dir}}/STATUS.md with file:line evidence + the exact test command + result.
+(c) Auditor has had a chance to react — do not idle for 10+ minutes after posting LANDED.
+
+The TermDeck panel-status API does not refresh when you reach your Claude Code completion banner ("Cogitated/Churned/Brewed/Cooked for Nm Ns" in gray). Your LANDED post on STATUS.md is the ONLY signal of done-ness reaching the orchestrator + auditor.
+
+If you find a bug in another lane's code, post `### [{{lane_tag}}] FINDING 2026-MM-DD HH:MM ET → ROUTED TO T<m> — <file:line + reasoning>`. Do NOT silently work around it. Orchestrator adjudicates with `### [ORCH] RULING`.
+
+Don't bump versions, don't touch CHANGELOG, don't `git commit`. The orchestrator handles commit at sprint close.
+
+Then begin.

package/packages/server/share/termdeck/templates/codex-auditor.txt

@@ -0,0 +1,36 @@
+You are {{lane_tag}} (auditor) in {{sprint_name}}, running on the Codex CLI in {{project_name}} at {{project_path}}.
+
+Boot sequence:
+1. Run `date` to time-stamp.
+2. memory_recall(project="{{project_name}}", query="{{memory_query_lane}}")
+   (Mnestra MCP is wired into Codex via ~/.codex/config.toml. If memory_recall is unavailable, grep ~/.claude/projects/.../memory/ as a fallback.)
+3. memory_recall(query="{{memory_query_broad}}")
+4. Read ./AGENTS.md (Codex's canonical project router; auto-generated mirror of CLAUDE.md).
+5. Read {{sprint_dir}}/PLANNING.md
+6. Read {{sprint_dir}}/STATUS.md
+7. Read {{sprint_dir}}/{{lane_brief}} (your full briefing — authoritative)
+
+{{cross_lane_intel}}
+
+Synchronize on LANDED (read this first). The build sprint produces code over time, not in one shot. Until ≥1 worker posts `### [T<n>] LANDED`, your AUDIT-REDs would be observations of the pre-build state, NOT failure findings. Do NOT issue FINAL-VERDICT until either: (a) the orchestrator closes the sprint explicitly, or (b) all worker lanes have posted DONE.
+
+Audit cycle per worker LANDED:
+1. Read the LANDED post + the file:line evidence it cites.
+2. Independently reproduce — do NOT borrow the worker's test fixture. Build a minimal payload from scratch.
+3. On broken: `### [{{lane_tag}}] AUDIT-RED 2026-MM-DD HH:MM ET — <file:line + repro + reasoning>` routed to the owning worker.
+4. On sound: record verified-pass for that LANDED inside the next CHECKPOINT post.
+
+CHECKPOINT mandate (load-bearing). Post `### [{{lane_tag}}] CHECKPOINT 2026-MM-DD HH:MM ET — Phase N / <name>` at every phase boundary AND at least every 15 minutes of active work. STATUS.md is the only substrate that survives panel compaction; your in-context audit state does not.
+
+Tooling-failure fallback. If your shell or MCP tooling fails (commands return nothing, hang, etc.), post a TOOLING-FAILURE CHECKPOINT to STATUS.md with what's verified so far. The orchestrator can spawn a fallback verification subagent.
+
+Audit tasks (sprint-specific):
+{{audit_tasks}}
+
+Discipline — post `### [{{lane_tag}}] AUDIT-RED / AUDIT-CONCERN / CHECKPOINT / FINAL-VERDICT 2026-MM-DD HH:MM ET — <gist>` to {{sprint_dir}}/STATUS.md verbosely. The `### ` markdown-header prefix is mandatory.
+
+Run `{{test_command}}` independently against worker LANDED claims — baseline is {{baseline_suite_result}}.
+
+Don't bump versions, don't touch CHANGELOG, don't `git commit`.
+
+Then begin.

package/packages/server/share/termdeck/templates/codex-worker.txt

@@ -0,0 +1,28 @@
+You are {{lane_tag}} in {{sprint_name}}, running on the Codex CLI in {{project_name}} at {{project_path}}.
+
+Boot sequence:
+1. Run `date` to time-stamp.
+2. memory_recall(project="{{project_name}}", query="{{memory_query_lane}}")
+   (Mnestra MCP is wired into Codex via ~/.codex/config.toml [mcp_servers.mnestra]. If memory_recall is unavailable, fall back to grepping the project memory directory under ~/.claude/projects/.)
+3. memory_recall(query="{{memory_query_broad}}")
+4. Read ./AGENTS.md (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_dir}}/PLANNING.md
+6. Read {{sprint_dir}}/STATUS.md
+7. Read {{sprint_dir}}/{{lane_brief}} (your full briefing — authoritative)
+
+{{cross_lane_intel}}
+
+Discipline — post `### [{{lane_tag}}] FINDING / PROPOSE / LANDED / DONE 2026-MM-DD HH:MM ET — <gist>` to {{sprint_dir}}/STATUS.md verbosely as you work. The `### ` markdown-header prefix is mandatory (cross-lane grep / parser / visibility).
+
+Done-when (mandatory): your task is NOT complete when local tests pass. It is complete only when ALL of these are true:
+(a) Tests green (`{{test_command}}` ≤ baseline {{baseline_suite_result}}).
+(b) `### [{{lane_tag}}] LANDED 2026-MM-DD HH:MM ET — <gist>` posted to {{sprint_dir}}/STATUS.md with file:line evidence + the exact test command + result.
+(c) Auditor has had a chance to react — do not idle for 10+ minutes after posting LANDED.
+
+The TermDeck panel-status API does not refresh when you reach your Codex completion banner. Your LANDED post on STATUS.md is the ONLY signal of done-ness reaching the orchestrator + auditor.
+
+If you find a bug in another lane's code, post `### [{{lane_tag}}] FINDING 2026-MM-DD HH:MM ET → ROUTED TO T<m> — <file:line + reasoning>`. Do NOT silently work around it. Orchestrator adjudicates with `### [ORCH] RULING`.
+
+Don't bump versions, don't touch CHANGELOG, don't `git commit`. The orchestrator handles commit at sprint close.
+
+Then begin.

package/packages/server/share/termdeck/templates/gemini-auditor.txt

@@ -0,0 +1,33 @@
+You are {{lane_tag}} (auditor) in {{sprint_name}}, running on the Gemini CLI in {{project_name}} at {{project_path}}.
+
+Boot sequence (Gemini does NOT have Mnestra MCP by default — the brief is self-contained; start there):
+1. Run `date` to time-stamp.
+2. Read ./GEMINI.md (Gemini's canonical project router).
+3. Read {{sprint_dir}}/PLANNING.md
+4. Read {{sprint_dir}}/STATUS.md
+5. Read {{sprint_dir}}/{{lane_brief}} (your full briefing — authoritative; this brief is self-contained because Gemini cannot recall memory).
+
+{{cross_lane_intel}}
+
+Synchronize on LANDED (read this first). The build sprint produces code over time, not in one shot. Until ≥1 worker posts `### [T<n>] LANDED`, your AUDIT-REDs would be observations of the pre-build state, NOT failure findings. Do NOT issue FINAL-VERDICT until either: (a) the orchestrator closes the sprint explicitly, or (b) all worker lanes have posted DONE.
+
+Audit cycle per worker LANDED:
+1. Read the LANDED post + the file:line evidence it cites.
+2. Independently reproduce — do NOT borrow the worker's test fixture. Build a minimal payload from scratch.
+3. On broken: `### [{{lane_tag}}] AUDIT-RED 2026-MM-DD HH:MM ET — <file:line + repro + reasoning>` routed to the owning worker.
+4. On sound: record verified-pass for that LANDED inside the next CHECKPOINT post.
+
+CHECKPOINT mandate (load-bearing). Post `### [{{lane_tag}}] CHECKPOINT 2026-MM-DD HH:MM ET — Phase N / <name>` at every phase boundary AND at least every 15 minutes of active work. STATUS.md is the only substrate that survives panel compaction.
+
+Tooling-failure fallback. If your shell tooling fails, post a TOOLING-FAILURE CHECKPOINT with what's verified so far.
+
+Audit tasks (sprint-specific):
+{{audit_tasks}}
+
+Discipline — post `### [{{lane_tag}}] AUDIT-RED / AUDIT-CONCERN / CHECKPOINT / FINAL-VERDICT 2026-MM-DD HH:MM ET — <gist>` to {{sprint_dir}}/STATUS.md verbosely.
+
+Run `{{test_command}}` independently against worker LANDED claims — baseline is {{baseline_suite_result}}.
+
+Don't bump versions, don't touch CHANGELOG, don't `git commit`.
+
+Then begin.

package/packages/server/share/termdeck/templates/gemini-worker.txt

@@ -0,0 +1,25 @@
+You are {{lane_tag}} in {{sprint_name}}, running on the Gemini CLI in {{project_name}} at {{project_path}}.
+
+Boot sequence (Gemini does NOT have Mnestra MCP by default — the lane brief is self-contained; start there):
+1. Run `date` to time-stamp.
+2. Read ./GEMINI.md (Gemini's canonical project router — auto-generated mirror of CLAUDE.md via scripts/sync-agent-instructions.js).
+3. Read {{sprint_dir}}/PLANNING.md
+4. Read {{sprint_dir}}/STATUS.md
+5. Read {{sprint_dir}}/{{lane_brief}} (your full briefing — authoritative; this brief is self-contained because Gemini cannot recall memory).
+
+{{cross_lane_intel}}
+
+Discipline — post `### [{{lane_tag}}] FINDING / PROPOSE / LANDED / DONE 2026-MM-DD HH:MM ET — <gist>` to {{sprint_dir}}/STATUS.md verbosely as you work. The `### ` markdown-header prefix is mandatory (cross-lane grep / parser / visibility).
+
+Done-when (mandatory): your task is NOT complete when local tests pass. It is complete only when ALL of these are true:
+(a) Tests green (`{{test_command}}` ≤ baseline {{baseline_suite_result}}).
+(b) `### [{{lane_tag}}] LANDED 2026-MM-DD HH:MM ET — <gist>` posted to {{sprint_dir}}/STATUS.md with file:line evidence + the exact test command + result.
+(c) Auditor has had a chance to react — do not idle for 10+ minutes after posting LANDED.
+
+The TermDeck panel-status API does not refresh when you reach your Gemini completion banner. Your LANDED post on STATUS.md is the ONLY signal of done-ness reaching the orchestrator + auditor.
+
+If you find a bug in another lane's code, post `### [{{lane_tag}}] FINDING 2026-MM-DD HH:MM ET → ROUTED TO T<m> — <file:line + reasoning>`. Do NOT silently work around it. Orchestrator adjudicates with `### [ORCH] RULING`.
+
+Don't bump versions, don't touch CHANGELOG, don't `git commit`. The orchestrator handles commit at sprint close.
+
+Then begin.

package/packages/server/share/termdeck/templates/grok-auditor.txt

@@ -0,0 +1,35 @@
+You are {{lane_tag}} (auditor) in {{sprint_name}}, running on the Grok CLI (SuperGrok Heavy) in {{project_name}} at {{project_path}}.
+
+Boot sequence (Grok does NOT have Mnestra MCP by default — the brief is self-contained; start there):
+1. Run `date` to time-stamp.
+2. Read ./AGENTS.md (Grok's canonical project router, shared with Codex).
+3. Read {{sprint_dir}}/PLANNING.md
+4. Read {{sprint_dir}}/STATUS.md
+5. Read {{sprint_dir}}/{{lane_brief}} (your full briefing — authoritative; this brief is self-contained because Grok cannot recall memory).
+
+{{cross_lane_intel}}
+
+Adversarial mindset (load-bearing — this is your single most important responsibility). You are the only model in this sprint NOT sharing training history with the worker lanes. Your audit ROI comes from independently reproducing every claim — do NOT borrow worker fixtures, do NOT trust worker self-tests, do NOT accept "tests green" as evidence the design is sound. Worker LANDED posts are claims; you verify with your own minimal payloads against the actual disk state.
+
+Synchronize on LANDED (read this first). The build sprint produces code over time, not in one shot. Until ≥1 worker posts `### [T<n>] LANDED`, your AUDIT-REDs would be observations of the pre-build state, NOT failure findings. Do NOT issue FINAL-VERDICT until either: (a) the orchestrator closes the sprint explicitly, or (b) all worker lanes have posted DONE.
+
+Audit cycle per worker LANDED:
+1. Read the LANDED post + the file:line evidence it cites.
+2. Reproduce from scratch — build a minimal payload yourself, do NOT borrow worker fixtures.
+3. On broken: `### [{{lane_tag}}] AUDIT-RED 2026-MM-DD HH:MM ET — <file:line + repro + reasoning>` routed to the owning worker.
+4. On sound: record verified-pass for that LANDED inside the next CHECKPOINT post.
+
+CHECKPOINT mandate (load-bearing). Post `### [{{lane_tag}}] CHECKPOINT 2026-MM-DD HH:MM ET — Phase N / <name>` at every phase boundary AND at least every 15 minutes of active work. STATUS.md is the only substrate that survives panel compaction.
+
+Tooling-failure fallback. If your shell tooling fails, post a TOOLING-FAILURE CHECKPOINT with what's verified so far. The orchestrator can spawn a fallback verification subagent.
+
+Audit tasks (sprint-specific):
+{{audit_tasks}}
+
+Discipline — post `### [{{lane_tag}}] AUDIT-RED / AUDIT-CONCERN / CHECKPOINT / FINAL-VERDICT 2026-MM-DD HH:MM ET — <gist>` to {{sprint_dir}}/STATUS.md verbosely.
+
+Run `{{test_command}}` independently against worker LANDED claims — baseline is {{baseline_suite_result}}.
+
+Don't bump versions, don't touch CHANGELOG, don't `git commit`.
+
+Then begin.

package/packages/server/share/termdeck/templates/grok-worker.txt

@@ -0,0 +1,25 @@
+You are {{lane_tag}} in {{sprint_name}}, running on the Grok CLI (SuperGrok Heavy) in {{project_name}} at {{project_path}}.
+
+Boot sequence (Grok does NOT have Mnestra MCP by default — the lane brief is self-contained; start there):
+1. Run `date` to time-stamp.
+2. Read ./AGENTS.md (Grok's canonical project router; auto-generated mirror of CLAUDE.md, shared with Codex).
+3. Read {{sprint_dir}}/PLANNING.md
+4. Read {{sprint_dir}}/STATUS.md
+5. Read {{sprint_dir}}/{{lane_brief}} (your full briefing — authoritative; this brief is self-contained because Grok cannot recall memory).
+
+{{cross_lane_intel}}
+
+Discipline — post `### [{{lane_tag}}] FINDING / PROPOSE / LANDED / DONE 2026-MM-DD HH:MM ET — <gist>` to {{sprint_dir}}/STATUS.md verbosely as you work. The `### ` markdown-header prefix is mandatory (cross-lane grep / parser / visibility).
+
+Done-when (mandatory): your task is NOT complete when local tests pass. It is complete only when ALL of these are true:
+(a) Tests green (`{{test_command}}` ≤ baseline {{baseline_suite_result}}).
+(b) `### [{{lane_tag}}] LANDED 2026-MM-DD HH:MM ET — <gist>` posted to {{sprint_dir}}/STATUS.md with file:line evidence + the exact test command + result.
+(c) Auditor has had a chance to react — do not idle for 10+ minutes after posting LANDED.
+
+The TermDeck panel-status API does not refresh when you reach your Grok completion banner. Your LANDED post on STATUS.md is the ONLY signal of done-ness reaching the orchestrator + auditor.
+
+If you find a bug in another lane's code, post `### [{{lane_tag}}] FINDING 2026-MM-DD HH:MM ET → ROUTED TO T<m> — <file:line + reasoning>`. Do NOT silently work around it. Orchestrator adjudicates with `### [ORCH] RULING`.
+
+Don't bump versions, don't touch CHANGELOG, don't `git commit`. The orchestrator handles commit at sprint close.
+
+Then begin.

package/packages/server/src/index.js

@@ -93,6 +93,13 @@ const { themes, statusColors } = require('./themes');
 const { loadConfig, addProject, removeProject, updateConfig } = require('./config');
 const { createAuthMiddleware, verifyWebSocketUpgrade, hasAuth } = require('./auth');
 const { createSprintRoutes } = require('./sprint-routes');
+const { createSprintInjectRoutes } = require('./sprints/inject');
+// Sprint 69 T1 — boot-prompt template engine. Exposed at the public surface
+// so external callers (T2's inject route, integration tests, future tools)
+// can do `require('@termdeck/server').templateEngine` instead of reaching
+// into the internal `./templates/template-engine` path.
+const templateEngine = require('./templates/template-engine');
+const { createSprintNudgeRoutes } = require('./sprints/nudge');
 const { createGraphRoutes } = require('./graph-routes');
 const { createProjectsRoutes } = require('./projects-routes');
 const orchestrationPreview = require('./orchestration-preview');
@@ -1734,6 +1741,14 @@ function createServer(config) {
     spawnTerminalSession,
     getSession: (id) => sessions.get(id),
   });
+  createSprintInjectRoutes({
+    app,
+    getSession: (id) => sessions.get(id),
+  });
+  createSprintNudgeRoutes({
+    app,
+    getSession: (id) => sessions.get(id),
+  });
 
   // Graph endpoints (Sprint 38 T4) — knowledge-graph view backing graph.html.
   // Reuses the daily-driver pg pool (same DATABASE_URL serves memory_items +
@@ -3062,6 +3077,10 @@ module.exports = {
   SECRETS_EXCLUDED_FROM_PTY,
   // Sprint 65 T2 (2.1) — operator-role whitelist, exported for the route fence.
   ALLOWED_SESSION_ROLES,
+  // Sprint 69 T1 — boot-prompt template engine. Exported so T2's inject
+  // endpoint and integration tests can import without traversing the
+  // internal `./templates/template-engine` path.
+  templateEngine,
   // Sprint 50 T1 — exported for unit testing the per-agent SessionEnd
   // hook trigger (skip-claude, no-transcript, no-hook-installed,
   // payload shape, fire-and-forget).

package/packages/server/src/parked-detection.js

@@ -0,0 +1,50 @@
+/**
+ * Parked-lane detection for TermDeck.
+ *
+ * Algorithm:
+ * - If session status is not "active", it's not parked (it might be thinking, editing, or exited).
+ * - If lastActivity was within the last 5 minutes, it's genuinely active.
+ * - Otherwise, parse the trailing output buffer for Claude Code's completion banners.
+ * - If matched, it's parked.
+ *
+ * Completion banners (Claude Code):
+ * - "Cogitated for 1m 2s"
+ * - "Churned for 5m 10s"
+ * - Verbs: Cogitated, Churned, Brewed, Cooked, Mused, Pondered, Wandered, Crafted.
+ */
+
+const { stripAnsi } = require('./transcripts');
+
+function detectParked(session) {
+  if (!session || !session.meta) return false;
+
+  // Only "active" (PTY-wise) sessions can be "parked" (semantic-wise).
+  // "thinking" or "editing" statuses are already semantic indicators
+  // of work-in-progress.
+  if (session.meta.status !== 'active') return false;
+
+  const now = Date.now();
+  const lastActivity = new Date(session.meta.lastActivity).getTime();
+  const ageMs = now - lastActivity;
+
+  // Threshold: 5 minutes.
+  const FIVE_MIN_MS = 5 * 60 * 1000;
+  if (ageMs < FIVE_MIN_MS) return false;
+
+  // Read the session's output buffer (last ~4KB preserved in Session.analyzeOutput).
+  const buffer = session._outputBuffer || '';
+  if (!buffer) return false;
+
+  // Strip ANSI to match the plain-text banner
+  const cleanBuffer = stripAnsi(buffer);
+
+  // Regex per BRIEF + PLANNING:
+  // (Cogitated|Churned|Brewed|Cooked|Mused|Pondered|Wandered|Crafted) for \d+m \d+s
+  const PARKED_BANNER_RE = /(?:Cogitated|Churned|Brewed|Cooked|Mused|Pondered|Wandered|Crafted) for \d+m \d+s/i;
+
+  // Look in the last ~1000 chars of the cleaned buffer.
+  const tail = cleanBuffer.slice(-1000);
+  return PARKED_BANNER_RE.test(tail);
+}
+
+module.exports = { detectParked };

package/packages/server/src/session.js

@@ -18,6 +18,8 @@ const flashbackDiag = require('./flashback-diag');
 const geminiAdapter = require('./agent-adapters/gemini');
 const { detectAdapter, getAdapterForSessionType } = require('./agent-adapters');
 
+const { detectParked } = require("./parked-detection");
+
 // Strip ANSI escape codes for pattern matching
 function stripAnsi(str) {
   return str
@@ -540,8 +542,10 @@ class Session {
       if (ageMs > Session.STALE_STATUS_THRESHOLD_MS) {
         meta.status = 'idle';
         meta.statusDetail = '';
+        meta.parked = true;
       }
     }
+    meta.parked = detectParked(this);
     return {
       id: this.id,
       pid: this.pid,

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

@@ -22,6 +22,7 @@ const os = require('os');
 const { execFileSync } = require('child_process');
 
 const { injectSprintPrompts } = require('./sprint-inject');
+const { parseStatusMd: parseStatusMdV2 } = require('./sprints/status-parser');
 
 const SLUG_RE = /^[a-z0-9][a-z0-9-]{0,40}$/;
 
@@ -428,6 +429,22 @@ function createSprintRoutes({ app, config, spawnTerminalSession, getSession }) {
     res.json({ project, sprints });
   });
 
+
+  // GET /api/sprints/status?file=<path> — new structured parser (Sprint 69 T3)
+  app.get('/api/sprints/status', (req, res) => {
+    const filePath = req.query.file;
+    if (!filePath) return res.status(400).json({ error: 'file query param required' });
+    if (!fs.existsSync(filePath)) {
+      return res.status(404).json({ error: `file not found: ${filePath}` });
+    }
+    try {
+      const parsed = parseStatusMdV2(filePath);
+      res.json(parsed);
+    } catch (err) {
+      res.status(500).json({ error: `parse failed: ${err.message}` });
+    }
+  });
+
   // GET /api/sprints/:name/status?project=foo — parse STATUS.md per-lane.
   app.get('/api/sprints/:name/status', (req, res) => {
     const project = req.query.project;

package/packages/server/src/sprints/inject.js

@@ -0,0 +1,323 @@
+'use strict';
+
+const DEFAULT_SUBMIT_OPTIONS = {
+  gapMs: 250,
+  settleMs: 400,
+  snapshotDelayMs: 5000,
+};
+
+const ALLOWED_ROLES = new Set(['worker', 'auditor', 'orchestrator']);
+
+class SprintRequestError extends Error {
+  constructor(message, statusCode = 400, details = {}) {
+    super(message);
+    this.name = 'SprintRequestError';
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+}
+
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizeCliType(type) {
+  if (type === 'claude') return 'claude-code';
+  return type || 'shell';
+}
+
+function validateInjectBody(body) {
+  const input = isPlainObject(body) ? body : {};
+  if (!Array.isArray(input.panels) || input.panels.length === 0) {
+    throw new SprintRequestError('panels must be a non-empty array');
+  }
+  if (!isPlainObject(input.variables)) {
+    throw new SprintRequestError('variables must be an object');
+  }
+
+  const panels = input.panels.map((panel, index) => {
+    if (!isPlainObject(panel)) {
+      throw new SprintRequestError(`panels[${index}] must be an object`);
+    }
+    const tag = typeof panel.tag === 'string' ? panel.tag.trim() : '';
+    const sessionId = typeof panel.sessionId === 'string' ? panel.sessionId.trim() : '';
+    const role = typeof panel.role === 'string' ? panel.role.trim() : '';
+    const laneBrief = typeof panel.lane_brief === 'string' ? panel.lane_brief.trim() : '';
+
+    if (!tag) throw new SprintRequestError(`panels[${index}].tag is required`);
+    if (!sessionId) throw new SprintRequestError(`panels[${index}].sessionId is required`);
+    if (!ALLOWED_ROLES.has(role)) {
+      throw new SprintRequestError(
+        `panels[${index}].role must be one of: ${Array.from(ALLOWED_ROLES).join(', ')}`,
+      );
+    }
+    if (!laneBrief) throw new SprintRequestError(`panels[${index}].lane_brief is required`);
+
+    return { tag, sessionId, role, lane_brief: laneBrief };
+  });
+
+  return { panels, variables: { ...input.variables } };
+}
+
+function resolvePanelSessions(panels, getSession) {
+  if (typeof getSession !== 'function') {
+    throw new Error('getSession(sessionId) callback required');
+  }
+  return panels.map((panel) => {
+    const session = getSession(panel.sessionId);
+    if (!session) {
+      throw new SprintRequestError(`session not found: ${panel.sessionId}`, 400, {
+        code: 'invalid_session',
+        tag: panel.tag,
+        sessionId: panel.sessionId,
+      });
+    }
+    return session;
+  });
+}
+
+function defaultLoadTemplate(cliType, role, variables) {
+  // T1 owns this module in Sprint 69. Resolve lazily so T2's route can load
+  // before T1's engine has landed; endpoint calls surface a clear error.
+  const engine = require('../templates/template-engine');
+  if (!engine || typeof engine.loadTemplate !== 'function') {
+    throw new Error('template-engine must export loadTemplate(cliType, role, variables)');
+  }
+  return engine.loadTemplate(cliType, role, variables);
+}
+
+function normalizeMissingVariables(err) {
+  if (!err) return [];
+  const raw =
+    err.missingVariables
+    || err.missing_variables
+    || err.variables
+    || err.variableNames
+    || err.missing;
+  if (Array.isArray(raw)) return raw.map(String);
+  if (typeof raw === 'string' && raw) return [raw];
+  return [];
+}
+
+function mapTemplateError(err) {
+  const message = err && err.message ? err.message : String(err);
+  const missingVariables = normalizeMissingVariables(err);
+  const lower = message.toLowerCase();
+  const name = err && err.name;
+  const code = err && err.code;
+
+  if (code === 'MODULE_NOT_FOUND' && /template-engine/.test(message)) {
+    return new SprintRequestError('template engine unavailable', 503, {
+      code: 'template_engine_unavailable',
+      detail: message,
+    });
+  }
+
+  if (
+    name === 'MissingVariableError'
+    || code === 'missing_variable'
+    || code === 'missing_variables'
+    || missingVariables.length > 0
+    || (lower.includes('missing') && lower.includes('variable'))
+  ) {
+    return new SprintRequestError(message, 400, {
+      code: 'missing_template_variables',
+      missingVariables,
+    });
+  }
+
+  if (
+    code === 'unknown_template'
+    || code === 'unknown_cli_type'
+    || code === 'unknown_role'
+    || lower.includes('unknown template')
+    || lower.includes('unknown cli')
+    || lower.includes('unknown role')
+    || lower.includes('template not found')
+  ) {
+    return new SprintRequestError(message, 400, { code: 'template_error' });
+  }
+
+  return err;
+}
+
+async function renderInjectPanels({ panels, variables, sessions, loadTemplate }) {
+  const loader = loadTemplate || defaultLoadTemplate;
+  const rendered = [];
+
+  for (let i = 0; i < panels.length; i++) {
+    const panel = panels[i];
+    const session = sessions[i];
+    const cliType = normalizeCliType(session && session.meta && session.meta.type);
+    const templateVars = {
+      ...variables,
+      lane_brief: panel.lane_brief,
+      lane_tag: panel.tag,
+    };
+
+    try {
+      const text = await Promise.resolve(loader(cliType, panel.role, templateVars));
+      if (typeof text !== 'string') {
+        throw new Error('loadTemplate must return a string');
+      }
+      rendered.push({ ...panel, cliType, text });
+    } catch (err) {
+      throw mapTemplateError(err);
+    }
+  }
+
+  return rendered;
+}
+
+function sessionSnapshot(panel, session) {
+  const meta = (session && session.meta) || {};
+  return {
+    tag: panel.tag,
+    sessionId: panel.sessionId,
+    status: meta.status || null,
+    statusDetail: meta.statusDetail || '',
+    lastActivity: meta.lastActivity || null,
+  };
+}
+
+function createDefaultWriteInput(getSession) {
+  return async ({ sessionId, text }) => {
+    const session = getSession(sessionId);
+    if (!session) {
+      throw new SprintRequestError(`session not found: ${sessionId}`, 400, {
+        code: 'invalid_session',
+        sessionId,
+      });
+    }
+    if (!session.pty || (session.meta && session.meta.status === 'exited')) {
+      throw new SprintRequestError(`Panel ${sessionId} has exited`, 410, {
+        code: 'panel_exited',
+        sessionId,
+      });
+    }
+    try {
+      session.pty.write(text);
+      if (typeof session.trackInput === 'function') session.trackInput(text);
+      session.meta.replyCount = (session.meta.replyCount || 0) + 1;
+      return { ok: true, bytes: text.length, replyCount: session.meta.replyCount };
+    } catch (err) {
+      throw new SprintRequestError(err && err.message ? err.message : String(err), 500, {
+        code: 'write_failed',
+        sessionId,
+      });
+    }
+  };
+}
+
+async function runTwoStageSubmit({
+  panels,
+  getSession,
+  writeInput,
+  sleep,
+  options,
+  source,
+}) {
+  const opts = { ...DEFAULT_SUBMIT_OPTIONS, ...(options || {}) };
+  const wait = sleep || defaultSleep;
+  const write = writeInput || createDefaultWriteInput(getSession);
+
+  if (!Array.isArray(panels) || panels.length === 0) {
+    throw new SprintRequestError('panels must be a non-empty array');
+  }
+
+  for (let i = 0; i < panels.length; i++) {
+    const panel = panels[i];
+    await write({
+      sessionId: panel.sessionId,
+      text: `\x1b[200~${panel.text}\x1b[201~`,
+      source: source || 'sprint',
+      stage: 'paste',
+      panel,
+    });
+    if (i < panels.length - 1) await wait(opts.gapMs);
+  }
+
+  await wait(opts.settleMs);
+
+  for (let i = 0; i < panels.length; i++) {
+    const panel = panels[i];
+    await write({
+      sessionId: panel.sessionId,
+      text: '\r',
+      source: source || 'sprint',
+      stage: 'submit',
+      panel,
+    });
+    if (i < panels.length - 1) await wait(opts.gapMs);
+  }
+
+  if (opts.snapshotDelayMs > 0) await wait(opts.snapshotDelayMs);
+
+  return panels.map((panel) => sessionSnapshot(panel, getSession(panel.sessionId)));
+}
+
+function sendError(res, err) {
+  const mapped = err instanceof SprintRequestError ? err : new SprintRequestError(
+    err && err.message ? err.message : String(err),
+    err && err.statusCode ? err.statusCode : 500,
+    err && err.details ? err.details : {},
+  );
+  return res.status(mapped.statusCode).json({
+    ok: false,
+    error: mapped.message,
+    ...(mapped.details || {}),
+  });
+}
+
+function createSprintInjectHandler({ getSession, loadTemplate, writeInput, sleep, options } = {}) {
+  return async (req, res) => {
+    let parsed;
+    let sessions;
+    try {
+      parsed = validateInjectBody(req.body || {});
+      sessions = resolvePanelSessions(parsed.panels, getSession);
+      const rendered = await renderInjectPanels({
+        panels: parsed.panels,
+        variables: parsed.variables,
+        sessions,
+        loadTemplate,
+      });
+      const snapshots = await runTwoStageSubmit({
+        panels: rendered,
+        getSession,
+        writeInput,
+        sleep,
+        options,
+        source: 'sprint-inject',
+      });
+      return res.json({ ok: true, panels: snapshots });
+    } catch (err) {
+      return sendError(res, err);
+    }
+  };
+}
+
+function createSprintInjectRoutes(opts) {
+  if (!opts || !opts.app) throw new Error('app required');
+  opts.app.post('/api/sprints/inject', createSprintInjectHandler(opts));
+}
+
+module.exports = {
+  ALLOWED_ROLES,
+  DEFAULT_SUBMIT_OPTIONS,
+  SprintRequestError,
+  createDefaultWriteInput,
+  createSprintInjectHandler,
+  createSprintInjectRoutes,
+  defaultLoadTemplate,
+  normalizeCliType,
+  renderInjectPanels,
+  resolvePanelSessions,
+  runTwoStageSubmit,
+  sendError,
+  validateInjectBody,
+};

package/packages/server/src/sprints/nudge.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const {
+  SprintRequestError,
+  resolvePanelSessions,
+  runTwoStageSubmit,
+  sendError,
+} = require('./inject');
+
+const ALLOWED_NUDGE_KINDS = new Set([
+  'post-landed-reminder',
+  'status-check',
+  'tooling-failure-recover',
+  'custom',
+]);
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function validateNudgeBody(body) {
+  const input = isPlainObject(body) ? body : {};
+  if (!Array.isArray(input.panels) || input.panels.length === 0) {
+    throw new SprintRequestError('panels must be a non-empty array');
+  }
+
+  const kind = typeof input.kind === 'string' ? input.kind.trim() : '';
+  if (!ALLOWED_NUDGE_KINDS.has(kind)) {
+    throw new SprintRequestError(
+      `kind must be one of: ${Array.from(ALLOWED_NUDGE_KINDS).join(', ')}`,
+    );
+  }
+
+  const panels = input.panels.map((panel, index) => {
+    if (!isPlainObject(panel)) {
+      throw new SprintRequestError(`panels[${index}] must be an object`);
+    }
+    const tag = typeof panel.tag === 'string' ? panel.tag.trim() : '';
+    const sessionId = typeof panel.sessionId === 'string' ? panel.sessionId.trim() : '';
+    if (!tag) throw new SprintRequestError(`panels[${index}].tag is required`);
+    if (!sessionId) throw new SprintRequestError(`panels[${index}].sessionId is required`);
+    return { tag, sessionId };
+  });
+
+  const context = isPlainObject(input.context) ? input.context : {};
+  if (kind === 'custom') {
+    const text = typeof input.text === 'string'
+      ? input.text
+      : (typeof context.custom_text === 'string' ? context.custom_text : context.customText);
+    if (typeof text !== 'string' || text.length === 0) {
+      throw new SprintRequestError('custom nudge requires text or context.custom_text');
+    }
+  }
+  if (kind === 'post-landed-reminder') {
+    if (!context.open_red) {
+      throw new SprintRequestError('post-landed-reminder requires context.open_red');
+    }
+    if (!context.test_repro && !context.testRepro) {
+      throw new SprintRequestError('post-landed-reminder requires context.test_repro');
+    }
+  }
+
+  return { panels, kind, context, text: input.text };
+}
+
+function valueFromMaybeObject(value, preferredKeys) {
+  if (typeof value === 'string') return value;
+  if (!isPlainObject(value)) return String(value || '');
+  for (const key of preferredKeys) {
+    if (typeof value[key] === 'string' && value[key]) return value[key];
+  }
+  return JSON.stringify(value);
+}
+
+function buildNudgeText({ panel, kind, context, text }) {
+  if (kind === 'custom') {
+    return typeof text === 'string' ? text : (context.custom_text || context.customText);
+  }
+
+  if (kind === 'post-landed-reminder') {
+    const sprintName = context.sprint_name || context.sprintName || 'current sprint';
+    const fileLine = valueFromMaybeObject(context.open_red, ['file_line', 'fileLine', 'line']);
+    const testRepro = context.test_repro || context.testRepro;
+    return [
+      `ORCHESTRATOR NUDGE — ${sprintName}.`,
+      `${panel.tag}: T4 audit found ${fileLine} with repro ${testRepro}.`,
+      `Your fix should land as \`### [${panel.tag}] LANDED ...\` to STATUS.md once tests pass and the auditor has reacted.`,
+    ].join(' ');
+  }
+
+  if (kind === 'status-check') {
+    const minutes = context.silent_minutes || context.silentMinutes || 'several';
+    return [
+      'ORCHESTRATOR STATUS-CHECK.',
+      `STATUS.md has been silent for ${minutes} minutes.`,
+      `Post a \`### [${panel.tag}] CHECKPOINT\` with your current progress, or \`LANDED\` if done.`,
+    ].join(' ');
+  }
+
+  return [
+    'ORCHESTRATOR RECOVERY — your shell tooling appears to have died.',
+    'POST a final TOOLING-FAILURE CHECKPOINT to STATUS.md with what you have verified so far.',
+    'The orchestrator will spawn a codex-rescue subagent as the verification fallback.',
+  ].join(' ');
+}
+
+function createSprintNudgeHandler({ getSession, writeInput, sleep, options } = {}) {
+  return async (req, res) => {
+    try {
+      const parsed = validateNudgeBody(req.body || {});
+      resolvePanelSessions(parsed.panels, getSession);
+      const panels = parsed.panels.map((panel) => ({
+        ...panel,
+        text: buildNudgeText({
+          panel,
+          kind: parsed.kind,
+          context: parsed.context,
+          text: parsed.text,
+        }),
+      }));
+      const snapshots = await runTwoStageSubmit({
+        panels,
+        getSession,
+        writeInput,
+        sleep,
+        options,
+        source: 'sprint-nudge',
+      });
+      return res.json({ ok: true, panels: snapshots });
+    } catch (err) {
+      return sendError(res, err);
+    }
+  };
+}
+
+function createSprintNudgeRoutes(opts) {
+  if (!opts || !opts.app) throw new Error('app required');
+  opts.app.post('/api/sprints/nudge', createSprintNudgeHandler(opts));
+}
+
+module.exports = {
+  ALLOWED_NUDGE_KINDS,
+  buildNudgeText,
+  createSprintNudgeHandler,
+  createSprintNudgeRoutes,
+  validateNudgeBody,
+};

package/packages/server/src/sprints/status-parser.js

@@ -0,0 +1,129 @@
+/**
+ * STATUS.md parser for TermDeck.
+ *
+ * Scans the whole file to extract the latest state for each lane.
+ */
+
+const fs = require('fs');
+
+function parseStatusMd(filePath) {
+  const result = {
+    lanes: {},
+    open_red_count: 0,
+    last_orchestrator_post: null,
+    last_final_verdict: null
+  };
+
+  if (!fs.existsSync(filePath)) {
+    return result;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+
+  // Regex per BRIEF (loosened for multiple suffixes):
+  // ^### \[(T\d+(?:-[A-Z0-9-]+)?|ORCH)\] (FINDING|PROPOSE|LANDED|DONE|AUDIT-RED|AUDIT-CONCERN|CHECKPOINT|FINAL-VERDICT|STATUS|RULING) (\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}) ET — (.*?)$
+  const POST_RE = /^### \[(T\d+(?:-[A-Z0-9-]+)?|ORCH)\] (FINDING|PROPOSE|LANDED|DONE|AUDIT-RED|AUDIT-CONCERN|CHECKPOINT|FINAL-VERDICT|STATUS|RULING) (\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}) ET — (.*?)$/;
+
+  const laneLandeds = {}; // laneTag -> latest LANDED timestamp
+  const openReds = []; // List of {tag, timestamp, gist}
+
+  lines.forEach((line, index) => {
+    const match = line.match(POST_RE);
+    if (!match) return;
+
+    const [full, tag, verb, date, time, gist] = match;
+    const timestamp = `${date}T${time}:00`; 
+    const lineNum = index + 1;
+
+    if (tag === 'ORCH') {
+      result.last_orchestrator_post = gist;
+      return;
+    }
+
+    // Ensure lane entry
+    if (!result.lanes[tag]) {
+      result.lanes[tag] = {
+        last_post: null,
+        open_reds_against_me: [],
+        landed_since_last_red: false
+      };
+    }
+
+    result.lanes[tag].last_post = {
+      verb,
+      timestamp: `${date}T${time}:00-04:00`,
+      line: lineNum,
+      gist
+    };
+
+    if (verb === 'LANDED') {
+      laneLandeds[tag] = timestamp;
+    }
+
+    if (verb === 'AUDIT-RED') {
+      const mentionedLanes = gist.match(/T\d+(?:-[A-Z0-9-]+)?/g) || [];
+      mentionedLanes.forEach(targetLane => {
+        // Ensure the mentioned lane also exists in result.lanes
+        if (!result.lanes[targetLane]) {
+          result.lanes[targetLane] = {
+            last_post: null,
+            open_reds_against_me: [],
+            landed_since_last_red: false
+          };
+        }
+        openReds.push({ tag: targetLane, timestamp, gist });
+      });
+    }
+
+    if (verb === 'FINAL-VERDICT') {
+      result.last_final_verdict = {
+        verb,
+        timestamp: `${date}T${time}:00-04:00`,
+        gist
+      };
+    }
+  });
+
+  // Calculate landed_since_last_red and open_reds_against_me
+  Object.keys(result.lanes).forEach(tag => {
+    const lastLanded = laneLandeds[tag];
+    
+    result.lanes[tag].open_reds_against_me = openReds
+      .filter(red => red.tag === tag && (!lastLanded || lastLanded <= red.timestamp))
+      .map(red => ({ timestamp: red.timestamp, gist: red.gist }));
+
+    const allRedsForLane = openReds.filter(red => red.tag === tag);
+    if (allRedsForLane.length === 0) {
+      result.lanes[tag].landed_since_last_red = !!lastLanded;
+    } else {
+      const latestRedTs = allRedsForLane.reduce((max, r) => r.timestamp > max ? r.timestamp : max, "");
+      result.lanes[tag].landed_since_last_red = !!(lastLanded && lastLanded > latestRedTs);
+    }
+  });
+
+  // Count open reds
+  const uniqueOpenReds = new Set();
+  openReds.forEach(red => {
+    const lastLanded = laneLandeds[red.tag];
+    if (!lastLanded || lastLanded <= red.timestamp) {
+      uniqueOpenReds.add(`${red.tag}:${red.timestamp}`);
+    }
+  });
+  result.open_red_count = uniqueOpenReds.size;
+
+  // Final Verdict lanes_with_open_defects
+  if (result.last_final_verdict) {
+    const openDefects = [];
+    Object.keys(result.lanes).forEach(tag => {
+      if (result.lanes[tag].open_reds_against_me.length > 0) {
+        openDefects.push(tag);
+      }
+    });
+    result.last_final_verdict.lanes_with_open_defects = openDefects;
+  }
+
+  return result;
+}
+
+module.exports = { parseStatusMd };

package/packages/server/src/templates/template-engine.js

@@ -0,0 +1,197 @@
+'use strict';
+
+// Sprint 69 T1 — boot-prompt template engine.
+//
+// Looks up templates by (cliType × role), substitutes {{variable}} tokens,
+// and returns the paste-ready string. Default templates ship in
+// packages/server/share/termdeck/templates/. A per-file override at
+// ~/.termdeck/templates/<cli>-<role>.txt wins when present so projects can
+// customise without forking the package.
+//
+// Public contract (consumed by T2's POST /api/sprints/inject handler):
+//   loadTemplate(cliType, role, variables) -> string
+//     Throws TemplateNotFoundError if neither override nor default exists.
+//     Throws MissingVariableError if any {{var}} would be left unsubstituted;
+//     the error's `missingVariables` array names every unfilled token (not
+//     just the first) so callers can validate the whole template in one pass.
+//   requiredVariables(cliType, role) -> string[]
+//     Pre-scans a template for {{var}} tokens; lets the inject endpoint
+//     validate the request body before rendering.
+//
+// Token grammar: /\{\{(\w+)\}\}/g — flat names, no whitespace, no dotted
+// paths. Deliberately simpler than the Sprint 47 boot-prompt-resolver (which
+// supported `{{lane.tag}}`) so the inject body shape stays flat and the
+// failure mode (unsubstituted token left in the rendered output) is easy to
+// reason about.
+//
+// Override-directory resolution order:
+//   1. process.env.TERMDECK_TEMPLATES_OVERRIDE_DIR (set in tests; also usable
+//      for system-wide installs e.g. /etc/termdeck/templates/).
+//   2. ~/.termdeck/templates/ — the documented per-user override location.
+//   3. <repo>/packages/server/share/termdeck/templates/ — the in-package
+//      defaults that ship with @jhizzard/termdeck.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const SUPPORTED_CLI_TYPES = Object.freeze(['claude-code', 'codex', 'gemini', 'grok']);
+const SUPPORTED_ROLES = Object.freeze(['worker', 'auditor', 'orchestrator']);
+
+// Filename convention: `<cliType>-<role>.txt`. `cliType` is the literal
+// session-manager `meta.type` value (verified at session.js:165 — the
+// canonical types are 'shell' / 'claude-code' / 'gemini' / 'python-server' /
+// 'one-shot'). No aliasing layer — per the [ORCH] RULING 2026-05-20 13:13 ET,
+// `meta.type` flows from `GET /api/sessions` straight into `loadTemplate` so
+// T2's inject endpoint stays a one-liner. If the inject caller needs to
+// normalize a short-form name (e.g. 'claude') to 'claude-code', that's the
+// caller's normalization layer (see T2's `normalizeCliType` in
+// packages/server/src/sprints/inject.js).
+
+// Templates live alongside the server package: packages/server/share/termdeck/templates/.
+// __dirname here is packages/server/src/templates, so '..' twice lands at
+// packages/server/, then into share/termdeck/templates.
+const DEFAULT_TEMPLATE_DIR = path.join(
+  __dirname,
+  '..',
+  '..',
+  'share',
+  'termdeck',
+  'templates'
+);
+
+class TemplateNotFoundError extends Error {
+  constructor(message, { cliType, role, lookedUpPaths } = {}) {
+    super(message);
+    this.name = 'TemplateNotFoundError';
+    this.cliType = cliType;
+    this.role = role;
+    this.lookedUpPaths = Array.isArray(lookedUpPaths) ? lookedUpPaths : [];
+  }
+}
+
+class MissingVariableError extends Error {
+  constructor(message, { cliType, role, missingVariables } = {}) {
+    super(message);
+    this.name = 'MissingVariableError';
+    this.cliType = cliType;
+    this.role = role;
+    this.missingVariables = Array.isArray(missingVariables) ? missingVariables : [];
+  }
+}
+
+function _overrideDir() {
+  if (process.env.TERMDECK_TEMPLATES_OVERRIDE_DIR) {
+    return process.env.TERMDECK_TEMPLATES_OVERRIDE_DIR;
+  }
+  return path.join(os.homedir(), '.termdeck', 'templates');
+}
+
+function _resolveTemplatePath(cliType, role) {
+  if (!cliType || typeof cliType !== 'string') {
+    throw new TemplateNotFoundError(
+      `loadTemplate requires a string cliType; got ${cliType === undefined ? 'undefined' : JSON.stringify(cliType)}`,
+      { cliType, role, lookedUpPaths: [] }
+    );
+  }
+  if (!role || typeof role !== 'string') {
+    throw new TemplateNotFoundError(
+      `loadTemplate requires a string role; got ${role === undefined ? 'undefined' : JSON.stringify(role)}`,
+      { cliType, role, lookedUpPaths: [] }
+    );
+  }
+
+  if (!SUPPORTED_CLI_TYPES.includes(cliType)) {
+    throw new TemplateNotFoundError(
+      `Unknown cliType="${cliType}". Supported: ${SUPPORTED_CLI_TYPES.join(', ')}.`,
+      { cliType, role, lookedUpPaths: [] }
+    );
+  }
+  if (!SUPPORTED_ROLES.includes(role)) {
+    throw new TemplateNotFoundError(
+      `Unknown role="${role}". Supported: ${SUPPORTED_ROLES.join(', ')}.`,
+      { cliType, role, lookedUpPaths: [] }
+    );
+  }
+
+  const filename = `${cliType}-${role}.txt`;
+  const overrideCandidate = path.join(_overrideDir(), filename);
+  const defaultCandidate = path.join(DEFAULT_TEMPLATE_DIR, filename);
+
+  if (fs.existsSync(overrideCandidate)) {
+    return { path: overrideCandidate, source: 'override' };
+  }
+  if (fs.existsSync(defaultCandidate)) {
+    return { path: defaultCandidate, source: 'default' };
+  }
+
+  throw new TemplateNotFoundError(
+    `Template not found for cliType="${cliType}" role="${role}". Looked up override=${overrideCandidate}, default=${defaultCandidate}.`,
+    { cliType, role, lookedUpPaths: [overrideCandidate, defaultCandidate] }
+  );
+}
+
+function _scanVariables(rawTemplate) {
+  const found = new Set();
+  // Fresh regex per call — global regexes carry stateful lastIndex.
+  const re = /\{\{(\w+)\}\}/g;
+  let m;
+  while ((m = re.exec(rawTemplate)) !== null) {
+    found.add(m[1]);
+  }
+  return found;
+}
+
+function loadTemplate(cliType, role, variables) {
+  const { path: templatePath } = _resolveTemplatePath(cliType, role);
+  const raw = fs.readFileSync(templatePath, 'utf8');
+  const vars = (variables && typeof variables === 'object') ? variables : {};
+
+  // First pass: substitute every {{name}} whose name is present (and not
+  // null/undefined). Empty string IS a valid substitution. We use a fresh
+  // regex per replace call so multiple loadTemplate() calls don't interact.
+  const rendered = raw.replace(/\{\{(\w+)\}\}/g, (match, name) => {
+    if (
+      Object.prototype.hasOwnProperty.call(vars, name) &&
+      vars[name] !== undefined &&
+      vars[name] !== null
+    ) {
+      return String(vars[name]);
+    }
+    return match;
+  });
+
+  // Second pass: detect any {{...}} still in the rendered string. If any
+  // remain, the contract is violated — name them all so the caller fixes
+  // them in one pass instead of one-at-a-time.
+  const leftover = _scanVariables(rendered);
+  if (leftover.size > 0) {
+    const missing = Array.from(leftover).sort();
+    throw new MissingVariableError(
+      `Missing template variables for ${cliType}/${role}: ${missing.join(', ')}`,
+      { cliType, role, missingVariables: missing }
+    );
+  }
+
+  return rendered;
+}
+
+function requiredVariables(cliType, role) {
+  const { path: templatePath } = _resolveTemplatePath(cliType, role);
+  const raw = fs.readFileSync(templatePath, 'utf8');
+  return Array.from(_scanVariables(raw)).sort();
+}
+
+module.exports = {
+  loadTemplate,
+  requiredVariables,
+  TemplateNotFoundError,
+  MissingVariableError,
+  SUPPORTED_CLI_TYPES,
+  SUPPORTED_ROLES,
+  DEFAULT_TEMPLATE_DIR,
+  // Internal helpers exported for unit tests; not part of the public contract.
+  _resolveTemplatePath,
+  _overrideDir,
+  _scanVariables,
+};