@hypit/hypit 0.1.3 → 0.1.5

package/packages/cli/src/commands/execution.ts

@@ -1,12 +1,14 @@
+import { readExecutionLog } from "@hypit/runtime";
 import type { BuildResultManifest, BuildResultRepository } from "@hypit/build-result";
 import type { NodeRuntimeHost } from "@hypit/runtime-host-node";
 
 import type { CliCommand, ExecutionCommand } from "../command.js";
-import { activityObservationKey, buildProgressLines, observeBuildView } from "../observation.js";
+import { activityObservationKey, buildProgressLines, buildProgressView, observeBuildView } from "../observation.js";
 import type { CliIo } from "../output.js";
 import type { CliRuntimeController } from "../runtime-port.js";
 import { formatOperationProgress } from "../runtime-view.js";
 import { buildStatusView } from "../view.js";
+import type { CliBuildStatusView } from "../view.js";
 import type { OperationalWriter } from "./types.js";
 
 type OpenProjectResults = () => Promise<{
@@ -14,8 +16,21 @@ type OpenProjectResults = () => Promise<{
   close(): void | Promise<void>;
 }>;
 
+function statusDetailLines(build: CliBuildStatusView | null): string[] {
+  return [
+    ...(build?.failure === undefined ? [] : [`Reason    ${build.failure}`]),
+    ...(build?.commands ?? []).map((command) => `${command.endpoint}: ${formatOperationProgress(command.progress)}`),
+    ...(build?.operations ?? []).map((operation) => {
+      const label = `${operation.endpoint}${operation.receipt === undefined ? "" : ` · task ${operation.receipt.id}`}`;
+      const detail = operation.failure !== undefined ? `${operation.failure.code} — ${operation.failure.message}`
+        : operation.progress === undefined ? operation.state : formatOperationProgress(operation.progress);
+      return `${label}: ${detail}${operation.count === undefined ? "" : ` ×${operation.count}`}`;
+    }),
+  ];
+}
+
 export function isExecutionCommand(args: CliCommand): args is ExecutionCommand {
-  return args.command === "status" || args.command === "cancel" || args.command === "activity"
+  return args.command === "logs" || args.command === "status" || args.command === "cancel" || args.command === "activity"
     || (args.command === "result" && (args.action === "finish" || args.action === "discard"));
 }
 
@@ -23,6 +38,7 @@ export function isExecutionCommand(args: CliCommand): args is ExecutionCommand {
 export async function runExecutionCommand(input: {
   readonly args: ExecutionCommand;
   readonly runtimeProfile: string | undefined;
+  readonly resolveProjectRuntime?: () => Promise<string | undefined>;
   readonly io: CliIo;
   readonly runtimeHost: (profile: string) => Promise<NodeRuntimeHost>;
   readonly runtimeController: (profile: string) => Promise<CliRuntimeController>;
@@ -30,6 +46,53 @@ export async function runExecutionCommand(input: {
   readonly write: OperationalWriter;
 }): Promise<void> {
   const { args, runtimeProfile, io, runtimeHost, runtimeController, openProjectResults, write } = input;
+  if (args.command === "logs") {
+    const opened = await openProjectResults();
+    let source: "runtime" | "result" | "unavailable" = "unavailable";
+    let view: import("@hypit/runtime").ExecutionLogView | undefined;
+    let finished = false;
+    try {
+      const result = await opened.repository.read(args.build);
+      finished = result?.outcome !== undefined;
+      if (result?.executionLog !== undefined) {
+        const chunks = await opened.repository.openFile(args.build, result.executionLog);
+        if (chunks === undefined) throw new Error(`Build ${args.build} execution log file is unavailable`);
+        view = await readExecutionLog(chunks, args.lines);
+        source = "result";
+      }
+    } finally { await opened.close(); }
+    const activeProfile = !finished && view === undefined
+      ? runtimeProfile ?? await input.resolveProjectRuntime?.() : undefined;
+    if (activeProfile !== undefined) {
+      const control = await (await runtimeHost(activeProfile)).openControl({ readOnly: true });
+      try { view = await control.logs?.(args.build, args.lines); }
+      finally { await control.close(); }
+      if (view !== undefined) source = "runtime";
+      // Result finishing can move the log between the first read and the active read.
+      if (view === undefined) {
+        const completed = await openProjectResults();
+        try {
+          const result = await completed.repository.read(args.build);
+          if (result?.executionLog !== undefined) {
+            const chunks = await completed.repository.openFile(args.build, result.executionLog);
+            if (chunks !== undefined) { view = await readExecutionLog(chunks, args.lines); source = "result"; }
+          }
+        } finally { await completed.close(); }
+      }
+    }
+    const records = view?.records ?? [];
+    const omitted = (view?.total ?? 0) - records.length;
+    write({ format: "hypit.cli-logs@1", build: args.build, source, records, omittedRecords: omitted },
+      view === undefined ? "No execution log recorded" : "Build execution log", "info",
+      [["Build", args.build], ["Source", source]], [
+        ...(omitted > 0 ? [`Showing last ${records.length} records; ${omitted} earlier records omitted. Use --lines to read more.`] : []),
+        ...records.map((record) => `${new Date(record.time).toISOString()}  ${record.endpoint}  ${record.command}  ${
+          record.kind === "phase" ? record.phase : record.kind === "diagnostic" || record.kind === "failed"
+            ? `${record.kind}: ${record.message}` : record.kind}`),
+      ]);
+    return;
+  }
+
   if (args.command === "status" && runtimeProfile === undefined) {
     const openedResults = await openProjectResults();
     let result;
@@ -42,7 +105,7 @@ export async function runExecutionCommand(input: {
       throw new Error(`Build ${args.build} has no finished Result; select its Runtime to observe active execution`);
     }
     const finished = result?.outcome !== undefined;
-    const build = result === undefined ? null : buildStatusView({ id: result.id, result });
+    const build = result === undefined ? null : buildStatusView({ id: result.id, result, verbose: args.presentation.verbose });
     const outcome = result?.outcome;
     write({ format: "hypit.cli-status@1", build }, result === undefined
       ? "Build Result not found"
@@ -56,11 +119,12 @@ export async function runExecutionCommand(input: {
       ...(build?.title === undefined ? [] : [["Title", build.title] as const]),
       ...(outcome === undefined ? [] : [["Outcome", outcome] as const]),
       ...(!finished && result !== undefined ? [["Result", "open"] as const] : []),
-      ...(build?.result.outputCount === undefined ? [] : [["Outputs", String(build.result.outputCount)] as const]),
-    ], !finished && result !== undefined
-      ? ["Select the Runtime to inspect active work."]
-      : []);
-    if (result === undefined || !finished) io.setExitCode?.(1);
+      ...(build?.targets?.length ? [["Targets", build.targets.join(", ")] as const] : []),
+    ], [
+      ...statusDetailLines(build),
+      ...(!finished && result !== undefined ? ["Select the Runtime to inspect active work."] : []),
+    ]);
+    if (result === undefined || !finished || outcome === "failed") io.setExitCode?.(1);
     return;
   }
 
@@ -98,11 +162,12 @@ export async function runExecutionCommand(input: {
           return {
             id: item.id,
             work: status.work,
-            ...(item.outcome === undefined ? {} : { outcome: item.outcome }),
+            phases: buildProgressView(item).phases,
             ...(status.attention === undefined ? {} : { attention: status.attention }),
           };
         });
-        const currentView = activityObservationKey(worker.state, activity.builds);
+        const currentView = JSON.stringify([activity.builds.length,
+          activityObservationKey(worker.state, activity.builds.slice(0, args.limit))]);
         if (args.watch && currentView === previous) return;
         previous = currentView;
         const value = {
@@ -111,7 +176,7 @@ export async function runExecutionCommand(input: {
           worker: worker.state,
           builds,
           ...(activity.builds.length <= args.limit ? {} : { omittedBuilds: activity.builds.length - args.limit }),
-          capacity: activity.capacity,
+          ...(args.presentation.verbose ? { capacity: activity.capacity } : {}),
         };
         const buildLines = activity.builds.slice(0, args.limit).map((item) => {
           const requestProgress = item.requests === undefined || item.requests.total === 0
@@ -119,20 +184,16 @@ export async function runExecutionCommand(input: {
             : ` · ${item.requests.completed}/${item.requests.total} steps`;
           return `${item.id}: ${buildStatusView({ id: item.id, runtime: item }).work.state}`
             + requestProgress
+            + Object.entries(buildProgressView(item).phases).map(([phase, count]) => ` · ${count} ${phase}`).join("")
             + `${item.stop?.cause === "execution-failed" ? " · stopping after failure" : item.cancellationRequested ? " · cancelling" : ""}`
             + `${item.issue === undefined ? "" : ` · ${item.issue.message}`}`;
         });
-        const activeOperations = activity.builds.flatMap((item) => item.operations)
-          .filter((item) => item.status === "pending");
         const operationLines = args.presentation.verbose
-          ? activity.builds.flatMap((build) => build.operations.filter((item) => item.status === "pending")
-              .map((item) => `${build.id} · ${item.endpoint}: ${item.progress === undefined
-                ? item.status
-                : formatOperationProgress(item.progress)}`)).slice(0, args.limit)
+          ? activity.builds.slice(0, args.limit).flatMap((build) => buildProgressView(build).details
+              .map((detail) => `${build.id} · ${detail}`))
           : [];
         write(value, "Runtime activity", activity.builds.length === 0 ? "success" : "info", [
           ["Active Builds", String(activity.builds.length)],
-          ["Active Operations", String(activeOperations.length)],
           ["Worker", worker.state],
         ], [
           ...buildLines,
@@ -187,7 +248,6 @@ export async function runExecutionCommand(input: {
         ...(result === undefined ? {} : { result }),
         ...(resultReadError === undefined ? {} : { resultReadError }),
         verbose: args.presentation.verbose,
-        operationLimit: args.limit,
       });
       const attention = build?.attention;
       const humanTitle = !found
@@ -226,14 +286,9 @@ export async function runExecutionCommand(input: {
             ["Result", "saving"] as const,
           ] : resultOutcome !== undefined ? [
             ["Outcome", resultOutcome] as const,
-            ...(build?.result.outputCount === undefined
-              ? [] : [["Outputs", String(build.result.outputCount)] as const]),
           ] : [["State", build?.work.state ?? "unknown"] as const]),
-        ], (build?.operations ?? []).map((operation) => operation.failure !== undefined
-          ? `${operation.endpoint}${operation.receipt === undefined ? "" : ` · task ${operation.receipt.id}`}: ${operation.failure.code} — ${operation.failure.message}`
-          : operation.progress === undefined
-            ? `${operation.endpoint}${operation.receipt === undefined ? "" : ` · task ${operation.receipt.id}`}: ${operation.state}`
-            : `${operation.endpoint}${operation.receipt === undefined ? "" : ` · task ${operation.receipt.id}`}: ${formatOperationProgress(operation.progress)}`)
+          ...(build?.targets?.length ? [["Targets", build.targets.join(", ")] as const] : []),
+        ], statusDetailLines(build)
           .concat(attention === undefined ? [] : [
             `Attention  ${attention.message}`,
             ...(attention.action === undefined ? [] : [`Action     ${attention.action}`]),

package/packages/cli/src/commands/results.ts

@@ -100,13 +100,8 @@ export async function runProjectResultCommand(input: {
       projectRoot,
       ...(args.outputName === undefined ? {} : { output: args.outputName }),
       limit: args.limit,
+      verbose: args.presentation.verbose,
     });
-    const focusedOutputs = args.outputName === undefined
-      ? build.outputs.filter((item) => item.target || item.highlighted)
-      : build.outputs;
-    const visibleOutputs = args.presentation.verbose ? build.outputs : focusedOutputs;
-    const outputCount = build.outputs.length + (build.omittedOutputs ?? 0);
-    const hiddenOutputCount = args.outputName === undefined ? outputCount - focusedOutputs.length : 0;
     write({ format: "hypit.cli-inspect@1", build }, "Build Result",
       manifest.outcome === "failed" ? "error"
         : manifest.outcome === "cancelled" ? "warning"
@@ -117,23 +112,24 @@ export async function runProjectResultCommand(input: {
         ["Outcome", build.outcome],
         ...(args.outputName === undefined ? [
           ["Targets", String(build.targetCount)] as const,
-          ["Outputs", String(outputCount)] as const,
+          ["Available Outputs", String(build.outputCount)] as const,
         ] : []),
       ], [
         ...(build.failure === undefined ? [] : [`Reason    ${build.failure}`]),
+        ...(build.executionLog === undefined ? [] : [`Execution log    hypit logs ${build.id}`]),
         ...(build.operations ?? []).map((operation) =>
           `${operation.endpoint}: ${operation.status}${operation.receipt === undefined ? "" : ` · task ${operation.receipt.id}`}`
           + (operation.failure === undefined ? "" : ` · ${operation.failure.code}: ${operation.failure.message}`)),
         ...(build.omittedOperations === undefined ? [] : [`${build.omittedOperations} more execution receipts · use --limit <count>`]),
         ...(build.note === undefined ? [] : [`Note      ${build.note}`]),
-        ...visibleOutputs.map((item) => `${item.highlighted ? "★" : item.target ? "Target" : "Output"}    ${item.name}`
+        ...build.outputs.map((item) => `${item.highlighted ? "★" : item.target ? "Target" : "Output"}    ${item.name}`
           + (!args.presentation.verbose ? "" : ` · ${item.type} · ${item.kind}`
             + `${item.mediaType === undefined ? "" : ` · ${item.mediaType}`}`
             + `${item.size === undefined ? "" : ` · ${item.size} bytes`}`)),
-        ...(!args.presentation.verbose && hiddenOutputCount > 0 ? [
-          `${hiddenOutputCount} other Output${hiddenOutputCount === 1 ? "" : "s"} · use --verbose or --output <name>`,
+        ...(args.outputName === undefined && (build.otherOutputCount ?? 0) > 0 ? [
+          `${build.otherOutputCount} other Outputs · use --verbose or --output <name>`,
         ] : []),
-        ...(args.presentation.verbose && build.omittedOutputs !== undefined ? [
+        ...(build.omittedOutputs !== undefined ? [
           `${build.omittedOutputs} more Outputs · use --limit <count> or --output <name>`,
         ] : []),
       ]);

package/packages/cli/src/index.ts

@@ -4,8 +4,8 @@ export { loadDiscoveredSourcePackages } from "./source-packages.js";
 export { collectRunFrontends, loadRunFile, resolveBuildResultValue } from "./run-file.js";
 export type { LoadedRunFile } from "./run-file.js";
 export { hypitHostStateRoot, hypitProjectStateRoot } from "./paths.js";
-export { resolvePackageRoot, resolveProjectRoot } from "./project-context.js";
-export { findRuntimeProfile } from "./runtime-selection.js";
+export { resolvePackageRoot, resolveProjectRoot } from "@hypit/project-context-node";
+export { findRuntimeProfile } from "@hypit/project-context-node";
 export { renderCliError, writeCliHelp, writeCliOutput } from "./output.js";
 export type {
   CliColorMode,

package/packages/cli/src/machine-view.ts

@@ -1,15 +1,25 @@
 import type { CliBuildResultView, CliBuildStatusView, CliOutputView } from "./view.js";
 
-type ProgramStateView = { readonly id: string; readonly state: string; readonly action?: string };
+type ProgramStateView = {
+  readonly id: string;
+  readonly state: string;
+  readonly action?: string;
+  readonly endpoint?: string;
+  readonly stateDetail?: string;
+  readonly detail?: string;
+  readonly pid?: number;
+  readonly logPath?: string;
+};
 type AttentionView = { readonly message: string; readonly action?: string };
 
 export type OperationalMachineView =
+  | { readonly format: "hypit.cli-logs@1"; readonly build: string; readonly source: "runtime" | "result" | "unavailable"; readonly records: readonly import("@hypit/runtime").ExecutionLogRecord[]; readonly omittedRecords: number }
   | { readonly format: "hypit.cli-runtime-init@1"; readonly profile: string; readonly project: string; readonly selected: true }
   | { readonly format: "hypit.cli-runtime-selection@1"; readonly selected: boolean; readonly removed?: boolean; readonly profile?: string; readonly project?: string }
-  | { readonly format: "hypit.cli-paths@1"; readonly project: string; readonly projectState: string; readonly profile?: string; readonly runtimeData?: string; readonly hostState: string; readonly machinePackages: string; readonly distribution?: string }
+  | { readonly format: "hypit.cli-paths@1"; readonly project: string; readonly projectState: string; readonly profileSource: "argument" | "project" | "none"; readonly selectionFile: string; readonly profile?: string; readonly runtimeData?: string; readonly hostState: string; readonly machinePackages: string; readonly distribution?: string }
   | { readonly format: "hypit.cli-package@1"; readonly action: "install" | "status"; readonly package: string; readonly ready: boolean }
-  | { readonly format: "hypit.cli-programs@1"; readonly action: "up" | "down" | "status"; readonly ready: boolean; readonly programs: readonly ProgramStateView[]; readonly omittedPrograms?: number }
-  | { readonly format: "hypit.cli-runtime-up@1"; readonly ready: boolean; readonly worker: string; readonly preparedPackages: number; readonly programs: { readonly total: number; readonly ready: number } }
+  | { readonly format: "hypit.cli-programs@1"; readonly action: "up" | "down" | "status"; readonly ready: boolean; readonly programCount: number; readonly readyCount: number; readonly programs: readonly ProgramStateView[]; readonly omittedPrograms?: number }
+  | { readonly format: "hypit.cli-runtime-up@1"; readonly ready: boolean; readonly worker: string; readonly preparedPackages: number; readonly programs: { readonly total: number; readonly ready: number; readonly items: readonly ProgramStateView[] } }
   | { readonly format: "hypit.cli-runtime-logs@1"; readonly lines: readonly string[]; readonly totalLines: number; readonly omittedLines: number; readonly path?: string }
   | { readonly format: "hypit.cli-runtime-down@1"; readonly worker: string }
   | { readonly format: "hypit.cli-runtime-status@1"; readonly ready: boolean; readonly attention: boolean; readonly worker: { readonly state: string; readonly configuration?: string }; readonly builds: Readonly<Record<string, number>>; readonly programs: { readonly total: number; readonly ready: number; readonly unavailable: readonly ProgramStateView[] }; readonly capacity: { readonly active: number } }
@@ -21,7 +31,7 @@ export type OperationalMachineView =
   | { readonly format: "hypit.cli-result-edit@1"; readonly build: string; readonly title: string | null; readonly note: string | null; readonly highlightedOutputCount: number; readonly highlightedOutputs: readonly string[]; readonly omittedHighlightedOutputs?: number }
   | { readonly format: "hypit.cli-get@1"; readonly build: string; readonly output: string; readonly type: string; readonly kind: "scalar" | "resource" | "composite"; readonly path: string }
   | { readonly format: "hypit.cli-status@1"; readonly build: CliBuildStatusView | null }
-  | { readonly format: "hypit.cli-activity@1"; readonly at: number; readonly worker: string; readonly builds: readonly { readonly id: string; readonly work: CliBuildStatusView["work"]; readonly outcome?: string; readonly attention?: AttentionView }[]; readonly omittedBuilds?: number; readonly capacity: readonly import("@hypit/runtime").CapacityReservation[] }
+  | { readonly format: "hypit.cli-activity@1"; readonly at: number; readonly worker: string; readonly builds: readonly { readonly id: string; readonly work: CliBuildStatusView["work"]; readonly phases: Readonly<Record<string, number>>; readonly attention?: AttentionView }[]; readonly omittedBuilds?: number; readonly capacity?: readonly import("@hypit/runtime").CapacityReservation[] }
   | { readonly format: "hypit.cli-result-discard@1"; readonly build: string; readonly discarded: boolean }
   | { readonly format: "hypit.cli-result-finish@1"; readonly build: string; readonly found?: false; readonly outcome?: string; readonly attention?: AttentionView }
   | { readonly format: "hypit.cli-cancel@1"; readonly requested: boolean; readonly build: CliBuildStatusView | null }

package/packages/cli/src/main.ts

@@ -13,7 +13,7 @@ import type {
   CliRuntime,
   CliRuntimeController,
 } from "./runtime-port.js";
-import { createPricingOutput, writeCliHelp, writeCliOutput } from "./output.js";
+import { createPlanOutput, createPricingOutput, writeCliHelp, writeCliOutput } from "./output.js";
 import type { CliIo, CliMachineView } from "./output.js";
 import { parseCommand } from "./arguments.js";
 import type { CliCommand, RuntimeOption } from "./command.js";
@@ -23,13 +23,13 @@ import { isProjectResultCommand, runProjectResultCommand } from "./commands/resu
 import { isEnvironmentCommand, runEnvironmentCommand } from "./commands/environment.js";
 import { isExecutionCommand, runExecutionCommand } from "./commands/execution.js";
 import { inlineValuePreview } from "./runtime-view.js";
-import { resolvePackageRoot, resolveProjectRoot } from "./project-context.js";
+import { resolvePackageRoot, resolveProjectRoot } from "@hypit/project-context-node";
 import { loadDiscoveredSourcePackages } from "./source-packages.js";
 import {
   clearRuntimeProfile,
   findRuntimeProfile,
   selectRuntimeProfile,
-} from "./runtime-selection.js";
+} from "@hypit/project-context-node";
 import {
   buildStatusView,
   cliTypeName,
@@ -40,8 +40,8 @@ function createPublicBuildId(now = Date.now()): string {
   return orderedBuildId(now, randomBytes(5).toString("hex").toUpperCase());
 }
 
-async function loadRuntime(host: NodeRuntimeHost): Promise<CliRuntime> {
-  return await host.createRuntime();
+async function loadRuntime(host: NodeRuntimeHost, endpoints: readonly string[]): Promise<CliRuntime> {
+  return await host.createRuntime({ endpoints });
 }
 
 function commandWorkspaceRoot(command: CliCommand): string | undefined {
@@ -116,7 +116,8 @@ export async function runCli(
     await (await runtimeHost(
       args.profile,
       args.packageRoot ?? await packageRootForProject(),
-    )).runWorker(args.readyFile, args.workerOwner);
+    )).runWorker(args.readyFile, args.workerOwner,
+      args.executionRoot === undefined ? undefined : { dataRoot: args.executionRoot });
     return;
   }
   if (args.command === "runtime" && args.action === "init") {
@@ -177,12 +178,14 @@ export async function runCli(
   }
 
   let runtimeProfile = acceptsRuntimeContext(args) ? args.runtimeProfile : undefined;
+  let runtimeSelectionFile: string | undefined;
   const runtimeWasExplicit = runtimeProfile !== undefined;
   let runtimeNeedsHint = runtimeWasExplicit;
-  if (acceptsRuntimeContext(args) && runtimeProfile === undefined) {
+  if (acceptsRuntimeContext(args) && runtimeProfile === undefined && args.command !== "logs") {
     const selected = await findRuntimeProfile(await commandProjectRoot());
     if (selected !== undefined) {
       runtimeProfile = selected.profile;
+      runtimeSelectionFile = selected.selectionFile;
       runtimeNeedsHint = false;
     }
   }
@@ -196,6 +199,7 @@ export async function runCli(
     await runEnvironmentCommand({
       args,
       runtimeProfile,
+      runtimeSelectionFile,
       io,
       distribution,
       projectRoot: await commandProjectRoot(),
@@ -228,6 +232,7 @@ export async function runCli(
       runtimeHost,
       runtimeController,
       openProjectResults: projectResults,
+      resolveProjectRuntime: async () => (await findRuntimeProfile(await commandProjectRoot()))?.profile,
       write: writeOperational,
     });
     return;
@@ -286,17 +291,18 @@ export async function runCli(
           author: projectPath(loaded.authorSource, effectiveWorkspaceRoot),
           frontend: sourceHeader.using,
           targetCount: loaded.document.targets.length,
-          targets: loaded.document.targets.slice(0, args.limit).map((item) => item.output),
+          targets: loaded.document.targets.map((item) => item.output),
           candidates: loaded.document.candidates.length,
           satisfactions: loaded.document.satisfactions.length,
-          unresolvedHistoricalOutputs: loaded.unresolvedHistoricalOutputs.slice(0, args.limit).map((item) => ({
+          historicalOutputCount: loaded.unresolvedHistoricalOutputs.length,
+          ...(args.presentation.verbose ? { unresolvedHistoricalOutputs: loaded.unresolvedHistoricalOutputs.slice(0, args.limit).map((item) => ({
             candidate: item.id,
             build: item.build,
             output: item.output,
           })),
           ...(loaded.unresolvedHistoricalOutputs.length <= args.limit ? {} : {
             omittedHistoricalOutputs: loaded.unresolvedHistoricalOutputs.length - args.limit,
-          }),
+          }) } : {}),
         } as const;
         writeCliOutput(io, args.presentation, {
           kind: "check-run",
@@ -321,9 +327,10 @@ export async function runCli(
         assets: result.attachments.length,
         modules: modules.length,
         outputCount: outputs.length,
-        outputs: outputs.slice(0, args.limit).map((item) => ({ name: item.name, type: cliTypeName(item.type) })),
-        ...(outputs.length <= args.limit ? {} : { omittedOutputs: outputs.length - args.limit }),
-        ...(args.presentation.verbose ? { details: {
+        ...(args.presentation.verbose ? {
+          outputs: outputs.slice(0, args.limit).map((item) => ({ name: item.name, type: cliTypeName(item.type) })),
+          ...(outputs.length <= args.limit ? {} : { omittedOutputs: outputs.length - args.limit }),
+          details: {
           modules: modules.slice(0, args.limit),
           values: values.slice(0, args.limit).map((item) => ({ name: item.name, type: cliTypeName(item.type) })),
         } } : {}),
@@ -387,6 +394,7 @@ export async function runCli(
         result: {
           repository: buildResults.location,
           ...(args.title === undefined ? {} : { title: args.title }),
+          resourceReferences: loadedRun.resultResourceReferences,
           forwards: result.resultForwards.filter((forward) =>
             catalog.publishedOutputs.some((published) => published.ref.id === forward.output)),
         },
@@ -398,7 +406,7 @@ export async function runCli(
       const evaluated = await evaluatePlanNeeds(result.definition, packageContributions);
       const providers = await describePlanProviders(host, evaluated.state, evaluated);
       assertPlannedRequests(evaluated.state, evaluated, providers);
-      const preflight = await preflightPlan(host, evaluated.state);
+      const preflight = await preflightPlan(host, evaluated.state, providers);
       // Build is an execution boundary, not a provisioning command. The cheap
       // preflight must already be clean; `runtime up` is the explicit place for
       // installing or starting declared programs.
@@ -411,7 +419,8 @@ export async function runCli(
         const detail = error instanceof Error ? error.message : String(error);
         throw new Error(`Runtime Worker could not start; no Build was queued: ${detail}`);
       }
-      runtime = await loadRuntime(await runtimeHost(runtimeProfile));
+      runtime = await loadRuntime(await runtimeHost(runtimeProfile, sourcePackageRoot),
+        [...new Set(providers.flatMap((item) => item.status === "resolved" && item.endpoint !== undefined ? [item.endpoint] : []))]);
       let built = await runtime.build(request);
       const requestCount = result.definition.plan.steps.reduce(
         (total, step) => total + Object.keys(step.needs).length,
@@ -484,7 +493,6 @@ export async function runCli(
         ...(activeView === undefined ? {} : { runtime: activeView }),
         ...(finishedResult === undefined ? {} : { result: finishedResult }),
         verbose: args.presentation.verbose,
-        operationLimit: args.limit,
       });
       const machine = {
         format: "hypit.cli-build@1" as const,
@@ -586,8 +594,8 @@ export async function runCli(
       });
       return;
     }
-    const preflight = planHost === undefined ? undefined : await preflightPlan(planHost, evaluated.state);
     const providers = planHost === undefined ? undefined : await describePlanProviders(planHost, evaluated.state, evaluated);
+    const preflight = planHost === undefined ? undefined : await preflightPlan(planHost, evaluated.state, providers ?? []);
     const needs = describePlanNeeds(evaluated.state, evaluated, providers ?? []);
     const outputNames = Object.fromEntries(result.compilation.author.exports.flatMap((item) =>
       item.ref.kind === "logical-output" ? [[item.ref.id, item.name]] : []));
@@ -596,8 +604,10 @@ export async function runCli(
       const candidate = loaded.run.satisfactionNames[selection.output];
       return output === undefined || candidate === undefined ? [] : [{ output, candidate }];
     });
-    const allUnreached = unreachedGenerations(result.compilation.author.graph, result.state, outputNames)
-      .map((item) => ({ output: item.name, operation: item.producer }));
+    const allUnreached = args.presentation.verbose
+      ? unreachedGenerations(result.compilation.author.graph, result.state, outputNames)
+        .map((item) => ({ output: item.name, operation: item.producer }))
+      : [];
     const targets = loaded.run.document.targets.map((item) => item.output);
     const unsupportedRequestCount = providers?.filter((item) => item.status === "unsupported").length ?? 0;
     const unresolvedRequestCount = providers?.filter((item) => item.status === "unresolved" || item.status === "ambiguous").length ?? 0;
@@ -606,45 +616,31 @@ export async function runCli(
     const requestIssueCount = needs.filter((item) => item.issue !== undefined).length;
     writeCliOutput(io, args.presentation, {
       kind: "plan",
-      machine: {
+      machine: createPlanOutput({
         format: "hypit.cli-plan@1",
         ok: (preflight?.ok ?? true) && unresolvedRequestCount === 0
           && unsupportedRequestCount === 0 && requestIssueCount === 0,
         run: projectPath(loaded.path, effectiveWorkspaceRoot),
         targetCount: targets.length,
-        targets: targets.slice(0, args.limit),
+        targets,
         steps: result.definition.plan.steps.length,
         requestCount: needs.length,
         requestIssueCount,
         ...(providerRequestCount === undefined ? {} : { providerRequestCount }),
         ...(providers === undefined ? {} : { localRequestCount, unresolvedRequestCount, unsupportedRequestCount }),
         choiceCount: allChoices.length,
-        choices: allChoices.slice(0, args.limit),
-        ...(allChoices.length <= args.limit ? {} : { omittedChoices: allChoices.length - args.limit }),
-        ...(allUnreached.length === 0 ? {} : { unreached: allUnreached.slice(0, args.limit) }),
-        ...(allUnreached.length <= args.limit ? {} : { omittedUnreached: allUnreached.length - args.limit }),
-        ...(providers === undefined ? {} : {
-          providers: providers.slice(0, Math.max(args.limit, 50)),
-          ...(providers.length <= Math.max(args.limit, 50)
-            ? {}
-            : { omittedProviders: providers.length - Math.max(args.limit, 50) }),
-        }),
-        needs: needs.slice(0, Math.max(args.limit, 50)),
-        ...(needs.length <= Math.max(args.limit, 50) ? {} : { omittedNeeds: needs.length - Math.max(args.limit, 50) }),
+        choices: allChoices,
+        unreached: allUnreached,
+        ...(providers === undefined ? {} : { providers }),
+        needs,
         ...(preflight === undefined ? {} : { preflight: {
           ok: preflight.ok,
           capabilityCount: preflight.capabilities.length,
-          capabilities: preflight.capabilities.slice(0, args.limit),
-          ...(preflight.capabilities.length <= args.limit
-            ? {}
-            : { omittedCapabilities: preflight.capabilities.length - args.limit }),
+          capabilities: preflight.capabilities,
           diagnosticCount: preflight.diagnostics.length,
-          diagnostics: preflight.diagnostics.slice(0, args.limit),
-          ...(preflight.diagnostics.length <= args.limit
-            ? {}
-            : { omittedDiagnostics: preflight.diagnostics.length - args.limit }),
+          diagnostics: preflight.diagnostics,
         } }),
-      },
+      }, { verbose: args.presentation.verbose, limit: args.limit }),
     });
     if ((preflight !== undefined && !preflight.ok) || unresolvedRequestCount > 0
       || unsupportedRequestCount > 0 || requestIssueCount > 0) io.setExitCode?.(1);

package/packages/cli/src/observation.ts

@@ -5,7 +5,8 @@ import { formatOperationProgress } from "./runtime-view.js";
 
 const FIRST_HEARTBEAT_MS = 30_000;
 const LATER_HEARTBEAT_MS = 60_000;
-const MIN_PROGRESS_INTERVAL_MS = 1_000;
+// Coalesce live counters into readable terminal updates; persistence can advance more often.
+const MIN_PROGRESS_INTERVAL_MS = 5_000;
 
 export type BuildProgressView = {
   readonly build: string;
@@ -22,6 +23,10 @@ function progressPhases(view: CliBuildView): Readonly<Record<string, number>> {
     const phase = operation.progress?.phase ?? "in progress";
     phases.set(phase, (phases.get(phase) ?? 0) + 1);
   }
+  for (const command of view.commands ?? []) {
+    const label = formatOperationProgress(command.progress);
+    phases.set(label, (phases.get(label) ?? 0) + 1);
+  }
   return Object.fromEntries([...phases].sort(([left], [right]) => left.localeCompare(right)));
 }
 
@@ -41,6 +46,7 @@ export function buildProgressView(view: CliBuildView, now = Date.now()): BuildPr
     phases: progressPhases(view),
     elapsedMs: Math.max(0, now - view.createdAt),
     details: [
+      ...(view.commands ?? []).map((item) => `${item.endpoint}: ${formatOperationProgress(item.progress)}`),
       ...(view.stop === undefined ? [] : [view.stop.cause === "execution-failed"
         ? `Build stopping after failure${view.stop.reason === undefined ? "" : `: ${view.stop.reason}`}`
         : `Build cancelling${view.stop.reason === undefined ? "" : `: ${view.stop.reason}`}`]),