@tiinex/core 0.19.0 → 0.21.0

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

@@ -0,0 +1,125 @@
+import { deepFreeze, normalizeToken } from '../handoff/coldStartQualification.shared.js';
+
+export const HOLDER_ASSIGNMENT_MODE = deepFreeze({
+  EXPLICIT_SESSION: 'explicit-session',
+  EXPLICIT_USER_SESSION: 'explicit-user-session',
+  EXPLICIT_ROLE_INVOCATION: 'explicit-role-invocation',
+  HANDOFF: 'handoff',
+  EXPLICIT_PARTICIPATION: 'explicit-participation'
+});
+
+const KNOWN_MODES = new Set(Object.values(HOLDER_ASSIGNMENT_MODE));
+
+export function projectHolderAssignmentModeAuthority(role = {}) {
+  const endpointKind = normalizeToken(role?.endpoint?.kind || '');
+  if (endpointKind !== 'role') return deepFreeze({
+    state: 'not-applicable',
+    modes: deepFreeze([]),
+    holderState: '',
+    source: 'none',
+    reasonCode: 'recipient-not-role',
+    unknownModes: deepFreeze([]),
+    provenance: baseProvenance(role, { basis: 'recipient-not-role', field: 'Assignment Modes' }),
+    boundary: 'Holder assignment-mode authority applies only to a selected Role recipient.'
+  });
+
+  const material = role?.material?.artifact || null;
+  const relationship = role?.holderRelationshipLoaded || {};
+  const holderState = String(relationship.holderState || '').trim();
+  const qualifiedMaterial = String(role?.state || '') === 'qualified'
+    && String(role?.material?.state || '') === 'qualified'
+    && Boolean(material?.path)
+    && /^[0-9a-f]{64}$/i.test(String(material?.sha256 || ''));
+  if (!qualifiedMaterial) return unresolved(role, holderState, 'qualified-role-holder-authority-not-established', 'none', {
+    basis: 'exact-qualified-role-assignment-mode-authority-not-established', field: 'Assignment Modes'
+  });
+
+  const structured = parseStructuredModes(relationship.assignmentModes);
+  if (!structured.present) return unresolved(role, holderState, 'holder-assignment-mode-authority-missing', 'qualified-recipient-role-material', {
+    basis: 'canonical-assignment-modes-missing', field: 'Assignment Modes'
+  });
+  if (structured.unknown.length) return unresolved(role, holderState, 'holder-assignment-mode-authority-unknown-token', 'qualified-recipient-role-structured-modes', {
+    basis: 'exact-qualified-role-assignment-modes', field: 'Assignment Modes', exactValue: structured.raw, unknownModes: structured.unknown
+  });
+  if (!structured.modes.length) return unresolved(role, holderState, 'holder-assignment-mode-authority-empty', 'qualified-recipient-role-structured-modes', {
+    basis: 'exact-qualified-role-assignment-modes', field: 'Assignment Modes', exactValue: structured.raw
+  });
+  return deepFreeze({
+    state: 'qualified',
+    modes: deepFreeze(structured.modes),
+    holderState,
+    source: 'qualified-recipient-role-structured-modes',
+    reasonCode: 'holder-assignment-mode-authority-qualified',
+    unknownModes: deepFreeze([]),
+    provenance: baseProvenance(role, {
+      basis: 'exact-qualified-role-assignment-modes',
+      field: 'Assignment Modes',
+      exactValue: structured.raw,
+      boundary: 'Positive mode authority comes only from the exact structured Assignment Modes field on the qualified current Role. Holder State is diagnostic-only; historical compatibility material does not authorize current holder binding.'
+    }),
+    boundary: 'Exact structured canonical assignment modes authorize only their named bounded mechanisms; they do not establish a holder, durable identity, participation, delegation, process, source, or acceptance authority.'
+  });
+}
+
+export function isCanonicalHolderAssignmentMode(value = '') {
+  return KNOWN_MODES.has(String(value || '').trim());
+}
+
+function parseStructuredModes(value) {
+  if (Array.isArray(value)) {
+    const raw = value.map((item) => String(item || '').trim()).filter(Boolean);
+    const tokens = raw.map(stripCode).filter(Boolean);
+    return classifyStructured(tokens, raw.join(', '), true);
+  }
+  const raw = String(value || '').trim();
+  if (!raw) return { present: false, raw: '', modes: [], unknown: [] };
+  const tokens = raw.split(',').map((item) => stripCode(item.trim())).filter(Boolean);
+  return classifyStructured(tokens, raw, true);
+}
+
+function classifyStructured(tokens, raw, present) {
+  const modes = [];
+  const unknown = [];
+  for (const token of tokens) {
+    if (KNOWN_MODES.has(token)) {
+      if (!modes.includes(token)) modes.push(token);
+    } else if (!unknown.includes(token)) unknown.push(token);
+  }
+  return { present, raw, modes, unknown };
+}
+
+function stripCode(value) {
+  const text = String(value || '').trim();
+  return /^`[^`]+`$/.test(text) ? text.slice(1, -1).trim() : text;
+}
+
+function unresolved(role, holderState, reasonCode, source, details = {}) {
+  return deepFreeze({
+    state: 'unresolved',
+    modes: deepFreeze([]),
+    holderState,
+    source,
+    reasonCode,
+    unknownModes: deepFreeze([...(details.unknownModes || [])]),
+    provenance: baseProvenance(role, details),
+    boundary: 'Positive holder assignment-mode authorization is unresolved. Core does not infer canonical modes from Holder State prose, historical Role compatibility, endpoint labels, package placement, session assertions, filenames, or lexical similarity.'
+  });
+}
+
+function baseProvenance(role = {}, details = {}) {
+  const material = role?.material?.artifact || {};
+  return deepFreeze({
+    basis: String(details.basis || ''),
+    roleArtifactPath: String(material.path || ''),
+    roleArtifactSha256: String(material.sha256 || ''),
+    roleSchemaId: String(material.schemaId || ''),
+    roleLabel: String(material.roleLabel || role?.endpoint?.label || ''),
+    section: 'Holder Relationship',
+    field: String(details.field || 'Assignment Modes'),
+    exactValue: String(details.exactValue || ''),
+    exactRoleSourcePath: '',
+    exactRoleSha256: '',
+    decisionArtifact: null,
+    boundary: String(details.boundary || 'Only exact structured Assignment Modes on exact qualified current Role material may establish canonical assignment modes. Holder State and historical compatibility material remain non-authoritative for positive authorization.')
+  });
+}

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

@@ -1,81 +1,80 @@
-import { deepFreeze, normalizeComparable, normalizeToken } from '../handoff/coldStartQualification.shared.js';
+import { deepFreeze, normalizeToken } from '../handoff/coldStartQualification.shared.js';
+import {
+  HOLDER_ASSIGNMENT_MODE,
+  isCanonicalHolderAssignmentMode,
+  projectHolderAssignmentModeAuthority
+} from './grounding.holderAssignmentModes.js';
 
-export const EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE = 'assignable per explicit session or Handoff';
-export const CURRENT_ROLE_EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE = 'assignable per explicit session, role invocation, or Handoff; no permanent holder asserted';
-export const ANCHOR_EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE = 'assignable per explicit session or Handoff; no permanent holder asserted';
-
-const AUTHORIZED_EXPLICIT_SESSION_OR_HANDOFF_STATES = new Set([
-  normalizeComparable(EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE),
-  normalizeComparable(CURRENT_ROLE_EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE),
-  normalizeComparable(ANCHOR_EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE)
-]);
-
-export function projectHolderBindingAuthorization(role = {}) {
+export function projectHolderBindingAuthorization(role = {}, options = {}) {
   const endpointKind = normalizeToken(role?.endpoint?.kind || '');
+  const requestedMode = String(options.assertionMode || options.assignmentMode || HOLDER_ASSIGNMENT_MODE.EXPLICIT_SESSION).trim();
   if (endpointKind !== 'role') return deepFreeze({
     state: 'not-applicable',
     assignmentMode: '',
+    authorizedModes: deepFreeze([]),
     holderState: '',
     source: 'none',
     reasonCode: 'recipient-not-role',
+    modeAuthority: projectHolderAssignmentModeAuthority(role),
     provenance: {
-      basis: 'recipient-not-role',
-      roleArtifactPath: '',
-      roleArtifactSha256: '',
-      section: 'Holder Relationship',
-      field: 'Holder State',
-      boundary: 'Holder-assignment authorization is only applicable when the selected Handoff recipient is a Role endpoint.'
+      basis: 'recipient-not-role', roleArtifactPath: '', roleArtifactSha256: '', section: 'Holder Relationship', field: 'Assignment Modes', exactValue: '', assertionMode: '', boundary: 'Holder-assignment authorization is only applicable when the selected Handoff recipient is a Role endpoint.'
     },
     boundary: 'No Role assignment authorization is required for a non-Role recipient.'
   });
 
-  const material = role?.material?.artifact || null;
-  const relationship = role?.holderRelationshipLoaded || {};
-  const holderState = String(relationship.holderState || '').trim();
-  const qualifiedMaterial = String(role?.state || '') === 'qualified'
-    && String(role?.material?.state || '') === 'qualified'
-    && Boolean(material?.path)
-    && Boolean(material?.sha256);
-  const provenance = {
-    basis: qualifiedMaterial ? 'exact-qualified-role-holder-relationship' : 'exact-qualified-role-holder-relationship-not-established',
-    roleArtifactPath: String(material?.path || ''),
-    roleArtifactSha256: String(material?.sha256 || ''),
-    roleSchemaId: String(material?.schemaId || ''),
-    roleLabel: String(material?.roleLabel || role?.endpoint?.label || ''),
-    section: 'Holder Relationship',
-    field: 'Holder State',
-    exactValue: holderState,
-    boundary: 'Only exact qualified recipient Role material may authorize the bounded session assignment mode. Handoff endpoints, transport identity, explicit session input, filenames, and package placement do not provide this authority.'
-  };
+  const modeAuthority = projectHolderAssignmentModeAuthority(role);
+  const holderState = String(modeAuthority.holderState || role?.holderRelationshipLoaded?.holderState || '').trim();
+  const provenance = deepFreeze({
+    ...(modeAuthority.provenance || {}),
+    assertionMode: requestedMode,
+    boundary: 'The bounded binding result compares one explicit assertion mechanism to exact qualified canonical assignment-mode authority. Holder State prose remains diagnostic-only.'
+  });
 
-  if (!qualifiedMaterial) return deepFreeze({
+  if (modeAuthority.state !== 'qualified') return deepFreeze({
     state: 'unresolved',
-    assignmentMode: '',
+    assignmentMode: requestedMode,
+    authorizedModes: deepFreeze([]),
     holderState,
-    source: 'none',
-    reasonCode: 'qualified-role-holder-authority-not-established',
+    source: modeAuthority.source || 'none',
+    reasonCode: modeAuthority.reasonCode || 'holder-assignment-mode-authority-unresolved',
+    modeAuthority,
     provenance,
-    boundary: 'A matching session Role assertion remains unauthorized until exact qualified Role material establishes the assignment mode.'
+    boundary: 'A matching Role assertion remains unauthorized until exact qualified canonical assignment-mode authority is established.'
   });
 
-  const assignmentAuthorized = AUTHORIZED_EXPLICIT_SESSION_OR_HANDOFF_STATES.has(normalizeComparable(holderState));
-  if (!assignmentAuthorized) return deepFreeze({
+  if (!isCanonicalHolderAssignmentMode(requestedMode)) return deepFreeze({
     state: 'unresolved',
-    assignmentMode: '',
+    assignmentMode: requestedMode,
+    authorizedModes: deepFreeze([...(modeAuthority.modes || [])]),
+    holderState,
+    source: modeAuthority.source,
+    reasonCode: 'holder-binding-assertion-mode-unqualified',
+    modeAuthority,
+    provenance,
+    boundary: 'The asserted binding mechanism is not a canonical mode established by semantic authority. Core does not reinterpret arbitrary assertion labels.'
+  });
+
+  if (!(modeAuthority.modes || []).includes(requestedMode)) return deepFreeze({
+    state: 'unresolved',
+    assignmentMode: requestedMode,
+    authorizedModes: deepFreeze([...(modeAuthority.modes || [])]),
     holderState,
-    source: 'qualified-recipient-role-material',
-    reasonCode: holderState ? 'holder-assignment-mode-not-authorized' : 'holder-assignment-mode-unresolved',
+    source: modeAuthority.source,
+    reasonCode: 'holder-assignment-mode-not-authorized',
+    modeAuthority,
     provenance,
-    boundary: 'The exact qualified Role does not establish authorization for explicit-session/Handoff assignment. Core preserves this as unresolved and does not reinterpret other Holder State wording.'
+    boundary: 'The exact qualified canonical mode set does not authorize the asserted bounded binding mechanism. No widening between session, user-session, invocation, Handoff, or participation modes is permitted.'
   });
 
   return deepFreeze({
     state: 'qualified',
-    assignmentMode: 'explicit-session-or-handoff',
+    assignmentMode: requestedMode,
+    authorizedModes: deepFreeze([...(modeAuthority.modes || [])]),
     holderState,
-    source: 'qualified-recipient-role-material',
+    source: modeAuthority.source,
     reasonCode: 'holder-assignment-mode-authorized',
+    modeAuthority,
     provenance,
-    boundary: 'Exact qualified Role Holder Relationship authorizes this assignment mode for the bounded current session only; it does not establish durable holder identity or broader participant/process/source authority.'
+    boundary: 'Exact qualified canonical assignment-mode authority authorizes only this bounded assertion mechanism; it does not establish durable holder identity or broader participant/process/delegation/source/acceptance authority.'
   });
 }

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

@@ -41,6 +41,7 @@ export function projectPortableGroundingReadiness(input = {}, options = {}) {
     route,
     toolingAvailable: true
   }, { ...options, coldStartMaterialContext: materialContext });
+  const authority = withExplicitGroundingAuthorityInputs(grounding, input);
   const continuation = projectGroundedContinuation({
     bundle,
     route,
@@ -62,7 +63,7 @@ export function projectPortableGroundingReadiness(input = {}, options = {}) {
   });
   return composeGroundingReadiness({
     mode: 'routed-handoff-package',
-    authority: grounding,
+    authority,
     continuation,
     contextAudit,
     material,
@@ -140,8 +141,8 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
         known.push(evidence('session-holder-role-binding-authorization', 'qualified', authority?.holderBinding?.authorization?.provenance?.roleArtifactPath || authority?.role?.endpoint?.label || 'recipient Role material'));
       } else {
         holderBindingActReady = false;
-        unresolved.push(evidence('session-holder-role-binding-authorization', holderAuthorizationState || 'unresolved', authority?.holderBinding?.authorization?.holderState || 'exact qualified Role Holder Relationship does not establish the explicit-session/Handoff assignment mode'));
-        reasons.push(reason('session-holder-role-binding-authorization-unresolved', 'The explicit consuming-session Role assertion matches the selected recipient Role, but exact qualified Role holder-assignment authority does not establish that assignment mode. Matching session input alone cannot make the route act-ready.'));
+        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.'));
       }
     }
 
@@ -254,6 +255,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
     }),
     continuity,
     orchestrationReadiness,
+    delegationReadiness: capsule.delegationReadiness,
     capsule,
     currentWork: Object.freeze({
       state: topology.currentFrontier.length ? 'current-frontier-resolved' : topology.currentTasks.length ? 'current-candidates-without-frontier' : 'unresolved',
@@ -288,6 +290,20 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
   });
 }
 
+
+function withExplicitGroundingAuthorityInputs(grounding = {}, input = {}) {
+  const context = input.delegationContext && typeof input.delegationContext === 'object' ? input.delegationContext : {};
+  const selected = {
+    delegateCapabilityAuthority: input.delegateCapabilityAuthority || context.delegateCapabilityAuthority || null,
+    processApplicability: input.processApplicability || context.processApplicability || null,
+    delegationTargetAuthority: input.delegationTargetAuthority || context.delegationTargetAuthority || context.targetAuthority || null,
+    implementationSourceAuthority: input.implementationSourceAuthority || context.implementationSourceAuthority || context.sourceAuthority || null,
+    delegationReturnReconciliationExpectation: input.delegationReturnReconciliationExpectation || context.delegationReturnReconciliationExpectation || context.returnReconciliationExpectation || null
+  };
+  const additions = Object.fromEntries(Object.entries(selected).filter(([, value]) => value && typeof value === 'object'));
+  return Object.freeze({ ...(grounding || {}), ...additions, ...(Object.keys(context).length ? { delegationContext: Object.freeze({ ...context }) } : {}) });
+}
+
 function projectWorkspaceActionCoverage(contextAudit = {}) {
   const workspaces = Array.isArray(contextAudit?.workspaceMaterializations) ? contextAudit.workspaceMaterializations : [];
   const summaries = workspaces.map((workspace) => {

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

@@ -174,7 +174,7 @@ export function resolveRequiredContextRecords(requiredContext = [], records = []
 }
 
 function isExactHydratedWorkspaceContext(entry = {}) {
-  if (String(entry.providerMode || '') !== 'archive') return false;
+  if (!['archive', 'cache'].includes(String(entry.providerMode || ''))) return false;
   if (!['hydrated-text', 'qualified-locator-only'].includes(String(entry.contentState || ''))) return false;
   const expectedBytes = Number(entry.bytes || 0);
   const actualBytes = Number(entry.actualBytes || 0);

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

@@ -71,8 +71,22 @@ function qualifyRequiredRequirement(bundle, descriptor, byteProvider, workspace,
   let resolution=null;
   if (!target||target.startsWith('#')) { resolution=resolveDescriptorMaterial(bundle,descriptor,byteProvider,target,requirementId,workspace.id,routePath); if(!resolution) reasons.push('exact-required-material-reference-or-binding-unresolved'); }
   const qualified=parseWorkspaceQualifiedReference(target);
-  if (!resolution&&!reasons.length&&qualified) resolution=resolveWorkspaceRequiredMaterial(byteProvider,{id:qualified.workspaceId},qualified.path);
-  if (!resolution&&!reasons.length&&!qualified&&!isExternalReference(target)) { const resolvedPath=resolveWorkspaceReference(routePath,target); if(!resolvedPath) reasons.push('workspace-reference-outside-or-invalid'); else resolution=resolveWorkspaceRequiredMaterial(byteProvider,workspace,resolvedPath); }
+  if (!resolution&&!reasons.length&&qualified) {
+    const workspaceResolution=resolveWorkspaceRequiredMaterial(byteProvider,{id:qualified.workspaceId},qualified.path);
+    resolution=workspaceResolution.state==='qualified'
+      ? workspaceResolution
+      : (resolveDescriptorMaterial(bundle,descriptor,byteProvider,target,requirementId,workspace.id,routePath)||workspaceResolution);
+  }
+  if (!resolution&&!reasons.length&&!qualified&&!isExternalReference(target)) {
+    const resolvedPath=resolveWorkspaceReference(routePath,target);
+    if(!resolvedPath) reasons.push('workspace-reference-outside-or-invalid');
+    else {
+      const workspaceResolution=resolveWorkspaceRequiredMaterial(byteProvider,workspace,resolvedPath);
+      resolution=workspaceResolution.state==='qualified'
+        ? workspaceResolution
+        : (resolveDescriptorMaterial(bundle,descriptor,byteProvider,target,requirementId,workspace.id,routePath)||workspaceResolution);
+    }
+  }
   if (!resolution&&!reasons.length) resolution=resolveDescriptorMaterial(bundle,descriptor,byteProvider,target,requirementId,workspace.id,routePath);
   if (!resolution&&!reasons.length) reasons.push('required-material-not-carried');
   if (resolution?.state!=='qualified'&&resolution?.reason) reasons.push(resolution.reason);
@@ -190,8 +204,10 @@ function resolveRouteParent(bundle, descriptor, byteProvider, workspace, routePa
     if (!markdown) continue;
     const self = validatedC14nV2PrimarySelfDigest(markdown);
     if (self.state !== 'verified' || self.value !== digest) continue;
-    const key = `${candidate.workspaceId || ''}\u0000${candidate.workspaceRelativePath || ''}\u0000${candidate.packagePath || ''}`;
-    digestMatches.set(key, Object.freeze({ state: 'qualified', markdown, basis: 'parent-target-digest-candidate', workspaceRelativePath: normalizeWorkspacePath(candidate.workspaceRelativePath || ''), packagePath: String(candidate.packagePath || ''), sha256: sha256Hex(data) }));
+    const candidatePath = normalizeWorkspacePath(candidate.workspaceRelativePath || '');
+    const candidateSha256 = sha256Hex(data);
+    const key = `${candidate.workspaceId || ''}\u0000${candidatePath}\u0000${candidateSha256}`;
+    if (!digestMatches.has(key)) digestMatches.set(key, Object.freeze({ state: 'qualified', markdown, basis: 'parent-target-digest-candidate', workspaceRelativePath: candidatePath, packagePath: String(candidate.packagePath || ''), sha256: candidateSha256 }));
   }
   if (digestMatches.size === 1) return [...digestMatches.values()][0];
   if (digestMatches.size > 1) return Object.freeze({ state: 'ambiguous', reason: 'multiple-parent-target-digest-candidates' });

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

@@ -19,6 +19,7 @@ import {
   resolveGroundingRouteMarkdown,
   recipientFactsIndexForColdStart,
   resolveReferencedRoleMaterial,
+  resolveReferencedEndpointRoleMaterial,
   selectGroundingRoute
 } from './coldStartQualification.materials.js';
 import {
@@ -60,6 +61,7 @@ export function groundPortableColdConsumer(input = {}, options = {}) {
 
   const bundle = input.bundle || input.package || input;
   const role = groundRecipientRole(input, handoff, bundle, orientation, selectedRoute, findings, materialContext);
+  const senderRole = groundSenderRole(handoff, bundle, orientation, selectedRoute, materialContext);
   const holderBinding = groundHolderBinding(input, handoff, role, findings);
   const participation = groundParticipation(input, handoff, bundle, orientation, selectedRoute, findings, materialContext);
   const interaction = groundInteraction(input, handoff);
@@ -84,6 +86,7 @@ export function groundPortableColdConsumer(input = {}, options = {}) {
     selectedRoute,
     handoff,
     role,
+    senderRole,
     holderBinding,
     participation,
     interaction,
@@ -120,6 +123,50 @@ export function groundPortableColdConsumer(input = {}, options = {}) {
   });
 }
 
+function groundSenderRole(handoff, bundle, orientation, selectedRoute, materialContext) {
+  const fromKind = normalizeToken(handoff.fromKind);
+  if (fromKind && fromKind !== 'role') return deepFreeze({
+    state: 'not-applicable',
+    endpoint: Object.freeze({ label: handoff.from || '', kind: handoff.fromKind || '', bounded: Boolean(handoff.from) }),
+    material: Object.freeze({ state: 'not-required', artifact: null }),
+    exactBoundaryLoaded: null,
+    authorityBoundaryLoaded: null,
+    boundary: 'Sender endpoint is not declared as Role; no sender Role authority is invented.'
+  });
+  if (!handoff.fromReference) return deepFreeze({
+    state: 'unresolved',
+    endpoint: Object.freeze({ label: handoff.from || '', kind: handoff.fromKind || (handoff.from ? 'role' : ''), bounded: Boolean(handoff.from) }),
+    material: Object.freeze({ state: 'missing-exact-reference', artifact: null }),
+    exactBoundaryLoaded: null,
+    authorityBoundaryLoaded: null,
+    boundary: 'Delegation projection requires an exact Handoff From Reference; Role inventory and endpoint labels are not substituted.'
+  });
+  const localFindings = [];
+  const material = resolveReferencedEndpointRoleMaterial(bundle, handoff, orientation, selectedRoute, localFindings, materialContext, 'from');
+  const parsed = material ? parseRoleMaterial(material) : null;
+  const target = normalizeComparable(handoff.from || '');
+  if (!parsed || (target && normalizeComparable(parsed.label) !== target)) return deepFreeze({
+    state: 'unresolved',
+    endpoint: Object.freeze({ label: handoff.from || '', kind: handoff.fromKind || (handoff.from ? 'role' : ''), bounded: Boolean(handoff.from) }),
+    material: Object.freeze({ state: localFindings.length ? 'unresolved-exact-reference' : 'missing', artifact: null }),
+    exactBoundaryLoaded: null,
+    authorityBoundaryLoaded: null,
+    boundary: 'Exact sender Role material did not qualify; sender authority is not inferred from carried Role inventory.'
+  });
+  return deepFreeze({
+    state: 'qualified',
+    endpoint: Object.freeze({ label: handoff.from || parsed.label || '', kind: handoff.fromKind || 'role', bounded: Boolean(handoff.from) }),
+    material: Object.freeze({
+      state: 'qualified',
+      artifact: Object.freeze({ path: parsed.path, sha256: parsed.sha256, schemaId: parsed.schemaId, title: parsed.title, roleLabel: parsed.label, roleKind: parsed.roleKind, reference: handoff.fromReference || '' })
+    }),
+    exactBoundaryLoaded: parsed.boundary,
+    authorityBoundaryLoaded: parsed.authorityBoundary,
+    interpretationLimitsLoaded: parsed.interpretationLimits,
+    boundary: 'Exact Handoff From Reference Role material only. Sender Role authority remains separate from Handoff transfer and is never inferred from endpoint naming or cache inventory.'
+  });
+}
+
 function groundRecipientRole(input, handoff, bundle, orientation, selectedRoute, findings, materialContext) {
   const toKind = normalizeToken(handoff.toKind);
   if (toKind && toKind !== 'role') return deepFreeze({
@@ -201,12 +248,14 @@ function groundHolderBinding(input, handoff, role, findings) {
   const roleRecipient = recipientRoleKind === 'role';
   const explicitlySupplied = Boolean(roleLabel || holderId);
   const sourceDetail = holderBindingSourceDetail(input, explicit, explicitlySupplied);
-  const authorization = projectHolderBindingAuthorization(role);
+  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',
@@ -224,6 +273,7 @@ function groundHolderBinding(input, handoff, role, findings) {
     return deepFreeze({
       state: 'unresolved',
       holderId,
+      assertionMode,
       roleLabel: '',
       recipientRoleLabel,
       recipientCompatibility: 'unresolved',
@@ -242,6 +292,7 @@ function groundHolderBinding(input, handoff, role, findings) {
     return deepFreeze({
       state: 'blocked',
       holderId,
+      assertionMode,
       roleLabel,
       recipientRoleLabel,
       recipientCompatibility: 'mismatch',
@@ -258,6 +309,7 @@ function groundHolderBinding(input, handoff, role, findings) {
   return deepFreeze({
     state: 'qualified',
     holderId,
+    assertionMode,
     roleLabel,
     recipientRoleLabel,
     recipientCompatibility: 'matched',
@@ -310,7 +362,7 @@ function holderBindingSourceDetail(input = {}, explicit = {}, explicitlySupplied
 
 function groundParticipation(input, handoff, bundle, orientation, selectedRoute, findings, materialContext) {
   const explicitParticipants = normalizeParticipants(input.participants || input.interaction?.participants || []);
-  const packageRoleGrounding = resolvePackageParticipantRoles(bundle, orientation, selectedRoute, findings);
+  const packageRoleGrounding = resolvePackageParticipantRoles(bundle, orientation, selectedRoute, findings, materialContext);
   const participants = dedupeGroundedParticipants(explicitParticipants);
   const contributions = normalizeContributions(input.contributions || input.interaction?.contributions || []);
   const currentContributionId = String(input.currentContributionId || input.interaction?.currentContributionId || '').trim();
@@ -345,7 +397,7 @@ function resolvePackageParticipantRoles(bundle = {}, orientation = null, selecte
     const pointerPath = String(pointerPaths[index] || '');
     const pointerFile = findFile(bundle, pointerPath);
     if (!pointerFile) { findings.push(portableFinding('error', 'portable.cold-start.participant-role.pointer.missing', 'Selected Handoff route declares Role grounding Pointer ancestry that is not carried.', { pointerPath })); continue; }
-    const compatibilityFacts = recipientV2FactsIndex(bundle).map.get(pointerPath) || null;
+    const compatibilityFacts = recipientFactsIndexForColdStart(bundle, materialContext).map.get(pointerPath) || null;
     const projectedFacts = (orientation?.participantRoles || []).find((item) => String(item.pointerPath || '') === pointerPath) || null;
     const facts = compatibilityFacts?.role === 'participant-role'
       ? compatibilityFacts
@@ -370,7 +422,18 @@ function resolvePackageParticipantRoles(bundle = {}, orientation = null, selecte
       packageDeclared: true,
       groundingOnly: true,
       semanticParticipant: false,
-      roleArtifact: Object.freeze({ path: parsed.path, sha256: parsed.sha256, schemaId: parsed.schemaId, roleLabel: parsed.label, roleKind: parsed.roleKind }),
+      materialQualification: 'qualified',
+      roleArtifact: Object.freeze({
+        path: parsed.path,
+        reference: String(facts.referenceTarget || parsed.path || ''),
+        sha256: parsed.sha256,
+        schemaId: parsed.schemaId,
+        roleLabel: parsed.label,
+        roleKind: parsed.roleKind
+      }),
+      exactBoundaryLoaded: parsed.boundary,
+      authorityBoundaryLoaded: parsed.authorityBoundary,
+      interpretationLimitsLoaded: parsed.interpretationLimits,
       pointerPath
     }));
   }