tmux-ide 2.9.0-beta.19 → 2.9.0-beta.21

package/packages/daemon/src/command-center/log-stream.ts

@@ -19,6 +19,7 @@ export async function streamBoundedLogs(
     entries?: number;
     bytes?: number;
     writeTimeoutMs?: number;
+    heartbeatIntervalMs?: number;
   },
 ): Promise<void> {
   const maxEntries = options.entries ?? 256;
@@ -29,6 +30,7 @@ export async function streamBoundedLogs(
   let wake: (() => void) | null = null;
   let unsubscribe = () => {};
   let timer: ReturnType<typeof setTimeout> | null = null;
+  let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
   let cancelWrite: (() => void) | null = null;
   const cleanup = () => {
     if (closed) return;
@@ -38,6 +40,8 @@ export async function streamBoundedLogs(
     bytes = 0;
     if (timer) clearTimeout(timer);
     timer = null;
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
     wake?.();
     wake = null;
     cancelWrite?.();
@@ -67,6 +71,10 @@ export async function streamBoundedLogs(
     unsubscribe();
     return;
   }
+  heartbeatTimer = setInterval(() => {
+    if (!closed && queue.length === 0 && !push({ event: "heartbeat", data: "keep-alive" })) abort();
+  }, options.heartbeatIntervalMs ?? 15_000);
+  heartbeatTimer.unref?.();
   try {
     // Keep newest bounded history, reserving room for gap/bookmark metadata.
     const retained: Frame[] = [];

package/packages/daemon/src/command-center/resources/fleet-preview-route.ts

@@ -15,6 +15,7 @@ type Capture = ((
     liveSessionId: string,
     signal?: AbortSignal,
     windowId?: string,
+    paneId?: string,
   ) => Promise<FleetPreviewSnapshot | null>;
 };
 const cleanText = (value: string) => stripVTControlCharacters(value).replace(/[^\P{Cc}\n\t]/gu, "");
@@ -26,6 +27,7 @@ export function createFleetPreviewCapture(
     liveSessionId: string,
     signal?: AbortSignal,
     windowId?: string,
+    paneId?: string,
   ): Promise<FleetPreviewSnapshot | null> => {
     const readSessions = async () => {
       const raw = await run(
@@ -76,8 +78,14 @@ export function createFleetPreviewCapture(
         );
     }
     const windowRows = rows.filter((row) => /^@\d+$/u.test(row[3] ?? ""));
+    const requestedPane = paneId ? windowRows.find((row) => row[0] === paneId) : undefined;
+    if (paneId && (!requestedPane || (windowId && requestedPane[3] !== windowId))) return null;
     const selectedWindowId =
-      windowId ?? windowRows.find((row) => row[1] === "1")?.[3] ?? windowRows[0]?.[3] ?? null;
+      requestedPane?.[3] ??
+      windowId ??
+      windowRows.find((row) => row[1] === "1")?.[3] ??
+      windowRows[0]?.[3] ??
+      null;
     if (windowId && !windowRows.some((row) => row[3] === windowId)) return null;
     const toWindow = (row: string[]): FleetPreviewWindow => ({
       id: row[3]!,
@@ -116,7 +124,7 @@ export function createFleetPreviewCapture(
     }
     windows.sort((a, b) => a.index - b.index);
     const candidates = selectedWindowId ? rows.filter((r) => r[3] === selectedWindowId) : rows;
-    const pane = candidates.find((r) => r[2] === "1")?.[0] ?? candidates[0]?.[0];
+    const pane = paneId ?? candidates.find((r) => r[2] === "1")?.[0] ?? candidates[0]?.[0];
     if (!pane || !/^%\d+$/u.test(pane)) return null;
     // Passive capture never changes active windows, size, input or terminal ownership.
     const captured = await run(["capture-pane", "-p", "-t", pane, "-S", "-24"], signal);
@@ -126,6 +134,7 @@ export function createFleetPreviewCapture(
       return null;
     return {
       windows,
+      selectedPaneId: pane,
       selectedWindowId,
       text: cleanText(captured)
         .split("\n")
@@ -141,6 +150,10 @@ export function createFleetPreviewCapture(
 }
 const requestSchema = z.strictObject({
   expectedInstanceId: z.uuid(),
+  paneId: z
+    .string()
+    .regex(/^%\d+$/u)
+    .optional(),
   windowId: z
     .string()
     .regex(/^@\d+$/u)
@@ -189,10 +202,15 @@ export function mountFleetPreviewRoute(
     pending = true;
     try {
       const signal = AbortSignal.any([c.req.raw.signal, AbortSignal.timeout(1500)]);
-      if (input.data.windowId && !options.capture.snapshot)
+      if ((input.data.windowId || input.data.paneId) && !options.capture.snapshot)
         return c.json({ error: "Window preview unavailable" }, 503);
       const snapshot = options.capture.snapshot
-        ? await options.capture.snapshot(input.data.liveSessionId, signal, input.data.windowId)
+        ? await options.capture.snapshot(
+            input.data.liveSessionId,
+            signal,
+            input.data.windowId,
+            input.data.paneId,
+          )
         : null;
       // Older capture providers remain valid for the original text-only contract.
       const legacy = !options.capture.snapshot
@@ -206,7 +224,11 @@ export function mountFleetPreviewRoute(
             liveSessionId: input.data.liveSessionId,
             text,
             ...(snapshot
-              ? { windows: snapshot.windows, selectedWindowId: snapshot.selectedWindowId }
+              ? {
+                  windows: snapshot.windows,
+                  selectedWindowId: snapshot.selectedWindowId,
+                  selectedPaneId: snapshot.selectedPaneId,
+                }
               : {}),
           });
     } catch {

package/packages/daemon/src/command-center/server.ts

@@ -155,6 +155,7 @@ import { mountWorkspaceResourceRoutes } from "./resources/workspace-resource-rou
 import { mountFleetResourceRoute } from "./resources/fleet-resource-route.ts";
 import { mountWorkspaceMissionsRoute } from "./resources/workspace-missions-route.ts";
 import { ownerAuthorityGate, requireOwnerAuthority } from "./owner-authority.ts";
+import { mountDiagnosticsRoute } from "./diagnostics.ts";
 import {
   mountStartupReadinessRoute,
   type StartupReadinessAttachmentAuthority,
@@ -532,6 +533,13 @@ export function createApp(options: CreateAppOptions = {}): Hono {
   // Allow cross-origin (Next.js dashboard, Tailscale, etc.)
   app.use("/*", cors());
 
+  // Owner-only reads use the same early routing boundary as issuance below:
+  // remote/project credentials neither authorize nor block the owner bearer.
+  mountDiagnosticsRoute(app, {
+    daemon: daemonInstanceIdentity,
+    ownerToken: options.remoteAccess?.ownerToken ?? null,
+  });
+
   // This exact route carries its own owner-only bearer and correlation gate.
   // Mount it before remote and project auth so a valid host capability is
   // neither rejected nor confused with any remotely shared user credential.

package/packages/daemon/src/doctor.ts

@@ -9,6 +9,10 @@ import { findCompiledTui, hasDevelopmentTuiSource, isBunAvailable } from "./tui/
 import { claudeSettingsPath } from "./tui/integrations/claude.ts";
 import { readNotificationPrefs, resolveNativeMacosNotifierPath } from "./tui/chrome/notify.ts";
 import { resolveConfig } from "./lib/resolved-config.ts";
+import {
+  collectDaemonProvenanceReport,
+  type DaemonProvenanceReport,
+} from "./lib/daemon-provenance.ts";
 
 interface CheckResult {
   label: string;
@@ -108,6 +112,55 @@ export function notifierRow(present: boolean): CheckResult {
   };
 }
 
+/**
+ * PURE — the "canonical daemon" row from a provenance report. Optional: a
+ * machine without a running daemon is healthy; the row exists so triage sees
+ * identity, supervisor and the real log destination without a second command.
+ */
+export function daemonProvenanceRow(report: DaemonProvenanceReport): CheckResult {
+  const label = "canonical daemon";
+  const historical = report.logFiles.filter((f) => f.status === "historical").length;
+  const suffix = historical
+    ? ` — ${historical} historical log file${historical === 1 ? "" : "s"} (see \`tmux-ide daemon info\`)`
+    : "";
+  const d = report.daemon;
+  switch (report.status) {
+    case "running":
+      return {
+        label,
+        pass: true,
+        detail:
+          `running v${d!.productVersion} pid ${d!.pid} (${d!.supervisor ?? "unknown supervisor"}) · ` +
+          `logs → ${d!.logDestination}${suffix}`,
+        optional: true,
+      };
+    case "stale-record":
+      return {
+        label,
+        pass: false,
+        detail: `record names pid ${d!.pid} (v${d!.productVersion}) but it is not running${suffix}`,
+        optional: true,
+      };
+    case "record-invalid":
+      return {
+        label,
+        pass: false,
+        detail: `record invalid (${report.record.status === "invalid" ? report.record.reason : "unknown"})${suffix}`,
+        optional: true,
+      };
+    default:
+      return {
+        label,
+        pass: true,
+        detail:
+          report.record.status === "reserved"
+            ? `not running (reserved for supervisor ${report.record.supervisionId})${suffix}`
+            : `not running${suffix}`,
+        optional: true,
+      };
+  }
+}
+
 function check(
   label: string,
   fn: () => string,
@@ -328,6 +381,23 @@ export async function doctor({
     ),
   );
 
+  // Canonical daemon identity + log provenance (credential-free), so a triage
+  // never chases a stale, manually redirected log file.
+  checks.push(
+    (() => {
+      try {
+        return daemonProvenanceRow(collectDaemonProvenanceReport());
+      } catch (e) {
+        return {
+          label: "canonical daemon",
+          pass: false,
+          detail: `provenance unavailable: ${(e as Error).message}`,
+          optional: true,
+        };
+      }
+    })(),
+  );
+
   // Native branded sender: only when the macOS channel is actually on.
   if (process.platform === "darwin" && readNotificationPrefs().macos) {
     checks.push(notifierRow(resolveNativeMacosNotifierPath() !== null));

package/packages/daemon/src/lib/app-config.ts

@@ -84,7 +84,9 @@ export interface AppThemeGlyphs {
  * reads as one system.
  */
 export interface AppTheme {
-  /** Explicit palette mode or terminal-following mode. Default keeps legacy dark visuals. */
+  /** Improve composed app text contrast. Default true. */
+  automaticContrast: boolean;
+  /** Explicit palette mode or terminal-following mode. Defaults to following the terminal. */
   mode: ThemeModeSetting;
   preset?: string;
   /** Primary/brand accent (default `colour75`). */
@@ -263,7 +265,8 @@ export const DEFAULT_APP_CONFIG: AppConfig = {
     panels: { explorer: "M-e", changes: "M-g", config: "M-," },
   },
   theme: {
-    mode: "dark",
+    automaticContrast: true,
+    mode: "system",
     accent: "colour75",
     muted: "colour240",
     fg: "colour250",
@@ -395,7 +398,12 @@ export function parseAppConfig(input: unknown): AppConfig {
       },
     },
     theme: {
-      mode: pickChoice(theme.mode, ["dark", "light", "system"], D.theme.mode),
+      automaticContrast: pickBool(theme.automaticContrast, D.theme.automaticContrast),
+      mode: pickChoice(
+        theme.mode,
+        ["dark", "light", "system"],
+        findVisualThemePreset(theme.preset)?.appearance ?? D.theme.mode,
+      ),
       ...(findVisualThemePreset(theme.preset) ? { preset: String(theme.preset) } : {}),
       accent: pickString(theme.accent, D.theme.accent),
       muted: pickString(theme.muted, D.theme.muted),

package/packages/daemon/src/lib/canonical-daemon.ts

@@ -646,6 +646,7 @@ export function writeCanonicalDaemonInfo(
     ...(info.environmentId !== undefined ? { environmentId: info.environmentId } : {}),
     bindHostname: info.bindHostname,
     authToken: info.authToken,
+    ...(info.provenance !== undefined ? { provenance: info.provenance } : {}),
   };
   writeFileSync(tmpPath, JSON.stringify(persisted, null, 2) + "\n", {
     encoding: "utf-8",

package/packages/daemon/src/lib/daemon-embed.ts

@@ -104,6 +104,8 @@ import {
 } from "./pane-source-credentials.ts";
 import { setActivationBackend, type ProjectActivationOptions } from "./active-projects.ts";
 import { readOrMintEnvironmentId } from "./environment-identity.ts";
+import { captureDaemonProvenance } from "./daemon-provenance.ts";
+import { registerLogSecret, setLogIdentity } from "./log.ts";
 import {
   canonicalDaemonUrl,
   clearCanonicalDaemonInfoIfOwned,
@@ -163,6 +165,12 @@ export function resolveDaemonProductVersion(
 export interface EmbeddedDaemonOptions {
   /** @internal Headless lifecycle only; explicit reservation, never inferred from ancestry. */
   supervisionId?: string;
+  /**
+   * @internal How this process came to own the daemon: the foreground
+   * `--headless` owner or a host embedding `startEmbeddedDaemon` directly.
+   * Stamped into the daemon record for triage; defaults to "embedded".
+   */
+  launcher?: "headless" | "embedded";
   /** @internal Successful previous generation stop in this same process. */
   predecessor?: CanonicalDaemonPredecessor;
   /** @internal Let the foreground lifecycle owner serialize settings restarts. */
@@ -1190,6 +1198,9 @@ async function startEmbeddedDaemonGeneration(
       internalReadOwnerToken: localBypassToken,
       registry: workspaceRegistry,
       tmuxAuthority,
+      // A gap cannot reconstruct historical interactions. Refresh inventory
+      // facts while authored operations retain their observation deadlines.
+      onGap: () => terminalInventoryRuntime?.invalidate(),
       onObserved: ({ workspaceName, semanticPaneId, operationKind, operationId }) => {
         if (operationKind !== "workspace.pane.read") terminalInventoryRuntime?.invalidate();
         if (operationId) {
@@ -1558,6 +1569,24 @@ async function startEmbeddedDaemonGeneration(
         console.error("[daemon] Direct terminal startup rollback reported cleanup failures.");
       }
     };
+    // Provenance (launcher, supervisor, actual stdout/stderr destination) is
+    // derived from this process, never from file-name conventions, so a later
+    // `daemon info` reads the truth from the record. Capture never throws;
+    // whatever it could not determine is reported as a warning.
+    const provenance = captureDaemonProvenance({
+      launcher: opts.launcher ?? "embedded",
+      ...(opts.supervisionId ? { supervisionId: opts.supervisionId } : {}),
+    });
+    if (provenance.warnings?.length && !opts.silent) {
+      for (const warning of provenance.warnings) {
+        console.warn(`[daemon] log provenance degraded: ${warning}`);
+      }
+    }
+    // Every structured record now carries this generation's identity, and the
+    // local bypass / shared tokens are redacted wherever they might appear.
+    setLogIdentity({ instanceId, version: productVersion });
+    registerLogSecret(localBypassToken);
+    registerLogSecret(opts.authToken);
     try {
       writeCanonicalDaemonInfo(
         {
@@ -1571,6 +1600,7 @@ async function startEmbeddedDaemonGeneration(
           environmentId,
           bindHostname,
           authToken: localBypassToken,
+          provenance,
         },
         claim,
       );