@toolproof-core/lib 1.0.26 → 1.0.28

package/src/types/types.ts

@@ -1,7 +1,7 @@
 import type {
     StepKindJson,
     ResourceJson,
-    ResourceTypeIdentityJson,
+    ResourceTypeIdJson,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
 import { MAPPINGS } from '../artifacts/artifacts.js';
@@ -12,16 +12,16 @@ export type Collection = keyof typeof CONSTANTS.Persistence.Collections;
 
 export type SchemaLike = Record<string, unknown>;
 
-export type ResourcesByType = Record<ResourceTypeIdentityJson, ResourceJson[]>;
+export type ResourcesByType = Record<ResourceTypeIdJson, ResourceJson[]>;
 
-export type IdentityName = keyof typeof MAPPINGS.IdentityNameToIdentityPrefix;
+export type IdName = keyof typeof MAPPINGS.IdNameToIdPrefix;
 
-export type IdentityStringByIdentityName<K extends IdentityName> = `${(typeof MAPPINGS.IdentityNameToIdentityPrefix)[K]}${string}`;
+export type IdStringByIdName<K extends IdName> = `${(typeof MAPPINGS.IdNameToIdPrefix)[K]}${string}`;
 
-export type StepIdentityStringByStepKind<K extends StepKindJson> = `${(typeof MAPPINGS.StepKindToStepIdentityPrefix)[K]}${string}`;
+export type StepIdStringByStepKind<K extends StepKindJson> = `${(typeof MAPPINGS.StepKindToStepIdPrefix)[K]}${string}`;
 
 export interface NucleusBaseSmall<T extends string = string> {
-    identity: T;
+    id: T;
 }
 
 export interface NucleusBaseLarge<T extends string = string> extends NucleusBaseSmall<T> {

package/src/utils/bindInputRoleToResource.ts

@@ -56,7 +56,7 @@ export function bindInputRefInStrategyState(
     if (result.status === CONSTANTS.Enums.ResourceShellKind.externalInputPotential) {
         const externalInput = result.entry;
         const reusedExternalInput: ExternalInputPotentialShellJson = {
-            identity: externalInput.identity,
+            id: externalInput.id,
             resourceTypeHandle: externalInput.resourceTypeHandle,
             resourceShellKind: CONSTANTS.Enums.ResourceShellKind.externalInputPotential,
         };
@@ -72,7 +72,7 @@ export function bindInputRefInStrategyState(
 
     if (result.status === CONSTANTS.Enums.ResourceShellKind.outputPotential) {
         const potentialInput: InternalInputPotentialShellJson = {
-            identity: sourceEntry.identity,
+            id: sourceEntry.id,
             resourceTypeHandle: sourceEntry.resourceTypeHandle,
             creationContext: {
                 toolStepHandle: source.toolStepHandle,

package/src/utils/creation/resourceCreation.ts

@@ -3,14 +3,14 @@ import type {
     ExternalInputPotentialShellJson,
     InternalInputPotentialShellJson,
     OutputPotentialShellJson,
-    ResourceIdentityJson,
+    ResourceIdJson,
     ResourceJson,
-    ResourceTypeIdentityJson,
+    ResourceTypeIdJson,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../../artifacts/artifacts.js';
 
-export function generatePath(resourceTypeHandle: ResourceTypeIdentityJson, identity: ResourceIdentityJson): string {
-    return `${resourceTypeHandle}/${identity}.json`;
+export function generatePath(resourceTypeHandle: ResourceTypeIdJson, id: ResourceIdJson): string {
+    return `${resourceTypeHandle}/${id}.json`;
 }
 
 export function createMaterializedFromOutputPotential(
@@ -18,11 +18,11 @@ export function createMaterializedFromOutputPotential(
     nucleus: unknown,
     timestamp?: string,
 ): ResourceJson {
-    const { identity, resourceTypeHandle, creationContext } = outputPotential;
-    const path = generatePath(resourceTypeHandle, identity);
+    const { id, resourceTypeHandle, creationContext } = outputPotential;
+    const path = generatePath(resourceTypeHandle, id);
 
     return {
-        identity,
+        id,
         resourceTypeHandle,
         creationContext,
         resourceShellKind: CONSTANTS.Enums.ResourceShellKind.materialized,
@@ -38,11 +38,11 @@ export function createMaterializedFromInputPotential(
     nucleus: unknown,
     timestamp?: string,
 ): ResourceJson {
-    const { identity, resourceTypeHandle, creationContext } = inputPotential;
-    const path = generatePath(resourceTypeHandle, identity);
+    const { id, resourceTypeHandle, creationContext } = inputPotential;
+    const path = generatePath(resourceTypeHandle, id);
 
     return {
-        identity,
+        id,
         resourceTypeHandle,
         creationContext,
         resourceShellKind: CONSTANTS.Enums.ResourceShellKind.materialized,
@@ -66,23 +66,23 @@ export function createMaterializedFromPotential(
 }
 
 export function createExternalInputPotential(
-    identity: ResourceIdentityJson,
-    resourceTypeHandle: ResourceTypeIdentityJson,
+    id: ResourceIdJson,
+    resourceTypeHandle: ResourceTypeIdJson,
 ): ExternalInputPotentialShellJson {
     return {
-        identity,
+        id,
         resourceTypeHandle,
         resourceShellKind: CONSTANTS.Enums.ResourceShellKind.externalInputPotential,
     };
 }
 
 export function createInputPotential(
-    identity: ResourceIdentityJson,
-    resourceTypeHandle: ResourceTypeIdentityJson,
+    id: ResourceIdJson,
+    resourceTypeHandle: ResourceTypeIdJson,
     creationContext: CreationContextJson,
 ): InternalInputPotentialShellJson {
     return {
-        identity,
+        id,
         resourceTypeHandle,
         creationContext,
         resourceShellKind: CONSTANTS.Enums.ResourceShellKind.internalInputPotential,
@@ -90,12 +90,12 @@ export function createInputPotential(
 }
 
 export function createOutputPotential(
-    identity: ResourceIdentityJson,
-    resourceTypeHandle: ResourceTypeIdentityJson,
+    id: ResourceIdJson,
+    resourceTypeHandle: ResourceTypeIdJson,
     creationContext: CreationContextJson,
 ): OutputPotentialShellJson {
     return {
-        identity,
+        id,
         resourceTypeHandle,
         creationContext,
         resourceShellKind: CONSTANTS.Enums.ResourceShellKind.outputPotential,

package/src/utils/creation/runnableStrategyCreation.ts

@@ -1,10 +1,10 @@
 import type {
     RawStrategyJson,
-    RunnableStrategyIdentityJson,
+    RunnableStrategyIdJson,
     RunnableStrategyJson,
     StepJson,
     StepArrayByStrategyThreadJson,
-    StrategyThreadIdentityJson,
+    StrategyThreadIdJson,
 } from '@toolproof-core/schema';
 import { getIndependentThreads } from '../parallelizeSteps.js';
 
@@ -14,28 +14,28 @@ export function getRunnableStrategyThreadGroups(rawStrategy: RawStrategyJson): S
 
 export function buildRunnableStrategy(
     rawStrategy: RawStrategyJson,
-    runnableStrategyIdentity: RunnableStrategyIdentityJson,
+    runnableStrategyId: RunnableStrategyIdJson,
     threadStepGroups: StepJson[][],
-    threadIdentities: StrategyThreadIdentityJson[],
+    threadIdentities: StrategyThreadIdJson[],
 ): RunnableStrategyJson {
     if (threadStepGroups.length !== threadIdentities.length) {
-        throw new Error('buildRunnableStrategy requires one thread identity per thread group');
+        throw new Error('buildRunnableStrategy requires one thread id per thread group');
     }
 
     const stepsByStrategyThread: StepArrayByStrategyThreadJson = {};
 
     for (const [index, group] of threadStepGroups.entries()) {
-        const threadIdentity = threadIdentities[index];
+        const threadId = threadIdentities[index];
 
-        if (!threadIdentity) {
-            throw new Error(`Missing thread identity for thread group index ${index}`);
+        if (!threadId) {
+            throw new Error(`Missing thread id for thread group index ${index}`);
         }
 
-        stepsByStrategyThread[threadIdentity] = group;
+        stepsByStrategyThread[threadId] = group;
     }
 
     return {
-        identity: runnableStrategyIdentity,
+        id: runnableStrategyId,
         stepsByStrategyThread,
         strategyState: rawStrategy.strategyState,
     };

package/src/utils/creation/stepCreation.ts

@@ -1,14 +1,14 @@
 import type {
-    BranchStepIdentityJson,
+    BranchStepIdJson,
     BranchStepJson,
     CaseJson,
-    ForStepIdentityJson,
+    ForStepIdJson,
     ForStepJson,
     ToolJson,
-    ToolStepIdentityJson,
+    ToolStepIdJson,
     ToolStepJson,
-    ResourceRoleIdentityJson,
-    WhileStepIdentityJson,
+    ResourceRoleIdJson,
+    WhileStepIdJson,
     WhileStepJson,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../../artifacts/artifacts.js';
@@ -16,20 +16,20 @@ import { CONSTANTS } from '../../artifacts/artifacts.js';
 export type LoopStepBuildIdentities =
     | {
         stepKind: typeof CONSTANTS.Enums.StepKind.for;
-        stepIdentity: ForStepIdentityJson;
-        whatIdentity: ToolStepIdentityJson;
-        whenIdentity: ToolStepIdentityJson;
+        stepId: ForStepIdJson;
+        whatId: ToolStepIdJson;
+        whenId: ToolStepIdJson;
     }
     | {
         stepKind: typeof CONSTANTS.Enums.StepKind.while;
-        stepIdentity: WhileStepIdentityJson;
-        whatIdentity: ToolStepIdentityJson;
-        whenIdentity: ToolStepIdentityJson;
+        stepId: WhileStepIdJson;
+        whatId: ToolStepIdJson;
+        whenId: ToolStepIdJson;
     };
 
 export type BranchCaseBuildIdentities = {
-    whatIdentity: ToolStepIdentityJson;
-    whenIdentity: ToolStepIdentityJson;
+    whatId: ToolStepIdJson;
+    whenId: ToolStepIdJson;
 };
 
 function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
@@ -40,19 +40,19 @@ function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
 
 function getRoleBindingSpec(tool: ToolJson): ToolStepJson['roleBindingSpec'] {
     return {
-        inputBindings: Object.keys(tool.roleSpec.inputRoleValueByIdentity) as ResourceRoleIdentityJson[],
-        outputBindings: Object.keys(tool.roleSpec.outputRoleValueByIdentity) as ResourceRoleIdentityJson[],
+        inputBindings: Object.keys(tool.roleSpec.inputRoleValueById) as ResourceRoleIdJson[],
+        outputBindings: Object.keys(tool.roleSpec.outputRoleValueById) as ResourceRoleIdJson[],
     };
 }
 
 export function buildToolStepFromTool(
     tool: ToolJson,
-    identity: ToolStepIdentityJson,
+    id: ToolStepIdJson,
 ): ToolStepJson {
     return {
-        identity,
+        id,
         stepKind: CONSTANTS.Enums.StepKind.tool,
-        toolHandle: tool.identity,
+        toolHandle: tool.id,
         roleBindingSpec: getRoleBindingSpec(tool),
     };
 }
@@ -62,19 +62,19 @@ export function buildLoopStepFromToolPair(
     whenTool: ToolJson,
     identities: LoopStepBuildIdentities,
 ): ForStepJson | WhileStepJson {
-    const what = buildToolStepFromTool(whatTool, identities.whatIdentity);
-    const when = buildToolStepFromTool(whenTool, identities.whenIdentity);
+    const what = buildToolStepFromTool(whatTool, identities.whatId);
+    const when = buildToolStepFromTool(whenTool, identities.whenId);
 
     if (identities.stepKind === CONSTANTS.Enums.StepKind.for) {
         return {
-            identity: identities.stepIdentity,
+            id: identities.stepId,
             stepKind: CONSTANTS.Enums.StepKind.for,
             case: { what, when },
         };
     }
 
     return {
-        identity: identities.stepIdentity,
+        id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: { what, when },
     };
@@ -82,11 +82,11 @@ export function buildLoopStepFromToolPair(
 
 export function buildBranchStepFromToolPairs(
     cases: Array<{ whatTool: ToolJson; whenTool: ToolJson }>,
-    branchIdentity: BranchStepIdentityJson,
+    branchId: BranchStepIdJson,
     caseIdentities: BranchCaseBuildIdentities[],
 ): BranchStepJson {
     if (cases.length !== caseIdentities.length) {
-        throw new Error('buildBranchStepFromToolPairs requires one identity pair per case');
+        throw new Error('buildBranchStepFromToolPairs requires one id pair per case');
     }
 
     const resolved = cases.map(({ whatTool, whenTool }, index) => {
@@ -96,15 +96,15 @@ export function buildBranchStepFromToolPairs(
             throw new Error(`Missing case identities for case index ${index}`);
         }
 
-        const what = buildToolStepFromTool(whatTool, identities.whatIdentity);
-        const when = buildToolStepFromTool(whenTool, identities.whenIdentity);
+        const what = buildToolStepFromTool(whatTool, identities.whatId);
+        const when = buildToolStepFromTool(whenTool, identities.whenId);
         return { what, when } satisfies CaseJson;
     });
 
     assertNonEmpty(resolved, 'buildBranchStepFromToolPairs requires at least one case');
 
     return {
-        identity: branchIdentity,
+        id: branchId,
         stepKind: CONSTANTS.Enums.StepKind.branch,
         cases: resolved,
     };
@@ -113,22 +113,22 @@ export function buildBranchStepFromToolPairs(
 export function cloneForStepWithIdentities(
     forStep: ForStepJson,
     identities: {
-        stepIdentity: ForStepIdentityJson;
-        whatIdentity: ToolStepIdentityJson;
-        whenIdentity: ToolStepIdentityJson;
+        stepId: ForStepIdJson;
+        whatId: ToolStepIdJson;
+        whenId: ToolStepIdJson;
     },
 ): ForStepJson {
     return {
-        identity: identities.stepIdentity,
+        id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.for,
         case: {
             what: {
                 ...forStep.case.what,
-                identity: identities.whatIdentity,
+                id: identities.whatId,
             },
             when: {
                 ...forStep.case.when,
-                identity: identities.whenIdentity,
+                id: identities.whenId,
             },
         },
     };
@@ -137,22 +137,22 @@ export function cloneForStepWithIdentities(
 export function cloneWhileStepWithIdentities(
     whileStep: WhileStepJson,
     identities: {
-        stepIdentity: WhileStepIdentityJson;
-        whatIdentity: ToolStepIdentityJson;
-        whenIdentity: ToolStepIdentityJson;
+        stepId: WhileStepIdJson;
+        whatId: ToolStepIdJson;
+        whenId: ToolStepIdJson;
     },
 ): WhileStepJson {
     return {
-        identity: identities.stepIdentity,
+        id: identities.stepId,
         stepKind: CONSTANTS.Enums.StepKind.while,
         case: {
             what: {
                 ...whileStep.case.what,
-                identity: identities.whatIdentity,
+                id: identities.whatId,
             },
             when: {
                 ...whileStep.case.when,
-                identity: identities.whenIdentity,
+                id: identities.whenId,
             },
         },
     };

package/src/utils/extractData.ts

@@ -1,22 +1,22 @@
 import type {
     RawStrategyJson,
-    ToolIdentityJson,
+    ToolIdJson,
     ToolJson,
-    ToolStepIdentityJson,
+    ToolStepIdJson,
     ToolStepJson,
     StepJson,
-    ResourceRoleIdentityJson,
+    ResourceRoleIdJson,
     ResourceRoleJson,
-    ResourceIdentityJson,
-    ResourceTypeIdentityJson,
+    ResourceIdJson,
+    ResourceTypeIdJson,
     ResourceJson,
 } from '@toolproof-core/schema';
 import { CONSTANTS } from '../artifacts/artifacts.js';
 
 
-export function extractToolHandlesFromRawStrategy(rawStrategy: RawStrategyJson): ToolIdentityJson[] {
+export function extractToolHandlesFromRawStrategy(rawStrategy: RawStrategyJson): ToolIdJson[] {
     const toolSteps = extractToolStepsFromRawStrategy(rawStrategy);
-    const ids = new Set<ToolIdentityJson>();
+    const ids = new Set<ToolIdJson>();
     for (const jStep of toolSteps) {
         ids.add(jStep.toolHandle);
     }
@@ -25,13 +25,13 @@ export function extractToolHandlesFromRawStrategy(rawStrategy: RawStrategyJson):
 
 export function extractToolStepsFromRawStrategy(rawStrategy: RawStrategyJson): ToolStepJson[] {
     const toolSteps: ToolStepJson[] = [];
-    const seen = new Set<ToolStepIdentityJson>();
+    const seen = new Set<ToolStepIdJson>();
 
     const addToolStep = (toolStep: ToolStepJson) => {
-        if (seen.has(toolStep.identity)) {
-            throw new Error(`Duplicate tool step identity encountered: ${toolStep.identity}`);
+        if (seen.has(toolStep.id)) {
+            throw new Error(`Duplicate tool step id encountered: ${toolStep.id}`);
         }
-        seen.add(toolStep.identity);
+        seen.add(toolStep.id);
         toolSteps.push(toolStep);
     };
 
@@ -69,23 +69,23 @@ export function extractToolStepsFromRawStrategy(rawStrategy: RawStrategyJson): T
 }
 
 
-export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategyJson, toolMap: Map<ToolIdentityJson, ToolJson>): Map<ResourceRoleIdentityJson, ResourceRoleJson> {
-    const roleMap = new Map<ResourceRoleIdentityJson, ResourceRoleJson>();
+export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategyJson, toolMap: Map<ToolIdJson, ToolJson>): Map<ResourceRoleIdJson, ResourceRoleJson> {
+    const roleMap = new Map<ResourceRoleIdJson, ResourceRoleJson>();
     const toolHandles = extractToolHandlesFromRawStrategy(rawStrategy);
 
     for (const toolHandle of toolHandles) {
         const tool = toolMap.get(toolHandle);
         if (!tool) continue;
 
-        for (const [rid, role] of Object.entries(tool.roleSpec.inputRoleValueByIdentity)) {
-            roleMap.set(rid as ResourceRoleIdentityJson, {
-                identity: rid as ResourceRoleIdentityJson,
+        for (const [rid, role] of Object.entries(tool.roleSpec.inputRoleValueById)) {
+            roleMap.set(rid as ResourceRoleIdJson, {
+                id: rid as ResourceRoleIdJson,
                 ...role,
             });
         }
-        for (const [rid, role] of Object.entries(tool.roleSpec.outputRoleValueByIdentity)) {
-            roleMap.set(rid as ResourceRoleIdentityJson, {
-                identity: rid as ResourceRoleIdentityJson,
+        for (const [rid, role] of Object.entries(tool.roleSpec.outputRoleValueById)) {
+            roleMap.set(rid as ResourceRoleIdJson, {
+                id: rid as ResourceRoleIdJson,
                 ...role,
             });
         }
@@ -94,11 +94,11 @@ export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategyJson, tool
     return roleMap;
 }
 
-export function extractSingleNonErrorOutputTypeHandle(tool: ToolJson): ResourceTypeIdentityJson | null {
+export function extractSingleNonErrorOutputTypeHandle(tool: ToolJson): ResourceTypeIdJson | null {
     const errorRoleId = CONSTANTS.Cosmos.ROLE_ErrorOutput;
-    const outputEntries = Object.entries(tool.roleSpec.outputRoleValueByIdentity).filter(([roleId]) => roleId !== errorRoleId);
+    const outputEntries = Object.entries(tool.roleSpec.outputRoleValueById).filter(([roleId]) => roleId !== errorRoleId);
     if (!outputEntries || !outputEntries[0] || outputEntries.length !== 1) {
-        throw new Error(`Tool ${tool.identity} must have exactly one non-error output role to be branchable/loopable`);
+        throw new Error(`Tool ${tool.id} must have exactly one non-error output role to be branchable/loopable`);
     } // ATTENTION_PUREIFY
     const outputRole = outputEntries[0][1];
     return outputRole.resourceTypeHandle;
@@ -107,27 +107,27 @@ export function extractSingleNonErrorOutputTypeHandle(tool: ToolJson): ResourceT
 
 
 export function extractResourceMapForType<TResource extends ResourceJson = ResourceJson>(
-    resourcesByType: Partial<Record<ResourceTypeIdentityJson, TResource[]>>,
-    resourceTypeHandle: ResourceTypeIdentityJson
-): Map<ResourceIdentityJson, TResource> {
+    resourcesByType: Partial<Record<ResourceTypeIdJson, TResource[]>>,
+    resourceTypeHandle: ResourceTypeIdJson
+): Map<ResourceIdJson, TResource> {
     const resources = resourcesByType[resourceTypeHandle] ?? [];
-    const map = new Map<ResourceIdentityJson, TResource>();
+    const map = new Map<ResourceIdJson, TResource>();
 
     for (const resource of resources) {
-        map.set(resource.identity, resource);
+        map.set(resource.id, resource);
     }
 
     return map;
 }
 
-// Only use this for resource types whose nuclei are entity-like objects with their own intrinsic identity.
-export function extractIdentityKeyedNucleusMapForType<
+// Only use this for resource types whose nuclei are entity-like objects with their own intrinsic id.
+export function extractIdKeyedNucleusMapForType<
     TKey extends string = string,
-    TNucleus extends { identity: string | number | boolean } = { identity: string | number | boolean },
+    TNucleus extends { id: string | number | boolean } = { id: string | number | boolean },
     TResource extends ResourceJson = ResourceJson
 >(
-    resourcesByType: Partial<Record<ResourceTypeIdentityJson, TResource[]>>,
-    resourceTypeHandle: ResourceTypeIdentityJson,
+    resourcesByType: Partial<Record<ResourceTypeIdJson, TResource[]>>,
+    resourceTypeHandle: ResourceTypeIdJson,
 ): Map<TKey, TNucleus> {
     const resourceMap = extractResourceMapForType<TResource>(resourcesByType, resourceTypeHandle);
     const out = new Map<TKey, TNucleus>();
@@ -136,33 +136,33 @@ export function extractIdentityKeyedNucleusMapForType<
         const data = (resource as any).nucleus as unknown;
         if (data === null || data === undefined) {
             throw new Error(
-                `Expected resource '${resource.identity}' of type '${resourceTypeHandle}' to have a nucleus`
+                `Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have a nucleus`
             );
         }
         if (typeof data !== 'object') {
             throw new Error(
-                `Expected resource '${resource.identity}' of type '${resourceTypeHandle}' to have an object nucleus with identity`
+                `Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have an object nucleus with id`
             );
         }
 
-        const maybeIdentity = (data as any).identity as unknown;
-        if (maybeIdentity === null || maybeIdentity === undefined) {
+        const maybeId = (data as any).id as unknown;
+        if (maybeId === null || maybeId === undefined) {
             throw new Error(
-                `Expected resource '${resource.identity}' of type '${resourceTypeHandle}' to have nucleus.identity`
+                `Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have nucleus.id`
             );
         }
         if (
-            typeof maybeIdentity !== 'string' &&
-            typeof maybeIdentity !== 'number' &&
-            typeof maybeIdentity !== 'boolean'
+            typeof maybeId !== 'string' &&
+            typeof maybeId !== 'number' &&
+            typeof maybeId !== 'boolean'
         ) {
             throw new Error(
-                `Expected resource '${resource.identity}' of type '${resourceTypeHandle}' to have nucleus.identity as string, number, or boolean`
+                `Expected resource '${resource.id}' of type '${resourceTypeHandle}' to have nucleus.id as string, number, or boolean`
             );
         }
 
         const value = data as TNucleus;
-        const key = String(maybeIdentity) as TKey;
+        const key = String(maybeId) as TKey;
 
         out.set(key, value);
     }

package/src/utils/parallelizeSteps.ts

@@ -1,9 +1,9 @@
 import type {
     BranchStepJson,
     ForStepJson,
-    ToolStepIdentityJson,
+    ToolStepIdJson,
     ToolStepJson,
-    ResourceRoleIdentityJson,
+    ResourceRoleIdJson,
     StepJson,
     StrategyStateJson,
     WhileStepJson,
@@ -19,25 +19,25 @@ export function getIndependentThreads(steps: StepJson[], strategyState: Strategy
         return `steps[${ownerIndex}] stepKind=${(step as any)?.stepKind ?? 'unknown'}`;
     };
 
-    // Map each toolStep.identity (including macro-nested tool steps) to owning top-level step index.
-    const toolStepIdToOwner = new Map<ToolStepIdentityJson, OwnerIndex>();
-    const ownerToToolStepIds = new Map<OwnerIndex, ToolStepIdentityJson[]>();
-    const toolStepById = new Map<ToolStepIdentityJson, ToolStepJson>();
+    // Map each toolStep.id (including macro-nested tool steps) to owning top-level step index.
+    const toolStepIdToOwner = new Map<ToolStepIdJson, OwnerIndex>();
+    const ownerToToolStepIds = new Map<OwnerIndex, ToolStepIdJson[]>();
+    const toolStepById = new Map<ToolStepIdJson, ToolStepJson>();
 
     const addToolStep = (toolStep: ToolStepJson | undefined, ownerIndex: OwnerIndex) => {
-        if (!toolStep?.identity) return;
+        if (!toolStep?.id) return;
 
-        const existingOwner = toolStepIdToOwner.get(toolStep.identity);
+        const existingOwner = toolStepIdToOwner.get(toolStep.id);
         if (existingOwner !== undefined) {
             throw new Error(
-                `Duplicate toolStep.identity '${toolStep.identity}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
+                `Duplicate toolStep.id '${toolStep.id}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
             );
         }
 
-        toolStepIdToOwner.set(toolStep.identity, ownerIndex);
-        toolStepById.set(toolStep.identity, toolStep);
+        toolStepIdToOwner.set(toolStep.id, ownerIndex);
+        toolStepById.set(toolStep.id, toolStep);
         const bucket = ownerToToolStepIds.get(ownerIndex) ?? [];
-        bucket.push(toolStep.identity);
+        bucket.push(toolStep.id);
         ownerToToolStepIds.set(ownerIndex, bucket);
     };
 
@@ -94,10 +94,10 @@ export function getIndependentThreads(steps: StepJson[], strategyState: Strategy
         const bucket = strategyState?.[toolStepId] ?? ({} as any);
 
         for (const inputRoleHandle of inputBindings) {
-            const entry = bucket?.[inputRoleHandle as ResourceRoleIdentityJson] as any;
+            const entry = bucket?.[inputRoleHandle as ResourceRoleIdJson] as any;
             if (!entry || entry.resourceShellKind !== 'internalInputPotential') continue;
 
-            const creatorToolStepHandle = entry?.creationContext?.toolStepHandle as ToolStepIdentityJson | undefined;
+            const creatorToolStepHandle = entry?.creationContext?.toolStepHandle as ToolStepIdJson | undefined;
             if (!creatorToolStepHandle) {
                 throw new Error(
                     `Unresolvable internalInputPotential in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): missing creationContext.toolStepHandle for role '${inputRoleHandle}'`