gorsee 0.2.11 → 0.2.13

package/dist-pkg/ai/summary.d.ts

@@ -4,12 +4,38 @@ import type { ReactiveTraceArtifact } from "../reactive/diagnostics.js";
 export interface AIContextPacket {
     schemaVersion: string;
     generatedAt: string;
+    app?: {
+        mode: "frontend" | "fullstack" | "server";
+        runtimeTopology: "single-instance" | "multi-instance";
+    };
     summary: {
         headline: string;
         events: number;
         errors: number;
         warnings: number;
     };
+    readiness: {
+        deploy: {
+            status: "ready" | "caution" | "blocked";
+            reasons: string[];
+        };
+        scaling: {
+            status: "ready" | "caution" | "blocked" | "not-applicable";
+            reasons: string[];
+        };
+    };
+    release?: {
+        appMode: "frontend" | "fullstack" | "server";
+        runtimeKind: "frontend-static" | "fullstack-runtime" | "server-runtime";
+        processEntrypoints: string[];
+        handlerEntrypoints: string[];
+        workerEntrypoint?: string;
+        routeCount: number;
+        clientAssetCount: number;
+        prerenderedCount: number;
+        serverEntryCount: number;
+        generatedAt: string;
+    };
     latestDiagnostic?: Partial<AIDiagnostic>;
     recentIncidents: Array<{
         ts: string;
@@ -53,5 +79,67 @@ export interface AIContextPacket {
     };
     recommendations: string[];
 }
+export interface AIReleaseBrief {
+    schemaVersion: string;
+    generatedAt: string;
+    app?: AIContextPacket["app"];
+    release?: AIContextPacket["release"];
+    readiness: AIContextPacket["readiness"];
+    verdict: "ship" | "review" | "hold";
+    headline: string;
+    blockers: string[];
+    cautions: string[];
+    recommendations: string[];
+}
+export interface AIIncidentBrief {
+    schemaVersion: string;
+    generatedAt: string;
+    app?: AIContextPacket["app"];
+    release?: AIContextPacket["release"];
+    readiness: AIContextPacket["readiness"];
+    severity: "critical" | "high" | "medium" | "low";
+    headline: string;
+    incidents: AIContextPacket["recentIncidents"];
+    clusters: AIContextPacket["incidentClusters"];
+    artifactRegressions: AIContextPacket["artifactRegressions"];
+    recommendations: string[];
+}
+export interface AIDeploySummary {
+    schemaVersion: string;
+    generatedAt: string;
+    app?: AIContextPacket["app"];
+    release?: AIContextPacket["release"];
+    readiness: AIContextPacket["readiness"];
+    status: "ready" | "review" | "blocked";
+    headline: string;
+    processEntrypoints: string[];
+    handlerEntrypoints: string[];
+    workerEntrypoint?: string;
+    artifactRegressions: AIContextPacket["artifactRegressions"];
+    recommendations: string[];
+}
+export interface AIIncidentSnapshot {
+    schemaVersion: string;
+    generatedAt: string;
+    app?: AIContextPacket["app"];
+    release?: AIContextPacket["release"];
+    readiness: AIContextPacket["readiness"];
+    severity: "critical" | "high" | "medium" | "low";
+    headline: string;
+    latestIncident?: AIContextPacket["recentIncidents"][number];
+    incidentCount: number;
+    clusterCount: number;
+    clusters: AIContextPacket["incidentClusters"];
+    hotspots: AIContextPacket["hotspots"];
+    recommendations: string[];
+}
 export declare function createAIContextPacket(report: AIHealthReport, events: AIEvent[], latestDiagnostic?: Partial<AIDiagnostic>, reactiveTrace?: ReactiveTraceArtifact | null): AIContextPacket;
 export declare function renderAIContextMarkdown(packet: AIContextPacket): string;
+export declare function createAIReleaseBrief(packet: AIContextPacket): AIReleaseBrief;
+export declare function renderAIReleaseBriefMarkdown(brief: AIReleaseBrief): string;
+export declare function createAIIncidentBrief(packet: AIContextPacket): AIIncidentBrief;
+export declare function renderAIIncidentBriefMarkdown(brief: AIIncidentBrief): string;
+export declare function createAIDeploySummary(packet: AIContextPacket): AIDeploySummary;
+export declare function renderAIDeploySummaryMarkdown(summary: AIDeploySummary): string;
+export declare function createAIIncidentSnapshot(packet: AIContextPacket): AIIncidentSnapshot;
+export declare function renderAIIncidentSnapshotMarkdown(snapshot: AIIncidentSnapshot): string;

package/dist-pkg/ai/summary.js

@@ -1,14 +1,32 @@
 import { GORSEE_AI_CONTEXT_SCHEMA_VERSION } from "./contracts.js";
 export function createAIContextPacket(report, events, latestDiagnostic, reactiveTrace) {
+  const readiness = report.readiness ?? {
+    deploy: { status: "ready", reasons: [] },
+    scaling: { status: "not-applicable", reasons: [] }
+  };
   return {
     schemaVersion: GORSEE_AI_CONTEXT_SCHEMA_VERSION,
     generatedAt: new Date().toISOString(),
+    app: report.app,
     summary: {
       headline: buildHeadline(report),
       events: report.events.total,
       errors: report.diagnostics.errors,
       warnings: report.diagnostics.warnings
     },
+    readiness,
+    release: report.release ? {
+      appMode: report.release.appMode,
+      runtimeKind: report.release.runtimeKind,
+      processEntrypoints: report.release.processEntrypoints,
+      handlerEntrypoints: report.release.handlerEntrypoints,
+      workerEntrypoint: report.release.workerEntrypoint,
+      routeCount: report.release.summary.routeCount,
+      clientAssetCount: report.release.summary.clientAssetCount,
+      prerenderedCount: report.release.summary.prerenderedCount,
+      serverEntryCount: report.release.summary.serverEntryCount,
+      generatedAt: report.release.generatedAt
+    } : void 0,
     latestDiagnostic,
     recentIncidents: report.incidents,
     incidentClusters: report.incidentClusters.map((cluster) => ({
@@ -49,6 +67,13 @@ export function renderAIContextMarkdown(packet) {
     "",
     `Generated: ${packet.generatedAt}`,
     "",
+    ...packet.app ? [
+      "## App Context",
+      "",
+      `- Mode: ${packet.app.mode}`,
+      `- Runtime topology: ${packet.app.runtimeTopology}`,
+      ""
+    ] : [],
     "## Summary",
     "",
     `- ${packet.summary.headline}`,
@@ -58,6 +83,28 @@ export function renderAIContextMarkdown(packet) {
   ];
   if (packet.latestDiagnostic?.code)
     lines.push("", "## Latest Diagnostic", "", `- ${packet.latestDiagnostic.code}: ${packet.latestDiagnostic.message ?? ""}`.trim());
+  if (packet.release) {
+    lines.push("", "## Release Artifact", "");
+    lines.push(`- Mode: ${packet.release.appMode}`);
+    lines.push(`- Runtime: ${packet.release.runtimeKind}`);
+    lines.push(`- Routes: ${packet.release.routeCount}`);
+    lines.push(`- Client assets: ${packet.release.clientAssetCount}`);
+    lines.push(`- Prerendered pages: ${packet.release.prerenderedCount}`);
+    lines.push(`- Server entries: ${packet.release.serverEntryCount}`);
+    if (packet.release.processEntrypoints.length > 0)
+      lines.push(`- Process entrypoints: ${packet.release.processEntrypoints.join(", ")}`);
+    if (packet.release.handlerEntrypoints.length > 0)
+      lines.push(`- Handler entrypoints: ${packet.release.handlerEntrypoints.join(", ")}`);
+    if (packet.release.workerEntrypoint)
+      lines.push(`- Worker entrypoint: ${packet.release.workerEntrypoint}`);
+  }
+  lines.push("", "## Readiness", "");
+  lines.push(`- Deploy: ${packet.readiness.deploy.status}`);
+  for (const reason of packet.readiness.deploy.reasons.slice(0, 3))
+    lines.push(`  - ${reason}`);
+  lines.push(`- Scaling: ${packet.readiness.scaling.status}`);
+  for (const reason of packet.readiness.scaling.reasons.slice(0, 3))
+    lines.push(`  - ${reason}`);
   if (packet.recentIncidents.length > 0) {
     lines.push("", "## Recent Incidents", "");
     for (const incident of packet.recentIncidents.slice(0, 10)) {
@@ -101,11 +148,264 @@ export function renderAIContextMarkdown(packet) {
   return lines.join(`
 `);
 }
+export function createAIReleaseBrief(packet) {
+  const blockers = [
+    ...packet.readiness.deploy.status === "blocked" ? packet.readiness.deploy.reasons : [],
+    ...packet.readiness.scaling.status === "blocked" ? packet.readiness.scaling.reasons : []
+  ], cautions = [
+    ...packet.readiness.deploy.status === "caution" ? packet.readiness.deploy.reasons : [],
+    ...packet.readiness.scaling.status === "caution" ? packet.readiness.scaling.reasons : []
+  ], verdict = blockers.length > 0 ? "hold" : cautions.length > 0 ? "review" : "ship";
+  return {
+    schemaVersion: GORSEE_AI_CONTEXT_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    app: packet.app,
+    release: packet.release,
+    readiness: packet.readiness,
+    verdict,
+    headline: verdict === "hold" ? "Release should not be promoted yet." : verdict === "review" ? "Release is close, but needs operator review." : "Release looks ready for promotion.",
+    blockers,
+    cautions,
+    recommendations: packet.recommendations
+  };
+}
+export function renderAIReleaseBriefMarkdown(brief) {
+  const lines = [
+    "# Gorsee AI Release Brief",
+    "",
+    `Schema: ${brief.schemaVersion}`,
+    "",
+    `Generated: ${brief.generatedAt}`,
+    "",
+    `Verdict: ${brief.verdict}`,
+    "",
+    brief.headline
+  ];
+  if (brief.release) {
+    lines.push("", "## Release", "");
+    lines.push(`- Mode: ${brief.release.appMode}`);
+    lines.push(`- Runtime: ${brief.release.runtimeKind}`);
+    lines.push(`- Routes: ${brief.release.routeCount}`);
+    lines.push(`- Client assets: ${brief.release.clientAssetCount}`);
+    lines.push(`- Server entries: ${brief.release.serverEntryCount}`);
+  }
+  lines.push("", "## Readiness", "");
+  lines.push(`- Deploy: ${brief.readiness.deploy.status}`);
+  lines.push(`- Scaling: ${brief.readiness.scaling.status}`);
+  if (brief.blockers.length > 0) {
+    lines.push("", "## Blockers", "");
+    for (const blocker of brief.blockers)
+      lines.push(`- ${blocker}`);
+  }
+  if (brief.cautions.length > 0) {
+    lines.push("", "## Cautions", "");
+    for (const caution of brief.cautions)
+      lines.push(`- ${caution}`);
+  }
+  if (brief.recommendations.length > 0) {
+    lines.push("", "## Recommendations", "");
+    for (const recommendation of brief.recommendations.slice(0, 5))
+      lines.push(`- ${recommendation}`);
+  }
+  return lines.join(`
+`);
+}
+export function createAIIncidentBrief(packet) {
+  const severity = packet.summary.errors > 0 ? packet.incidentClusters.length > 0 && packet.incidentClusters[0].count > 1 ? "critical" : "high" : packet.summary.warnings > 0 ? "medium" : "low";
+  return {
+    schemaVersion: GORSEE_AI_CONTEXT_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    app: packet.app,
+    release: packet.release,
+    readiness: packet.readiness,
+    severity,
+    headline: packet.recentIncidents[0]?.message ?? packet.summary.headline,
+    incidents: packet.recentIncidents,
+    clusters: packet.incidentClusters,
+    artifactRegressions: packet.artifactRegressions,
+    recommendations: packet.recommendations
+  };
+}
+export function renderAIIncidentBriefMarkdown(brief) {
+  const lines = [
+    "# Gorsee AI Incident Brief",
+    "",
+    `Schema: ${brief.schemaVersion}`,
+    "",
+    `Generated: ${brief.generatedAt}`,
+    "",
+    `Severity: ${brief.severity}`,
+    "",
+    brief.headline
+  ];
+  if (brief.release) {
+    lines.push("", "## Release Context", "");
+    lines.push(`- Mode: ${brief.release.appMode}`);
+    lines.push(`- Runtime: ${brief.release.runtimeKind}`);
+  }
+  if (brief.incidents.length > 0) {
+    lines.push("", "## Incidents", "");
+    for (const incident of brief.incidents.slice(0, 5)) {
+      const loc = incident.file ? ` (${incident.file}${incident.line ? `:${incident.line}` : ""})` : incident.route ? ` (${incident.route})` : "";
+      lines.push(`- [${incident.kind}] ${incident.message}${loc}`);
+    }
+  }
+  if (brief.clusters.length > 0) {
+    lines.push("", "## Clusters", "");
+    for (const cluster of brief.clusters.slice(0, 5))
+      lines.push(`- ${cluster.kind} \xD7 ${cluster.count}`);
+  }
+  if (brief.recommendations.length > 0) {
+    lines.push("", "## Recommendations", "");
+    for (const recommendation of brief.recommendations.slice(0, 5))
+      lines.push(`- ${recommendation}`);
+  }
+  return lines.join(`
+`);
+}
+export function createAIDeploySummary(packet) {
+  const status = packet.readiness.deploy.status === "blocked" ? "blocked" : packet.readiness.deploy.status === "caution" || packet.readiness.scaling.status === "caution" || packet.readiness.scaling.status === "blocked" ? "review" : "ready";
+  return {
+    schemaVersion: GORSEE_AI_CONTEXT_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    app: packet.app,
+    release: packet.release,
+    readiness: packet.readiness,
+    status,
+    headline: status === "blocked" ? "Deploy promotion is currently blocked by release or diagnostics signals." : status === "review" ? "Deploy promotion needs operator review before rollout." : "Deploy promotion looks ready from the current local artifact surface.",
+    processEntrypoints: packet.release?.processEntrypoints ?? [],
+    handlerEntrypoints: packet.release?.handlerEntrypoints ?? [],
+    workerEntrypoint: packet.release?.workerEntrypoint,
+    artifactRegressions: packet.artifactRegressions,
+    recommendations: packet.recommendations
+  };
+}
+export function renderAIDeploySummaryMarkdown(summary) {
+  const lines = [
+    "# Gorsee AI Deploy Summary",
+    "",
+    `Schema: ${summary.schemaVersion}`,
+    "",
+    `Generated: ${summary.generatedAt}`,
+    "",
+    `Status: ${summary.status}`,
+    "",
+    summary.headline
+  ];
+  if (summary.app) {
+    lines.push("", "## App Context", "");
+    lines.push(`- Mode: ${summary.app.mode}`);
+    lines.push(`- Runtime topology: ${summary.app.runtimeTopology}`);
+  }
+  if (summary.release) {
+    lines.push("", "## Release Context", "");
+    lines.push(`- Mode: ${summary.release.appMode}`);
+    lines.push(`- Runtime: ${summary.release.runtimeKind}`);
+    lines.push(`- Routes: ${summary.release.routeCount}`);
+    lines.push(`- Client assets: ${summary.release.clientAssetCount}`);
+    lines.push(`- Prerendered pages: ${summary.release.prerenderedCount}`);
+    lines.push(`- Server entries: ${summary.release.serverEntryCount}`);
+  }
+  lines.push("", "## Entrypoints", "");
+  lines.push(`- Process: ${summary.processEntrypoints.length > 0 ? summary.processEntrypoints.join(", ") : "none"}`);
+  lines.push(`- Handlers: ${summary.handlerEntrypoints.length > 0 ? summary.handlerEntrypoints.join(", ") : "none"}`);
+  lines.push(`- Worker: ${summary.workerEntrypoint ?? "none"}`);
+  lines.push("", "## Readiness", "");
+  lines.push(`- Deploy: ${summary.readiness.deploy.status}`);
+  lines.push(`- Scaling: ${summary.readiness.scaling.status}`);
+  if (summary.artifactRegressions.length > 0) {
+    lines.push("", "## Artifact Regressions", "");
+    for (const regression of summary.artifactRegressions.slice(0, 5)) {
+      const path = regression.path ? ` (${regression.path})` : "";
+      lines.push(`- ${regression.phase} ${regression.latestStatus}${path}`);
+    }
+  }
+  if (summary.recommendations.length > 0) {
+    lines.push("", "## Recommendations", "");
+    for (const recommendation of summary.recommendations.slice(0, 5))
+      lines.push(`- ${recommendation}`);
+  }
+  return lines.join(`
+`);
+}
+export function createAIIncidentSnapshot(packet) {
+  const brief = createAIIncidentBrief(packet);
+  return {
+    schemaVersion: GORSEE_AI_CONTEXT_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    app: packet.app,
+    release: packet.release,
+    readiness: packet.readiness,
+    severity: brief.severity,
+    headline: brief.headline,
+    latestIncident: packet.recentIncidents[0],
+    incidentCount: packet.recentIncidents.length,
+    clusterCount: packet.incidentClusters.length,
+    clusters: packet.incidentClusters,
+    hotspots: packet.hotspots,
+    recommendations: packet.recommendations
+  };
+}
+export function renderAIIncidentSnapshotMarkdown(snapshot) {
+  const lines = [
+    "# Gorsee AI Incident Snapshot",
+    "",
+    `Schema: ${snapshot.schemaVersion}`,
+    "",
+    `Generated: ${snapshot.generatedAt}`,
+    "",
+    `Severity: ${snapshot.severity}`,
+    "",
+    snapshot.headline
+  ];
+  if (snapshot.app) {
+    lines.push("", "## App Context", "");
+    lines.push(`- Mode: ${snapshot.app.mode}`);
+    lines.push(`- Runtime topology: ${snapshot.app.runtimeTopology}`);
+  }
+  if (snapshot.release) {
+    lines.push("", "## Release Context", "");
+    lines.push(`- Mode: ${snapshot.release.appMode}`);
+    lines.push(`- Runtime: ${snapshot.release.runtimeKind}`);
+  }
+  lines.push("", "## Incident Overview", "");
+  lines.push(`- Incidents: ${snapshot.incidentCount}`);
+  lines.push(`- Clusters: ${snapshot.clusterCount}`);
+  if (snapshot.latestIncident)
+    lines.push(`- Latest: [${snapshot.latestIncident.kind}] ${snapshot.latestIncident.message}`);
+  if (snapshot.clusters.length > 0) {
+    lines.push("", "## Clusters", "");
+    for (const cluster of snapshot.clusters.slice(0, 5))
+      lines.push(`- ${cluster.kind} \xD7 ${cluster.count}`);
+  }
+  if (snapshot.hotspots.length > 0) {
+    lines.push("", "## Hotspots", "");
+    for (const hotspot of snapshot.hotspots.slice(0, 5))
+      lines.push(`- ${hotspot.kind}: ${hotspot.key} \xD7 ${hotspot.count}`);
+  }
+  if (snapshot.recommendations.length > 0) {
+    lines.push("", "## Recommendations", "");
+    for (const recommendation of snapshot.recommendations.slice(0, 5))
+      lines.push(`- ${recommendation}`);
+  }
+  return lines.join(`
+`);
+}
 function buildHeadline(report) {
+  const readiness = report.readiness ?? {
+    deploy: { status: "ready", reasons: [] },
+    scaling: { status: "not-applicable", reasons: [] }
+  };
   if (report.diagnostics.errors > 0)
     return "Project currently has AI-observed errors that need attention.";
+  if (readiness.deploy.status === "blocked")
+    return "Deploy readiness is currently blocked by release, diagnostic, or artifact signals.";
+  if (readiness.scaling.status === "blocked")
+    return "Scaling readiness is currently blocked by multi-instance or distributed-state signals.";
   if (report.diagnostics.warnings > 0)
     return "Project is stable but has warnings worth reviewing.";
+  if (report.release)
+    return `Release artifact is present for ${report.release.appMode} (${report.release.runtimeKind}).`;
   if (report.events.total === 0)
     return "AI observability is enabled but no events were collected yet.";
   return "Project looks healthy from the current AI event stream.";
@@ -129,7 +429,10 @@ function topEntries(source, kind) {
   return [...source.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([key, count]) => ({ key, count, kind }));
 }
 function buildRecommendations(report, latestDiagnostic, events, reactiveTrace) {
-  const recommendations = [], errorEvents = events.filter((event) => event.severity === "error"), requestErrors = events.filter((event) => event.kind === "request.error");
+  const recommendations = [], readiness = report.readiness ?? {
+    deploy: { status: "ready", reasons: [] },
+    scaling: { status: "not-applicable", reasons: [] }
+  }, errorEvents = events.filter((event) => event.severity === "error"), requestErrors = events.filter((event) => event.kind === "request.error");
   if (latestDiagnostic?.code)
     recommendations.push(`Investigate the latest diagnostic ${latestDiagnostic.code} before relying on this context in automation.`);
   if (requestErrors.length > 0)
@@ -140,6 +443,12 @@ function buildRecommendations(report, latestDiagnostic, events, reactiveTrace) {
     recommendations.push("Run `gorsee ai doctor` after the next build to verify whether build-phase errors persist.");
   if (report.artifactRegressions.length > 0)
     recommendations.push("Review artifact regressions before shipping; release/deploy/build artifacts have recorded failures or warnings.");
+  if (report.release)
+    recommendations.push(`Validate dist/release.json before promotion; current runtime kind is ${report.release.runtimeKind}.`);
+  if (readiness.deploy.status !== "ready")
+    recommendations.push(`Deploy readiness is ${readiness.deploy.status}; resolve the reported release/artifact issues before promotion.`);
+  if (readiness.scaling.status === "blocked" || readiness.scaling.status === "caution")
+    recommendations.push(`Scaling readiness is ${readiness.scaling.status}; review runtime.topology and distributed-state signals before horizontal rollout.`);
   if (reactiveTrace && reactiveTrace.events.length > 0)
     recommendations.push("Reactive trace data is available; inspect dependency edges and invalidation events before changing resource or mutation behavior.");
   if (recommendations.length === 0)

package/dist-pkg/build/manifest.d.ts

@@ -1,3 +1,5 @@
 import type { Route } from "../router/scanner.js";
-import { type BuildManifest } from "../server/manifest.js";
-export declare function createBuildManifest(routes: Route[], entryMap: Map<string, string>, hashMap: Map<string, string>, prerenderedPaths?: Iterable<string>): Promise<BuildManifest>;
+import { type BuildManifest, type ReleaseArtifact } from "../server/manifest.js";
+import type { AppMode } from "../runtime/app-config.js";
+export declare function createBuildManifest(routes: Route[], entryMap: Map<string, string>, hashMap: Map<string, string>, prerenderedPaths?: Iterable<string>, appMode?: AppMode): Promise<BuildManifest>;
+export declare function createReleaseArtifact(manifest: BuildManifest, clientAssets: Iterable<string>, serverEntries: Iterable<string>): ReleaseArtifact;

package/dist-pkg/build/manifest.js

@@ -1,8 +1,12 @@
 import { inspectRouteBuildMetadata } from "./route-metadata.js";
-import { BUILD_MANIFEST_SCHEMA_VERSION } from "../server/manifest.js";
-export async function createBuildManifest(routes, entryMap, hashMap, prerenderedPaths = []) {
+import {
+  BUILD_MANIFEST_SCHEMA_VERSION,
+  RELEASE_ARTIFACT_SCHEMA_VERSION
+} from "../server/manifest.js";
+export async function createBuildManifest(routes, entryMap, hashMap, prerenderedPaths = [], appMode = "fullstack") {
   const prerendered = new Set(prerenderedPaths), manifest = {
     schemaVersion: BUILD_MANIFEST_SCHEMA_VERSION,
+    appMode,
     routes: {},
     chunks: [],
     prerendered: [...prerendered],
@@ -21,3 +25,29 @@ export async function createBuildManifest(routes, entryMap, hashMap, prerendered
       manifest.chunks.push(hashed);
   return manifest;
 }
+export function createReleaseArtifact(manifest, clientAssets, serverEntries) {
+  const clientAssetList = [...clientAssets].sort(), serverEntryList = [...serverEntries].sort(), prerenderedHtml = manifest.prerendered.map((pathname) => pathname === "/" ? "static/index.html" : `static/${pathname.slice(1)}/index.html`).sort(), processEntrypoints = serverEntryList.filter((entry) => entry === "prod.js" || entry === "prod-node.js"), handlerEntrypoints = serverEntryList.filter((entry) => entry === "server-handler.js" || entry === "server-handler-node.js"), workerEntrypoint = serverEntryList.includes("worker.js") ? "worker.js" : void 0;
+  return {
+    schemaVersion: RELEASE_ARTIFACT_SCHEMA_VERSION,
+    appMode: manifest.appMode ?? "fullstack",
+    generatedAt: manifest.buildTime,
+    summary: {
+      routeCount: Object.keys(manifest.routes).length,
+      clientAssetCount: clientAssetList.length,
+      prerenderedCount: manifest.prerendered.length,
+      serverEntryCount: serverEntryList.length
+    },
+    runtime: {
+      kind: manifest.appMode === "frontend" ? "frontend-static" : manifest.appMode === "server" ? "server-runtime" : "fullstack-runtime",
+      processEntrypoints,
+      handlerEntrypoints,
+      workerEntrypoint
+    },
+    artifacts: {
+      buildManifest: "manifest.json",
+      clientAssets: clientAssetList,
+      serverEntries: serverEntryList,
+      prerenderedHtml
+    }
+  };
+}

package/dist-pkg/cli/cmd-ai.js

@@ -7,14 +7,18 @@ import {
   createIDEProjectionWatcher,
   createAIBridgeServer,
   createAIContextPacket,
+  createAIIncidentBrief,
+  createAIReleaseBrief,
   createAIMCPServer,
   createLineReader,
   readAIDiagnosticsSnapshot,
   readAIEvents,
   readReactiveTraceArtifact,
+  renderAIIncidentBriefMarkdown,
   renderAIContextMarkdown,
   renderAIContextBundleMarkdown,
   renderAIFrameworkMarkdown,
+  renderAIReleaseBriefMarkdown,
   resolveAIStorePaths,
   resolveAISessionPackPaths,
   resolveIDEProjectionPaths,
@@ -97,8 +101,22 @@ async function runAIDoctor(paths, flags) {
   console.log(`  Diagnostics: ${report.diagnostics.total}`);
   console.log(`  Errors: ${report.diagnostics.errors}`);
   console.log(`  Warnings: ${report.diagnostics.warnings}`);
+  console.log(`  Deploy readiness: ${report.readiness.deploy.status}`);
+  console.log(`  Scaling readiness: ${report.readiness.scaling.status}`);
   if (report.events.latest)
     console.log(`  Latest event: ${report.events.latest.kind} @ ${report.events.latest.ts}`);
+  if (report.release) {
+    console.log(`
+  Release artifact:`);
+    console.log(`    - mode=${report.release.appMode} runtime=${report.release.runtimeKind}`);
+    console.log(`    - routes=${report.release.summary.routeCount} clientAssets=${report.release.summary.clientAssetCount} prerendered=${report.release.summary.prerenderedCount} serverEntries=${report.release.summary.serverEntryCount}`);
+    if (report.release.processEntrypoints.length > 0)
+      console.log(`    - process=${report.release.processEntrypoints.join(", ")}`);
+    if (report.release.handlerEntrypoints.length > 0)
+      console.log(`    - handlers=${report.release.handlerEntrypoints.join(", ")}`);
+    if (report.release.workerEntrypoint)
+      console.log(`    - worker=${report.release.workerEntrypoint}`);
+  }
   if (report.diagnostics.latest?.code)
     console.log(`  Latest diagnostic: ${report.diagnostics.latest.code} ${report.diagnostics.latest.message ?? ""}`.trim());
   if (report.incidents.length > 0) {
@@ -125,6 +143,14 @@ async function runAIDoctor(paths, flags) {
       console.log(`    - [${artifact.phase}] errors=${artifact.errors} warnings=${artifact.warnings} successes=${artifact.successes}${details ? ` (${details})` : ""}`);
     }
   }
+  if (report.readiness.deploy.reasons.length > 0 || report.readiness.scaling.reasons.length > 0) {
+    console.log(`
+  Readiness reasons:`);
+    for (const reason of report.readiness.deploy.reasons.slice(0, 3))
+      console.log(`    - deploy: ${reason}`);
+    for (const reason of report.readiness.scaling.reasons.slice(0, 3))
+      console.log(`    - scaling: ${reason}`);
+  }
   if (reactiveTrace) {
     console.log(`
   Reactive trace:`);
@@ -169,6 +195,24 @@ async function runAIExport(cwd, paths, flags) {
     return;
   }
   const events = await readAIEvents(paths.eventsPath, { limit: flags.limit ?? 200 }), diagnostics = await readAIDiagnosticsSnapshot(paths.diagnosticsPath), reactiveTrace = await readReactiveTraceArtifact(paths.reactiveTracePath), report = await buildAIHealthReport(paths, { limit: flags.limit ?? 200 }), packet = createAIContextPacket(report, events, diagnostics?.latest, reactiveTrace);
+  if (flags.brief === "release") {
+    const brief = createAIReleaseBrief(packet);
+    if ((flags.format ?? "json") === "markdown") {
+      console.log(renderAIReleaseBriefMarkdown(brief));
+      return;
+    }
+    console.log(JSON.stringify(brief, null, 2));
+    return;
+  }
+  if (flags.brief === "incident") {
+    const brief = createAIIncidentBrief(packet);
+    if ((flags.format ?? "json") === "markdown") {
+      console.log(renderAIIncidentBriefMarkdown(brief));
+      return;
+    }
+    console.log(JSON.stringify(brief, null, 2));
+    return;
+  }
   if ((flags.format ?? "json") === "markdown") {
     console.log(renderAIContextMarkdown(packet));
     return;
@@ -186,6 +230,14 @@ async function runAIPack(cwd, paths, flags) {
       generatedAt: result.bundle.generatedAt,
       latestJsonPath: result.paths.latestJsonPath,
       latestMarkdownPath: result.paths.latestMarkdownPath,
+      latestDeploySummaryJsonPath: result.paths.latestDeploySummaryJsonPath,
+      latestDeploySummaryMarkdownPath: result.paths.latestDeploySummaryMarkdownPath,
+      latestReleaseBriefJsonPath: result.paths.latestReleaseBriefJsonPath,
+      latestReleaseBriefMarkdownPath: result.paths.latestReleaseBriefMarkdownPath,
+      latestIncidentBriefJsonPath: result.paths.latestIncidentBriefJsonPath,
+      latestIncidentBriefMarkdownPath: result.paths.latestIncidentBriefMarkdownPath,
+      latestIncidentSnapshotJsonPath: result.paths.latestIncidentSnapshotJsonPath,
+      latestIncidentSnapshotMarkdownPath: result.paths.latestIncidentSnapshotMarkdownPath,
       historyDir: result.paths.historyDir,
       snippets: result.bundle.snippets.length
     }, null, 2));
@@ -196,6 +248,14 @@ async function runAIPack(cwd, paths, flags) {
 `);
   console.log(`  latest json -> ${result.paths.latestJsonPath}`);
   console.log(`  latest md   -> ${result.paths.latestMarkdownPath}`);
+  console.log(`  deploy      -> ${result.paths.latestDeploySummaryJsonPath}`);
+  console.log(`  deploy md   -> ${result.paths.latestDeploySummaryMarkdownPath}`);
+  console.log(`  release     -> ${result.paths.latestReleaseBriefJsonPath}`);
+  console.log(`  release md  -> ${result.paths.latestReleaseBriefMarkdownPath}`);
+  console.log(`  incident    -> ${result.paths.latestIncidentBriefJsonPath}`);
+  console.log(`  incident md -> ${result.paths.latestIncidentBriefMarkdownPath}`);
+  console.log(`  snapshot    -> ${result.paths.latestIncidentSnapshotJsonPath}`);
+  console.log(`  snapshot md -> ${result.paths.latestIncidentSnapshotMarkdownPath}`);
   console.log(`  history     -> ${result.paths.historyDir}`);
   console.log(`  snippets    -> ${result.bundle.snippets.length}`);
   console.log();
@@ -274,6 +334,11 @@ function parseAIFlags(args) {
       if (format === "json" || format === "markdown")
         flags.format = format;
     }
+    if (arg === "--brief") {
+      const brief = args[i + 1];
+      if (brief === "release" || brief === "incident")
+        flags.brief = brief;
+    }
   }
   return flags;
 }
@@ -287,6 +352,7 @@ function printAIHelp() {
   console.log("    doctor     Summarize diagnostics and recent incidents");
   console.log("    replay     Replay correlated AI events in timeline order");
   console.log("    export     Export a compact AI context packet or bundle");
+  console.log("               Use --brief release|incident for verdict-oriented summaries");
   console.log("    pack       Write the latest agent-ready session pack to disk");
   console.log("    ide-sync   Write IDE-friendly diagnostics/events/context files");
   console.log("    bridge     Start local HTTP bridge for IDE/agent ingestion");