@tiinex/core 0.17.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Shared host-neutral Tiinex implementation core for artifacts, schemas, validation, lineage, grounding, Handoffs, provenance and deterministic workflows.",
   "type": "module",
   "sideEffects": true,
@@ -78,6 +78,7 @@
     "./tooling/portable/engine.facade.js": "./src/tooling/portable/engine.facade.js",
     "./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.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",
@@ -169,12 +170,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "2986187f3e95582d13c784060272e111931c6a1b",
+  "gitHead": "12321ec2a8d09722b464ef7977afa2dcdc924718",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "2986187f3e95582d13c784060272e111931c6a1b",
-    "sourceTree": "0c65ff04241c756ae67978d777d1bee8ac1befc9",
+    "sourceCommit": "12321ec2a8d09722b464ef7977afa2dcdc924718",
+    "sourceTree": "eba0d10ad8f5fc20cc1c98ee88c328fbd4dafa4c",
     "repository": "Tiinex/core",
-    "previousVersion": "0.16.0"
+    "previousVersion": "0.17.0"
   }
 }

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

@@ -31,8 +31,8 @@ export async function runCommonAuthorCli(parsed = {}, runtime = {}) {
 
   const parentReference = resolveParentReference(flags, state);
   const parentSource = String(flags['parent-source'] || flags['parent-file'] || '').trim();
-  if (isWorkspaceQualifiedReference(parentReference) && !parentSource) throw new Error('portable.cli.author.parent-source.required');
-  if (parentSource && !parentReference) throw new Error('portable.cli.author.parent.required');
+  if (isWorkspaceQualifiedReference(parentReference) && !parentSource) throw new Error(`portable.cli.author.parent-source.required: --parent ${parentReference} names an explicit cross-Workspace Parent. Supply --parent-source <local-file> containing the exact qualified Parent bytes; Tooling will not discover or fetch that Parent automatically.`);
+  if (parentSource && !parentReference) throw new Error('portable.cli.author.parent.required: --parent-source supplies Parent bytes but no semantic Parent reference. Supply --parent <workspace::path|relative-path> explicitly; Tooling will not infer Parent identity from the source file.');
   if (isWorkspaceQualifiedReference(parentReference) && !requestedArtifactRelativePath && !targetDirectory) throw new Error('portable.cli.author.cross-workspace-parent.target-required');
   const parentPath = parentReference ? (parentSource ? path.resolve(parentSource) : safeWorkspaceTarget(workspaceRoot, parentReference)) : '';
   const artifactRelativePath = requestedArtifactRelativePath || await allocateArtifactRelativePath({ workspaceRoot, targetDirectory, parentRelativePath: parentReference, schemaId, title });
@@ -80,6 +80,7 @@ export async function runCommonAuthorCli(parsed = {}, runtime = {}) {
     }, {});
     const blocking = Number(audit?.findingSummary?.counts?.error || 0) + Number(stage?.findingSummary?.counts?.error || 0);
     if (blocking) {
+      const actionableFindings = projectAuthorActionableFindings(audit, stage);
       await rm(artifactPath, { force: true });
       wrote = false;
       return Object.freeze({
@@ -90,7 +91,8 @@ export async function runCommonAuthorCli(parsed = {}, runtime = {}) {
         audit,
         stage,
         findingSummary: mergeFindingSummaries(audit?.findingSummary, stage?.findingSummary),
-        nextAction: 'Resolve the reported schema/continuity finding, then rerun the same author command. No invalid durable artifact was retained.',
+        actionableFindings,
+        nextAction: actionableFindings[0]?.nextAction || 'Resolve the reported schema/continuity finding, then rerun the same author command. No invalid durable artifact was retained.',
         boundary: 'Common-path authoring composes the shared renderer, c14n-v2 sealing, runtime audit, and staging qualification. It may write only the requested local Workspace artifact and runtime-only .tiinex continuation state; it performs no remote mutation.'
       });
     }
@@ -125,12 +127,12 @@ async function parentRecordFromArtifact(parentPath, parentRelativePath, context
   const schemaId = String(current.schema?.id || '').trim();
   const schemaTarget = String(current.schema?.target || '').trim();
   const self = canonicalC14nV2SelfState(markdown);
-  if (!schemaId) throw new Error('portable.cli.author.parent.schema-authority.required');
+  if (!schemaId) throw new Error('portable.cli.author.parent.schema-authority.required: the supplied Parent does not declare a Current Schema. Supply exact qualified Parent bytes with an explicit Current Schema reference; Tooling will not infer Parent schema authority from path or filename.');
   if (self.state !== 'verified') throw new Error(`portable.cli.author.parent.integrity.${self.reason || self.state}`);
   const schemaReferenceAuthority = schemaTarget
     ? exactDeclaredSchemaReferenceAuthority(schemaId, schemaTarget)
     : await recoverQualifiedRuntimeSchemaReferenceAuthority(schemaId, context.runtime || {});
-  if (!schemaReferenceAuthority) throw new Error('portable.cli.author.parent.schema-authority.required');
+  if (!schemaReferenceAuthority) throw new Error(`portable.cli.author.parent.schema-authority.required: Parent schema ${schemaId} lacks an exact qualified schema-reference authority. Supply Parent bytes with an exact Current Schema target or qualified runtime canonical schema material; Tooling will not invent the schema target.`);
   return Object.freeze({
     id: parentRelativePath,
     path: parentRelativePath,
@@ -144,6 +146,28 @@ async function parentRecordFromArtifact(parentPath, parentRelativePath, context
   });
 }
 
+function projectAuthorActionableFindings(audit = {}, stage = {}) {
+  const findings = [
+    ...(audit.findings || audit.actionableFindings || []),
+    ...(stage.findings || stage.actionableFindings || [])
+  ].filter((item) => item && (item.severity === 'error' || item.severity === 'warning'));
+  const seen = new Set();
+  const out = [];
+  for (const item of findings) {
+    const code = String(item.code || '');
+    const key = `${code}\u0000${String(item.message || '')}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(Object.freeze({
+      code,
+      message: String(item.message || ''),
+      ...(item.contractGuidance ? { contractGuidance: Object.freeze({ ...item.contractGuidance }) } : {}),
+      nextAction: String(item.contractGuidance?.nextAction || 'Resolve this exact finding using its cited authority/evidence, then rerun the same author command. No invalid durable artifact was retained.')
+    }));
+  }
+  return Object.freeze(out.slice(0, 20));
+}
+
 export function parentRecoveryMode(reference = '') {
   const classification = classifyParentRecoveryReference(reference);
   if (classification.kind === 'workspace-qualified') return 'workspace-qualified';

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

@@ -103,6 +103,7 @@ function projectGroundDefault(result = {}, parsed = {}) {
     status: result.status,
     readiness: compactReadiness(result.readiness),
     authority: compactGroundAuthority(result.authority),
+    orchestrationReadiness: compactOrchestrationReadiness(result.orchestrationReadiness),
     requiredContext: Object.freeze({
       declared: Number(required.declared || 0),
       matchedInWorkspaceSnapshots: Number(required.matchedInWorkspaceSnapshots || 0),
@@ -254,13 +255,18 @@ function compactGroundAuthority(authority = {}) {
     route: Object.freeze({
       id: String(route.id || ''),
       pointerPath: String(route.pointerPath || ''),
-      workspaceId: String(route.workspaceId || '')
+      workspaceId: String(route.workspaceId || ''),
+      workspaceRelativePath: String(route.workspaceRelativePath || ''),
+      sha256: String(route.sha256 || ''),
+      provenance: route.provenance ? Object.freeze({ ...route.provenance }) : null
     }),
     handoff: Object.freeze({
       purpose: String(handoff.purpose || ''),
       from: String(handoff.from || ''),
       to: String(handoff.to || ''),
-      completionExpectation: handoff.completionExpectation || null
+      completionExpectation: handoff.completionExpectation || null,
+      transfers: Object.freeze((handoff.transfers || []).map((item) => Object.freeze({ ...item }))),
+      provenance: handoff.provenance ? Object.freeze({ ...handoff.provenance }) : null
     }),
     role: Object.freeze({
       state: String(role.state || ''),
@@ -275,7 +281,8 @@ function compactGroundAuthority(authority = {}) {
       recipientCompatibility: String(holderBinding.recipientCompatibility || ''),
       source: String(holderBinding.source || ''),
       explicit: Boolean(holderBinding.explicit),
-      inferredFromTransport: Boolean(holderBinding.inferredFromTransport)
+      inferredFromTransport: Boolean(holderBinding.inferredFromTransport),
+      provenance: holderBinding.provenance ? Object.freeze({ ...holderBinding.provenance }) : null
     }),
     operationBoundary: Object.freeze({
       sourceMutation: Boolean(operationBoundary.sourceMutation),
@@ -286,14 +293,35 @@ function compactGroundAuthority(authority = {}) {
   });
 }
 
+function compactOrchestrationReadiness(value = {}) {
+  if (!value || typeof value !== 'object') return null;
+  const wider = value.widerOrchestration || {};
+  return Object.freeze({
+    state: String(value.state || ''),
+    boundedActionReadiness: String(value.boundedActionReadiness || ''),
+    widerOrchestration: Object.freeze({
+      state: String(wider.state || ''),
+      blockers: Object.freeze((wider.blockers || []).slice(0, 8).map((item) => Object.freeze({ ...item })))
+    }),
+    participantMap: String(value.participantMap || ''),
+    sourceScope: String(value.sourceScope || ''),
+    processApplicability: value.processApplicability ? Object.freeze({ ...value.processApplicability, unresolved: Object.freeze([...(value.processApplicability.unresolved || [])].map((item) => Object.freeze({ ...item }))) }) : null,
+    boundary: String(value.boundary || '')
+  });
+}
+
 function projectRequiredContextItem(item = {}) {
   const contentProjected = Boolean(item.contentProjected && typeof item.content === 'string');
   return Object.freeze({
     requirementId: String(item.requirementId || ''),
     name: String(item.name || ''),
+    material: String(item.material || ''),
+    purpose: String(item.purpose || ''),
+    declaredAvailability: String(item.declaredAvailability || ''),
     state: String(item.state || ''),
     workspaceId: String(item.workspaceId || ''),
     innerPath: String(item.innerPath || ''),
+    provenance: item.provenance ? Object.freeze({ ...item.provenance }) : null,
     contentProjected,
     ...(contentProjected ? { content: item.content } : {})
   });

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

@@ -134,6 +134,9 @@ function cliColdStartQualificationSummary(result = {}, flags = {}) {
     return Object.freeze({
       requirementId: item.requirementId,
       name: item.name,
+      material: item.material,
+      purpose: item.purpose,
+      declaredAvailability: item.declaredAvailability,
       state: item.state,
       referenceTarget: item.referenceTarget,
       kind: item.kind,
@@ -147,6 +150,7 @@ function cliColdStartQualificationSummary(result = {}, flags = {}) {
       actualBytes: item.actualBytes,
       actualSha256: item.actualSha256,
       contentState: item.contentState,
+      provenance: item.provenance,
       contentProjected,
       ...(contentProjected ? { content: item.content } : {})
     });

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

@@ -6,7 +6,7 @@ import { qualifyToolingRuntimeSourceAlignment } from './handoff.manufacture.runt
 import { normalizeHandoffCarrierLineage } from '../../handoff/carrierLineage.js';
 import { normalizeHandoffCarrierProfile } from '../../handoff/carrierProfile.js';
 import { enumerateNodeWorkspace, PORTABLE_NODE_WORKSPACE_ENUMERATION_SCHEMA_ID } from './handoff.manufacture.enumeration.js';
-import { preparePackageParentWorkspaceReuse } from './handoff.manufacture.packageParent.js';
+import { preparePackageParentWorkspaceReuse, projectRequiredContextWorkspaceSelectionPreflight } from './handoff.manufacture.packageParent.js';
 import { qualifyPortableSourceReconciliationProofForManufacture } from '../../comparison/sourceFrontierReconciliationProof.js';
 import { qualifyPortableManufactureSchemaReferenceCandidate } from '../../handoff/schemaReferencePreflight.js';
 import { qualifyDelegationReturnReservation } from '../../handoff/delegationReturnReservation.js';
@@ -46,14 +46,6 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
     (value) => Object.freeze({ value, error: null }),
     (error) => Object.freeze({ value: null, error })
   );
-  const enumerationPromise = enumerateNodeWorkspace(workspaceRoot, {
-    workspaceId,
-    workspaceTitle: requestedWorkspaceTitle,
-    sourceMetadata: input.workspaceSource || input.sourceMetadata || {},
-    excludeDirectories: input.excludeDirectories || options.excludeDirectories,
-    excludeRelativePaths: input.excludeRelativePaths || options.excludeRelativePaths,
-    maxFiles: input.maxFiles || options.maxFiles
-  });
   const additionalWorkspaceDescriptors = normalizeAdditionalWorkspaceDescriptors(input.additionalWorkspaces || input.workspaceRoots || input.workspaceDescriptors || []);
   const seenWorkspaceIds = new Set([workspaceId]);
   const additionalWorkspaceInputs = additionalWorkspaceDescriptors.map((descriptor) => {
@@ -77,6 +69,23 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
     workspaceIds: input.packageParentWorkspaceIds || input.reusePackageParentWorkspaceIds || [],
     workspaceAliases: input.packageParentWorkspaceAliases || input.workspaceAliases || {}
   });
+  const handoffMarkdown = await handoffMarkdownPromise;
+  const requiredContextWorkspaceSelectionPreflight = projectRequiredContextWorkspaceSelectionPreflight({
+    handoffMarkdown,
+    currentWorkspaceIds: [...seenWorkspaceIds],
+    packageParentReuse
+  });
+  if (requiredContextWorkspaceSelectionPreflight.state === 'action-required') {
+    throw new Error(`portable.handoff-manufacture.required-context.workspace-selection.required: ${requiredContextWorkspaceSelectionPreflight.nextAction} Missing Workspace ids: ${requiredContextWorkspaceSelectionPreflight.missingWorkspaceIds.join(',')}. Tooling will not auto-select package-parent Workspace source from carrier lineage.`);
+  }
+  const enumerationPromise = enumerateNodeWorkspace(workspaceRoot, {
+    workspaceId,
+    workspaceTitle: requestedWorkspaceTitle,
+    sourceMetadata: input.workspaceSource || input.sourceMetadata || {},
+    excludeDirectories: input.excludeDirectories || options.excludeDirectories,
+    excludeRelativePaths: input.excludeRelativePaths || options.excludeRelativePaths,
+    maxFiles: input.maxFiles || options.maxFiles
+  });
   const additionalEnumerationsPromise = Promise.all(additionalWorkspaceInputs.map(async ({ descriptor, id, root, requestedTitle }) => {
     const enumerated = await enumerateNodeWorkspace(root, {
       workspaceId: id,
@@ -90,8 +99,7 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
     return Object.freeze({ descriptor, id, root, requestedTitle, enumerated });
   }));
 
-  const [handoffMarkdown, enumeration, additionalEnumerations] = await Promise.all([
-    handoffMarkdownPromise,
+  const [enumeration, additionalEnumerations] = await Promise.all([
     enumerationPromise,
     additionalEnumerationsPromise
   ]);
@@ -217,10 +225,12 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
         selectionMode: String(packageParentReuse.selectionMode || ''),
         requestedWorkspaceIds: Object.freeze([...(packageParentReuse.requestedWorkspaceIds || [])].map(String)),
         providerWorkspaceIds: Object.freeze([...(packageParentReuse.providerWorkspaceIds || [])].map(String)),
+        providerWorkspaceTargets: Object.freeze([...(packageParentReuse.providerWorkspaceTargets || [])].map((item) => Object.freeze({ ...item }))),
         inheritedWorkspaceIds: Object.freeze((packageParentReuse.inherited || []).map((item) => String(item.id || ''))),
         workspaceAliases: Object.freeze([...(packageParentReuse.workspaceAliases || [])].map((item) => Object.freeze({ ...item }))),
         boundary: String(packageParentReuse.boundary || '')
       }),
+      requiredContextWorkspaceSelectionPreflight,
       carrierProjection: Object.freeze({ requestedRoutes: transportRoutes.length || 1, carrierLineage: normalizeHandoffCarrierLineage(input.carrierLineage || null), carrierProfile: normalizeHandoffCarrierProfile(input.carrierProfile || null), boundary: 'Routes are qualified later against packaged workspace bytes; adapter text is not authority.' })
     }),
     verifyRoundtrip: input.verifyRoundtrip !== false

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

@@ -1,6 +1,8 @@
 import { packageFileBytes, sha256Hex } from '../../../../export/package.bytes.js';
 import { inspectRecipientFacingV2Topology } from '../../handoff/recipientV2.inspect.js';
 import { parseHandoffPackageV1, RECIPIENT_V2_PACKAGE_V1_ROOT_PATH } from '../../handoff/recipientV2.packageV1.js';
+import { projectHandoffMaterialRequirements } from '../../handoff/materialClosure.requirements.js';
+import { parseWorkspaceQualifiedReference } from '../../handoff/workspaceQualifiedReference.js';
 
 export function preparePackageParentWorkspaceReuse(input = {}) {
   const bundle = input.bundle || null;
@@ -63,6 +65,7 @@ export function preparePackageParentWorkspaceReuse(input = {}) {
     providers: Object.freeze(providers),
     providerState: 'qualified',
     providerWorkspaceIds: Object.freeze(providers.map((item) => normalizeId(item.id))),
+    providerWorkspaceTargets: Object.freeze([...providerTargetById.entries()].map(([workspaceId, targetPath]) => Object.freeze({ workspaceId, path: targetPath }))),
     inherited: Object.freeze(inherited),
     workspaceTargets: Object.freeze(workspaceTargets),
     inspectionStatus: inspection.status,
@@ -74,6 +77,44 @@ export function preparePackageParentWorkspaceReuse(input = {}) {
   });
 }
 
+export function projectRequiredContextWorkspaceSelectionPreflight(input = {}) {
+  const reuse = input.packageParentReuse || input.reuse || {};
+  const currentWorkspaceIds = new Set([...(input.currentWorkspaceIds || [])].map(normalizeId).filter(Boolean));
+  const inheritedWorkspaceIds = new Set((reuse.inherited || []).map((item) => normalizeId(item.id || item.enumeration?.materialization?.id || '')).filter(Boolean));
+  const providerTargets = new Map((reuse.providerWorkspaceTargets || []).map((item) => [normalizeId(item.workspaceId), normalizeWorkspacePath(item.path)]));
+  const requirements = projectHandoffMaterialRequirements({ markdown: String(input.handoffMarkdown || '') }).required || [];
+  const missing = [];
+  for (const requirement of requirements) {
+    const target = parseWorkspaceQualifiedReference(String(requirement.reference?.target || requirement.materialReference || ''));
+    if (!target) continue;
+    const workspaceId = normalizeId(target.workspaceId);
+    if (!workspaceId || currentWorkspaceIds.has(workspaceId) || inheritedWorkspaceIds.has(workspaceId)) continue;
+    const providerTarget = providerTargets.get(workspaceId) || '';
+    if (!providerTarget || providerTarget !== normalizeWorkspacePath(target.path)) continue;
+    if (!/\bworkspace\b/i.test(String(requirement.material || ''))) continue;
+    missing.push(Object.freeze({
+      requirementId: String(requirement.id || ''),
+      name: String(requirement.name || ''),
+      workspaceId,
+      material: String(requirement.material || ''),
+      purpose: String(requirement.purpose || ''),
+      referenceTarget: String(requirement.reference?.target || requirement.materialReference || ''),
+      providerWorkspaceTarget: providerTarget,
+      basis: 'explicit-required-context-workspace-material-matches-qualified-package-parent-workspace-target'
+    }));
+  }
+  const missingWorkspaceIds = Object.freeze([...new Set(missing.map((item) => item.workspaceId))].sort());
+  return Object.freeze({
+    state: missingWorkspaceIds.length ? 'action-required' : 'ready',
+    missingWorkspaceIds,
+    requirements: Object.freeze(missing),
+    nextAction: missingWorkspaceIds.length
+      ? `Re-run manufacture with --package-parent-workspaces ${missingWorkspaceIds.join(',')} to carry the explicitly required Workspace material from the qualified package parent.`
+      : 'No mechanically required package-parent Workspace carriage selection is missing.',
+    boundary: 'This preflight fires only when exact Handoff Required Context explicitly describes Workspace material and its workspace-qualified Material Reference exactly matches a qualified package-parent Workspace target. It never auto-selects source, infers Workspace intent from filenames alone, or treats carrier lineage as source authority.'
+  });
+}
+
 export function normalizePackageParentWorkspaceSelection(value = []) {
   const raw = Array.isArray(value) ? value : [value];
   const tokens = raw.flatMap((item) => String(item || '').split(',')).map((item) => String(item || '').trim()).filter(Boolean);
@@ -205,6 +246,7 @@ function emptyReuse(state, options = {}) {
     providers: Object.freeze([]),
     providerState: String(options.providerState || 'unavailable'),
     providerWorkspaceIds: Object.freeze([]),
+    providerWorkspaceTargets: Object.freeze([]),
     inherited: Object.freeze([]),
     workspaceTargets: Object.freeze([]),
     inspectionStatus: String(options.inspectionStatus || ''),
@@ -218,6 +260,7 @@ function emptyReuse(state, options = {}) {
   });
 }
 function normalizeId(value = '') { return String(value || '').trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, ''); }
+function normalizeWorkspacePath(value = '') { return String(value || '').trim().replace(/\\/g, '/').replace(/^\/+/, ''); }
 function mediaTypeForPath(value = '') { const lower = String(value || '').toLowerCase(); if (lower.endsWith('.md')) return 'text/markdown'; if (lower.endsWith('.json')) return 'application/json'; if (/\.(?:m?js|cjs)$/.test(lower)) return 'text/javascript'; if (lower.endsWith('.ts')) return 'text/typescript'; if (lower.endsWith('.css')) return 'text/css'; if (lower.endsWith('.html')) return 'text/html'; if (/\.(?:yml|yaml)$/.test(lower)) return 'text/yaml'; if (lower.endsWith('.txt')) return 'text/plain'; return 'application/octet-stream'; }
 function stableJson(value) { return JSON.stringify(sortJson(value)); }
 function sortJson(value) { if (Array.isArray(value)) return value.map(sortJson); if (!value || typeof value !== 'object') return value; return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortJson(value[key])])); }

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

@@ -2,6 +2,8 @@ import { projectParticipantAuthority } from './grounding.participantAuthority.js
 import { projectWorkProvenance } from './grounding.workProvenance.js';
 import { projectGroundingSourceEvidence } from './grounding.sourceEvidence.js';
 import { projectGroundingPlanningContext } from './grounding.planningContext.js';
+import { projectGroundingParticipantContext } from './grounding.participantContext.js';
+import { projectGroundingProcessApplicability } from './grounding.processApplicability.js';
 
 export const PORTABLE_GROUNDING_CAPSULE_SCHEMA_ID = 'tiinex.portable.grounding-capsule.v1';
 
@@ -12,12 +14,15 @@ export function projectGroundingCapsule({ authority = null, continuation = null,
   const routeRecords = selectedRouteRecords(authority, records);
   const workProvenance = projectWorkProvenance({ records, topology });
   const participantAuthority = projectParticipantAuthority(authority);
+  const participantContext = projectGroundingParticipantContext(authority);
+  const processApplicability = projectGroundingProcessApplicability(authority);
+  const sourceEvidence = projectGroundingSourceEvidence({ records, contextAudit, continuation, requiredContext });
   return Object.freeze({
     schema: PORTABLE_GROUNDING_CAPSULE_SCHEMA_ID,
     semanticReductions: Object.freeze(requiredContext.slice(0, MAX_CONTEXT).map(reduceRequiredContext)),
     frontier: projectFrontier(topology, blockers),
     exclusions: Object.freeze(routeRecords.flatMap((record) => parseExclusions(record.markdown || '')).slice(0, MAX_EXCLUSIONS)),
-    sourceEvidence: projectGroundingSourceEvidence({ records, contextAudit, continuation }),
+    sourceEvidence,
     planningContext: projectGroundingPlanningContext(requiredContext),
     roleState: Object.freeze({
       recipient: String(authority?.role?.endpoint?.label || authority?.handoff?.to || ''),
@@ -27,8 +32,15 @@ export function projectGroundingCapsule({ authority = null, continuation = null,
       compatibility: String(authority?.holderBinding?.recipientCompatibility || 'unresolved')
     }),
     participantAuthority,
+    participantContext,
+    processApplicability,
     workProvenance,
-    unresolved: Object.freeze([...workProvenance.unresolved]),
+    unresolved: Object.freeze([
+      ...workProvenance.unresolved,
+      ...participantContext.unresolved,
+      ...processApplicability.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.orchestrationReadiness.js

@@ -0,0 +1,33 @@
+export function projectGroundingOrchestrationReadiness({ readinessState = '', participantContext = null, processApplicability = null, sourceEvidence = null, topology = {} } = {}) {
+  const boundedAction = String(readinessState || '');
+  const participantMap = String(participantContext?.participantMapState || 'not-established');
+  const unavailableSources = sourceEvidence?.blockers || [];
+  const sourceScope = sourceScopeState(sourceEvidence);
+  const processState = String(processApplicability?.state || 'not-established');
+  const blockers = [];
+  if (participantMap !== 'explicit-bounded-map') blockers.push(Object.freeze({ code: 'participant-capability-map-not-established', detail: 'Current route grounding does not establish a semantic participant/capability map. Grounding-only Role pointers and endpoint labels are insufficient.' }));
+  if (unavailableSources.length) blockers.push(...unavailableSources.map((item) => Object.freeze({ code: item.code || 'authoritative-material-unavailable', detail: item.request || item.name || item.referenceTarget || '' })));
+  if (sourceScope !== 'explicit-multi-source') blockers.push(Object.freeze({ code: 'source-authority-scope-bounded', detail: 'Source evidence is bounded to exact carried/current-route material and does not establish whole-program source authority.' }));
+  if (processState !== 'explicit-qualified-authority') blockers.push(Object.freeze({
+    code: 'process-applicability-semantic-authority-not-established',
+    detail: String(processApplicability?.unresolved?.[0]?.detail || 'Current grounding does not contain an explicit upstream-qualified process-applicability projection; process inventory and Role carriage are not substitutes.')
+  }));
+  if (!(topology.currentFrontier || []).length) blockers.push(Object.freeze({ code: 'current-work-frontier-unresolved', detail: 'No exact current Task frontier is resolved for orchestration.' }));
+  return Object.freeze({
+    state: blockers.length ? 'bounded-route-only' : 'sufficiently-grounded-for-current-orchestration-scope',
+    boundedActionReadiness: boundedAction,
+    widerOrchestration: Object.freeze({ state: blockers.length ? 'not-established' : 'bounded-established', blockers: Object.freeze(blockers.slice(0, 8)) }),
+    participantMap,
+    sourceScope,
+    processApplicability: processApplicability || Object.freeze({ state: processState, unresolved: Object.freeze([]) }),
+    boundary: 'Diagnostic projection only; this is not a new lifecycle state and does not weaken or broaden grounded-to-act. Route authorization is not treated as whole-program understanding.'
+  });
+}
+
+function sourceScopeState(sourceEvidence = {}) {
+  const workspaces = sourceEvidence?.workspaces || [];
+  const qualified = workspaces.filter((item) => ['qualified', 'explicit-profile'].includes(String(item.state || '')));
+  if (qualified.length > 1 && qualified.every((item) => item.sources?.length || item.repository || item.rootPath)) return 'explicit-multi-source';
+  if (qualified.length) return 'bounded-current-route';
+  return 'unresolved';
+}

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

@@ -0,0 +1,58 @@
+const MAX_PARTICIPANTS = 8;
+const MAX_ROLES = 8;
+
+export function projectGroundingParticipantContext(authority = null) {
+  const participation = authority?.participation || {};
+  const semanticParticipants = (participation.participants || []).slice(0, MAX_PARTICIPANTS).map((item) => Object.freeze({
+    id: String(item.id || ''),
+    label: String(item.label || ''),
+    roles: Object.freeze([...(item.roles || [])].map(String)),
+    verification: String(item.verification || 'declared'),
+    semanticParticipant: true,
+    basis: 'explicit-participant-declaration',
+    provenance: Object.freeze({
+      basis: 'explicit-qualified-participation-input',
+      source: String(item.source || item.provenance?.source || ''),
+      boundary: 'Only explicit semantic participant authority is projected as participation.'
+    })
+  }));
+  const roleGrounding = (participation.packageRoleGrounding || participation.packageRoleParticipants || []).slice(0, MAX_ROLES).map((item) => Object.freeze({
+    label: String(item.label || item.roleArtifact?.roleLabel || ''),
+    pointerPath: String(item.pointerPath || ''),
+    roleArtifact: Object.freeze({ ...(item.roleArtifact || {}) }),
+    groundingOnly: true,
+    semanticParticipant: false,
+    basis: 'explicit-package-role-grounding-pointer',
+    provenance: Object.freeze({
+      basis: 'package-role-grounding-pointer',
+      pointerPath: String(item.pointerPath || ''),
+      boundary: 'This proves only package-local Role grounding availability, not semantic participation.'
+    })
+  }));
+  const endpoints = (participation.handoffCapacities || []).slice(0, 2).map((item) => Object.freeze({
+    direction: String(item.direction || ''),
+    label: String(item.label || ''),
+    kind: String(item.kind || ''),
+    semanticClass: 'handoff-capacity',
+    semanticParticipant: false,
+    provenance: Object.freeze({
+      basis: 'selected-handoff-endpoint',
+      boundary: 'Handoff endpoint capacity is not a participant declaration.'
+    })
+  }));
+  const mapState = semanticParticipants.length ? 'explicit-bounded-map' : 'not-established';
+  return Object.freeze({
+    state: semanticParticipants.length ? 'explicit-semantic-participants' : roleGrounding.length ? 'qualified-role-grounding-only' : 'unresolved',
+    participantMapState: mapState,
+    semanticParticipants: Object.freeze(semanticParticipants),
+    roleGrounding: Object.freeze(roleGrounding),
+    endpoints: Object.freeze(endpoints),
+    unresolved: Object.freeze(semanticParticipants.length ? [] : [{
+      code: 'participant-map-not-established',
+      detail: 'No explicit semantic participant declaration or authoritative participant Relation is present in the current grounding input. Carried Role pointers remain grounding-only.',
+      basis: 'absence-of-explicit-semantic-participant-authority',
+      nextAuthorityNeeded: 'Provide an explicit qualified participant declaration/projection from semantic authority; do not infer it from Roles or Handoff endpoints.'
+    }]),
+    boundary: 'Only explicit semantic participant declarations count as participants here. Package Role grounding pointers and Handoff endpoints are projected separately and never infer participation, holder identity, delegation, or relevance from Role inventory, filenames, transport, chat position, or package adjacency.'
+  });
+}

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

@@ -0,0 +1,38 @@
+const MAX_FACTS = 12;
+
+export function projectGroundingProcessApplicability(authority = null) {
+  const supplied = authority?.processApplicability || null;
+  const explicitlyQualified = Boolean(
+    supplied
+    && supplied.explicit === true
+    && String(supplied.qualification || supplied.state || '') === 'qualified'
+  );
+  if (!explicitlyQualified) return Object.freeze({
+    state: 'not-established',
+    facts: Object.freeze([]),
+    provenance: Object.freeze({
+      basis: 'no-upstream-qualified-explicit-process-applicability-projection',
+      source: '',
+      boundary: 'Core does not discover process inventory or define the semantic declaration pattern. It consumes only an upstream projection already marked explicit and qualified by semantic authority.'
+    }),
+    unresolved: Object.freeze([Object.freeze({
+      code: 'process-applicability-semantic-authority-not-established',
+      detail: 'Current qualified grounding authority contains no explicit, upstream-qualified process-applicability projection. Supply semantic-owner-qualified applicability authority; do not infer applicability from carried Roles, Handoff endpoints, filenames, folders, process inventory, or repository adjacency.'
+    })]),
+    boundary: 'Semantics-neutral pass-through only. Absence stays unresolved; carriage and inventory never become applicability.'
+  });
+
+  const facts = Array.isArray(supplied.facts) ? supplied.facts : Array.isArray(supplied.items) ? supplied.items : [];
+  return Object.freeze({
+    state: 'explicit-qualified-authority',
+    facts: Object.freeze(facts.slice(0, MAX_FACTS).map((item) => Object.freeze({ ...(item || {}) }))),
+    provenance: Object.freeze({
+      basis: 'upstream-qualified-explicit-process-applicability-projection',
+      source: String(supplied.source || supplied.provenance?.source || ''),
+      upstreamProvenance: supplied.provenance ? Object.freeze({ ...(supplied.provenance || {}) }) : null,
+      boundary: 'Facts are passed through without Core interpreting process inventory or inventing process-to-participant semantics.'
+    }),
+    unresolved: Object.freeze([]),
+    boundary: 'Semantics-neutral pass-through only. Core does not define or expand the declaration pattern that established these facts.'
+  });
+}

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

@@ -1,12 +1,57 @@
 export function projectGroundingAuthority(authority, mode) {
   if (!authority || mode !== 'routed-handoff-package') return Object.freeze({ state: 'not-supplied', route: null, handoff: null, role: null, holderBinding: null, operationBoundary: null });
   const mutationBoundary = authority.mutationBoundary || null;
+  const selectedRoute = authority.selectedRoute || null;
+  const handoff = authority.handoff || null;
   return Object.freeze({
     state: String(authority.status || ''),
-    route: authority.selectedRoute ? Object.freeze({ id: authority.selectedRoute.id || '', pointerPath: authority.selectedRoute.pointerPath || '', workspaceId: authority.selectedRoute.workspaceId || '' }) : null,
-    handoff: authority.handoff ? Object.freeze({ purpose: authority.handoff.purpose || '', from: authority.handoff.from || '', to: authority.handoff.to || '', completionExpectation: authority.handoff.completionExpectation || null }) : null,
+    route: selectedRoute ? Object.freeze({
+      id: selectedRoute.id || '',
+      pointerPath: selectedRoute.pointerPath || '',
+      workspaceId: selectedRoute.workspaceId || '',
+      workspaceRelativePath: selectedRoute.workspaceRelativeHandoffPath || selectedRoute.workspaceRelativePath || '',
+      sha256: selectedRoute.sha256 || '',
+      provenance: Object.freeze({
+        basis: 'explicit-qualified-route-selection',
+        pointerPath: selectedRoute.pointerPath || '',
+        workspaceId: selectedRoute.workspaceId || '',
+        workspaceRelativePath: selectedRoute.workspaceRelativeHandoffPath || selectedRoute.workspaceRelativePath || '',
+        boundary: 'Route authority is bounded to the exact qualified selected route; nearby package routes and filenames are not substituted.'
+      })
+    }) : null,
+    handoff: handoff ? Object.freeze({
+      purpose: handoff.purpose || '',
+      from: handoff.from || '',
+      to: handoff.to || '',
+      transfers: Object.freeze((handoff.transfers || []).map((item) => Object.freeze({ ...item }))),
+      completionExpectation: handoff.completionExpectation || null,
+      provenance: Object.freeze({
+        basis: 'exact-selected-handoff-bytes',
+        routeId: handoff.routeId || selectedRoute?.id || '',
+        workspaceId: handoff.workspaceId || selectedRoute?.workspaceId || '',
+        workspaceRelativePath: handoff.workspaceRelativePath || selectedRoute?.workspaceRelativeHandoffPath || '',
+        packagePath: handoff.packagePath || selectedRoute?.packagePath || '',
+        sha256: handoff.sha256 || selectedRoute?.sha256 || '',
+        boundary: handoff.boundary || 'Exact selected Handoff bytes are semantic authority for Handoff parties, purpose, transfers and completion expectation.'
+      })
+    }) : null,
     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 || '', holderId: authority.holderBinding.holderId || '', roleLabel: authority.holderBinding.roleLabel || '', recipientRoleLabel: authority.holderBinding.recipientRoleLabel || '', recipientCompatibility: authority.holderBinding.recipientCompatibility || '', source: authority.holderBinding.source || '', explicit: Boolean(authority.holderBinding.explicit), inferredFromTransport: Boolean(authority.holderBinding.inferredFromTransport), boundary: authority.holderBinding.boundary || '' }) : null,
+    holderBinding: authority.holderBinding ? Object.freeze({
+      state: authority.holderBinding.state || '',
+      holderId: authority.holderBinding.holderId || '',
+      roleLabel: authority.holderBinding.roleLabel || '',
+      recipientRoleLabel: authority.holderBinding.recipientRoleLabel || '',
+      recipientCompatibility: authority.holderBinding.recipientCompatibility || '',
+      source: authority.holderBinding.source || '',
+      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 || '',
+        boundary: authority.holderBinding.boundary || 'Consuming-session holder identity is never inferred from route transport or recipient position.'
+      }),
+      boundary: authority.holderBinding.boundary || ''
+    }) : null,
     operationBoundary: mutationBoundary ? Object.freeze({
       ...mutationBoundary,
       scope: 'current-grounding-operation-only',

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

@@ -9,6 +9,7 @@ import { auditHandoffPackageContextCarriage } from '../handoff/contextAudit.js';
 import { acceptedRecoveryMaterial, projectColdStartContinuity } from './grounding.continuity.js';
 import { projectGroundingAuthority } from './grounding.readiness.authority.js';
 import { projectGroundingCapsule } from './grounding.capsule.js';
+import { projectGroundingOrchestrationReadiness } from './grounding.orchestrationReadiness.js';
 
 export const PORTABLE_GROUNDING_READINESS_SCHEMA_ID = 'tiinex.portable.grounding-readiness.v1';
 
@@ -190,6 +191,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
   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.'));
+  const orchestrationReadiness = projectGroundingOrchestrationReadiness({ readinessState: state, participantContext: capsule.participantContext, processApplicability: capsule.processApplicability, sourceEvidence: capsule.sourceEvidence, topology });
 
   return Object.freeze({
     schema: PORTABLE_GROUNDING_READINESS_SCHEMA_ID,
@@ -240,6 +242,7 @@ export function composeGroundingReadiness({ mode = 'loaded-material', authority
       boundary: 'Leaf/root roles are derived only from loaded declared Parent edges produced by the shared lineage resolver. Filename numbering, carrier dimensions, directory depth, branch names, and Task lifecycle labels are never substituted for Parent topology.'
     }),
     continuity,
+    orchestrationReadiness,
     capsule,
     currentWork: Object.freeze({
       state: topology.currentFrontier.length ? 'current-frontier-resolved' : topology.currentTasks.length ? 'current-candidates-without-frontier' : 'unresolved',

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

@@ -122,12 +122,16 @@ export function projectRequiredContext(requiredContext = [], selectors = []) {
     return Object.freeze({
       requirementId: entry.requirementId || '',
       name: entry.name || '',
+      material: entry.material || '',
+      purpose: entry.purpose || '',
+      declaredAvailability: entry.declaredAvailability || '',
       state: entry.state || '',
       workspaceId: entry.workspaceId || '',
       innerPath: entry.innerPath || entry.workspaceRelativePath || '',
       referenceTarget: entry.referenceTarget || '',
       bytes: Number(entry.bytes || entry.actualBytes || 0),
       sha256: entry.sha256 || entry.actualSha256 || '',
+      provenance: entry.provenance ? Object.freeze({ ...entry.provenance }) : null,
       contentProjected,
       ...(contentProjected ? { content: entry.content } : {})
     });

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

@@ -1,12 +1,17 @@
 import { parseWorkspaceEntrypoints } from '../handoff/workspaceSourceIdentity.js';
 const MAX_WORKSPACES = 8;
 const MAX_SOURCES = 8;
+const MAX_MATERIALS = 12;
+const MAX_BLOCKERS = 8;
 
-export function projectGroundingSourceEvidence({ records = [], contextAudit = null, continuation = null, sourceProfiles = [] } = {}) {
+export function projectGroundingSourceEvidence({ records = [], contextAudit = null, continuation = null, requiredContext = [], sourceProfiles = [] } = {}) {
   const byPath = new Map((records || []).map((record) => [String(record.path || ''), record]));
   const profiles = profileIndex(sourceProfiles);
+  const coverageByWorkspace = new Map();
   const workspaces = (contextAudit?.workspaceMaterializations || []).slice(0, MAX_WORKSPACES).map((workspace) => {
     const workspaceId = String(workspace.workspaceId || '');
+    const coverage = normalizeCoverage(workspace);
+    if (workspaceId) coverageByWorkspace.set(workspaceId, coverage);
     const innerPath = normalizePath(workspace.sourceWorkspaceTargetInnerPath || '');
     const exactPath = workspaceId && innerPath ? `${workspaceId}/${innerPath}` : '';
     const record = exactPath ? byPath.get(exactPath) : null;
@@ -21,10 +26,21 @@ export function projectGroundingSourceEvidence({ records = [], contextAudit = nu
       && record.hasContinuityContext
       && record.hasIntegrity
     );
-    if (!qualifiedArtifact && !explicitProfile.length) return Object.freeze({ workspace: workspaceId, state: 'unresolved' });
+    if (!qualifiedArtifact && !explicitProfile.length) return Object.freeze({
+      workspace: workspaceId,
+      state: 'unresolved',
+      coverage,
+      carrier: String(workspace.reason || ''),
+      provenance: Object.freeze({
+        basis: 'carried-workspace-materialization-without-qualified-source-declaration',
+        sourceArtifactPath: exactPath,
+        boundary: 'Workspace carriage alone does not establish repository/source identity.'
+      })
+    });
     return Object.freeze({
       workspace: workspaceId,
       state: qualifiedArtifact ? 'qualified' : 'explicit-profile',
+      coverage,
       carrier: String(workspace.reason || 'qualified-workspace-snapshot'),
       sourceArtifactPath: exactPath,
       sourceArtifactSha256: String(workspace.sourceWorkspaceTargetSha256 || ''),
@@ -32,20 +48,150 @@ export function projectGroundingSourceEvidence({ records = [], contextAudit = nu
       ref: String(unique?.ref || ''),
       rootPath: String(unique?.rootPath || ''),
       remoteState: String(unique?.remoteState || 'not-checked'),
-      sources: Object.freeze(sources.slice(0, MAX_SOURCES))
+      sources: Object.freeze(sources.slice(0, MAX_SOURCES)),
+      provenance: Object.freeze({
+        basis: qualifiedArtifact ? 'exact-qualified-workspace-source-artifact' : 'explicit-source-profile',
+        sourceArtifactPath: exactPath,
+        sourceArtifactSha256: String(workspace.sourceWorkspaceTargetSha256 || ''),
+        coverageBasis: String(workspace.reason || ''),
+        boundary: qualifiedArtifact
+          ? 'Source identity is projected only from the exact qualified Workspace artifact carried for this Workspace.'
+          : 'Source identity is projected only from an explicitly supplied source profile; no repository discovery is implied.'
+      })
     });
   });
+
+  const requirements = (requiredContext || []).slice(0, MAX_MATERIALS).map((entry) => projectRequirement(entry, coverageByWorkspace));
+  const unavailable = requirements.filter((entry) => entry.availability === 'unavailable');
+  const blockers = unavailable.slice(0, MAX_BLOCKERS).map((entry) => Object.freeze({
+    code: 'authoritative-material-unavailable',
+    requirementId: entry.requirementId,
+    name: entry.name,
+    requiredMaterial: Object.freeze({
+      material: entry.material,
+      referenceTarget: entry.referenceTarget,
+      workspace: entry.workspace,
+      path: entry.path
+    }),
+    owner: Object.freeze({
+      kind: 'selected-handoff-required-context',
+      requirementId: entry.requirementId,
+      name: entry.name,
+      purpose: entry.purpose
+    }),
+    basis: Object.freeze({
+      state: entry.state,
+      availability: entry.availability,
+      materialClass: entry.materialClass,
+      workspaceCoverage: entry.workspaceCoverage,
+      providerMode: entry.providerMode,
+      kind: entry.kind,
+      provenance: entry.provenance
+    }),
+    blockingReason: 'The exact declared Required Context material is not qualified in current carried/explicit material, so Tooling cannot claim that authority is available.',
+    workspace: entry.workspace,
+    path: entry.path,
+    referenceTarget: entry.referenceTarget,
+    request: exactMaterialRequest(entry)
+  }));
+  const boundedOrCache = requirements.filter((entry) => entry.availability === 'qualified' && ['bounded-workspace', 'cache'].includes(entry.materialClass));
+  const contextMaterials = [
+    ...(contextAudit?.materialCarriers || []).map((item) => projectAuditMaterial(item, 'requirement-material')),
+    ...(contextAudit?.explicitDetachedMaterial || []).map((item) => projectAuditMaterial(item, 'bounded-or-cache-material')),
+    ...(contextAudit?.lineageMaterializations || []).map((item) => projectAuditMaterial(item, 'lineage-cache-material'))
+  ].slice(0, MAX_MATERIALS);
+
   return Object.freeze({
     carrier: Object.freeze({
       state: String(contextAudit?.coverage?.state || contextAudit?.status || 'unresolved'),
       workspaceCount: Number(contextAudit?.workspaceMaterializations?.length || 0),
-      packageSourcePath: String(continuation?.packageSourcePath || '')
+      packageSourcePath: String(continuation?.packageSourcePath || ''),
+      completeWorkspaceCount: workspaces.filter((item) => item.coverage === 'complete').length,
+      boundedWorkspaceCount: workspaces.filter((item) => item.coverage === 'bounded').length
     }),
     workspaces: Object.freeze(workspaces),
-    boundary: 'Exact selected Workspace source artifact/profile only.'
+    requirements: Object.freeze(requirements),
+    boundedOrCache: Object.freeze(boundedOrCache),
+    carriedMaterial: Object.freeze(contextMaterials),
+    blockers: Object.freeze(blockers),
+    boundary: 'Exact selected Workspace/source declarations and exact qualified Required Context material only. Complete Workspace carriage, bounded Workspace/cache material, explicit requirements, and unavailable authoritative material remain distinct. Missing material never authorizes repository, connector, or network discovery.'
+  });
+}
+
+function projectRequirement(entry = {}, coverageByWorkspace = new Map()) {
+  const state = String(entry.state || 'unresolved');
+  const providerMode = String(entry.providerMode || '');
+  const workspace = String(entry.workspaceId || '');
+  const workspaceCoverage = coverageByWorkspace.get(workspace) || 'unresolved';
+  let materialClass = 'explicit-requirement';
+  if (state === 'qualified') {
+    if (providerMode === 'cache' || String(entry.kind || '') === 'workspace-cache-entry') materialClass = 'cache';
+    else if (providerMode === 'archive' && workspaceCoverage === 'bounded') materialClass = 'bounded-workspace';
+    else if (providerMode === 'archive' && workspaceCoverage === 'complete') materialClass = 'complete-workspace';
+    else if (providerMode === 'archive') materialClass = 'workspace-material';
+    else materialClass = 'qualified-material';
+  }
+  return Object.freeze({
+    requirementId: String(entry.requirementId || ''),
+    name: String(entry.name || ''),
+    material: String(entry.material || ''),
+    purpose: String(entry.purpose || ''),
+    declaredAvailability: String(entry.declaredAvailability || ''),
+    state,
+    availability: state === 'qualified' ? 'qualified' : 'unavailable',
+    materialClass,
+    workspace,
+    workspaceCoverage,
+    path: String(entry.innerPath || entry.workspaceRelativePath || ''),
+    packagePath: String(entry.packagePath || entry.archivePackagePath || ''),
+    providerMode,
+    kind: String(entry.kind || ''),
+    referenceTarget: String(entry.referenceTarget || ''),
+    bytes: Number(entry.bytes || 0),
+    sha256: String(entry.sha256 || ''),
+    provenance: Object.freeze({
+      basis: String(entry.provenance?.basis || 'selected-handoff-required-context-and-route-closure'),
+      declarationSource: entry.provenance?.declarationSource ? Object.freeze({ ...(entry.provenance.declarationSource || {}) }) : null,
+      resolutionKind: String(entry.provenance?.resolutionKind || entry.kind || ''),
+      providerMode: String(entry.provenance?.providerMode || providerMode),
+      boundary: String(entry.provenance?.boundary || 'Requirement identity comes from the selected Handoff declaration; qualification/material class comes from exact route closure and carried source state.')
+    })
+  });
+}
+
+function projectAuditMaterial(item = {}, classification = '') {
+  return Object.freeze({
+    classification,
+    requirementId: String(item.requirementId || item.requirement?.id || ''),
+    name: String(item.requirement?.name || ''),
+    workspace: String(item.workspaceId || item.targetWorkspaceId || item.selectedProvider?.workspaceId || ''),
+    path: String(item.workspaceRelativePath || item.targetPath || item.originalPath || item.selectedProvider?.workspaceRelativePath || ''),
+    packagePath: String(item.path || item.archivePackagePath || ''),
+    bytes: Number(item.bytes || item.actualBytes || 0),
+    sha256: String(item.sha256 || item.actualSha256 || ''),
+    authority: Object.freeze({ ...(item.authority || {}) }),
+    provenance: Object.freeze({
+      basis: classification,
+      carrierPath: String(item.path || item.archivePackagePath || ''),
+      boundary: 'Diagnostic carriage evidence only; presence does not create semantic authority beyond the requirement/material it exactly resolves.'
+    })
   });
 }
 
+function exactMaterialRequest(entry = {}) {
+  const target = entry.referenceTarget || [entry.workspace, entry.path].filter(Boolean).join('::') || entry.name || entry.requirementId || 'the declared Required Context material';
+  return `Provide exact qualified material for ${target}, or an explicitly qualified bounded Workspace/cache carrier that resolves this declared requirement. Do not substitute GitHub, a connector, a repository checkout, or network discovery without separate authority.`;
+}
+
+function normalizeCoverage(workspace = {}) {
+  const explicit = String(workspace.coverage || '').trim().toLowerCase();
+  if (explicit === 'complete' || explicit === 'bounded') return explicit;
+  const reason = String(workspace.reason || '').toLowerCase();
+  if (reason.includes('bounded') || reason.includes('partial')) return 'bounded';
+  if (reason.includes('complete')) return 'complete';
+  return 'unresolved';
+}
+
 function profileIndex(value = []) {
   const map = new Map();
   if (!value) return map;
@@ -64,8 +210,4 @@ function profileIndex(value = []) {
 }
 function normalizeProfileList(value) { return (Array.isArray(value) ? value : [value]).filter(Boolean).map(normalizeProfile); }
 function normalizeProfile(value = {}) { return Object.freeze({ label: String(value.label || ''), sourceKind: String(value.sourceKind || value.kind || ''), repository: String(value.repository || ''), ref: String(value.ref || ''), rootPath: String(value.rootPath || ''), remoteState: String(value.remoteState || 'not-checked'), basis: 'explicit-source-profile' }); }
-function section(markdown = '', heading = '') { const escaped = escape(heading); return String(markdown || '').match(new RegExp(`(?:^|\\n)##\\s+${escaped}\\s*\\r?\\n([\\s\\S]*?)(?=\\n##\\s+|\\n#\\s+Continuity Integrity|$)`, 'i'))?.[1]?.trim() || ''; }
-function field(markdown = '', label = '') { const escaped = escape(label); return strip(String(markdown || '').match(new RegExp(`^\\s*-\\s+${escaped}:\\s*(.+)$`, 'mi'))?.[1] || ''); }
 function normalizePath(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\/+/, ''); }
-function strip(value = '') { return String(value || '').replace(/^\[([^\]]+)\]\([^)]+\)$/, '$1').replace(/[`*_]/g, '').trim(); }
-function escape(value = '') { return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }

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

@@ -76,7 +76,18 @@ function qualifyRequiredRequirement(bundle, descriptor, byteProvider, workspace,
   if (!resolution&&!reasons.length) resolution=resolveDescriptorMaterial(bundle,descriptor,byteProvider,target,requirementId,workspace.id,routePath);
   if (!resolution&&!reasons.length) reasons.push('required-material-not-carried');
   if (resolution?.state!=='qualified'&&resolution?.reason) reasons.push(resolution.reason);
-  return deepFreeze({requirementId:String(requirement.id||''),name:String(requirement.name||''),referenceTarget:target,state:!reasons.length&&resolution?.state==='qualified'?'qualified':'blocked',resolution:resolution?.state==='qualified'?resolution:null,reasons:Object.freeze([...new Set(reasons)])});
+  return deepFreeze({
+    requirementId:String(requirement.id||''),
+    name:String(requirement.name||''),
+    material:String(requirement.material||''),
+    purpose:String(requirement.purpose||''),
+    declaredAvailability:String(requirement.availability||''),
+    referenceTarget:target,
+    declarationSource:requirement.source||null,
+    state:!reasons.length&&resolution?.state==='qualified'?'qualified':'blocked',
+    resolution:resolution?.state==='qualified'?resolution:null,
+    reasons:Object.freeze([...new Set(reasons)])
+  });
 }
 
 function resolveWorkspaceRequiredMaterial(byteProvider, workspace, resolvedPath) {

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

@@ -232,6 +232,9 @@ function hydrateRequiredContextEntry(bundle = {}, entry = {}, context = null) {
   const base = {
     requirementId: String(entry.requirementId || ''),
     name: String(entry.name || ''),
+    material: String(entry.material || ''),
+    purpose: String(entry.purpose || ''),
+    declaredAvailability: String(entry.declaredAvailability || ''),
     state: String(entry.state || resolution.state || 'unresolved'),
     referenceTarget: String(entry.referenceTarget || ''),
     kind: String(resolution.kind || ''),
@@ -241,7 +244,14 @@ function hydrateRequiredContextEntry(bundle = {}, entry = {}, context = null) {
     packagePath: String(resolution.packagePath || ''),
     providerMode: String(resolution.providerMode || ''),
     bytes: Number(resolution.bytes || 0),
-    sha256: String(resolution.sha256 || '')
+    sha256: String(resolution.sha256 || ''),
+    provenance: Object.freeze({
+      basis: 'selected-handoff-required-context-declaration',
+      declarationSource: entry.declarationSource ? Object.freeze({ ...(entry.declarationSource || {}) }) : null,
+      resolutionKind: String(resolution.kind || ''),
+      providerMode: String(resolution.providerMode || ''),
+      boundary: 'Material/Purpose/Availability are copied from the exact selected Handoff Required Context declaration; qualification and bytes come from exact route closure resolution.'
+    })
   };
   if (base.state !== 'qualified') return Object.freeze({ ...base, contentState: 'unavailable', content: '' });
   const hydrated = resolveQualifiedMaterialBytes(bundle, resolution, context);

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

@@ -184,7 +184,7 @@ function auditRecipientV2(bundle = {}) {
         sha256: String(material.sha256 || '')
       })))
     : [];
-  return deepFreeze({ schema: PORTABLE_HANDOFF_CONTEXT_AUDIT_SCHEMA_ID, status: inspection.status === 'valid' && !unexplained ? 'ready' : 'blocked', coverage: Object.freeze({ nonControlCarrierCount: files.length, classifiedCarrierCount: classified, unexplainedCarrierCount: unexplained, state: unexplained ? 'incomplete' : 'qualified' }), workspaceMaterializations: Object.freeze((inspection.workspaces || []).map((item) => Object.freeze({ workspaceId: item.workspaceId, reason: 'complete-workspace-archive-representation', qualification: 'qualified', carrierMode: 'archive', workspaceTargetPackagePath: item.workspaceArtifactPath, archivePackagePath: item.workspaceArchivePath, sourceWorkspaceTargetInnerPath: item.sourceWorkspaceTargetInnerPath, sourceWorkspaceTargetSha256: item.sourceWorkspaceTargetSha256 }))), lineageMaterializations: Object.freeze(lineageMaterializations), materialCarriers: Object.freeze([]), generatedEntrypoints: Object.freeze([String(inspection.rootArtifact?.path || ''), RECIPIENT_V2_READ_PATH, ...(inspection.endpointRoles || []).map((item) => item.pointerPath), ...(inspection.participantRoles || []).map((item) => item.pointerPath), ...(inspection.routes || []).map((item) => item.pointerPath)].filter(Boolean)), namedPackageRequirements: Object.freeze([]), explicitDetachedMaterial: Object.freeze(cacheMaterials), unexplainedCarriers: Object.freeze([]), duplicateByteSummary: Object.freeze({ materialCarriersAlsoPresentInWorkspace: 0, totalMaterialCarriers: cacheMaterials.length, interpretation: 'Exact Workspace-scoped recipient cache material is permitted only when not satisfied by a qualified Workspace archive.' }), routeGrounding: Object.freeze((inspection.carrierProjection?.routes || []).map((route) => Object.freeze({ routeId: route.id, workspaceId: route.workspaceId, handoffPackagePath: route.packagePath, required: route.requiredClosure?.requirements || [] }))), inspections: Object.freeze({ recipientV2: inspection.status, parentBoundaryGrounding: parentBoundaryGroundingEligible ? 'qualified-package-v1' : 'not-projected' }), findings: Object.freeze(dedupeFindings(findings)), boundary: 'Recipient-facing v2 carriage audit over qualified visible Tiinex artifacts and exact payload bytes. Complete Workspace snapshots and independently qualified package-v1 detached Parent-boundary lineage are projected separately; detached lineage never implies whole-Workspace carriage or membership.' });
+  return deepFreeze({ schema: PORTABLE_HANDOFF_CONTEXT_AUDIT_SCHEMA_ID, status: inspection.status === 'valid' && !unexplained ? 'ready' : 'blocked', coverage: Object.freeze({ nonControlCarrierCount: files.length, classifiedCarrierCount: classified, unexplainedCarrierCount: unexplained, state: unexplained ? 'incomplete' : 'qualified' }), workspaceMaterializations: Object.freeze((inspection.workspaces || []).map((item) => Object.freeze({ workspaceId: item.workspaceId, coverage: String(item.coverage || 'unresolved'), reason: String(item.coverage || '') === 'complete' ? 'complete-workspace-archive-representation' : String(item.coverage || '') === 'bounded' ? 'bounded-workspace-archive-representation' : 'workspace-archive-representation', qualification: 'qualified', carrierMode: 'archive', workspaceTargetPackagePath: item.workspaceArtifactPath, archivePackagePath: item.workspaceArchivePath, sourceWorkspaceTargetInnerPath: item.sourceWorkspaceTargetInnerPath, sourceWorkspaceTargetSha256: item.sourceWorkspaceTargetSha256 }))), lineageMaterializations: Object.freeze(lineageMaterializations), materialCarriers: Object.freeze([]), generatedEntrypoints: Object.freeze([String(inspection.rootArtifact?.path || ''), RECIPIENT_V2_READ_PATH, ...(inspection.endpointRoles || []).map((item) => item.pointerPath), ...(inspection.participantRoles || []).map((item) => item.pointerPath), ...(inspection.routes || []).map((item) => item.pointerPath)].filter(Boolean)), namedPackageRequirements: Object.freeze([]), explicitDetachedMaterial: Object.freeze(cacheMaterials), unexplainedCarriers: Object.freeze([]), duplicateByteSummary: Object.freeze({ materialCarriersAlsoPresentInWorkspace: 0, totalMaterialCarriers: cacheMaterials.length, interpretation: 'Exact Workspace-scoped recipient cache material is permitted only when not satisfied by a qualified Workspace archive.' }), routeGrounding: Object.freeze((inspection.carrierProjection?.routes || []).map((route) => Object.freeze({ routeId: route.id, workspaceId: route.workspaceId, handoffPackagePath: route.packagePath, required: route.requiredClosure?.requirements || [] }))), inspections: Object.freeze({ recipientV2: inspection.status, parentBoundaryGrounding: parentBoundaryGroundingEligible ? 'qualified-package-v1' : 'not-projected' }), findings: Object.freeze(dedupeFindings(findings)), boundary: 'Recipient-facing v2 carriage audit over qualified visible Tiinex artifacts and exact payload bytes. Complete Workspace snapshots and independently qualified package-v1 detached Parent-boundary lineage are projected separately; detached lineage never implies whole-Workspace carriage or membership.' });
 }
 
 function indexWorkspaceEntries(workspaces = []) {

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

@@ -8,8 +8,8 @@ export function auditPortableRecoveryAcceptance(input = {}) {
   const basisInspection = inspectRecipientFacingV2Topology(input.basis?.bundle || input.basis || {});
   const candidateInspection = inspectRecipientFacingV2Topology(input.candidate?.bundle || input.candidate || {});
   const findings = [];
-  if (String(basisInspection.status || '') !== 'valid') findings.push(finding('error', 'portable.recovery-acceptance.basis-unqualified', 'Recovery acceptance audit requires one independently qualified accepted-basis Handoff package.'));
-  if (String(candidateInspection.status || '') !== 'valid') findings.push(finding('error', 'portable.recovery-acceptance.candidate-unqualified', 'Recovery acceptance audit requires one independently qualified candidate Handoff package.'));
+  if (String(basisInspection.status || '') !== 'valid') findings.push(finding('error', 'portable.recovery-acceptance.basis-unqualified', 'Recovery acceptance audit requires one independently qualified accepted-basis recipient-facing carrier. A qualified pointerless Workspace package is permitted; Handoff routing is not required for the accepted basis.'));
+  if (String(candidateInspection.status || '') !== 'valid') findings.push(finding('error', 'portable.recovery-acceptance.candidate-unqualified', 'Recovery acceptance audit requires one independently qualified candidate recipient-facing carrier. Candidate restart suitability still requires complete selected Workspace coverage.'));
   if (findings.some((item) => item.severity === 'error')) return auditResult('blocked', [], findings, basisInspection, candidateInspection, input);
 
   const candidateIds = [...new Set((candidateInspection.workspaces || []).map((item) => normalizeId(item.workspaceId)).filter(Boolean))].sort();
@@ -92,7 +92,9 @@ function auditResult(status, workspaces, findings, basisInspection, candidateIns
     status,
     state: status === 'ready' && allReady ? 'acceptance-audit-ready' : 'acceptance-audit-blocked',
     basisQualification: String(basisInspection.status || 'invalid'),
+    basisCarrierRole: String(basisInspection.packageContract?.packageRole || ''),
     candidateQualification: String(candidateInspection.status || 'invalid'),
+    candidateCarrierRole: String(candidateInspection.packageContract?.packageRole || ''),
     selectionMode: (input.workspaceIds || input.selectedWorkspaceIds || []).length ? 'explicit-workspace-set' : 'all-candidate-workspaces',
     workspaces: freeze(workspaces),
     counts: freeze({ workspaces: workspaces.length, readyWorkspaces: workspaces.filter((item) => item.state === 'ready').length, completeWorkspaces: completeWorkspaceCount, unexplainedRemovals: unexplainedRemovalCount }),
@@ -106,7 +108,7 @@ function auditResult(status, workspaces, findings, basisInspection, candidateIns
       semanticAcceptanceGranted: false
     }),
     findings: freeze(findings),
-    boundary: 'Coarse Recovery acceptance audit over already-qualified carrier bytes. It decodes the exact candidate Workspace representations, compares them to one explicit accepted basis, and fails on unexplained source removals or incomplete coverage. It does not inspect a live checkout, prove Git cleanliness/committability, decide semantic correctness, authorize deletion, or grant Master Recovery acceptance; target landing still requires the separate exact source preflight.'
+    boundary: 'Coarse Recovery acceptance audit over already-qualified recipient-facing carrier bytes. The accepted basis may be a routed Handoff carrier or a qualified pointerless Workspace carrier; route authority is not required merely to establish exact basis bytes. It decodes the exact candidate Workspace representations, compares them to one explicit accepted basis, and fails on unexplained source removals or incomplete candidate coverage. It does not inspect a live checkout, prove Git cleanliness/committability, decide semantic correctness, authorize deletion, or grant Master Recovery acceptance; target landing still requires the separate exact source preflight.'
   });
 }
 

package/src/tooling/portable/schema/contract.field-domain.js

@@ -52,12 +52,13 @@ export function validatePortableFieldDomains(input = {}) {
       }));
 
       if (qualification === 'invalid') {
+        const contractGuidance = fieldDomainContractGuidance(results);
         findings.push(fieldDomainFinding(
           'error',
           'portable.contract.field-domain.value.invalid',
-          `Value is outside the allowed field domain for ${bucket.group}.${bucket.field}: ${occurrence.value}.`,
+          invalidFieldDomainMessage(bucket.group, bucket.field, occurrence.value, contractGuidance),
           'structurally-invalid',
-          { group: bucket.group, field: bucket.field, value: occurrence.value, owner: occurrence.owner, contributions: results }
+          { group: bucket.group, field: bucket.field, value: occurrence.value, owner: occurrence.owner, contributions: results, contractGuidance }
         ));
       } else if (qualification === 'extension-candidate') {
         findings.push(fieldDomainFinding(
@@ -242,6 +243,46 @@ function fieldDomainFinding(severity, code, message, state, extra = {}) {
   return portableFinding(severity, code, message, { ...extra, state });
 }
 
+function fieldDomainContractGuidance(results = []) {
+  const contributions = (results || []).map((item) => Object.freeze({
+    sourceSchemaId: String(item.sourceSchemaId || ''),
+    sourceGroup: String(item.sourceGroup || ''),
+    field: String(item.field || ''),
+    allowedValues: Object.freeze([...(item.allowedValues || [])].map(String)),
+    allowedShapes: Object.freeze([...(item.allowedShapes || [])].map(String)),
+    domainPolicy: String(item.domainPolicy || ''),
+    declarationLine: Number(item.declarationLine || 0),
+    contractPath: [
+      String(item.sourceSchemaId || ''),
+      String(item.sourceGroup || ''),
+      'Field Value Constraints',
+      String(item.field || '')
+    ].filter(Boolean).join(' :: ')
+  }));
+  return Object.freeze({
+    contributions: Object.freeze(contributions),
+    nextAction: contributions.length === 1
+      ? `Use one value/shape allowed by ${contributions[0].contractPath || 'the cited field-domain contract'}; do not invent an extension unless the declared domain policy authorizes one.`
+      : 'Satisfy every contributing field-domain authority. Review each exact contractPath below; do not treat values from separate contributions as a union unless the contracts themselves establish that.'
+  });
+}
+
+function invalidFieldDomainMessage(group, field, value, guidance = {}) {
+  const contributions = guidance.contributions || [];
+  if (contributions.length === 1) {
+    const item = contributions[0];
+    const allowed = item.allowedValues || [];
+    const shapes = item.allowedShapes || [];
+    const domain = [
+      allowed.length ? `Allowed values: ${allowed.join(', ')}` : '',
+      shapes.length ? `Allowed shapes: ${shapes.join(', ')}` : ''
+    ].filter(Boolean).join('; ');
+    const path = item.contractPath ? ` Contract: ${item.contractPath}${item.declarationLine ? ` (line ${item.declarationLine})` : ''}.` : '';
+    return `Value is outside the allowed field domain for ${group}.${field}: ${value}.${domain ? ` ${domain}.` : ''}${path}`;
+  }
+  return `Value is outside the allowed field domain for ${group}.${field}: ${value}. Multiple field-domain authorities apply; see contractGuidance for each exact contract path and allowed values/shapes.`;
+}
+
 function exact(value = '') {
   return String(value || '').trim();
 }