@tiinex/core 0.18.0 → 0.20.0

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,
@@ -113,6 +114,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
     const route = authority?.selectedRoute || null;
     const roleState = String(authority?.role?.state || 'unresolved');
     const holderState = String(authority?.holderBinding?.state || 'unresolved');
+    const holderAuthorizationState = String(authority?.holderBinding?.authorization?.state || (holderState === 'not-applicable' ? 'not-applicable' : 'unresolved'));
     if (!route || String(authority?.status || '') === 'blocked') missing(missingEvidence, unresolved, 'authority-route-unqualified', 'The selected Handoff route is not qualified for this grounding result.');
     else known.push(evidence('qualified-handoff-route', 'qualified', route.id || route.pointerPath || 'selected-route'));
     if (roleState === 'qualified' || roleState === 'not-applicable') known.push(evidence('recipient-role-boundary', roleState, authority?.role?.endpoint?.label || 'recipient'));
@@ -120,7 +122,6 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
     else missing(missingEvidence, unresolved, 'recipient-role-unresolved', 'The Handoff recipient Role boundary is not qualified for act-ready grounding.');
 
     if (holderState === 'qualified' || holderState === 'not-applicable') {
-      holderBindingActReady = true;
       known.push(evidence('session-holder-role-binding', holderState, authority?.holderBinding?.roleLabel || authority?.role?.endpoint?.label || 'recipient'));
     } else if (holderState === 'blocked') {
       holderBindingActReady = false;
@@ -131,13 +132,28 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
       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.'));
     }
 
+    if (holderState === 'not-applicable') {
+      holderBindingActReady = true;
+      known.push(evidence('session-holder-role-binding-authorization', 'not-applicable', 'selected Handoff recipient is not a Role endpoint'));
+    } else if (holderState === 'qualified') {
+      if (holderAuthorizationState === 'qualified') {
+        holderBindingActReady = true;
+        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?.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.'));
+      }
+    }
+
     const required = Array.isArray(requiredContext) ? requiredContext : [];
     const unresolvedRequired = required.filter((entry) => entry.state !== 'qualified');
     if (unresolvedRequired.length) missing(missingEvidence, unresolved, 'required-context-unqualified', `${unresolvedRequired.length} declared Required Context item(s) are not exact-qualified.`);
     else known.push(evidence('required-context-closure', 'qualified', `${required.length} item(s)`));
     if (String(continuation?.state || '') !== 'ready') missing(missingEvidence, unresolved, 'continuation-not-ready', 'The grounded continuation is not ready for substantive work.');
-    if (String(contextAudit?.status || '') !== 'ready' || String(contextAudit?.coverage?.state || '') !== 'qualified') missing(missingEvidence, unresolved, 'workspace-snapshot-coverage-unqualified', 'Complete carried Workspace snapshot coverage is not qualified.');
-    else known.push(evidence('workspace-snapshot-coverage', 'qualified', `${contextAudit.workspaceMaterializations?.length || 0} workspace(s)`));
+    const workspaceCoverage = projectWorkspaceActionCoverage(contextAudit);
+    if (!workspaceCoverage.qualified) missing(missingEvidence, unresolved, 'workspace-snapshot-coverage-unqualified', workspaceCoverage.message);
+    else known.push(evidence('workspace-snapshot-coverage', 'qualified', `${workspaceCoverage.count} workspace representation(s): ${workspaceCoverage.completeCount} complete, ${workspaceCoverage.boundedCount} bounded`));
     for (const item of requiredRecordResolution.missing) missing(missingEvidence, unresolved, 'required-context-not-in-snapshot', item);
     if (!routeRecordIds.size) missing(missingEvidence, unresolved, 'selected-route-not-in-snapshot', 'The qualified selected Handoff route was not found at its exact carried Workspace path.');
   } else {
@@ -148,7 +164,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
   if (!records.length) missing(missingEvidence, unresolved, 'no-artifact-records', 'No readable Tiinex artifact records were loaded for grounding.');
   else known.push(evidence('loaded-artifact-records', 'known', `${records.length} record(s)`));
 
-  inferred.push(evidence('relevant-lineage-scope', 'bounded-inference', handoffMode ? 'directed declared-Parent cone around the exact selected Handoff route within complete carried Workspace snapshots plus independently qualified exact detached Parent-boundary cache records' : 'all loaded records'));
+  inferred.push(evidence('relevant-lineage-scope', 'bounded-inference', handoffMode ? 'directed declared-Parent cone around the exact selected Handoff route within qualified carried Workspace representations (complete or bounded as declared) plus independently qualified exact detached Parent-boundary cache records' : 'all loaded records'));
   inferred.push(evidence('lineage-leaf-role', 'bounded-inference', 'derived only from declared Parent edges in the shared resolver'));
 
   if (handoffMode) {
@@ -157,7 +173,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
     } else if (topology.routeLeaves.length) {
       known.push(evidence('selected-route-parent-lineage-leaf', 'resolved', `${topology.routeLeaves.length} selected-route leaf/leaves`));
     } else {
-      missing(missingEvidence, unresolved, 'selected-route-lineage-leaf-missing', 'The selected Handoff route is not a resolved Parent-lineage leaf in the complete carried Workspace snapshots.');
+      missing(missingEvidence, unresolved, 'selected-route-lineage-leaf-missing', 'The selected Handoff route is not a resolved Parent-lineage leaf in the qualified carried Workspace material.');
     }
     if (lineageIssues.length > routeBlockingLineageIssues.length) unresolved.push(evidence('upstream-lineage-diagnostics', continuity.state === 'qualified' ? 'degraded-nonblocking' : 'blocking-for-cold-start-continuity', `${lineageIssues.length - routeBlockingLineageIssues.length} upstream Parent-lineage issue(s) remain outside the selected-route edge boundary.`));
   } else if (lineageIssues.length) {
@@ -190,7 +206,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
   let state = 'grounded-to-act';
   if (missingEvidence.length) state = 'insufficient-grounding';
   else if (!handoffMode || !holderBindingActReady || !topology.currentFrontier.length || humanOnly.length) state = 'grounded-to-discuss';
-  if (state === 'grounded-to-act') reasons.push(reason('bounded-act-ready', 'Selected Handoff authority, explicit consuming-session holder Role binding, Required Context, carried Workspace coverage, cold-start continuity to a qualified semantic root, the selected-route Parent-lineage leaf, and declared current-work frontier evidence are all resolved enough for the next bounded action.'));
+  if (state === 'grounded-to-act') reasons.push(reason('bounded-act-ready', 'Selected Handoff authority, explicit consuming-session holder Role binding, exact qualified holder-assignment authorization where the recipient is a Role, exact Required Context, qualified carried Workspace coverage (complete or bounded as declared), cold-start continuity to a qualified semantic root, the selected-route Parent-lineage leaf, and declared current-work frontier evidence are all resolved enough for the next bounded action.'));
   const orchestrationReadiness = projectGroundingOrchestrationReadiness({ readinessState: state, participantContext: capsule.participantContext, processApplicability: capsule.processApplicability, sourceEvidence: capsule.sourceEvidence, topology });
 
   return Object.freeze({
@@ -218,11 +234,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
         requestedSelectors: requiredContextProjection.requestedSelectors,
         unmatchedSelectors: requiredContextProjection.unmatchedSelectors
       }),
-      workspaceSnapshots: contextAudit ? Object.freeze({
-        state: String(contextAudit.coverage?.state || contextAudit.status || 'unresolved'),
-        qualified: String(contextAudit.status || '') === 'ready',
-        count: contextAudit.workspaceMaterializations?.length || 0
-      }) : Object.freeze({ state: 'not-supplied', qualified: false, count: 0 })
+      workspaceSnapshots: contextAudit ? projectWorkspaceActionCoverage(contextAudit) : Object.freeze({ state: 'not-supplied', qualified: false, count: 0, completeCount: 0, boundedCount: 0, unqualified: Object.freeze([]), message: 'No carried Workspace context audit was supplied.' })
     }),
     lineage: Object.freeze({
       state: handoffMode ? (routeBlockingLineageIssues.length ? 'unresolved' : topology.routeLeaves.length ? (lineageIssues.length ? 'resolved-with-upstream-degradation' : 'resolved') : 'missing-leaf') : (lineageIssues.length ? 'unresolved' : topology.leaves.length ? 'resolved' : 'missing-leaf'),
@@ -243,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',
@@ -277,6 +290,61 @@ 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) => {
+    const coverage = workspaceCoverageState(workspace);
+    const qualification = String(workspace?.qualification || '').trim().toLowerCase();
+    const qualified = ['complete', 'bounded'].includes(coverage) && qualification === 'qualified';
+    return Object.freeze({ workspaceId: String(workspace?.workspaceId || ''), coverage, qualification: qualification || 'unresolved', qualified });
+  });
+  const aggregateReady = String(contextAudit?.status || '') === 'ready' && String(contextAudit?.coverage?.state || '') === 'qualified';
+  const qualified = aggregateReady && summaries.length > 0 && summaries.every((item) => item.qualified);
+  const completeCount = summaries.filter((item) => item.coverage === 'complete').length;
+  const boundedCount = summaries.filter((item) => item.coverage === 'bounded').length;
+  const unqualified = summaries.filter((item) => !item.qualified);
+  const message = qualified
+    ? `Qualified carried Workspace coverage is established for ${summaries.length} representation(s): ${completeCount} complete, ${boundedCount} bounded.`
+    : !aggregateReady
+      ? 'Carried Workspace context audit is not qualified for bounded action readiness.'
+      : !summaries.length
+        ? 'No qualified carried Workspace representation is available for the selected Handoff route.'
+        : `Carried Workspace representation qualification is incomplete for ${unqualified.length} workspace(s); bounded carriage is actionable only when each carried representation is independently qualified as complete or bounded.`;
+  return Object.freeze({
+    state: qualified ? 'qualified' : 'unqualified',
+    qualified,
+    count: summaries.length,
+    completeCount,
+    boundedCount,
+    unqualified: Object.freeze(unqualified),
+    message,
+    boundary: 'Complete and bounded carriage remain distinct. Bounded coverage can satisfy current-route action readiness only when the carried representation itself is qualified; it never implies whole-Workspace or whole-program authority.'
+  });
+}
+
+function workspaceCoverageState(workspace = {}) {
+  const explicit = String(workspace?.coverage || workspace?.materialization || '').trim().toLowerCase();
+  if (explicit === 'complete' || explicit === 'bounded') return explicit;
+  const reason = String(workspace?.reason || '').trim().toLowerCase();
+  if (reason.includes('bounded') || reason.includes('partial')) return 'bounded';
+  if (reason.includes('complete')) return 'complete';
+  return 'unresolved';
+}
+
 function projectCurrentWork(topology = {}, records = [], includeCurrentWork = false) {
   const recordById = new Map((records || []).map((record) => [String(record.id || ''), record]));
   const frontier = (topology.currentFrontier || []).slice(0, MAX_ITEMS).map((item) => {
@@ -300,8 +368,13 @@ 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 + required context + cold-start root continuity + selected-route Parent leaf + declared current-work frontier' });
+  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-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'
+  });
   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({
     kind: continuity.recovery?.state === 'host-action-available' ? 'recover-required-parent-with-host-action' : 'request-exact-required-parent-material',

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

@@ -168,13 +168,13 @@ export function resolveRequiredContextRecords(requiredContext = [], records = []
     const record = byPath.get(expectedPath);
     if (record) { ids.add(record.id); matched += 1; continue; }
     if (isExactHydratedWorkspaceContext(entry)) { matched += 1; continue; }
-    missing.push(`${entry.requirementId || entry.name || expectedPath}: exact qualified context was not found at ${expectedPath} inside the complete carried Workspace snapshots.`);
+    missing.push(`${entry.requirementId || entry.name || expectedPath}: exact qualified context was not found at ${expectedPath} inside the qualified carried Workspace material.`);
   }
   return Object.freeze({ ids, matched, missing: Object.freeze(missing) });
 }
 
 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 {
@@ -31,6 +32,7 @@ import {
   normalizeStringList,
   normalizeToken
 } from './coldStartQualification.shared.js';
+import { projectHolderBindingAuthorization } from '../grounding/grounding.holderBindingAuthorization.js';
 
 export function groundPortableColdConsumer(input = {}, options = {}) {
   const ingressKind = normalizeIngressKind(input.ingressKind || input.kind || (input.toolingAvailable === false ? COLD_START_INGRESS_KINDS.DEGRADED_CAPTURE : COLD_START_INGRESS_KINDS.HANDOFF));
@@ -59,7 +61,8 @@ export function groundPortableColdConsumer(input = {}, options = {}) {
 
   const bundle = input.bundle || input.package || input;
   const role = groundRecipientRole(input, handoff, bundle, orientation, selectedRoute, findings, materialContext);
-  const holderBinding = groundHolderBinding(input, handoff, findings);
+  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);
 
@@ -68,7 +71,12 @@ export function groundPortableColdConsumer(input = {}, options = {}) {
   }
 
   const blocked = findings.some((finding) => finding.severity === 'error');
-  const degraded = degradedCapture.active || role.state === 'degraded' || holderBinding.state === 'unresolved' || interaction.modeState === 'unresolved' || participation.participantState === 'unresolved';
+  const degraded = degradedCapture.active
+    || role.state === 'degraded'
+    || holderBinding.state === 'unresolved'
+    || holderBinding.authorization?.state === 'unresolved'
+    || interaction.modeState === 'unresolved'
+    || participation.participantState === 'unresolved';
   return deepFreeze({
     schema: PORTABLE_COLD_CONSUMER_GROUNDING_SCHEMA_ID,
     version: 1,
@@ -78,6 +86,7 @@ export function groundPortableColdConsumer(input = {}, options = {}) {
     selectedRoute,
     handoff,
     role,
+    senderRole,
     holderBinding,
     participation,
     interaction,
@@ -114,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({
@@ -178,13 +231,14 @@ function groundRecipientRole(input, handoff, bundle, orientation, selectedRoute,
     compatibility,
     exactBoundaryLoaded: selected ? selected.boundary : null,
     authorityBoundaryLoaded: selected ? selected.authorityBoundary : null,
+    holderRelationshipLoaded: selected ? selected.holderRelationship : null,
     interpretationLimitsLoaded: selected ? selected.interpretationLimits : null,
     boundary: 'A Handoff `To Kind: role` endpoint remains bounded even when current Role material is missing. Matching Role material qualifies the loaded boundary but does not prove a human holder, consent, or authority beyond the Role artifact itself.'
   });
 }
 
 
-function groundHolderBinding(input, handoff, findings) {
+function groundHolderBinding(input, handoff, role, findings) {
   const raw = input.holderBinding || input.sessionHolderBinding || input.sessionRoleBinding || {};
   const explicit = typeof raw === 'string' ? { roleLabel: raw } : (raw && typeof raw === 'object' ? raw : {});
   const roleLabel = String(explicit.roleLabel || explicit.role || input.holderRole || input.sessionRole || '').trim();
@@ -193,14 +247,22 @@ function groundHolderBinding(input, handoff, 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.'
@@ -211,10 +273,14 @@ function groundHolderBinding(input, handoff, findings) {
     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.'
@@ -226,10 +292,14 @@ function groundHolderBinding(input, handoff, findings) {
     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.'
@@ -239,19 +309,60 @@ function groundHolderBinding(input, handoff, findings) {
   return deepFreeze({
     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 holderDurableIdentityProjection(holderId = '') {
+  return deepFreeze({
+    state: 'not-established',
+    declaredHolderId: String(holderId || ''),
+    boundary: 'A bounded session Role assertion and its assignment authorization do not establish durable Party/person/model holder identity. Exact holder/Party authority would be required separately.'
+  });
+}
+
+function holderBindingSourceDetail(input = {}, explicit = {}, explicitlySupplied = false) {
+  if (!explicitlySupplied) return deepFreeze({
+    kind: 'none',
+    locator: '',
+    authorityClass: 'none',
+    semanticAuthorityState: 'not-established',
+    qualifiedMaterialSource: false,
+    boundary: 'No consuming-session holder declaration was supplied.'
+  });
+  const declaredLocator = String(explicit.sourceLocator || explicit.source || '').trim();
+  let locator = declaredLocator;
+  if (!locator) {
+    if (input.holderBinding) locator = 'input.holderBinding';
+    else if (input.sessionHolderBinding) locator = 'input.sessionHolderBinding';
+    else if (input.sessionRoleBinding) locator = 'input.sessionRoleBinding';
+    else if (input.holderRole || input.holderId) locator = 'input.holderRole/input.holderId';
+    else if (input.sessionRole) locator = 'input.sessionRole';
+    else locator = 'explicit-session-input';
+  }
+  return deepFreeze({
+    kind: 'operator-session-input',
+    locator,
+    authorityClass: 'session-binding-input-only',
+    semanticAuthorityState: 'not-established',
+    qualifiedMaterialSource: false,
+    boundary: 'This source proves only the explicit consuming-session Role-capacity declaration supplied to Tooling. It is not semantic holder-assignment authority carried by qualified material.'
+  });
+}
+
 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();
@@ -286,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