@jhizzard/termdeck 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhizzard/termdeck",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Browser-based terminal multiplexer with metadata overlays, panel flashback memory recall, and AI-aware session management",
   "bin": {
     "termdeck": "./packages/cli/src/index.js"

package/packages/cli/src/doctor.js

@@ -203,6 +203,24 @@ function renderFooter(rows, exitCode) {
       `  Or upgrade individually: npm install -g @jhizzard/termdeck@latest`
     );
   }
+  // Sprint 56 (T1 Cross-Cutting #2 Part A) — logical inversion fix. Pre-
+  // Sprint-56 the footer always read "All packages up to date" on exit 0,
+  // even when every row was NOT_INSTALLED. That's logically wrong: saying
+  // "all up to date" when "all not installed" misleads the user into
+  // thinking the stack is healthy. Distinguish the two states explicitly.
+  const notInstalled = rows.filter((r) => r.status === STATUS.NOT_INSTALLED).length;
+  if (notInstalled === rows.length && rows.length > 0) {
+    return (
+      `\n  No stack packages detected (${rows.length} of ${rows.length} not installed).\n` +
+      `  To bootstrap the full stack: npx @jhizzard/termdeck-stack`
+    );
+  }
+  if (notInstalled > 0) {
+    return (
+      `\n  ${notInstalled} of ${rows.length} stack packages not installed; the rest up to date.\n` +
+      `  To install missing pieces: npx @jhizzard/termdeck-stack`
+    );
+  }
   return `\n  All packages up to date.`;
 }
 

package/packages/cli/src/index.js

@@ -104,6 +104,18 @@ function checkTranscriptTableHint(databaseUrl) {
 // Parse CLI args
 const args = process.argv.slice(2);
 
+// Sprint 56 (T1 Cell 18) — `--version` / `-v` handler. Pre-Sprint-56 the
+// flag was silently ignored: the CLI fell through to the launcher's stack
+// boot path and never printed a version. Now mirror the convention every
+// CLI in the world honors: print the package version and exit 0. Done
+// BEFORE the `init` dispatch so `termdeck --version init --mnestra`
+// (nonsensical but unambiguous) still terminates with the version.
+if (args.includes('--version') || args.includes('-v')) {
+  const pkg = require(path.join(__dirname, '..', '..', '..', 'package.json'));
+  process.stdout.write(`@jhizzard/termdeck v${pkg.version}\n`);
+  process.exit(0);
+}
+
 // Subcommand dispatch — handle `termdeck init --mnestra|--rumen` before
 // falling through to the default launcher's flag parsing. The `require` of
 // init-*.js is lazy so users running the normal `termdeck` command never pay

package/packages/cli/src/init-rumen.js

@@ -172,9 +172,28 @@ function preflight() {
   const missing = required.filter((k) => !secrets[k]);
   if (missing.length > 0) {
     fail(`missing keys: ${missing.join(', ')}`);
-    process.stderr.write(
-      '\nRun `termdeck init --mnestra` first — it writes the keys this wizard needs.\n'
-    );
+    // Sprint 56 (T1 Cell 10) — distinguish "no secrets file" (current
+    // message is correct: run init --mnestra to bootstrap) from "secrets
+    // file exists but missing one or more keys" (current message is
+    // misleading: user already ran init --mnestra; the actual cause is
+    // that ANTHROPIC_API_KEY is OPTIONAL for Mnestra but REQUIRED for
+    // Rumen, so a user who skipped it during init --mnestra ends up here).
+    const secretsPath = path.join(os.homedir(), '.termdeck', 'secrets.env');
+    const fileExists = fs.existsSync(secretsPath);
+    if (fileExists) {
+      process.stderr.write(
+        `\n~/.termdeck/secrets.env exists but is missing the keys above.\n` +
+        `${missing.includes('ANTHROPIC_API_KEY')
+          ? 'Note: ANTHROPIC_API_KEY is optional for Mnestra but REQUIRED for Rumen.\n'
+          : ''}` +
+        `Re-run \`termdeck init --mnestra\` to add the missing keys, or edit\n` +
+        `${secretsPath} directly and re-run \`termdeck init --rumen\`.\n`
+      );
+    } else {
+      process.stderr.write(
+        '\nRun `termdeck init --mnestra` first — it writes the keys this wizard needs.\n'
+      );
+    }
     return null;
   }
   ok();
@@ -896,7 +915,7 @@ function wireAccessTokenInMcpJson({ token, mcpJsonPath, _testFs } = {}) {
   return { status: 'updated', path: targetPath };
 }
 
-function printNextSteps(projectRef, vaultResult, llmResult) {
+function printNextSteps(projectRef, vaultResult, llmResult, skipSchedule) {
   const rumenTickUrl = `https://${projectRef}.supabase.co/functions/v1/rumen-tick`;
   const graphInferenceUrl = `https://${projectRef}.supabase.co/functions/v1/graph-inference`;
   const now = new Date();
@@ -912,13 +931,24 @@ function printNextSteps(projectRef, vaultResult, llmResult) {
     ? '  Graph edges: classified by Claude Haiku 4.5 (GRAPH_LLM_CLASSIFY=1).'
     : '  Graph edges: untyped (relates_to). To enable: supabase secrets set GRAPH_LLM_CLASSIFY=1';
 
+  // Sprint 56 (T1 Cell 12) — when --skip-schedule was passed, the cron
+  // schedule wasn't applied. Don't print "first run" or the cron-cadence
+  // claim — there is no scheduled first run. Show the function URL so
+  // the user knows what to manually invoke instead.
+  const rumenLine = skipSchedule
+    ? `  rumen-tick        cron NOT scheduled (--skip-schedule). Manual fire only.`
+    : `  rumen-tick        every 15 min — first run: ${next.toISOString().replace(/\.\d+Z$/, 'Z')}`;
+  const graphLine = skipSchedule
+    ? `  graph-inference   cron NOT scheduled (--skip-schedule). Manual fire only.`
+    : `  graph-inference   daily at 03:00 UTC (Sprint 42 cron)`;
+
   process.stdout.write(`
 Rumen is deployed.
 
 Edge Functions:
-  rumen-tick        every 15 min — first run: ${next.toISOString().replace(/\.\d+Z$/, 'Z')}
+${rumenLine}
                     ${rumenTickUrl}
-  graph-inference   daily at 03:00 UTC (Sprint 42 cron)
+${graphLine}
                     ${graphInferenceUrl}
 
 Next steps:
@@ -954,10 +984,20 @@ async function main(argv) {
   }
 
   if (!flags.yes) {
-    const go = await prompts.confirm(`? Proceed with deploy to project ${projectRef}?`);
-    if (!go) {
-      process.stdout.write('Cancelled.\n');
-      return 0;
+    // Sprint 56 (T1 Cell 13b) — dry-run-aware annotation parity. The
+    // graph-classify confirm at line 696-698 already prints "(dry-run,
+    // defaulting Y)" when flags.dryRun is set; this prompt didn't, leaving
+    // users unsure whether they were authorizing a real deploy or a no-op
+    // simulation. Match the same shape: print the prompt with the dry-run
+    // annotation, auto-progress without blocking on user input in dry-run.
+    if (flags.dryRun) {
+      process.stdout.write(`? Proceed with deploy to project ${projectRef}? [Y/n] (dry-run, defaulting Y)\n`);
+    } else {
+      const go = await prompts.confirm(`? Proceed with deploy to project ${projectRef}?`);
+      if (!go) {
+        process.stdout.write('Cancelled.\n');
+        return 0;
+      }
     }
   }
 
@@ -1053,7 +1093,7 @@ async function main(argv) {
     process.stdout.write('→ Skipping pg_cron schedule (per --skip-schedule) ✓\n');
   }
 
-  printNextSteps(projectRef, vaultResult, llmResult);
+  printNextSteps(projectRef, vaultResult, llmResult, flags.skipSchedule);
   return 0;
 }
 

package/packages/server/src/index.js

@@ -272,6 +272,20 @@ function createServer(config) {
 
   app.use(express.json());
 
+  // Sprint 56 (T2 F-T2-1) — malformed-JSON body returns JSON 400, not
+  // express's default HTML error page. Pre-Sprint-56 every POST/PATCH
+  // endpoint that consumed a JSON body returned `text/html` on parse
+  // failure, breaking programmatic clients (the inject script, MCP, CI
+  // smoke tests). The status code (400) was correct; only the body
+  // shape regressed. Mounted IMMEDIATELY after express.json() so it
+  // catches body-parse errors before any route handler runs.
+  app.use((err, req, res, next) => {
+    if (err && (err.type === 'entity.parse.failed' || err instanceof SyntaxError)) {
+      return res.status(400).json({ error: 'Malformed JSON body', detail: err.message });
+    }
+    return next(err);
+  });
+
   // First-run detection (Sprint 19 T3): true when ~/.termdeck/config.yaml
   // does not exist. Surfaced on /api/config so the client can offer the
   // setup wizard on first visit. T1's /api/setup endpoint may reuse this.

package/packages/server/src/setup/audit-upgrade.js

@@ -136,6 +136,29 @@ const PROBES = Object.freeze([
       "  and column_name = 'session_id' limit 1",
     presentWhen: 'rowReturned'
   },
+  {
+    // Sprint 53 T2 — Rumen picker rewrite. memory_sessions.rumen_processed_at
+    // (added by mig 018) is the picker's idempotency stamp.
+    // rumen 0.5.0+ filters `WHERE rumen_processed_at IS NULL` in extract.ts
+    // and stamps `UPDATE … SET rumen_processed_at = NOW()` between
+    // synthesize and surface (rumen/src/index.ts). Without this column,
+    // rumen-tick errors on the WHERE clause and produces 0 sessions/tick.
+    // Mig 018's ADD COLUMN IF NOT EXISTS + partial index are idempotent
+    // on already-stamped installs; safe to apply repeatedly.
+    //
+    // T4-CODEX 2026-05-04 17:32 ET pre-FIX audit catch — without this probe,
+    // a user upgrading TermDeck and only running `init --rumen --yes`
+    // could deploy the new picker without the column.
+    name: 'memory_sessions.rumen_processed_at',
+    kind: 'mnestra',
+    migrationFile: '018_rumen_processed_at.sql',
+    probeSql:
+      "select 1 as present from information_schema.columns " +
+      "where table_schema = 'public' " +
+      "  and table_name = 'memory_sessions' " +
+      "  and column_name = 'rumen_processed_at' limit 1",
+    presentWhen: 'rowReturned'
+  },
   {
     name: 'rumen-tick cron schedule',
     kind: 'rumen',

package/packages/server/src/setup/mnestra-migrations/018_rumen_processed_at.sql

@@ -0,0 +1,40 @@
+-- Migration 018 — memory_sessions.rumen_processed_at column.
+--
+-- Sprint 53 T2 (Rumen picker rewrite). Adds a tracking column so Rumen's
+-- extract phase can pick candidate sessions directly from memory_sessions
+-- (one row per Claude Code session, post-Sprint-51.6 bundled hook) and
+-- mark them as processed atomically when surface succeeds.
+--
+-- Why a column not a separate table: the picker hot path is "give me the
+-- N most recent sessions Rumen hasn't seen yet." A boolean/timestamp on
+-- memory_sessions answers that with one filtered range scan; a separate
+-- rumen_processed table would force a NOT EXISTS / LEFT JOIN per tick.
+--
+-- Why timestamptz not boolean: the timestamp doubles as a debug aid
+-- ("when did Rumen last touch this session?") and lets a future backfill
+-- script identify the cutoff between pre-Sprint-53 (NULL — never touched
+-- by the new picker) and post-Sprint-53 (stamped) without an extra column.
+--
+-- Idempotent — safe on:
+--   1. Joshua's daily-driver (pre-Sprint-53; column will be added with
+--      every existing memory_sessions row at NULL → all become candidates
+--      on the first post-deploy tick, which is the desired bootstrap).
+--   2. Brad's jizzard-brain (Linux SSH; same shape, same null-bootstrap).
+--   3. Fresh canonical installs (post-mig-017 schema; column added on
+--      first run, no rows to backfill).
+--   4. Re-runs (ADD COLUMN IF NOT EXISTS + CREATE INDEX IF NOT EXISTS).
+--
+-- The partial index is the picker's hot path: SELECT … WHERE
+-- rumen_processed_at IS NULL AND ended_at IS NOT NULL ORDER BY started_at DESC.
+-- Indexing only NULL rows keeps the index tiny (hundreds of rows at any
+-- given moment, since stamped rows drop out) — much smaller than a full
+-- B-tree on rumen_processed_at would be.
+
+alter table public.memory_sessions
+  add column if not exists rumen_processed_at timestamptz;
+
+-- Partial index — covers only unprocessed sessions, ordered by recency.
+-- Picker query plan: index range scan on the partial index, no seqscan.
+create index if not exists memory_sessions_rumen_unprocessed_idx
+  on public.memory_sessions(started_at desc nulls last)
+  where rumen_processed_at is null;

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

@@ -46,6 +46,50 @@ const CANONICAL_TS_RE =
 const CANONICAL_NO_TS_RE =
   /^[-*]?\s*(T\d+):\s*(FINDING|FIX-PROPOSED|DONE)\s+[—\-]\s+(.+)$/;
 
+// Sprint 56 (T4 Cell 7) — hardening-rule shape canonized 2026-05-04 yet
+// the merger never knew about it. The new shape every 3+1+1 lane post
+// follows is:
+//   `### [Tn(-CODEX)?] STAGE-VERB YYYY-MM-DD HH:MM ET — gist`
+// where STAGE-VERB is liberal (BOOT, FINDING, FIX-PROPOSED, DONE, ACK,
+// CHECKPOINT, AUDIT, REOPEN, NOTE, SKIP, PASS, FAIL, KICKOFF,
+// SUB-FINDING, FINDING-MICRO, RETRACTED, …). Old merger only knew
+// FINDING/FIX-PROPOSED/DONE so we'd silently drop everything else.
+//
+// Two patterns to handle:
+//   - Lines using `### ` markdown-header prefix (these are normally
+//     rejected by HEADER_RE as section headers — we MUST check this
+//     pattern BEFORE the HEADER_RE rejection in mergeStatusLine).
+//   - Lines using bare `[Tn]` without the `### ` prefix.
+//
+// Output shape: route the verb to the closest legacy STAGE so dashboard
+// consumers expecting the 3-stage taxonomy still parse cleanly. Verbs
+// outside the legacy set get bucketed by best-effort match (DONE for
+// terminal verbs, FINDING for diagnostic, FIX-PROPOSED for action).
+const HARDENING_RULE_RE =
+  /^(?:###\s+)?\[(T\d+(?:-[A-Z]+)?)\]\s+([A-Z][A-Z-]*)\s+(\d{4}-\d{2}-\d{2}\s+\d{1,2}:\d{2}\s+ET)\s+[—\-]\s+(.+)$/;
+
+// Best-effort normalization: many of the new verbs are introductory
+// (BOOT/KICKOFF/CHECKPOINT/ACK/NOTE → FINDING-shape information), some
+// are terminal (DONE/PASS/FAIL/SKIP/RETRACTED → DONE-shape closure),
+// and the action ones (FIX-PROPOSED/AUDIT/REOPEN) map to FIX-PROPOSED.
+// FINDING/SUB-FINDING/FINDING-MICRO obviously map to FINDING.
+function normalizeHardeningVerb(verb) {
+  const v = verb.toUpperCase();
+  if (v === 'FINDING' || v === 'SUB-FINDING' || v === 'FINDING-MICRO' ||
+      v === 'BOOT' || v === 'KICKOFF' || v === 'CHECKPOINT' ||
+      v === 'ACK' || v === 'NOTE') {
+    return 'FINDING';
+  }
+  if (v === 'FIX-PROPOSED' || v === 'AUDIT' || v === 'REOPEN') {
+    return 'FIX-PROPOSED';
+  }
+  if (v === 'DONE' || v === 'PASS' || v === 'FAIL' || v === 'SKIP' ||
+      v === 'RETRACTED' || v === 'COMPLETE' || v === 'COMPLETED') {
+    return 'DONE';
+  }
+  return 'FINDING';
+}
+
 // Markdown section header — never a status line.
 const HEADER_RE = /^#{1,6}\s/;
 // Bare bracket-like meta lines: `_(no entries yet)_`, `> note`, etc.
@@ -108,13 +152,27 @@ function mergeStatusLine(rawLine, opts = {}) {
   if (typeof rawLine !== 'string') return null;
   const line = rawLine.replace(/\r?\n$/, '').trim();
   if (!line) return null;
+
+  // Sprint 56 (T4 Cell 7) — check the hardening-rule shape FIRST,
+  // before HEADER_RE rejects every `### `-prefixed line as a markdown
+  // section header. Sprint 51.6 hardening canonized lane posts as
+  // `### [Tn] STAGE-VERB YYYY-MM-DD HH:MM ET — gist`; without this
+  // early-return the merger silently dropped every Sprint 53/55 lane
+  // post.
+  let m = HARDENING_RULE_RE.exec(line);
+  if (m) {
+    const [, tag, verb, ts, summary] = m;
+    const stage = normalizeHardeningVerb(verb);
+    return `- ${tag}: ${stage} — ${summary.trim()} — ${ts.trim()}`;
+  }
+
   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);
+  m = CANONICAL_TS_RE.exec(line);
   if (m) {
     const [, tag, stage, summary, ts] = m;
     return `- ${tag}: ${stage} — ${summary.trim()} — ${ts.trim()}`;