@dadado/agent-kit-cli 5.15.1 → 5.16.0

package/dashboard/dashboard-data.mjs

@@ -4,7 +4,7 @@
 // Scans .cursor/plans, HANDOFF, memory, config, git status, terminals, processes
 // Outputs JSON to stdout (consumed by dashboard.html)
 
-import { execFileSync, execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import {
@@ -14,6 +14,9 @@ import {
   resolveSnapshotRepoRoot,
   truncateStr,
 } from "./lib/guards.mjs";
+import { projectSlugFromRoot } from "./lib/live-refresh.mjs";
+import { PIPELINE_CACHE_ENV, readCachedPipeline } from "./lib/pipeline-cache.mjs";
+import { selectWorkspaceProcesses } from "./lib/processes.mjs";
 import {
   EXTERNAL_REPORT_FILE_RE,
   FIELD_REPORT_CADENCE_LEDGER_REL,
@@ -46,6 +49,8 @@ import { MAX_TERMINAL_BYTES, buildTerminalSnapshotFields } from "./lib/terminal-
 const KIT_ROOT = resolve(import.meta.dirname, "..");
 /** Snapshot root: consumer workspace when MISSION_CONTROL_REPO_ROOT is set, else kit tree. */
 const ROOT = resolveSnapshotRepoRoot(process.env, KIT_ROOT);
+/** serve.mjs next to this script; its process is in scope even when ROOT is a consumer tree. */
+const SERVE_PATH = resolve(import.meta.dirname, "serve.mjs");
 const MAX_TERMINALS = 20;
 const MAX_PROCESSES = 25;
 const MAX_GIT_GRAPH_LINES = 25;
@@ -140,7 +145,7 @@ const SNAPSHOT = {
         "Memory records: error count, decision count, recent decisions, recent parsed errors, error-o-meter stats",
       git: "Git repository state: branch, dirty status, commit, ahead/behind, bounded files[], promotion flow vs staging/main, graph lines, staging hygiene",
       devops:
-        "Best-effort DevOps signal: pipeline ({available, runs[], reason?} recent gh run list rows; reason is 'budget' when the shared snapshot budget ran out before gh was attempted, or 'call-failed' when gh was attempted and missing/unauthenticated/timed out/errored; reason is only present when available is false) and deploy ({tags[], changelog} v* git tags + latest CHANGELOG release entry as a 'what shipped recently' proxy, not a live infra poll)",
+        "Best-effort DevOps signal: pipeline ({available, runs[], reason?} recent gh run list rows; reason is 'budget' when the shared snapshot budget ran out before gh was attempted, or 'call-failed' when gh was attempted and missing/unauthenticated/timed out/errored; reason is only present when available is false; fetchedAt is the ISO time gh was last attempted, reused from serve.mjs for up to 60s) and deploy ({tags[], changelog} v* git tags + latest CHANGELOG release entry as a 'what shipped recently' proxy, not a live infra poll)",
       terminals:
         "Active Cursor terminal sessions with metadata, output line count, and capped lastOutput",
       processes:
@@ -473,29 +478,19 @@ if (existsSync(memoryDecisionsDir)) {
 
 // 6. Git
 try {
-  const gitOpts = { cwd: ROOT, encoding: "utf-8", timeout: 5000 };
-  const branch = execSync("git rev-parse --abbrev-ref HEAD", gitOpts).trim();
+  const gitOpts = {
+    cwd: ROOT,
+    encoding: "utf-8",
+    timeout: 5000,
+    stdio: ["ignore", "pipe", "ignore"],
+  };
+  const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], gitOpts).trim();
   // Only strip the trailing newline(s) here — `git status --short` uses
   // positional XY status columns, so an unstaged-only row starts with a
   // literal leading space (e.g. " M path"). A full-string .trim() eats that
   // leading space on line 1 only, shifting parseGitStatusShort's staged /
   // unstaged read for the first row.
-  const status = execSync("git status --short", gitOpts).replace(/\n+$/, "");
-  const lastCommit = execSync("git log -1 --oneline", gitOpts).trim();
-  let ahead = 0;
-  let behind = 0;
-  try {
-    ahead =
-      Number.parseInt(execSync("git rev-list --count origin/main..HEAD", gitOpts).trim(), 10) || 0;
-  } catch {
-    /* no upstream */
-  }
-  try {
-    behind =
-      Number.parseInt(execSync("git rev-list --count HEAD..origin/main", gitOpts).trim(), 10) || 0;
-  } catch {
-    /* no upstream */
-  }
+  const status = execFileSync("git", ["status", "--short"], gitOpts).replace(/\n+$/, "");
 
   const parsed = parseGitStatusShort(status);
   let recentLog = [];
@@ -528,6 +523,10 @@ try {
     vsMain: countDivergence("origin/main...HEAD"),
     stagingVsMain: countDivergence("origin/main...origin/staging"),
   };
+  // Derived from the calls above instead of three more git spawns.
+  const lastCommit = recentLog[0] ?? "";
+  const ahead = flow.vsMain?.ahead ?? 0;
+  const behind = flow.vsMain?.behind ?? 0;
 
   // Readable graph (branch lanes + merges) as pre-rendered text lines.
   let graphLines = [];
@@ -589,6 +588,11 @@ function collectPipelineRuns() {
   // above; the budget reserve must cover its own timeout, not just a nominal
   // buffer (see .cursor/memory/errors/2026-07-26_mission-control-dashboard-data-timeout.md
   // for why this file's soft-budget guards exist).
+  // serve.mjs hands back the last attempted result; reuse it while fresh so a
+  // snapshot every few seconds does not re-run the network call. Checked
+  // before the budget guard so a fresh cache never reads as "budget".
+  const cached = readCachedPipeline(process.env[PIPELINE_CACHE_ENV], Date.now());
+  if (cached) return cached;
   if (!withinSnapshotBudget(GH_RUN_LIST_TIMEOUT_MS + 400)) {
     // `gh` was never even attempted this snapshot — the shared budget ran out
     // first. Distinguished from a failed/timed-out call below so the UI does
@@ -597,6 +601,8 @@ function collectPipelineRuns() {
     // and the residual note this fix landed from) to an auth/install problem.
     return { available: false, runs: [], reason: "budget" };
   }
+  // fetchedAt marks an attempted call (cacheable); the budget miss above has none.
+  const fetchedAt = new Date().toISOString();
   try {
     // Trimmed to the fields renderDevopsPipelineCard() / navDevopsDot actually
     // read (workflow, status, conclusion, branch, event, createdAt). databaseId
@@ -616,7 +622,9 @@ function collectPipelineRuns() {
       { cwd: ROOT, encoding: "utf-8", timeout: GH_RUN_LIST_TIMEOUT_MS },
     );
     const rows = JSON.parse(out);
-    if (!Array.isArray(rows)) return { available: false, runs: [], reason: "call-failed" };
+    if (!Array.isArray(rows)) {
+      return { available: false, runs: [], reason: "call-failed", fetchedAt };
+    }
     const runs = rows.slice(0, MAX_PIPELINE_RUNS).map((r) => ({
       workflow: truncateStr(String(r.workflowName || ""), MAX_PIPELINE_NAME_CHARS),
       status: String(r.status || ""),
@@ -625,14 +633,14 @@ function collectPipelineRuns() {
       event: String(r.event || ""),
       createdAt: r.createdAt || null,
     }));
-    return { available: true, runs };
+    return { available: true, runs, fetchedAt };
   } catch {
-    // gh missing, unauthenticated, its own execSync timeout, or non-repo cwd
+    // gh missing, unauthenticated, its own execFileSync timeout, or non-repo cwd
     // all read the same to the caller: no pipeline signal for this snapshot.
     // Not further split (e.g. timeout vs auth) — that would need parsing the
-    // execSync error shape, which is more taxonomy than the empty-state copy
+    // execFileSync error shape, which is more taxonomy than the empty-state copy
     // needs; "call-failed" is enough to stop the UI from guessing "auth".
-    return { available: false, runs: [], reason: "call-failed" };
+    return { available: false, runs: [], reason: "call-failed", fetchedAt };
   }
 }
 
@@ -668,7 +676,12 @@ function parseLatestChangelogEntryForDeploySignal(changelog) {
 
 function collectDeploySignal() {
   if (!withinSnapshotBudget(400)) return { tags: [], changelog: null };
-  const gitOpts = { cwd: ROOT, encoding: "utf-8", timeout: 5000 };
+  const gitOpts = {
+    cwd: ROOT,
+    encoding: "utf-8",
+    timeout: 5000,
+    stdio: ["ignore", "pipe", "ignore"],
+  };
   let tags = [];
   try {
     // v*-only: an archive/* or other non-release tag under "what shipped
@@ -719,7 +732,7 @@ function collectDeploySignal() {
 // 7. Terminals (read from Cursor terminal files)
 const terminalsDir = resolve(process.env.HOME || "~", ".cursor", "projects");
 // Derive project path from ROOT rather than hardcoding a specific slug
-const projectSlug = ROOT.replace(/\//g, "-").replace(/^-/, "");
+const projectSlug = projectSlugFromRoot(ROOT);
 const terminalProjectPath = join(terminalsDir, projectSlug, "terminals");
 
 if (existsSync(terminalProjectPath)) {
@@ -831,38 +844,23 @@ try {
   if (!withinSnapshotBudget(500)) {
     SNAPSHOT.processes = [];
   } else {
-    const psOutput = execSync("ps -axo pid=,pcpu=,pmem=,etime=,command=", {
+    const psOutput = execFileSync("ps", ["-axo", "pid=,pcpu=,pmem=,etime=,command="], {
       encoding: "utf-8",
       timeout: 3000,
     }).trim();
     if (psOutput) {
-      const interesting = [];
-      for (const line of psOutput.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        if (!/node|git|serve\.mjs|dashboard/i.test(trimmed)) continue;
-        if (/grep|dashboard-data/.test(trimmed)) continue;
-        const parts = trimmed.split(/\s+/);
-        const pid = parts[0];
-        const cpu = parts[1];
-        const mem = parts[2];
-        const etime = parts[3];
-        const cmd = parts.slice(4).join(" ") || "unknown";
-        let label = "other";
-        if (cmd.includes("serve.mjs") || cmd.includes("node dashboard")) label = "dashboard-server";
-        else if (/\bgit\b/.test(cmd)) label = "git";
-        else if (cmd.includes("node")) label = "node";
-        interesting.push({
-          pid,
-          cpu,
-          mem,
-          etime,
-          command: truncateStr(cmd, MAX_STRING.processCommand),
-          label,
-          description: describeProcess({ label, command: cmd, cpu, etime }),
-        });
-        if (interesting.length >= MAX_PROCESSES) break;
-      }
+      // Workspace-scoped + redacted (lib/processes.mjs): never ship host-wide argv.
+      const interesting = selectWorkspaceProcesses(psOutput, {
+        root: ROOT,
+        servePath: SERVE_PATH,
+        redact: redactTerminalOutput,
+        truncate: truncateStr,
+        maxCommandChars: MAX_STRING.processCommand,
+        maxProcesses: MAX_PROCESSES,
+      }).map(({ fullCommand: cmd, ...row }) => {
+        const { label, cpu, etime } = row;
+        return { ...row, description: describeProcess({ label, command: cmd, cpu, etime }) };
+      });
       SNAPSHOT.processes = interesting;
     }
   }
@@ -881,8 +879,9 @@ try {
     const auditAges = [];
     const nowEpoch = Math.floor(Date.now() / 1000);
     try {
-      const tmuxOut = execSync(
-        "tmux list-sessions -F '#{session_name} #{session_attached} #{session_created}'",
+      const tmuxOut = execFileSync(
+        "tmux",
+        ["list-sessions", "-F", "#{session_name} #{session_attached} #{session_created}"],
         { encoding: "utf-8", timeout: 2000, stdio: ["ignore", "pipe", "ignore"] },
       );
       for (const line of tmuxOut.split("\n")) {
@@ -897,12 +896,17 @@ try {
       // tmux missing or no server: fail-open
     }
     try {
-      // `screen -ls` exits 1 while successfully listing, so soften the exit code.
-      const screenOut = execSync("screen -ls || true", {
-        encoding: "utf-8",
-        timeout: 2000,
-        stdio: ["ignore", "pipe", "ignore"],
-      });
+      // `screen -ls` exits 1 while successfully listing, so keep stdout from the error.
+      let screenOut = "";
+      try {
+        screenOut = execFileSync("screen", ["-ls"], {
+          encoding: "utf-8",
+          timeout: 2000,
+          stdio: ["ignore", "pipe", "ignore"],
+        });
+      } catch (err) {
+        screenOut = typeof err?.stdout === "string" ? err.stdout : "";
+      }
       // The "N Sockets in <dir>." line trails the session list; socket mtime ~ start time.
       let sockdir = null;
       for (const line of screenOut.split("\n")) {
@@ -984,7 +988,7 @@ SNAPSHOT.health.status = checks.every((c) => c.ok)
 function collectAgentPrompts() {
   if (!withinSnapshotBudget(800)) return [];
   const projectsDir = resolve(process.env.HOME || "~", ".cursor", "projects");
-  const slug = ROOT.replace(/\//g, "-").replace(/^-/, "");
+  const slug = projectSlugFromRoot(ROOT);
   const transcriptsDir = join(projectsDir, slug, "agent-transcripts");
   if (!existsSync(transcriptsDir)) return [];
 
@@ -1123,7 +1127,7 @@ function collectExternalReports() {
 function collectSubagentRuns() {
   if (!withinSnapshotBudget(700)) return [];
   const projectsDir = resolve(process.env.HOME || "~", ".cursor", "projects");
-  const slug = ROOT.replace(/\//g, "-").replace(/^-/, "");
+  const slug = projectSlugFromRoot(ROOT);
   const transcriptsDir = join(projectsDir, slug, "agent-transcripts");
   if (!existsSync(transcriptsDir)) return [];
 

package/dashboard/lib/guards.d.mts

@@ -129,6 +129,11 @@ export function mergeConfigAllowlist(
 ): Record<string, unknown>;
 export function allowlistConfig(raw: unknown): Record<string, unknown>;
 export function isAllowedOrigin(origin: unknown, port: unknown): boolean;
+export function isAllowedHostHeader(
+  hostHeader: unknown,
+  port: unknown,
+  opts?: { broadcast?: boolean; lanAddresses?: string[]; bindHost?: string },
+): boolean;
 export function applyCorsHeaders(
   req: GuardRequest,
   res: { setHeader: (name: string, value: string) => unknown },

package/dashboard/lib/guards.mjs

@@ -1072,6 +1072,37 @@ export function isAllowedOrigin(origin, port) {
   }
 }
 
+/**
+ * DNS-rebinding guard: accept only a Host header naming this server by a
+ * loopback literal (`localhost`, `127.0.0.1`, `[::1]`) on `port`. In broadcast
+ * mode a LAN IPv4 literal of this machine (or the IPv4 bind host) on `port` is
+ * accepted too. A hostname that merely resolves here (rebinding) never is.
+ * @param {unknown} hostHeader
+ * @param {unknown} port
+ * @param {{ broadcast?: boolean, lanAddresses?: string[], bindHost?: string }} [opts]
+ */
+export function isAllowedHostHeader(hostHeader, port, opts = {}) {
+  if (!hostHeader || typeof hostHeader !== "string") return false;
+  let url;
+  try {
+    url = new URL(`http://${hostHeader.trim()}`);
+  } catch {
+    return false;
+  }
+  if (url.username || url.password || url.pathname !== "/") return false;
+  const resolvedPort = url.port || "80";
+  if (resolvedPort !== String(port)) return false;
+  const name = url.hostname.toLowerCase();
+  if (name === "localhost" || name === "127.0.0.1" || name === "[::1]") return true;
+  if (!opts.broadcast) return false;
+  // The operator-chosen bind host (not a wildcard) names this server by definition.
+  const bind = typeof opts.bindHost === "string" ? opts.bindHost.trim().toLowerCase() : "";
+  if (bind && bind !== "0.0.0.0" && bind !== "::" && bind === name) return true;
+  if (!/^\d{1,3}(?:\.\d{1,3}){3}$/.test(name)) return false;
+  const lan = opts.lanAddresses ?? listLanIPv4Addresses();
+  return lan.includes(name);
+}
+
 export function applyCorsHeaders(req, res, port) {
   const origin = req.headers?.origin;
   if (isAllowedOrigin(origin, port)) {

package/dashboard/lib/identity-probe.mjs

@@ -0,0 +1,56 @@
+/**
+ * Ask a running Mission Control listener which workspace it serves.
+ *
+ * `/api/identity` answers without building a snapshot. A listener started by an
+ * older kit has no such route (HTTP error or a non-JSON page), so fall back once
+ * to the legacy `/dashboard-data.json` probe; otherwise an update would treat
+ * its own old server as a foreign process. A timeout never falls back.
+ */
+import { execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+
+const CURL_HTTP_ERROR = 22; // curl -f: server answered with status >= 400
+
+/** @param {unknown} root */
+function normalizeRoot(root) {
+  return typeof root === "string" && root.trim() ? resolve(root.trim()) : null;
+}
+
+/**
+ * @param {string} baseUrl e.g. `http://127.0.0.1:4242`
+ * @param {string} [query] e.g. `?token=…` (already encoded)
+ * @param {{ run?: typeof execFileSync }} [deps]
+ * @returns {string | null}
+ */
+export function probeListenerRoot(baseUrl, query = "", deps = {}) {
+  const run = deps.run ?? execFileSync;
+  let raw;
+  try {
+    raw = run("curl", ["-sf", `${baseUrl}/api/identity${query}`], {
+      encoding: "utf8",
+      timeout: 2000,
+    });
+  } catch (err) {
+    if (/** @type {{ status?: number }} */ (err)?.status !== CURL_HTTP_ERROR) return null;
+    return legacyRoot(run, baseUrl, query);
+  }
+  try {
+    return normalizeRoot(JSON.parse(raw)?.repoRoot);
+  } catch {
+    return legacyRoot(run, baseUrl, query);
+  }
+}
+
+/** @param {typeof execFileSync} run @param {string} baseUrl @param {string} query */
+function legacyRoot(run, baseUrl, query) {
+  try {
+    const raw = run("curl", ["-sf", `${baseUrl}/dashboard-data.json${query}`], {
+      encoding: "utf8",
+      timeout: 8000,
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    return normalizeRoot(JSON.parse(raw)?.system?.repoRoot);
+  } catch {
+    return null;
+  }
+}

package/dashboard/lib/pipeline-cache.mjs

@@ -0,0 +1,58 @@
+/**
+ * Cross-snapshot cache for the DevOps pipeline signal (`gh run list`).
+ *
+ * Mirrors the AGENT_KIT_PREV_INVENTORY hand-off: serve.mjs keeps the last
+ * `devops.pipeline` it saw and passes it back via AGENT_KIT_PREV_PIPELINE, so
+ * dashboard-data.mjs skips the network call while that result is fresh.
+ * Only results carrying `fetchedAt` (gh was actually attempted) are cacheable;
+ * a `reason: "budget"` miss never sticks.
+ */
+
+export const PIPELINE_CACHE_ENV = "AGENT_KIT_PREV_PIPELINE";
+export const PIPELINE_CACHE_TTL_MS = 60_000;
+
+/**
+ * @param {unknown} pipeline
+ * @returns {boolean}
+ */
+function isCacheablePipeline(pipeline) {
+  return (
+    !!pipeline &&
+    typeof pipeline === "object" &&
+    !Array.isArray(pipeline) &&
+    typeof pipeline.available === "boolean" &&
+    Array.isArray(pipeline.runs) &&
+    typeof pipeline.fetchedAt === "string" &&
+    Number.isFinite(Date.parse(pipeline.fetchedAt))
+  );
+}
+
+/**
+ * Cached pipeline from the env blob when younger than `ttlMs`, else null.
+ * @param {string | undefined} raw
+ * @param {number} nowMs
+ * @param {number} [ttlMs]
+ * @returns {object | null}
+ */
+export function readCachedPipeline(raw, nowMs, ttlMs = PIPELINE_CACHE_TTL_MS) {
+  if (!raw || typeof raw !== "string") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isCacheablePipeline(parsed)) return null;
+  const age = nowMs - Date.parse(parsed.fetchedAt);
+  return age >= 0 && age < ttlMs ? parsed : null;
+}
+
+/**
+ * Env blob for the next snapshot from a parsed snapshot, or null to keep the prior one.
+ * @param {unknown} snapshot
+ * @returns {string | null}
+ */
+export function pipelineCacheJsonFromSnapshot(snapshot) {
+  const pipeline = snapshot?.devops?.pipeline;
+  return isCacheablePipeline(pipeline) ? JSON.stringify(pipeline) : null;
+}

package/dashboard/lib/processes.mjs

@@ -0,0 +1,71 @@
+/**
+ * Process-list scoping for Mission Control snapshots.
+ *
+ * The snapshot ships command lines to every viewer (LAN in broadcast mode), so
+ * the list is scoped to this workspace: only commands that mention the
+ * snapshot root or the serve.mjs path survive, and each surviving command runs
+ * through the caller's secret redactor before truncation.
+ */
+
+/**
+ * True when `cmd` names `needle` as a whole path: the next character must end the
+ * path (`/`, whitespace, quote, `:` or end), so `/x/app` does not match `/x/app-other`.
+ */
+function mentionsPath(cmd, needle) {
+  let from = 0;
+  for (;;) {
+    const at = cmd.indexOf(needle, from);
+    if (at === -1) return false;
+    const next = cmd[at + needle.length];
+    if (next === undefined || /[\/\s"':]/.test(next)) return true;
+    from = at + 1;
+  }
+}
+
+/**
+ * Parse `ps -axo pid=,pcpu=,pmem=,etime=,command=` output into scoped rows.
+ * Pure: no process spawning, no fs. `command` is redacted then truncated; the
+ * returned `fullCommand` is redacted but untruncated (for local narration only).
+ *
+ * @param {string} psOutput
+ * @param {{
+ *   root: string,
+ *   servePath: string,
+ *   redact: (text: string) => string,
+ *   truncate: (text: string, max: number) => string,
+ *   maxCommandChars: number,
+ *   maxProcesses: number,
+ * }} opts
+ * @returns {Array<{ pid: string, cpu: string, mem: string, etime: string, command: string, fullCommand: string, label: string }>}
+ */
+export function selectWorkspaceProcesses(psOutput, opts) {
+  const { root, servePath, redact, truncate, maxCommandChars, maxProcesses } = opts;
+  const needles = [root, servePath].filter((s) => typeof s === "string" && s.length > 1);
+  const rows = [];
+  if (needles.length === 0) return rows;
+  for (const line of String(psOutput ?? "").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    const rawCmd = parts.slice(4).join(" ");
+    if (!rawCmd) continue;
+    if (!needles.some((n) => mentionsPath(rawCmd, n))) continue;
+    if (/grep|dashboard-data/.test(rawCmd)) continue;
+    const cmd = redact(rawCmd);
+    let label = "other";
+    if (cmd.includes("serve.mjs") || cmd.includes("node dashboard")) label = "dashboard-server";
+    else if (/\bgit\b/.test(cmd)) label = "git";
+    else if (cmd.includes("node")) label = "node";
+    rows.push({
+      pid: parts[0],
+      cpu: parts[1],
+      mem: parts[2],
+      etime: parts[3],
+      command: truncate(cmd, maxCommandChars),
+      fullCommand: cmd,
+      label,
+    });
+    if (rows.length >= maxProcesses) break;
+  }
+  return rows;
+}

package/dashboard/serve.mjs

@@ -18,6 +18,7 @@ import {
   applyCorsHeaders,
   authorizeMissionControlRequest,
   broadcastAuthCookieHeader,
+  isAllowedHostHeader,
   isAllowedOrigin,
   isLoopbackAddress,
   listLanIPv4Addresses,
@@ -35,6 +36,7 @@ import {
   resolveAgentTranscriptsWatchPath,
   resolveWatchPaths,
 } from "./lib/live-refresh.mjs";
+import { PIPELINE_CACHE_ENV, pipelineCacheJsonFromSnapshot } from "./lib/pipeline-cache.mjs";
 import { buildInventoryBaseline } from "./lib/semantic-model.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -53,6 +55,10 @@ const PORT = Number.parseInt(process.env.PORT || "3333", 10);
 const TOKEN_REQUIRED = authResolved.tokenRequired;
 const AUTH_TOKEN = authResolved.token;
 const DASHBOARD_REAL = realpathSync(DASHBOARD_DIR);
+// Resolved once at startup: the Host guard runs on every request, and an
+// os.networkInterfaces() walk per request is wasted work. Restart to pick up
+// a new LAN address (Wi-Fi rejoin).
+const LAN_ADDRESSES = authResolved.broadcast ? listLanIPv4Addresses() : [];
 
 const MIME = {
   ".html": "text/html; charset=utf-8",
@@ -69,6 +75,8 @@ const dataScript = join(__dirname, "dashboard-data.mjs");
 
 /** Compact inventory baseline fed back into the next data-script run via env. */
 let previousInventoryJson = null;
+/** Last attempted devops.pipeline (with fetchedAt); the data script reuses it while fresh. */
+let previousPipelineJson = null;
 
 /**
  * @param {string} payload
@@ -91,6 +99,19 @@ function inventoryBaselineJsonFromPayload(payload) {
   }
 }
 
+/**
+ * @param {string} payload
+ * @returns {string|null}
+ */
+function pipelineCacheJsonFromPayload(payload) {
+  try {
+    const data = JSON.parse(payload);
+    return data && !data.error ? pipelineCacheJsonFromSnapshot(data) : null;
+  } catch {
+    return null;
+  }
+}
+
 function setCorsHeaders(req, res) {
   applyCorsHeaders(req, res, PORT);
 }
@@ -262,6 +283,7 @@ function runDataScript() {
       [REPO_ROOT_ENV]: ROOT,
       // Empty string = cold start (dashboard-data treats falsy as no previous).
       AGENT_KIT_PREV_INVENTORY: previousInventoryJson || "",
+      [PIPELINE_CACHE_ENV]: previousPipelineJson || "",
     };
     execFile(
       process.execPath,
@@ -284,6 +306,8 @@ function runDataScript() {
         }
         const baseline = inventoryBaselineJsonFromPayload(stdout);
         if (baseline) previousInventoryJson = baseline;
+        const pipelineCache = pipelineCacheJsonFromPayload(stdout);
+        if (pipelineCache) previousPipelineJson = pipelineCache;
         resolve(stdout);
       },
     );
@@ -400,6 +424,18 @@ const server = createServer((req, res) => {
   const url = new URL(req.url, `http://127.0.0.1:${PORT}`);
   const path = url.pathname;
 
+  // DNS-rebinding guard: refuse foreign Host headers before any route runs.
+  if (
+    !isAllowedHostHeader(req.headers?.host, PORT, {
+      broadcast: authResolved.broadcast,
+      bindHost: HOST,
+      lanAddresses: LAN_ADDRESSES,
+    })
+  ) {
+    sendJson(res, 421, { error: "misdirected request: host not allowed" });
+    return;
+  }
+
   setCorsHeaders(req, res);
 
   if (path === "/api/config" && req.method === "OPTIONS") {
@@ -438,6 +474,12 @@ const server = createServer((req, res) => {
     res.setHeader("Set-Cookie", broadcastAuthCookieHeader(AUTH_TOKEN));
   }
 
+  // Cheap identity probe for start scripts: no snapshot work, same Host/auth gates.
+  if (path === "/api/identity" && req.method === "GET") {
+    sendJson(res, 200, { repoRoot: ROOT, tokenGated: TOKEN_REQUIRED });
+    return;
+  }
+
   // SSE endpoint
   if (path === "/api/events") {
     res.writeHead(200, {
@@ -530,7 +572,7 @@ server.listen(PORT, HOST, () => {
     console.log(`  Events:  ${url}/api/events (SSE)`);
     console.log(`  Config:  ${url}/api/config (PUT/PATCH, loopback)`);
   } else {
-    const lan = listLanIPv4Addresses();
+    const lan = LAN_ADDRESSES;
     const tokenQ = AUTH_TOKEN ? `?token=${encodeURIComponent(AUTH_TOKEN)}` : "";
     console.log(`  Bind:    ${HOST}:${PORT} (token-gated)`);
     console.log(`  Local:   http://127.0.0.1:${PORT}/${tokenQ}`);

package/dashboard/start-broadcast.mjs

@@ -39,6 +39,7 @@ import {
   resolveContextConfigPath,
   resolveSnapshotRepoRoot,
 } from "./lib/guards.mjs";
+import { probeListenerRoot } from "./lib/identity-probe.mjs";
 import { openBrowser, readPreferredBrowserFromConfig } from "./lib/open-browser.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -99,18 +100,7 @@ function probeHttp(url) {
 
 /** Snapshot root reported by a listener that accepts our token, else null. */
 function snapshotRootAt(port, token) {
-  const url = `http://127.0.0.1:${port}/dashboard-data.json?token=${encodeURIComponent(token)}`;
-  try {
-    const raw = execFileSync("curl", ["-sf", url], {
-      encoding: "utf8",
-      timeout: 8000,
-      maxBuffer: 10 * 1024 * 1024,
-    });
-    const root = JSON.parse(raw)?.system?.repoRoot;
-    return typeof root === "string" && root.trim() ? resolve(root.trim()) : null;
-  } catch {
-    return null;
-  }
+  return probeListenerRoot(`http://127.0.0.1:${port}`, `?token=${encodeURIComponent(token)}`);
 }
 
 /**

package/dashboard/start.mjs

@@ -29,6 +29,7 @@ import {
   resolveSnapshotRepoRoot,
   sameRepoRoot,
 } from "./lib/guards.mjs";
+import { probeListenerRoot } from "./lib/identity-probe.mjs";
 import { openBrowser, readPreferredBrowserFromConfig } from "./lib/open-browser.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -83,19 +84,7 @@ function listeningPids(port = PORT) {
 
 /** @returns {string | null} */
 function runningSnapshotRoot(port = PORT) {
-  const dataUrl = `http://${DISPLAY_HOST}:${port}/dashboard-data.json`;
-  try {
-    const raw = execFileSync("curl", ["-sf", dataUrl], {
-      encoding: "utf8",
-      timeout: 8000,
-      maxBuffer: 10 * 1024 * 1024,
-    });
-    const data = JSON.parse(raw);
-    const root = data?.system?.repoRoot;
-    return typeof root === "string" && root.trim() ? resolve(root.trim()) : null;
-  } catch {
-    return null;
-  }
+  return probeListenerRoot(`http://${DISPLAY_HOST}:${port}`);
 }
 
 /**