@jhizzard/termdeck 0.10.4 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhizzard/termdeck",
-  "version": "0.10.4",
+  "version": "0.12.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"
@@ -29,7 +29,8 @@
     "server": "node packages/server/src/index.js",
     "start": "NODE_ENV=production node packages/cli/src/index.js",
     "test": "node --test packages/server/tests/**/*.test.js",
-    "install:app": "bash install.sh"
+    "install:app": "bash install.sh",
+    "sync-rumen-functions": "bash scripts/sync-rumen-functions.sh"
   },
   "dependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",

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

@@ -18,10 +18,12 @@
 //   2. Derive project ref from SUPABASE_URL; confirm with user
 //   3. supabase link --project-ref <ref>
 //   4. Apply rumen migration 001 via pg
-//   5. supabase functions deploy rumen-tick --no-verify-jwt
+//   5. supabase functions deploy rumen-tick AND graph-inference (Sprint 43 T3)
+//      from a single staging dir with multi-function supabase/config.toml
 //   6. supabase secrets set DATABASE_URL=... ANTHROPIC_API_KEY=... [OPENAI_API_KEY=...]
-//   7. Test the function with a manual POST (fetch)
-//   8. Apply pg_cron schedule migration (002) with project ref substituted
+//   7. Test rumen-tick with a manual POST (graph-inference is cron-only)
+//   8. Apply pg_cron schedule migrations 002 (rumen-tick) AND 003 (graph-inference)
+//      with project ref substituted
 
 const path = require('path');
 const fs = require('fs');
@@ -34,6 +36,7 @@ const {
   dotenv,
   supabaseUrl: urlHelper,
   migrations,
+  migrationTemplating,
   pgRunner,
   preconditions
 } = require(SETUP_DIR);
@@ -300,67 +303,98 @@ async function applyRumenTables(secrets, dryRun) {
   }
 }
 
-function deployFunction(rumenVersion, dryRun) {
-  step('Running: supabase functions deploy rumen-tick --no-verify-jwt...');
+// Sprint 43 T3: rumen-tick is the only function with a `__RUMEN_VERSION__`
+// placeholder (its `npm:@jhizzard/rumen@<ver>` import is rewritten at deploy
+// time). graph-inference pins its own deps (`npm:postgres@3.4.4`) and is
+// copied verbatim. If a future function adds a placeholder, list it here.
+const FUNCTIONS_WITH_VERSION_PLACEHOLDER = new Set(['rumen-tick']);
+
+function deployFunctions(rumenVersion, dryRun) {
+  const fnNames = migrations.listRumenFunctions();
+  if (fnNames.length === 0) {
+    fail('no Rumen Edge Function source found in bundled setup or @jhizzard/rumen package');
+    return false;
+  }
+
+  step(`Staging ${fnNames.length} Edge Function(s) (${fnNames.join(', ')})...`);
   if (dryRun) { ok('(dry-run)'); return true; }
 
-  // We need the supabase command to run against a repo layout with
-  // `supabase/functions/rumen-tick/`. The TermDeck install does NOT include
-  // a `supabase/` directory at the project root, so we stage a tiny working
-  // directory under `os.tmpdir()` that mirrors what the CLI expects.
-  const stage = stageRumenFunction(rumenVersion);
+  // Stage all functions in one directory and one config.toml so a single
+  // `supabase functions deploy <name>` invocation per function can share the
+  // project root. This mirrors how a real Supabase repo is laid out.
+  let stage;
+  try {
+    stage = stageRumenFunctions(rumenVersion);
+  } catch (err) {
+    fail(err.message);
+    return false;
+  }
   if (!stage) {
-    fail('could not stage rumen-tick function source');
+    fail('could not stage Rumen Edge Function source');
     return false;
   }
-
-  const r = runShell('supabase', ['functions', 'deploy', 'rumen-tick', '--no-verify-jwt'], {
-    cwd: stage
-  });
-  if (!r.ok) { fail(`deploy failed (exit ${r.code})`); return false; }
   ok();
+
+  for (const name of fnNames) {
+    step(`Running: supabase functions deploy ${name} --no-verify-jwt...`);
+    const r = runShell('supabase', ['functions', 'deploy', name, '--no-verify-jwt'], {
+      cwd: stage
+    });
+    if (!r.ok) {
+      fail(`deploy of ${name} failed (exit ${r.code})`);
+      return false;
+    }
+    ok();
+  }
   return true;
 }
 
-// Create a staging directory containing:
-//   <stage>/supabase/functions/rumen-tick/{index.ts, tsconfig.json}
-// Also write a minimal `supabase/config.toml` so `supabase functions deploy`
-// doesn't complain about a missing project root.
-function stageRumenFunction(rumenVersion) {
+// Create a staging directory containing every bundled Rumen Edge Function:
+//   <stage>/supabase/functions/<name>/{index.ts, tsconfig.json}
+//   <stage>/supabase/config.toml  (one [functions.<name>] block per function)
+//
+// `__RUMEN_VERSION__` is substituted only in functions listed in
+// FUNCTIONS_WITH_VERSION_PLACEHOLDER (currently just rumen-tick). Other
+// files are copied verbatim. Returns the staging dir path or null if no
+// function source could be located.
+function stageRumenFunctions(rumenVersion) {
   if (!rumenVersion || !/^\d+\.\d+\.\d+/.test(rumenVersion)) {
-    throw new Error(`stageRumenFunction: invalid rumenVersion ${JSON.stringify(rumenVersion)}`);
+    throw new Error(`stageRumenFunctions: invalid rumenVersion ${JSON.stringify(rumenVersion)}`);
   }
+  const root = migrations.rumenFunctionsRoot();
+  const fnNames = migrations.listRumenFunctions();
+  if (fnNames.length === 0) return null;
+
   const stage = fs.mkdtempSync(path.join(os.tmpdir(), 'termdeck-rumen-stage-'));
-  const functionSrc = migrations.rumenFunctionDir();
-  if (!fs.existsSync(functionSrc)) return null;
-
-  const dest = path.join(stage, 'supabase', 'functions', 'rumen-tick');
-  fs.mkdirSync(dest, { recursive: true });
-  for (const f of fs.readdirSync(functionSrc)) {
-    const srcPath = path.join(functionSrc, f);
-    const destPath = path.join(dest, f);
-    // Substitute the version placeholder in the Deno entry point. Other files
-    // in the directory (tsconfig.json, etc.) are copied verbatim.
-    if (f === 'index.ts') {
-      const raw = fs.readFileSync(srcPath, 'utf-8');
-      if (!raw.includes('__RUMEN_VERSION__')) {
-        throw new Error(
-          `rumen-tick/index.ts is missing the __RUMEN_VERSION__ placeholder — ` +
-          `has someone reintroduced a hardcoded version?`
-        );
+
+  for (const name of fnNames) {
+    const fnSrc = path.join(root, name);
+    const fnDest = path.join(stage, 'supabase', 'functions', name);
+    fs.mkdirSync(fnDest, { recursive: true });
+    for (const f of fs.readdirSync(fnSrc)) {
+      const srcPath = path.join(fnSrc, f);
+      const destPath = path.join(fnDest, f);
+      if (f === 'index.ts' && FUNCTIONS_WITH_VERSION_PLACEHOLDER.has(name)) {
+        const raw = fs.readFileSync(srcPath, 'utf-8');
+        if (!raw.includes('__RUMEN_VERSION__')) {
+          throw new Error(
+            `${name}/index.ts is missing the __RUMEN_VERSION__ placeholder — ` +
+            `has someone reintroduced a hardcoded version? ` +
+            `Re-run scripts/sync-rumen-functions.sh to repopulate the placeholder.`
+          );
+        }
+        fs.writeFileSync(destPath, raw.replace(/__RUMEN_VERSION__/g, rumenVersion));
+      } else {
+        fs.copyFileSync(srcPath, destPath);
       }
-      fs.writeFileSync(destPath, raw.replace(/__RUMEN_VERSION__/g, rumenVersion));
-    } else {
-      fs.copyFileSync(srcPath, destPath);
     }
   }
 
+  const fnBlocks = fnNames.map((name) => `[functions.${name}]\nverify_jwt = false\n`).join('\n');
   const configToml = `# staged by termdeck init --rumen
 project_id = "termdeck-rumen-stage"
 
-[functions.rumen-tick]
-verify_jwt = false
-`;
+${fnBlocks}`;
   fs.writeFileSync(path.join(stage, 'supabase', 'config.toml'), configToml);
 
   return stage;
@@ -428,26 +462,53 @@ async function testFunction(projectRef, secrets, dryRun) {
   return true;
 }
 
+// Sprint 42 T3: bundle of cron-schedule migrations whose `<project-ref>`
+// placeholder must be substituted at apply-time. Both are idempotent
+// (cron.unschedule + cron.schedule), so applying in sequence is safe even
+// when one was already installed. Pre-Sprint 42, only 002 was applied —
+// migration 003 (graph-inference-tick) shipped bundled but unsubstituted
+// and unscheduled, which is part of why Sprint 38 close-out left the
+// graph-inference cron disabled.
+const SCHEDULE_MIGRATIONS = [
+  { matcher: /002.*pg_cron/, label: '002_pg_cron_schedule (rumen-tick)' },
+  { matcher: /003.*graph_inference/, label: '003_graph_inference_schedule (graph-inference-tick)' }
+];
+
 async function applySchedule(projectRef, secrets, dryRun) {
-  step('Applying pg_cron schedule (every 15 minutes)...');
+  step('Applying pg_cron schedules (rumen-tick + graph-inference-tick)...');
   if (dryRun) { ok('(dry-run)'); return true; }
 
   const files = migrations.listRumenMigrations();
-  const scheduleFile = files.find((f) => /002.*pg_cron/.test(path.basename(f)));
-  if (!scheduleFile) { fail('bundled 002_pg_cron_schedule.sql is missing'); return false; }
-
-  const raw = migrations.readFile(scheduleFile);
-  // Substitute the project ref into the schedule body. The bundled migration
-  // ships with the placeholder `<project-ref>` per Rumen's deploy docs; we
-  // also accept `{{PROJECT_REF}}` for robustness.
-  const substituted = raw
-    .replace(/<project-ref>/g, projectRef)
-    .replace(/\{\{PROJECT_REF\}\}/g, projectRef);
-
-  // The shipped migration uses Supabase Vault (`vault.decrypted_secrets`) to
-  // pull the service-role key. If the user hasn't stored the key in Vault the
-  // cron call will fail. We leave that as a post-install step and print a
-  // reminder below.
+  const planned = [];
+  for (const { matcher, label } of SCHEDULE_MIGRATIONS) {
+    const file = files.find((f) => matcher.test(path.basename(f)));
+    if (!file) { fail(`bundled ${label} is missing`); return false; }
+    planned.push({ file, label });
+  }
+
+  // Substitute the project ref into each schedule body. Both bundled
+  // migrations ship with the `<project-ref>` placeholder per Rumen's
+  // deploy docs; the helper also accepts `{{PROJECT_REF}}` for robustness
+  // and refuses to ship an unsubstituted placeholder to the database.
+  const substituted = [];
+  try {
+    for (const { file, label } of planned) {
+      const raw = migrations.readFile(file);
+      substituted.push({
+        sql: migrationTemplating.applyTemplating(raw, { projectRef }),
+        label
+      });
+    }
+  } catch (err) {
+    fail(err.message);
+    return false;
+  }
+
+  // The shipped migrations use Supabase Vault (`vault.decrypted_secrets`)
+  // to pull the service-role keys (`rumen_service_role_key` for 002 and
+  // `graph_inference_service_role_key` for 003). If a key isn't stored in
+  // Vault the corresponding cron call will fail at runtime. We leave that
+  // as a post-install step and print a reminder below.
 
   let client;
   try {
@@ -457,20 +518,21 @@ async function applySchedule(projectRef, secrets, dryRun) {
     return false;
   }
   try {
-    // Run the substituted SQL directly rather than applying the original file.
-    try {
-      await pgRunner.run(client, substituted);
-      ok();
-      return true;
-    } catch (err) {
-      fail(err.message);
-      process.stderr.write(
-        '\nThe schedule SQL failed — the most common cause is that pg_cron or pg_net\n' +
-        'is not enabled in the Supabase project. Enable them in Dashboard → Database\n' +
-        '→ Extensions, then re-run `termdeck init --rumen --skip-schedule=false`.\n'
-      );
-      return false;
+    for (const { sql, label } of substituted) {
+      try {
+        await pgRunner.run(client, sql);
+      } catch (err) {
+        fail(`${label}: ${err.message}`);
+        process.stderr.write(
+          '\nThe schedule SQL failed — the most common cause is that pg_cron or pg_net\n' +
+          'is not enabled in the Supabase project. Enable them in Dashboard → Database\n' +
+          '→ Extensions, then re-run `termdeck init --rumen --skip-schedule=false`.\n'
+        );
+        return false;
+      }
     }
+    ok();
+    return true;
   } finally {
     try { await client.end(); } catch (_err) { /* ignore */ }
   }
@@ -540,7 +602,8 @@ function wireAccessTokenInMcpJson({ token, mcpJsonPath, _testFs } = {}) {
 }
 
 function printNextSteps(projectRef) {
-  const functionUrl = `https://${projectRef}.supabase.co/functions/v1/rumen-tick`;
+  const rumenTickUrl = `https://${projectRef}.supabase.co/functions/v1/rumen-tick`;
+  const graphInferenceUrl = `https://${projectRef}.supabase.co/functions/v1/graph-inference`;
   const now = new Date();
   // Round up to the next 15-minute mark so the hint is accurate.
   const next = new Date(now.getTime());
@@ -548,16 +611,20 @@ function printNextSteps(projectRef) {
   process.stdout.write(`
 Rumen is deployed.
 
-Schedule: every 15 minutes via pg_cron
-First scheduled run: ${next.toISOString().replace(/\.\d+Z$/, 'Z')}
-Edge Function URL: ${functionUrl}
+Edge Functions:
+  rumen-tick        every 15 min — first run: ${next.toISOString().replace(/\.\d+Z$/, 'Z')}
+                    ${rumenTickUrl}
+  graph-inference   daily at 03:00 UTC (Sprint 42 cron)
+                    ${graphInferenceUrl}
 
 Next steps:
-  1. Monitor:  psql "$DATABASE_URL" -c "SELECT * FROM rumen_jobs ORDER BY started_at DESC LIMIT 5"
-  2. Store the service_role key in Supabase Vault as \`rumen_service_role_key\`
-     so the cron call in migrations/002_pg_cron_schedule.sql can authenticate.
+  1. Monitor rumen jobs: psql "$DATABASE_URL" -c "SELECT * FROM rumen_jobs ORDER BY started_at DESC LIMIT 5"
+  2. Store service_role keys in Supabase Vault — required for both cron schedules:
+       rumen_service_role_key            (used by 002_pg_cron_schedule.sql)
+       graph_inference_service_role_key  (used by 003_graph_inference_schedule.sql)
   3. Rumen insights flow back into Mnestra's memory_items via rumen_insights.
-  4. TermDeck's Flashback will surface cross-project patterns automatically.
+  4. graph-inference fills memory_relationships edges nightly (cosine similarity ≥ 0.85).
+  5. TermDeck's Flashback will surface cross-project patterns automatically.
 `);
 }
 
@@ -635,7 +702,7 @@ async function main(argv) {
     process.stderr.write(`  ! falling back to pinned FALLBACK_RUMEN_VERSION=${FALLBACK_RUMEN_VERSION}\n`);
   }
 
-  if (!deployFunction(resolved.version, flags.dryRun)) return 6;
+  if (!deployFunctions(resolved.version, flags.dryRun)) return 6;
   if (!setFunctionSecrets(secrets, flags.dryRun)) return 7;
   if (!(await testFunction(projectRef, secrets, flags.dryRun))) return 8;
   if (!flags.skipSchedule) {
@@ -671,3 +738,6 @@ module.exports = main;
 // pin the access-token detection without spawning a real `supabase` binary.
 module.exports._looksLikeMissingAccessToken = looksLikeMissingAccessToken;
 module.exports._wireAccessTokenInMcpJson = wireAccessTokenInMcpJson;
+// Sprint 43 T3: stage helper exposed so init-rumen-deploy.test.js can pin
+// the multi-function staging contract without shelling out to `supabase`.
+module.exports._stageRumenFunctions = stageRumenFunctions;

package/packages/client/public/app.js

@@ -91,6 +91,65 @@
       setupGuideRail();
     }
 
+    // ===== Drag/drop reorder of PTY panels (Sprint 42 T4) =====
+    // The grip handle in panel-header-left flips draggable=true on mousedown
+    // so an accidental drag inside the xterm region never fires. Drop
+    // position is determined by cursor x within the target panel — left half
+    // inserts before, right half inserts after — so reordering matches the
+    // intent in any grid layout (1x2, 2x2, 2x4, etc.). DOM reorder only;
+    // session.creation-order remains canonical for Alt+1…9 and panel-index.
+    function setupPanelDragDrop(panel) {
+      const handle = panel.querySelector('.panel-drag-handle');
+      if (!handle) return;
+
+      handle.addEventListener('mousedown', () => { panel.draggable = true; });
+      // Mouse leaves handle without a drag starting → reset
+      handle.addEventListener('mouseleave', () => {
+        if (!panel.classList.contains('dragging')) panel.draggable = false;
+      });
+
+      panel.addEventListener('dragstart', (e) => {
+        if (!panel.draggable) { e.preventDefault(); return; }
+        try { e.dataTransfer.effectAllowed = 'move'; } catch (_e) {}
+        try { e.dataTransfer.setData('text/plain', panel.id); } catch (_e) {}
+        panel.classList.add('dragging');
+      });
+
+      panel.addEventListener('dragend', () => {
+        panel.classList.remove('dragging');
+        panel.draggable = false;
+        document.querySelectorAll('.term-panel.drag-over').forEach((p) => p.classList.remove('drag-over'));
+      });
+
+      panel.addEventListener('dragover', (e) => {
+        const dragging = document.querySelector('.term-panel.dragging');
+        if (!dragging || dragging === panel) return;
+        e.preventDefault();
+        try { e.dataTransfer.dropEffect = 'move'; } catch (_e) {}
+        panel.classList.add('drag-over');
+      });
+
+      panel.addEventListener('dragleave', (e) => {
+        // Only clear when leaving the panel entirely (not entering a child).
+        if (!panel.contains(e.relatedTarget)) panel.classList.remove('drag-over');
+      });
+
+      panel.addEventListener('drop', (e) => {
+        e.preventDefault();
+        panel.classList.remove('drag-over');
+        const draggedId = (() => {
+          try { return e.dataTransfer.getData('text/plain'); } catch (_e) { return ''; }
+        })();
+        const dragged = draggedId
+          ? document.getElementById(draggedId)
+          : document.querySelector('.term-panel.dragging');
+        if (!dragged || dragged === panel) return;
+        const rect = panel.getBoundingClientRect();
+        const dropAfter = (e.clientX - rect.left) > rect.width / 2;
+        panel.parentNode.insertBefore(dragged, dropAfter ? panel.nextSibling : panel);
+      });
+    }
+
     // ===== Create Terminal Panel =====
     function createTerminalPanel(sessionData) {
       const id = sessionData.id;
@@ -128,6 +187,7 @@
       panel.innerHTML = `
         <div class="panel-header">
           <div class="panel-header-left">
+            <span class="panel-drag-handle" title="Drag to reorder">⋮⋮</span>
             <span class="status-dot" id="dot-${id}" style="background:${getStatusColor(meta.status)}"></span>
             <span class="panel-type">${getTypeLabel(meta.type)}</span>
             ${meta.project ? `<span class="panel-project ${projClass}">${meta.project}</span>` : ''}
@@ -193,6 +253,11 @@
 
       document.getElementById('termGrid').appendChild(panel);
 
+      // Sprint 42 T4: drag/drop reorder. Inject identifier is the session
+      // UUID, so DOM reorder is purely visual — Alt+1…9 (creation-order),
+      // /api/sessions/:id/input, and reply-form targets are unaffected.
+      setupPanelDragDrop(panel);
+
       // Create xterm.js instance
       const terminal = new Terminal({
         fontFamily: "'SF Mono', 'Cascadia Code', 'JetBrains Mono', 'Fira Code', Consolas, monospace",
@@ -238,7 +303,7 @@
               updatePanelMeta(id, msg.session.meta);
               break;
             case 'proactive_memory':
-              showProactiveToast(id, msg.hit);
+              showProactiveToast(id, msg.hit, msg.flashback_event_id);
               break;
             case 'exit':
               updatePanelMeta(id, {
@@ -265,6 +330,15 @@
                 if (typeof updateRagIndicator === 'function') updateRagIndicator();
               }
               break;
+            case 'projects_changed':
+              // Sprint 42 T4: server broadcasts on POST/DELETE /api/projects.
+              // Sync the in-memory projects map and re-render the dropdown so
+              // other open dashboard tabs stay consistent without a refresh.
+              if (msg.projects && state.config) {
+                state.config.projects = msg.projects;
+                if (typeof rebuildProjectDropdown === 'function') rebuildProjectDropdown();
+              }
+              break;
           }
         } catch (err) { console.error('[client] ws message parse failed:', err); }
       };
@@ -509,7 +583,7 @@
       }
     }
 
-    function showProactiveToast(id, hit) {
+    function showProactiveToast(id, hit, flashbackEventId) {
       const entry = state.sessions.get(id);
       if (!entry || !entry.el) return;
 
@@ -532,16 +606,29 @@
 
       entry.el.appendChild(toast);
 
+      // Sprint 43 T2: track dismiss/click-through against flashback_events.
+      // The id is set server-side in the proactive_memory WS frame; if it's
+      // missing (server-side INSERT failed, or older server) the POSTs are
+      // skipped and the live toast still works — persistence is best-effort.
       const dismiss = () => {
         toast.remove();
         clearTimeout(toast._autoTimer);
+        if (flashbackEventId) {
+          fetch(`${API}/api/flashback/${flashbackEventId}/dismissed`, { method: 'POST' })
+            .catch((err) => console.warn('[flashback] dismiss POST failed:', err.message));
+        }
       };
       toast.querySelector('.t-dismiss').addEventListener('click', (e) => {
         e.stopPropagation();
         dismiss();
       });
       toast.addEventListener('click', () => {
-        dismiss();
+        toast.remove();
+        clearTimeout(toast._autoTimer);
+        if (flashbackEventId) {
+          fetch(`${API}/api/flashback/${flashbackEventId}/clicked`, { method: 'POST' })
+            .catch((err) => console.warn('[flashback] clicked POST failed:', err.message));
+        }
         showFlashbackModal(hit, id);
       });
 
@@ -1260,7 +1347,7 @@
               updatePanelMeta(id, msg.session.meta);
               break;
             case 'proactive_memory':
-              showProactiveToast(id, msg.hit);
+              showProactiveToast(id, msg.hit, msg.flashback_event_id);
               break;
             case 'exit':
               updatePanelMeta(id, { status: 'exited', statusDetail: `Exited (${msg.exitCode})` });
@@ -1281,6 +1368,14 @@
                 if (typeof updateRagIndicator === 'function') updateRagIndicator();
               }
               break;
+            case 'projects_changed':
+              // Sprint 42 T4: parity with main WS handler. Project add/remove
+              // broadcasts arrive on every ws client; idempotent.
+              if (msg.projects && state.config) {
+                state.config.projects = msg.projects;
+                if (typeof rebuildProjectDropdown === 'function') rebuildProjectDropdown();
+              }
+              break;
           }
         } catch (err) { console.error('[client] reconnect ws message failed:', err); }
       };
@@ -1552,6 +1647,104 @@
       }
     }
 
+    // ===== Remove Project modal (Sprint 42 T4) =====
+    // Removes a project from ~/.termdeck/config.yaml. Files on disk at the
+    // project's `path` are NEVER touched — the modal copy makes that explicit
+    // so users don't fear data loss. 409 from the server (live PTY sessions
+    // for that project) prompts the user with a force-override.
+    function openRemoveProjectModal() {
+      const modal = document.getElementById('removeProjectModal');
+      const sel = document.getElementById('rpmSelect');
+      sel.innerHTML = '<option value="">— pick a project —</option>';
+      for (const name of Object.keys(state.config.projects || {})) {
+        const opt = document.createElement('option');
+        opt.value = name;
+        opt.textContent = name;
+        sel.appendChild(opt);
+      }
+      sel.value = '';
+      document.getElementById('rpmConfirm').disabled = true;
+      document.getElementById('rpmConfirm').dataset.force = '';
+      document.getElementById('rpmConfirm').textContent = 'remove project';
+      const warn = document.getElementById('rpmWarning');
+      warn.hidden = true;
+      warn.textContent = '';
+      setRpmStatus('', null);
+      modal.classList.add('open');
+      setTimeout(() => sel.focus(), 50);
+    }
+
+    function closeRemoveProjectModal() {
+      document.getElementById('removeProjectModal').classList.remove('open');
+    }
+
+    function setRpmStatus(msg, kind) {
+      const el = document.getElementById('rpmStatus');
+      if (!el) return;
+      el.textContent = msg || '';
+      el.classList.remove('error', 'ok');
+      if (kind) el.classList.add(kind);
+    }
+
+    function onRpmSelectChange() {
+      const name = document.getElementById('rpmSelect').value;
+      const btn = document.getElementById('rpmConfirm');
+      btn.disabled = !name;
+      btn.dataset.force = '';
+      btn.textContent = name ? `remove "${name}"` : 'remove project';
+      const warn = document.getElementById('rpmWarning');
+      warn.hidden = true;
+      warn.textContent = '';
+      setRpmStatus('', null);
+    }
+
+    async function submitRemoveProject() {
+      const name = document.getElementById('rpmSelect').value;
+      if (!name) return;
+      const btn = document.getElementById('rpmConfirm');
+      const force = btn.dataset.force === 'true';
+      btn.disabled = true;
+      setRpmStatus(force ? 'Removing (with force)…' : 'Removing…', null);
+
+      try {
+        const url = `${API}/api/projects/${encodeURIComponent(name)}${force ? '?force=true' : ''}`;
+        const res = await fetch(url, { method: 'DELETE' });
+        const text = await res.text();
+        let body = {};
+        try { body = JSON.parse(text); } catch { body = { error: text }; }
+
+        if (res.status === 409) {
+          const live = body.liveSessions || 0;
+          const warn = document.getElementById('rpmWarning');
+          warn.hidden = false;
+          warn.innerHTML =
+            `<strong>"${name}" has ${live} live PTY session${live === 1 ? '' : 's'}.</strong> ` +
+            `Closing those terminals first is recommended. ` +
+            `Or click <em>remove anyway</em> to force removal — terminals stay open but lose their project tag in config.yaml.`;
+          btn.dataset.force = 'true';
+          btn.textContent = 'remove anyway';
+          btn.disabled = false;
+          setRpmStatus('', null);
+          return;
+        }
+
+        if (!res.ok) {
+          setRpmStatus(`Failed: ${body.error || res.statusText}`, 'error');
+          btn.disabled = false;
+          return;
+        }
+
+        // Success — sync in-memory config + dropdown.
+        state.config.projects = body.projects || {};
+        rebuildProjectDropdown();
+        setRpmStatus(`Removed "${name}" ✓ (files on disk untouched)`, 'ok');
+        setTimeout(() => { closeRemoveProjectModal(); }, 900);
+      } catch (err) {
+        setRpmStatus(`Failed: ${err.message || err}`, 'error');
+        btn.disabled = false;
+      }
+    }
+
     // ===== Orchestration preview modal (Sprint 37 T3) =====
     // The preview button next to the project select shows what
     // `termdeck init --project <name>` would create for the currently
@@ -3714,6 +3907,16 @@
       if (e.key === 'Escape') { e.preventDefault(); closeAddProjectModal(); }
     });
 
+    // Remove-project modal wiring (Sprint 42 T4)
+    document.getElementById('btnRemoveProject').addEventListener('click', openRemoveProjectModal);
+    document.getElementById('rpmCancel').addEventListener('click', closeRemoveProjectModal);
+    document.getElementById('rpmConfirm').addEventListener('click', submitRemoveProject);
+    document.getElementById('rpmSelect').addEventListener('change', onRpmSelectChange);
+    document.querySelector('#removeProjectModal .remove-project-backdrop').addEventListener('click', closeRemoveProjectModal);
+    document.getElementById('removeProjectModal').addEventListener('keydown', (e) => {
+      if (e.key === 'Escape') { e.preventDefault(); closeRemoveProjectModal(); }
+    });
+
     // Orchestration preview modal wiring (Sprint 37 T3)
     document.getElementById('btnPreviewProject').addEventListener('click', openPreviewModal);
     document.getElementById('promptProject').addEventListener('change', syncPreviewButton);