@tiinex/core 0.17.0 → 0.19.0

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,9 @@ 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';
+import { projectGroundingImplementationSourceAuthority } from './grounding.implementationSourceAuthority.js';
 
 export const PORTABLE_GROUNDING_CAPSULE_SCHEMA_ID = 'tiinex.portable.grounding-capsule.v1';
 
@@ -12,23 +15,39 @@ 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 implementationSourceAuthority = projectGroundingImplementationSourceAuthority({ authority, records, contextAudit, requiredContext });
+  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 || ''),
       recipientState: String(authority?.role?.state || 'unresolved'),
       holder: String(authority?.holderBinding?.roleLabel || ''),
       holderState: String(authority?.holderBinding?.state || 'unresolved'),
-      compatibility: String(authority?.holderBinding?.recipientCompatibility || 'unresolved')
+      compatibility: String(authority?.holderBinding?.recipientCompatibility || 'unresolved'),
+      authorizationState: String(authority?.holderBinding?.authorization?.state || (String(authority?.holderBinding?.state || '') === 'not-applicable' ? 'not-applicable' : 'unresolved')),
+      authorizationSource: String(authority?.holderBinding?.authorization?.source || ''),
+      durableIdentityState: String(authority?.holderBinding?.durableIdentity?.state || 'not-established')
     }),
     participantAuthority,
+    participantContext,
+    processApplicability,
+    implementationSourceAuthority,
     workProvenance,
-    unresolved: Object.freeze([...workProvenance.unresolved]),
+    unresolved: Object.freeze([
+      ...workProvenance.unresolved,
+      ...participantContext.unresolved,
+      ...processApplicability.unresolved,
+      ...implementationSourceAuthority.unresolved,
+      ...sourceEvidence.blockers.map((item) => ({ code: item.code, detail: item.request }))
+    ]),
     boundary: 'Full Required Context bodies remain selector-gated.'
   });
 }

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

@@ -0,0 +1,81 @@
+import { deepFreeze, normalizeComparable, normalizeToken } from '../handoff/coldStartQualification.shared.js';
+
+export const EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE = 'assignable per explicit session or Handoff';
+export const CURRENT_ROLE_EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE = 'assignable per explicit session, role invocation, or Handoff; no permanent holder asserted';
+export const ANCHOR_EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE = 'assignable per explicit session or Handoff; no permanent holder asserted';
+
+const AUTHORIZED_EXPLICIT_SESSION_OR_HANDOFF_STATES = new Set([
+  normalizeComparable(EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE),
+  normalizeComparable(CURRENT_ROLE_EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE),
+  normalizeComparable(ANCHOR_EXPLICIT_SESSION_OR_HANDOFF_HOLDER_STATE)
+]);
+
+export function projectHolderBindingAuthorization(role = {}) {
+  const endpointKind = normalizeToken(role?.endpoint?.kind || '');
+  if (endpointKind !== 'role') return deepFreeze({
+    state: 'not-applicable',
+    assignmentMode: '',
+    holderState: '',
+    source: 'none',
+    reasonCode: 'recipient-not-role',
+    provenance: {
+      basis: 'recipient-not-role',
+      roleArtifactPath: '',
+      roleArtifactSha256: '',
+      section: 'Holder Relationship',
+      field: 'Holder State',
+      boundary: 'Holder-assignment authorization is only applicable when the selected Handoff recipient is a Role endpoint.'
+    },
+    boundary: 'No Role assignment authorization is required for a non-Role recipient.'
+  });
+
+  const material = role?.material?.artifact || null;
+  const relationship = role?.holderRelationshipLoaded || {};
+  const holderState = String(relationship.holderState || '').trim();
+  const qualifiedMaterial = String(role?.state || '') === 'qualified'
+    && String(role?.material?.state || '') === 'qualified'
+    && Boolean(material?.path)
+    && Boolean(material?.sha256);
+  const provenance = {
+    basis: qualifiedMaterial ? 'exact-qualified-role-holder-relationship' : 'exact-qualified-role-holder-relationship-not-established',
+    roleArtifactPath: String(material?.path || ''),
+    roleArtifactSha256: String(material?.sha256 || ''),
+    roleSchemaId: String(material?.schemaId || ''),
+    roleLabel: String(material?.roleLabel || role?.endpoint?.label || ''),
+    section: 'Holder Relationship',
+    field: 'Holder State',
+    exactValue: holderState,
+    boundary: 'Only exact qualified recipient Role material may authorize the bounded session assignment mode. Handoff endpoints, transport identity, explicit session input, filenames, and package placement do not provide this authority.'
+  };
+
+  if (!qualifiedMaterial) return deepFreeze({
+    state: 'unresolved',
+    assignmentMode: '',
+    holderState,
+    source: 'none',
+    reasonCode: 'qualified-role-holder-authority-not-established',
+    provenance,
+    boundary: 'A matching session Role assertion remains unauthorized until exact qualified Role material establishes the assignment mode.'
+  });
+
+  const assignmentAuthorized = AUTHORIZED_EXPLICIT_SESSION_OR_HANDOFF_STATES.has(normalizeComparable(holderState));
+  if (!assignmentAuthorized) return deepFreeze({
+    state: 'unresolved',
+    assignmentMode: '',
+    holderState,
+    source: 'qualified-recipient-role-material',
+    reasonCode: holderState ? 'holder-assignment-mode-not-authorized' : 'holder-assignment-mode-unresolved',
+    provenance,
+    boundary: 'The exact qualified Role does not establish authorization for explicit-session/Handoff assignment. Core preserves this as unresolved and does not reinterpret other Holder State wording.'
+  });
+
+  return deepFreeze({
+    state: 'qualified',
+    assignmentMode: 'explicit-session-or-handoff',
+    holderState,
+    source: 'qualified-recipient-role-material',
+    reasonCode: 'holder-assignment-mode-authorized',
+    provenance,
+    boundary: 'Exact qualified Role Holder Relationship authorizes this assignment mode for the bounded current session only; it does not establish durable holder identity or broader participant/process/source authority.'
+  });
+}

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

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

package/src/tooling/portable/grounding/grounding.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.participantAuthority.js

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

package/src/tooling/portable/grounding/grounding.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,72 @@
 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 || '',
+      bindingPresent: String(authority.holderBinding.state || '') === 'qualified',
+      declarationPresent: Boolean(authority.holderBinding.explicit),
+      holderId: authority.holderBinding.holderId || '',
+      roleLabel: authority.holderBinding.roleLabel || '',
+      recipientRoleLabel: authority.holderBinding.recipientRoleLabel || '',
+      recipientCompatibility: authority.holderBinding.recipientCompatibility || '',
+      source: authority.holderBinding.source || '',
+      sourceDetail: authority.holderBinding.sourceDetail ? Object.freeze({ ...(authority.holderBinding.sourceDetail || {}) }) : null,
+      authorization: authority.holderBinding.authorization ? Object.freeze({
+        ...(authority.holderBinding.authorization || {}),
+        provenance: authority.holderBinding.authorization.provenance ? Object.freeze({ ...(authority.holderBinding.authorization.provenance || {}) }) : null
+      }) : null,
+      durableIdentity: authority.holderBinding.durableIdentity ? Object.freeze({ ...(authority.holderBinding.durableIdentity || {}) }) : Object.freeze({ state: 'not-established' }),
+      semanticAuthorityState: authority.holderBinding.sourceDetail?.semanticAuthorityState || 'not-established',
+      explicit: Boolean(authority.holderBinding.explicit),
+      inferredFromTransport: Boolean(authority.holderBinding.inferredFromTransport),
+      provenance: Object.freeze({
+        basis: authority.holderBinding.explicit ? 'explicit-consuming-session-holder-binding' : 'unresolved-or-non-explicit-holder-binding',
+        source: authority.holderBinding.source || '',
+        sourceKind: authority.holderBinding.sourceDetail?.kind || '',
+        sourceLocator: authority.holderBinding.sourceDetail?.locator || '',
+        semanticAuthorityState: authority.holderBinding.sourceDetail?.semanticAuthorityState || 'not-established',
+        qualifiedMaterialSource: Boolean(authority.holderBinding.sourceDetail?.qualifiedMaterialSource),
+        authorizationState: authority.holderBinding.authorization?.state || 'unresolved',
+        authorizationBasis: authority.holderBinding.authorization?.provenance?.basis || '',
+        boundary: authority.holderBinding.boundary || 'Consuming-session holder identity is never inferred from route transport or recipient position.'
+      }),
+      boundary: authority.holderBinding.boundary || ''
+    }) : null,
     operationBoundary: mutationBoundary ? Object.freeze({
       ...mutationBoundary,
       scope: 'current-grounding-operation-only',