@dadado/agent-kit-cli 6.1.0 → 6.2.0

package/dashboard/README.md

@@ -31,7 +31,9 @@ A host page can replace the copy-to-clipboard default by defining
 every action is one `{ kind: "copy", text, subject, destination, toastMessage }` record. The web
 dashboard keeps the copy-only default. Contract, CSP readiness counts and the innerHTML sink
 audit: `docs/mission-control-embedding.md`. The snapshot shape is versioned by `dashboardDataVersion`
-and published as `docs/contracts/mission-control-snapshot.schema.json`.
+and published as `docs/contracts/mission-control-snapshot.schema.json`. The Flight Log lists pending
+operator tickets (gate exits awaiting triage) read-only from `gateExit`
+(`lib/gate-exit-tickets.mjs`, the no-fetch mirror of `agent-kit ground-control status`).
 
 ## Git tab and DevOps tab
 

package/dashboard/dashboard-data.mjs

@@ -7,6 +7,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { collectGateExitTickets } from "./lib/gate-exit-tickets.mjs";
 import {
   allowlistConfig,
   MAX_STRING,
@@ -132,7 +133,7 @@ function redactTerminalOutput(text) {
 
 const SNAPSHOT = {
   _schema: {
-    version: "1.5.0",
+    version: "1.6.0",
     description: "Mission Control dashboard data model",
     fields: {
       generatedAt: "ISO-8601 timestamp of snapshot generation",
@@ -151,6 +152,8 @@ const SNAPSHOT = {
         "Active Cursor terminal sessions with metadata, output line count, and capped lastOutput",
       runLogs:
         "Newest headless agent-kit run / tick logs from <state root>/loop-logs (AGENT_KIT_STATE_ROOT: .cursor by default, or .agent-kit; no ~/.cursor dependency): format, session id, capped last agent text, result, LOOP_TICK_RESULT line, HITL gate ids and reply stamps (1.5.0)",
+      gateExit:
+        "Pending operator tickets (read-only, never fetches): {marker: absent|ok|invalid, base, tickets[] (stamp, headline, askId, labels, trigger, openedAt, url, branch, branchState unmerged|merged|none, inMarker), skipped[] (latest launcher skip records), truncated} from .cursor/context/gate-exit.json and gate-exit/<stamp> branches; same contract as agent-kit ground-control status (1.6.0)",
       processes:
         "Running process snapshots (node, serve.mjs, git operations) with elapsed time and a generated narration per process",
       skills: "Available skills discovered in .cursor/skills/",
@@ -159,7 +162,7 @@ const SNAPSHOT = {
     },
   },
   generatedAt: new Date().toISOString(),
-  dashboardDataVersion: "1.5.0",
+  dashboardDataVersion: "1.6.0",
   plans: [],
   system: {
     repoRoot: ROOT,
@@ -171,6 +174,7 @@ const SNAPSHOT = {
   git: {},
   terminals: [],
   runLogs: [],
+  gateExit: { marker: "absent", base: "staging", tickets: [], skipped: [], truncated: false },
   processes: [],
   skills: [],
   health: { status: "ok", checks: [] },
@@ -779,6 +783,12 @@ if (withinSnapshotBudget(200)) {
   SNAPSHOT.runLogs = collectRunLogs(ROOT, { redact: redactTerminalOutput });
 }
 
+// 7c. Pending operator tickets (gate exits): marker + gate-exit/<stamp> branches, read-only and
+// without a fetch (the CLI's `ground-control status` fetches; a refresh must not).
+if (withinSnapshotBudget(200)) {
+  SNAPSHOT.gateExit = collectGateExitTickets(ROOT, { redact: redactTerminalOutput });
+}
+
 // 8. Config
 const configPath = join(ROOT, ".cursor", "context", "config.json");
 if (existsSync(configPath)) {
@@ -1372,6 +1382,7 @@ function readPreviousInventory() {
     flightLogLedger: collectFlightLogLedger(),
     cadenceLedger: collectCadenceLedger(),
     cadenceConfig: collectCadenceConfig(),
+    gateExitTickets: SNAPSHOT.gateExit?.tickets || [],
   });
   persistMissionTimingLedger(missionControl.timingLedger);
   persistFlightLogLedger(missionControl.flightLogLedger);

package/dashboard/dashboard.html

@@ -3397,6 +3397,23 @@ html[data-monitor-density="comfortable"] .live-activity-feed .monitor-row .monit
   gap: 6px;
   margin-bottom: 4px;
 }
+/* Pending operator tickets lane (read-only; prompt chrome via flightLogKindClassName). */
+.flight-log-tickets {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-bottom: 4px;
+}
+.flight-log-card-ticket {
+  cursor: default;
+}
+.flight-log-card-code {
+  margin-top: 6px;
+  font-family: var(--mc-font-mono);
+  font-size: 11px;
+  color: var(--text-secondary);
+  word-break: break-all;
+}
 .flight-log-card {
   display: block;
   width: 100%;
@@ -6499,6 +6516,13 @@ function snapshotPrevData(d) {
           quietOpenTriages: Array.isArray(d.missionControl.flightLog.quietOpenTriages)
             ? d.missionControl.flightLog.quietOpenTriages.map((i) => i?.id || i?.sourcePath || '')
             : [],
+          tickets: Array.isArray(d.missionControl.flightLog.tickets)
+            ? d.missionControl.flightLog.tickets.map((t) => ({
+                stamp: t?.stamp || '',
+                branchState: t?.branchState || '',
+                text: t?.text || '',
+              }))
+            : [],
         }
       : null,
   };
@@ -7445,6 +7469,52 @@ function renderFlightLogQuietOpenTriageCard(item, idx) {
   `;
 }
 
+/**
+ * Pending operator ticket card (gate exit awaiting triage). Read-only: no button,
+ * no handler; prompt chrome from flightLogKindClassName('prompt'). Triage stays in
+ * the CLI (`agent-kit ground-control`) or the `ticket` Ask; the card shows the command.
+ * @param {{ id?: string, stamp?: string, title?: string, text?: string, askId?: string|null, branch?: string|null, branchState?: string, url?: string|null, triage?: string, sourcePath?: string }} ticket
+ * @param {number} idx
+ */
+function renderFlightLogTicketCard(ticket, idx) {
+  const stamp = typeof ticket?.stamp === 'string' ? ticket.stamp.trim() : '';
+  const text = typeof ticket?.text === 'string' ? ticket.text.trim() : '';
+  if (!stamp || !text) return '';
+  const title =
+    typeof ticket?.title === 'string' && ticket.title.trim() ? ticket.title.trim() : 'Pending ticket';
+  const state =
+    ticket?.branchState === 'merged'
+      ? 'merged, ready to accept'
+      : ticket?.branchState === 'unmerged'
+        ? 'awaiting merge'
+        : 'no gate-exit branch';
+  const metaBits = [];
+  if (typeof ticket?.askId === 'string' && ticket.askId) metaBits.push(`Ask ${escapeHtml(ticket.askId)}`);
+  metaBits.push(
+    escapeHtml(typeof ticket?.branch === 'string' && ticket.branch ? `${ticket.branch} (${state})` : state),
+  );
+  if (typeof ticket?.url === 'string' && /^https?:\/\//.test(ticket.url)) metaBits.push(escapeHtml(ticket.url));
+  const triage = typeof ticket?.triage === 'string' && ticket.triage.trim() ? ticket.triage.trim() : '';
+  const aria = `${title} ${stamp}: ${text}`;
+  const kindClass = flightLogKindClassName('prompt');
+  return `
+    <div class="flight-log-card flight-log-card-current flight-log-card-ticket ${kindClass}" role="listitem" tabindex="0" data-focus-key="flight-log-ticket-${idx}" data-flight-log-kind="prompt" data-ticket-stamp="${escapeAttr(stamp)}" aria-label="${escapeAttr(aria)}">
+      <span class="flight-log-card-label">${escapeHtml(title)} · ${escapeHtml(stamp)}</span>
+      <div class="flight-log-card-text">${escapeHtml(text)}</div>
+      <div class="flight-log-card-meta">${metaBits.join(' · ')}</div>
+      ${triage ? `<div class="flight-log-card-code">${escapeHtml(triage)}</div>` : ''}
+    </div>
+  `;
+}
+
+/** Pending ticket rows on the Flight Log (stamp + text required, as the card renders). */
+function flightLogTicketEntries(fl) {
+  if (!fl || !Array.isArray(fl.tickets)) return [];
+  return fl.tickets.filter(
+    (t) => t && typeof t.stamp === 'string' && t.stamp.trim() && typeof t.text === 'string' && t.text.trim(),
+  );
+}
+
 /**
  * Resolve Live Gaps text for Flight Log render + fingerprint (same fallback chain).
  * Prefer fl.current; with Plan:none, fall back to now.gaps then system.handoff.gaps.
@@ -7537,6 +7607,16 @@ function renderAttentionPanel(d, attentionChanged) {
     .filter(Boolean)
     .join('');
   const hasOpenTriages = openTriageCards.length > 0;
+  // Pending operator tickets render above every branch: a ticket never falls through to All clear.
+  const tickets = flightLogTicketEntries(fl);
+  const ticketCards = tickets
+    .map((t, idx) => renderFlightLogTicketCard(t, idx))
+    .filter(Boolean)
+    .join('');
+  const hasTickets = ticketCards.length > 0;
+  const ticketsBlock = hasTickets
+    ? `<div class="flight-log-tickets" role="list" aria-label="Pending operator tickets (Ground Control)">${ticketCards}</div>`
+    : '';
 
   let body;
   const hasCurrent = Boolean(current);
@@ -7546,6 +7626,8 @@ function renderAttentionPanel(d, attentionChanged) {
   if (!hasCurrent && !hasPast && !hasWarnings) {
     if (hasOpenTriages) {
       body = `<div class="flight-log-stack" role="list" aria-label="Reviews awaiting triage">${openTriageCards}</div>`;
+    } else if (hasTickets) {
+      body = '';
     } else {
       body = renderEmptyStateCta({
         headline: 'All clear',
@@ -7578,8 +7660,9 @@ function renderAttentionPanel(d, attentionChanged) {
         </div>`;
     body = `${warningsBlock}<div class="flight-log-stack" role="list">${currentCard}${pastCards}</div>`;
   }
+  body = `${ticketsBlock}${body}`;
 
-  const countLabel = hasCurrent
+  const baseCountLabel = hasCurrent
     ? hasPast
       ? `1 · ${past.length} earlier${hasWarnings ? ` · ${warnings.length} warn` : ''}`
       : hasWarnings
@@ -7592,6 +7675,12 @@ function renderAttentionPanel(d, attentionChanged) {
         : hasOpenTriages
           ? `${quietOpenTriages.length} review`
           : 'Clear';
+  const ticketCountLabel = hasTickets ? `${tickets.length} ticket${tickets.length === 1 ? '' : 's'}` : '';
+  const countLabel = !ticketCountLabel
+    ? baseCountLabel
+    : baseCountLabel === 'Clear'
+      ? ticketCountLabel
+      : `${ticketCountLabel} · ${baseCountLabel}`;
 
   return `
     <div class="card${attentionChanged ? ' card-flash' : ''}" id="attention-panel">
@@ -7695,9 +7784,13 @@ function flightLogFingerprint(d) {
           )
           .join('\n')
       : '';
+  // Pending tickets: stamp + merge state + headline, so a merge or a new note re-renders.
+  const tickets = flightLogTicketEntries(fl)
+    .map((t) => `${t.stamp}|${t.branchState || ''}|${t.text}`)
+    .join('\n');
   // Busy-outside-plan header chip must re-render the card on flip.
   const busy = (d.missionControl?.now ?? d.now)?.busyOutsidePlan?.active === true;
-  return `${current}\0${past}\0${warnings}\0${openTriages}\0${busy ? 'busy' : ''}`;
+  return `${current}\0${past}\0${warnings}\0${openTriages}\0${tickets}\0${busy ? 'busy' : ''}`;
 }
 
 // Step progress bar: one segment per plan step (completed / current / remaining).

package/dashboard/lib/gate-exit-tickets.d.mts

@@ -0,0 +1,45 @@
+/** Ambient types for dashboard/lib/gate-exit-tickets.mjs (consumed by CLI TypeScript). */
+
+export const GATE_EXIT_BRANCH_PREFIX: "gate-exit/";
+export const GATE_EXIT_MARKER_RELPATH: ".cursor/context/gate-exit.json";
+export const GATE_EXIT_NOTE_DIR: ".cursor/gate-exit";
+export const GATE_EXIT_DEFAULT_BASE: "staging";
+export const GATE_EXIT_STAMP_RE: RegExp;
+export const MAX_GATE_EXIT_TICKETS: 10;
+export const MAX_GATE_EXIT_SKIPPED: 5;
+export const MAX_GATE_EXIT_TEXT: 300;
+
+export type GitRunner = (args: string[]) => { code: number; stdout: string };
+
+export interface GateExitTicketRow {
+  stamp: string;
+  headline: string | null;
+  askId: string | null;
+  labels: string[];
+  trigger: "gate" | "stopped-by-operator" | "failure" | null;
+  openedAt: string | null;
+  url: string | null;
+  branch: string | null;
+  branchState: "unmerged" | "merged" | "none";
+  inMarker: boolean;
+}
+
+export interface GateExitTickets {
+  marker: "absent" | "ok" | "invalid";
+  base: string;
+  tickets: GateExitTicketRow[];
+  skipped: string[];
+  truncated: boolean;
+}
+
+export function makeGitRunner(root: string, timeoutMs?: number): GitRunner;
+export function readGateExitMarkerSync(
+  root: string,
+):
+  | { kind: "absent" }
+  | { kind: "invalid" }
+  | { kind: "ok"; pending: Record<string, unknown>[]; skipped: string[] };
+export function collectGateExitTickets(
+  root: string,
+  opts?: { git?: GitRunner; redact?: (s: string) => string; max?: number },
+): GateExitTickets;

package/dashboard/lib/gate-exit-tickets.mjs

@@ -0,0 +1,233 @@
+/**
+ * Pending operator tickets for Mission Control (ADR 2026-10-08
+ * countdown-coming-home-generic-lane point 3: "Mission Control shows pending
+ * tickets read-only in the Flight Log").
+ *
+ * Mirrors the read half of `groundControlStatus`
+ * (packages/cli/src/commands/ground-control.ts) on the same contract: the
+ * gitignored marker `.cursor/context/gate-exit.json`, `gate-exit/<UTC stamp>`
+ * branches, the note at `.cursor/gate-exit/<stamp>.md` (first line = ticket
+ * headline), and the same merged test (branch tip is an ancestor of the base,
+ * or the base holds the note blob byte for byte). A parity test pins this file
+ * to the CLI (packages/cli/src/dashboard/gate-exit-tickets.test.ts).
+ *
+ * Unlike `agent-kit ground-control status` this never fetches: the dashboard
+ * re-snapshots on every refresh, so it shows the last fetched state. It never
+ * writes, never throws, and costs one `git for-each-ref` when there is no
+ * marker and no gate-exit branch.
+ */
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const GATE_EXIT_BRANCH_PREFIX = "gate-exit/";
+export const GATE_EXIT_MARKER_RELPATH = ".cursor/context/gate-exit.json";
+export const GATE_EXIT_NOTE_DIR = ".cursor/gate-exit";
+export const GATE_EXIT_DEFAULT_BASE = "staging";
+export const GATE_EXIT_STAMP_RE = /^\d{8}T\d{6}Z$/;
+export const MAX_GATE_EXIT_TICKETS = 10;
+export const MAX_GATE_EXIT_SKIPPED = 5;
+export const MAX_GATE_EXIT_TEXT = 300;
+
+const SAFE_REF_RE = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+const TRIGGERS = new Set(["gate", "stopped-by-operator", "failure", "review"]);
+
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+
+function cap(text, max = MAX_GATE_EXIT_TEXT) {
+  const s = String(text ?? "").trim();
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+
+function isSafeBaseRef(ref) {
+  return (
+    typeof ref === "string" &&
+    SAFE_REF_RE.test(ref) &&
+    !ref.includes("..") &&
+    !ref.endsWith("/") &&
+    !ref.endsWith(".lock")
+  );
+}
+
+/** Synchronous git runner: `{ code, stdout }`, never throws. */
+export function makeGitRunner(root, timeoutMs = 5000) {
+  return (args) => {
+    try {
+      const stdout = execFileSync("git", args, {
+        cwd: root,
+        encoding: "utf-8",
+        timeout: timeoutMs,
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+      return { code: 0, stdout };
+    } catch (err) {
+      const status = isRecord(err) && typeof err.status === "number" ? err.status : 1;
+      return { code: status || 1, stdout: "" };
+    }
+  };
+}
+
+/** Marker read with the CLI's validation (`readGateExitMarker`). */
+export function readGateExitMarkerSync(root) {
+  let raw;
+  try {
+    raw = readFileSync(join(root, GATE_EXIT_MARKER_RELPATH), "utf8");
+  } catch (err) {
+    if (isRecord(err) && err.code === "ENOENT") return { kind: "absent" };
+    return { kind: "invalid" };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed) || parsed.schema !== 1) return { kind: "invalid" };
+    if (!Array.isArray(parsed.pending) || !Array.isArray(parsed.skipped)) {
+      return { kind: "invalid" };
+    }
+    const pending = parsed.pending.filter(
+      (e) => isRecord(e) && typeof e.stamp === "string" && GATE_EXIT_STAMP_RE.test(e.stamp),
+    );
+    return { kind: "ok", pending, skipped: parsed.skipped.map(String) };
+  } catch {
+    return { kind: "invalid" };
+  }
+}
+
+/** Base ref chain of `resolveGateExitRefs`: origin/<base>, origin/HEAD, local <base>, HEAD. */
+function resolveBaseRef(git, hasOrigin, requested) {
+  let base = isSafeBaseRef(requested) ? requested : GATE_EXIT_DEFAULT_BASE;
+  const verify = (ref) => git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]).code === 0;
+  if (hasOrigin) {
+    if (verify(`refs/remotes/origin/${base}`))
+      return { base, baseRef: `refs/remotes/origin/${base}` };
+    const head = git(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]);
+    const fallback = head.stdout.trim().replace(/^origin\//, "");
+    if (head.code === 0 && isSafeBaseRef(fallback)) {
+      base = fallback;
+      return { base, baseRef: `refs/remotes/origin/${fallback}` };
+    }
+    return { base, baseRef: "HEAD" };
+  }
+  if (verify(`refs/heads/${base}`)) return { base, baseRef: `refs/heads/${base}` };
+  return { base, baseRef: "HEAD" };
+}
+
+function blobId(git, spec) {
+  const r = git(["rev-parse", "--verify", "--quiet", spec]);
+  const id = r.stdout.trim();
+  return r.code === 0 && id ? id : null;
+}
+
+function notePath(stamp) {
+  return `${GATE_EXIT_NOTE_DIR}/${stamp}.md`;
+}
+
+function isMerged(git, branchRef, baseRef, stamp) {
+  if (git(["merge-base", "--is-ancestor", branchRef, baseRef]).code === 0) return true;
+  const onBranch = blobId(git, `${branchRef}:${notePath(stamp)}`);
+  return onBranch !== null && onBranch === blobId(git, `${baseRef}:${notePath(stamp)}`);
+}
+
+function readHeadline(git, ref, stamp) {
+  const shown = git(["show", `${ref}:${notePath(stamp)}`]);
+  if (shown.code !== 0) return null;
+  const first = shown.stdout.split("\n")[0]?.trim() ?? "";
+  return first || null;
+}
+
+function stampOfBranch(short) {
+  const i = short.lastIndexOf(GATE_EXIT_BRANCH_PREFIX);
+  if (i < 0) return null;
+  const stamp = short.slice(i + GATE_EXIT_BRANCH_PREFIX.length);
+  return GATE_EXIT_STAMP_RE.test(stamp) ? stamp : null;
+}
+
+function shortRef(ref) {
+  return ref.replace(/^refs\/remotes\//, "").replace(/^refs\/heads\//, "");
+}
+
+function emptyResult(marker, base = GATE_EXIT_DEFAULT_BASE) {
+  return { marker, base, tickets: [], skipped: [], truncated: false };
+}
+
+/**
+ * Pending operator tickets: marker entries plus unmerged gate-exit branches
+ * (remote-tracking and local) with no entry. A merged branch with no entry is
+ * history and is hidden, as in `ground-control status`.
+ * @param {string} root
+ * @param {{ git?: (args: string[]) => { code: number, stdout: string }, redact?: (s: string) => string, max?: number }} [opts]
+ */
+export function collectGateExitTickets(root, opts = {}) {
+  const redact = typeof opts.redact === "function" ? opts.redact : (s) => s;
+  const max = Number.isInteger(opts.max) && opts.max > 0 ? opts.max : MAX_GATE_EXIT_TICKETS;
+  const git = opts.git ?? makeGitRunner(root);
+  const marker = readGateExitMarkerSync(root);
+  const entries = marker.kind === "ok" ? marker.pending : [];
+  const skipped =
+    marker.kind === "ok" ? marker.skipped.slice(-MAX_GATE_EXIT_SKIPPED).map((s) => cap(s, 80)) : [];
+
+  const listed = git([
+    "for-each-ref",
+    "--format=%(refname)",
+    `refs/remotes/origin/${GATE_EXIT_BRANCH_PREFIX}`,
+    `refs/heads/${GATE_EXIT_BRANCH_PREFIX}`,
+  ]);
+  const branchRefs = listed.code === 0 ? listed.stdout.split("\n").filter((l) => l.trim()) : [];
+  if (entries.length === 0 && branchRefs.length === 0) {
+    return { ...emptyResult(marker.kind), skipped };
+  }
+
+  const hasOrigin = git(["remote", "get-url", "origin"]).code === 0;
+  const defaultRefs = resolveBaseRef(git, hasOrigin, GATE_EXIT_DEFAULT_BASE);
+  // Same scopes as the CLI: with an origin, remote-tracking + local heads; without, local heads.
+  const remoteScope = `refs/remotes/origin/${GATE_EXIT_BRANCH_PREFIX}`;
+  const present = new Set(branchRefs);
+  const stamps = new Set(entries.map((e) => e.stamp));
+  for (const ref of branchRefs) {
+    if (!hasOrigin && ref.startsWith(remoteScope)) continue;
+    const stamp = stampOfBranch(shortRef(ref));
+    if (stamp) stamps.add(stamp);
+  }
+
+  const tickets = [];
+  const ordered = [...stamps].sort();
+  for (const stamp of ordered) {
+    const entry = entries.find((e) => e.stamp === stamp);
+    const remote = `refs/remotes/origin/${GATE_EXIT_BRANCH_PREFIX}${stamp}`;
+    const local = `refs/heads/${GATE_EXIT_BRANCH_PREFIX}${stamp}`;
+    const branchRef = hasOrigin && present.has(remote) ? remote : present.has(local) ? local : null;
+    const refs =
+      entry && isSafeBaseRef(entry.base) && entry.base !== defaultRefs.base
+        ? resolveBaseRef(git, hasOrigin, entry.base)
+        : defaultRefs;
+    let branchState = "none";
+    if (branchRef) {
+      branchState = isMerged(git, branchRef, refs.baseRef, stamp) ? "merged" : "unmerged";
+    }
+    if (!entry && branchState === "merged") continue;
+    const headline =
+      (branchRef ? readHeadline(git, branchRef, stamp) : null) ??
+      readHeadline(git, refs.baseRef, stamp);
+    const url = typeof entry?.url === "string" && /^https?:\/\//.test(entry.url) ? entry.url : null;
+    tickets.push({
+      stamp,
+      headline: headline ? cap(redact(headline)) : null,
+      askId: typeof entry?.askId === "string" ? cap(entry.askId, 64) : null,
+      labels: Array.isArray(entry?.labels)
+        ? entry.labels.slice(0, 8).map((l) => cap(redact(String(l)), 80))
+        : [],
+      trigger: TRIGGERS.has(entry?.trigger) ? entry.trigger : null,
+      openedAt: typeof entry?.openedAt === "string" ? cap(entry.openedAt, 40) : null,
+      url: url ? cap(redact(url), 300) : null,
+      branch: branchRef ? shortRef(branchRef) : null,
+      branchState,
+      inMarker: Boolean(entry),
+    });
+  }
+
+  return {
+    marker: marker.kind,
+    base: defaultRefs.base,
+    tickets: tickets.slice(0, max),
+    skipped,
+    truncated: tickets.length > max,
+  };
+}

package/dashboard/lib/semantic-model.d.mts

@@ -32,3 +32,24 @@ export type HandoffMarkdown = {
 };
 
 export function parseHandoffMarkdown(content: string): HandoffMarkdown | null;
+
+/** Flight Log pending operator tickets lane (read-only rows). */
+export type FlightLogTicket = {
+  id: string;
+  stamp: string;
+  title: string;
+  text: string;
+  askId: string | null;
+  branch: string | null;
+  branchState: "unmerged" | "merged" | "none";
+  url: string | null;
+  triage: string;
+  sourcePath: string;
+};
+
+export const FLIGHT_LOG_TICKETS_CAP: 5;
+
+export function buildFlightLogTickets(
+  tickets: Record<string, unknown>[] | null | undefined,
+  opts?: { cap?: number },
+): FlightLogTicket[];

package/dashboard/lib/semantic-model.mjs

@@ -643,6 +643,51 @@ export function listFlightLogQuietOpenTriages(reportOrAttentionItems, opts = {})
   return out;
 }
 
+/** Cap pending operator tickets on the Flight Log tickets lane. */
+export const FLIGHT_LOG_TICKETS_CAP = 5;
+
+/**
+ * Pending operator tickets for the Flight Log (read-only; prompt chrome).
+ * Input rows come from `collectGateExitTickets` (dashboard/lib/gate-exit-tickets.mjs,
+ * the read half of `agent-kit ground-control status`). No action: triage stays
+ * in the CLI (`ground-control accept|discard <stamp>`) or the `ticket` Ask.
+ * @param {object[]|null|undefined} tickets
+ * @param {{ cap?: number }} [opts]
+ * @returns {{ id: string, stamp: string, title: string, text: string, askId: string|null, branch: string|null, branchState: string, url: string|null, triage: string, sourcePath: string }[]}
+ */
+export function buildFlightLogTickets(tickets, opts = {}) {
+  const cap =
+    typeof opts.cap === "number" && opts.cap > 0 ? Math.floor(opts.cap) : FLIGHT_LOG_TICKETS_CAP;
+  if (!Array.isArray(tickets)) return [];
+  const out = [];
+  for (const t of tickets) {
+    if (!t || typeof t.stamp !== "string" || !/^\d{8}T\d{6}Z$/.test(t.stamp)) continue;
+    const headline =
+      typeof t.headline === "string" && t.headline.trim()
+        ? t.headline.replace(/^#\s*/, "").trim()
+        : `Gate exit ${t.stamp} (note not readable)`;
+    const branchState =
+      t.branchState === "merged" || t.branchState === "unmerged" ? t.branchState : "none";
+    out.push({
+      id: `flight-log-ticket:${t.stamp}`,
+      stamp: t.stamp,
+      title: "Pending ticket",
+      text: truncateStr(headline, MAX_SEMANTIC_LABEL),
+      askId: typeof t.askId === "string" && t.askId ? t.askId : null,
+      branch: typeof t.branch === "string" && t.branch ? t.branch : null,
+      branchState,
+      url: typeof t.url === "string" && /^https?:\/\//.test(t.url) ? t.url : null,
+      triage:
+        branchState === "merged"
+          ? `agent-kit ground-control accept ${t.stamp}`
+          : `agent-kit ground-control accept|discard ${t.stamp}`,
+      sourcePath: t.inMarker ? ".cursor/context/gate-exit.json" : t.branch || "gate-exit/",
+    });
+    if (out.length >= cap) break;
+  }
+  return out;
+}
+
 /** Relative path of the gitignored Field Report activity cadence ledger. */
 export const FIELD_REPORT_CADENCE_LEDGER_REL = ".cursor/context/field-report-cadence.json";
 
@@ -3790,6 +3835,7 @@ export function buildMissionControlView({
   flightLogLedger = null,
   cadenceLedger = null,
   cadenceConfig = null,
+  gateExitTickets = [],
   nowMs = Date.now(),
 } = {}) {
   const nowBase = buildCurrentExecution(plans, handoff);
@@ -3814,6 +3860,7 @@ export function buildMissionControlView({
     },
   );
   flightLog.warnings = buildFlightLogWarnings(handoff);
+  flightLog.tickets = buildFlightLogTickets(gateExitTickets);
   const classifiedPlans = enrichPlans(plans, handoff);
   const planEvents = formatPlanHandoffActivity({ now, handoff, plans });
   const inventoryEvents = formatInventoryActivity(

package/dist/{add-YTCDLPUS.js → add-Y2426TGU.js}

@@ -5,7 +5,7 @@ import {
 import {
   REGISTRY_CLI_ARGS,
   resolveRegistryFromCli
-} from "./chunk-3DGTPONS.js";
+} from "./chunk-C2SJDYAM.js";
 import {
   logger
 } from "./chunk-ZB43YMHW.js";
@@ -22,11 +22,11 @@ import {
   resolveProtectedGlobs,
   saveManifest,
   upsertIdList
-} from "./chunk-DBPNGZNH.js";
+} from "./chunk-NSSXSZLL.js";
 import {
   KIT_VERSION
 } from "./chunk-7HDQEK6T.js";
-import "./chunk-C26I6HTO.js";
+import "./chunk-C4Q77GGJ.js";
 import "./chunk-5B4DVO6C.js";
 
 // src/commands/add.ts

package/dist/{chunk-PCCQUWE5.js → chunk-3LLXDHIU.js}

@@ -2,7 +2,7 @@ import {
   REPO_ROOT_ENV,
   bundledDashboardCandidates,
   findDashboardStart
-} from "./chunk-HFUH3HVS.js";
+} from "./chunk-XDCCYBCJ.js";
 import {
   HELMET_ACCENT,
   HELMET_FILL,

package/dist/{chunk-YP4OOK4T.js → chunk-BEKQ6PVD.js}

@@ -5,7 +5,7 @@ import {
   RESOLVE_AGENT_KIT_REL,
   SESSION_START_HOOK_MARKER,
   discoverInstalledCommands
-} from "./chunk-PPKX55GI.js";
+} from "./chunk-SPYIP76F.js";
 import {
   findOnPath
 } from "./chunk-WGLPZXNU.js";
@@ -18,7 +18,7 @@ import {
   REQUIRED_SECRET_PATTERNS,
   detectGitDirty,
   runScanner
-} from "./chunk-U5F6RJN4.js";
+} from "./chunk-GO3K752H.js";
 import {
   CONTEXT_CONFIG_REL,
   contextConfigPath

package/dist/{chunk-3DGTPONS.js → chunk-C2SJDYAM.js}

@@ -5,7 +5,7 @@ import {
   DEFAULT_REGISTRY_REF,
   DEFAULT_REGISTRY_URL,
   resolveRegistryRoot
-} from "./chunk-DBPNGZNH.js";
+} from "./chunk-NSSXSZLL.js";
 
 // src/lifecycle/resolve-cli.ts
 async function resolveRegistryFromCli(options) {

package/dist/{chunk-C26I6HTO.js → chunk-C4Q77GGJ.js}

@@ -23,7 +23,6 @@ function runnerStatePaths(root, env = process.env) {
 }
 async function ensureLoopLogsDir(paths) {
   await mkdir(paths.loopLogsDir, { recursive: true });
-  if (paths.stateDir === ".cursor") return;
   const ignore = path.join(paths.loopLogsDir, ".gitignore");
   try {
     await writeFile(ignore, "*\n", { flag: "wx" });