@tiinex/core 0.18.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Shared host-neutral Tiinex implementation core for artifacts, schemas, validation, lineage, grounding, Handoffs, provenance and deterministic workflows.",
   "type": "module",
   "sideEffects": true,
@@ -79,6 +79,7 @@
     "./tooling/portable/grounding/grounding.capsule.js": "./src/tooling/portable/grounding/grounding.capsule.js",
     "./tooling/portable/grounding/grounding.participantAuthority.js": "./src/tooling/portable/grounding/grounding.participantAuthority.js",
     "./tooling/portable/grounding/grounding.processApplicability.js": "./src/tooling/portable/grounding/grounding.processApplicability.js",
+    "./tooling/portable/grounding/grounding.implementationSourceAuthority.js": "./src/tooling/portable/grounding/grounding.implementationSourceAuthority.js",
     "./tooling/portable/grounding/grounding.readiness.js": "./src/tooling/portable/grounding/grounding.readiness.js",
     "./tooling/portable/grounding/grounding.workProvenance.js": "./src/tooling/portable/grounding/grounding.workProvenance.js",
     "./tooling/portable/handoff/carrierLineage.js": "./src/tooling/portable/handoff/carrierLineage.js",
@@ -170,12 +171,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "12321ec2a8d09722b464ef7977afa2dcdc924718",
+  "gitHead": "fe01706aecacbf28c66e2ac052e4f639170dfe73",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "12321ec2a8d09722b464ef7977afa2dcdc924718",
-    "sourceTree": "eba0d10ad8f5fc20cc1c98ee88c328fbd4dafa4c",
+    "sourceCommit": "fe01706aecacbf28c66e2ac052e4f639170dfe73",
+    "sourceTree": "b4e5dbb825a1504fef53f1e5281d4bd6fd3c87ff",
     "repository": "Tiinex/core",
-    "previousVersion": "0.17.0"
+    "previousVersion": "0.18.0"
   }
 }

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

@@ -117,7 +117,7 @@ export async function commandInput(parsed, runtime = {}) {
         packageSourcePath: packagePath,
         includeLegacyTopics: Boolean(flags['include-legacy-topics']),
         includeRequiredContext: flags['include-required-context'] || '',
-        holderBinding: { roleLabel: flags['holder-role'] || '', holderId: flags['holder-id'] || '' },
+        holderBinding: { roleLabel: flags['holder-role'] || '', holderId: flags['holder-id'] || '', sourceLocator: holderBindingCliSource(flags) },
         host,
         recoveryAcceptance
       },
@@ -471,4 +471,11 @@ function mergeLoadedMaterial(primary = {}, secondary = {}) {
 }
 
 function normalizeRuntimePaths(value) { const paths = Array.isArray(value) ? value : value ? [value] : []; return paths.map((entry) => String(entry || '').trim()).filter(Boolean); }
+function holderBindingCliSource(flags = {}) {
+  const fields = [];
+  if (Object.prototype.hasOwnProperty.call(flags, 'holder-role')) fields.push('--holder-role');
+  if (Object.prototype.hasOwnProperty.call(flags, 'holder-id')) fields.push('--holder-id');
+  return fields.length ? `cli:${fields.join(',')}` : '';
+}
+
 function splitFlag(value) { return !value || value === true ? [] : String(value).split(',').map((item) => item.trim()).filter(Boolean); }

package/src/tooling/portable/adapters/cli/cli.common-output.js

@@ -163,6 +163,7 @@ function projectHandoffDefault(result = {}, parsed = {}) {
       status: String(carrier.status || ''),
       mode: String(carrier.mode || ''),
       lineage: carrier.lineage ? compactCarrierLineage(carrier.lineage) : null,
+      allocation: result.carrierAllocation ? Object.freeze({ ...result.carrierAllocation }) : null,
       route: Object.freeze({
         id: String(route.id || ''),
         state: String(route.state || ''),
@@ -275,11 +276,17 @@ function compactGroundAuthority(authority = {}) {
     }),
     holderBinding: Object.freeze({
       state: String(holderBinding.state || ''),
+      bindingPresent: Boolean(holderBinding.bindingPresent),
+      declarationPresent: Boolean(holderBinding.declarationPresent),
       holderId: String(holderBinding.holderId || ''),
       roleLabel: String(holderBinding.roleLabel || ''),
       recipientRoleLabel: String(holderBinding.recipientRoleLabel || ''),
       recipientCompatibility: String(holderBinding.recipientCompatibility || ''),
       source: String(holderBinding.source || ''),
+      sourceDetail: holderBinding.sourceDetail ? Object.freeze({ ...holderBinding.sourceDetail }) : null,
+      authorization: holderBinding.authorization ? Object.freeze({ ...holderBinding.authorization, provenance: holderBinding.authorization.provenance ? Object.freeze({ ...holderBinding.authorization.provenance }) : null }) : null,
+      durableIdentity: holderBinding.durableIdentity ? Object.freeze({ ...holderBinding.durableIdentity }) : Object.freeze({ state: 'not-established' }),
+      semanticAuthorityState: String(holderBinding.semanticAuthorityState || 'not-established'),
       explicit: Boolean(holderBinding.explicit),
       inferredFromTransport: Boolean(holderBinding.inferredFromTransport),
       provenance: holderBinding.provenance ? Object.freeze({ ...holderBinding.provenance }) : null

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

@@ -10,7 +10,7 @@ import { projectRecipientV2HumanOutput } from '../../handoff/recipientV2.humanOu
 import { inspectRecipientFacingV2Topology } from '../../handoff/recipientV2.inspect.js';
 import { carrierLineageFromCliParent, initialHandoffCarrierLineage, parentHandoffCarrierLineageFromBundle, parentHandoffCarrierProfileFromBundle } from '../../handoff/carrierLineage.js';
 import { loadNodePortableInput } from '../../input/node.input.js';
-import { reserveHandoffSiblingIndex } from './cli.handoff-sibling-allocation.js';
+import { resolveHandoffSiblingAllocation } from './cli.handoff-sibling-allocation.js';
 import { normalizeHandoffCarrierProfile } from '../../handoff/carrierProfile.js';
 
 export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime = {}) {
@@ -26,7 +26,6 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
   const handoffPath = flags.handoff || parsed.positionals?.[1] || continuationState.returnHandoffPath || '';
   if (!flags['workspace-id'] && continuationState.workspaceId) flags['workspace-id'] = continuationState.workspaceId;
   if (!flags['workspace-target'] && continuationState.workspaceTarget) flags['workspace-target'] = continuationState.workspaceTarget;
-  if (!flags['package-sibling-index'] && continuationState.returnPackageSiblingIndex) flags['package-sibling-index'] = continuationState.returnPackageSiblingIndex;
   if (!flags['package-parent'] && continuationState.packageParentPath) flags['package-parent'] = continuationState.packageParentPath;
   if (!flags.route && handoffPath) flags.route = handoffPath;
   if (!flags.output && !flags['output-dir'] && parsed.surfaceCommand === 'handoff' && continuationState.returnOutputDir) flags['output-dir'] = continuationState.returnOutputDir;
@@ -55,6 +54,7 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
   let packageParentSha256 = '';
   let carrierLineage = initialHandoffCarrierLineage();
   let inheritedCarrierProfile = normalizeHandoffCarrierProfile(null);
+  let carrierAllocation = Object.freeze({ state: 'root', allocationMode: 'initial-root', siblingIndex: null, provenance: Object.freeze({ basis: 'initial-carrier-root' }) });
   if (parentPackagePath) {
     const resolvedParent = path.resolve(parentPackagePath);
     const parentBytes = new Uint8Array(await readFile(resolvedParent));
@@ -86,21 +86,35 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
       major: Boolean(flags['package-major']),
       majorReason: flags['major-reason'] || ''
     });
-    const siblingAllocation = await reserveHandoffSiblingIndex({
-      parentPackagePath: resolvedParent,
-      parentPackageSha256: provisionalLineage.parentPackageSha256,
-      parentDimension: provisionalLineage.parentDimension,
-      enabled: !flags['package-major'] && Boolean(flags.output || flags['output-dir']),
-      siblingIndex: flags['package-sibling-index']
-    });
-    carrierLineage = flags['package-major'] ? provisionalLineage : carrierLineageFromCliParent({
-      bundle: parentBundle,
-      parentPath: resolvedParent,
-      parentBytes,
-      routeDimensions,
-      qualifiedParentLineage: parentLineage,
-      siblingIndex: siblingAllocation.siblingIndex
-    });
+    if (flags['package-major']) {
+      carrierLineage = provisionalLineage;
+      carrierAllocation = Object.freeze({
+        state: 'qualified', allocationMode: 'explicit-major', siblingIndex: null,
+        provenance: Object.freeze({ basis: 'explicit-major-request', parentPackagePath: resolvedParent, parentPackageSha256: provisionalLineage.parentPackageSha256, parentDimension: provisionalLineage.parentDimension }),
+        boundary: 'Carrier Major creation remains explicit and separate from non-Major pointer-order allocation.'
+      });
+    } else {
+      const parentInspection = inspectRecipientFacingV2Topology(parentBundle);
+      const siblingAllocation = await resolveHandoffSiblingAllocation({
+        parentInspection,
+        parentPackagePath: resolvedParent,
+        parentPackageSha256: provisionalLineage.parentPackageSha256,
+        parentDimension: provisionalLineage.parentDimension,
+        selectedRoutePointer: continuationState.selectedRoutePointer || flags['package-parent-route-pointer'] || '',
+        selectedRouteId: continuationState.selectedRouteId || flags['package-parent-route-id'] || '',
+        explicitSiblingIndex: flags['package-sibling-index'],
+        enabled: Boolean(flags.output || flags['output-dir'])
+      });
+      carrierAllocation = siblingAllocation;
+      carrierLineage = carrierLineageFromCliParent({
+        bundle: parentBundle,
+        parentPath: resolvedParent,
+        parentBytes,
+        routeDimensions,
+        qualifiedParentLineage: parentLineage,
+        siblingIndex: siblingAllocation.siblingIndex
+      });
+    }
     packageParentSha256 = String(carrierLineage.parentPackageSha256 || '');
   } else if (flags['package-major']) {
     throw new Error('portable.cli.handoff-carrier.package-major.parent-required');
@@ -129,6 +143,7 @@ export async function prepareHandoffManufactureCliCommand(parsed = {}, runtime =
     verifyRoundtrip,
     recipientRouteSelector: flags.route || '',
     carrierLineage,
+    carrierAllocation,
     carrierProfile,
     packageParentBundle,
     packageParentPath: parentPackagePath ? path.resolve(parentPackagePath) : '',
@@ -329,6 +344,7 @@ export function summarizeHandoffManufactureCliOutput(result = {}, writeReceipt =
     }) : null,
     toolingBootstrap: result.toolingBootstrap || null,
     carrierLineage: result.carrierLineage || projection.lineage || null,
+    carrierAllocation: result.carrierAllocation || result.manufacturingEvidence?.carrierAllocation || null,
     majorReadiness: result.majorReadiness || null,
     operationBoundary: result.operationBoundary ? Object.freeze({ ...result.operationBoundary }) : null,
     manufacturingEvidence: result.manufacturingEvidence || null,

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

@@ -2,6 +2,125 @@ import { mkdir, open, readFile } from 'node:fs/promises';
 import path from 'node:path';
 
 const MAX_SIBLING_INDEX = 9999;
+const POINTER_PATH_RE = /^(\d{3}(?:-\d+)*)-handoff-pointer\.trace\.md$/;
+
+export function deriveHandoffSiblingAllocation({ parentInspection = null, selectedRoutePointer = '', selectedRouteId = '', 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: explicit || null,
+    allocationMode: explicit ? 'explicit-override-only' : 'unavailable',
+    reasonCode: 'qualified-parent-route-topology-unavailable',
+    provenance: provenanceBase({ parentPackagePath, parentPackageSha256, parentDimension, explicitSiblingIndex: explicit }),
+    boundary: allocationBoundary()
+  });
+  if (String(inspection.status || '') !== 'valid') return freeze({
+    state: 'blocked',
+    siblingIndex: null,
+    allocationMode: 'blocked',
+    reasonCode: 'qualified-parent-route-topology-invalid',
+    provenance: provenanceBase({ parentPackagePath, parentPackageSha256, parentDimension, explicitSiblingIndex: explicit }),
+    boundary: allocationBoundary()
+  });
+
+  const routes = [...(inspection.routes || [])].map((route) => ({
+    pointerPath: String(route.pointerPath || '').trim(),
+    routeId: String(route.routeId || '').trim(),
+    workspaceId: String(route.workspaceId || '').trim(),
+    workspaceRelativeHandoffPath: String(route.workspaceRelativeHandoffPath || '').trim()
+  }));
+  if (!routes.length) return blocked('qualified-parent-route-topology-empty');
+
+  const qualified = [];
+  const seenDimensions = new Set();
+  for (const route of routes) {
+    const match = route.pointerPath.match(POINTER_PATH_RE);
+    if (!match) return blocked('qualified-parent-route-pointer-order-unresolved');
+    const dimension = match[1];
+    if (seenDimensions.has(dimension)) return blocked('qualified-parent-route-pointer-order-ambiguous');
+    seenDimensions.add(dimension);
+    qualified.push({ ...route, pointerDimension: dimension, pointerSegments: dimension.split('-').map((value) => Number.parseInt(value, 10)) });
+  }
+  qualified.sort(comparePointerOrder);
+
+  const pointerSelector = String(selectedRoutePointer || '').trim();
+  const routeIdSelector = String(selectedRouteId || '').trim();
+  let selected = null;
+  if (pointerSelector) {
+    const matches = qualified.filter((route) => route.pointerPath === pointerSelector);
+    if (matches.length !== 1) return blocked(matches.length ? 'selected-parent-route-pointer-ambiguous' : 'selected-parent-route-pointer-unqualified');
+    selected = matches[0];
+  }
+  if (routeIdSelector) {
+    const matches = qualified.filter((route) => route.routeId === routeIdSelector);
+    if (matches.length !== 1) return blocked(matches.length ? 'selected-parent-route-id-ambiguous' : 'selected-parent-route-id-unqualified');
+    if (selected && selected.pointerPath !== matches[0].pointerPath) return blocked('selected-parent-route-selector-conflict');
+    selected = matches[0];
+  }
+  if (!selected) {
+    if (qualified.length !== 1) return blocked('selected-parent-route-required-for-parallel-topology');
+    selected = qualified[0];
+  }
+
+  const siblingIndex = qualified.findIndex((route) => route.pointerPath === selected.pointerPath) + 1;
+  if (!Number.isInteger(siblingIndex) || siblingIndex < 1 || siblingIndex > MAX_SIBLING_INDEX) return blocked('derived-sibling-index-out-of-range');
+  if (explicit && explicit !== siblingIndex) return blocked('explicit-sibling-index-conflicts-with-qualified-topology', { expectedSiblingIndex: siblingIndex });
+
+  return freeze({
+    state: 'qualified',
+    siblingIndex,
+    childDimension: parentDimension ? `${String(parentDimension).trim()}-${siblingIndex}` : '',
+    allocationMode: 'qualified-parent-route-pointer-ordinal',
+    explicitOverride: explicit ? 'matched-derived-value' : 'not-supplied',
+    reasonCode: '',
+    provenance: {
+      ...provenanceBase({ parentPackagePath, parentPackageSha256, parentDimension, explicitSiblingIndex: explicit }),
+      basis: 'qualified-parent-route-pointer-ordinal',
+      selectedRoutePointer: selected.pointerPath,
+      selectedRouteId: selected.routeId,
+      selectedWorkspaceId: selected.workspaceId,
+      selectedWorkspaceRelativeHandoffPath: selected.workspaceRelativeHandoffPath,
+      routeOrdinal: siblingIndex,
+      qualifiedRouteCount: qualified.length,
+      pointerOrder: qualified.map((route, index) => Object.freeze({ ordinal: index + 1, pointerPath: route.pointerPath, routeId: route.routeId }))
+    },
+    boundary: allocationBoundary()
+  });
+
+  function blocked(reasonCode, extra = {}) {
+    return freeze({
+      state: 'blocked', siblingIndex: null, allocationMode: 'blocked', reasonCode, ...extra,
+      provenance: provenanceBase({ parentPackagePath, parentPackageSha256, parentDimension, explicitSiblingIndex: explicit }),
+      boundary: allocationBoundary()
+    });
+  }
+}
+
+export async function resolveHandoffSiblingAllocation(input = {}) {
+  const derived = deriveHandoffSiblingAllocation(input);
+  if (derived.state === 'qualified') return derived;
+  if (derived.state === 'blocked') throw new Error(`portable.cli.handoff-carrier.sibling-allocation.${derived.reasonCode}`);
+  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({
+    parentPackagePath: input.parentPackagePath,
+    parentPackageSha256: input.parentPackageSha256,
+    parentDimension: input.parentDimension,
+    enabled: input.enabled !== false,
+    siblingIndex: explicit
+  });
+  return freeze({
+    ...legacy,
+    allocationMode: 'explicit-advanced-override',
+    explicitOverride: 'required-because-qualified-topology-unavailable',
+    provenance: {
+      ...provenanceBase({ ...input, explicitSiblingIndex: explicit }),
+      basis: 'explicit-advanced-override-without-qualified-route-topology'
+    },
+    boundary: allocationBoundary()
+  });
+}
 
 export async function reserveHandoffSiblingIndex({ parentPackagePath = '', parentPackageSha256 = '', parentDimension = '', enabled = true, siblingIndex = null } = {}) {
   const requestedSiblingIndex = normalizeSiblingIndex(siblingIndex);
@@ -35,21 +154,39 @@ export async function reserveHandoffSiblingIndex({ parentPackagePath = '', paren
   }
 }
 
+function comparePointerOrder(left, right) {
+  const a = left.pointerSegments || [], b = right.pointerSegments || [];
+  for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+    if (a[index] === undefined) return -1;
+    if (b[index] === undefined) return 1;
+    if (a[index] !== b[index]) return a[index] - b[index];
+  }
+  return left.pointerPath.localeCompare(right.pointerPath);
+}
+
+function provenanceBase({ parentPackagePath = '', parentPackageSha256 = '', parentDimension = '', explicitSiblingIndex = null } = {}) {
+  return {
+    parentPackagePath: String(parentPackagePath || ''),
+    parentPackageSha256: String(parentPackageSha256 || '').trim().toLowerCase(),
+    parentDimension: String(parentDimension || '').trim(),
+    explicitSiblingIndex: explicitSiblingIndex ? normalizeSiblingIndex(explicitSiblingIndex) : null
+  };
+}
+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;
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_SIBLING_INDEX) throw new Error('portable.cli.handoff-carrier.sibling-allocation.index-invalid');
   return parsed;
 }
-
 async function readAllocation(allocationPath) {
   try { return JSON.parse(await readFile(allocationPath, 'utf8')); }
   catch { throw new Error('portable.cli.handoff-carrier.sibling-allocation.existing-reservation-invalid'); }
 }
-
 function sameAllocation(left = {}, right = {}) {
   return String(left.parentPackageSha256 || '') === String(right.parentPackageSha256 || '')
     && String(left.parentDimension || '') === String(right.parentDimension || '')
     && Number(left.siblingIndex || 0) === Number(right.siblingIndex || 0)
     && String(left.childDimension || '') === String(right.childDimension || '');
 }
+function freeze(value) { if (Array.isArray(value)) return Object.freeze(value.map(freeze)); if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value; return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, freeze(item)]))); }

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

@@ -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. When the outgoing Handoff declares `Signal Kind: return`, delegation manufacture is transport-not-ready unless the delegator supplies `--return-package-sibling-index <1..9999>` for the expected non-Major return, or explicitly declares `--return-package-major`; the qualified reservation is carried in the route pointer and later continuation state. A non-major continuation that writes a carrier must supply an explicitly coordinated `--package-sibling-index <1..9999>`; Tooling will not silently discover the next sibling because isolated runtimes cannot prove a globally unique reservation. Distinct explicit sibling indexes preserve same-Major parallelism, while 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. `--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.',
     '',
     `Advanced/internal catalog: ${command} operations`
   ];

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

@@ -140,7 +140,8 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
   }
   const suppliedTransportRoutes = [...(input.transportRoutes || input.handoffRoutes || [])].map((route) => normalizeTransportRoute(route, workspaceId)).filter(Boolean);
   const reservationProjection = returnCarrierReservationPreflight.state === 'qualified' && returnCarrierReservationPreflight.returnExpected
-    ? Object.freeze({ carrierKind: returnCarrierReservationPreflight.carrierKind, siblingIndex: returnCarrierReservationPreflight.siblingIndex })
+    && (returnCarrierReservationPreflight.carrierKind === 'major' || Number.isInteger(returnCarrierReservationPreflight.siblingIndex))
+    ? Object.freeze({ carrierKind: returnCarrierReservationPreflight.carrierKind, ...(Number.isInteger(returnCarrierReservationPreflight.siblingIndex) ? { siblingIndex: returnCarrierReservationPreflight.siblingIndex } : {}) })
     : null;
   const transportRoutes = Object.freeze((suppliedTransportRoutes.length ? suppliedTransportRoutes : [Object.freeze({ workspaceId, path: handoffPath })]).map((route) => Object.freeze({ ...route, ...(route.path === handoffPath && String(route.workspaceId || '') === workspaceId && reservationProjection ? { returnCarrierReservation: reservationProjection } : {}) })));
   const workspaceTargets = mergeWorkspaceTargetBindings(normalizeWorkspaceTargetBindings({
@@ -205,6 +206,7 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
     transportRoutes,
     workspaceTargets,
     carrierLineage: normalizeHandoffCarrierLineage(input.carrierLineage || null),
+    carrierAllocation: input.carrierAllocation ? Object.freeze({ ...input.carrierAllocation }) : null,
     carrierProfile: normalizeHandoffCarrierProfile(input.carrierProfile || null),
     toolingBootstrap: toolingBootstrap.summary,
     reconciliationProofQualification,
@@ -218,6 +220,7 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
       reconciliationProof: reconciliationProofQualification,
       schemaReferencePreflight,
       returnCarrierReservationPreflight,
+      carrierAllocation: input.carrierAllocation ? Object.freeze({ ...input.carrierAllocation }) : null,
       packageParentWorkspaceReuse: Object.freeze({
         state: String(packageParentReuse.state || ''),
         providerState: String(packageParentReuse.providerState || ''),

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

@@ -4,6 +4,7 @@ import { projectGroundingSourceEvidence } from './grounding.sourceEvidence.js';
 import { projectGroundingPlanningContext } from './grounding.planningContext.js';
 import { projectGroundingParticipantContext } from './grounding.participantContext.js';
 import { projectGroundingProcessApplicability } from './grounding.processApplicability.js';
+import { projectGroundingImplementationSourceAuthority } from './grounding.implementationSourceAuthority.js';
 
 export const PORTABLE_GROUNDING_CAPSULE_SCHEMA_ID = 'tiinex.portable.grounding-capsule.v1';
 
@@ -16,6 +17,7 @@ export function projectGroundingCapsule({ authority = null, continuation = null,
   const participantAuthority = projectParticipantAuthority(authority);
   const participantContext = projectGroundingParticipantContext(authority);
   const processApplicability = projectGroundingProcessApplicability(authority);
+  const implementationSourceAuthority = projectGroundingImplementationSourceAuthority({ authority, records, contextAudit, requiredContext });
   const sourceEvidence = projectGroundingSourceEvidence({ records, contextAudit, continuation, requiredContext });
   return Object.freeze({
     schema: PORTABLE_GROUNDING_CAPSULE_SCHEMA_ID,
@@ -29,16 +31,21 @@ export function projectGroundingCapsule({ authority = null, continuation = null,
       recipientState: String(authority?.role?.state || 'unresolved'),
       holder: String(authority?.holderBinding?.roleLabel || ''),
       holderState: String(authority?.holderBinding?.state || 'unresolved'),
-      compatibility: String(authority?.holderBinding?.recipientCompatibility || 'unresolved')
+      compatibility: String(authority?.holderBinding?.recipientCompatibility || 'unresolved'),
+      authorizationState: String(authority?.holderBinding?.authorization?.state || (String(authority?.holderBinding?.state || '') === 'not-applicable' ? 'not-applicable' : 'unresolved')),
+      authorizationSource: String(authority?.holderBinding?.authorization?.source || ''),
+      durableIdentityState: String(authority?.holderBinding?.durableIdentity?.state || 'not-established')
     }),
     participantAuthority,
     participantContext,
     processApplicability,
+    implementationSourceAuthority,
     workProvenance,
     unresolved: Object.freeze([
       ...workProvenance.unresolved,
       ...participantContext.unresolved,
       ...processApplicability.unresolved,
+      ...implementationSourceAuthority.unresolved,
       ...sourceEvidence.blockers.map((item) => ({ code: item.code, detail: item.request }))
     ]),
     boundary: 'Full Required Context bodies remain selector-gated.'

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

@@ -0,0 +1,81 @@
+import { deepFreeze, normalizeComparable, normalizeToken } from '../handoff/coldStartQualification.shared.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 = {}) {
+  const endpointKind = normalizeToken(role?.endpoint?.kind || '');
+  if (endpointKind !== 'role') return deepFreeze({
+    state: 'not-applicable',
+    assignmentMode: '',
+    holderState: '',
+    source: 'none',
+    reasonCode: 'recipient-not-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.'
+    },
+    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.'
+  };
+
+  if (!qualifiedMaterial) return deepFreeze({
+    state: 'unresolved',
+    assignmentMode: '',
+    holderState,
+    source: 'none',
+    reasonCode: 'qualified-role-holder-authority-not-established',
+    provenance,
+    boundary: 'A matching session Role assertion remains unauthorized until exact qualified Role material establishes the assignment mode.'
+  });
+
+  const assignmentAuthorized = AUTHORIZED_EXPLICIT_SESSION_OR_HANDOFF_STATES.has(normalizeComparable(holderState));
+  if (!assignmentAuthorized) return deepFreeze({
+    state: 'unresolved',
+    assignmentMode: '',
+    holderState,
+    source: 'qualified-recipient-role-material',
+    reasonCode: holderState ? 'holder-assignment-mode-not-authorized' : 'holder-assignment-mode-unresolved',
+    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.'
+  });
+
+  return deepFreeze({
+    state: 'qualified',
+    assignmentMode: 'explicit-session-or-handoff',
+    holderState,
+    source: 'qualified-recipient-role-material',
+    reasonCode: 'holder-assignment-mode-authorized',
+    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.'
+  });
+}

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

@@ -0,0 +1,109 @@
+const MAX_FACTS = 12;
+const MAX_WORKSPACE_FACTS = 12;
+
+export function projectGroundingImplementationSourceAuthority({ authority = null, records = [], contextAudit = null, requiredContext = [] } = {}) {
+  const supplied = authority?.implementationSourceAuthority || null;
+  const exactUpstream = qualifiesExactUpstreamProjection(supplied);
+  const descriptiveFacts = projectDescriptiveWorkspaceFacts({ records, contextAudit, requiredContext });
+
+  if (!exactUpstream) return Object.freeze({
+    state: 'unresolved',
+    facts: Object.freeze([]),
+    descriptiveFacts,
+    provenance: Object.freeze({
+      basis: 'no-exact-upstream-qualified-implementation-source-authority-projection',
+      sourceArtifact: null,
+      boundary: 'Core does not derive implementation-source creation authority from Workspace carriage, completeness, boundedness, writability language, path adjacency, repository identity, or current Task wording.'
+    }),
+    unresolved: Object.freeze([Object.freeze({
+      code: 'implementation-source-authority-not-established',
+      detail: 'No exact upstream-qualified implementation-source authority projection is present. Workspace purpose/boundary facts remain descriptive only; do not infer permission to create or select implementation source from carriage, writability, repository identity, path adjacency, or executable Task presence.'
+    })]),
+    boundary: 'Semantics-neutral diagnostic only. Core exposes exact upstream authority projections when independently qualified, but does not define allow/deny meaning or manufacture source-creation permission.'
+  });
+
+  const facts = Array.isArray(supplied.facts) ? supplied.facts : Array.isArray(supplied.items) ? supplied.items : [];
+  return Object.freeze({
+    state: 'explicit-qualified-upstream-projection',
+    facts: Object.freeze(facts.slice(0, MAX_FACTS).map((item) => Object.freeze({ ...(item || {}) }))),
+    descriptiveFacts,
+    provenance: Object.freeze({
+      basis: 'exact-upstream-qualified-implementation-source-authority-projection',
+      sourceArtifact: Object.freeze(projectSourceArtifact(supplied)),
+      upstreamProvenance: supplied.provenance ? Object.freeze({ ...(supplied.provenance || {}) }) : null,
+      boundary: 'Core passes through the already-qualified upstream projection and exact source-artifact identity without interpreting its semantic allow/deny meaning.'
+    }),
+    unresolved: Object.freeze([]),
+    boundary: 'Semantics-neutral pass-through only. The upstream semantic owner defines the meaning of projected facts; Core neither broadens nor converts them into generic source authority.'
+  });
+}
+
+function qualifiesExactUpstreamProjection(value = null) {
+  if (!value || typeof value !== 'object' || value.explicit !== true) return false;
+  if (String(value.qualification || value.state || '').trim().toLowerCase() !== 'qualified') return false;
+  const source = projectSourceArtifact(value);
+  return Boolean(source.path && /^[0-9a-f]{64}$/i.test(source.sha256));
+}
+
+function projectSourceArtifact(value = {}) {
+  const source = value.sourceArtifact || value.provenance?.sourceArtifact || {};
+  return {
+    workspaceId: String(source.workspaceId || source.workspace || ''),
+    path: String(source.path || source.workspaceRelativePath || value.provenance?.sourceArtifactPath || ''),
+    sha256: String(source.sha256 || value.provenance?.sourceArtifactSha256 || '').trim().toLowerCase(),
+    schemaId: String(source.schemaId || '')
+  };
+}
+
+function projectDescriptiveWorkspaceFacts({ records = [], contextAudit = null, requiredContext = [] } = {}) {
+  const byPath = new Map((records || []).map((record) => [String(record.path || ''), record]));
+  const out = [];
+  for (const workspace of contextAudit?.workspaceMaterializations || []) {
+    if (out.length >= MAX_WORKSPACE_FACTS) break;
+    if (String(workspace.qualification || '') !== 'qualified') continue;
+    const workspaceId = String(workspace.workspaceId || '');
+    const innerPath = normalizePath(workspace.sourceWorkspaceTargetInnerPath || '');
+    const exactPath = workspaceId && innerPath ? `${workspaceId}/${innerPath}` : '';
+    const record = exactPath ? byPath.get(exactPath) : null;
+    if (!record || !record.hasContinuityContext || !record.hasIntegrity) continue;
+    const boundary = section(record.markdown || '', 'Workspace Boundary');
+    if (!boundary) continue;
+    out.push(Object.freeze({
+      kind: 'workspace-boundary',
+      workspace: workspaceId,
+      text: compact(boundary, 500),
+      authorityEffect: 'descriptive-only',
+      provenance: Object.freeze({
+        basis: 'exact-qualified-workspace-artifact-section',
+        sourceArtifactPath: exactPath,
+        sourceArtifactSha256: String(workspace.sourceWorkspaceTargetSha256 || ''),
+        section: 'Workspace Boundary',
+        boundary: 'Exact carried Workspace metadata is exposed as a fact only; Core does not reinterpret boundary prose as implementation-source creation permission.'
+      })
+    }));
+  }
+  for (const entry of requiredContext || []) {
+    if (out.length >= MAX_WORKSPACE_FACTS) break;
+    if (String(entry.state || '') !== 'qualified' || !String(entry.purpose || '').trim()) continue;
+    out.push(Object.freeze({
+      kind: 'required-context-purpose',
+      workspace: String(entry.workspaceId || ''),
+      text: compact(entry.purpose, 500),
+      authorityEffect: 'descriptive-only',
+      provenance: Object.freeze({
+        basis: String(entry.provenance?.basis || 'selected-handoff-required-context-declaration'),
+        declarationSource: entry.provenance?.declarationSource ? Object.freeze({ ...(entry.provenance.declarationSource || {}) }) : null,
+        requirementId: String(entry.requirementId || ''),
+        boundary: 'Selected-Handoff purpose text is exposed verbatim as route context; it is not converted into implementation-source creation authority.'
+      })
+    }));
+  }
+  return Object.freeze(out);
+}
+
+function section(markdown = '', heading = '') {
+  const escaped = String(heading || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return String(markdown || '').match(new RegExp(`(?:^|\\n)##\\s+${escaped}\\s*\\r?\\n([\\s\\S]*?)(?=\\n##\\s+|\\n#\\s+Continuity Integrity|$)`, 'i'))?.[1]?.trim() || '';
+}
+function compact(value = '', limit = 500) { const text = String(value || '').replace(/\s+/g, ' ').trim(); return text.length > limit ? `${text.slice(0, limit - 1).trimEnd()}…` : text; }
+function normalizePath(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\/+/, ''); }

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

@@ -10,7 +10,7 @@ export function projectParticipantAuthority(authority = null) {
     recipientRole: String(role.endpoint?.label || authority?.handoff?.to || ''),
     roleMaterial: Object.freeze({ path: String(material.path || ''), schemaId: String(material.schemaId || ''), roleLabel: String(material.roleLabel || '') }),
     authorityBoundary: Object.freeze({ mayDo: compact(declared.mayDo), doesNotAuthorize: compact(declared.doesNotAuthorize), reviewBoundary: compact(declared.reviewBoundary) }),
-    holderBinding: Object.freeze({ state: String(holder.state || 'unresolved'), roleLabel: String(holder.roleLabel || ''), source: String(holder.source || 'none'), explicit: Boolean(holder.explicit), inferredFromTransport: Boolean(holder.inferredFromTransport) }),
+    holderBinding: Object.freeze({ state: String(holder.state || 'unresolved'), bindingPresent: String(holder.state || '') === 'qualified', declarationPresent: Boolean(holder.explicit), roleLabel: String(holder.roleLabel || ''), source: String(holder.source || 'none'), sourceDetail: holder.sourceDetail ? Object.freeze({ ...(holder.sourceDetail || {}) }) : null, authorization: holder.authorization ? Object.freeze({ ...holder.authorization, provenance: holder.authorization.provenance ? Object.freeze({ ...holder.authorization.provenance }) : null }) : null, durableIdentity: holder.durableIdentity ? Object.freeze({ ...holder.durableIdentity }) : Object.freeze({ state: 'not-established' }), semanticAuthorityState: String(holder.sourceDetail?.semanticAuthorityState || 'not-established'), explicit: Boolean(holder.explicit), inferredFromTransport: Boolean(holder.inferredFromTransport) }),
     participantIdentityCreatesAuthority: false,
     conversationPositionCreatesAuthority: false,
     universalHumanFeedbackRule: false,

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

@@ -38,16 +38,31 @@ export function projectGroundingAuthority(authority, mode) {
     role: authority.role ? Object.freeze({ state: authority.role.state || '', label: authority.role.endpoint?.label || '', kind: authority.role.endpoint?.kind || '' }) : null,
     holderBinding: authority.holderBinding ? Object.freeze({
       state: authority.holderBinding.state || '',
+      bindingPresent: String(authority.holderBinding.state || '') === 'qualified',
+      declarationPresent: Boolean(authority.holderBinding.explicit),
       holderId: authority.holderBinding.holderId || '',
       roleLabel: authority.holderBinding.roleLabel || '',
       recipientRoleLabel: authority.holderBinding.recipientRoleLabel || '',
       recipientCompatibility: authority.holderBinding.recipientCompatibility || '',
       source: authority.holderBinding.source || '',
+      sourceDetail: authority.holderBinding.sourceDetail ? Object.freeze({ ...(authority.holderBinding.sourceDetail || {}) }) : null,
+      authorization: authority.holderBinding.authorization ? Object.freeze({
+        ...(authority.holderBinding.authorization || {}),
+        provenance: authority.holderBinding.authorization.provenance ? Object.freeze({ ...(authority.holderBinding.authorization.provenance || {}) }) : null
+      }) : null,
+      durableIdentity: authority.holderBinding.durableIdentity ? Object.freeze({ ...(authority.holderBinding.durableIdentity || {}) }) : Object.freeze({ state: 'not-established' }),
+      semanticAuthorityState: authority.holderBinding.sourceDetail?.semanticAuthorityState || 'not-established',
       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',
         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),
+        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.'
       }),
       boundary: authority.holderBinding.boundary || ''

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

@@ -113,6 +113,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 +121,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 +131,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?.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.'));
+      }
+    }
+
     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 +163,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 +172,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 +205,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 +233,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'),
@@ -277,6 +288,47 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
   });
 }
 
+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 +352,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,7 +168,7 @@ 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) });
 }

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

@@ -31,6 +31,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 +60,7 @@ 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 holderBinding = groundHolderBinding(input, handoff, role, findings);
   const participation = groundParticipation(input, handoff, bundle, orientation, selectedRoute, findings, materialContext);
   const interaction = groundInteraction(input, handoff);
 
@@ -68,7 +69,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,
@@ -178,13 +184,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,6 +200,9 @@ 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 authorization = projectHolderBindingAuthorization(role);
+  const durableIdentity = holderDurableIdentityProjection(holderId);
 
   if (!roleRecipient) return deepFreeze({
     state: 'not-applicable',
@@ -201,6 +211,9 @@ function groundHolderBinding(input, handoff, findings) {
     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.'
@@ -215,6 +228,9 @@ function groundHolderBinding(input, handoff, findings) {
       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.'
@@ -230,6 +246,9 @@ function groundHolderBinding(input, handoff, findings) {
       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.'
@@ -243,12 +262,52 @@ function groundHolderBinding(input, handoff, findings) {
     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);

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

@@ -160,6 +160,7 @@ export function parseRoleMaterial(entry) {
     const roleSection = sectionText(parsed.body?.text || '', 'Role Identity');
     const boundarySection = sectionText(parsed.body?.text || '', 'Role Boundary');
     const authoritySection = sectionText(parsed.body?.text || '', 'Authority And Responsibility Boundary');
+    const holderSection = sectionText(parsed.body?.text || '', 'Holder Relationship');
     const limitsSection = sectionText(parsed.body?.text || '', 'Interpretation Limits');
     const label = sectionField(roleSection, 'Role Label');
     return deepFreeze({
@@ -172,6 +173,13 @@ export function parseRoleMaterial(entry) {
       roleKind: sectionField(roleSection, 'Role Kind'),
       boundary: Object.freeze({ inScope: sectionField(boundarySection, 'In Scope'), outOfScope: sectionField(boundarySection, 'Out Of Scope'), context: sectionField(boundarySection, 'Context') }),
       authorityBoundary: Object.freeze({ mayDo: sectionField(authoritySection, 'May Do'), doesNotAuthorize: sectionField(authoritySection, 'Does Not Authorize'), reviewBoundary: sectionField(authoritySection, 'Review Boundary') }),
+      holderRelationship: Object.freeze({
+        holderState: sectionField(holderSection, 'Holder State'),
+        currentHolder: sectionField(holderSection, 'Current Holder'),
+        possibleHolder: sectionField(holderSection, 'Possible Holder'),
+        unknownHolder: sectionField(holderSection, 'Unknown Holder'),
+        relationArtifact: sectionReferenceTarget(holderSection, 'Relation Artifact')
+      }),
       interpretationLimits: Object.freeze({ doesNotProve: sectionField(limitsSection, 'Does Not Prove'), mustNotBeTreatedAs: sectionField(limitsSection, 'Must Not Be Treated As') }),
       parentTrace: String(parsed.envelope?.parent?.trace || ''),
       parentSchemaId: String(parsed.envelope?.parent?.schema?.id || '')

package/src/tooling/portable/handoff/delegationReturnReservation.js

@@ -32,14 +32,16 @@ export function qualifyDelegationReturnReservation(input = {}) {
     });
   }
 
+  const rawSupplied = rawIndex !== undefined && rawIndex !== null && String(rawIndex).trim() !== '';
   const siblingIndex = parseSiblingIndex(rawIndex);
-  if (siblingIndex === null) findings.push(finding('error', 'portable.delegation-return-reservation.sibling-index.required', 'A return Handoff is transport-not-ready until the delegator supplies one explicit non-Major return package sibling index in the supported range 1..9999.'));
+  if (rawSupplied && siblingIndex === null) findings.push(finding('error', 'portable.delegation-return-reservation.sibling-index.invalid', 'Explicit return package sibling override must be an integer in the supported range 1..9999.'));
   return freeze({
     schema: PORTABLE_DELEGATION_RETURN_RESERVATION_SCHEMA_ID,
     state: findings.length ? 'blocked' : 'qualified',
     returnExpected: true,
     carrierKind: 'non-major',
     siblingIndex,
+    allocationMode: siblingIndex === null ? 'derive-from-qualified-recipient-selected-pointer' : 'explicit-advanced-override',
     findings,
     boundary: boundary()
   });
@@ -95,7 +97,7 @@ function field(section = '', name = '') {
   const match = String(section || '').match(new RegExp(`^\\s*-\\s+${escapeRegExp(name)}\\s*:\\s*(.+?)\\s*$`, 'mi'));
   return String(match?.[1] || '').trim();
 }
-function boundary() { return 'Transport preflight only. It validates an explicit delegator-coordinated return reservation and never allocates, discovers, increments, guesses, recycles, or promotes a sibling index into semantic Parent, Workspace, Role, acceptance, or completion authority.'; }
+function boundary() { return 'Transport preflight only. Ordinary non-Major return allocation is derived later from the exact qualified selected parent Handoff Pointer ordinal; an explicit return sibling index is an advanced compatibility override only. This projection never promotes transport allocation into semantic Parent, Workspace, Role, acceptance, completion, participant, process, or source authority.'; }
 function finding(severity, code, message) { return Object.freeze({ severity, code, message }); }
 function escapeRegExp(value = '') { return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
 function freeze(value) { if (Array.isArray(value)) return Object.freeze(value.map(freeze)); if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value; return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, freeze(item)]))); }

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

@@ -77,6 +77,7 @@ export function manufactureRecipientRelativeHandoffPackage(input = {}, options =
     roundtrip: upgraded.roundtrip || null,
     toolingBootstrap: input.toolingBootstrap || null,
     manufacturingEvidence: input.manufacturingEvidence || null,
+    carrierAllocation: input.carrierAllocation || input.manufacturingEvidence?.carrierAllocation || null,
     schemaReferencePreflight,
     returnCarrierReservationPreflight,
     reconciliationProofQualification,

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

@@ -5,6 +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 || ''),
     workspaceId: String(item.facts?.workspaceId || ''),
     workspaceRelativeHandoffPath: String(item.facts?.workspaceRelativeHandoffPath || ''),
     returnCarrierReservation: item.facts?.returnCarrierReservation || qualified?.returnCarrierReservation || null,
@@ -17,6 +18,7 @@ export function projectRecipientV2Routes(routePointers = [], endpointPointers =
 export function projectRecipientV2EndpointRoles(pointers = []) {
   return Object.freeze(pointers.map((item) => Object.freeze({
     pointerPath: item.path,
+    routeId: String(item.facts?.routeId || qualified?.id || ''),
     workspaceId: String(item.facts?.workspaceId || ''),
     routeId: String(item.facts?.routeId || ''),
     requirementId: String(item.facts?.endpointRequirementId || ''),
@@ -36,6 +38,7 @@ export function projectRecipientV2EndpointRoles(pointers = []) {
 export function projectRecipientV2ParticipantRoles(pointers = []) {
   return Object.freeze(pointers.map((item) => Object.freeze({
     pointerPath: item.path,
+    routeId: String(item.facts?.routeId || qualified?.id || ''),
     workspaceId: String(item.facts?.workspaceId || ''),
     routeId: String(item.facts?.routeId || ''),
     roleLabelHint: String(item.facts?.roleLabelHint || ''),

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

@@ -256,7 +256,7 @@ export function inspectRecipientFacingV2PackageV1(bundle = {}, options = {}) {
   return deepFreeze({
     schema: 'tiinex.portable.recipient-facing-handoff-package-v1.inspection.v1', detected: Boolean(packageFile), status, format: RECIPIENT_V2_PACKAGE_V1_FORMAT_ID,
     rootArtifact: packageFile ? Object.freeze({ path: packageFile.path, schemaId: RECIPIENT_V2_PACKAGE_V1_SCHEMA_ID, sha256: sha256Hex(packageFileBytes(packageFile)), carrierLineage: lineage }) : null,
-    readArtifact, workspaces: Object.freeze(workspaceParts.map((item) => Object.freeze({ workspaceId: item.workspaceId, coverage: String(item.representation?.coverage || item.facts?.coverage || 'complete'), bindingState: item.bindingState || String(item.representation?.bindingState || 'verified'), workspaceArtifactPath: item.artifact.path, workspaceArchivePath: item.archiveFile?.path || '', sourceWorkspaceTargetInnerPath: item.facts.sourceWorkspaceTargetInnerPath, sourceWorkspaceTargetSha256: item.facts.sourceWorkspaceTargetSha256 }))), sealedWorkspaces: Object.freeze(sealedWorkspaceBindings),
+    readArtifact, workspaces: Object.freeze(workspaceParts.map((item) => Object.freeze({ workspaceId: item.workspaceId, coverage: String(item.representation?.coverage || item.facts?.coverage || 'complete'), bindingState: item.bindingState || String(item.representation?.bindingState || 'verified'), workspaceArtifactPath: item.artifact.path, workspaceRepresentationArtifactPath: String(item.representationArtifact?.path || ''), workspacePayloadArtifactPath: String(item.payloadArtifact?.path || item.protectedPayloadArtifact?.path || ''), workspaceArchivePath: item.archiveFile?.path || '', sourceWorkspaceTargetInnerPath: item.facts.sourceWorkspaceTargetInnerPath, sourceWorkspaceTargetSha256: item.facts.sourceWorkspaceTargetSha256 }))), sealedWorkspaces: Object.freeze(sealedWorkspaceBindings),
     routes: projectRecipientV2Routes(routePointers, endpointRolePointers, participantRolePointers, carrierProjection?.routes || []), endpointRoles: projectRecipientV2EndpointRoles(endpointRolePointers), participantRoles: projectRecipientV2ParticipantRoles(participantRolePointers),
     caches: Object.freeze(caches.map((cache) => Object.freeze({ workspaceId: String(cache.facts?.workspaceId || ''), artifactPath: cache.artifact.path, archivePath: cache.file.path, materials: cache.facts.materials || [] }))),
     bootstrapInspection, transportManifest: null, artifactFacts: Object.freeze(generatedArtifacts.map((item) => Object.freeze({ path: item.path, facts: item.facts }))), descriptor, workspaceByteProvider, carrierProjection, coldConsumerProjection,