Adapt simulation code to the canonical blueprint types

After rebasing onto the schema-driven data model, two points of drift from
the old hand-written types needed fixing:

- BlueprintTask was renamed to Task (the canonical, schema-generated name),
  in blueprint-simulate.ts and blueprint-load.ts.
- Blueprint.tasks is now optional (tasks?: Task[]), because the JSON schema
  does not mark tasks as required. deriveSimulationBlueprint /
  stripSimulationDerivation / normalizeBlueprint / fetchBlueprint always
  populate tasks, so their return types now say so (Blueprint & { tasks });
  the derive path also guards `bp.tasks ?? []` on its input. The
  blueprint-simulate test fixture uses `satisfies Blueprint` to keep its
  concrete tasks type.

Also harmonized blueprint-flow.ts to use the SYSTEM_*_TASK_TYPE constants
(ADR-0003) instead of repeating 'system.start' / 'system.end' literals.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: chenkasirer

src/utils/__tests__/blueprint-simulate.test.ts

@@ -15,7 +15,7 @@ import {
   stripSimulationDerivation,
 } from '../blueprint-simulate';
 
-const BLUEPRINT: Blueprint = {
+const BLUEPRINT = {
   version: '1.0',
   id: 'my-blueprint',
   name: 'My Blueprint',
@@ -35,7 +35,7 @@ const BLUEPRINT: Blueprint = {
     { id: 'sleep', type: 'system.sleep', depends_on: [{ id: 'plan' }] },
     { id: 'end', type: 'system.end', depends_on: [{ id: 'sleep' }] },
   ],
-};
+} satisfies Blueprint;
 
 describe('deriveSimulationBlueprintId', () => {
   it('appends the __sim suffix', () => {
@@ -315,7 +315,7 @@ describe('stripSimulationDerivation', () => {
   });
 
   it('survives repeated laps of Simulate and Edit', () => {
-    let bp = BLUEPRINT;
+    let bp: Blueprint = BLUEPRINT;
     for (let lap = 0; lap < 3; lap++) {
       bp = stripSimulationDerivation(deriveSimulationBlueprint(bp));
     }

src/utils/blueprint-flow.ts

@@ -7,6 +7,10 @@ import type {
   BlueprintMeta,
   Task,
 } from '../types/blueprint-schema';
+import {
+  SYSTEM_START_TASK_TYPE,
+  SYSTEM_END_TASK_TYPE,
+} from '../types/blueprint-schema';
 
 /**
  * Serialization between the canonical Blueprint data model and the React Flow
@@ -41,7 +45,7 @@ export function blueprintToFlow(bp: Blueprint): { nodes: Node[]; edges: Edge[] }
     } satisfies AuthorNodeData,
     sourcePosition: Position.Right,
     targetPosition: Position.Left,
-    deletable: task.type !== 'system.start' && task.type !== 'system.end',
+    deletable: task.type !== SYSTEM_START_TASK_TYPE && task.type !== SYSTEM_END_TASK_TYPE,
   }));
 
   const edges: Edge[] = [];

src/utils/blueprint-load.ts

@@ -1,6 +1,6 @@
 import type {
   Blueprint,
-  BlueprintTask,
+  Task,
   Dependency,
   TaskInput,
   TaskOutput,
@@ -76,8 +76,8 @@ function toDependency(raw: Record<string, unknown>): Dependency {
   return withoutNulls({ id: String(raw.id ?? ''), type: raw.type }) as Dependency;
 }
 
-function toTask(raw: Record<string, unknown>): BlueprintTask {
-  const task: BlueprintTask = { id: String(raw.id ?? ''), type: String(raw.type ?? '') };
+function toTask(raw: Record<string, unknown>): Task {
+  const task: Task = { id: String(raw.id ?? ''), type: String(raw.type ?? '') };
 
   const description = asString(raw.description);
   const condition = asString(raw.condition);
@@ -100,14 +100,14 @@ function toTask(raw: Record<string, unknown>): BlueprintTask {
 }
 
 /** Normalises a stored blueprint — COMPAS-wrapped or already flat — into an authoring `Blueprint`. */
-export function normalizeBlueprint(raw: unknown): Blueprint {
+export function normalizeBlueprint(raw: unknown): Blueprint & { tasks: Task[] } {
   const data = unwrap(raw);
   const id = asString(data.id);
   if (!id) {
     throw new Error('Blueprint is missing an id');
   }
 
-  const blueprint: Blueprint = {
+  const blueprint: Blueprint & { tasks: Task[] } = {
     version: asString(data.version) ?? '1.0',
     id,
     name: asString(data.name) ?? id,
@@ -121,7 +121,7 @@ export function normalizeBlueprint(raw: unknown): Blueprint {
 }
 
 /** Fetches a stored blueprint by id, ready to open in the authoring tool. */
-export async function fetchBlueprint(apiBaseUrl: string, id: string): Promise<Blueprint> {
+export async function fetchBlueprint(apiBaseUrl: string, id: string): Promise<Blueprint & { tasks: Task[] }> {
   const response = await fetch(`${apiBaseUrl}/blueprints/${encodeURIComponent(id)}`);
   if (!response.ok) {
     throw new Error(

src/utils/blueprint-simulate.ts

@@ -1,4 +1,4 @@
-import type { Blueprint, BlueprintTask, TaskOutput, TaskParam } from '../types/blueprint-schema';
+import type { Blueprint, Task, TaskOutput, TaskParam } from '../types/blueprint-schema';
 import {
   isSystemTaskType,
   SYSTEM_COMPOSITE_TASK_TYPE,
@@ -31,14 +31,14 @@ export const SIMULATION_OPT_OUT_PARAM_NAME = '__sim_use_real_agent__';
 
 /** True if `params` carries the opt-out flag. Operates on a bare param list so both the
  * derive-time rewrite and the authoring-tool panel (which only has `AuthorNodeData.params`,
- * not a full `BlueprintTask`) can share one check. */
+ * not a full `Task`) can share one check. */
 export function isOptedOutParams(params: TaskParam[] | undefined): boolean {
   return (params ?? []).some(
     (p) => p.name === SIMULATION_OPT_OUT_PARAM_NAME && p.value === true,
   );
 }
 
-export function isOptedOutOfSimulation(task: BlueprintTask): boolean {
+export function isOptedOutOfSimulation(task: Task): boolean {
   return isOptedOutParams(task.params);
 }
 
@@ -90,7 +90,7 @@ export class CompositeTaskNotSupportedError extends Error {
   }
 }
 
-function rewriteTaskType(task: BlueprintTask): string {
+function rewriteTaskType(task: Task): string {
   const { type } = task;
   if (isSystemTaskType(type)) {
     return type;
@@ -121,15 +121,16 @@ function simulatedOutputParams(outputs: TaskOutput[] | undefined): TaskParam[] {
  * Throws CompositeTaskNotSupportedError, naming the offending tasks, if the
  * blueprint contains any `system.composite` task.
  */
-export function deriveSimulationBlueprint(bp: Blueprint): Blueprint {
-  const compositeTaskIds = bp.tasks
+export function deriveSimulationBlueprint(bp: Blueprint): Blueprint & { tasks: Task[] } {
+  const sourceTasks = bp.tasks ?? [];
+  const compositeTaskIds = sourceTasks
     .filter((task) => task.type === SYSTEM_COMPOSITE_TASK_TYPE)
     .map((task) => task.id);
   if (compositeTaskIds.length) {
     throw new CompositeTaskNotSupportedError(compositeTaskIds);
   }
 
-  const tasks: BlueprintTask[] = bp.tasks.map((task) => {
+  const tasks: Task[] = sourceTasks.map((task) => {
     const type = rewriteTaskType(task);
     // Only tasks actually rewritten to simulation.* need their outputs carried as params —
     // this also keeps the rewrite idempotent (re-deriving an already-derived task, whose type
@@ -166,14 +167,14 @@ export function deriveSimulationBlueprint(bp: Blueprint): Blueprint {
  * `__sim_out__` params from. Safe on a blueprint that was never derived — nothing matches, and
  * it passes through unchanged.
  */
-export function stripSimulationDerivation(bp: Blueprint): Blueprint {
-  const tasks: BlueprintTask[] = bp.tasks.map((task) => {
+export function stripSimulationDerivation(bp: Blueprint): Blueprint & { tasks: Task[] } {
+  const tasks: Task[] = (bp.tasks ?? []).map((task) => {
     const type = stripSimulationTypePrefix(task.type);
     const params = (task.params ?? []).filter(
       (param) => !param.name.startsWith(SIMULATED_OUTPUT_PARAM_PREFIX),
     );
 
-    const stripped: BlueprintTask = { ...task, type };
+    const stripped: Task = { ...task, type };
     if (params.length) {
       stripped.params = params;
     } else {