@toolproof-core/lib 1.0.48 → 1.0.50

package/src/utils/mutableStrategyOverlay.ts

@@ -21,15 +21,13 @@ export type MutableBranchStepKey = `BRANCH_STEP-${string}`;
 export type MutableWhileStepKey = `WHILE_STEP-${string}`;
 export type MutableForStepKey = `FOR_STEP-${string}`;
 export type MutableLoopStepKey = MutableWhileStepKey | MutableForStepKey;
-export type MutableMacroStepKey = MutableBranchStepKey | MutableLoopStepKey;
-export type MutableStepKey = MutableToolStepKey | MutableMacroStepKey;
+export type MutableStepKey = MutableToolStepKey | MutableBranchStepKey | MutableLoopStepKey;
 
 export type MutableMaterializedResource = MaterializedResource;
 
 export type MutableToolStepRoleAddress =
     Omit<ToolStepRoleAddress, 'toolStepPath'> & {
         stepKey: MutableToolStepKey;
-        toolStepKey: MutableToolStepKey;
     };
 
 export type MutableInternalInputPotential =
@@ -50,7 +48,6 @@ export type MutableStrategyState = Partial<Record<MutableToolStepKey, MutableStr
 
 export type MutableToolStep = ToolStep & {
     stepKey: MutableToolStepKey;
-    toolStepKey: MutableToolStepKey;
 };
 
 export type MutableCase = Omit<Case, 'when' | 'what'> & {
@@ -60,19 +57,16 @@ export type MutableCase = Omit<Case, 'when' | 'what'> & {
 
 export type MutableBranchStep = Omit<BranchStep, 'cases'> & {
     stepKey: MutableBranchStepKey;
-    macroStepKey: MutableBranchStepKey;
     cases: [MutableCase, ...MutableCase[]];
 };
 
 export type MutableWhileStep = Omit<WhileStep, 'case'> & {
     stepKey: MutableWhileStepKey;
-    macroStepKey: MutableWhileStepKey;
     case: MutableCase;
 };
 
 export type MutableForStep = Omit<ForStep, 'case'> & {
     stepKey: MutableForStepKey;
-    macroStepKey: MutableForStepKey;
     case: MutableCase;
 };
 
@@ -108,16 +102,16 @@ export function setAuthoringSteps(
 
 export function getStrategyStateEntryByRoleName(
     strategyState: MutableStrategyState,
-    toolStepKey: MutableToolStepKey,
+    stepKey: MutableToolStepKey,
 ): MutableStrategyStateEntryByRoleName | undefined {
-    return strategyState[toolStepKey];
+    return strategyState[stepKey];
 }
 
 export function getStrategyStateEntry(
     strategyState: MutableStrategyState,
     toolStepRoleAddress: MutableToolStepRoleAddress,
 ): MutableStrategyStateEntry | undefined {
-    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey);
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.stepKey);
     return inputEntryByRoleName?.[toolStepRoleAddress.roleName];
 }
 
@@ -126,11 +120,11 @@ export function setStrategyStateEntry(
     toolStepRoleAddress: MutableToolStepRoleAddress,
     entry: MutableStrategyStateEntry,
 ): MutableStrategyState {
-    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.toolStepKey) ?? {};
+    const inputEntryByRoleName = getStrategyStateEntryByRoleName(strategyState, toolStepRoleAddress.stepKey) ?? {};
 
     return {
         ...strategyState,
-        [toolStepRoleAddress.toolStepKey]: {
+        [toolStepRoleAddress.stepKey]: {
             ...inputEntryByRoleName,
             [toolStepRoleAddress.roleName]: entry,
         },
@@ -144,7 +138,7 @@ export function clearInputBinding(
     const inputEntryByRoleName =
         getStrategyStateEntryByRoleName(
             strategyState,
-            toolStepRoleAddress.toolStepKey,
+            toolStepRoleAddress.stepKey,
         );
 
     if (!inputEntryByRoleName || !(toolStepRoleAddress.roleName in inputEntryByRoleName)) {
@@ -156,13 +150,13 @@ export function clearInputBinding(
 
     if (Object.keys(nextInputEntryByRoleName).length === 0) {
         const nextStrategyState = { ...strategyState };
-        delete nextStrategyState[toolStepRoleAddress.toolStepKey];
+        delete nextStrategyState[toolStepRoleAddress.stepKey];
         return nextStrategyState;
     }
 
     return {
         ...strategyState,
-        [toolStepRoleAddress.toolStepKey]: nextInputEntryByRoleName,
+        [toolStepRoleAddress.stepKey]: nextInputEntryByRoleName,
     };
 }
 
@@ -197,14 +191,14 @@ export function bindInternalInputPotential(
     }
 ): MutableStrategyState {
 
-    const sourceToolStep = context.toolStepByKey.get(sourceAddress.toolStepKey);
+    const sourceToolStep = context.toolStepByKey.get(sourceAddress.stepKey);
     if (!sourceToolStep) {
-        throw new Error(`Source tool step not found for '${sourceAddress.toolStepKey}'.`);
+        throw new Error(`Source tool step not found for '${sourceAddress.stepKey}'.`);
     }
 
-    const targetToolStep = context.toolStepByKey.get(targetAddress.toolStepKey);
+    const targetToolStep = context.toolStepByKey.get(targetAddress.stepKey);
     if (!targetToolStep) {
-        throw new Error(`Target tool step not found for '${targetAddress.toolStepKey}'.`);
+        throw new Error(`Target tool step not found for '${targetAddress.stepKey}'.`);
     }
 
     const sourceTool = context.toolMap.get(sourceToolStep.toolHandle);
@@ -219,13 +213,13 @@ export function bindInternalInputPotential(
 
     const targetInputRoleValue = getInputRoleValue(targetTool, targetAddress.roleName);
     if (!targetInputRoleValue) {
-        throw new Error(`Target input role not found for (${targetAddress.toolStepKey}, ${targetAddress.roleName}).`);
+        throw new Error(`Target input role not found for (${targetAddress.stepKey}, ${targetAddress.roleName}).`);
     }
 
     const sourceOutputRoleValue = getOutputRoleValue(sourceTool, sourceAddress.roleName);
     const sourceInputRoleValue = getInputRoleValue(sourceTool, sourceAddress.roleName);
 
-    const sourceInputEntryByRoleName = strategyState[sourceAddress.toolStepKey];
+    const sourceInputEntryByRoleName = strategyState[sourceAddress.stepKey];
     const sourceInputEntry = sourceInputEntryByRoleName?.[sourceAddress.roleName];
 
     const sourceRoleType = sourceOutputRoleValue
@@ -238,17 +232,17 @@ export function bindInternalInputPotential(
 
     if (!sourceOutputRoleValue && sourceInputRoleValue) {
         if (!sourceInputEntry) {
-            throw new Error(`Source input role is not bound for (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}).`); // ATTENTION: not an ontological invariant, but it might help catch some mistakes early on.
+            throw new Error(`Source input role is not bound for (${sourceAddress.stepKey}, ${sourceAddress.roleName}).`); // ATTENTION: not an ontological invariant, but it might help catch some mistakes early on.
         }
     }
 
     if (!sourceOutputRoleValue && !sourceInputRoleValue) {
-        throw new Error(`Source role not found for (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}).`);
+        throw new Error(`Source role not found for (${sourceAddress.stepKey}, ${sourceAddress.roleName}).`);
     }
 
     if (!sourceRoleType || !targetRoleType || sourceRoleType !== targetRoleType) {
         throw new Error(
-            `Reference type mismatch between source (${sourceAddress.toolStepKey}, ${sourceAddress.roleName}) and target (${targetAddress.toolStepKey}, ${targetAddress.roleName}).`
+            `Reference type mismatch between source (${sourceAddress.stepKey}, ${sourceAddress.roleName}) and target (${targetAddress.stepKey}, ${targetAddress.roleName}).`
         );
     }
 
@@ -256,7 +250,6 @@ export function bindInternalInputPotential(
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             stepKey: sourceAddress.stepKey,
-            toolStepKey: sourceAddress.toolStepKey,
             roleName: sourceAddress.roleName,
         },
     });

package/src/utils/stepCreation.ts

@@ -32,7 +32,6 @@ export function createToolStepFromTool(
 ): MutableToolStep {
     return {
         stepKey: generateIdentifier('ToolStepKey'),
-        toolStepKey: generateIdentifier('ToolStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.tool,
         toolHandle: tool.handle,
         roleBindingSpec: getRoleBindingSpec(tool),
@@ -63,7 +62,6 @@ export function createLoopStepFromCase(
     if (stepKind === CONSTANTS.Enums.StepKind.for) {
         return {
             stepKey: generateIdentifier('ForStepKey'),
-            macroStepKey: generateIdentifier('ForStepKey'),
             stepKind: CONSTANTS.Enums.StepKind.for,
             case: stepCase,
         };
@@ -71,7 +69,6 @@ export function createLoopStepFromCase(
 
     return {
         stepKey: generateIdentifier('WhileStepKey'),
-        macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: stepCase,
     };
@@ -84,7 +81,6 @@ export function createBranchStepFromCases(
 
     return {
         stepKey: generateIdentifier('BranchStepKey'),
-        macroStepKey: generateIdentifier('BranchStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.branch,
         cases,
     };
@@ -95,16 +91,15 @@ export function cloneForStep(
 ): MutableForStep {
     return {
         stepKey: generateIdentifier('ForStepKey'),
-        macroStepKey: generateIdentifier('ForStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.for,
         case: {
             what: {
                 ...forStep.case.what,
-                toolStepKey: generateIdentifier('ToolStepKey'),
+                stepKey: generateIdentifier('ToolStepKey'),
             },
             when: {
                 ...forStep.case.when,
-                toolStepKey: generateIdentifier('ToolStepKey'),
+                stepKey: generateIdentifier('ToolStepKey'),
             },
         },
     };
@@ -115,16 +110,15 @@ export function cloneWhileStep(
 ): MutableWhileStep {
     return {
         stepKey: generateIdentifier('WhileStepKey'),
-        macroStepKey: generateIdentifier('WhileStepKey'),
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: {
             what: {
                 ...whileStep.case.what,
-                toolStepKey: generateIdentifier('ToolStepKey'),
+                stepKey: generateIdentifier('ToolStepKey'),
             },
             when: {
                 ...whileStep.case.when,
-                toolStepKey: generateIdentifier('ToolStepKey'),
+                stepKey: generateIdentifier('ToolStepKey'),
             },
         },
     };

package/src/utils/stepParallelization.ts

@@ -17,7 +17,7 @@ export function getIndependentThreads(
 		return `steps[${ownerIndex}] stepKind=${step?.stepKind ?? 'unknown'}`;
 	};
 
-	const toolStepKeyToOwner = new Map<MutableToolStepKey, OwnerIndex>();
+	const stepKeyToOwner = new Map<MutableToolStepKey, OwnerIndex>();
 	const toolStepByKey = new Map<MutableToolStepKey, MutableToolStep>();
 
 	const addToolStep = (
@@ -26,15 +26,15 @@ export function getIndependentThreads(
 	) => {
 		if (!toolStep) return;
 
-		const existingOwner = toolStepKeyToOwner.get(toolStep.toolStepKey);
+		const existingOwner = stepKeyToOwner.get(toolStep.stepKey);
 		if (existingOwner !== undefined) {
 			throw new Error(
-				`Duplicate toolStepKey '${toolStep.toolStepKey}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
+				`Duplicate stepKey '${toolStep.stepKey}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
 			);
 		}
 
-		toolStepKeyToOwner.set(toolStep.toolStepKey, ownerIndex);
-		toolStepByKey.set(toolStep.toolStepKey, toolStep);
+		stepKeyToOwner.set(toolStep.stepKey, ownerIndex);
+		toolStepByKey.set(toolStep.stepKey, toolStep);
 	};
 
 	steps.forEach((step, ownerIndex) => {
@@ -55,28 +55,28 @@ export function getIndependentThreads(
 		ensureOwner(index);
 	}
 
-	for (const [toolStepKey, ownerIndex] of toolStepKeyToOwner) {
+	for (const [stepKey, ownerIndex] of stepKeyToOwner) {
 		ensureOwner(ownerIndex);
 
-		const toolStep = toolStepByKey.get(toolStepKey);
+		const toolStep = toolStepByKey.get(stepKey);
 		const inputBindings = toolStep?.roleBindingSpec?.inputBindings ?? [];
-		const bucket = strategyState[toolStepKey];
+		const bucket = strategyState[stepKey];
 
 		for (const inputRoleId of inputBindings) {
 			const entry = bucket?.[inputRoleId];
 			if (!entry || entry.strategyStateEntryKind !== 'internalInputPotential') continue;
 
-			const producerToolStepKey = entry.toolStepRoleAddress?.toolStepKey;
-			if (typeof producerToolStepKey !== 'string') {
+			const producerStepKey = entry.toolStepRoleAddress?.stepKey;
+			if (typeof producerStepKey !== 'string') {
 				throw new Error(
-					`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.toolStepKey for role '${inputRoleId}'`
+					`Unresolvable internalInputPotential in toolStep '${stepKey}' (${getOwnerLabel(ownerIndex)}): missing toolStepRoleAddress.stepKey for role '${inputRoleId}'`
 				);
 			}
 
-			const producerOwner = toolStepKeyToOwner.get(producerToolStepKey);
+			const producerOwner = stepKeyToOwner.get(producerStepKey);
 			if (producerOwner === undefined) {
 				throw new Error(
-					`Unresolvable internalInputPotential in toolStep '${toolStepKey}' (${getOwnerLabel(ownerIndex)}): source toolStepKey '${producerToolStepKey}' not found in strategy steps`
+					`Unresolvable internalInputPotential in toolStep '${stepKey}' (${getOwnerLabel(ownerIndex)}): source stepKey '${producerStepKey}' not found in strategy steps`
 				);
 			}
 

package/src/utils/strategyCanonicalization.ts

@@ -31,8 +31,8 @@ import { generateIdentifier } from './identifierGeneration.js';
 
 function stripMutableCase(stepCase: MutableCase): Case {
     const { when, what, ...rest } = stepCase;
-    const { stepKey: _whenStepKey, toolStepKey: _whenToolStepKey, ...canonicalWhen } = when;
-    const { stepKey: _whatStepKey, toolStepKey: _whatToolStepKey, ...canonicalWhat } = what;
+    const { stepKey: _whenStepKey, ...canonicalWhen } = when;
+    const { stepKey: _whatStepKey, ...canonicalWhat } = what;
 
     return {
         ...rest,
@@ -47,18 +47,18 @@ function buildExecutionPathMap(strategy: MutableStrategy): Map<MutableToolStepKe
     const registerStep = (step: MutableStep, pathPrefix: string) => {
         switch (step.stepKind) {
             case CONSTANTS.Enums.StepKind.tool:
-                executionPathByKey.set(step.toolStepKey, `${pathPrefix}/self` as ToolStepPath);
+                executionPathByKey.set(step.stepKey, `${pathPrefix}/self` as ToolStepPath);
                 return;
             case CONSTANTS.Enums.StepKind.branch:
                 step.cases.forEach((stepCase, caseIndex) => {
-                    executionPathByKey.set(stepCase.when.toolStepKey, `${pathPrefix}/cases/${caseIndex}/when` as ToolStepPath);
-                    executionPathByKey.set(stepCase.what.toolStepKey, `${pathPrefix}/cases/${caseIndex}/what` as ToolStepPath);
+                    executionPathByKey.set(stepCase.when.stepKey, `${pathPrefix}/cases/${caseIndex}/when` as ToolStepPath);
+                    executionPathByKey.set(stepCase.what.stepKey, `${pathPrefix}/cases/${caseIndex}/what` as ToolStepPath);
                 });
                 return;
             case CONSTANTS.Enums.StepKind.while:
             case CONSTANTS.Enums.StepKind.for:
-                executionPathByKey.set(step.case.when.toolStepKey, `${pathPrefix}/case/when` as ToolStepPath);
-                executionPathByKey.set(step.case.what.toolStepKey, `${pathPrefix}/case/what` as ToolStepPath);
+                executionPathByKey.set(step.case.when.stepKey, `${pathPrefix}/case/when` as ToolStepPath);
+                executionPathByKey.set(step.case.what.stepKey, `${pathPrefix}/case/what` as ToolStepPath);
                 return;
             default:
                 throw new Error('Unsupported step kind while projecting strategy.');
@@ -82,9 +82,9 @@ function toCanonicalStrategyStateEntry(
         return entry as MaterializedResource | ExternalInputPotential;
     }
 
-    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.toolStepKey);
+    const sourceToolStepPath = executionPathByKey.get(entry.toolStepRoleAddress.stepKey);
     if (!sourceToolStepPath) {
-        throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${entry.toolStepRoleAddress.toolStepKey}'.`);
+        throw new Error(`Cannot project strategy state: no execution path found for stepKey '${entry.toolStepRoleAddress.stepKey}'.`);
     }
 
     return {
@@ -99,11 +99,11 @@ function toCanonicalStrategyStateEntry(
 function toCanonicalStep(step: MutableStep): Step {
     switch (step.stepKind) {
         case CONSTANTS.Enums.StepKind.tool: {
-            const { stepKey: _stepKey, toolStepKey: _toolStepKey, ...canonicalToolStep } = step;
+            const { stepKey: _stepKey, ...canonicalToolStep } = step;
             return canonicalToolStep;
         }
         case CONSTANTS.Enums.StepKind.branch: {
-            const { stepKey: _stepKey, macroStepKey: _macroStepKey, cases, ...rest } = step;
+            const { stepKey: _stepKey, cases, ...rest } = step;
             return {
                 ...rest,
                 cases: cases.map(stripMutableCase) as [Case, ...Case[]],
@@ -111,7 +111,7 @@ function toCanonicalStep(step: MutableStep): Step {
         }
         case CONSTANTS.Enums.StepKind.while:
         case CONSTANTS.Enums.StepKind.for: {
-            const { stepKey: _stepKey, macroStepKey: _macroStepKey, case: stepCase, ...rest } = step;
+            const { stepKey: _stepKey, case: stepCase, ...rest } = step;
             return {
                 ...rest,
                 case: stripMutableCase(stepCase),
@@ -139,7 +139,6 @@ function toMutableStrategyStateEntry(
         strategyStateEntryKind: 'internalInputPotential',
         toolStepRoleAddress: {
             stepKey: sourceToolStepKey,
-            toolStepKey: sourceToolStepKey,
             roleName: entry.toolStepRoleAddress.roleName,
         },
     } satisfies MutableInternalInputPotential;
@@ -150,7 +149,6 @@ function toMutableToolStep(step: ToolStep): MutableToolStep {
     return {
         ...step,
         stepKey: key,
-        toolStepKey: key,
     };
 }
 
@@ -171,7 +169,6 @@ function toMutableBranchStep(step: BranchStep): MutableBranchStep {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         cases: cases.map(toMutableCase) as [MutableCase, ...MutableCase[]],
     };
 }
@@ -183,7 +180,6 @@ function toMutableWhileStep(step: WhileStep): MutableWhileStep {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -195,7 +191,6 @@ function toMutableForStep(step: ForStep): MutableForStep {
     return {
         ...rest,
         stepKey: key,
-        macroStepKey: key,
         case: toMutableCase(stepCase),
     };
 }
@@ -219,8 +214,8 @@ function buildExecutionKeyMap(strategy: MutableStrategy): Map<ToolStepPath, Muta
     const executionPathByKey = buildExecutionPathMap(strategy);
     const executionKeyByPath = new Map<ToolStepPath, MutableToolStepKey>();
 
-    for (const [toolStepKey, toolStepPath] of executionPathByKey.entries()) {
-        executionKeyByPath.set(toolStepPath, toolStepKey);
+    for (const [stepKey, toolStepPath] of executionPathByKey.entries()) {
+        executionKeyByPath.set(toolStepPath, stepKey);
     }
 
     return executionKeyByPath;
@@ -239,12 +234,12 @@ export function strategyToMutableStrategy(strategy: Strategy): MutableStrategy {
     const strategyState: MutableStrategy['strategyState'] = {};
 
     for (const [toolStepPath, inputEntryByRoleName] of Object.entries(strategy.strategyState)) {
-        const toolStepKey = executionKeyByPath.get(toolStepPath as ToolStepPath);
-        if (!toolStepKey) {
+        const stepKey = executionKeyByPath.get(toolStepPath as ToolStepPath);
+        if (!stepKey) {
             throw new Error(`Cannot deproject strategy state: no mutable key found for toolStepPath '${toolStepPath}'.`);
         }
 
-        strategyState[toolStepKey] = Object.fromEntries(
+        strategyState[stepKey] = Object.fromEntries(
             Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
                 if (entry === undefined) {
                     throw new Error(
@@ -271,21 +266,21 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
     const strategyState: Strategy['strategyState'] = {};
 
-    for (const [toolStepKey, inputEntryByRoleName] of Object.entries(mutableStrategy.strategyState)) {
+    for (const [stepKey, inputEntryByRoleName] of Object.entries(mutableStrategy.strategyState)) {
         if (!inputEntryByRoleName) {
             continue;
         }
 
-        const toolStepPath = executionPathByKey.get(toolStepKey as MutableToolStepKey);
+        const toolStepPath = executionPathByKey.get(stepKey as MutableToolStepKey);
         if (!toolStepPath) {
-            throw new Error(`Cannot project strategy state: no execution path found for toolStepKey '${toolStepKey}'.`);
+            throw new Error(`Cannot project strategy state: no execution path found for stepKey '${stepKey}'.`);
         }
 
         strategyState[toolStepPath] = Object.fromEntries(
             Object.entries(inputEntryByRoleName).map(([roleName, entry]) => {
                 if (entry === undefined) {
                     throw new Error(
-                        `Cannot project strategy state: role '${roleName}' on toolStepKey '${toolStepKey}' is explicitly undefined.`
+                        `Cannot project strategy state: role '${roleName}' on stepKey '${stepKey}' is explicitly undefined.`
                     );
                 }
 
@@ -304,28 +299,28 @@ export function mutableStrategyToStrategy(mutableStrategy: MutableStrategy): Str
     };
 }
 
-export function mutableToolStepKeyToToolStepPath(
+export function mutableStepKeyToToolStepPath(
     mutableStrategy: MutableStrategy,
-    toolStepKey: MutableToolStepKey,
+    stepKey: MutableToolStepKey,
 ): ToolStepPath {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(toolStepKey);
+    const toolStepPath = executionPathByKey.get(stepKey);
     if (!toolStepPath) {
-        throw new Error(`Cannot project toolStepPath: no execution path found for toolStepKey '${toolStepKey}'.`);
+        throw new Error(`Cannot project toolStepPath: no execution path found for stepKey '${stepKey}'.`);
     }
 
     return toolStepPath;
 }
 
-export function projectMutableStrategyStateEntriesByToolStepKeyToCanonicalDelta(
+export function projectMutableStrategyStateEntriesByStepKeyToCanonicalDelta(
     mutableStrategy: MutableStrategy,
-    toolStepKey: MutableToolStepKey,
+    stepKey: MutableToolStepKey,
     entries: MutableStrategyStateEntryByRoleName,
 ): Strategy['strategyState'] {
     const executionPathByKey = buildExecutionPathMap(mutableStrategy);
-    const toolStepPath = executionPathByKey.get(toolStepKey);
+    const toolStepPath = executionPathByKey.get(stepKey);
     if (!toolStepPath) {
-        throw new Error(`Cannot project strategy state delta: no execution path found for toolStepKey '${toolStepKey}'.`);
+        throw new Error(`Cannot project strategy state delta: no execution path found for stepKey '${stepKey}'.`);
     }
 
     const canonicalEntries: Strategy['strategyState'][ToolStepPath] = Object.fromEntries(
@@ -334,7 +329,7 @@ export function projectMutableStrategyStateEntriesByToolStepKeyToCanonicalDelta(
             .map(([roleName, entry]) => {
                 if (entry === undefined) {
                     throw new Error(
-                        `Cannot project strategy state delta: role '${roleName}' on toolStepKey '${toolStepKey}' is explicitly undefined.`
+                        `Cannot project strategy state delta: role '${roleName}' on stepKey '${stepKey}' is explicitly undefined.`
                     );
                 }
 

package/src/utils/strategyStateResolution.ts

@@ -28,7 +28,7 @@ export function resolveStrategyStateChain(
 	for (let depth = 0; depth <= maxDepth; depth++) {
 		path.push(current);
 
-		const visitKey = `${current.toolStepKey}::${current.roleName}`;
+		const visitKey = `${current.stepKey}::${current.roleName}`;
 		if (visited.has(visitKey)) {
 			return { status: 'unresolved', reason: 'cycle', path };
 		}