@tiinex/core 0.13.0 → 0.15.0

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

@@ -4,9 +4,11 @@ import { upgradeRecipientRelativeHandoffTransportPackageV2 } from './materialClo
 import { buildRecipientRelativeHandoffV2DirectBaseline } from './materialClosure.archiveV2.direct.js';
 import { qualifyMajorCarrierReadiness } from './carrierLineage.js';
 import { manufactureRecipientRelativeWorkspacePackage } from './workspaceCarrier.manufacture.js';
+import { manufactureRecipientRelativeBootstrapPackage } from './bootstrapCarrier.manufacture.js';
 
 export function manufactureRecipientRelativeHandoffPackage(input = {}, options = {}) {
   if (String(input.carrierMode || '') === 'workspace') return manufactureRecipientRelativeWorkspacePackage(input, options);
+  if (String(input.carrierMode || '') === 'bootstrap') return manufactureRecipientRelativeBootstrapPackage(input, options);
   const baseline = buildRecipientRelativeHandoffV2DirectBaseline(input, options);
   const upgraded = upgradeRecipientRelativeHandoffTransportPackageV2(baseline, input, options);
   const toolingBootstrapInspection = upgraded.inspection?.bootstrapInspection || inspectPortableToolingBootstrap(baseline.bundle || upgraded.bundle || {});
@@ -91,6 +93,6 @@ export function manufactureRecipientRelativeHandoffPackage(input = {}, options =
     baseline: Object.freeze({ schema: baseline.schema, status: baseline.status, packageRepresentationSha256: String(baseline.bundle?.packageRepresentationSha256 || ''), representation: 'semantic-control-plus-detached-material-without-exploded-workspace-carrier' }),
     findings,
     findingSummary: summarizePortableFindings(findings),
-    boundary: 'Canonical archive-backed Handoff manufacturing facade. It fails closed unless each carrier workspace is bound to one exact carried tiinex.workspace.v1 artifact and one independently verified complete workspace archive; the actively selected local Handoff candidate must satisfy prospective per-field exact schema-reference authority, and when reconciliation proof is required/supplied, the exact source selected for manufacture must also match the qualified candidate reconciled frontier.'
+    boundary: 'Canonical archive-backed Handoff manufacturing facade. It fails closed unless every selected source-material binding qualifies under tiinex.handoff.package.v1, the exact authoritative selected Handoff is contained by clear qualified carried material, the actively selected local Handoff candidate satisfies prospective per-field exact schema-reference authority, and any required reconciliation proof matches the exact source selected for manufacture.'
   });
 }

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

@@ -9,7 +9,7 @@ import { buildPhase1WorkspaceCarriers } from './recipientV2.artifactFirst.worksp
 import { buildPhase1RolePointers } from './recipientV2.artifactFirst.roles.js';
 import { deriveRecipientV2ArtifactFirstPhase1Facts } from './recipientV2.artifactFirst.materials.js';
 import { inspectRecipientV2ArtifactFirstPhase1Specimen } from './recipientV2.artifactFirst.inspect.js';
-import { RECIPIENT_V2_READ_PATH, RECIPIENT_V2_ARTIFACT_FIRST_PHASE1_FORMAT_ID, RECIPIENT_V2_ARTIFACT_FIRST_PHASE1_SCHEMA_ID, RECIPIENT_V2_ARTIFACT_FIRST_PHASE2_CLEAN_FORMAT_ID, RECIPIENT_V2_ARTIFACT_FIRST_PHASE2_CLEAN_SCHEMA_ID, PHASE2_CLEAN_PROFILE, PHASE2_COMPATIBILITY_TRANSPORT, PHASE1_BOOTSTRAP_ROLE, PHASE1_CACHE_ROLE, normalizeRoutePath, cacheMaterialBelongsToRoute, sortedQualifiedCarrierRoutes, selectOne, oneFile, repathFinalizedFile, phase1RoutePointerPath, phase1RolePathPrefix, blocked, finding, deepFreeze } from './recipientV2.artifactFirst.shared.js';
+import { RECIPIENT_V2_READ_PATH, RECIPIENT_V2_ARTIFACT_FIRST_PHASE1_FORMAT_ID, RECIPIENT_V2_ARTIFACT_FIRST_PHASE1_SCHEMA_ID, RECIPIENT_V2_ARTIFACT_FIRST_PHASE2_CLEAN_FORMAT_ID, RECIPIENT_V2_ARTIFACT_FIRST_PHASE2_CLEAN_SCHEMA_ID, PHASE2_CLEAN_PROFILE, PHASE2_COMPATIBILITY_TRANSPORT, PHASE1_BOOTSTRAP_ROLE, PHASE1_CACHE_ROLE, normalizeRoutePath, cacheMaterialBelongsToRoute, cacheMaterialIsBoundedWorkspaceRecovery, safeToken, sortedQualifiedCarrierRoutes, selectOne, oneFile, repathFinalizedFile, phase1RoutePointerPath, phase1RolePathPrefix, blocked, finding, deepFreeze } from './recipientV2.artifactFirst.shared.js';
 
 export function buildRecipientV2ArtifactFirstPhase1Specimen(input = {}) {
   const cleanCarrierPhase2 = input.cleanCarrierPhase2 === true;
@@ -103,60 +103,100 @@ export function buildRecipientV2ArtifactFirstPhase1Specimen(input = {}) {
     })
   }) : null;
 
-  const sourceCache = (sourceInspection.caches || []).find((item) => String(item.workspaceId || '') === workspaceId) || null;
-  const selectedCacheMaterials = sourceCache ? (sourceCache.materials || []).filter((item) => cacheMaterialBelongsToRoute(item, workspaceId, route.workspaceRelativeHandoffPath)) : [];
+  const sourceCaches = [...(sourceInspection.caches || [])];
+  const sourceCache = sourceCaches.find((item) => String(item.workspaceId || '') === workspaceId) || null;
+  const selectedRouteCacheMaterials = sourceCache ? (sourceCache.materials || []).filter((item) => cacheMaterialBelongsToRoute(item, workspaceId, route.workspaceRelativeHandoffPath)) : [];
   const siblingDetachedMaterials = routePlans
     .filter((plan) => plan.routeId !== selectedRouteId)
-    .flatMap((plan) => (sourceInspection.caches || []).flatMap((cache) => (cache.materials || []).filter((item) => cacheMaterialBelongsToRoute(item, plan.workspaceId, plan.workspaceRelativeHandoffPath))));
-  if (siblingDetachedMaterials.length) return blocked('shared-route-detached-cache-unsupported', [finding('error', 'portable.handoff-v2-phase1.shared-route.detached-cache-unsupported', 'Shared artifact-first carriage currently supports detached cache material only for the explicitly selected route; sibling routes must resolve closure from carried Workspace source.', { count: siblingDetachedMaterials.length })]);
+    .flatMap((plan) => sourceCaches.flatMap((cache) => (cache.materials || []).filter((item) => cacheMaterialBelongsToRoute(item, plan.workspaceId, plan.workspaceRelativeHandoffPath) && !cacheMaterialIsBoundedWorkspaceRecovery(item, plan.workspaceId))));
+  if (siblingDetachedMaterials.length) return blocked('shared-route-detached-cache-unsupported', [finding('error', 'portable.handoff-v2-phase1.shared-route.detached-cache-unsupported', 'Shared artifact-first carriage currently supports route-specific detached cache material only for the explicitly selected route; bounded Workspace recovery remains independently carryable for every bounded Workspace.', { count: siblingDetachedMaterials.length })]);
+
+  const cacheBuilds = [];
   let cacheArtifact = null;
-  let cacheArchiveFile = null;
-  let cacheProjection = null;
-  if (selectedCacheMaterials.length) {
-    const sourceCacheArchive = oneFile(sourceBundle.files || [], sourceCache.archivePath);
-    if (!sourceCacheArchive) return blocked('cache-source-unresolved', [finding('error', 'portable.handoff-v2-phase1.cache.source-unresolved', 'Selected-route detached cache archive is unavailable in the qualified source carrier.', { path: sourceCache.archivePath })]);
+  let selectedCacheMaterials = [];
+  let auxiliaryCacheOrdinal = 0;
+  for (const candidateCache of sourceCaches) {
+    const cacheWorkspaceId = String(candidateCache.workspaceId || '');
+    const recoveryMaterials = (candidateCache.materials || []).filter((item) => cacheMaterialIsBoundedWorkspaceRecovery(item, cacheWorkspaceId));
+    const routeMaterials = cacheWorkspaceId === workspaceId ? selectedRouteCacheMaterials : [];
+    const byMaterialKey = new Map();
+    for (const material of [...routeMaterials, ...recoveryMaterials]) {
+      const key = `${String(material.requirementId || '')}\u0000${String(material.archiveEntry || '')}`;
+      if (!byMaterialKey.has(key)) byMaterialKey.set(key, material);
+    }
+    const carriedMaterials = [...byMaterialKey.values()];
+    if (!carriedMaterials.length) continue;
+
+    const sourceCacheArchive = oneFile(sourceBundle.files || [], candidateCache.archivePath);
+    if (!sourceCacheArchive) return blocked('cache-source-unresolved', [finding('error', 'portable.handoff-v2-phase1.cache.source-unresolved', 'Detached cache archive is unavailable in the qualified source carrier.', { workspaceId: cacheWorkspaceId, path: candidateCache.archivePath })]);
     const sourceCacheInspection = inspectStoredWorkspaceArchive(packageFileBytes(sourceCacheArchive), { ownedBytes: true });
-    if (sourceCacheInspection.state !== 'qualified') return blocked('cache-source-invalid', [finding('error', 'portable.handoff-v2-phase1.cache.source-invalid', 'Selected-route detached cache archive did not independently qualify.', { path: sourceCache.archivePath, findings: sourceCacheInspection.findings || [] })]);
+    if (sourceCacheInspection.state !== 'qualified') return blocked('cache-source-invalid', [finding('error', 'portable.handoff-v2-phase1.cache.source-invalid', 'Detached cache archive did not independently qualify.', { workspaceId: cacheWorkspaceId, path: candidateCache.archivePath, findings: sourceCacheInspection.findings || [] })]);
+
     const selectedEntries = [];
     const materialBindings = [];
-    for (const material of selectedCacheMaterials) {
+    for (const material of carriedMaterials) {
       const archiveEntry = String(material.archiveEntry || '');
       const matches = sourceCacheInspection.entries.filter((entry) => String(entry.path || '') === archiveEntry);
-      if (matches.length !== 1) return blocked('cache-material-unresolved', [finding('error', 'portable.handoff-v2-phase1.cache.material-unresolved', 'Selected-route cache material must resolve exactly one source cache entry.', { requirementId: String(material.requirementId || ''), referenceTarget: String(material.referenceTarget || ''), archiveEntry, count: matches.length })]);
+      if (matches.length !== 1) return blocked('cache-material-unresolved', [finding('error', 'portable.handoff-v2-phase1.cache.material-unresolved', 'Carried cache material must resolve exactly one source cache entry.', { workspaceId: cacheWorkspaceId, requirementId: String(material.requirementId || ''), referenceTarget: String(material.referenceTarget || ''), archiveEntry, count: matches.length })]);
       selectedEntries.push({ path: archiveEntry, data: matches[0].data });
-      materialBindings.push(Object.freeze({ requirementId: String(material.requirementId || ''), classification: String(material.classification || ''), referenceTarget: String(material.referenceTarget || ''), archiveEntry }));
+      materialBindings.push(Object.freeze({
+        requirementId: String(material.requirementId || ''),
+        classification: String(material.classification || ''),
+        referenceTarget: String(material.referenceTarget || ''),
+        routeWorkspaceId: String(material.routeWorkspaceId || ''),
+        routePath: String(material.routePath || ''),
+        sourceRequirementId: String(material.sourceRequirementId || ''),
+        sourceWorkspaceId: String(material.sourceWorkspaceId || ''),
+        sourcePath: String(material.sourcePath || ''),
+        targetWorkspaceId: String(material.targetWorkspaceId || ''),
+        targetPath: String(material.targetPath || ''),
+        originalPath: String(material.originalPath || ''),
+        archiveEntry,
+        bytes: Number(material.bytes || matches[0].bytes || 0),
+        sha256: String(material.sha256 || matches[0].sha256 || '')
+      }));
     }
-    const cacheArchivePath = '001-5-cache.zip';
-    const cacheArtifactPath = '001-5-cache.trace.md';
-    cacheArchiveFile = finalizeFile({
-      path: cacheArchivePath,
+
+    const selectedWorkspaceCache = cacheWorkspaceId === workspaceId;
+    auxiliaryCacheOrdinal += selectedWorkspaceCache ? 0 : 1;
+    const cacheStem = selectedWorkspaceCache ? '001-5-cache' : `001-5-${auxiliaryCacheOrdinal}-${safeToken(cacheWorkspaceId)}-recovery-cache`;
+    const builtArchivePath = `${cacheStem}.zip`;
+    const builtArtifactPath = `${cacheStem}.trace.md`;
+    const builtArchiveFile = finalizeFile({
+      path: builtArchivePath,
       kind: 'handoff-material-cache',
       logicalKind: 'recipient-v2-phase1-workspace-dependency-cache',
       mediaType: 'application/zip',
       data: exportFileMapZipUint8Array(selectedEntries, 'portable.handoff-v2-phase1.cache.path.invalid'),
-      boundary: 'Exact selected-route detached dependency bytes owned by the visible cache External Payload artifact. Cache location and compatibility JSON are not semantic authority.'
+      boundary: 'Exact route-scoped detached dependency and/or bounded Workspace Parent-recovery bytes owned by one visible cache External Payload artifact. Cache location and compatibility JSON are not semantic authority.'
     });
-    cacheArtifact = finalizeFile({
-      path: cacheArtifactPath,
+    const builtArtifact = finalizeFile({
+      path: builtArtifactPath,
       kind: 'tiinex-external-payload-artifact',
       logicalKind: 'recipient-v2-phase1-workspace-dependency-cache-reference',
       mediaType: 'text/markdown',
       content: renderRecipientV2ExternalPayload({
         artifactFirst: true,
         createdAt,
-        workspaceId,
-        title: `Workspace Dependency Cache — ${workspaceId}`,
-        summary: 'Artifact-first Phase 1 exact selected-route dependency bytes absent from the qualified Workspace payload.',
-        label: `${workspaceId} selected-route Handoff dependency cache`,
+        workspaceId: cacheWorkspaceId,
+        title: `Workspace Dependency Cache — ${cacheWorkspaceId}`,
+        summary: 'Artifact-first exact detached dependency and bounded Parent-recovery bytes absent from the qualified Workspace payload.',
+        label: `${cacheWorkspaceId} Handoff dependency and recovery cache`,
         kind: 'zip export',
         role: PHASE1_CACHE_ROLE,
-        location: cacheArchivePath,
-        bytes: cacheArchiveFile.bytes,
-        sha256: cacheArchiveFile.sha256,
+        location: builtArchivePath,
+        bytes: builtArchiveFile.bytes,
+        sha256: builtArchiveFile.sha256,
         materials: materialBindings
       })
     });
-    cacheProjection = Object.freeze({ workspaceId, artifactPath: cacheArtifactPath, archivePath: cacheArchivePath, materials: Object.freeze(materialBindings) });
+    const projection = Object.freeze({ workspaceId: cacheWorkspaceId, artifactPath: builtArtifactPath, archivePath: builtArchivePath, materials: Object.freeze(materialBindings) });
+    const built = Object.freeze({ workspaceId: cacheWorkspaceId, artifact: builtArtifact, archiveFile: builtArchiveFile, projection, sourceMaterials: Object.freeze(carriedMaterials) });
+    cacheBuilds.push(built);
+    if (selectedWorkspaceCache) {
+      cacheArtifact = builtArtifact;
+      selectedCacheMaterials = carriedMaterials;
+    }
   }
 
   const endpointRoleArtifacts = [];
@@ -257,7 +297,7 @@ export function buildRecipientV2ArtifactFirstPhase1Specimen(input = {}) {
       destinations: [
         ...(bootstrapArtifact ? [{ label: 'Portable Tooling bootstrap payload', target: bootstrapArtifactPath }] : []),
         ...workspaceCarriers.map((item) => ({ label: `${item.workspaceId} Workspace payload`, target: item.payloadArtifactPath })),
-        ...(cacheArtifact ? [{ label: 'Selected-route dependency cache payload', target: cacheArtifact.path }] : []),
+        ...cacheBuilds.map((item) => ({ label: `Workspace dependency/recovery cache ${item.workspaceId}`, target: item.artifact.path })),
         ...workspaceCarriers.map((item) => ({ label: `${item.workspaceId} Workspace material representation`, target: item.relationArtifactPath })),
         ...endpointRoleArtifacts.map((item) => ({ label: 'Endpoint Role pointer', target: item.path })),
         ...participantRoleArtifacts.map((item) => ({ label: 'Participant Role pointer', target: item.path })),
@@ -267,7 +307,8 @@ export function buildRecipientV2ArtifactFirstPhase1Specimen(input = {}) {
   });
 
   const workspaceFiles = workspaceCarriers.flatMap((item) => [item.payloadArtifact, item.archiveFile, item.relationArtifact]);
-  const semanticFiles = Object.freeze([ingressPointer, ...(bootstrapArtifact && bootstrapArchiveFile ? [bootstrapArtifact, bootstrapArchiveFile] : []), ...workspaceFiles, ...(cacheArtifact && cacheArchiveFile ? [cacheArtifact, cacheArchiveFile] : []), ...endpointRoleArtifacts, ...participantRoleArtifacts, ...routePointers]);
+  const cacheFiles = cacheBuilds.flatMap((item) => [item.artifact, item.archiveFile]);
+  const semanticFiles = Object.freeze([ingressPointer, ...(bootstrapArtifact && bootstrapArchiveFile ? [bootstrapArtifact, bootstrapArchiveFile] : []), ...workspaceFiles, ...cacheFiles, ...endpointRoleArtifacts, ...participantRoleArtifacts, ...routePointers]);
   const factsByPath = deriveRecipientV2ArtifactFirstPhase1Facts(semanticFiles);
   const manifestInputs = semanticFiles.map((file) => {
     const facts = factsByPath.get(String(file.path || '')) || null;
@@ -293,7 +334,7 @@ export function buildRecipientV2ArtifactFirstPhase1Specimen(input = {}) {
       sourceWorkspaceTargetInnerPath: String(item.workspace.sourceWorkspaceTargetInnerPath || ''),
       sourceWorkspaceTargetSha256: String(item.workspace.sourceWorkspaceTargetSha256 || '')
     }))),
-    caches: Object.freeze(cacheProjection ? [cacheProjection] : []),
+    caches: Object.freeze(cacheBuilds.map((item) => item.projection)),
     endpointRoles: Object.freeze(endpointRoleProjections),
     participantRoles: Object.freeze(participantRoleProjections),
     routes: Object.freeze(routeTopology),

package/src/tooling/portable/handoff/recipientV2.artifactFirst.closure.js

@@ -124,7 +124,7 @@ export function phase1CacheParentCandidates(cacheQualifications = []) {
       const entry = matches[0];
       const data = packageFileBytes({ data: entry.data });
       if (Number(material.bytes || 0) !== data.byteLength || String(material.sha256 || '') !== sha256Hex(data)) continue;
-      candidates.push(Object.freeze({ workspaceId: String(cache.workspaceId || ''), workspaceRelativePath: normalizeRoutePath(material.referenceTarget || ''), archiveEntry: String(material.archiveEntry || ''), bytes: data.byteLength, sha256: sha256Hex(data), data }));
+      candidates.push(Object.freeze({ workspaceId: String(material.targetWorkspaceId || cache.workspaceId || ''), workspaceRelativePath: normalizeRoutePath(material.originalPath || material.targetPath || material.referenceTarget || ''), archiveEntry: String(material.archiveEntry || ''), bytes: data.byteLength, sha256: sha256Hex(data), data }));
     }
   }
   return Object.freeze(candidates);

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

@@ -34,7 +34,15 @@ export function inspectRecipientV2ArtifactFirstPhase1Specimen(bundle = {}) {
   if (!routes.length) findings.push(finding('error', 'portable.handoff-v2-phase1.route.count', 'Artifact-first specimen requires at least one visible Handoff route Pointer.', { count: routes.length }));
   if (!workspacePayloads.length) findings.push(finding('error', 'portable.handoff-v2-phase1.payload.workspace-count', 'Artifact-first full-source carriage requires at least one Workspace External Payload artifact.', { count: workspacePayloads.length }));
   if (bootstrapPayloads.length > 1) findings.push(finding('error', 'portable.handoff-v2-phase1.bootstrap.count', 'A carried portable Tooling bootstrap must have exactly one owning External Payload artifact.', { count: bootstrapPayloads.length }));
-  if (cachePayloads.length > 1) findings.push(finding('error', 'portable.handoff-v2-phase1.cache.count', 'A selected Workspace may expose at most one selected-route dependency cache External Payload.', { count: cachePayloads.length }));
+  const cachePayloadsByWorkspace = new Map();
+  for (const item of cachePayloads) {
+    const cacheWorkspaceId = String(item.parsed?.workspaceId || '');
+    if (!cacheWorkspaceId) findings.push(finding('error', 'portable.handoff-v2-phase1.cache.workspace-id-missing', 'Every dependency/recovery cache External Payload must visibly declare its owning Workspace Id.', { path: item.path }));
+    const list = cachePayloadsByWorkspace.get(cacheWorkspaceId) || [];
+    list.push(item);
+    cachePayloadsByWorkspace.set(cacheWorkspaceId, list);
+  }
+  for (const [cacheWorkspaceId, items] of cachePayloadsByWorkspace) if (cacheWorkspaceId && items.length > 1) findings.push(finding('error', 'portable.handoff-v2-phase1.cache.count', 'Each carried Workspace may expose at most one dependency/recovery cache External Payload.', { workspaceId: cacheWorkspaceId, count: items.length }));
   if (unknownPayloads.length) findings.push(finding('error', 'portable.handoff-v2-phase1.payload.unclassified', 'Phase 1 specimen contains an External Payload artifact outside the bounded Workspace/bootstrap/cache ownership subset.', { count: unknownPayloads.length }));
   if (!relations.length) findings.push(finding('error', 'portable.handoff-v2-phase1.relation.count', 'Artifact-first full-source carriage requires a typed material-representation Relation for every carried Workspace.', { count: relations.length }));
   if (markdownFiles.some((file) => factsByPath.get(String(file.path || ''))?.role === 'package-root')) findings.push(finding('error', 'portable.handoff-v2-phase1.package-root.present', 'Phase 1 specimen must not use a package-root Pointer as receiver semantic authority.'));

package/src/tooling/portable/handoff/recipientV2.artifactFirst.materials.js

@@ -75,7 +75,7 @@ export function deriveRecipientV2ArtifactFirstPhase1Facts(files = []) {
           const matches = archive?.state === 'qualified' ? archive.entries.filter((entry) => String(entry.path || '') === String(material.archiveEntry || '')) : [];
           const entry = matches.length === 1 ? matches[0] : null;
           const bytes = entry ? packageFileBytes({ data: entry.data }) : new Uint8Array();
-          return Object.freeze({ requirementId: material.requirementId, classification: material.classification, referenceTarget: material.referenceTarget, routeWorkspaceId: parsed.workspaceId, routePath: '', sourceRequirementId: material.requirementId, originalPath: '', archiveEntry: material.archiveEntry, bytes: bytes.byteLength, sha256: bytes.byteLength ? sha256Hex(bytes) : '' });
+          return Object.freeze({ requirementId: material.requirementId, classification: material.classification, referenceTarget: material.referenceTarget, routeWorkspaceId: material.routeWorkspaceId || parsed.workspaceId, routePath: material.routePath || '', sourceRequirementId: material.sourceRequirementId || material.requirementId, sourceWorkspaceId: material.sourceWorkspaceId || '', sourcePath: material.sourcePath || '', targetWorkspaceId: material.targetWorkspaceId || '', targetPath: material.targetPath || '', originalPath: material.originalPath || '', archiveEntry: material.archiveEntry, bytes: bytes.byteLength, sha256: bytes.byteLength ? sha256Hex(bytes) : '' });
         });
         facts.set(path, recipientV2TransportFacts('workspace-dependency-cache', { workspaceId: parsed.workspaceId, archivePath: parsed.location || '', archiveBytes: Number(parsed.bytes || 0), archiveSha256: parsed.integrityValue || '', materials: Object.freeze(materials) }));
       }
@@ -115,16 +115,36 @@ function parsePhase1MaterialBindings(markdown = '') {
     const requirement = line.match(/^\s*-\s+Requirement Id:\s*(.*?)\s*$/i);
     if (requirement) {
       if (current) out.push(Object.freeze(current));
-      current = { requirementId: String(requirement[1] || '').trim(), classification: '', referenceTarget: '', archiveEntry: '' };
+      current = { requirementId: String(requirement[1] || '').trim(), classification: '', referenceTarget: '', routeWorkspaceId: '', routePath: '', sourceRequirementId: '', sourceWorkspaceId: '', sourcePath: '', targetWorkspaceId: '', targetPath: '', originalPath: '', archiveEntry: '', bytes: null, sha256: '' };
       continue;
     }
     if (!current) continue;
     const classification = line.match(/^\s+-\s+Classification:\s*(.*?)\s*$/i);
     const reference = line.match(/^\s+-\s+Material Reference:\s*(.*?)\s*$/i);
     const archiveEntry = line.match(/^\s+-\s+Archive Entry:\s*(.*?)\s*$/i);
+    const routeWorkspaceId = line.match(/^\s+-\s+Route Workspace Id:\s*(.*?)\s*$/i);
+    const routePath = line.match(/^\s+-\s+Route Path:\s*(.*?)\s*$/i);
+    const sourceRequirementId = line.match(/^\s+-\s+Source Requirement Id:\s*(.*?)\s*$/i);
+    const sourceWorkspaceId = line.match(/^\s+-\s+Source Workspace Id:\s*(.*?)\s*$/i);
+    const sourcePath = line.match(/^\s+-\s+Source Path:\s*(.*?)\s*$/i);
+    const targetWorkspaceId = line.match(/^\s+-\s+Target Workspace Id:\s*(.*?)\s*$/i);
+    const targetPath = line.match(/^\s+-\s+Target Path:\s*(.*?)\s*$/i);
+    const originalPath = line.match(/^\s+-\s+Original Path:\s*(.*?)\s*$/i);
+    const bytes = line.match(/^\s+-\s+Byte Size:\s*(.*?)\s*$/i);
+    const sha256 = line.match(/^\s+-\s+SHA256:\s*(.*?)\s*$/i);
     if (classification) current.classification = String(classification[1] || '').trim();
     else if (reference) current.referenceTarget = String(reference[1] || '').trim();
     else if (archiveEntry) current.archiveEntry = String(archiveEntry[1] || '').trim();
+    else if (routeWorkspaceId) current.routeWorkspaceId = String(routeWorkspaceId[1] || '').trim();
+    else if (routePath) current.routePath = String(routePath[1] || '').trim();
+    else if (sourceRequirementId) current.sourceRequirementId = String(sourceRequirementId[1] || '').trim();
+    else if (sourceWorkspaceId) current.sourceWorkspaceId = String(sourceWorkspaceId[1] || '').trim();
+    else if (sourcePath) current.sourcePath = String(sourcePath[1] || '').trim();
+    else if (targetWorkspaceId) current.targetWorkspaceId = String(targetWorkspaceId[1] || '').trim();
+    else if (targetPath) current.targetPath = String(targetPath[1] || '').trim();
+    else if (originalPath) current.originalPath = String(originalPath[1] || '').trim();
+    else if (bytes) current.bytes = Number(bytes[1] || 0);
+    else if (sha256) current.sha256 = String(sha256[1] || '').trim();
   }
   if (current) out.push(Object.freeze(current));
   return Object.freeze(out);
@@ -183,7 +203,6 @@ export function qualifyPhase1CachePayload(cachePayload = null, semanticFiles = [
     if (archive.state !== 'qualified') localFindings.push(finding('error', 'portable.handoff-v2-phase1.cache.archive-invalid', 'Selected-route cache payload is not a qualified deterministic stored-ZIP representation.', { path: location, findings: archive.findings || [] }));
   }
   const seenRequirements = new Set();
-  const seenReferences = new Set();
   const seenEntries = new Set();
   for (const material of cachePayload.parsed?.materials || []) {
     const requirementId = String(material.requirementId || '');
@@ -193,13 +212,16 @@ export function qualifyPhase1CachePayload(cachePayload = null, semanticFiles = [
       localFindings.push(finding('error', 'portable.handoff-v2-phase1.cache.material-binding-incomplete', 'Every selected-route cache material binding must visibly declare requirement id, material reference, and archive entry.'));
       continue;
     }
-    if (seenRequirements.has(requirementId) || seenReferences.has(referenceTarget) || seenEntries.has(archiveEntry)) localFindings.push(finding('error', 'portable.handoff-v2-phase1.cache.material-binding-ambiguous', 'Selected-route cache material bindings must be one-to-one by requirement id, material reference, and archive entry.', { requirementId, referenceTarget, archiveEntry }));
-    seenRequirements.add(requirementId); seenReferences.add(referenceTarget); seenEntries.add(archiveEntry);
+    if (seenRequirements.has(requirementId) || seenEntries.has(archiveEntry)) localFindings.push(finding('error', 'portable.handoff-v2-phase1.cache.material-binding-ambiguous', 'Cache material bindings must be one-to-one by requirement id and archive entry; multiple requirements may legitimately share the same Parent reference.', { requirementId, referenceTarget, archiveEntry }));
+    seenRequirements.add(requirementId); seenEntries.add(archiveEntry);
     const entryMatches = archive?.state === 'qualified' ? archive.entries.filter((entry) => String(entry.path || '') === archiveEntry) : [];
     if (archive?.state === 'qualified' && entryMatches.length !== 1) localFindings.push(finding('error', 'portable.handoff-v2-phase1.cache.material-entry-unresolved', 'Selected-route cache material binding must resolve exactly one exact cache entry.', { requirementId, referenceTarget, archiveEntry, count: entryMatches.length }));
     const entry = entryMatches.length === 1 ? entryMatches[0] : null;
     const entryBytes = entry ? packageFileBytes({ data: entry.data }) : new Uint8Array();
-    materialQualifications.push(deepFreeze({ requirementId, classification: String(material.classification || ''), referenceTarget, archiveEntry, bytes: entryBytes.byteLength, sha256: entryBytes.byteLength ? sha256Hex(entryBytes) : '' }));
+    const entrySha256 = entryBytes.byteLength ? sha256Hex(entryBytes) : '';
+    if (material.bytes !== null && material.bytes !== undefined && Number(material.bytes) !== entryBytes.byteLength) localFindings.push(finding('error', 'portable.handoff-v2-phase1.cache.material-byte-size-mismatch', 'Visible cache material Byte Size must equal the exact owned archive entry bytes.', { requirementId, archiveEntry, declaredBytes: Number(material.bytes), actualBytes: entryBytes.byteLength }));
+    if (material.sha256 && String(material.sha256) !== entrySha256) localFindings.push(finding('error', 'portable.handoff-v2-phase1.cache.material-sha256-mismatch', 'Visible cache material SHA256 must equal the exact owned archive entry digest.', { requirementId, archiveEntry }));
+    materialQualifications.push(deepFreeze({ requirementId, classification: String(material.classification || ''), referenceTarget, routeWorkspaceId: String(material.routeWorkspaceId || ''), routePath: String(material.routePath || ''), sourceRequirementId: String(material.sourceRequirementId || ''), sourceWorkspaceId: String(material.sourceWorkspaceId || ''), sourcePath: String(material.sourcePath || ''), targetWorkspaceId: String(material.targetWorkspaceId || ''), targetPath: String(material.targetPath || ''), originalPath: String(material.originalPath || ''), archiveEntry, bytes: entryBytes.byteLength, sha256: entrySha256 }));
   }
   if (!(cachePayload.parsed?.materials || []).length) localFindings.push(finding('error', 'portable.handoff-v2-phase1.cache.material-bindings-missing', 'Selected-route cache External Payload must visibly bind every owned detached material to one archive entry.'));
   findings.push(...localFindings);

package/src/tooling/portable/handoff/recipientV2.artifactFirst.shared.js

@@ -20,6 +20,14 @@ export function cacheMaterialBelongsToRoute(material = {}, workspaceId = '', rou
   return String(material.routeWorkspaceId || '') === String(workspaceId || '') && normalizeRoutePath(material.routePath || '') === normalizeRoutePath(routePath || '');
 }
 
+export function cacheMaterialIsBoundedWorkspaceRecovery(material = {}, workspaceId = '') {
+  const id = String(workspaceId || '').trim();
+  return Boolean(id
+    && String(material.classification || '') === 'parent-boundary'
+    && String(material.routeWorkspaceId || '') === id
+    && String(material.sourceRequirementId || '').startsWith(`bounded-workspace:${id}:`));
+}
+
 export function selectOne(items = [], selector = '', label = 'item', findings = [], selectorFn = (item) => String(item.workspaceId || '')) { const candidates = selector ? items.filter((item) => selectorFn(item) === String(selector)) : items; if (candidates.length !== 1) { findings.push(finding('error', `portable.handoff-v2-phase1.${label}.selection`, `Phase 1 specimen requires exactly one selected ${label}.`, { selector: String(selector || ''), count: candidates.length })); return null; } return candidates[0]; }
 
 export function oneFile(files = [], path = '') { const matches = files.filter((file) => String(file.path || '') === String(path || '')); return matches.length === 1 ? matches[0] : null; }

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

@@ -2,17 +2,22 @@ export function recipientColdProjection(carrier = {}, readPath = '001-1-READ-BEF
   const routes = Object.freeze((carrier.routes || []).map((route) => Object.freeze({ id: String(route.id || ''), state: String(route.state || ''), workspaceId: String(route.workspaceId || ''), workspaceRelativeHandoffPath: String(route.workspaceRelativePath || ''), packagePath: String(route.packagePath || ''), sha256: String(route.sha256 || ''), from: String(route.parties?.from || ''), to: String(route.parties?.to || '') })));
   const workspaces = Object.freeze((carrier.workspaces || []).map((workspace) => Object.freeze({ id: String(workspace.id || ''), title: String(workspace.title || workspace.id || ''), slug: String(workspace.slug || ''), qualification: String(workspace.qualification || '') })));
   const qualified = routes.filter((route) => route.state === 'qualified');
-  const workspaceMode = String(carrier.mode || '') === 'workspace';
+  const mode = String(carrier.mode || '');
+  const workspaceMode = mode === 'workspace';
+  const bootstrapMode = mode === 'bootstrap';
+  const routeMode = !workspaceMode && !bootstrapMode;
   return deepFreeze({
     schema: 'tiinex.portable.handoff-cold-consumer-projection.v1', version: 1,
     status: carrier.status === 'ready' ? 'ready' : 'blocked',
     controls: Object.freeze({ start: readPath, carrier: 'visible-qualified-artifacts', closure: 'visible-qualified-artifacts-plus-exact-payload-bytes', fileMap: 'not-exposed-in-v2', manifest: 'not-exposed-in-v2' }),
-    preferredPath: Object.freeze(workspaceMode
-      ? { ingressKind: 'pointerless-workspace-package', firstSemanticOperation: 'orient-handoff-package', groundingOperation: 'none', qualificationOperation: 'workspace-qualification-after-orientation', minimalHostBootstrapActions: 1, nativeFallback: 'explicit-and-justified-only', providerSpecificSemanticAuthority: false }
-      : { ingressKind: 'routed-handoff-package', firstSemanticOperation: 'orient-handoff-package', groundingOperation: 'ground-cold-consumer', qualificationOperation: 'qualify-cold-start', minimalHostBootstrapActions: 1, nativeFallback: 'explicit-and-justified-only', providerSpecificSemanticAuthority: false }),
+    preferredPath: Object.freeze(bootstrapMode
+      ? { ingressKind: 'bootstrap-only-package', firstSemanticOperation: 'orient-handoff-package', groundingOperation: 'none', qualificationOperation: 'bootstrap-qualification-after-orientation', minimalHostBootstrapActions: 1, nativeFallback: 'explicit-and-justified-only', providerSpecificSemanticAuthority: false }
+      : workspaceMode
+        ? { ingressKind: 'pointerless-workspace-package', firstSemanticOperation: 'orient-handoff-package', groundingOperation: 'none', qualificationOperation: 'workspace-qualification-after-orientation', minimalHostBootstrapActions: 1, nativeFallback: 'explicit-and-justified-only', providerSpecificSemanticAuthority: false }
+        : { ingressKind: 'routed-handoff-package', firstSemanticOperation: 'orient-handoff-package', groundingOperation: 'ground-cold-consumer', qualificationOperation: 'qualify-cold-start', minimalHostBootstrapActions: 1, nativeFallback: 'explicit-and-justified-only', providerSpecificSemanticAuthority: false }),
     workspaces, routes,
-    selection: Object.freeze({ policy: String(carrier.selection?.policy || ''), qualifiedRouteCount: qualified.length, implicitRouteId: workspaceMode ? '' : qualified.length === 1 ? qualified[0].id : '' }),
-    authority: Object.freeze({ semanticAuthority: 'none', packageTruthRequired: true, routeBindingAuthority: workspaceMode ? 'none' : 'qualified-visible-artifact-plus-exact-payload-byte-truth-only' })
+    selection: Object.freeze({ policy: String(carrier.selection?.policy || ''), qualifiedRouteCount: qualified.length, implicitRouteId: routeMode && qualified.length === 1 ? qualified[0].id : '' }),
+    authority: Object.freeze({ semanticAuthority: 'none', packageTruthRequired: true, routeBindingAuthority: routeMode ? 'qualified-visible-artifact-plus-exact-payload-byte-truth-only' : 'none', recipientAuthority: routeMode ? 'qualified-selected-handoff-to-endpoint-only' : 'none', holderAuthority: 'none', workAuthority: 'none' })
   });
 }
 

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

@@ -26,3 +26,15 @@ export function recipientV2WorkspaceEntryCurrentRead() {
     Object.freeze({ label: 'Fallback', value: 'fail closed when Tooling cannot qualify the package role, exact Workspace bindings, bootstrap, or all-none Route Discovery profile; native package archaeology is not a preferred-path substitute' })
   ]);
 }
+
+export function recipientV2BootstrapEntryCurrentRead() {
+  return Object.freeze([
+    Object.freeze({ label: 'Bootstrap Exception', value: 'before Tiinex Tooling is available, use host capabilities only to read this entry/bootstrap node and extract the declared bootstrap ZIP into a writable runtime location; do not perform package archaeology' }),
+    Object.freeze({ label: 'Tooling Entrypoint', value: '`runtime/tools/tiinex-portable.mjs` relative to the chosen bootstrap extraction root; use this exact path and do not search/list the extracted runtime to discover it' }),
+    Object.freeze({ label: 'First Tooling Invocation', value: '`node <bootstrap-root>/runtime/tools/tiinex-portable.mjs orient-handoff-package <untouched-bootstrap-package.zip>`' }),
+    Object.freeze({ label: 'Carrier Mode', value: 'bootstrap-only carrier; no Workspace/material binding, Handoff route, recipient, Role holder, current work, transfer, acceptance, completion, participation, or grounded-to-act authority is declared or inferred' }),
+    Object.freeze({ label: 'Route Selection', value: 'none; the canonical package role requires both source-material binding sections and all route-specific projection fields to declare absence' }),
+    Object.freeze({ label: 'Next Action', value: 'after Tooling orientation, continue only with separately supplied qualified semantic material or an explicit later Handoff; this carrier itself supplies no project/source authority' }),
+    Object.freeze({ label: 'Fallback', value: 'fail closed when Tooling cannot qualify the package role, Start, bootstrap, or zero-material/zero-route profile; native package archaeology is not a preferred-path substitute' })
+  ]);
+}

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

@@ -2,6 +2,21 @@ import { projectHandoffCarrierOutputFromPackage, projectHandoffHumanOutput } fro
 import { inspectRecipientFacingV2Topology } from './recipientV2.inspect.js';
 import { RECIPIENT_V2_READ_PATH } from './recipientV2.topology.js';
 
+
+export function recipientV2GenericInvocation(inspection = {}) {
+  const startPath = String(inspection.packageContract?.startPath || RECIPIENT_V2_READ_PATH);
+  if (!startPath || inspection.status !== 'valid') return '';
+  return [
+    'Tiinex package attached.',
+    '',
+    'Cold start: read Start directly; do not list or extract this package.',
+    '',
+    'Start:',
+    startPath,
+    ''
+  ].join('\n');
+}
+
 export function recipientV2StandardInvocation(humanOutput = {}, inspection = {}) {
   const route = humanOutput.selectedRoute || {};
   return recipientV2InvocationForRoute(route, inspection);
@@ -16,7 +31,7 @@ function recipientV2InvocationForRoute(route = {}, inspection = {}) {
     'Cold start: read Start directly; do not list or extract this package.',
     '',
     'Start:',
-    RECIPIENT_V2_READ_PATH,
+    String(inspection.packageContract?.startPath || RECIPIENT_V2_READ_PATH),
     'Continue from (do not read native; pass to Tiinex after bootstrap):',
     String(routeMeta.pointerPath),
     ''
@@ -25,8 +40,9 @@ function recipientV2InvocationForRoute(route = {}, inspection = {}) {
 
 export function projectRecipientV2HumanOutput(humanOutput = {}, inspection = {}) {
   if (humanOutput.status !== 'ready' && humanOutput.status !== 'selection-required') return humanOutput;
-  const invocation = humanOutput.primary ? recipientV2StandardInvocation(humanOutput, inspection) : '';
-  if (humanOutput.primary && !invocation) return Object.freeze({ ...humanOutput, status: 'blocked', findings: Object.freeze([...(humanOutput.findings || []), Object.freeze({ severity: 'error', code: 'portable.handoff-v2-human-output.route-pointer.unresolved', message: 'Recipient-v2 human output requires one exact package-local Handoff route pointer for the selected semantic Handoff.' })]) });
+  const routed = String(inspection.packageContract?.packageRole || '') === 'recipient-facing-handoff-carrier';
+  const invocation = humanOutput.primary ? (routed ? recipientV2StandardInvocation(humanOutput, inspection) : recipientV2GenericInvocation(inspection)) : '';
+  if (humanOutput.primary && !invocation) return Object.freeze({ ...humanOutput, status: 'blocked', findings: Object.freeze([...(humanOutput.findings || []), Object.freeze({ severity: 'error', code: routed ? 'portable.handoff-v2-human-output.route-pointer.unresolved' : 'portable.handoff-v2-human-output.start.unresolved', message: routed ? 'Recipient-v2 human output requires one exact package-local Handoff route pointer for the selected semantic Handoff.' : 'Recipient-v2 generic human output requires one exact qualified package-local Start artifact.' })]) });
   const sharedRoutes = (humanOutput.sharedRouting?.routes || []).map((item) => {
     const route = (inspection.carrierProjection?.routes || []).find((candidate) => String(candidate.id || '') === String(item.routeId || ''))
       || { id: item.routeId, workspaceId: item.workspaceId, workspaceRelativePath: item.workspaceRelativeHandoffPath };
@@ -35,12 +51,15 @@ export function projectRecipientV2HumanOutput(humanOutput = {}, inspection = {})
   });
   if (humanOutput.sharedRouting && sharedRoutes.some((item) => !item)) return Object.freeze({ ...humanOutput, status: 'blocked', findings: Object.freeze([...(humanOutput.findings || []), Object.freeze({ severity: 'error', code: 'portable.handoff-v2-human-output.shared-route-pointer.unresolved', message: 'Recipient-v2 shared human output requires one exact package-local Handoff route pointer for every qualified route.' })]) });
   const sharedRouting = humanOutput.sharedRouting ? Object.freeze({ ...humanOutput.sharedRouting, routes: Object.freeze(sharedRoutes) }) : null;
+  const recipientLabel = routed ? String(humanOutput.selectedRoute?.parties?.to || '').trim() : '';
+  const presentation = Object.freeze({ ...(humanOutput.presentation || {}), recipientLabel, recipientProjectionAuthority: routed ? 'qualified-selected-handoff-to-endpoint-only' : 'none' });
   return Object.freeze({
     ...humanOutput,
+    presentation,
     normalInlineRouting: humanOutput.normalInlineRouting ? Object.freeze({ ...humanOutput.normalInlineRouting, content: invocation }) : null,
     sharedRouting,
     fallbackTransportText: humanOutput.fallbackTransportText ? Object.freeze({ ...humanOutput.fallbackTransportText, content: invocation }) : null,
-    boundary: `${String(humanOutput.boundary || '')} Recipient-v2 host-layer routing is a deterministic address label only: the fixed package Start artifact and exact package-local Continue-from Handoff Route Pointers. Workspace, semantic Handoff path, Role, and Task stay package-owned; shared route texts are read-only addresses and sibling routes remain unselected until one exact qualified route is chosen.`
+    boundary: `${String(humanOutput.boundary || '')} Recipient-v2 host-layer transport text is a deterministic projection only: every qualified package may expose its exact Start address; Continue-from and recipient-specific projection exist only for an exact qualified selected Handoff route. Workspace/material/Role presence creates no recipient, holder, participation, delegation, or work authority.`
   });
 }
 
@@ -48,11 +67,34 @@ export function projectPortableHandoffCarrierOutputFromPackage(input = {}) {
   const bundle = input.bundle || input;
   const inspection = inspectRecipientFacingV2Topology(bundle);
   if (inspection.detected !== true) return projectHandoffCarrierOutputFromPackage(input);
-  const humanOutput = projectRecipientV2HumanOutput(projectHandoffHumanOutput({ projection: inspection.carrierProjection || {}, route: input.route || input.routePath || input.routeId || '', collisionInstance: input.collisionInstance || input.instance || 1 }), inspection);
+  const routed = String(inspection.packageContract?.packageRole || '') === 'recipient-facing-handoff-carrier';
+  const baseHumanOutput = routed
+    ? projectHandoffHumanOutput({ projection: inspection.carrierProjection || {}, route: input.route || input.routePath || input.routeId || '', collisionInstance: input.collisionInstance || input.instance || 1 })
+    : genericPackageHumanOutput(inspection, input);
+  const humanOutput = projectRecipientV2HumanOutput(baseHumanOutput, inspection);
   const findings = Object.freeze([...(inspection.findings || []), ...(humanOutput.findings || [])]);
   const status = inspection.status === 'valid' && humanOutput.status === 'ready' ? 'ready' : humanOutput.status === 'selection-required' ? 'selection-required' : 'blocked';
   const carrierInspection = boundedRecipientV2Inspection(inspection);
-  return deepFreeze({ schema: 'tiinex.portable.handoff-carrier-output-projection.v1', status, carrierInspection, humanOutput, findings, boundary: 'Read-only regeneration of recipient-v2 carrier filename and minimal Start/Continue-from transport address from package-qualified route truth. Package byte/provider internals are intentionally omitted from the human-output projection.' });
+  return deepFreeze({ schema: 'tiinex.portable.handoff-carrier-output-projection.v1', status, carrierInspection, humanOutput, findings, boundary: 'Read-only regeneration of recipient-v2 carrier filename and minimal Start/Continue-from transport address from package-qualified role and route truth. Route-less package roles expose generic Start transport only; package byte/provider internals are intentionally omitted from the human-output projection.' });
+}
+
+function genericPackageHumanOutput(inspection = {}, input = {}) {
+  const projection = inspection.carrierProjection || {};
+  const mode = String(projection.mode || '');
+  const ready = inspection.status === 'valid' && projection.status === 'ready' && ['workspace', 'bootstrap'].includes(mode) && (projection.routes || []).length === 0;
+  const dimension = String(projection.lineage?.dimension || '001');
+  const filename = String(input.filename || input.projectedFilename || `tiinex-${dimension}.handoff-package.zip`);
+  return Object.freeze({
+    schema: 'tiinex.portable.handoff-human-output.v1', status: ready ? 'ready' : 'blocked',
+    primary: ready ? Object.freeze({ kind: `${mode}-package`, filename, dimension, parentDimension: String(projection.lineage?.parentDimension || ''), checkpointKind: String(projection.lineage?.checkpointKind || ''), routeId: '', workspaceId: '', workspaceRelativeHandoffPath: '', collisionInstance: 1, singleHumanTransportChoice: true }) : null,
+    normalInlineRouting: ready ? Object.freeze({ kind: 'transport-text', content: '', normalEmission: true, requiredForHumanCompletion: true, placement: 'adjacent-to-primary', authority: 'none' }) : null,
+    sharedRouting: null,
+    presentation: Object.freeze({ kind: mode === 'bootstrap' ? 'bootstrap-only-carrier' : 'pointerless-workspace-carrier', label: mode === 'bootstrap' ? 'Bootstrap carrier' : 'Workspace carrier', authority: 'none', recipientLabel: '', recipientProjectionAuthority: 'none' }),
+    normalEmissionBoundary: Object.freeze({ allowed: Object.freeze(['package-file', 'generic-start-transport-text']), forbidden: Object.freeze(['route-specific-continue-from', 'recipient-label-from-material', 'holder-label', 'current-work-label']) }),
+    fallbackTransportText: ready ? Object.freeze({ supported: true, filename: filename.replace(/\.handoff-package\.zip$/i, '.transport.txt'), content: '', normalEmission: false, requiredForHumanCompletion: false, authority: 'none' }) : null,
+    selectedRoute: null, findings: Object.freeze([]),
+    boundary: 'Route-less recipient-v2 package output projection. Generic Start transport only; material carriage creates no recipient, holder, participation, delegation, or work authority.'
+  });
 }