@tiinex/core 0.28.0 → 0.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "Shared host-neutral Tiinex implementation core for artifacts, schemas, validation, lineage, grounding, Handoffs, provenance and deterministic workflows.",
   "type": "module",
   "sideEffects": true,
@@ -173,12 +173,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "b2f8dfc75545e80da0e9bedfe428e191db131c30",
+  "gitHead": "5d51273d4c10f8a15367c32bcef8bbce11484ca8",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "b2f8dfc75545e80da0e9bedfe428e191db131c30",
-    "sourceTree": "f9c5c0634c6dee60d0cc0b5b59b76f8cbb291729",
+    "sourceCommit": "5d51273d4c10f8a15367c32bcef8bbce11484ca8",
+    "sourceTree": "1372b29b40dbee5e11d2a52d9cac7731f41941a2",
     "repository": "Tiinex/core",
-    "previousVersion": "0.27.0"
+    "previousVersion": "0.29.0"
   }
 }

package/src/schemas/creation.contracts.js

@@ -173,7 +173,10 @@ export function validateArtifactCreationResult(draft = {}, parentRecord = {}, op
 
   if (rootCreation) findings.push(...validateRootCreationRepresentation(draft.markdown || '', contract));
   else if (parentExpected) {
-    const relativeReference = relativePath(dirname(options.childPath || draft.path || ''), parentRecord.path || '');
+    const recoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim();
+    const relativeReference = recoveryMode === 'workspace-qualified'
+      ? String(parentRecord.relativeReference || parentRecord.path || '')
+      : relativePath(dirname(options.childPath || draft.path || ''), parentRecord.path || '');
     const parentIntegrityTarget = qualifiedParentIntegrityTarget(parentRecord, relativeReference);
     const representation = qualifyContinuationCreationRepresentation(draft.markdown || '', contract, parentRecord, { relativeReference, parentIntegrityTarget });
     findings.push(...(representation.findings || []).map((message, index) => error(`creation.continuation-representation.${index + 1}`, message)));
@@ -221,7 +224,8 @@ function qualifiedParentIntegrityTarget(parentRecord = {}, relativeReference = '
   const published = parentRecord?.publishedReference || parentRecord?.browseGitReference || parentRecord?.browseGit || null;
   const target = typeof published === 'string' ? '' : String(published?.target || published?.url || '');
   const state = typeof published === 'string' ? 'unresolved' : String(published?.state || published?.resolutionState || 'unresolved');
-  const recoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim() === 'external-versioned' ? 'external-versioned' : 'local-relative';
+  const declaredRecoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim();
+  const recoveryMode = declaredRecoveryMode === 'external-versioned' ? 'external-versioned' : declaredRecoveryMode === 'workspace-qualified' ? 'workspace-qualified' : 'local-relative';
   if (recoveryMode === 'external-versioned') return state === 'qualified' && target ? target : '';
   return state === 'qualified' && target ? target : String(relativeReference || '');
 }

package/src/schemas/creation.representation.js

@@ -217,7 +217,8 @@ export function qualifyContinuationCreationRepresentation(markdown = '', contrac
     const publishedTarget = typeof publishedReference === 'string' ? '' : String(publishedReference?.target || publishedReference?.url || '');
     const publishedState = typeof publishedReference === 'string' ? 'unresolved' : String(publishedReference?.state || publishedReference?.resolutionState || 'unresolved');
     const publishedQualified = Boolean(publishedTarget && publishedState === 'qualified');
-    const recoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim() === 'external-versioned' ? 'external-versioned' : 'local-relative';
+    const declaredRecoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim();
+    const recoveryMode = declaredRecoveryMode === 'external-versioned' ? 'external-versioned' : declaredRecoveryMode === 'workspace-qualified' ? 'workspace-qualified' : 'local-relative';
     if (recoveryMode === 'external-versioned') {
       if (!publishedQualified) findings.push('External Parent recovery requires one qualified version-stable published representation.');
       if (origins.length !== 1 || relative.length !== 0 || browse.length !== 1) findings.push('External Parent Origin must contain exactly one [browse + git](...) entry and must not fabricate [relative](...).');

package/src/tooling/portable/adapters/cli/cli.command-input.js

@@ -182,6 +182,7 @@ export async function commandInput(parsed, runtime = {}) {
     options: {}
   };
   if(parsed.command==='project-workspace-landing')return land(flags,material,readOptionalJson,splitFlag);
+  if (parsed.command === 'project-authoring-parent') return { input: { ...material, reference: flags.reference || '' }, options: {} };
   const operatorBridgeInput = await prepareOperatorBridgeCliInput(parsed.command, material, flags, readOptionalJson);
   if (operatorBridgeInput) return operatorBridgeInput;
   if (parsed.command === 'project-editor-assistance') return prepareEditorAssistanceCliInput(material, flags);

package/src/tooling/portable/adapters/cli/cli.handoff-manufacture.js

@@ -20,6 +20,7 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
   if (!['handoff', 'workspace', 'bootstrap'].includes(carrierMode)) throw new Error(`portable.cli.handoff-carrier.carrier-mode.invalid:${carrierMode}`);
   if (carrierMode === 'workspace') return prepareWorkspaceCarrierCliCommand(flags, workspaceRoot, runtime);
   if (carrierMode === 'bootstrap') return prepareBootstrapCarrierCliCommand(flags, runtime);
+  if (flags['package-major'] && flags['package-consolidation']) throw new Error('portable.cli.handoff-carrier.package-major-consolidation-conflict');
   const continuationState = parsed.surfaceCommand === 'handoff'
     ? await readGroundContinuationState(workspaceRoot)
     : {};
@@ -103,6 +104,7 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
         selectedRoutePointer: continuationState.selectedRoutePointer || flags['package-parent-route-pointer'] || '',
         selectedRouteId: continuationState.selectedRouteId || flags['package-parent-route-id'] || '',
         explicitSiblingIndex: flags['package-sibling-index'],
+        consolidation: Boolean(flags['package-consolidation']),
         enabled: Boolean(flags.output || flags['output-dir'])
       });
       carrierAllocation = siblingAllocation;
@@ -118,6 +120,8 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
     packageParentSha256 = String(carrierLineage.parentPackageSha256 || '');
   } else if (flags['package-major']) {
     throw new Error('portable.cli.handoff-carrier.package-major.parent-required');
+  } else if (flags['package-consolidation']) {
+    throw new Error('portable.cli.handoff-carrier.package-consolidation.parent-required');
   }
   const carrierProfile = selectCarrierProfile({
     operator: operatorCarrierProfile,

package/src/tooling/portable/adapters/cli/cli.handoff-sibling-allocation.js

@@ -97,10 +97,62 @@ export function deriveHandoffSiblingAllocation({ parentInspection = null, select
   }
 }
 
+export function deriveHandoffConsolidationAllocation({ parentInspection = null, explicitSiblingIndex = null, parentPackagePath = '', parentPackageSha256 = '', parentDimension = '' } = {}) {
+  const explicit = normalizeSiblingIndex(explicitSiblingIndex);
+  const inspection = parentInspection && typeof parentInspection === 'object' ? parentInspection : null;
+  if (!inspection || inspection.detected === false) return freeze({
+    state: 'unavailable', siblingIndex: null, allocationMode: 'unavailable',
+    reasonCode: 'qualified-parent-route-topology-unavailable-for-consolidation',
+    provenance: provenanceBase({ parentPackagePath, parentPackageSha256, parentDimension, explicitSiblingIndex: explicit }),
+    boundary: consolidationBoundary()
+  });
+  if (String(inspection.status || '') !== 'valid') return consolidationBlocked('qualified-parent-route-topology-invalid-for-consolidation');
+  const routes = [...(inspection.routes || [])];
+  if (!routes.length) return consolidationBlocked('qualified-parent-route-topology-empty-for-consolidation');
+
+  const topology = deriveHandoffSiblingAllocation({
+    parentInspection: inspection,
+    selectedRoutePointer: String(routes[0]?.pointerPath || ''),
+    parentPackagePath, parentPackageSha256, parentDimension
+  });
+  if (topology.state !== 'qualified') return consolidationBlocked(topology.reasonCode || 'qualified-parent-route-pointer-order-unresolved');
+  const routeCount = Number(topology.provenance?.qualifiedRouteCount || 0);
+  const siblingIndex = routeCount + 1;
+  if (!Number.isInteger(siblingIndex) || siblingIndex < 2 || siblingIndex > MAX_SIBLING_INDEX) return consolidationBlocked('derived-consolidation-sibling-index-out-of-range');
+  if (explicit && explicit !== siblingIndex) return consolidationBlocked('explicit-sibling-index-conflicts-with-qualified-consolidation-topology', { expectedSiblingIndex: siblingIndex });
+
+  return freeze({
+    state: 'qualified', siblingIndex,
+    childDimension: parentDimension ? `${String(parentDimension).trim()}-${siblingIndex}` : '',
+    allocationMode: 'qualified-parent-route-consolidation-ordinal',
+    explicitOverride: explicit ? 'matched-derived-value' : 'not-supplied',
+    reasonCode: '',
+    provenance: {
+      ...provenanceBase({ parentPackagePath, parentPackageSha256, parentDimension, explicitSiblingIndex: explicit }),
+      basis: 'qualified-parent-route-consolidation-ordinal',
+      qualifiedRouteCount: routeCount,
+      consolidationOrdinal: siblingIndex,
+      commonFrontierDimension: String(parentDimension || '').trim(),
+      pointerOrder: topology.provenance.pointerOrder
+    },
+    boundary: consolidationBoundary()
+  });
+
+  function consolidationBlocked(reasonCode, extra = {}) {
+    return freeze({
+      state: 'blocked', siblingIndex: null, allocationMode: 'blocked', reasonCode, ...extra,
+      provenance: provenanceBase({ parentPackagePath, parentPackageSha256, parentDimension, explicitSiblingIndex: explicit }),
+      boundary: consolidationBoundary()
+    });
+  }
+}
+
 export async function resolveHandoffSiblingAllocation(input = {}) {
-  const derived = deriveHandoffSiblingAllocation(input);
+  const consolidation = input.consolidation === true;
+  const derived = consolidation ? deriveHandoffConsolidationAllocation(input) : deriveHandoffSiblingAllocation(input);
   if (derived.state === 'qualified') return derived;
   if (derived.state === 'blocked') throw new Error(`portable.cli.handoff-carrier.sibling-allocation.${derived.reasonCode}`);
+  if (consolidation) throw new Error('portable.cli.handoff-carrier.sibling-allocation.qualified-parent-route-topology-required-for-consolidation');
   const explicit = normalizeSiblingIndex(input.explicitSiblingIndex ?? input.siblingIndex);
   if (!explicit) throw new Error('portable.cli.handoff-carrier.sibling-allocation.explicit-index-required-when-topology-unavailable');
   const legacy = await reserveHandoffSiblingIndex({
@@ -172,6 +224,7 @@ function provenanceBase({ parentPackagePath = '', parentPackageSha256 = '', pare
     explicitSiblingIndex: explicitSiblingIndex ? normalizeSiblingIndex(explicitSiblingIndex) : null
   };
 }
+function consolidationBoundary() { return 'Transport-only carrier consolidation allocation. The consolidation sibling is exactly N+1 for N qualified Handoff routes on the common pre-batch carrier frontier. It is never derived from one specialist return, arrival order, retries, output collisions, local allocation files or artifact Parent lineage; explicit Major stabilization remains separate.'; }
 function allocationBoundary() { return 'Transport-only carrier allocation. A non-Major sibling ordinal may come only from exact qualified package-local Handoff Pointer order for the selected parent route, or from an explicit advanced override when such topology is unavailable. Allocation never creates semantic Parent, Workspace, Role, acceptance, completion, participant, process, or source authority; different carrier prefixes are not coordinated.'; }
 function normalizeSiblingIndex(value) {
   if (value === null || value === undefined || value === '') return 0;

package/src/tooling/portable/adapters/cli/cli.help.js

@@ -63,9 +63,9 @@ function commonCommandHelp(command, surfaceCommand) {
     `${command} ground <handoff-package.zip> --route <Continue-from> [--holder-role <recipient-role>]`,
     `${command} ground <handoff-package.zip> --route <Continue-from> --holder-role <recipient-role> --continue <workspace-dir>`,
     '',
-    'Reads and qualifies the exact selected Handoff route. The default projection keeps readiness, recipient authority boundary, explicit consuming-session holder binding, Required Context closure, continuity/blockers, current Task identity, and exact next action compact; add `--full` for the full qualified receipt.',
+    'Reads and qualifies the exact selected Handoff route. The default projection keeps readiness, recipient authority boundary, consuming-session holder binding, Required Context closure, continuity/blockers, current Task identity, and exact next action compact; add `--full` for the full qualified receipt.',
     'Add `--include-required-context <requirement-id,name|all>` and/or `--include-current-work` only when exact body text is needed. `ground --continue` includes the bounded current Task body needed to proceed, retains Required Context counts and continuity/recovery state, and does not repeat qualified Required Context item paths or root-detail receipts unless explicitly requested (or `--full` is used).',
-    'For a Role recipient, `--holder-role <recipient-role>` is an explicit consuming-session Role-capacity binding; it is never inferred from route selection, provider identity, or assistant/user position. Without it, the holder remains unresolved and grounding stays discussion-only. After `grounded-to-act`, `--continue` materializes the selected carried Workspace into an empty local directory and writes runtime-only `.tiinex/continuation.json`. The grounding operation itself is non-mutating; downstream work authority comes from qualified Handoff/Task/Role artifacts, not from that operation-safety fact.',
+    'For a Role recipient, exact qualified consumption of the selected Handoff may establish the bounded consuming-session Role-capacity binding when the exact qualified recipient Role authorizes canonical Assignment Mode `handoff`. `--holder-role <recipient-role>` remains an explicit consuming-session assertion and must match the selected recipient; mismatches block and never fall back to Handoff assignment. No binding is inferred from package delivery, route orientation alone, provider identity, or assistant/user position. After `grounded-to-act`, `--continue` materializes the selected carried Workspace into an empty local directory and writes runtime-only `.tiinex/continuation.json`. The grounding operation itself is non-mutating; downstream work authority comes from qualified Handoff/Task/Role artifacts, not from that operation-safety fact.',
     '',
     `Advanced/internal catalog: ${command} operations`
   ];
@@ -83,7 +83,7 @@ function commonCommandHelp(command, surfaceCommand) {
     '',
     `${command} handoff <workspace-dir>`,
     '',
-    'Infers the latest qualified authored Handoff, selected Workspace identity/target, received package parent as carrier-lineage evidence, canonical projected filename, and return output directory. Ordinary non-Major continuation derives its sibling ordinal from the exact qualified selected Handoff Pointer order in the received parent carrier, so common-path `handoff` does not require `--package-sibling-index` or `--return-package-sibling-index`. A single selected Pointer derives `-1`; parallel qualified Pointers derive dense local ordinals in Pointer order, and each returned branch continues from its own carrier. `--package-sibling-index` remains an advanced compatibility override only when qualified route topology is unavailable, and must match when topology already proves the value; conflicting or ambiguous topology fails closed. `--return-package-major` remains the explicit Major-return declaration. Different carrier prefixes are never globally coordinated. Byte-identical duplicate transport at one exact output path is idempotent and divergent bytes fail closed. It does not implicitly carry sibling Workspaces from the received package; advanced manufacture must select exact reusable parent snapshots with `--package-parent-workspaces <id,...|all>`. Recovery/integration manufacture can bind the reconciled byte proof with `--require-reconciliation-proof --reconciliation-proof <full-reconcile-receipt.json>`; missing, non-ready, edited, or source-stale proof blocks package output. The default receipt keeps output identity, routing text, closure/workspace qualification, verification, and actionable findings compact; add `--full` for the complete manufacture receipt. Normal operator completion is exactly one Handoff package plus the adjacent exact routing text. In markdown-capable hosts render that routing in a fenced code block; do not emit canonical Workspace Evidence/Handoff markdown as additional loose transport files. Runtime-only `.tiinex` state is excluded from canonical manufacture.',
+    'Infers the latest qualified authored Handoff, selected Workspace identity/target, received package parent as carrier-lineage evidence, canonical projected filename, and return output directory. Ordinary non-Major continuation derives its sibling ordinal from the exact qualified selected Handoff Pointer order in the received parent carrier, so common-path `handoff` does not require `--package-sibling-index` or `--return-package-sibling-index`. A single selected Pointer derives `-1`; parallel qualified Pointers derive dense local ordinals in Pointer order, and each returned branch continues from its own carrier. Advanced manufacture may declare `--package-consolidation` against the common pre-batch parent carrier; with N qualified route Pointers it derives consolidation ordinal N+1 and rejects conflicting overrides or missing qualified common-frontier topology. `--package-sibling-index` remains an advanced compatibility override only when qualified route topology is unavailable for ordinary route returns, and must match when topology already proves the value; conflicting or ambiguous topology fails closed. `--return-package-major` remains the explicit Major-return declaration. Different carrier prefixes are never globally coordinated. Byte-identical duplicate transport at one exact output path is idempotent and divergent bytes fail closed. It does not implicitly carry sibling Workspaces from the received package; advanced manufacture must select exact reusable parent snapshots with `--package-parent-workspaces <id,...|all>`. Recovery/integration manufacture can bind the reconciled byte proof with `--require-reconciliation-proof --reconciliation-proof <full-reconcile-receipt.json>`; missing, non-ready, edited, or source-stale proof blocks package output. The default receipt keeps output identity, routing text, closure/workspace qualification, verification, and actionable findings compact; add `--full` for the complete manufacture receipt. Normal operator completion is exactly one Handoff package plus the adjacent exact routing text. In markdown-capable hosts render that routing in a fenced code block; do not emit canonical Workspace Evidence/Handoff markdown as additional loose transport files. Runtime-only `.tiinex` state is excluded from canonical manufacture.',
     '',
     `Advanced/internal catalog: ${command} operations`
   ];

package/src/tooling/portable/adapters/node/handoff.manufacture.js

@@ -181,7 +181,7 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
   const dependencyClosure = await expandPointerDependencyClosure({ requirements, materials, workspaceRuntimeById, bindings: input.materialBindings || {} });
   requirements = dependencyClosure.requirements;
   materials = appendMissingRequirementMaterials(dependencyClosure.materials, resolvePackageParentRequirementMaterials(requirements, packageParentExactMaterialProvider));
-  const routeParentBoundaryClosure = expandRouteParentBoundaryClosure({ requirements, materials, workspaceMaterializations, workspaceRuntimeById, routeSpecs });
+  const routeParentBoundaryClosure = expandRouteParentBoundaryClosure({ requirements, materials, workspaceMaterializations, workspaceRuntimeById, routeSpecs, exactMaterialProvider: packageParentExactMaterialProvider });
   requirements = routeParentBoundaryClosure.requirements;
   materials = appendMissingRequirementMaterials(routeParentBoundaryClosure.materials, resolvePackageParentRequirementMaterials(requirements, packageParentExactMaterialProvider));
   const parentBoundaryClosure = expandBoundedParentBoundaryClosure({ requirements, materials, workspaceMaterializations, workspaceRuntimeById });

package/src/tooling/portable/adapters/node/handoff.manufacture.scope.js

@@ -166,10 +166,9 @@ export function expandRouteParentBoundaryClosure(input = {}) {
       const visitKey = `${currentWorkspaceId}\0${currentPath}`;
       if (visited.has(visitKey)) break;
       visited.add(visitKey);
-      const runtime = input.workspaceRuntimeById?.get(currentWorkspaceId);
-      const currentEntry = runtime ? entryFromEnumeration(runtime.enumeration, currentPath) : null;
-      if (!currentEntry) break;
-      const markdown = decodeUtf8(currentEntry.data);
+      const currentSource = exactArtifactSource(input, materials, currentWorkspaceId, currentPath);
+      if (!currentSource) break;
+      const markdown = decodeUtf8(currentSource.data);
       if (!markdown) break;
       let parent;
       try { parent = parseArtifactMarkdown(markdown).envelope?.parent || {}; } catch { break; }
@@ -188,8 +187,7 @@ export function expandRouteParentBoundaryClosure(input = {}) {
       }
       if (!targetWorkspaceId || !targetPath) break;
 
-      const targetRuntime = input.workspaceRuntimeById?.get(targetWorkspaceId);
-      const targetEntry = targetRuntime ? entryFromEnumeration(targetRuntime.enumeration, targetPath) : null;
+      const targetSource = exactArtifactSource(input, materials, targetWorkspaceId, targetPath);
       const targetMaterialization = materializationByWorkspaceId.get(targetWorkspaceId);
       const targetAlreadyCarried = workspaceMaterializationIncludesPath(targetMaterialization, targetPath);
       const routeTargetKey = `${routeWorkspaceId}\0${routePath}\0${targetWorkspaceId}\0${targetPath}`;
@@ -217,10 +215,10 @@ export function expandRouteParentBoundaryClosure(input = {}) {
             fields: Object.freeze({ RouteWorkspace: routeWorkspaceId, RoutePath: routePath, SourceWorkspace: currentWorkspaceId, SourcePath: currentPath, TargetWorkspace: targetWorkspaceId, TargetPath: targetPath, Reference: reference })
           });
           dependencies.push(requirement);
-          if (targetEntry) materials.push(materialCandidateFromWorkspaceEntry(requirement, targetWorkspaceId, targetPath, targetEntry, targetRuntime.enumeration, targetRuntime));
+          if (targetSource) materials.push(materialCandidateFromExactArtifactSource(requirement, targetSource));
         }
       }
-      if (!targetEntry) break;
+      if (!targetSource) break;
       currentWorkspaceId = targetWorkspaceId;
       currentPath = targetPath;
     }
@@ -232,6 +230,81 @@ export function expandRouteParentBoundaryClosure(input = {}) {
   });
 }
 
+function exactArtifactSource(input = {}, materials = [], workspaceIdValue = '', targetPathValue = '') {
+  const workspaceId = String(workspaceIdValue || '').trim();
+  const targetPath = normalizeRelativePath(targetPathValue);
+  if (!workspaceId || !targetPath) return null;
+
+  // Explicit current/inherited Workspace providers retain precedence over detached cache
+  // material. This preserves the existing package-parent precedence boundary while allowing
+  // the exact same route traversal to continue when the next ancestor is cache-only.
+  const runtime = input.workspaceRuntimeById?.get(workspaceId);
+  const entry = runtime ? entryFromEnumeration(runtime.enumeration, targetPath) : null;
+  if (entry) return Object.freeze({
+    kind: 'workspace-entry', workspaceId, path: targetPath, data: entry.data, bytes: Number(entry.bytes || 0), sha256: String(entry.sha256 || ''),
+    mediaType: String(entry.mediaType || 'text/markdown'), entry, runtime
+  });
+
+  const candidates = [];
+  for (const material of materials || []) {
+    const provenance = material?.provenance || {};
+    const candidateWorkspaceId = String(provenance.workspaceId || material.workspaceId || material.targetWorkspaceId || '').trim();
+    const candidatePath = normalizeRelativePath(provenance.path || material.path || material.targetPath || '');
+    if (candidateWorkspaceId !== workspaceId || candidatePath !== targetPath || !material?.data) continue;
+    candidates.push(Object.freeze({
+      kind: 'qualified-material', workspaceId, path: targetPath, data: material.data, bytes: Number(material.bytes || 0), sha256: String(material.sha256 || ''),
+      mediaType: String(material.mediaType || 'text/markdown'), providerId: String(material.providerId || ''), providerKind: String(material.providerKind || ''),
+      provenance: Object.freeze({ ...provenance }), authority: Object.freeze({ ...(material.authority || {}) })
+    }));
+  }
+  for (const material of input.exactMaterialProvider?.entries || []) {
+    const provenance = material?.provenance || {};
+    const candidateWorkspaceId = String(provenance.workspaceId || '').trim();
+    const candidatePath = normalizeRelativePath(provenance.path || '');
+    if (candidateWorkspaceId !== workspaceId || candidatePath !== targetPath || !material?.data) continue;
+    candidates.push(Object.freeze({
+      kind: 'qualified-material', workspaceId, path: targetPath, data: material.data, bytes: Number(material.bytes || 0), sha256: String(material.sha256 || ''),
+      mediaType: String(material.mediaType || 'text/markdown'), providerId: String(material.providerId || 'qualified-package-parent-exact-material'),
+      providerKind: String(material.providerKind || 'qualified-package-parent-cache-material'), provenance: Object.freeze({ ...provenance }),
+      authority: Object.freeze({ packageParentMaterialQualified: true, semanticAuthority: 'none', sourceSelectionAuthority: false })
+    }));
+  }
+  if (!candidates.length) return null;
+  const digests = [...new Set(candidates.map((candidate) => String(candidate.sha256 || '')).filter(Boolean))];
+  if (digests.length !== 1) return null;
+  return candidates.find((candidate) => candidate.sha256 === digests[0]) || null;
+}
+
+function materialCandidateFromExactArtifactSource(requirement = {}, source = {}) {
+  if (source.kind === 'workspace-entry') {
+    return materialCandidateFromWorkspaceEntry(requirement, source.workspaceId, source.path, source.entry, source.runtime.enumeration, source.runtime);
+  }
+  return Object.freeze({
+    requirementId: String(requirement.id || ''),
+    referenceTarget: String(requirement.reference?.target || requirement.referenceTarget || ''),
+    path: String(source.path || ''),
+    data: source.data,
+    bytes: Number(source.bytes || 0),
+    sha256: String(source.sha256 || ''),
+    mediaType: String(source.mediaType || 'text/markdown'),
+    providerId: String(source.providerId || 'qualified-exact-material'),
+    providerKind: String(source.providerKind || 'qualified-exact-material'),
+    provenance: Object.freeze({
+      ...(source.provenance || {}),
+      workspaceId: String(source.workspaceId || source.provenance?.workspaceId || ''),
+      path: String(source.path || source.provenance?.path || ''),
+      reboundRequirementId: String(requirement.id || ''),
+      reboundClassification: String(requirement.classification || '')
+    }),
+    authority: Object.freeze({
+      ...(source.authority || {}),
+      localIdentityQualified: true,
+      semanticAuthority: 'none',
+      sourceSelectionAuthority: false
+    })
+  });
+}
+
 function workspaceMaterializationIncludesPath(materialization = null, targetPath = '') {
   if (!materialization) return false;
   const state = String(materialization.state || materialization.materialization || '');

package/src/tooling/portable/draft/draft.exact.js

@@ -16,6 +16,7 @@ export function normalizePortableParentRecord(parent = {}) {
     boundary: String(parent.boundary || parent.source?.boundary || ''),
     sourceMode: String(parent.sourceMode || ''),
     recoveryMode: String(parent.recoveryMode || parent.parentRecoveryMode || ''),
+    relativeReference: String(parent.relativeReference || ''),
     source: parent.source || null,
     markdown: String(parent.markdown || ''),
     integrity: parent.integrity || null,
@@ -108,11 +109,14 @@ export function qualifyPortableRenderedParentRepresentation(markdown = '', paren
   const observed = parsed.envelope?.parent || {};
   const hasObserved = Boolean(observed.schema?.id || observed.trace || observed.origin || observed.createdAt || observed.boundary || observed.originEntries?.length);
   if (rootCreation) return Object.freeze({ state: hasObserved ? 'invalid' : 'qualified', reason: hasObserved ? 'exact-result-parent-unexpected' : '' });
-  const relative = relativePath(dirname(childPath), parent.path);
   const published = parent.publishedReference || {};
   const publishedTarget = String(published.target || '');
   const publishedQualified = Boolean(publishedTarget && published.state === 'qualified');
-  const recoveryMode = String(parent.recoveryMode || '').trim() === 'external-versioned' ? 'external-versioned' : 'local-relative';
+  const declaredRecoveryMode = String(parent.recoveryMode || '').trim();
+  const recoveryMode = declaredRecoveryMode === 'external-versioned' ? 'external-versioned' : declaredRecoveryMode === 'workspace-qualified' ? 'workspace-qualified' : 'local-relative';
+  const relative = recoveryMode === 'workspace-qualified'
+    ? String(parent.relativeReference || parent.path || '')
+    : relativePath(dirname(childPath), parent.path);
   const schemaTarget = String(parent.schemaReferenceAuthority?.preferredTarget || '');
   const origins = observed.originEntries || [];
   const createdAtLines = renderedParentFieldLines(markdown, 'Created At');

package/src/tooling/portable/editor/authoring.parent.js

@@ -1,5 +1,7 @@
 import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
 import { auditPortableRecord } from '../audit/audit.capability.js';
+import { classifyParentRecoveryReference } from '../../../lineage/parentRecoveryReference.js';
+import { buildArtifactCreationContract } from '../../../schemas/creation.contracts.js';
 
 export const PORTABLE_AUTHORING_PARENT_SCHEMA_ID = 'tiinex.portable.authoring-parent.v1';
 
@@ -15,13 +17,24 @@ export function projectPortableAuthoringParent(input = {}) {
   const schemaId = String(parsed.envelope?.current?.schema?.id || audit.schemaId || '');
   const schemaTarget = String(parsed.envelope?.current?.schema?.target || '');
   const createdAt = String(parsed.envelope?.current?.createdAt || audit.artifact?.createdAt || '');
+  const explicitReference = String(input.reference || '').trim();
+  const projectedPath = explicitReference || String(record.path || record.id || '');
+  const referenceClassification = classifyParentRecoveryReference(projectedPath);
+  if (referenceClassification.kind === 'malformed-workspace-qualified') return freeze({ schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID, status: 'blocked', parentRecord: null, findings: [{ severity: 'error', code: 'portable.authoring-parent.reference.malformed', message: 'Selected Parent reference is malformed and cannot be used for native authoring.' }], operationBoundary: boundary() });
+  const recoveryMode = referenceClassification.kind === 'workspace-qualified' ? 'workspace-qualified' : 'local-relative';
+  const canonicalCurrent = buildArtifactCreationContract({ schemaId, transitionType: 'continue-from-record' })?.schemaReferences?.current || null;
+  const canonicalTargets = new Set([...(canonicalCurrent?.exactTargets || []), String(canonicalCurrent?.preferredTarget || '')].filter(Boolean));
+  const schemaReferenceQualified = Boolean(schemaTarget && canonicalCurrent?.resolutionState === 'qualified' && canonicalTargets.has(schemaTarget));
+  const schemaReferenceAuthority = schemaReferenceQualified
+    ? { ...canonicalCurrent, preferredTarget: schemaTarget, resolutionState: 'qualified', resolutionEvidence: { ...(canonicalCurrent?.resolutionEvidence || {}), basis: 'declared-parent-target-exact-canonical-match' } }
+    : { schemaId, preferredTarget: schemaTarget, exactTargets: schemaTarget ? [schemaTarget] : [], resolutionState: 'unresolved', evidence: { basis: 'declared-current-schema-reference-only' } };
   return freeze({
     schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID,
     status: 'ready',
     parentRecord: {
-      id: String(record.path || record.id || ''), path: String(record.path || record.id || ''), schemaId, currentSchemaId: schemaId, currentCreatedAt: createdAt,
+      id: projectedPath, path: projectedPath, schemaId, currentSchemaId: schemaId, currentCreatedAt: createdAt, createdAt, recoveryMode, relativeReference: recoveryMode === 'workspace-qualified' ? projectedPath : '',
       markdown: record.markdown, sourceMode: String(record.sourceMode || 'portable-node-local'),
-      schemaReferenceAuthority: { schemaId, preferredTarget: schemaTarget, exactTargets: schemaTarget ? [schemaTarget] : [], resolutionState: 'unresolved', evidence: { basis: 'declared-current-schema-reference-only' } }
+      schemaReferenceAuthority
     },
     findings: [],
     operationBoundary: boundary(),

package/src/tooling/portable/grounding/grounding.participantAuthority.js

@@ -14,7 +14,7 @@ export function projectParticipantAuthority(authority = null) {
     participantIdentityCreatesAuthority: false,
     conversationPositionCreatesAuthority: false,
     universalHumanFeedbackRule: false,
-    boundary: 'Qualified Role material plus explicit holder binding is the basis. Identity/chat position alone create no authority; no universal human-input-as-feedback rule is imposed.'
+    boundary: 'Qualified Role material plus a qualified holder binding is the basis; that binding may be explicit or may come from exact qualified selected-Handoff consumption when the Role authorizes `handoff`. Identity/chat position alone create no authority; no universal human-input-as-feedback rule is imposed.'
   });
 }
 function compact(value = '', limit = 180) { const text = String(value || '').replace(/\s+/g, ' ').trim(); return text.length > limit ? `${text.slice(0, limit - 1).trimEnd()}…` : text; }

package/src/tooling/portable/grounding/grounding.readiness.authority.js

@@ -55,12 +55,18 @@ export function projectGroundingAuthority(authority, mode) {
       explicit: Boolean(authority.holderBinding.explicit),
       inferredFromTransport: Boolean(authority.holderBinding.inferredFromTransport),
       provenance: Object.freeze({
-        basis: authority.holderBinding.explicit ? 'explicit-consuming-session-holder-binding' : 'unresolved-or-non-explicit-holder-binding',
+        basis: authority.holderBinding.explicit ? 'explicit-consuming-session-holder-binding' : (authority.holderBinding.source === 'qualified-selected-handoff-consumption' && String(authority.holderBinding.state || '') === 'qualified' ? 'qualified-selected-handoff-consumption-binding' : 'unresolved-or-non-explicit-holder-binding'),
         source: authority.holderBinding.source || '',
         sourceKind: authority.holderBinding.sourceDetail?.kind || '',
         sourceLocator: authority.holderBinding.sourceDetail?.locator || '',
         semanticAuthorityState: authority.holderBinding.sourceDetail?.semanticAuthorityState || 'not-established',
         qualifiedMaterialSource: Boolean(authority.holderBinding.sourceDetail?.qualifiedMaterialSource),
+        assignmentMode: authority.holderBinding.assertionMode || authority.holderBinding.authorization?.assignmentMode || '',
+        routePointerPath: authority.holderBinding.sourceDetail?.routePointerPath || '',
+        handoffArtifactPath: authority.holderBinding.sourceDetail?.handoffArtifactPath || '',
+        handoffArtifactSha256: authority.holderBinding.sourceDetail?.handoffArtifactSha256 || '',
+        roleArtifactPath: authority.holderBinding.sourceDetail?.roleArtifactPath || authority.holderBinding.authorization?.provenance?.roleArtifactPath || '',
+        roleArtifactSha256: authority.holderBinding.sourceDetail?.roleArtifactSha256 || authority.holderBinding.authorization?.provenance?.roleArtifactSha256 || '',
         authorizationState: authority.holderBinding.authorization?.state || 'unresolved',
         authorizationBasis: authority.holderBinding.authorization?.provenance?.basis || '',
         boundary: authority.holderBinding.boundary || 'Consuming-session holder identity is never inferred from route transport or recipient position.'

package/src/tooling/portable/grounding/grounding.readiness.js

@@ -129,7 +129,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
     } else {
       holderBindingActReady = false;
       unresolved.push(evidence('session-holder-role-binding', 'unresolved', `recipient Role ${authority?.role?.endpoint?.label || authority?.handoff?.to || 'recipient'} is qualified separately from the consuming session`));
-      reasons.push(reason('session-holder-role-binding-unresolved', 'The selected recipient Role does not assign itself to this consuming session. Supply an explicit matching session holder Role binding before act-ready continuation.'));
+      reasons.push(reason('session-holder-role-binding-unresolved', 'The selected recipient Role is not yet bound to this consuming session. Exact qualified selected-Handoff consumption may bind it only when the exact recipient Role authorizes Assignment Mode `handoff`; otherwise supply an explicit matching session holder Role binding authorized by that Role.'));
     }
 
     if (holderState === 'not-applicable') {
@@ -142,7 +142,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
       } else {
         holderBindingActReady = false;
         unresolved.push(evidence('session-holder-role-binding-authorization', holderAuthorizationState || 'unresolved', authority?.holderBinding?.authorization?.reasonCode || 'exact qualified canonical assignment-mode authority does not authorize the asserted binding mechanism'));
-        reasons.push(reason('session-holder-role-binding-authorization-unresolved', 'The explicit consuming-session Role assertion matches the selected recipient Role, but exact qualified canonical assignment-mode authority does not authorize the asserted mechanism. Matching session input alone cannot make the route act-ready.'));
+        reasons.push(reason('session-holder-role-binding-authorization-unresolved', 'The consuming-session Role binding matches the selected recipient Role, but exact qualified canonical assignment-mode authority does not authorize the asserted mechanism. Matching session input or Handoff selection alone cannot make the route act-ready.'));
       }
     }
 
@@ -368,12 +368,12 @@ function projectCurrentWork(topology = {}, records = [], includeCurrentWork = fa
 }
 
 function nextActionFor(state, topology, continuity = {}, authority = null) {
-  if (state === 'grounded-to-act') return Object.freeze({ kind: 'continue-bounded-handoff-work', target: topology.currentFrontier[0]?.path || '', basis: 'qualified authority + explicit session holder Role binding + exact qualified holder-assignment authorization when Role-recipient + required context + cold-start root continuity + selected-route Parent leaf + declared current-work frontier' });
-  if (state === 'grounded-to-discuss' && String(authority?.holderBinding?.state || 'unresolved') === 'unresolved') return Object.freeze({ kind: 'declare-explicit-session-holder-role-binding', target: authority?.role?.endpoint?.label || authority?.handoff?.to || '', basis: 'recipient Role qualification is separate from consuming-session holder binding; no transport/provider/assistant-user identity inference is permitted' });
+  if (state === 'grounded-to-act') return Object.freeze({ kind: 'continue-bounded-handoff-work', target: topology.currentFrontier[0]?.path || '', basis: 'qualified authority + qualified session holder Role binding (explicit or exact selected-Handoff consumption) + exact qualified holder-assignment authorization when Role-recipient + required context + cold-start root continuity + selected-route Parent leaf + declared current-work frontier' });
+  if (state === 'grounded-to-discuss' && String(authority?.holderBinding?.state || 'unresolved') === 'unresolved') return Object.freeze({ kind: 'establish-session-holder-role-binding', target: authority?.role?.endpoint?.label || authority?.handoff?.to || '', basis: 'recipient Role qualification is separate from consuming-session holder binding; exact qualified selected-Handoff consumption may establish `handoff` assignment when authorized, otherwise an explicit authorized binding is required; no transport/provider/assistant-user identity inference is permitted' });
   if (state === 'grounded-to-discuss' && String(authority?.holderBinding?.state || '') === 'qualified' && String(authority?.holderBinding?.authorization?.state || 'unresolved') !== 'qualified') return Object.freeze({
     kind: 'resolve-session-holder-binding-authorization',
     target: authority?.holderBinding?.authorization?.provenance?.roleArtifactPath || authority?.role?.endpoint?.label || authority?.handoff?.to || '',
-    basis: 'a matching explicit session Role assertion is not semantic authorization; exact qualified recipient Role Holder Relationship authority must establish the assignment mode'
+    basis: 'a matching session Role binding is not semantic authorization by itself; exact qualified recipient Role Holder Relationship authority must establish the selected assignment mode'
   });
   if (state === 'grounded-to-discuss') return Object.freeze({ kind: topology.currentFrontier.length ? 'obtain-bounded-action-authority-or-human-gate' : 'resolve-current-work-frontier', target: topology.currentTasks[0]?.path || '', basis: 'discussion-ready but act-readiness condition is unresolved' });
   if (continuity?.state === 'unproven') return Object.freeze({

package/src/tooling/portable/handoff/carrierProjection.routeQualification.js

@@ -129,10 +129,22 @@ function resolveDescriptorMaterial(bundle, descriptor, byteProvider, target = ''
   const expectedRouteWorkspaceId = String(routeWorkspaceId || '');
   const expectedRoutePath = normalizeWorkspacePath(routePath || '');
   const matches = (descriptor.materialized || []).filter((entry) => {
-    if (expectedRequirementId && String(entry.requirementId || '') !== expectedRequirementId) return false;
+    const entryRequirementId = String(entry.requirementId || '');
+    const entrySourceRequirementId = String(entry.sourceRequirementId || '');
+    const entryRouteWorkspaceId = String(entry.routeWorkspaceId || '');
+    const entryRoutePath = normalizeWorkspacePath(entry.routePath || '');
+    const exactRequirementMatch = !expectedRequirementId || entryRequirementId === expectedRequirementId;
+    const routeScopedSourceMatch = Boolean(
+      expectedRequirementId &&
+      entrySourceRequirementId === expectedRequirementId &&
+      expectedRouteWorkspaceId && expectedRoutePath &&
+      entryRouteWorkspaceId === expectedRouteWorkspaceId &&
+      entryRoutePath === expectedRoutePath
+    );
+    if (expectedRequirementId && !exactRequirementMatch && !routeScopedSourceMatch) return false;
     if (expectedTarget && String(entry.referenceTarget || '') !== expectedTarget) return false;
-    if (expectedRouteWorkspaceId && entry.routeWorkspaceId && String(entry.routeWorkspaceId || '') !== expectedRouteWorkspaceId) return false;
-    if (expectedRoutePath && entry.routePath && normalizeWorkspacePath(entry.routePath || '') !== expectedRoutePath) return false;
+    if (expectedRouteWorkspaceId && entryRouteWorkspaceId && entryRouteWorkspaceId !== expectedRouteWorkspaceId) return false;
+    if (expectedRoutePath && entryRoutePath && entryRoutePath !== expectedRoutePath) return false;
     return Boolean(expectedTarget || expectedRequirementId);
   });
   const byRepresentation = new Map();

package/src/tooling/portable/handoff/coldStartQualification.grounding.js

@@ -247,82 +247,110 @@ function groundHolderBinding(input, handoff, role, findings) {
   const recipientRoleKind = normalizeToken(handoff.toKind || (recipientRoleLabel ? 'role' : ''));
   const roleRecipient = recipientRoleKind === 'role';
   const explicitlySupplied = Boolean(roleLabel || holderId);
-  const sourceDetail = holderBindingSourceDetail(input, explicit, explicitlySupplied);
-  const assertionMode = String(explicit.assignmentMode || explicit.bindingMode || explicit.mechanism || input.holderAssignmentMode || input.sessionAssignmentMode || 'explicit-session').trim();
-  const authorization = projectHolderBindingAuthorization(role, { assertionMode });
   const durableIdentity = holderDurableIdentityProjection(holderId);
 
-  if (!roleRecipient) return deepFreeze({
-    state: 'not-applicable',
-    holderId,
-    assertionMode,
-    roleLabel,
-    recipientRoleLabel,
-    recipientCompatibility: 'not-applicable',
-    source: explicitlySupplied ? 'explicit-input' : 'none',
-    sourceDetail,
-    authorization,
-    durableIdentity,
-    explicit: explicitlySupplied,
-    inferredFromTransport: false,
-    boundary: 'The selected Handoff recipient is not a Role endpoint, so no consuming-session Role holder binding is required or inferred.'
-  });
+  if (!roleRecipient) {
+    const assertionMode = String(explicit.assignmentMode || explicit.bindingMode || explicit.mechanism || input.holderAssignmentMode || input.sessionAssignmentMode || 'explicit-session').trim();
+    const sourceDetail = holderBindingSourceDetail(input, explicit, explicitlySupplied);
+    const authorization = projectHolderBindingAuthorization(role, { assertionMode });
+    return deepFreeze({
+      state: 'not-applicable', holderId, assertionMode, roleLabel, recipientRoleLabel,
+      recipientCompatibility: 'not-applicable', source: explicitlySupplied ? 'explicit-input' : 'none', sourceDetail,
+      authorization, durableIdentity, explicit: explicitlySupplied, inferredFromTransport: false,
+      boundary: 'The selected Handoff recipient is not a Role endpoint, so no consuming-session Role holder binding is required or inferred.'
+    });
+  }
+
+  if (!explicitlySupplied) {
+    const assertionMode = 'handoff';
+    const authorization = projectHolderBindingAuthorization(role, { assertionMode });
+    const exactHandoff = exactSelectedHandoffAssignmentEvidence(handoff, role);
+    const sourceDetail = handoffHolderBindingSourceDetail(handoff, role, exactHandoff, authorization);
+    if (exactHandoff && authorization.state === 'qualified') return deepFreeze({
+      state: 'qualified', holderId: '', assertionMode, roleLabel: recipientRoleLabel, recipientRoleLabel,
+      recipientCompatibility: 'matched', source: 'qualified-selected-handoff-consumption', sourceDetail,
+      authorization, durableIdentity, explicit: false, inferredFromTransport: false,
+      boundary: 'Qualified consumption of the exact selected Handoff binds this bounded Tooling session to its exact recipient Role only because that exact qualified Role authorizes the canonical `handoff` assignment mode. Package delivery, route position, provider/chat identity and Role inventory alone do not bind a holder; durable identity and broader semantic authority remain unestablished.'
+    });
+    return deepFreeze({
+      state: 'unresolved', holderId: '', assertionMode, roleLabel: '', recipientRoleLabel,
+      recipientCompatibility: 'unresolved', source: exactHandoff ? 'qualified-selected-handoff-consumption' : 'none', sourceDetail,
+      authorization, durableIdentity, explicit: false, inferredFromTransport: false,
+      boundary: 'No explicit holder declaration was supplied, and bounded Handoff assignment can qualify only from the exact selected qualified Handoff plus exact recipient Role material that directly authorizes the canonical `handoff` mode. Transport delivery, endpoint naming, cached Role inventory and assistant/user position are insufficient.'
+    });
+  }
+
+  const sourceDetail = holderBindingSourceDetail(input, explicit, true);
+  const assertionMode = String(explicit.assignmentMode || explicit.bindingMode || explicit.mechanism || input.holderAssignmentMode || input.sessionAssignmentMode || 'explicit-session').trim();
+  const authorization = projectHolderBindingAuthorization(role, { assertionMode });
 
   if (!roleLabel) {
     if (holderId) findings.push(portableFinding('warning', 'portable.cold-start.holder-binding.role-missing', 'A consuming-session holder identifier was supplied without an explicit Role capacity; the holder binding remains unresolved.', { holderId, recipientRole: recipientRoleLabel }));
     return deepFreeze({
-      state: 'unresolved',
-      holderId,
-      assertionMode,
-      roleLabel: '',
-      recipientRoleLabel,
-      recipientCompatibility: 'unresolved',
-      source: explicitlySupplied ? 'explicit-input' : 'none',
-      sourceDetail,
-      authorization,
-      durableIdentity,
-      explicit: explicitlySupplied,
-      inferredFromTransport: false,
-      boundary: 'Recipient Role and consuming-session holder are separate. No holder Role is inferred from route selection, transport identity, provider identity, assistant/user position, or participant declarations.'
+      state: 'unresolved', holderId, assertionMode, roleLabel: '', recipientRoleLabel,
+      recipientCompatibility: 'unresolved', source: 'explicit-input', sourceDetail, authorization, durableIdentity,
+      explicit: true, inferredFromTransport: false,
+      boundary: 'A partial explicit holder declaration is not completed from the Handoff path. Explicit-session and Handoff assignment remain mode-isolated.'
     });
   }
 
   if (recipientRoleLabel && normalizeComparable(roleLabel) !== normalizeComparable(recipientRoleLabel)) {
     findings.push(portableFinding('error', 'portable.cold-start.holder-binding.role-mismatch', 'Explicit consuming-session holder Role does not match the selected Handoff recipient Role.', { holderRole: roleLabel, recipientRole: recipientRoleLabel }));
     return deepFreeze({
-      state: 'blocked',
-      holderId,
-      assertionMode,
-      roleLabel,
-      recipientRoleLabel,
-      recipientCompatibility: 'mismatch',
-      source: 'explicit-input',
-      sourceDetail,
-      authorization,
-      durableIdentity,
-      explicit: true,
-      inferredFromTransport: false,
-      boundary: 'An explicit holder Role mismatch is contradictory and blocks act-ready grounding. Tooling does not relabel the session to make the route fit.'
+      state: 'blocked', holderId, assertionMode, roleLabel, recipientRoleLabel,
+      recipientCompatibility: 'mismatch', source: 'explicit-input', sourceDetail, authorization, durableIdentity,
+      explicit: true, inferredFromTransport: false,
+      boundary: 'An explicit holder Role mismatch is contradictory and blocks act-ready grounding. Tooling does not relabel the session or fall back to Handoff assignment to make the route fit.'
     });
   }
 
   return deepFreeze({
-    state: 'qualified',
-    holderId,
-    assertionMode,
-    roleLabel,
-    recipientRoleLabel,
-    recipientCompatibility: 'matched',
-    source: 'explicit-input',
-    sourceDetail,
-    authorization,
-    durableIdentity,
-    explicit: true,
-    inferredFromTransport: false,
+    state: 'qualified', holderId, assertionMode, roleLabel, recipientRoleLabel,
+    recipientCompatibility: 'matched', source: 'explicit-input', sourceDetail, authorization, durableIdentity,
+    explicit: true, inferredFromTransport: false,
     boundary: 'Explicit consuming-session Role-capacity binding only. This binds the current Tooling invocation/session to the selected recipient Role capacity; it does not prove a human identity, consent, or authority beyond the qualified Handoff/Role/Task boundaries.'
   });
 }
 
+function exactSelectedHandoffAssignmentEvidence(handoff = {}, role = {}) {
+  const artifact = role?.material?.artifact || {};
+  return String(handoff.schemaId || '') === 'tiinex.handoff.v1'
+    && Boolean(String(handoff.routeId || '').trim())
+    && Boolean(String(handoff.routePointerPath || '').trim())
+    && Boolean(String(handoff.workspaceRelativePath || '').trim())
+    && /^[0-9a-f]{64}$/i.test(String(handoff.sha256 || ''))
+    && String(role?.state || '') === 'qualified'
+    && String(role?.material?.state || '') === 'qualified'
+    && Boolean(String(artifact.path || '').trim())
+    && /^[0-9a-f]{64}$/i.test(String(artifact.sha256 || ''));
+}
+
+function handoffHolderBindingSourceDetail(handoff = {}, role = {}, exactHandoff = false, authorization = {}) {
+  const artifact = role?.material?.artifact || {};
+  const qualified = exactHandoff && String(authorization?.state || '') === 'qualified';
+  return deepFreeze({
+    kind: exactHandoff ? 'qualified-selected-handoff-consumption' : 'none',
+    locator: exactHandoff ? String(handoff.routePointerPath || handoff.workspaceRelativePath || '') : '',
+    authorityClass: exactHandoff ? 'selected-handoff-assignment-evidence' : 'none',
+    semanticAuthorityState: qualified ? 'qualified-bounded-handoff-assignment' : 'not-established',
+    qualifiedMaterialSource: Boolean(exactHandoff),
+    assignmentMode: 'handoff',
+    routeId: String(handoff.routeId || ''),
+    routePointerPath: String(handoff.routePointerPath || ''),
+    handoffArtifactPath: String(handoff.workspaceRelativePath || ''),
+    handoffArtifactSha256: String(handoff.sha256 || ''),
+    roleArtifactPath: String(artifact.path || ''),
+    roleArtifactSha256: String(artifact.sha256 || ''),
+    roleSchemaId: String(artifact.schemaId || ''),
+    roleLabel: String(artifact.roleLabel || role?.endpoint?.label || ''),
+    authorizationState: String(authorization?.state || 'unresolved'),
+    authorizationBasis: String(authorization?.provenance?.basis || ''),
+    boundary: exactHandoff
+      ? 'Exact selected qualified Handoff consumption plus exact qualified recipient Role material are the bounded assignment evidence. This is semantic Handoff/Role evidence, not package-delivery, provider, model, chat-position, filename or neighboring-route inference.'
+      : 'Exact selected Handoff/Role assignment evidence is not established; no Handoff-mode holder binding is projected.'
+  });
+}
+
 function holderDurableIdentityProjection(holderId = '') {
   return deepFreeze({
     state: 'not-established',

package/src/tooling/portable/handoff/coldStartQualification.materials.js

@@ -390,6 +390,7 @@ export function parseHandoffGrounding(markdown, route) {
       returnTo: sectionField(completion, 'Return To')
     }),
     routeId: String(route?.id || ''),
+    routePointerPath: String(route?.pointerPath || ''),
     workspaceId: String(route?.workspaceId || ''),
     workspaceRelativePath: String(route?.workspaceRelativeHandoffPath || route?.workspaceRelativePath || ''),
     packagePath: String(route?.packagePath || ''),
@@ -405,7 +406,7 @@ function markdownReferenceTarget(value = '') {
 }
 
 export function emptyHandoffGrounding() {
-  return deepFreeze({ schemaId: '', purpose: '', from: '', fromKind: '', fromReference: '', to: '', toKind: '', toReference: '', transfers: Object.freeze([]), retainedResponsibilities: Object.freeze([]), completionExpectation: Object.freeze({ signalKind: '', signalMeaning: '', returnTo: '' }), routeId: '', workspaceId: '', workspaceRelativePath: '', packagePath: '', sha256: '', boundary: 'No Handoff material supplied.' });
+  return deepFreeze({ schemaId: '', purpose: '', from: '', fromKind: '', fromReference: '', to: '', toKind: '', toReference: '', transfers: Object.freeze([]), retainedResponsibilities: Object.freeze([]), completionExpectation: Object.freeze({ signalKind: '', signalMeaning: '', returnTo: '' }), routeId: '', routePointerPath: '', workspaceId: '', workspaceRelativePath: '', packagePath: '', sha256: '', boundary: 'No Handoff material supplied.' });
 }
 
 export function resolveGroundingRouteMarkdown(bundle = {}, selectedRoute = {}, findings = [], context = null) {

package/src/tooling/portable/handoff/recipientV2.endpointRolePointers.js

@@ -8,7 +8,7 @@ export function buildEndpointRolePointerChain(input = {}) {
   const findings = [];
   let lineageParent = input.lineageParent || null;
   let nextDimension = String(input.nextDimension || '');
-  for (const requirement of input.requirements || []) {
+  for (const requirement of orderedEndpointRequirements(input.requirements || [])) {
     const target = input.resolveRoleMaterialTarget(requirement, input.descriptor, input.workspaceById, input.cache, input.route);
     if (target.state !== 'qualified') {
       findings.push(finding('error', `portable.handoff-v2-surface.endpoint-role.${target.reason || 'unresolved'}`, 'Endpoint Role requirement did not resolve to one exact carried Workspace/cache representation.', { routeId: String(input.route?.id || ''), requirementId: String(requirement.id || '') }));
@@ -175,5 +175,18 @@ export function buildParticipantRolePointerChain(input = {}) {
   });
 }
 
+function orderedEndpointRequirements(requirements = []) {
+  return [...requirements].map((item, index) => ({ item, index })).sort((a, b) => {
+    const rank = (entry) => {
+      const party = String(entry?.party || entry?.fields?.Side || '').trim().toLowerCase();
+      if (party === 'from') return 0;
+      if (party === 'to') return 1;
+      return 2;
+    };
+    const delta = rank(a.item) - rank(b.item);
+    return delta || a.index - b.index;
+  }).map(({ item }) => item);
+}
+
 function safeToken(value = '') { return String(value || '').trim().toLowerCase().normalize('NFKD').replace(/[\u0300-\u036f]/g, '').replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80) || 'workspace'; }
 function finding(severity, code, message, extra = {}) { return Object.freeze({ severity, code, message, ...extra }); }

package/src/tooling/portable/handoff/recipientV2.inspect.projection.js

@@ -5,7 +5,7 @@ export function projectRecipientV2Routes(routePointers = [], endpointPointers =
     const qualified = (qualifiedRoutes || []).find((route) => String(route.workspaceId || '') === String(item.facts?.workspaceId || '') && String(route.workspaceRelativePath || '') === String(item.facts?.workspaceRelativeHandoffPath || '')) || null;
     return Object.freeze({
     pointerPath: item.path,
-    routeId: String(item.facts?.routeId || qualified?.id || ''),
+    routeId: String(item.facts?.routeId || ''),
     workspaceId: String(item.facts?.workspaceId || ''),
     workspaceRelativeHandoffPath: String(item.facts?.workspaceRelativeHandoffPath || ''),
     returnCarrierReservation: item.facts?.returnCarrierReservation || qualified?.returnCarrierReservation || null,

package/src/tooling/portable/handoff/recipientV2.packageV1.build.js

@@ -163,10 +163,10 @@ function buildRecipientFacingV2PackageV1Prepared(input = {}, sealedByWorkspaceId
     const binding = bindingForWorkspace(descriptor, owningWorkspace.workspaceId);
     let lineageParent = cache?.parent || owningWorkspace.parent;
     let nextDimension = cache ? `${plan.prefix}-1-1` : `${plan.prefix}-1`;
-    const endpointChain = buildEndpointRolePointerChain({ requirements: route.materialRequirements?.endpointRoles || [], descriptor, workspaceById, cache, workspace: owningWorkspace, route, createdAt, lineageParent, nextDimension, resolveRoleMaterialTarget: roleMaterialTarget, parentAuthority: recipientV2ParentAuthority });
-    files.push(...endpointChain.files); topology.endpointRoles.push(...endpointChain.roles); findings.push(...endpointChain.findings); lineageParent = endpointChain.lineageParent; nextDimension = endpointChain.nextDimension;
     const participantChain = buildParticipantRolePointerChain({ requirements: route.materialRequirements?.participantRoles || [], descriptor, workspaceById, cache, workspace: owningWorkspace, route, createdAt, lineageParent, nextDimension, resolveRoleMaterialTarget: roleMaterialTarget, parentAuthority: recipientV2ParentAuthority });
     files.push(...participantChain.files); topology.participantRoles.push(...participantChain.roles); findings.push(...participantChain.findings); lineageParent = participantChain.lineageParent; nextDimension = participantChain.nextDimension;
+    const endpointChain = buildEndpointRolePointerChain({ requirements: route.materialRequirements?.endpointRoles || [], descriptor, workspaceById, cache, workspace: owningWorkspace, route, createdAt, lineageParent, nextDimension, resolveRoleMaterialTarget: roleMaterialTarget, parentAuthority: recipientV2ParentAuthority });
+    files.push(...endpointChain.files); topology.endpointRoles.push(...endpointChain.roles); findings.push(...endpointChain.findings); lineageParent = endpointChain.lineageParent; nextDimension = endpointChain.nextDimension;
     const pointerPath = `${nextDimension}-handoff-pointer.trace.md`;
     const routeEntry = (binding?.entryMap?.entries || []).find((entry) => String(entry.path || '') === String(route.workspaceRelativePath || ''));
     const pointerFacts = {

package/src/tooling/portable/handoff/recipientV2.topology.js

@@ -183,8 +183,8 @@ function buildRecipientFacingV2TopologyLegacy(input = {}) {
     const routeDimension = cache ? `001-${plan.workspace.ordinal}-1-${plan.ordinal}` : `001-${plan.workspace.ordinal}-${plan.ordinal}`;
     let lineageParent = cache?.parent || workspace.parent;
     let nextDimension = routeDimension;
-    const endpointChain = buildEndpointRolePointerChain({
-      requirements: route.materialRequirements?.endpointRoles || [],
+    const participantChain = buildParticipantRolePointerChain({
+      requirements: route.materialRequirements?.participantRoles || [],
       descriptor,
       workspaceById,
       cache,
@@ -196,13 +196,13 @@ function buildRecipientFacingV2TopologyLegacy(input = {}) {
       resolveRoleMaterialTarget: roleMaterialTarget,
       parentAuthority: recipientV2ParentAuthority
     });
-    files.push(...endpointChain.files);
-    topology.endpointRoles.push(...endpointChain.roles);
-    findings.push(...endpointChain.findings);
-    lineageParent = endpointChain.lineageParent;
-    nextDimension = endpointChain.nextDimension;
-    const participantChain = buildParticipantRolePointerChain({
-      requirements: route.materialRequirements?.participantRoles || [],
+    files.push(...participantChain.files);
+    topology.participantRoles.push(...participantChain.roles);
+    findings.push(...participantChain.findings);
+    lineageParent = participantChain.lineageParent;
+    nextDimension = participantChain.nextDimension;
+    const endpointChain = buildEndpointRolePointerChain({
+      requirements: route.materialRequirements?.endpointRoles || [],
       descriptor,
       workspaceById,
       cache,
@@ -214,11 +214,11 @@ function buildRecipientFacingV2TopologyLegacy(input = {}) {
       resolveRoleMaterialTarget: roleMaterialTarget,
       parentAuthority: recipientV2ParentAuthority
     });
-    files.push(...participantChain.files);
-    topology.participantRoles.push(...participantChain.roles);
-    findings.push(...participantChain.findings);
-    lineageParent = participantChain.lineageParent;
-    nextDimension = participantChain.nextDimension;
+    files.push(...endpointChain.files);
+    topology.endpointRoles.push(...endpointChain.roles);
+    findings.push(...endpointChain.findings);
+    lineageParent = endpointChain.lineageParent;
+    nextDimension = endpointChain.nextDimension;
     const pointerPath = `${nextDimension}-handoff-pointer.trace.md`;
     const pointerFacts = {
       workspaceId: workspace.workspaceId,

package/src/tooling/portable/materialization/epistemic.plan.js

@@ -4,7 +4,8 @@ import { normalizePortableInput } from '../input/portable.input.js';
 import { portableFinding, summarizePortableFindings } from '../findings.js';
 import { planPortableArtifact } from '../schema/schema.guide.js';
 import { indexPortableLoadedParentRecords, projectPortableLoadedParentRecord, resolvePortableLoadedParentReference } from './loaded.parent.js';
-import { allocateContinuationPath, allocateRootArtifactPath } from '../../../transitions/record.transitions.js';
+import { allocateContinuationPath, allocateDirectoryArtifactPath, allocateRootArtifactPath } from '../../../transitions/record.transitions.js';
+import { normalizePortableParentRecord, qualifyPortableExactParent } from '../draft/draft.exact.js';
 
 export const PORTABLE_EPISTEMIC_PLAN_SCHEMA_ID = 'tiinex.portable.epistemic-materialization-plan.v1';
 
@@ -69,18 +70,20 @@ function planProposal({ proposal, index, proposals, proposalIds, loadedIndex, ma
   const clarificationNeeds = [];
   const contract = buildArtifactCreationContract({ schemaId: proposal.schemaId, transitionType: proposal.parentRef ? 'continue-from-record' : 'create-artifact' });
   const artifactPlan = planPortableArtifact({ ...material, schemaId: proposal.schemaId, task: proposal.parentRef ? 'continue' : 'create', values: proposal.values || {}, inputs: proposal.values || {} }, options);
-  const parent = resolveParentReference(proposal.parentRef, { loadedIndex, proposalIds, proposalIndex: index, proposals });
+  const parent = resolveParentReference(proposal.parentRef, { loadedIndex, proposalIds, proposalIndex: index, proposals, suppliedParentRecord: proposal.parentRecord });
   const parentForAllocation = parent.status === 'resolved'
     ? parent.kind === 'proposal'
       ? plannedParentRecord(plannedById.get(parent.parent?.proposalId || ''))
       : parent.parent
     : null;
-  const allocationOptions = Object.freeze({ existingPaths: Object.freeze([...occupiedPaths]), path: proposal.path || '' });
+  const allocationOptions = Object.freeze({ existingPaths: Object.freeze([...occupiedPaths]), path: proposal.path || '', targetDirectory: proposal.targetDirectory || '' });
   const allocated = proposal.parentRef && parentForAllocation
     ? allocateContinuationPath({ parentRecord: parentForAllocation, targetId: proposal.schemaId, targetLabel: proposal.schemaId, title: proposal.title || proposal.summary || proposal.id }, allocationOptions)
-    : !proposal.parentRef
-      ? allocateRootArtifactPath({ targetId: proposal.schemaId, targetLabel: proposal.schemaId, title: proposal.title || proposal.summary || proposal.id }, allocationOptions)
-      : Object.freeze({ path: proposal.path || '', policy: Object.freeze({}) });
+    : !proposal.parentRef && proposal.targetDirectory
+      ? allocateDirectoryArtifactPath({ targetDirectory: proposal.targetDirectory, targetId: proposal.schemaId, targetLabel: proposal.schemaId, title: proposal.title || proposal.summary || proposal.id }, allocationOptions)
+      : !proposal.parentRef
+        ? allocateRootArtifactPath({ targetId: proposal.schemaId, targetLabel: proposal.schemaId, title: proposal.title || proposal.summary || proposal.id }, allocationOptions)
+        : Object.freeze({ path: proposal.path || '', policy: Object.freeze({}) });
 
   if (!proposal.schemaId) {
     findings.push(portableFinding('error', 'portable.materialization.schema.required', 'Each proposal must declare an implemented schema id; schema meaning is never inferred by the writer.', { proposalId: proposal.id }));
@@ -130,6 +133,7 @@ function planProposal({ proposal, index, proposals, proposalIds, loadedIndex, ma
     rationale: proposal.rationale,
     evidenceRefs: proposal.evidenceRefs,
     parentRef: proposal.parentRef,
+    targetDirectory: proposal.targetDirectory,
     parent: parent.status === 'resolved' ? parent.parent : null,
     parentKind: parent.status === 'resolved' ? parent.kind : '',
     creationContract: contract,
@@ -148,6 +152,8 @@ function normalizeProposals(value) {
       mode: clean(raw.mode || ''),
       schemaId: clean(raw.schemaId || raw.schema || ''),
       parentRef: exact(raw.parentRef ?? raw.parent ?? ''),
+      parentRecord: raw.parentRecord && typeof raw.parentRecord === 'object' ? Object.freeze(clone(raw.parentRecord)) : null,
+      targetDirectory: clean(raw.targetDirectory || raw.directory || ''),
       path: clean(raw.path || ''),
       title: clean(raw.title || ''),
       summary: clean(raw.summary || ''),
@@ -168,9 +174,17 @@ function plannedParentRecord(entry = null) {
   return Object.freeze({ id: entry.id || '', path: entry.path, schemaId: entry.schemaId || '', title: entry.title || entry.summary || entry.id || '' });
 }
 
-function resolveParentReference(ref, { loadedIndex, proposalIds, proposalIndex, proposals }) {
+function resolveParentReference(ref, { loadedIndex, proposalIds, proposalIndex, proposals, suppliedParentRecord = null }) {
   if (!ref) return { status: 'none', kind: 'none', parent: null };
   const reference = exact(ref);
+  if (suppliedParentRecord && typeof suppliedParentRecord === 'object') {
+    const normalized = normalizePortableParentRecord(suppliedParentRecord);
+    const declared = new Set([exact(normalized.id), exact(normalized.path)].filter(Boolean));
+    if (!declared.has(reference)) return { status: 'mismatch', code: 'portable.materialization.parent.supplied-reference-mismatch', message: 'The supplied Parent record does not identify the declared Parent reference.', candidates: [...declared] };
+    const qualification = qualifyPortableExactParent(normalized, 'continue-from-record');
+    if (!['qualified', 'qualified-local-continuity'].includes(String(qualification.state || ''))) return { status: 'unqualified', code: `portable.materialization.parent.supplied-${qualification.reason || 'unqualified'}`, message: 'The supplied Parent record is not qualified for continuation authoring.', candidates: [] };
+    return { status: 'resolved', kind: 'supplied-record', parent: qualification.snapshot };
+  }
   const proposalRef = reference.startsWith('proposal:') ? reference.slice('proposal:'.length) : proposalIds.has(reference) ? reference : '';
   if (proposalRef) {
     const targetIndex = proposals.findIndex((proposal) => proposal.id === proposalRef);

package/src/transitions/record.transitions.js

@@ -169,19 +169,21 @@ export function allocateContinuationPath({ parentRecord = {}, targetId = '', tar
   const explicitPath = canonicalLocalPath(options.path || options.draftPath || '');
   if (explicitPath) return { path: uniqueTransitionPath(explicitPath, occupied), policy: pathPolicyForExplicit(explicitPath) };
   const parentPath = externalWebArtifactUrl(parentRecord) ? '' : canonicalLocalPath(parentRecord.path || parentRecord.sourcePath || parentRecord.sourceTarget?.sourceArtifactPath || '');
-  const parentDir = parentDirectory(parentPath) || '.topics';
-  const requestedDir = canonicalLocalPath(options.targetDirectory || options.directory || '');
-  const targetDir = requestedDir || parentDir;
+  const parentDir = parentDirectory(parentPath);
+  const requestedRaw = String(options.targetDirectory || options.directory || '').trim();
+  const requestedExplicit = Boolean(requestedRaw);
+  const requestedDir = requestedRaw === '.' ? '' : canonicalLocalPath(requestedRaw);
+  const targetDir = requestedExplicit ? requestedDir : (parentDir || '.topics');
   const parentPrefix = lineagePrefixFromPath(parentPath);
   const labelSlug = slugify(title || parentRecord.title || targetLabel || 'continuation');
   const targetSlug = slugify(targetLabel || labelFromSchemaId(targetId) || 'leaf');
   const extension = '.trace.md';
-  const directoryLocal = Boolean(requestedDir && requestedDir !== parentDir);
+  const directoryLocal = Boolean(requestedExplicit && requestedDir !== parentDir);
   const policy = {
     schema: 'tiinex.transition.path-policy.v1',
     kind: directoryLocal ? 'directory-local-continuation' : 'same-parent-directory',
     parentDirectory: parentDir,
-    targetDirectory: targetDir,
+    targetDirectory: requestedExplicit && requestedDir === '' ? '.' : targetDir,
     parentPath,
     parentLineagePrefix: parentPrefix,
     labelSlug,
@@ -196,14 +198,16 @@ export function allocateDirectoryArtifactPath({ targetDirectory = '.topics', tar
   const occupied = existingTransitionPaths(options);
   const explicitPath = canonicalLocalPath(options.path || options.draftPath || '');
   if (explicitPath) return { path: uniqueTransitionPath(explicitPath, occupied), policy: pathPolicyForExplicit(explicitPath) };
-  const dir = canonicalLocalPath(targetDirectory || '.topics') || '.topics';
+  const targetRaw = String(targetDirectory ?? '').trim();
+  const explicitRoot = targetRaw === '.';
+  const dir = explicitRoot ? '' : (canonicalLocalPath(targetRaw || '.topics') || '.topics');
   const labelSlug = slugify(title || targetLabel || labelFromSchemaId(targetId) || 'artifact');
   const targetSlug = slugify(targetLabel || labelFromSchemaId(targetId) || 'artifact');
   const extension = '.trace.md';
   const policy = {
     schema: 'tiinex.transition.path-policy.v1',
     kind: 'directory-local-root',
-    targetDirectory: dir,
+    targetDirectory: explicitRoot ? '.' : dir,
     labelSlug,
     targetSlug,
     extension,
@@ -214,20 +218,25 @@ export function allocateDirectoryArtifactPath({ targetDirectory = '.topics', tar
 
 function pathFromPolicy(policy = {}, occupied = new Set()) {
   const kind = String(policy.kind || '').trim();
-  const dir = canonicalLocalPath(policy.targetDirectory || policy.parentDirectory || '.topics') || '.topics';
+  const hasTargetDirectory = Object.prototype.hasOwnProperty.call(policy, 'targetDirectory');
+  const hasParentDirectory = Object.prototype.hasOwnProperty.call(policy, 'parentDirectory');
+  const rawDirectory = hasTargetDirectory ? String(policy.targetDirectory ?? '') : hasParentDirectory ? String(policy.parentDirectory ?? '') : '.topics';
+  const rootDirectory = rawDirectory === '.' || ((hasTargetDirectory || hasParentDirectory) && rawDirectory === '');
+  const dir = rootDirectory ? '' : (canonicalLocalPath(rawDirectory || '.topics') || '.topics');
+  const pathPrefix = dir ? `${dir}/` : '';
   const extension = String(policy.extension || '.trace.md').startsWith('.') ? String(policy.extension || '.trace.md') : `.${policy.extension}`;
   const labelSlug = slugify(policy.labelSlug || 'continuation');
   const targetSlug = slugify(policy.targetSlug || 'leaf');
   const parentPrefix = String(policy.parentLineagePrefix || '').trim();
   if (kind === 'directory-local-root' || kind === 'directory-local-continuation') {
     const rootPrefix = nextDirectoryRootLineagePrefix(dir, occupied);
-    return `${dir}/${rootPrefix}-${labelSlug}.${extension.replace(/^\./, '')}`;
+    return `${pathPrefix}${rootPrefix}-${labelSlug}.${extension.replace(/^\./, '')}`;
   }
   if (parentPrefix) {
     const childPrefix = nextChildLineagePrefix(parentPrefix, dir, occupied);
-    return `${dir}/${childPrefix}-${labelSlug}.${extension.replace(/^\./, '')}`;
+    return `${pathPrefix}${childPrefix}-${labelSlug}.${extension.replace(/^\./, '')}`;
   }
-  return uniqueTransitionPath(`${dir}/${labelSlug}--${targetSlug}${extension}`, occupied);
+  return uniqueTransitionPath(`${pathPrefix}${labelSlug}--${targetSlug}${extension}`, occupied);
 }
 
 function pathPolicyForExplicit(path = '') {