@tempo-ai/mcp 0.0.106 → 0.0.107

package/dist/{serve-7RSR6WI6.js → serve-IXP2WX42.js}

@@ -5907,14 +5907,15 @@ var TOOL_MANIFEST = [
     "docs_move",
     "docs_delete"
   ]),
-  // ── comments (16) ───────────────────────────────────────────────────────
+  // ── comments (17) ───────────────────────────────────────────────────────
   ...read("comments", [
     "comments_list_for_canvas",
     "comments_get_thread",
     "comments_list_unread_notifications",
     "comments_list_activity_for_canvas",
     "comments_list_threads_in_org",
-    "comments_search"
+    "comments_search",
+    "comments_get_pr_visual_review"
   ]),
   ...write("comments", [
     "comments_create_thread",
@@ -10752,9 +10753,169 @@ function refineByMessage(message, details) {
   return { code: "internal", message, details };
 }
 
+// ../canvas-comments-mcp/tools/pr-visual-review.ts
+var VISUAL_REVIEW_STATUS_CONTEXT = "visual-review";
+var VISUAL_REVIEW_STICKY_MARKER = "<!-- tempo-visual-review -->";
+var INTENTIONAL_NO_REPORT = /bypass|not applicable|no visual change/i;
+var REPORT_KEY = /^[A-Za-z0-9_-]{16,128}$/;
+var REPORT_KEY_IN_TEXT = /[?&]k=([A-Za-z0-9_-]{16,128})/;
+var GitHubApiError = class extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "GitHubApiError";
+    this.status = options.status;
+    this.unavailable = options.unavailable ?? false;
+  }
+};
+function normalizeGitHubRepo(value) {
+  const trimmed2 = value.trim();
+  if (!trimmed2) return null;
+  const candidates = [trimmed2];
+  if (/^github\.com\//i.test(trimmed2)) {
+    candidates.push(`https://${trimmed2}`);
+  } else if (/^[^/:@\s]+\/[^/\s]+$/.test(trimmed2)) {
+    candidates.push(`https://github.com/${trimmed2}`);
+  }
+  for (const candidate of candidates) {
+    const normalized = normalizeRepoUrl(candidate);
+    if (normalized && /^github\.com\/[^/]+\/[^/]+$/.test(normalized)) {
+      return normalized;
+    }
+  }
+  return null;
+}
+function parseVisualReviewPrInput(pr, repository) {
+  let prNumber = null;
+  let repo = repository ?? null;
+  if (typeof pr === "number") {
+    prNumber = Number.isInteger(pr) && pr > 0 ? pr : null;
+  } else {
+    const trimmed2 = pr.trim();
+    const numeric = trimmed2.match(/^#?(\d+)$/);
+    if (numeric) {
+      prNumber = Number(numeric[1]);
+    } else {
+      try {
+        const url = new URL(trimmed2);
+        const match = url.pathname.match(/^\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/);
+        if (url.hostname.toLowerCase() !== "github.com" || !match) return null;
+        repo = `${match[1]}/${match[2]}`;
+        prNumber = Number(match[3]);
+      } catch {
+        return null;
+      }
+    }
+  }
+  const repoKey = repo ? normalizeGitHubRepo(repo) : null;
+  return prNumber && repoKey ? { prNumber, repoKey } : null;
+}
+function githubRepoFromKey(repoKey) {
+  const match = /^github\.com\/([^/]+)\/([^/]+)$/.exec(repoKey);
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+function parseReportKey(value) {
+  const trimmed2 = value.trim();
+  if (!trimmed2) return null;
+  if (REPORT_KEY.test(trimmed2)) return trimmed2;
+  try {
+    const key = new URL(trimmed2).searchParams.get("k");
+    return key && REPORT_KEY.test(key) ? key : null;
+  } catch {
+    return null;
+  }
+}
+function reportKeyInText(text) {
+  const match = text ? REPORT_KEY_IN_TEXT.exec(text) : null;
+  return match ? match[1] : null;
+}
+async function resolvePrVisualReviewViaGitHub(githubApi, repository, prNumber) {
+  const pull = await githubApi(`repos/${repository}/pulls/${prNumber}`);
+  const headSha = pull.head?.sha;
+  const pullRequest = {
+    repository,
+    number: prNumber,
+    url: pull.html_url,
+    title: pull.title,
+    state: pull.state,
+    draft: pull.draft,
+    headSha
+  };
+  if (!headSha) {
+    return {
+      pullRequest,
+      status: null,
+      reportKey: null,
+      reportKeySource: null,
+      intentionalNoReport: false
+    };
+  }
+  const combined = await githubApi(
+    `repos/${repository}/commits/${headSha}/status`
+  );
+  const raw = (combined.statuses ?? []).find(
+    (candidate) => candidate.context === VISUAL_REVIEW_STATUS_CONTEXT
+  );
+  const status = raw?.state ? {
+    state: raw.state,
+    description: raw.description ?? void 0,
+    targetUrl: raw.target_url ?? void 0,
+    updatedAt: raw.updated_at
+  } : null;
+  const intentionalNoReport = status?.state === "success" && INTENTIONAL_NO_REPORT.test(status.description ?? "");
+  let reportKey = reportKeyInText(status?.targetUrl);
+  let reportKeySource = reportKey ? "head-status" : null;
+  if (!reportKey && !intentionalNoReport) {
+    for (let page = 1; ; page += 1) {
+      const pageSuffix = page === 1 ? "" : `&page=${page}`;
+      const comments = await githubApi(
+        `repos/${repository}/issues/${prNumber}/comments?per_page=100${pageSuffix}`
+      );
+      const sticky = comments.find(
+        (comment) => typeof comment.body === "string" && comment.body.includes(VISUAL_REVIEW_STICKY_MARKER)
+      );
+      const key = reportKeyInText(sticky?.body);
+      if (key) {
+        reportKey = key;
+        reportKeySource = "sticky-comment";
+        break;
+      }
+      if (comments.length < 100) break;
+    }
+  }
+  return { pullRequest, status, reportKey, reportKeySource, intentionalNoReport };
+}
+
 // ../canvas-comments-mcp/tools/read.ts
+function mapGitHubApiError(error) {
+  if (error.unavailable) {
+    return {
+      code: "github_unavailable",
+      message: `${error.message}. Pass \`reportUrl\` \u2014 the PR's \`visual-review\` check link (\u2026?k=\u2026) \u2014 instead.`
+    };
+  }
+  if (error.status === 404) {
+    return {
+      code: "not_found",
+      message: `GitHub returned 404 for that pull request: it does not exist, or your GitHub account cannot see it (${error.message}).`
+    };
+  }
+  if (error.status === 401 || error.status === 403) {
+    return {
+      code: "forbidden",
+      message: `GitHub refused the read as your account (${error.message}).`
+    };
+  }
+  return { code: "github_error", message: error.message };
+}
+var EMPTY_COMMENTS = {
+  openThreads: 0,
+  resolvedThreads: 0,
+  returnedThreads: 0,
+  truncated: false,
+  threads: []
+};
 function registerReadTools2(server, deps) {
-  const { convex, resolveCanvasContentPath } = deps;
+  const { convex, resolveCanvasContentPath, getRepoUrl, githubApi } = deps;
   const canvasKey = async (contentPath) => {
     const resolved = resolveCanvasContentPath ? await resolveCanvasContentPath(contentPath) : contentPath;
     return normalizeCanvasContentPath(resolved);
@@ -10897,6 +11058,198 @@ function registerReadTools2(server, deps) {
       }
     }
   );
+  server.tool(
+    "comments_get_pr_visual_review",
+    "Get a GitHub PR's visual review in one read-only call: the current `visual-review` commit status, the Tempo VRT report gate, actionable per-storyboard verdicts/approvals, and the canvas review comment threads. Pass `pr` (a GitHub PR URL is preferred; a PR number / '#123' needs `repository` unless the local Tempo workspace has a GitHub remote) \u2014 the PR's head status and report link are read with YOUR GitHub credentials through the `gh` CLI, so only PRs you can see on GitHub resolve. Without a usable `gh` (hosted / CLI sessions) pass `reportUrl` instead: the PR's `visual-review` check link (\u2026?k=\u2026). GitHub's head status is authoritative (bypass / no-visual-change PRs report correctly); while the current head is still capturing, the newest completed run is returned with report.stale=true so review threads stay visible. Only open threads are returned by default.",
+    {
+      pr: z10.union([z10.number().int().positive(), z10.string().min(1)]).optional().describe(
+        "GitHub PR URL (recommended), or a positive PR number / '#123' (then `repository` or a workspace GitHub remote is required)."
+      ),
+      repository: z10.string().optional().describe(
+        "GitHub repository as owner/repo, an HTTPS/SSH remote, or a Tempo repoKey (github.com/owner/repo). Only needed with a bare PR number."
+      ),
+      reportUrl: z10.string().optional().describe(
+        "The PR's `visual-review` check link / Tempo report URL (\u2026?k=\u2026), or the bare report key. Required when no GitHub CLI is available; may be combined with `pr` to confirm freshness against the current head."
+      ),
+      includeResolved: z10.boolean().default(false).describe("Include resolved review threads; defaults to false."),
+      maxThreads: z10.number().int().min(1).max(100).default(50).describe("Maximum newest matching threads to return (default 50).")
+    },
+    async (args, ctx) => {
+      try {
+        const includeResolved = args.includeResolved ?? false;
+        const maxThreads = Math.min(args.maxThreads ?? 50, 100);
+        const warnings = [];
+        let reportKey = null;
+        if (args.reportUrl !== void 0) {
+          reportKey = parseReportKey(args.reportUrl);
+          if (!reportKey) {
+            return errorResult3({
+              code: "validation_error",
+              message: "`reportUrl` must be a Tempo visual-review link carrying `?k=<key>` (the PR's `visual-review` check link) or a bare report key."
+            });
+          }
+        }
+        let parsedPr = null;
+        if (args.pr !== void 0) {
+          let repository = args.repository;
+          if (!repository && getRepoUrl) {
+            try {
+              repository = await getRepoUrl();
+            } catch {
+              repository = null;
+            }
+          }
+          parsedPr = parseVisualReviewPrInput(args.pr, repository);
+          if (!parsedPr) {
+            return errorResult3({
+              code: "validation_error",
+              message: "Pass a GitHub PR URL, or a PR number with `repository` (owner/repo, an HTTPS/SSH remote, or github.com/owner/repo)."
+            });
+          }
+        }
+        if (!reportKey && !parsedPr) {
+          return errorResult3({
+            code: "validation_error",
+            message: "Pass `pr` (a GitHub PR URL) or `reportUrl` (the PR's `visual-review` check link)."
+          });
+        }
+        let github = null;
+        if (parsedPr) {
+          const repository = githubRepoFromKey(parsedPr.repoKey);
+          if (!repository) {
+            return errorResult3({
+              code: "validation_error",
+              message: "Only GitHub repositories are supported."
+            });
+          }
+          if (githubApi) {
+            try {
+              github = await resolvePrVisualReviewViaGitHub(
+                githubApi,
+                repository,
+                parsedPr.prNumber
+              );
+            } catch (error) {
+              if (!(error instanceof GitHubApiError)) throw error;
+              if (!reportKey) return errorResult3(mapGitHubApiError(error));
+              warnings.push(
+                `GitHub lookup failed (${error.message}); freshness against the PR's current head is unknown.`
+              );
+            }
+            if (github && !reportKey) reportKey = github.reportKey;
+          } else if (!reportKey) {
+            return errorResult3({
+              code: "github_unavailable",
+              message: "Resolving a PR needs an authenticated GitHub CLI (`gh`) on this machine, which this session does not have. Pass `reportUrl` \u2014 the PR's `visual-review` check link (\u2026?k=\u2026) \u2014 instead."
+            });
+          }
+        }
+        let detail = reportKey ? await convex.action(api3.visualReviewGithub.getPrReviewForMcp, {
+          // biome-ignore lint/suspicious/noExplicitAny: cross-package id casting
+          organizationId: ctx.orgId,
+          reportKey,
+          includeResolved,
+          maxThreads
+        }) : null;
+        if (reportKey && !detail) {
+          if (!github) {
+            return errorResult3({
+              code: "not_found",
+              message: "No Tempo visual-review report exists for that key."
+            });
+          }
+          warnings.push(
+            `GitHub links report key ${reportKey}, but Tempo has no such report (it may have been swept).`
+          );
+        }
+        if (detail && parsedPr && (detail.report.run.repoKey !== parsedPr.repoKey || detail.report.run.prNumber !== parsedPr.prNumber)) {
+          warnings.push(
+            `The resolved report belongs to ${detail.report.run.repoKey} PR #${detail.report.run.prNumber ?? "?"}, not the requested PR; it was ignored.`
+          );
+          detail = null;
+        }
+        if (detail && !github && githubApi && detail.report.run.prNumber !== void 0) {
+          const repository = githubRepoFromKey(detail.report.run.repoKey);
+          if (repository) {
+            try {
+              github = await resolvePrVisualReviewViaGitHub(
+                githubApi,
+                repository,
+                detail.report.run.prNumber
+              );
+              if (github.reportKey && github.reportKey !== reportKey) {
+                warnings.push(
+                  `GitHub currently links a different report for this PR (key ${github.reportKey}${github.status?.targetUrl ? `: ${github.status.targetUrl}` : ""}); you asked for ${reportKey}.`
+                );
+              }
+            } catch (error) {
+              if (!(error instanceof GitHubApiError)) throw error;
+              warnings.push(
+                `GitHub lookup failed (${error.message}); freshness against the PR's current head is unknown.`
+              );
+            }
+          }
+        }
+        const headSha = github?.pullRequest.headSha;
+        const stale = Boolean(
+          detail && headSha && detail.report.run.headSha !== headSha
+        );
+        if (stale && detail) {
+          warnings.push(
+            `No visual-review run has completed for the current head ${headSha}; report verdicts are from the newest completed run at ${detail.report.run.headSha} (report.stale = true). Review threads are current.`
+          );
+        }
+        const runRepoKey = detail?.report.run.repoKey ?? parsedPr?.repoKey;
+        const pullRequest = github?.pullRequest ?? {
+          repository: (runRepoKey && githubRepoFromKey(runRepoKey)) ?? runRepoKey ?? "",
+          number: detail?.report.run.prNumber ?? parsedPr?.prNumber
+        };
+        const githubStatus = github?.status;
+        const status = githubStatus ? {
+          state: githubStatus.state === "error" ? "failure" : githubStatus.state,
+          description: githubStatus.description ?? "GitHub visual-review status",
+          source: "github",
+          targetUrl: githubStatus.targetUrl,
+          updatedAt: githubStatus.updatedAt
+        } : github ? {
+          // GitHub answered authoritatively for the current head and
+          // the context is absent. Keep that distinct from Tempo's
+          // stored gate, which remains available under `report.gate`.
+          state: "missing",
+          description: stale ? "No visual-review status is present on the current PR head yet." : "No visual-review status is present on the PR head.",
+          source: "none"
+        } : detail && !stale ? {
+          // No GitHub read was possible (for example reportUrl-only
+          // hosted usage), so the stored gate is the best available
+          // status signal rather than an assertion about GitHub.
+          ...detail.derivedStatus,
+          source: "tempo",
+          targetUrl: detail.report.url
+        } : {
+          state: "unavailable",
+          description: "GitHub status could not be read; only stored Tempo data is shown.",
+          source: "none"
+        };
+        if (githubStatus && detail && !stale) {
+          const published = githubStatus.state === "error" ? "failure" : githubStatus.state;
+          if (published !== detail.derivedStatus.state) {
+            warnings.push(
+              `GitHub's published visual-review status is ${githubStatus.state}, but Tempo's current report gate derives ${detail.derivedStatus.state}; inspect report.run.lastPublishError for a stale-status failure.`
+            );
+          }
+        }
+        return jsonResult3({
+          pullRequest,
+          status,
+          report: detail ? { ...detail.report, stale } : null,
+          comments: detail?.comments ?? EMPTY_COMMENTS,
+          warnings: [...warnings, ...detail?.warnings ?? []]
+        });
+      } catch (e) {
+        return errorResult3(mapMcpError(e));
+      }
+    }
+  );
 }
 
 // ../canvas-comments-mcp/tools/write.ts
@@ -11218,10 +11571,15 @@ function registerReadStateTools(server, deps) {
 }
 
 // ../canvas-comments-mcp/server.ts
+var COMMENTS_MCP_INSTRUCTIONS = [
+  "Tempo canvas comments: review threads pinned to canvases and storyboards, org-scoped and keyed by (orgProjectId, branch, contentPath) where contentPath is the canvas FOLDER path.",
+  "When the user asks for a pull request's visual-review (VRT) status, verdicts, or review feedback, call comments_get_pr_visual_review first: it joins the GitHub `visual-review` check, the Tempo report gate, and the review threads in one read-only call.",
+  "The AI acts as the signed-in user \u2014 every write is attributed to them, never to a separate AI identity."
+].join("\n\n");
 function createCommentsMcpServer(context) {
   const server = new McpServer3(
     { name: "tempo-comments-tools", version: "1.0.0" },
-    { capabilities: { tools: {} } }
+    { capabilities: { tools: {} }, instructions: COMMENTS_MCP_INSTRUCTIONS }
   );
   const convex = new AuthedConvexClient({
     url: context.convexUrl,
@@ -11245,8 +11603,13 @@ function createCommentsMcpServer(context) {
     context.getCurrentOrgGeneration
   );
   const getWritePermission = context.getWritePermission ?? (() => true);
-  const { resolveCanvasContentPath } = context;
-  registerReadTools2(instrumented, { convex, resolveCanvasContentPath });
+  const { resolveCanvasContentPath, getRepoUrl, githubApi } = context;
+  registerReadTools2(instrumented, {
+    convex,
+    resolveCanvasContentPath,
+    getRepoUrl,
+    githubApi
+  });
   registerWriteTools2(instrumented, {
     convex,
     getWritePermission,
@@ -24377,6 +24740,19 @@ function classifyDevServerOutput(line) {
     observedAt: Date.now()
   };
 }
+function buildHostUnresponsiveHint(url, unreachableSinceMs, nowMs = Date.now()) {
+  const unreachableForSeconds = Math.max(
+    0,
+    Math.round((nowMs - unreachableSinceMs) / 1e3)
+  );
+  return {
+    class: "host-unresponsive",
+    hint: `The canvas dev server is running but has stopped answering requests at ${url} (no response for ${unreachableForSeconds}s). It may be wedged after a dependency change or an interrupted install; retrying restarts it.`,
+    errorCode: "not_reachable",
+    line: `url health probe failed: ${url}`,
+    observedAt: nowMs
+  };
+}
 function matchClass(line) {
   if (isShellParseAbortOutput(line)) {
     return {
@@ -28016,6 +28392,21 @@ ${output.trim()}`
     this.name = "InstallDependencyConflictError";
   }
 };
+var InstallInterruptedError = class extends TempoDevServerError {
+  constructor(command, output, evidence) {
+    const explanation = evidence === "concurrent-install" ? "Install command was interrupted \u2014 node_modules changed while it ran, because another install was running in the same folder at the same time" : "Install command could not move a package aside because node_modules is in an inconsistent state (npm ENOTEMPTY) \u2014 left behind when an earlier install was cut short, or by another install running in the same folder";
+    const remedy = evidence === "concurrent-install" ? "Wait for any other install in this folder to finish, then retry the canvas." : "If no other install is running, delete that folder's node_modules and retry the canvas.";
+    super(
+      "install_interrupted",
+      `${explanation}: ${command}
+${output.trim()}
+
+${remedy}`
+    );
+    this.name = "InstallInterruptedError";
+    this.evidence = evidence;
+  }
+};
 function shellDialectRewriteHint(field) {
   return `Hint: Tempo runs tempo.config.json's "${field}" through the platform shell, which is cmd.exe on Windows \u2014 it cannot parse PowerShell. Rewrite the command as a plain, cross-platform invocation with no shell conditionals (e.g. "npm install", or "npm install --prefix .. && npm install" \u2014 cmd supports \`&&\`). Avoid PowerShell-only syntax: \`if (...) { ... } else { ... }\`, \`Test-Path\`, \`$env:FOO\`. If you need cmd's own conditional, it is \`if exist package.json (...) else (...)\`.`;
 }
@@ -28383,6 +28774,29 @@ var CanvasRegistry = class {
   }
 };
 
+// ../tempo-devserver/process-hint-slots.ts
+var ProcessHintSlots = class {
+  constructor() {
+    this.outputHint = null;
+    this.supervisorHint = null;
+  }
+  current() {
+    return this.supervisorHint ?? this.outputHint;
+  }
+  recordOutput(hint) {
+    this.outputHint = hint;
+  }
+  recordSupervisor(hint) {
+    this.supervisorHint = hint;
+  }
+  /** Withdraw the supervisor hint when it is of `hintClass`; false if it was not. */
+  clearSupervisor(hintClass) {
+    if (this.supervisorHint?.class !== hintClass) return false;
+    this.supervisorHint = null;
+    return true;
+  }
+};
+
 // ../tempo-devserver/project-node-version.ts
 import { access, readFile as readFile10, readdir as readdir5 } from "fs/promises";
 import path16 from "path";
@@ -28965,10 +29379,11 @@ var TempoHostProcess = class _TempoHostProcess {
     this.outputListeners = [];
     // Collects recent process output so early-exit errors include diagnostic context
     this.recentOutput = [];
-    // Most recent user-actionable hint classified from stdout/stderr — drives
-    // the renderer's toolbar messaging when the canvas is stuck or errored.
-    // See `hint-classifier.ts` for the classification rules.
-    this.lastHint = null;
+    // User-actionable hints about this process — classified from stdout/stderr
+    // (see `hint-classifier.ts`) or observed by the supervisor from outside —
+    // drive the renderer's toolbar messaging when the canvas is stuck or
+    // errored. Two slots, because the two sources have different lifetimes.
+    this.hints = new ProcessHintSlots();
     this.hintListeners = [];
     this.explicitTempoHostUrl = options.explicitTempoHostUrl;
     this.tempoHostUrlSource = options.tempoHostUrlSource;
@@ -29029,19 +29444,7 @@ var TempoHostProcess = class _TempoHostProcess {
         hint: new MissingRootDepsError(this.missingRootDepsProjectRoot).message
       } : classifiedHint;
       if (hint) {
-        this.lastHint = hint;
-        devLog("process:hint", {
-          pid: this.child.pid ?? null,
-          class: hint.class,
-          hint: hint.hint,
-          line: text.slice(0, 500)
-        });
-        for (const listener of this.hintListeners) {
-          try {
-            listener(hint);
-          } catch {
-          }
-        }
+        this.recordHint(hint);
       }
       const matchedUrl = extractServerUrl2(text);
       if (matchedUrl && !this.detectedBaseUrl) {
@@ -29157,15 +29560,69 @@ ${output}` : "";
   }
   onHint(listener) {
     this.hintListeners.push(listener);
-    if (this.lastHint) {
+    const current = this.hints.current();
+    if (current) {
       try {
-        listener(this.lastHint);
+        listener(current);
       } catch {
       }
     }
   }
   getLastHint() {
-    return this.lastHint;
+    return this.hints.current();
+  }
+  /**
+   * Record a hint classified from this process's stdout/stderr and notify
+   * subscribers with whatever hint is now in effect (a supervisor hint, if one
+   * is active, still takes precedence — see `ProcessHintSlots`).
+   */
+  recordHint(hint) {
+    this.hints.recordOutput(hint);
+    this.logHint(hint);
+    this.notifyHintListeners(this.hints.current());
+  }
+  /**
+   * Record a hint the supervisor observed about this process from outside its
+   * output (a live child whose URL stopped answering — see
+   * `runUrlHealthProbeTick`). It is shown in place of any output hint until
+   * `clearSupervisorHint` withdraws it.
+   */
+  recordSupervisorHint(hint) {
+    this.hints.recordSupervisor(hint);
+    this.logHint(hint);
+    this.notifyHintListeners(hint);
+  }
+  /**
+   * Withdraw the supervisor hint of `hintClass` once the condition it
+   * described has cleared (a URL probe succeeding again). Subscribers receive
+   * the hint now in effect — the output hint that was showing before, or
+   * `null` — so a consumer that mirrors "the current hint" (the Electron
+   * adapter → renderer toolbar detail) stops reporting a recovered host as
+   * stuck without losing a compile diagnostic that is still true.
+   */
+  clearSupervisorHint(hintClass) {
+    if (!this.hints.clearSupervisor(hintClass)) return;
+    devLog("process:hint_cleared", {
+      pid: this.child.pid ?? null,
+      class: hintClass
+    });
+    this.notifyHintListeners(this.hints.current());
+  }
+  logHint(hint) {
+    devLog("process:hint", {
+      pid: this.child.pid ?? null,
+      class: hint.class,
+      hint: hint.hint,
+      line: hint.line
+    });
+  }
+  notifyHintListeners(hint) {
+    for (const listener of this.hintListeners) {
+      try {
+        listener(hint);
+      } catch {
+      }
+    }
   }
   getLivenessSource() {
     return this.launcherFinished ? "probe" : "child";
@@ -29179,9 +29636,10 @@ ${output}` : "";
    * no indication that the command never even parsed. See TEM-436.
    */
   hintSuffix() {
-    return this.lastHint ? `
+    const current = this.hints.current();
+    return current ? `
 
-Hint: ${this.lastHint.hint}` : "";
+Hint: ${current.hint}` : "";
   }
   getPid() {
     return this.child.pid ?? null;
@@ -29588,6 +30046,11 @@ var TempoDevServer = class _TempoDevServer {
     // local `process` var out of `startDevServer`.
     this.activeHostProcess = null;
     this.urlHealthProbeConsecutiveFailures = 0;
+    // Bumped whenever the probe loop is (re)started or stopped, so a probe
+    // that was already in flight for the PREVIOUS loop cannot report into this
+    // one. URL equality is not enough of a fence: a replacement process on the
+    // same URL would inherit the old process's last failure.
+    this.urlHealthProbeGeneration = 0;
     // Tempo-managed Next hosts never share the user's ordinary `.next` cache.
     // This starts at the stable Tempo-owned directory and only receives a suffix
     // after Next reports an observed lock conflict for that directory.
@@ -30788,6 +31251,7 @@ var TempoDevServer = class _TempoDevServer {
     if (this.disposed) return;
     this.urlHealthProbeUrl = url;
     this.urlHealthProbeConsecutiveFailures = 0;
+    this.urlHealthProbeGeneration += 1;
     this.urlHealthProbeTimer = setInterval(() => {
       void this.runUrlHealthProbeTick();
     }, _TempoDevServer.URL_HEALTH_PROBE_INTERVAL_MS);
@@ -30802,9 +31266,11 @@ var TempoDevServer = class _TempoDevServer {
     }
     this.urlHealthProbeUrl = null;
     this.urlHealthProbeConsecutiveFailures = 0;
+    this.urlHealthProbeGeneration += 1;
   }
   async runUrlHealthProbeTick() {
     const probedUrl = this.urlHealthProbeUrl;
+    const generation = this.urlHealthProbeGeneration;
     if (!probedUrl || this.disposed) return;
     const reachable = await probeUrlOnce(
       probedUrl,
@@ -30812,18 +31278,26 @@ var TempoDevServer = class _TempoDevServer {
       this.projectRoot,
       this.activeHostIdentity
     );
-    if (this.urlHealthProbeUrl !== probedUrl) return;
+    if (this.urlHealthProbeGeneration !== generation) return;
     if (reachable) {
       this.state.urlUnreachableSince = null;
       this.urlHealthProbeConsecutiveFailures = 0;
+      this.activeHostProcess?.clearSupervisorHint("host-unresponsive");
       return;
     }
     if (this.activeHostProcess?.isAlive()) {
       this.state.urlUnreachableSince ??= Date.now();
+      this.urlHealthProbeConsecutiveFailures += 1;
       devLog("supervisor:url_probe_failed_host_alive", {
         url: probedUrl,
+        consecutiveFailures: this.urlHealthProbeConsecutiveFailures,
         unreachableSince: this.state.urlUnreachableSince
       });
+      if (this.urlHealthProbeConsecutiveFailures === _TempoDevServer.URL_HEALTH_FAILURES_TO_DEMOTE) {
+        this.activeHostProcess.recordSupervisorHint(
+          buildHostUnresponsiveHint(probedUrl, this.state.urlUnreachableSince)
+        );
+      }
       return;
     }
     const probeBacked = this.activeHostLivenessSource() === "probe";
@@ -32063,6 +32537,11 @@ var INSTALL_LOCK_PATTERN = new RegExp(
   `(?:EPERM|EACCES|EBUSY)[\\s\\S]{0,400}?(?:${INSTALL_LOCK_SYSCALLS})|(?:${INSTALL_LOCK_SYSCALLS})[\\s\\S]{0,400}?(?:EPERM|EACCES|EBUSY)|operation not permitted|permission denied|resource busy or locked`,
   "i"
 );
+function classifyInterruptedInstallOutput(output) {
+  if (/\bTAR_ENTRY_ERROR\b/.test(output)) return "concurrent-install";
+  if (/\bENOTEMPTY\b/.test(output)) return "inconsistent-tree";
+  return null;
+}
 function classifyInstallFailure(command, output) {
   if (isShellParseAbortOutput(output)) {
     return new InstallShellDialectMismatchError(command, output);
@@ -32070,6 +32549,10 @@ function classifyInstallFailure(command, output) {
   if (/ERESOLVE|unable to resolve dependency tree|could not resolve/i.test(output)) {
     return new InstallDependencyConflictError(command, output);
   }
+  const interruptedEvidence = classifyInterruptedInstallOutput(output);
+  if (interruptedEvidence) {
+    return new InstallInterruptedError(command, output, interruptedEvidence);
+  }
   if (/\bEBUSY\b|resource busy or locked/i.test(output)) {
     return new InstallFileLockedError(command, output);
   }
@@ -46700,7 +47183,7 @@ function buildBackends(runtime, toolsets, workspace) {
 }
 
 // src/version.ts
-var CLI_VERSION = "0.0.106";
+var CLI_VERSION = "0.0.107";
 
 // src/canvas-hooks.ts
 var import_pngjs4 = __toESM(require_png(), 1);
@@ -49214,4 +49697,4 @@ export {
   runServe,
   scopeParamsFor
 };
-//# sourceMappingURL=serve-7RSR6WI6.js.map
+//# sourceMappingURL=serve-IXP2WX42.js.map