@tiinex/core 0.29.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.29.0",
+  "version": "0.31.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": "d2ab9eeaaf1a0c0d13e2d7a5f9de4d010cf5e5bb",
+  "gitHead": "54c359f5d721194579aec2089cae096643912f07",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "d2ab9eeaaf1a0c0d13e2d7a5f9de4d010cf5e5bb",
-    "sourceTree": "50ae220f210ec6551825735fb7d9ba8f7956edc5",
+    "sourceCommit": "54c359f5d721194579aec2089cae096643912f07",
+    "sourceTree": "fbf8219dabf97f9939544b63387372c2c705726e",
     "repository": "Tiinex/core",
-    "previousVersion": "0.28.0"
+    "previousVersion": "0.30.0"
   }
 }

package/src/schemas/schema.lineageAuthority.js

@@ -0,0 +1,120 @@
+export const SCHEMA_LINEAGE_SOURCE_AUTHORITY_QUALIFICATION_SCHEMA_ID = 'tiinex.core.schema-lineage-source-authority-qualification.v1';
+
+export function qualifyCompiledSchemaLineageSourceAuthority(validationContract = {}) {
+  const lineage = Array.isArray(validationContract?.lineage) ? validationContract.lineage.map((item) => String(item || '').trim()) : [];
+  const projected = Array.isArray(validationContract?.lineageAuthority) ? validationContract.lineageAuthority : [];
+  const findings = [];
+  const edges = [];
+
+  if (!lineage.length || validationContract?.lineageQualification?.state !== 'valid') {
+    findings.push('Compiled validation lineage is unavailable or not valid.');
+  }
+  if (projected.length !== lineage.length) {
+    findings.push(`Compiled validation lineage source authority cardinality is ${projected.length}; expected ${lineage.length}.`);
+  }
+
+  const count = Math.min(projected.length, lineage.length);
+  for (let index = 0; index < count; index += 1) {
+    const entry = projected[index] || {};
+    const expectedSchemaId = lineage[index] || '';
+    const actualSchemaId = String(entry?.schemaId || '').trim();
+    if (!actualSchemaId || actualSchemaId !== expectedSchemaId) {
+      findings.push(`Compiled lineage source authority identity mismatch at index ${index}: expected ${expectedSchemaId || '(missing schema id)'} but observed ${actualSchemaId || '(missing schema id)'}.`);
+    }
+  }
+
+  for (let index = 1; index < count; index += 1) {
+    const parent = projected[index - 1] || {};
+    const child = projected[index] || {};
+    const parentSchemaId = String(parent?.schemaId || '').trim();
+    const childSchemaId = String(child?.schemaId || '').trim();
+    const declaredParentSchemaId = String(child?.parentSchemaId || '').trim();
+    const parentSource = normalizeSourceTuple(parent?.source || {});
+    const candidates = Object.freeze((Array.isArray(child?.parentSourceCandidates) ? child.parentSourceCandidates : []).map(normalizeSourceTuple));
+
+    if (!declaredParentSchemaId || declaredParentSchemaId !== parentSchemaId) {
+      findings.push(`Compiled lineage identity is incoherent across ${parentSchemaId || '(unknown parent)'} -> ${childSchemaId || '(unknown child)'}.`);
+      edges.push(freezeEdge({ state: 'contradictory', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'parent-schema-identity-mismatch' }));
+      continue;
+    }
+
+    if (isQualifiedLocalUnpublishedSchemaSource(parent?.source || {})) {
+      edges.push(freezeEdge({ state: 'qualified-local-supersession', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'qualified-local-unpublished-parent-authority' }));
+      continue;
+    }
+
+    const exactCandidates = candidates.filter(completeSourceTuple);
+    if (candidates.length !== 1 || exactCandidates.length !== 1) {
+      const reason = candidates.length > 1 ? 'ambiguous-parent-source-authority' : 'parent-source-authority-unavailable';
+      findings.push(candidates.length > 1
+        ? `Declared parent source authority is ambiguous for ${childSchemaId}: ${candidates.length} exact pinned candidates.`
+        : `Declared parent source authority is unavailable for ${childSchemaId} -> ${parentSchemaId}.`);
+      edges.push(freezeEdge({ state: 'unresolved', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason }));
+      continue;
+    }
+
+    const expected = exactCandidates[0];
+    if (!sameSourceTuple(parentSource, expected)) {
+      findings.push(`Compiled lineage substitutes source authority for ${childSchemaId} -> ${parentSchemaId}: declared ${formatSource(expected)} but compiled ${formatSource(parentSource)}.`);
+      edges.push(freezeEdge({ state: 'contradictory', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'compiled-parent-source-substitution' }));
+      continue;
+    }
+
+    edges.push(freezeEdge({ state: 'qualified', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'exact-parent-source-match' }));
+  }
+
+  const contradictory = edges.some((edge) => edge.state === 'contradictory') || findings.some((finding) => finding.includes('identity mismatch') || finding.includes('identity is incoherent') || finding.includes('substitutes source authority'));
+  const unresolved = !contradictory && (findings.length > 0 || edges.some((edge) => edge.state === 'unresolved'));
+  const state = contradictory ? 'contradictory' : unresolved ? 'unresolved' : 'qualified';
+  return deepFreeze({
+    schema: SCHEMA_LINEAGE_SOURCE_AUTHORITY_QUALIFICATION_SCHEMA_ID,
+    state,
+    complete: state === 'qualified',
+    lineage: Object.freeze([...lineage]),
+    edges: Object.freeze(edges),
+    findings: Object.freeze(findings),
+    boundary: 'Exact runtime validation authority requires source-coherent compiled inheritance. Qualified local unpublished Parent authority may intentionally supersede published Parent locators; all other inheritance edges require one exact declared Parent source tuple matching the compiled Parent material.'
+  });
+}
+
+export function isQualifiedLocalUnpublishedSchemaSource(source = {}) {
+  return String(source?.publicationState || '').trim().toLowerCase() === 'accepted-local-unpublished'
+    && String(source?.snapshotCompleteness || '').trim() === 'exact-axiom-canonical-unpublished-bounded-workspace-contract';
+}
+
+function normalizeSourceTuple(value = {}) {
+  return Object.freeze({
+    repository: String(value?.repository || '').trim(),
+    commit: String(value?.commit || '').trim().toLowerCase(),
+    path: String(value?.path || '').trim()
+  });
+}
+
+function completeSourceTuple(value = {}) {
+  return Boolean(value.repository && /^[0-9a-f]{40}$/.test(value.commit) && value.path);
+}
+
+function sameSourceTuple(left = {}, right = {}) {
+  return left.repository === right.repository && left.commit === right.commit && left.path === right.path;
+}
+
+function formatSource(value = {}) {
+  return `${value.repository || '(unknown repo)'}@${value.commit || '(unknown commit)'}/${value.path || '(unknown path)'}`;
+}
+
+function freezeEdge(value = {}) {
+  return Object.freeze({
+    state: String(value.state || 'unresolved'),
+    parentSchemaId: String(value.parentSchemaId || ''),
+    childSchemaId: String(value.childSchemaId || ''),
+    actual: value.actual || Object.freeze({ repository: '', commit: '', path: '' }),
+    candidates: value.candidates || Object.freeze([]),
+    reason: String(value.reason || '')
+  });
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}

package/src/schemas/schema.source.js

@@ -1,5 +1,6 @@
 import { sha256Hex, utf8Bytes } from '../export/package.bytes.js';
 import { qualifyGithubSchemaSourceProvider } from './schema.githubSourceTarget.js';
+import { qualifyCompiledSchemaLineageSourceAuthority } from './schema.lineageAuthority.js';
 
 export const BUNDLED_SCHEMA_SOURCE_SCHEMA_ID = 'tiinex.site.bundled-schema-source.v1';
 export const SCHEMA_RUNTIME_PROJECTION_SCHEMA_ID = 'tiinex.site.schema-runtime-projection.v1';
@@ -48,6 +49,7 @@ export function defineBundledSchemaSource(binding = {}, projection = {}, options
         ...(!loadedBlobSha ? ['Loaded schema Git-blob identity is unavailable from the runtime projection.'] : [])
       ])
     });
+    const validationLineageAuthority = qualifyCompiledSchemaLineageSourceAuthority(runtimeProjection.validationContract || {});
     const validationContract = projectionExact && runtimeProjection.validationContract?.schemaId === schemaId && runtimeProjection.validationContract?.lineageQualification?.state === 'valid'
       ? runtimeProjection.validationContract
       : null;
@@ -85,6 +87,7 @@ export function defineBundledSchemaSource(binding = {}, projection = {}, options
       authority,
       bindingMaterialCoherence,
       materialIdentity,
+      validationLineageAuthority,
       compiledContract,
       projection: runtimeProjection,
       findings: Object.freeze([
@@ -93,7 +96,8 @@ export function defineBundledSchemaSource(binding = {}, projection = {}, options
         ...(runtimeProjection.sourceChecksum !== expectedChecksum ? ['Schema runtime projection source checksum does not match binding.'] : []),
         ...(runtimeProjection.bindingChecksum !== expectedChecksum ? ['Schema runtime projection binding checksum does not match binding.'] : []),
         ...(runtimeProjection.validationContract && runtimeProjection.validationContract?.schemaId !== schemaId ? ['Schema runtime validation projection identity does not match binding.'] : []),
-        ...(runtimeProjection.validationContract && runtimeProjection.validationContract?.lineageQualification?.state !== 'valid' ? ['Schema runtime validation projection lineage is not exact/valid.'] : [])
+        ...(runtimeProjection.validationContract && runtimeProjection.validationContract?.lineageQualification?.state !== 'valid' ? ['Schema runtime validation projection lineage is not exact/valid.'] : []),
+        ...(validationLineageAuthority.state !== 'qualified' ? validationLineageAuthority.findings : [])
       ])
     });
     return cached;

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/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/schema/qualifiedLocalRoot.runtime.js

@@ -13,10 +13,19 @@ export function portableRuntimeValidationContractForSchema(schemaId = '', resolu
   const resolution = resolutionInput || resolveSchemaModule({ schemaId });
   if (resolution?.fallbackUsed || !resolution?.module) return unavailable('registered-schema-resolution-unavailable', { resolution });
   const qualification = typeof resolution.module.schemaSource?.qualify === 'function' ? resolution.module.schemaSource.qualify() : null;
+  const lineageAuthority = qualification?.validationLineageAuthority || null;
+  if (qualification?.state === 'qualified' && lineageAuthority && lineageAuthority.state !== 'qualified') {
+    return unavailable('compiled-validation-lineage-source-authority-unqualified', {
+      resolution,
+      findings: Object.freeze([...(lineageAuthority.findings || [])]),
+      lineageAuthority,
+      baseQualificationState: String(qualification?.state || 'unavailable')
+    });
+  }
   const baseContract = qualification?.state === 'qualified' ? qualification?.compiledContract?.validationContract || null : null;
-  if (!baseContract) return unavailable(qualification?.state === 'qualified' ? 'compiled-validation-contract-unavailable' : 'schema-source-unqualified', { resolution });
+  if (!baseContract) return unavailable(qualification?.state === 'qualified' ? 'compiled-validation-contract-unavailable' : 'schema-source-unqualified', { resolution, findings: Object.freeze([...(qualification?.findings || [])]), baseQualificationState: String(qualification?.state || 'unavailable') });
   const projected = projectPortableValidationContractWithQualifiedLocalRoot(baseContract);
-  return deepFreeze({ ...projected, resolution, baseQualificationState: String(qualification?.state || 'unavailable') });
+  return deepFreeze({ ...projected, resolution, lineageAuthority, baseQualificationState: String(qualification?.state || 'unavailable') });
 }
 
 export function portableRuntimeValidationAuthorityForRecord(record = {}) {
@@ -26,7 +35,10 @@ export function portableRuntimeValidationAuthorityForRecord(record = {}) {
   const schemaId = String(declaredSchema.id || record?.schemaId || record?.currentSchemaId || '').trim();
   const runtime = portableRuntimeValidationContractForSchema(schemaId);
   if (runtime.state !== 'qualified' || !runtime.compiledContract) {
-    return unavailableAuthority(schemaId, runtime, ['Registered compiled validation authority is unavailable for the declared Current Schema.']);
+    const runtimeFindings = Array.isArray(runtime?.findings) && runtime.findings.length
+      ? runtime.findings
+      : ['Registered compiled validation authority is unavailable for the declared Current Schema.'];
+    return unavailableAuthority(schemaId, runtime, runtimeFindings);
   }
 
   const findings = [];