@osolmaz/pi-workflows 0.12.0 → 0.12.1

package/src/extension/index.ts

@@ -18,6 +18,7 @@ import { compositionMetadata } from "../workflows/composition.js";
 import { humanDecisionChannelRequest } from "../workflows/decision-presentation.js";
 import { WorkflowEngine } from "../workflows/engine.js";
 import {
+  BuiltinWorkflowRevisionChangedError,
   ClaimLostError,
   errorMessage,
   isClaimLostError,
@@ -41,6 +42,7 @@ import {
 } from "../workflows/store.js";
 import type {
   AcceptedHumanDecision,
+  ResolvedHumanDecision,
   AgentStepContract,
   HumanDecisionRequest,
   HumanDecisionSubmission,
@@ -48,6 +50,7 @@ import type {
   WorkflowDefinitionSnapshot,
   WorkflowRunResult,
   WorkflowRunState,
+  WorkflowSource,
   WorkflowUpdateRecord,
 } from "../workflows/types.js";
 import {
@@ -194,19 +197,14 @@ function humanDecisionRequest(value: unknown): HumanDecisionRequest | null {
     value !== null && typeof value === "object"
       ? (value as { schema?: unknown }).schema
       : undefined;
-  if (
-    schema !== "pi-workflows.human-decision-request.v1" &&
-    schema !== "pi-workflows.human-decision-request.v2"
-  ) {
-    return null;
-  }
+  if (schema !== "pi-workflows.human-decision-request.v1") return null;
   return value as HumanDecisionRequest;
 }
 
 type PreparedLaunchOptions = {
   presentation?: boolean;
   parentRunId?: string;
-  humanDecision?: AcceptedHumanDecision;
+  humanDecision?: ResolvedHumanDecision;
 };
 
 type StartRunOptions = {
@@ -218,8 +216,8 @@ type StartRunOptions = {
   signal?: AbortSignal;
   /** Continue a checkpointed run: input becomes the legacy answer payload. */
   parentRunId?: string;
-  /** Accepted verified-human answer for a protected decision continuation. */
-  humanDecision?: AcceptedHumanDecision;
+  /** Durable human or timeout response for a protected decision continuation. */
+  humanDecision?: ResolvedHumanDecision;
   /** Resume a parked run at its stopped node instead of starting fresh. */
   resume?: boolean;
   /** An existing queue claim token, when the caller already claimed the run. */
@@ -237,6 +235,29 @@ function launchSourceIdentity(workflow: WorkflowDefinition, root: unknown): unkn
   };
 }
 
+function continuationSourceChangedError(
+  runId: string,
+  previous: WorkflowSource,
+  current: WorkflowSource,
+): Error {
+  if (
+    previous.kind === "builtin" &&
+    current.kind === "builtin" &&
+    previous.id === current.id &&
+    previous.revision !== current.revision
+  ) {
+    return new BuiltinWorkflowRevisionChangedError({
+      runId,
+      workflowId: current.id,
+      previousRevision: previous.revision,
+      currentRevision: current.revision,
+    });
+  }
+  return new Error(
+    `Workflow source changed since run ${runId} started; revert the edit to answer its checkpoint`,
+  );
+}
+
 function preparedLaunchOptions(options: StartRunOptions): PreparedLaunchOptions {
   return {
     ...(options.presentation !== undefined ? { presentation: options.presentation } : {}),
@@ -1210,8 +1231,10 @@ export default function piWorkflows(pi: ExtensionAPI) {
         parent.state.workflowSource !== undefined &&
         !isDeepStrictEqual(parent.state.workflowSource, workflowSource)
       ) {
-        throw new Error(
-          `Workflow source changed since run ${options.parentRunId} started; revert the edit to answer its checkpoint`,
+        throw continuationSourceChangedError(
+          options.parentRunId,
+          parent.state.workflowSource,
+          workflowSource,
         );
       }
     }
@@ -2061,7 +2084,7 @@ export default function piWorkflows(pi: ExtensionAPI) {
       };
       const store = new HumanDecisionStore(new WorkflowRunStore().outputRoot);
       const acceptance = await store.accept(request, submission);
-      if (acceptance.status === "conflict") {
+      if (acceptance.status === "conflict" || acceptance.decision.provenance !== "human") {
         throw new Error("That human decision was already answered differently.");
       }
       accepted = acceptance.decision;
@@ -2093,6 +2116,7 @@ export default function piWorkflows(pi: ExtensionAPI) {
         schema: "pi-workflows.human-decision-continuation.v1",
         decisionId: request.decisionId,
         requestDigest: request.requestDigest,
+        provenance: accepted.provenance,
         parentRunId: waiting.parentRunId,
         runId: continuationRunId,
         createdAt: accepted.acceptedAt,
@@ -2218,60 +2242,72 @@ export default function piWorkflows(pi: ExtensionAPI) {
         queueRecord !== undefined &&
         (queueRecord.originSessionId === null ||
           queueRecord.originSessionId === ctx.sessionManager.getSessionId());
-      const accepted = await store.readAccepted(request.decisionId);
-      if (accepted === null) {
+      let resolved = await store.readResolved(request.decisionId);
+      if (resolved === null) {
         let cancellation = await store.readCancellation(request.decisionId);
-        if (
-          cancellation === null &&
-          request.expiresAt !== undefined &&
-          Date.parse(request.expiresAt) <= Date.now()
-        ) {
-          await store.cancel(request, "expired");
-          cancellation = await store.readCancellation(request.decisionId);
+        const expired =
+          request.expiresAt !== undefined && Date.parse(request.expiresAt) <= Date.now();
+        if (cancellation === null && expired) {
+          if (request.defaultResponse === undefined) {
+            await store.cancel(request, "expired");
+            cancellation = await store.readCancellation(request.decisionId);
+          } else {
+            try {
+              resolved = (await store.resolveTimeout(request)).decision;
+            } catch {
+              cancellation = await store.readCancellation(request.decisionId);
+              resolved = await store.readResolved(request.decisionId);
+            }
+          }
         }
         if (cancellation !== null) {
           await settleHumanDecisionChannels(cancellation);
           continue;
         }
-        if (!deliverPending || !ownedBySession) continue;
-        const channels = audienceChannels(decisionChannelConfig, request.audience);
-        for (const channelId of channels) {
-          const channel = telegramDecisionChannels.get(channelId);
-          if (channel !== undefined) await channel.deliver(humanDecisionChannelRequest(request));
-        }
-        if (ctx.mode === "tui" && channels.includes("pi") && lastWaitingRunId === null) {
-          lastWaitingRunId = request.runId;
-          queueMicrotask(() => void promptHumanDecision(ctx, request));
+        if (resolved === null) {
+          if (!deliverPending || !ownedBySession) continue;
+          const channels = audienceChannels(decisionChannelConfig, request.audience);
+          for (const channelId of channels) {
+            const channel = telegramDecisionChannels.get(channelId);
+            if (channel !== undefined) await channel.deliver(humanDecisionChannelRequest(request));
+          }
+          if (ctx.mode === "tui" && channels.includes("pi") && lastWaitingRunId === null) {
+            lastWaitingRunId = request.runId;
+            queueMicrotask(() => void promptHumanDecision(ctx, request));
+          }
+          continue;
         }
-        continue;
       }
 
       if (!ownedBySession) continue;
+      const currentParent = await readRunBundle(runStore.runDirFor(request.runId));
+      if (currentParent === null || currentParent.state.status !== "waiting") continue;
       const runId = `continuation-${request.decisionId.slice("decision-".length)}`;
       const continuation = (await store.readContinuation(request.decisionId)) ?? {
         schema: "pi-workflows.human-decision-continuation.v1" as const,
         decisionId: request.decisionId,
         requestDigest: request.requestDigest,
+        provenance: resolved.provenance,
         parentRunId: request.runId,
         runId,
-        createdAt: accepted.acceptedAt,
+        createdAt: resolved.acceptedAt,
       };
       await store.recordContinuation(request.decisionId, continuation);
       const existing = await readRunBundle(runStore.runDirFor(continuation.runId));
       if (existing === null && activeRun === null) {
-        if (parent.state.workflowSource === undefined) continue;
+        if (currentParent.state.workflowSource === undefined) continue;
         const workflowRef =
-          parent.state.workflowSource.kind === "builtin"
-            ? `builtin:${parent.state.workflowSource.id}`
-            : parent.state.workflowSource.path;
-        await startRun(ctx, workflowRef, parent.state.input, {
+          currentParent.state.workflowSource.kind === "builtin"
+            ? `builtin:${currentParent.state.workflowSource.id}`
+            : currentParent.state.workflowSource.path;
+        await startRun(ctx, workflowRef, currentParent.state.input, {
           parentRunId: request.runId,
-          humanDecision: accepted,
+          humanDecision: resolved,
           runId: continuation.runId,
           quiet: true,
         });
       }
-      await settleHumanDecisionChannels(accepted);
+      await settleHumanDecisionChannels(resolved);
       if (activeRun !== null) break;
     }
   };
@@ -2352,8 +2388,10 @@ export default function piWorkflows(pi: ExtensionAPI) {
         parent.state.workflowSource !== undefined &&
         !isDeepStrictEqual(parent.state.workflowSource, workflowSource)
       ) {
-        throw new Error(
-          `Workflow source changed since run ${options.parentRunId} started; revert the edit to answer its checkpoint`,
+        throw continuationSourceChangedError(
+          options.parentRunId,
+          parent.state.workflowSource,
+          workflowSource,
         );
       }
     }

package/src/extension/session-events.ts

@@ -9,7 +9,7 @@ export type PublicAssistantMessageEvent =
   | { type: "toolcall_start"; contentIndex: number; partial: unknown }
   | { type: "toolcall_delta"; contentIndex: number; delta: string; partial: unknown }
   | { type: "toolcall_end"; contentIndex: number; toolCall: unknown; partial: unknown }
-  | { type: "done"; reason: "stop" | "length" | "toolUse"; message: unknown }
+  | { type: "done"; reason: "stop" | "length" | "toolUse" | "deferred"; message: unknown }
   | { type: "error"; reason: "aborted" | "error"; error: unknown };
 
 export type TurnStartEventLike = { turnIndex: number };
@@ -44,7 +44,7 @@ export type NormalizedAssistantEvent =
   | { type: "toolcall_start"; contentIndex: number }
   | { type: "toolcall_delta"; contentIndex: number; delta: string }
   | { type: "toolcall_end"; contentIndex: number; toolCall: unknown }
-  | { type: "done"; reason: "stop" | "length" | "toolUse" }
+  | { type: "done"; reason: "stop" | "length" | "toolUse" | "deferred" }
   | { type: "error"; reason: "aborted" | "error" };
 
 /** Remove cumulative snapshots while preserving every semantic stream event. */

package/src/extension/widget.ts

@@ -162,9 +162,11 @@ function progressLines(
       : progressTracksFromRecords(updateHistory, now).map((track) => track.estimate);
   const projected = mergeProgressEstimates(latestProgressEstimates(state, now), measured ?? []);
   const estimates = mergeProgressEstimates(projected, monitorEstimates(state) ?? []);
-  const lines = prioritizeProgressEstimates(estimates).map((estimate) =>
-    formatProgressLine(estimate, now),
-  );
+  const lines = prioritizeWidgetProgress(prioritizeProgressEstimates(estimates)).map((estimate) => {
+    const indentation =
+      estimate.key.startsWith("agents/") && estimate.key.split("/").length > 2 ? "  " : "";
+    return `${indentation}${formatProgressLine(estimate, now)}`;
+  });
   const schedule = (state.updates ?? []).find(
     (record) => record.type === "monitor.schedule" && record.key === "next-check",
   );
@@ -180,6 +182,24 @@ function progressLines(
   return lines;
 }
 
+function prioritizeWidgetProgress(estimates: ProgressEstimate[]): ProgressEstimate[] {
+  const weight = (estimate: ProgressEstimate) => {
+    if (!estimate.key.startsWith("agents/")) return 0;
+    const child = estimate.key.split("/").length > 2;
+    if (!child) return -4;
+    if (estimate.data.status === "failed" || estimate.data.status === "blocked") return -3;
+    if (
+      estimate.data.status === "running" ||
+      estimate.data.status === "pending" ||
+      estimate.data.status === "waiting"
+    ) {
+      return -2;
+    }
+    return 2;
+  };
+  return [...estimates].sort((left, right) => weight(left) - weight(right));
+}
+
 function monitorEstimates(state: WorkflowRunState): ProgressEstimate[] | undefined {
   const output = state.outputs.estimate;
   if (output === null || typeof output !== "object" || Array.isArray(output)) return undefined;
@@ -309,8 +329,7 @@ function nodeRuntimeSegments(
             })
           : undefined;
       const requestAudience =
-        (request?.schema === "pi-workflows.human-decision-request.v1" ||
-          request?.schema === "pi-workflows.human-decision-request.v2") &&
+        request?.schema === "pi-workflows.human-decision-request.v1" &&
         typeof request.audience === "string"
           ? request.audience
           : human.audience;

package/src/render/graph-render.ts

@@ -313,8 +313,7 @@ function renderCellText(
       ? (state.finalOutput as { schema?: unknown }).schema
       : undefined;
   const waitingRequest =
-    waitingSchema === "pi-workflows.human-decision-request.v1" ||
-    waitingSchema === "pi-workflows.human-decision-request.v2"
+    waitingSchema === "pi-workflows.human-decision-request.v1"
       ? (state.finalOutput as {
           audience?: unknown;
           presentationDigest?: unknown;

package/src/viewer/render.ts

@@ -147,13 +147,13 @@ function nodeStatusLine(bundle: LoadedRunBundle, nodeId: string, width: number,
     suffix = ansi.yellow(
       human === undefined
         ? " waiting"
-        : ` waiting for human · ${sanitizeText(requestAudience ?? "operator")}${request?.schema === "pi-workflows.human-decision-request.v2" ? ` · ${sanitizeText(request.presentation.summary)}` : ""} · ${Object.values(
+        : ` waiting for human · ${sanitizeText(requestAudience ?? "operator")}${request === null ? "" : ` · ${sanitizeText(request.presentation.summary)}`} · ${Object.values(
             human.choices,
           )
             .map((choice) => sanitizeText(choice.label))
             .join(
               " / ",
-            )}${request?.schema === "pi-workflows.human-decision-request.v2" ? ` · ${request.presentationDigest.slice(7, 19)}` : ""}`,
+            )}${request === null ? "" : ` · ${request.presentationDigest.slice(7, 19)}`}`,
     );
   } else if (result) {
     glyph = result.outcome === "ok" ? ansi.green("✓") : ansi.red("✗");
@@ -210,8 +210,7 @@ function inspectorLines(step: WorkflowStepRecord, width: number): string[] {
 function humanDecisionRequest(value: unknown): HumanDecisionRequest | null {
   if (value === null || typeof value !== "object") return null;
   const schema = (value as { schema?: unknown }).schema;
-  return schema === "pi-workflows.human-decision-request.v1" ||
-    schema === "pi-workflows.human-decision-request.v2"
+  return schema === "pi-workflows.human-decision-request.v1"
     ? (value as HumanDecisionRequest)
     : null;
 }
@@ -271,12 +270,14 @@ export function renderRunDetailLines(
     lines.push("");
     lines.push(ansi.bold("progress"));
     for (const track of progress) {
-      lines.push(fitWidth(formatProgressLine(track.estimate, now), size.width));
+      const depth = track.key.startsWith("agents/") ? track.key.split("/").length - 2 : 0;
+      const indentation = "  ".repeat(Math.max(0, depth));
+      lines.push(fitWidth(`${indentation}${formatProgressLine(track.estimate, now)}`, size.width));
       const latest = track.samples.at(-1);
       lines.push(
         fitWidth(
           ansi.dim(
-            `  ${track.estimate.sampleCount} samples · ${track.estimate.confidence ?? "no"} confidence · updated ${latest?.at ?? "unknown"}`,
+            `${indentation}  ${track.estimate.sampleCount} samples · ${track.estimate.confidence ?? "no"} confidence · updated ${latest?.at ?? "unknown"}`,
           ),
           size.width,
         ),

package/src/workflows/catalog.ts

@@ -1,5 +1,5 @@
 import { isWorkflowDefinition } from "./definition.js";
-import { WorkflowSourceChangedError } from "./errors.js";
+import { BuiltinWorkflowRevisionChangedError } from "./errors.js";
 import type { WorkflowDefinition, WorkflowSource } from "./types.js";
 
 const BUILTIN_ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
@@ -102,7 +102,12 @@ export class BuiltinWorkflowCatalog {
       throw new Error(`Unknown built-in workflow: ${source.id}`);
     }
     if (entry.revision !== source.revision) {
-      throw new WorkflowSourceChangedError(runId);
+      throw new BuiltinWorkflowRevisionChangedError({
+        runId,
+        workflowId: entry.id,
+        previousRevision: source.revision,
+        currentRevision: entry.revision,
+      });
     }
     return entry.definition;
   }

package/src/workflows/composition.ts

@@ -480,6 +480,7 @@ function wrapNode(
     case "checkpoint": {
       const human = node.humanDecision;
       const audience = human?.audience;
+      const onTimeout = human?.onTimeout;
       return {
         ...common,
         nodeType: "checkpoint",
@@ -496,6 +497,14 @@ function wrapNode(
                     : audience!,
                 choices: human.choices,
                 request: (context: WorkflowNodeContext) => human.request(project(context)),
+                ...(onTimeout !== undefined
+                  ? {
+                      onTimeout:
+                        typeof onTimeout === "function"
+                          ? (context: WorkflowNodeContext) => onTimeout(project(context))
+                          : onTimeout,
+                    }
+                  : {}),
               },
             }
           : {}),

package/src/workflows/decision-presentation.ts

@@ -56,7 +56,18 @@ export function decisionPresentationDigest(presentation: DecisionPresentation):
 export function validateHumanDecisionRequestIntegrity(
   request: HumanDecisionRequest,
 ): HumanDecisionRequest {
-  if (request.schema === "pi-workflows.human-decision-request.v1") return request;
+  if (
+    request.schema !== "pi-workflows.human-decision-request.v1" ||
+    !Object.hasOwn(request, "subject") ||
+    !Object.hasOwn(request, "presentation") ||
+    !Object.hasOwn(request, "subjectDigest") ||
+    !Object.hasOwn(request, "presentationDigest") ||
+    !Object.hasOwn(request, "revision")
+  ) {
+    throw new Error(
+      "Human decision state uses an incompatible alpha contract; reset the affected workflow run and decision state.",
+    );
+  }
   const presentation = normalizeDecisionPresentation(request.presentation);
   const subjectDigest = digestCanonical(request.subject);
   const presentationDigest = digestCanonical(presentation);
@@ -70,6 +81,7 @@ export function validateHumanDecisionRequestIntegrity(
     title: request.title,
     choices: request.choices,
     ...(request.expiresAt !== undefined ? { expiresAt: request.expiresAt } : {}),
+    ...(request.defaultResponse !== undefined ? { defaultResponse: request.defaultResponse } : {}),
     subject: request.subject,
     presentation,
     revision: request.revision,
@@ -90,10 +102,7 @@ export function humanDecisionChannelRequest(
   request: HumanDecisionRequest,
 ): HumanDecisionChannelRequest {
   validateHumanDecisionRequestIntegrity(request);
-  const presentation =
-    request.schema === "pi-workflows.human-decision-request.v2"
-      ? normalizeDecisionPresentation(request.presentation)
-      : legacyDecisionPresentation(request.body);
+  const presentation = normalizeDecisionPresentation(request.presentation);
   const presentationDigest = decisionPresentationDigest(presentation);
   return {
     schema: "pi-workflows.human-decision-channel-request.v1",
@@ -108,25 +117,26 @@ export function humanDecisionChannelRequest(
     title: request.title,
     presentation,
     presentationDigest,
-    revision: request.schema === "pi-workflows.human-decision-request.v2" ? request.revision : 1,
+    revision: request.revision,
     choices: request.choices,
     createdAt: request.createdAt,
     ...(request.expiresAt !== undefined ? { expiresAt: request.expiresAt } : {}),
+    ...(request.defaultResponse !== undefined ? { defaultResponse: request.defaultResponse } : {}),
   };
 }
 
-export function legacyDecisionPresentation(body: unknown): DecisionPresentation {
+export function valueDecisionPresentation(value: unknown): DecisionPresentation {
   const blocks: DecisionPresentationBlock[] = [];
-  if (typeof body === "string") {
-    appendLegacyText(blocks, body, "Decision details");
+  if (typeof value === "string") {
+    appendValueText(blocks, value, "Decision details");
   } else {
-    appendLegacyValue(blocks, body, undefined);
+    appendValue(blocks, value, undefined);
   }
   const summary =
-    typeof body === "string"
+    typeof value === "string"
       ? "Review the decision message below."
       : "Review the decision details below.";
-  return normalizeDecisionPresentation(boundLegacyPresentation(summary, blocks, body));
+  return normalizeDecisionPresentation(boundValuePresentation(summary, blocks, value));
 }
 
 export function decisionDocumentSegments(
@@ -150,6 +160,13 @@ export function decisionDocumentSegments(
       segments.push({ kind: block.kind, text: block.text });
     }
   }
+  if (request.expiresAt !== undefined && request.defaultResponse !== undefined) {
+    const selected = request.choices[request.defaultResponse.choice];
+    segments.push({
+      kind: "paragraph",
+      text: `If no answer is accepted by ${request.expiresAt}, this decision continues automatically with: ${selected?.label ?? request.defaultResponse.choice}.`,
+    });
+  }
   const choices = Object.values(request.choices).map((choice) =>
     choice.input === undefined
       ? `• ${choice.label}`
@@ -251,10 +268,10 @@ function normalizeString(value: unknown, label: string): string {
   return text;
 }
 
-function boundLegacyPresentation(
+function boundValuePresentation(
   summary: string,
   blocks: DecisionPresentationBlock[],
-  body: unknown,
+  value: unknown,
 ): DecisionPresentation {
   const candidate: DecisionPresentation = {
     schema: "pi-workflows.decision-presentation.v1",
@@ -263,13 +280,13 @@ function boundLegacyPresentation(
   };
   if (
     blocks.length <= MAX_PRESENTATION_BLOCKS &&
-    blocks.every(legacyBlockFitsSchema) &&
+    blocks.every(valueBlockFitsSchema) &&
     presentationCodeUnits(candidate) <= MAX_PRESENTATION_CODE_UNITS
   ) {
     return candidate;
   }
-  const originalCodeUnits = canonicalJson(body).length;
-  const omission = `Some legacy decision content is not shown because it exceeds the readable presentation limit. Inspect the durable v1 request before answering. Body digest: ${digestCanonical(body)}. Original body: ${originalCodeUnits} UTF-16 code units. Generated blocks: ${blocks.length}.`;
+  const originalCodeUnits = canonicalJson(value).length;
+  const omission = `Some decision content is not shown because it exceeds the readable presentation limit. Inspect the canonical source value before answering. Value digest: ${digestCanonical(value)}. Original value: ${originalCodeUnits} UTF-16 code units. Generated blocks: ${blocks.length}.`;
   const budget = MAX_PRESENTATION_CODE_UNITS - summary.length - omission.length;
   const kept: DecisionPresentationBlock[] = [];
   let used = 0;
@@ -278,7 +295,7 @@ function boundLegacyPresentation(
     const units = presentationBlockCodeUnits(block);
     if (
       kept.length >= MAX_PRESENTATION_BLOCKS ||
-      !legacyBlockFitsSchema(block) ||
+      !valueBlockFitsSchema(block) ||
       used + units > budget
     ) {
       omitted = true;
@@ -298,7 +315,7 @@ function boundLegacyPresentation(
   };
 }
 
-function legacyBlockFitsSchema(block: DecisionPresentationBlock): boolean {
+function valueBlockFitsSchema(block: DecisionPresentationBlock): boolean {
   if (block.kind === "paragraph" || block.kind === "preformatted") {
     return block.text.length <= MAX_PRESENTATION_STRING_CODE_UNITS;
   }
@@ -332,47 +349,43 @@ function presentationCodeUnits(presentation: DecisionPresentation): number {
   return total;
 }
 
-function appendLegacyValue(
+function appendValue(
   blocks: DecisionPresentationBlock[],
   value: unknown,
   label: string | undefined,
 ): void {
   if (isScalar(value)) {
-    const scalar = legacyScalar(value);
+    const scalar = valueScalar(value);
     if (label === undefined || scalar.length > MAX_PRESENTATION_STRING_CODE_UNITS) {
-      appendLegacyText(
-        blocks,
-        scalar,
-        label === undefined ? "Decision details" : legacyLabel(label),
-      );
+      appendValueText(blocks, scalar, label === undefined ? "Decision details" : valueLabel(label));
     } else {
-      blocks.push({ kind: "fields", items: [{ label: legacyLabel(label), value: scalar }] });
+      blocks.push({ kind: "fields", items: [{ label: valueLabel(label), value: scalar }] });
     }
     return;
   }
   if (Array.isArray(value)) {
-    if (label !== undefined) blocks.push({ kind: "section", title: legacyLabel(label) });
+    if (label !== undefined) blocks.push({ kind: "section", title: valueLabel(label) });
     if (value.length === 0) {
       blocks.push({ kind: "paragraph", text: "None" });
       return;
     }
     if (
       value.every(isScalar) &&
-      value.every((item) => legacyScalar(item).length <= MAX_PRESENTATION_STRING_CODE_UNITS)
+      value.every((item) => valueScalar(item).length <= MAX_PRESENTATION_STRING_CODE_UNITS)
     ) {
-      const items = value.map(legacyScalar);
+      const items = value.map(valueScalar);
       for (let index = 0; index < items.length; index += MAX_PRESENTATION_ITEMS) {
         blocks.push({ kind: "bullets", items: items.slice(index, index + MAX_PRESENTATION_ITEMS) });
       }
       return;
     }
-    value.forEach((item, index) => appendLegacyValue(blocks, item, `Item ${index + 1}`));
+    value.forEach((item, index) => appendValue(blocks, item, `Item ${index + 1}`));
     return;
   }
   const entries = Object.entries(value as Record<string, unknown>).sort(([left], [right]) =>
     compareKeys(left, right),
   );
-  if (label !== undefined) blocks.push({ kind: "section", title: legacyLabel(label) });
+  if (label !== undefined) blocks.push({ kind: "section", title: valueLabel(label) });
   if (entries.length === 0) {
     blocks.push({ kind: "paragraph", text: "None" });
     return;
@@ -380,34 +393,34 @@ function appendLegacyValue(
   const fields = entries
     .filter(
       ([, child]) =>
-        isScalar(child) && legacyScalar(child).length <= MAX_PRESENTATION_STRING_CODE_UNITS,
+        isScalar(child) && valueScalar(child).length <= MAX_PRESENTATION_STRING_CODE_UNITS,
     )
-    .map(([key, child]) => ({ label: legacyLabel(key), value: legacyScalar(child) }));
+    .map(([key, child]) => ({ label: valueLabel(key), value: valueScalar(child) }));
   for (let index = 0; index < fields.length; index += MAX_PRESENTATION_ITEMS) {
     blocks.push({ kind: "fields", items: fields.slice(index, index + MAX_PRESENTATION_ITEMS) });
   }
   for (const [key, child] of entries.filter(
     ([, child]) =>
-      !isScalar(child) || legacyScalar(child).length > MAX_PRESENTATION_STRING_CODE_UNITS,
+      !isScalar(child) || valueScalar(child).length > MAX_PRESENTATION_STRING_CODE_UNITS,
   )) {
-    appendLegacyValue(blocks, child, key);
+    appendValue(blocks, child, key);
   }
 }
 
-function appendLegacyText(
+function appendValueText(
   blocks: DecisionPresentationBlock[],
   value: string,
   section: string,
 ): void {
-  const text = sanitizeLegacyText(value);
+  const text = sanitizeValueText(value);
   blocks.push({ kind: "section", title: section });
   for (const part of splitByCodeUnits(text, MAX_PRESENTATION_STRING_CODE_UNITS)) {
     blocks.push({ kind: "paragraph", text: part.trim().length === 0 ? "None" : part });
   }
 }
 
-function legacyLabel(value: string): string {
-  const sanitized = sanitizeLegacyText(value)
+function valueLabel(value: string): string {
+  const sanitized = sanitizeValueText(value)
     .replaceAll(/[_-]+/gu, " ")
     .replaceAll(/([a-z0-9])([A-Z])/gu, "$1 $2")
     .replaceAll(/\s+/gu, " ")
@@ -416,13 +429,13 @@ function legacyLabel(value: string): string {
   return `${sanitized[0]!.toUpperCase()}${sanitized.slice(1)}`;
 }
 
-function legacyScalar(value: unknown): string {
+function valueScalar(value: unknown): string {
   if (value === null) return "None";
   if (typeof value === "boolean") return value ? "Yes" : "No";
-  return sanitizeLegacyText(String(value));
+  return sanitizeValueText(String(value));
 }
 
-function sanitizeLegacyText(value: string): string {
+function sanitizeValueText(value: string): string {
   return value
     .replaceAll("\r\n", "\n")
     .replaceAll("\r", "\n")