forgeos 0.1.0-alpha.2 → 0.1.0-alpha.21

package/src/forge/compiler/make-registry/build.ts

@@ -34,6 +34,8 @@ export function buildMakeRegistry(generatorVersion: string): MakeRegistryArtifac
       "forge make list --json",
       "forge make explain <primitive> --json",
       "forge make ui --framework vite --dry-run --json",
+      "forge make ui --framework nuxt --dry-run --json",
+      "forge make ai-chat support --dry-run --json",
       "forge make resource <name> --fields title:text,status:enum(open,closed) --dry-run --json",
       "forge make resource <name> --fields title:text --with-ui --yes",
       "forge make apply <planId>",
@@ -112,16 +114,25 @@ export function buildMakeRegistry(generatorVersion: string): MakeRegistryArtifac
       },
       {
         name: "ui",
-        summary: "Add a Vite React frontend shell with ForgeProvider devAuth and a generated client bridge.",
+        summary: "Add a Vite React or Nuxt Vue frontend shell with generated Forge client bindings.",
         creates: [
           "web/package.json",
-          "web/index.html",
-          "web/src/lib/forge.ts",
-          "web/src/main.tsx",
-          "web/src/App.tsx",
+          "web/src/lib/forge.ts or web/composables/forge.ts",
+          "web/src/main.tsx or web/app.vue",
         ],
         modifies: [],
-        examples: ["forge make ui --framework vite --yes"],
+        examples: ["forge make ui --framework vite --yes", "forge make ui --framework nuxt --yes"],
+      },
+      {
+        name: "ai-chat",
+        summary: "Add a Forge AI agent and React chat component backed by /ai/agents/run.",
+        creates: [
+          "src/ai/<name>Agent.ts",
+          "web/components/<Name>AiChat.tsx",
+          "web/app/<name>-ai/page.tsx when web/app exists",
+        ],
+        modifies: [],
+        examples: ["forge make ai-chat support --yes"],
       },
       {
         name: "resource",
@@ -154,7 +165,8 @@ export function buildMakeTemplates(): MakeTemplateArtifact {
       { name: "workflow", sourceKind: "runtime", outputPattern: "src/workflows/<name>.ts" },
       { name: "component", sourceKind: "frontend", outputPattern: "web/components/<name>.tsx" },
       { name: "page", sourceKind: "frontend", outputPattern: "web/app/<route>/page.tsx" },
-      { name: "ui", sourceKind: "frontend", outputPattern: "web/src/App.tsx" },
+      { name: "ui", sourceKind: "frontend", outputPattern: "web/src/App.tsx or web/app.vue" },
+      { name: "ai-chat", sourceKind: "frontend", outputPattern: "web/components/<name>AiChat.tsx" },
       { name: "placeholder-test", sourceKind: "test", outputPattern: "tests/make-generated/<name>.test.ts" },
     ],
   };

package/src/forge/compiler/orchestrator/plan-profile.ts

@@ -0,0 +1,23 @@
+import type { EmitPlan } from "../types/emit.ts";
+
+export interface PlanPhaseTimings {
+  coreArtifactsMs: number;
+  agentArtifactsMs: number;
+  supportArtifactsMs: number;
+  fileRenderMs: number;
+  finalizeMs: number;
+  totalMs: number;
+}
+
+const planProfiles = new WeakMap<EmitPlan, PlanPhaseTimings>();
+
+export function recordPlanProfile(
+  plan: EmitPlan,
+  timings: PlanPhaseTimings,
+): void {
+  planProfiles.set(plan, timings);
+}
+
+export function getPlanProfile(plan: EmitPlan): PlanPhaseTimings | undefined {
+  return planProfiles.get(plan);
+}

package/src/forge/compiler/orchestrator/plan.ts

@@ -27,9 +27,15 @@ import {
   buildSubscriptionManifest,
 } from "../live-query-registry/build.ts";
 import { buildApiSurface } from "../api-surface/build.ts";
+import {
+  buildExternalServiceGraph,
+  serializeExternalServiceGraphJson,
+  serializeExternalServiceGraphTs,
+} from "../external-manifest/registry.ts";
 import {
   buildClientManifest,
   buildReactManifest,
+  buildVueManifest,
 } from "../client-sdk/build-manifest.ts";
 import {
   buildFrontendGraph,
@@ -43,6 +49,9 @@ import {
   renderReactDts,
   renderReactManifestTs,
   renderReactTs,
+  renderVueDts,
+  renderVueManifestTs,
+  renderVueTs,
 } from "../client-sdk/render-client.ts";
 import { buildSqlPlan } from "../data-graph/sql/ddl.ts";
 import { buildRlsArtifacts } from "../data-graph/rls/build.ts";
@@ -54,6 +63,8 @@ import { buildDevManifest } from "../dev-manifest/build.ts";
 import { buildRuntimeGraph } from "../runtime-graph/build.ts";
 import {
   buildAgentContractArtifacts,
+  serializeAgentToolRegistryJson,
+  serializeAgentToolRegistryTs,
   serializeCapabilityMapJson,
   serializeCapabilityMapTs,
   serializeAgentContractJson,
@@ -95,7 +106,6 @@ import { detectOrphanedGeneratedFiles } from "./orphans.ts";
 import type { DiscoverContext } from "./types.ts";
 import {
   serializeAppGraphJson,
-  serializeAppGraphTs,
   serializeDataGraphJson,
   serializeDataGraphTs,
   serializeImportGuardsJson,
@@ -108,6 +118,7 @@ import {
   serializeRuntimeGraphTs,
   serializeRuntimeMatrixJson,
   serializeRuntimeMatrixTs,
+  serializeConstFromJson,
   serializeRuntimeRegistryTs,
   serializeDevManifestJson,
   serializeDevManifestTs,
@@ -199,10 +210,12 @@ import {
   serializeClientApiTsExport,
   serializeClientManifestJson,
   serializeReactManifestJson,
+  serializeVueManifestJson,
   buildMockMapEntries,
 } from "./serialize.ts";
 import { buildDefaultAuthRegistry, AUTH_ENV } from "../../runtime/auth/config.ts";
 import type { EnvSchema } from "../types/secret-registry.ts";
+import { recordPlanProfile } from "./plan-profile.ts";
 
 export interface PlanInput {
   appGraph: AppGraph;
@@ -290,6 +303,8 @@ function augmentEnvSchemaWithAuthVars(schema: EnvSchema): EnvSchema {
 }
 
 export function plan(input: PlanInput): EmitPlan {
+  const started = performance.now();
+  let checkpoint = started;
   const matrix = buildRuntimeMatrix(input.classified);
   const dataGraph = buildDataGraph(input.appGraph);
   const sqlPlan = buildSqlPlan(dataGraph);
@@ -298,7 +313,8 @@ export function plan(input: PlanInput): EmitPlan {
   const workflowSubscriptions = buildWorkflowSubscriptions(workflowRegistry);
   const telemetryRegistry = buildTelemetryRegistry(input.appGraph);
   const telemetrySinks = buildTelemetrySinks(input.classified);
-  const policyRegistry = buildPolicyRegistry(input.appGraph);
+  const externalServices = buildExternalServiceGraph(input.ctx.workspaceRoot);
+  const policyRegistry = buildPolicyRegistry(input.appGraph, externalServices);
   const permissionMatrix = buildPermissionMatrixFromRegistry(policyRegistry);
   const tenantScope = buildTenantScope(dataGraph);
   const secretRegistry = buildSecretRegistry(input.classified);
@@ -321,15 +337,20 @@ export function plan(input: PlanInput): EmitPlan {
     queryRegistry,
     liveQueryRegistry,
     workflowRegistry,
+    externalServices,
   );
   const clientManifest = buildClientManifest(apiSurface, input.classified);
   const reactManifest = buildReactManifest(clientManifest);
+  const vueManifest = buildVueManifest(clientManifest);
   const frontendGraph = buildFrontendGraph({
     workspaceRoot: input.ctx.workspaceRoot,
     clientManifest,
   });
   const devManifest = buildDevManifest(runtimeGraph, queryRegistry, input.appGraph);
   const mockMapEntries = buildMockMapEntries(input.classified);
+  const coreArtifactsMs = performance.now() - checkpoint;
+  checkpoint = performance.now();
+
   const agentArtifacts = buildAgentContractArtifacts({
     workspaceRoot: input.ctx.workspaceRoot,
     appGraph: input.appGraph,
@@ -350,8 +371,12 @@ export function plan(input: PlanInput): EmitPlan {
     apiSurface,
     clientManifest,
     frontendGraph,
+    externalServices,
   });
   const agentAdapterManifest = buildAgentAdapterManifest(agentArtifacts.contract);
+  const agentArtifactsMs = performance.now() - checkpoint;
+  checkpoint = performance.now();
+
   const rlsArtifacts = buildRlsArtifacts(sqlPlan, tenantScope);
   const packageUpgradeRegistry = {
     schemaVersion: "0.1.0" as const,
@@ -387,6 +412,12 @@ export function plan(input: PlanInput): EmitPlan {
     apiSurface,
     sources: input.ctx.sources,
   });
+  const supportArtifactsMs = performance.now() - checkpoint;
+  checkpoint = performance.now();
+
+  const appGraphJson = serializeAppGraphJson(input.appGraph);
+  const packageGraphJson = serializePackageGraphJson(input.packageGraph);
+  const runtimeMatrixJson = serializeRuntimeMatrixJson(matrix);
 
   const files: EmitFile[] = [
     makeEmitFile("AGENTS.md", agentArtifacts.agentsMd),
@@ -398,7 +429,24 @@ export function plan(input: PlanInput): EmitPlan {
       `${GENERATED_DIR}/agentContract.json`,
       serializeAgentContractJson(agentArtifacts.contract),
     ),
+    makeEmitFile(
+      `${GENERATED_DIR}/externalServices.ts`,
+      serializeExternalServiceGraphTs(externalServices),
+    ),
+    makeEmitFile(
+      `${GENERATED_DIR}/externalServices.json`,
+      serializeExternalServiceGraphJson(externalServices),
+    ),
     makeEmitFile(`${GENERATED_DIR}/appMap.md`, agentArtifacts.appMapMd),
+    makeEmitFile(
+      `${GENERATED_DIR}/agentTools.ts`,
+      serializeAgentToolRegistryTs(agentArtifacts.toolRegistry),
+    ),
+    makeEmitFile(
+      `${GENERATED_DIR}/agentTools.json`,
+      serializeAgentToolRegistryJson(agentArtifacts.toolRegistry),
+    ),
+    makeEmitFile(`${GENERATED_DIR}/agentTools.md`, agentArtifacts.agentToolsMd),
     makeEmitFile(
       `${GENERATED_DIR}/capabilityMap.ts`,
       serializeCapabilityMapTs(agentArtifacts.capabilityMap),
@@ -417,6 +465,10 @@ export function plan(input: PlanInput): EmitPlan {
       `${GENERATED_DIR}/agentQuickstart.md`,
       agentArtifacts.agentQuickstartMd,
     ),
+    makeEmitFile(
+      `${GENERATED_DIR}/agentCairGuide.md`,
+      agentArtifacts.agentCairGuideMd,
+    ),
     makeEmitFile(
       `${GENERATED_DIR}/agentAdapterManifest.ts`,
       serializeAgentAdapterManifestTs(agentAdapterManifest),
@@ -435,11 +487,11 @@ export function plan(input: PlanInput): EmitPlan {
     ),
     makeEmitFile(
       `${GENERATED_DIR}/appGraph.ts`,
-      serializeAppGraphTs(input.appGraph),
+      serializeConstFromJson("appGraph", appGraphJson),
     ),
     makeEmitFile(
       `${GENERATED_DIR}/appGraph.json`,
-      serializeAppGraphJson(input.appGraph),
+      appGraphJson,
     ),
     makeEmitFile(
       `${GENERATED_DIR}/packageGraph.ts`,
@@ -447,7 +499,7 @@ export function plan(input: PlanInput): EmitPlan {
     ),
     makeEmitFile(
       `${GENERATED_DIR}/packageGraph.json`,
-      serializePackageGraphJson(input.packageGraph),
+      packageGraphJson,
     ),
     makeEmitFile(
       `${GENERATED_DIR}/runtimeMatrix.ts`,
@@ -455,7 +507,7 @@ export function plan(input: PlanInput): EmitPlan {
     ),
     makeEmitFile(
       `${GENERATED_DIR}/runtimeMatrix.json`,
-      serializeRuntimeMatrixJson(matrix),
+      runtimeMatrixJson,
     ),
     makeEmitFile(
       `${GENERATED_DIR}/importGuards.ts`,
@@ -844,7 +896,16 @@ export function plan(input: PlanInput): EmitPlan {
       `${GENERATED_DIR}/reactManifest.json`,
       serializeReactManifestJson(reactManifest),
     ),
+    makeEmitFile(`${GENERATED_DIR}/vue.ts`, renderVueTs()),
+    makeEmitFile(`${GENERATED_DIR}/vue.d.ts`, renderVueDts()),
+    makeEmitFile(`${GENERATED_DIR}/vueManifest.ts`, renderVueManifestTs(vueManifest)),
+    makeEmitFile(
+      `${GENERATED_DIR}/vueManifest.json`,
+      serializeVueManifestJson(vueManifest),
+    ),
   ];
+  const fileRenderMs = performance.now() - checkpoint;
+  checkpoint = performance.now();
 
   const sortedFiles = stableSortEmitFiles(files);
   const plannedPathSet = new Set(sortedFiles.map((file) => file.path));
@@ -855,8 +916,9 @@ export function plan(input: PlanInput): EmitPlan {
   );
 
   const lock = buildForgeLock(input);
+  const finalizeMs = performance.now() - checkpoint;
 
-  return {
+  const result = {
     files: sortedFiles,
     orphanedFiles,
     lock,
@@ -873,4 +935,13 @@ export function plan(input: PlanInput): EmitPlan {
       ),
     ],
   };
+  recordPlanProfile(result, {
+    coreArtifactsMs,
+    agentArtifactsMs,
+    supportArtifactsMs,
+    fileRenderMs,
+    finalizeMs,
+    totalMs: performance.now() - started,
+  });
+  return result;
 }

package/src/forge/compiler/orchestrator/profile.ts

@@ -1,15 +1,37 @@
+import type { AppGraphPhaseTimings } from "../app-graph/profile.ts";
+import type { SignalProfile } from "../classifier/signals.ts";
+import type { PlanPhaseTimings } from "./plan-profile.ts";
+
 export interface CompilePhaseTimings {
+  fastCheckMs: number;
+  sessionMs: number;
   discoverMs: number;
+  graphBuildMs: number;
   appGraphMs: number;
+  appGraph?: AppGraphPhaseTimings;
   packageGraphMs: number;
+  classifyMs: number;
+  classifierSignals?: SignalProfile;
   planMs: number;
+  planDetail?: PlanPhaseTimings;
+  runtimeMatrixMs: number;
+  importGuardsMs: number;
+  qualityGateMs: number;
   emitMs: number;
+  postEmitMs: number;
+  unaccountedMs: number;
   totalMs: number;
 }
 
 let lastTimings: CompilePhaseTimings | null = null;
 
 export function isCompileProfileEnabled(): boolean {
+  return process.env.FORGE_PROFILE === "1" ||
+    process.env.FORGE_PROFILE === "true" ||
+    process.env.FORGE_PROFILE === "silent";
+}
+
+export function shouldPrintCompileProfile(): boolean {
   return process.env.FORGE_PROFILE === "1" || process.env.FORGE_PROFILE === "true";
 }
 
@@ -26,11 +48,54 @@ export function getCompileTimings(): CompilePhaseTimings | null {
 export function formatCompileTimings(timings: CompilePhaseTimings): string {
   return [
     "forge compile profile:",
+    `  fast-check: ${timings.fastCheckMs}ms`,
+    `  session: ${timings.sessionMs}ms`,
     `  discover: ${timings.discoverMs}ms`,
+    `  graph-build: ${timings.graphBuildMs}ms`,
     `  app-graph: ${timings.appGraphMs}ms`,
+    ...(timings.appGraph
+      ? [
+          `    normalize: ${timings.appGraph.normalizeMs}ms`,
+          `    parse: ${timings.appGraph.parseMs}ms`,
+          `    symbols: ${timings.appGraph.symbolsMs}ms`,
+          `    duplicates: ${timings.appGraph.duplicatesMs}ms`,
+          `    module-graph: ${timings.appGraph.moduleGraphMs}ms`,
+          `    input-hash: ${timings.appGraph.inputHashMs}ms`,
+        ]
+      : []),
     `  package-graph: ${timings.packageGraphMs}ms`,
+    `  classify: ${timings.classifyMs}ms`,
+    ...(timings.classifierSignals
+      ? [
+          `    gatherSignals: ${timings.classifierSignals.totalMs}ms`,
+          `    gatherSignals calls: ${timings.classifierSignals.calls}`,
+          `    gatherSignals exports scanned: ${timings.classifierSignals.exports}`,
+          `    gatherSignals corpus bytes: ${timings.classifierSignals.corpusBytes}`,
+          `    gatherSignals packages: ${timings.classifierSignals.packageCount}`,
+          ...timings.classifierSignals.topPackages
+            .slice(0, 5)
+            .map(
+              (pkg) =>
+                `      ${pkg.packageName}: ${pkg.totalMs}ms, ${pkg.calls} calls, ${pkg.exports} exports`,
+            ),
+        ]
+      : []),
     `  plan: ${timings.planMs}ms`,
+    ...(timings.planDetail
+      ? [
+          `    core-artifacts: ${timings.planDetail.coreArtifactsMs}ms`,
+          `    agent-artifacts: ${timings.planDetail.agentArtifactsMs}ms`,
+          `    support-artifacts: ${timings.planDetail.supportArtifactsMs}ms`,
+          `    file-render: ${timings.planDetail.fileRenderMs}ms`,
+          `    finalize: ${timings.planDetail.finalizeMs}ms`,
+        ]
+      : []),
+    `  runtime-matrix: ${timings.runtimeMatrixMs}ms`,
+    `  import-guards: ${timings.importGuardsMs}ms`,
+    `  quality-gate: ${timings.qualityGateMs}ms`,
     `  emit: ${timings.emitMs}ms`,
+    `  post-emit: ${timings.postEmitMs}ms`,
+    `  unaccounted: ${timings.unaccountedMs}ms`,
     `  total: ${timings.totalMs}ms`,
   ].join("\n");
 }

package/src/forge/compiler/orchestrator/run.ts

@@ -5,6 +5,12 @@ import {
 import type { GenerateOptions, GenerateResult } from "../types/cli.ts";
 import type { Diagnostic } from "../types/diagnostic.ts";
 import { classify } from "../classifier/classify.ts";
+import { getAppGraphProfile } from "../app-graph/profile.ts";
+import {
+  clearSignalProfile,
+  getSignalProfile,
+  resetSignalProfile,
+} from "../classifier/signals.ts";
 import type { ClassifiedPackage } from "../classifier/runtime-matrix.ts";
 import { buildRuntimeMatrix } from "../classifier/runtime-matrix.ts";
 import { emit } from "../emitter/emit.ts";
@@ -25,8 +31,10 @@ import {
   formatCompileTimings,
   isCompileProfileEnabled,
   recordCompileTimings,
+  shouldPrintCompileProfile,
 } from "./profile.ts";
 import { plan } from "./plan.ts";
+import { getPlanProfile } from "./plan-profile.ts";
 import {
   buildAppGraphForSession,
   discoverForSession,
@@ -100,6 +108,7 @@ export async function run(options: GenerateOptions): Promise<GenerateResult> {
 async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
   const profileEnabled = isCompileProfileEnabled();
   const runStarted = profileEnabled ? performance.now() : 0;
+  let fastCheckMs = 0;
   let generateCheckCache: GenerateResult["cache"] =
     options.check && !options.dryRun
       ? {
@@ -110,7 +119,9 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
       : undefined;
 
   if (options.check && !options.dryRun) {
+    const fastCheckStarted = profileEnabled ? performance.now() : 0;
     const fastCheck = runFastGenerateCheck(options.workspaceRoot);
+    fastCheckMs = profileEnabled ? performance.now() - fastCheckStarted : 0;
     if (fastCheck.kind === "hit") {
       return fastCheck.result;
     }
@@ -121,7 +132,9 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
     };
   }
 
+  const sessionStarted = profileEnabled ? performance.now() : 0;
   const session = getCompileSession(options.workspaceRoot);
+  const sessionMs = profileEnabled ? performance.now() - sessionStarted : 0;
 
   const discoverStarted = profileEnabled ? performance.now() : 0;
   const ctx = discoverForSession(session);
@@ -130,20 +143,40 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
 
   const pkgCompiler = new PackageGraphCompiler();
 
-  const graphStarted = profileEnabled ? performance.now() : 0;
-  const [appGraph, pkgResult] = await Promise.all([
-    buildAppGraphForSession(session),
-    pkgCompiler.build(ctx.dependencies, {
+  let appGraphMs = 0;
+  let packageGraphMs = 0;
+  const graphBuildStarted = profileEnabled ? performance.now() : 0;
+  const appGraphPromise = (async () => {
+    const started = profileEnabled ? performance.now() : 0;
+    const graph = await buildAppGraphForSession(session);
+    appGraphMs = profileEnabled ? performance.now() - started : 0;
+    return graph;
+  })();
+  const packageGraphPromise = (async () => {
+    const started = profileEnabled ? performance.now() : 0;
+    const result = await pkgCompiler.build(ctx.dependencies, {
       runtimeInspect: false,
       resolutionMode: "nodenext",
       cacheDir: ctx.cacheDir,
       concurrency: options.concurrency,
       lockfileHash: ctx.lockfileHash,
-    }),
-  ]);
-  const graphMs = profileEnabled ? performance.now() - graphStarted : 0;
+    });
+    packageGraphMs = profileEnabled ? performance.now() - started : 0;
+    return result;
+  })();
+  const [appGraph, pkgResult] = await Promise.all([appGraphPromise, packageGraphPromise]);
+  const graphBuildMs = profileEnabled ? performance.now() - graphBuildStarted : 0;
 
+  const classifyStarted = profileEnabled ? performance.now() : 0;
+  if (profileEnabled) {
+    resetSignalProfile();
+  }
   const classified = classifyPackages(pkgResult.graph);
+  const classifierSignals = profileEnabled ? getSignalProfile() : undefined;
+  if (profileEnabled) {
+    clearSignalProfile();
+  }
+  const classifyMs = profileEnabled ? performance.now() - classifyStarted : 0;
 
   const planStarted = profileEnabled ? performance.now() : 0;
   const emitPlan = plan({
@@ -160,8 +193,13 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
       ? "dry-run"
       : "write";
 
+  const runtimeMatrixStarted = profileEnabled ? performance.now() : 0;
   const matrix = buildRuntimeMatrix(classified);
+  const runtimeMatrixMs = profileEnabled ? performance.now() - runtimeMatrixStarted : 0;
+  const importGuardsStarted = profileEnabled ? performance.now() : 0;
   const guardDiagnostics = checkImportGuards(appGraph.moduleGraph, matrix);
+  const importGuardsMs = profileEnabled ? performance.now() - importGuardsStarted : 0;
+  const qualityGateStarted = profileEnabled ? performance.now() : 0;
   // Import guards fail `forge check`; generate/drift only surface them as warnings.
   const guardDiagnosticsForGate =
     mode === "check"
@@ -176,6 +214,7 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
     pkgResult.diagnostics,
     [...guardDiagnosticsForGate, ...(emitPlan.diagnostics ?? [])],
   );
+  const qualityGateMs = profileEnabled ? performance.now() - qualityGateStarted : 0;
 
   const emitStarted = profileEnabled ? performance.now() : 0;
   const emitResult = await emit(emitPlan, {
@@ -184,6 +223,7 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
   });
   const emitMs = profileEnabled ? performance.now() - emitStarted : 0;
 
+  const postEmitStarted = profileEnabled ? performance.now() : 0;
   const warnings: Diagnostic[] = [
     ...qualityDiagnostics.filter((d) => d.severity === "warning"),
     ...emitResult.warnings,
@@ -214,30 +254,6 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
     }
   }
 
-  if (profileEnabled) {
-    const totalMs = performance.now() - runStarted;
-    recordCompileTimings({
-      discoverMs,
-      appGraphMs: graphMs,
-      packageGraphMs: 0,
-      planMs,
-      emitMs,
-      totalMs,
-    });
-    const fsProfile = getFileSystemProfile();
-    process.stderr.write(`${formatCompileTimings({
-      discoverMs,
-      appGraphMs: graphMs,
-      packageGraphMs: 0,
-      planMs,
-      emitMs,
-      totalMs,
-    })}\n`);
-    if (fsProfile) {
-      process.stderr.write(`${formatFileSystemProfile(fsProfile)}\n`);
-    }
-  }
-
   const driftFailure =
     options.check &&
     (emitResult.changed.length > 0 ||
@@ -257,6 +273,56 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
   const unchanged = emitResult.unchanged.filter((path) =>
     plannedPaths.has(path),
   );
+  const postEmitMs = profileEnabled ? performance.now() - postEmitStarted : 0;
+
+  if (profileEnabled) {
+    const totalMs = performance.now() - runStarted;
+    const appGraphProfile = getAppGraphProfile(appGraph);
+    const planProfile = getPlanProfile(emitPlan);
+    const unaccountedMs = Math.max(
+      0,
+      totalMs -
+        fastCheckMs -
+        sessionMs -
+        discoverMs -
+        graphBuildMs -
+        classifyMs -
+        planMs -
+        runtimeMatrixMs -
+        importGuardsMs -
+        qualityGateMs -
+        emitMs -
+        postEmitMs,
+    );
+    const timings = {
+      fastCheckMs,
+      sessionMs,
+      discoverMs,
+      graphBuildMs,
+      appGraphMs,
+      ...(appGraphProfile ? { appGraph: appGraphProfile } : {}),
+      packageGraphMs,
+      classifyMs,
+      ...(classifierSignals ? { classifierSignals } : {}),
+      planMs,
+      ...(planProfile ? { planDetail: planProfile } : {}),
+      runtimeMatrixMs,
+      importGuardsMs,
+      qualityGateMs,
+      emitMs,
+      postEmitMs,
+      unaccountedMs,
+      totalMs,
+    };
+    recordCompileTimings(timings);
+    const fsProfile = getFileSystemProfile();
+    if (shouldPrintCompileProfile()) {
+      process.stderr.write(`${formatCompileTimings(timings)}\n`);
+      if (fsProfile) {
+        process.stderr.write(`${formatFileSystemProfile(fsProfile)}\n`);
+      }
+    }
+  }
 
   return {
     changed,