@tiinex/core 0.18.0 → 0.20.0

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

@@ -3,6 +3,7 @@ import { inspectRecipientFacingV2Topology } from '../../handoff/recipientV2.insp
 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';
+import { inspectStoredWorkspaceArchive } from '../../handoff/workspaceByteProvider.js';
 
 export function preparePackageParentWorkspaceReuse(input = {}) {
   const bundle = input.bundle || null;
@@ -77,6 +78,128 @@ export function preparePackageParentWorkspaceReuse(input = {}) {
   });
 }
 
+
+
+export function preparePackageParentExactMaterialProvider(input = {}) {
+  const bundle = input.bundle || null;
+  const currentIds = new Set([...(input.currentWorkspaceIds || [])].map(normalizeId).filter(Boolean));
+  if (!bundle?.files?.length) return emptyExactMaterialProvider('unavailable');
+  const inspection = inspectRecipientFacingV2Topology(bundle);
+  const claims = [];
+  for (const cache of inspection.caches || []) {
+    const archivePath = String(cache.archivePath || '').trim();
+    const matches = (bundle.files || []).filter((file) => String(file.path || '') === archivePath);
+    let archive = null;
+    if (matches.length === 1) {
+      try { archive = inspectStoredWorkspaceArchive(packageFileBytes(matches[0]), { ownedBytes: true }); } catch { archive = null; }
+    }
+    const byPath = new Map((archive?.entries || []).map((entry) => [String(entry.path || ''), entry]));
+    for (const material of cache.materials || []) {
+      const referenceTarget = String(material.referenceTarget || '').trim();
+      if (!referenceTarget) continue;
+      const parsed = parseWorkspaceQualifiedReference(referenceTarget);
+      if (parsed && currentIds.has(normalizeId(parsed.workspaceId))) continue;
+      const entry = byPath.get(String(material.archiveEntry || '')) || null;
+      const declaredSha = String(material.sha256 || '').trim();
+      const declaredBytes = Number(material.bytes || 0);
+      const entrySha = entry ? String(entry.sha256 || sha256Hex(entry.data || new Uint8Array())) : '';
+      const entryBytes = entry ? Number(entry.bytes || packageFileBytes({ data: entry.data }).byteLength) : 0;
+      const qualified = inspection.status === 'valid' && archive?.state === 'qualified' && Boolean(entry)
+        && (!declaredSha || declaredSha === entrySha) && (!declaredBytes || declaredBytes === entryBytes);
+      claims.push(Object.freeze({
+        referenceTarget,
+        state: qualified ? 'available-qualified' : 'present-unqualified',
+        reason: qualified ? '' : inspection.status !== 'valid' ? 'parent-carrier-inspection-invalid' : archive?.state !== 'qualified' ? 'cache-archive-unqualified' : !entry ? 'cache-entry-unresolved' : 'cache-entry-identity-mismatch',
+        classification: String(material.classification || ''),
+        sourceRequirementId: String(material.requirementId || material.sourceRequirementId || ''),
+        workspaceId: String(cache.workspaceId || ''),
+        cacheArtifactPath: String(cache.artifactPath || ''),
+        cacheArchivePath: archivePath,
+        archiveEntry: String(material.archiveEntry || ''),
+        targetWorkspaceId: String(material.targetWorkspaceId || parsed?.workspaceId || ''),
+        targetPath: String(material.targetPath || material.originalPath || parsed?.path || ''),
+        bytes: entryBytes, sha256: entrySha, data: entry?.data || null
+      }));
+    }
+  }
+  const byTarget = new Map();
+  for (const claim of claims) {
+    const list = byTarget.get(claim.referenceTarget) || [];
+    list.push(claim); byTarget.set(claim.referenceTarget, list);
+  }
+  const entries = [];
+  for (const [referenceTarget, targetClaims] of byTarget.entries()) {
+    const qualified = targetClaims.filter((item) => item.state === 'available-qualified');
+    const digests = [...new Set(qualified.map((item) => item.sha256).filter(Boolean))];
+    if (digests.length !== 1) continue;
+    const same = qualified.filter((item) => item.sha256 === digests[0]);
+    if (!same.length) continue;
+    const first = same[0];
+    entries.push(Object.freeze({
+      referenceTarget, data: first.data, bytes: first.bytes, sha256: first.sha256,
+      providerId: 'qualified-package-parent-exact-material',
+      providerKind: 'qualified-package-parent-cache-material',
+      provenance: Object.freeze({
+        parentPackagePath: String(input.parentPackagePath || ''), parentPackageSha256: String(input.parentPackageSha256 || ''),
+        providerMode: 'qualified-package-parent-cache', cacheArtifactPath: first.cacheArtifactPath, cacheArchivePath: first.cacheArchivePath,
+        archiveEntry: first.archiveEntry, sourceRequirementIds: Object.freeze([...new Set(same.map((item) => item.sourceRequirementId).filter(Boolean))].sort()),
+        referenceTarget, workspaceId: first.targetWorkspaceId || first.workspaceId, path: first.targetPath, authority: 'none'
+      })
+    }));
+  }
+  return Object.freeze({
+    state: inspection.status === 'valid' ? 'qualified' : 'present-unqualified', inspectionStatus: String(inspection.status || ''),
+    entries: Object.freeze(entries), claims: Object.freeze(claims),
+    boundary: 'Exact material already present in a received qualified package cache may satisfy a newly authored return requirement only after exact declared-target and byte-identity qualification. Reuse is mechanical byte closure only: it does not select Workspace source, create semantic authority, infer delegation, or authorize repository discovery.'
+  });
+}
+
+export function resolvePackageParentRequirementMaterials(requirements = {}, provider = {}) {
+  const out = [];
+  const byTarget = new Map((provider.entries || []).map((entry) => [String(entry.referenceTarget || ''), entry]));
+  for (const requirement of allBlockingRequirements(requirements)) {
+    const target = String(requirement.reference?.target || requirement.materialReference || '').trim();
+    if (!target) continue;
+    const entry = byTarget.get(target);
+    if (!entry) continue;
+    out.push(Object.freeze({
+      requirementId: String(requirement.id || ''), referenceTarget: target, path: String(entry.provenance?.path || ''),
+      data: entry.data, bytes: Number(entry.bytes || 0), sha256: String(entry.sha256 || ''),
+      providerId: String(entry.providerId || ''), providerKind: String(entry.providerKind || ''),
+      provenance: Object.freeze({ ...(entry.provenance || {}), reboundRequirementId: String(requirement.id || ''), reboundClassification: String(requirement.classification || '') }),
+      authority: Object.freeze({ packageParentMaterialQualified: true, semanticAuthority: 'none', sourceSelectionAuthority: false })
+    }));
+  }
+  return Object.freeze(out);
+}
+
+export function projectPackageParentMaterialClosurePreflight(requirements = {}, provider = {}) {
+  const claimsByTarget = new Map();
+  for (const claim of provider.claims || []) { const list = claimsByTarget.get(String(claim.referenceTarget || '')) || []; list.push(claim); claimsByTarget.set(String(claim.referenceTarget || ''), list); }
+  const entryTargets = new Set((provider.entries || []).map((item) => String(item.referenceTarget || '')));
+  const projected = [];
+  for (const requirement of allBlockingRequirements(requirements)) {
+    const target = String(requirement.reference?.target || requirement.materialReference || '').trim();
+    if (!target) continue;
+    const claims = claimsByTarget.get(target) || [];
+    const state = entryTargets.has(target) ? 'available-qualified' : claims.length ? 'present-unqualified' : 'absent';
+    projected.push(Object.freeze({
+      requirementId: String(requirement.id || ''), classification: normalizeRequirementClass(requirement.classification), referenceTarget: target, state,
+      provenance: Object.freeze(claims.map((claim) => Object.freeze({ cacheArchivePath: claim.cacheArchivePath, archiveEntry: claim.archiveEntry, sha256: claim.sha256, reason: claim.reason }))),
+      nextAction: state === 'available-qualified' ? 'No action required; exact parent-carrier bytes are mechanically available.' : `Supply exact qualified material for ${target} through an explicit local binding, qualified Workspace provider, or qualified received-package cache surface. Tooling will not scan repositories or infer a source.`
+    }));
+  }
+  const blockers = projected.filter((item) => item.state !== 'available-qualified');
+  return Object.freeze({
+    state: blockers.length ? 'action-required' : 'ready', requirements: Object.freeze(projected), blockerCount: blockers.length,
+    boundary: 'This preflight classifies exact return-material closure only. Qualified received-package bytes may close declared material requirements, but this does not create semantic authority, select a Workspace source, establish process applicability, or authorize repository/network discovery.'
+  });
+}
+
+function allBlockingRequirements(requirements = {}) { return [...(requirements.required || []), ...(requirements.endpointRoles || []), ...(requirements.participantRoles || []), ...(requirements.dependencies || [])]; }
+function normalizeRequirementClass(value = '') { const v = String(value || ''); return v === 'endpoint-role' || v === 'participant-role' ? v : v || 'required'; }
+function emptyExactMaterialProvider(state = 'unavailable') { return Object.freeze({ state, inspectionStatus: '', entries: Object.freeze([]), claims: Object.freeze([]), boundary: 'No qualified received-package exact material provider is available; Tooling will not infer one.' }); }
+
 export function projectRequiredContextWorkspaceSelectionPreflight(input = {}) {
   const reuse = input.packageParentReuse || input.reuse || {};
   const currentWorkspaceIds = new Set([...(input.currentWorkspaceIds || [])].map(normalizeId).filter(Boolean));

package/src/tooling/portable/audit/audit.capability.js

@@ -8,15 +8,21 @@ export const PORTABLE_SHARED_AUDIT_CAPABILITY_SCHEMA_ID = 'tiinex.portable.share
 export function auditPortableRecord(record = {}, options = {}) {
   const schemaId = String(record.schemaId || record.currentSchemaId || '');
   const requireExactSchemaAuthority = options.requireExactSchemaAuthority === true;
-  const runtimeAuthority = requireExactSchemaAuthority ? portableRuntimeValidationAuthorityForRecord(record) : null;
-  const runtimeProjection = requireExactSchemaAuthority ? runtimeAuthority : portableRuntimeValidationContractForSchema(schemaId);
+  const explicitSchemaValidationAuthority = options.schemaValidationAuthority || null;
+  const runtimeAuthority = explicitSchemaValidationAuthority || (requireExactSchemaAuthority ? portableRuntimeValidationAuthorityForRecord(record) : null);
+  const runtimeProjection = explicitSchemaValidationAuthority
+    ? (explicitSchemaValidationAuthority.state === 'qualified' ? explicitSchemaValidationAuthority : null)
+    : requireExactSchemaAuthority
+      ? runtimeAuthority
+      : portableRuntimeValidationContractForSchema(schemaId);
   let result;
   try {
     result = runAudit({
       record,
       markdown: record.markdown,
-      validationContractOverride: runtimeProjection?.state === 'qualified' ? runtimeProjection.compiledContract : null,
-      schemaValidationAuthority: requireExactSchemaAuthority ? runtimeAuthority : null,
+      validationContractOverride: options.validationContractOverride || (runtimeProjection?.state === 'qualified' ? runtimeProjection.compiledContract : null),
+      schemaValidationAuthority: explicitSchemaValidationAuthority || (requireExactSchemaAuthority ? runtimeAuthority : null),
+      schemaReferenceAuthorities: options.schemaReferenceAuthorities || null,
       schemaReferenceContext: options.schemaReferenceContext || 'historical'
     });
   } catch (error) {

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

@@ -4,6 +4,9 @@ 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';
+import { projectGroundingDelegationReadiness } from './grounding.delegationReadiness.js';
+import { projectGroundingDelegationArtifactAuthority } from './grounding.delegationArtifactAuthority.js';
 
 export const PORTABLE_GROUNDING_CAPSULE_SCHEMA_ID = 'tiinex.portable.grounding-capsule.v1';
 
@@ -15,8 +18,12 @@ export function projectGroundingCapsule({ authority = null, continuation = null,
   const workProvenance = projectWorkProvenance({ records, topology });
   const participantAuthority = projectParticipantAuthority(authority);
   const participantContext = projectGroundingParticipantContext(authority);
-  const processApplicability = projectGroundingProcessApplicability(authority);
   const sourceEvidence = projectGroundingSourceEvidence({ records, contextAudit, continuation, requiredContext });
+  const delegationArtifactAuthority = projectGroundingDelegationArtifactAuthority({ authority, records, topology, sourceEvidence });
+  const effectiveAuthority = mergeArtifactDelegationAuthority(authority, delegationArtifactAuthority);
+  const processApplicability = projectGroundingProcessApplicability(effectiveAuthority);
+  const implementationSourceAuthority = projectGroundingImplementationSourceAuthority({ authority: effectiveAuthority, records, contextAudit, requiredContext });
+  const delegationReadiness = projectGroundingDelegationReadiness({ authority: effectiveAuthority, processApplicability, implementationSourceAuthority });
   return Object.freeze({
     schema: PORTABLE_GROUNDING_CAPSULE_SCHEMA_ID,
     semanticReductions: Object.freeze(requiredContext.slice(0, MAX_CONTEXT).map(reduceRequiredContext)),
@@ -29,22 +36,46 @@ export function projectGroundingCapsule({ authority = null, continuation = null,
       recipientState: String(authority?.role?.state || 'unresolved'),
       holder: String(authority?.holderBinding?.roleLabel || ''),
       holderState: String(authority?.holderBinding?.state || 'unresolved'),
-      compatibility: String(authority?.holderBinding?.recipientCompatibility || 'unresolved')
+      compatibility: String(authority?.holderBinding?.recipientCompatibility || 'unresolved'),
+      authorizationState: String(authority?.holderBinding?.authorization?.state || (String(authority?.holderBinding?.state || '') === 'not-applicable' ? 'not-applicable' : 'unresolved')),
+      authorizationSource: String(authority?.holderBinding?.authorization?.source || ''),
+      assertionMode: String(authority?.holderBinding?.assertionMode || authority?.holderBinding?.authorization?.assignmentMode || ''),
+      authorizedModes: Object.freeze([...(authority?.holderBinding?.authorization?.authorizedModes || [])]),
+      authorizationBasis: String(authority?.holderBinding?.authorization?.modeAuthority?.provenance?.basis || authority?.holderBinding?.authorization?.provenance?.basis || ''),
+      durableIdentityState: String(authority?.holderBinding?.durableIdentity?.state || 'not-established')
     }),
     participantAuthority,
     participantContext,
     processApplicability,
+    implementationSourceAuthority,
+    delegationArtifactAuthority,
+    delegationReadiness,
     workProvenance,
     unresolved: Object.freeze([
       ...workProvenance.unresolved,
       ...participantContext.unresolved,
       ...processApplicability.unresolved,
+      ...implementationSourceAuthority.unresolved,
+      ...delegationReadiness.blockers.map((item) => ({ code: item.code, detail: item.request })),
       ...sourceEvidence.blockers.map((item) => ({ code: item.code, detail: item.request }))
     ]),
     boundary: 'Full Required Context bodies remain selector-gated.'
   });
 }
 
+function mergeArtifactDelegationAuthority(authority = null, artifact = null) {
+  if (!artifact || typeof artifact !== 'object') return authority || {};
+  const base = authority && typeof authority === 'object' ? authority : {};
+  return Object.freeze({
+    ...base,
+    delegateCapabilityAuthority: base.delegateCapabilityAuthority || artifact.delegateCapabilityAuthority,
+    processApplicability: base.processApplicability || artifact.processApplicability,
+    delegationTargetAuthority: base.delegationTargetAuthority || artifact.delegationTargetAuthority,
+    implementationSourceAuthority: base.implementationSourceAuthority || artifact.implementationSourceAuthority,
+    delegationReturnReconciliationExpectation: base.delegationReturnReconciliationExpectation || artifact.delegationReturnReconciliationExpectation
+  });
+}
+
 function reduceRequiredContext(entry = {}) {
   const qualified = String(entry.state || '') === 'qualified';
   const markdown = qualified && typeof entry.content === 'string' ? entry.content : '';

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

@@ -0,0 +1,220 @@
+import { posix } from 'node:path';
+import { sha256Hex } from '../../../export/package.bytes.js';
+
+export function projectGroundingDelegationArtifactAuthority({ authority = null, records = [], topology = {}, sourceEvidence = null } = {}) {
+  const unresolved = [];
+  const handoff = authority?.handoff || null;
+  const recipientRole = authority?.role || null;
+  const senderRole = authority?.senderRole || null;
+  if (!handoff || String(handoff.schemaId || '') !== 'tiinex.handoff.v1') return empty('selected-qualified-handoff-not-established');
+
+  const transferSelection = selectControllingTransfer(handoff, records, topology);
+  if (!transferSelection) unresolved.push('forward-controlling-transfer-not-established');
+  const recipient = qualifiedRole(recipientRole, handoff.toReference || '');
+  if (!recipient) unresolved.push('exact-recipient-role-authority-not-established');
+  const sender = qualifiedRole(senderRole, handoff.fromReference || '');
+  if (!sender) unresolved.push('exact-sender-role-authority-not-established');
+
+  const taskRecord = transferSelection?.record || null;
+  const targetWorkspaceId = String(taskRecord?.path || '').split('/')[0] || '';
+  const workspaceSource = (sourceEvidence?.workspaces || []).find((item) => String(item.workspace || '') === targetWorkspaceId && ['qualified', 'explicit-profile'].includes(String(item.state || ''))) || null;
+  if (!workspaceSource?.repository) unresolved.push('exact-target-repository-authority-not-established');
+
+  const delegateCapabilityAuthority = recipient && transferSelection ? delegateProjection(recipient, handoff, transferSelection) : null;
+  if (!delegateCapabilityAuthority) unresolved.push('delegate-capability-artifact-projection-not-established');
+
+  const processApplicability = sender && transferSelection ? processProjection(sender, handoff, transferSelection) : null;
+  if (!processApplicability) unresolved.push('delegation-applicability-artifact-projection-not-established');
+
+  const delegationTargetAuthority = taskRecord && workspaceSource && transferSelection
+    ? targetProjection(taskRecord, workspaceSource, handoff, transferSelection)
+    : null;
+  if (!delegationTargetAuthority) unresolved.push('delegation-target-artifact-projection-not-established');
+
+  const implementationSourceAuthority = taskRecord && recipient && transferSelection
+    ? sourceProjection(taskRecord, recipient, handoff, transferSelection)
+    : null;
+  if (!implementationSourceAuthority) unresolved.push('implementation-source-artifact-projection-not-established');
+
+  const delegationReturnReconciliationExpectation = transferSelection
+    ? returnProjection(handoff, transferSelection)
+    : null;
+  if (!delegationReturnReconciliationExpectation) unresolved.push('return-reconciliation-artifact-projection-not-established');
+
+  const ready = Boolean(delegateCapabilityAuthority && processApplicability && delegationTargetAuthority && implementationSourceAuthority && delegationReturnReconciliationExpectation);
+  return Object.freeze({
+    state: ready ? 'qualified-forward-artifact-closure' : 'not-established',
+    delegateCapabilityAuthority,
+    processApplicability,
+    delegationTargetAuthority,
+    implementationSourceAuthority,
+    delegationReturnReconciliationExpectation,
+    unresolved: Object.freeze([...new Set(unresolved)].map((code) => Object.freeze({ code }))),
+    provenance: Object.freeze({
+      basis: 'exact-qualified-forward-selected-artifact-chain',
+      selectedHandoff: sourceArtifactFromHandoff(handoff),
+      controllingTask: taskRecord ? sourceArtifactFromRecord(taskRecord) : null,
+      senderRole: sender ? sender.sourceArtifact : null,
+      recipientRole: recipient ? recipient.sourceArtifact : null,
+      boundary: 'Projection only. Exact Handoff transfer, exact endpoint Role authority, exact controlling Task and exact Workspace source identity are composed mechanically; Role/cache inventory, filenames, adjacency and arbitrary prose are never searched for delegation meaning.'
+    }),
+    boundary: 'Artifact-derived delegation closure is available only from the exact selected forward chain. It does not select a delegate, invent a process, create source permission, or treat an endpoint alone as delegation authority.'
+  });
+}
+
+function selectControllingTransfer(handoff, records, topology) {
+  const handoffPath = qualifiedHandoffPath(handoff);
+  const frontierPaths = new Set((topology?.currentFrontier || []).flatMap((item) => [String(item.path || ''), String(item.resolvedPath || '')]).filter(Boolean));
+  const candidates = [];
+  for (const transfer of handoff.transfers || []) {
+    const target = String(transfer.controllingArtifactTarget || '').trim();
+    if (!target) continue;
+    const resolved = resolveReference(target, handoffPath);
+    if (!resolved) continue;
+    const matches = (records || []).filter((record) => String(record.path || '') === resolved && String(record.schemaId || '') === 'tiinex.task.v1' && record.hasContinuityContext && record.hasIntegrity);
+    if (matches.length !== 1) continue;
+    if (frontierPaths.size && !frontierPaths.has(resolved) && !frontierPaths.has(String(matches[0].id || ''))) continue;
+    candidates.push(Object.freeze({ transfer, record: matches[0], resolvedPath: resolved }));
+  }
+  return candidates.length === 1 ? candidates[0] : null;
+}
+
+function qualifiedRole(role, declaredReference = '') {
+  const artifact = role?.material?.artifact || null;
+  if (String(role?.state || '') !== 'qualified' || String(role?.material?.state || '') !== 'qualified' || !artifact) return null;
+  const sha256 = String(artifact.sha256 || '').trim().toLowerCase();
+  if (!/^[0-9a-f]{64}$/i.test(sha256)) return null;
+  const reference = String(artifact.reference || declaredReference || '').trim();
+  if (!reference) return null;
+  return Object.freeze({
+    label: String(role?.endpoint?.label || artifact.roleLabel || ''),
+    kind: String(role?.endpoint?.kind || 'role'),
+    roleKind: String(artifact.roleKind || ''),
+    boundary: Object.freeze({ ...(role.exactBoundaryLoaded || {}) }),
+    authority: Object.freeze({ ...(role.authorityBoundaryLoaded || {}) }),
+    sourceArtifact: sourceArtifactFromReference(reference, sha256, String(artifact.schemaId || 'tiinex.party.role.v1'))
+  });
+}
+
+function delegateProjection(role, handoff, selected) {
+  const capabilities = [
+    role.roleKind ? Object.freeze({ kind: 'role-kind', value: role.roleKind }) : null,
+    role.boundary.inScope ? Object.freeze({ kind: 'role-in-scope', value: role.boundary.inScope }) : null,
+    role.authority.mayDo ? Object.freeze({ kind: 'role-may-do', value: role.authority.mayDo }) : null
+  ].filter(Boolean);
+  if (!role.label || !capabilities.length) return null;
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    delegate: Object.freeze({ label: role.label, kind: role.kind || 'role' }),
+    capabilities: Object.freeze(capabilities),
+    selection: Object.freeze({ state: 'explicit-forward-selected', forwardSelected: true }),
+    sourceArtifact: role.sourceArtifact,
+    facts: Object.freeze([
+      Object.freeze({ kind: 'selected-handoff-transfer', handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || ''), transferKind: String(selected.transfer.transferKind || ''), controllingArtifact: selected.resolvedPath }),
+      Object.freeze({ kind: 'exact-recipient-role-authority', role: role.label, roleKind: role.roleKind })
+    ]),
+    provenance: Object.freeze({ source: role.sourceArtifact.path, basis: 'selected-handoff-transfer-to-exact-recipient-role-and-controlling-task', forwardSelector: Object.freeze({ handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || ''), controllingArtifact: selected.resolvedPath }) })
+  });
+}
+
+function processProjection(role, handoff, selected) {
+  const facts = [
+    role.authority.delegation ? Object.freeze({ kind: 'sender-role-delegation', value: role.authority.delegation }) : null,
+    role.authority.requiredInstrument ? Object.freeze({ kind: 'sender-role-required-instrument', value: role.authority.requiredInstrument }) : null,
+    role.authority.mayDo ? Object.freeze({ kind: 'sender-role-may-do', value: role.authority.mayDo }) : null,
+    Object.freeze({ kind: 'selected-handoff-work-transfer', transferId: String(selected.transfer.id || ''), transferKind: String(selected.transfer.transferKind || ''), controllingArtifact: selected.resolvedPath })
+  ].filter(Boolean);
+  if (facts.length < 2) return null;
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    facts: Object.freeze(facts),
+    source: role.sourceArtifact.path,
+    provenance: Object.freeze({ source: role.sourceArtifact.path, sourceArtifact: role.sourceArtifact, basis: 'exact-sender-role-authority-plus-selected-handoff-work-transfer', forwardSelector: Object.freeze({ handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || '') }) })
+  });
+}
+
+function targetProjection(taskRecord, workspaceSource, handoff, selected) {
+  const workspaceId = String(taskRecord.path || '').split('/')[0];
+  const relativeTask = String(taskRecord.path || '').slice(workspaceId.length + 1);
+  const relativeHandoff = String(handoff.workspaceRelativePath || '').replace(/^\/+/, '');
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    target: Object.freeze({
+      workspaceId,
+      repository: String(workspaceSource.repository || ''),
+      rootPath: String(workspaceSource.rootPath || ''),
+      taskDirectory: posix.dirname(relativeTask),
+      handoffDirectory: posix.dirname(relativeHandoff)
+    }),
+    sourceArtifact: sourceArtifactFromRecord(taskRecord),
+    facts: Object.freeze([
+      Object.freeze({ kind: 'controlling-task-placement', path: String(taskRecord.path || '') }),
+      Object.freeze({ kind: 'workspace-source-identity', workspaceId, repository: String(workspaceSource.repository || ''), rootPath: String(workspaceSource.rootPath || '') })
+    ]),
+    provenance: Object.freeze({ source: String(taskRecord.path || ''), basis: 'exact-controlling-task-plus-qualified-workspace-source-identity', forwardSelector: Object.freeze({ handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || '') }) })
+  });
+}
+
+function sourceProjection(taskRecord, role, handoff, selected) {
+  const scope = section(taskRecord.markdown || '', 'Scope');
+  const facts = [
+    scope ? Object.freeze({ kind: 'controlling-task-scope', value: scope }) : null,
+    role.authority.mayDo ? Object.freeze({ kind: 'recipient-role-may-do', value: role.authority.mayDo }) : null,
+    role.authority.requiredInstrument ? Object.freeze({ kind: 'recipient-role-required-instrument', value: role.authority.requiredInstrument }) : null,
+    Object.freeze({ kind: 'selected-handoff-work-transfer', transferId: String(selected.transfer.id || ''), transferKind: String(selected.transfer.transferKind || ''), controllingArtifact: selected.resolvedPath })
+  ].filter(Boolean);
+  if (!scope || !role.authority.mayDo) return null;
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    sourceArtifact: sourceArtifactFromRecord(taskRecord),
+    facts: Object.freeze(facts),
+    provenance: Object.freeze({ source: String(taskRecord.path || ''), basis: 'exact-controlling-task-scope-plus-recipient-role-authority-plus-selected-transfer', forwardSelector: Object.freeze({ handoff: qualifiedHandoffPath(handoff), transferId: String(selected.transfer.id || '') }), recipientRoleSourceArtifact: role.sourceArtifact })
+  });
+}
+
+function returnProjection(handoff, selected) {
+  const completion = handoff.completionExpectation || {};
+  const returnTo = String(completion.returnTo || '').trim();
+  const retained = (handoff.retainedResponsibilities || []).filter((item) => normalize(item.retainedBy) === normalize(returnTo));
+  if (!completion.signalKind || !completion.signalMeaning || !returnTo || retained.length !== 1) return null;
+  return Object.freeze({
+    explicit: true,
+    qualification: 'qualified',
+    completionExpectation: Object.freeze({ signalKind: String(completion.signalKind), signalMeaning: String(completion.signalMeaning), returnTo }),
+    reconciliation: Object.freeze({ state: 'retained-by-return-target', expectation: String(retained[0].responsibility || '') }),
+    sourceArtifact: sourceArtifactFromHandoff(handoff),
+    facts: Object.freeze([
+      Object.freeze({ kind: 'selected-handoff-completion-expectation', signalKind: String(completion.signalKind), returnTo }),
+      Object.freeze({ kind: 'return-target-retained-responsibility', id: String(retained[0].id || ''), retainedBy: returnTo, responsibility: String(retained[0].responsibility || '') })
+    ]),
+    provenance: Object.freeze({ source: qualifiedHandoffPath(handoff), basis: 'exact-selected-handoff-completion-plus-return-target-retained-responsibility', forwardSelector: Object.freeze({ transferId: String(selected.transfer.id || ''), controllingArtifact: selected.resolvedPath }) })
+  });
+}
+
+function sourceArtifactFromRecord(record) {
+  return Object.freeze({ workspaceId: String(record.path || '').split('/')[0] || '', path: String(record.path || ''), sha256: sha256(record.markdown || ''), schemaId: String(record.schemaId || '') });
+}
+function sourceArtifactFromHandoff(handoff) {
+  return Object.freeze({ workspaceId: String(handoff.workspaceId || ''), path: qualifiedHandoffPath(handoff), sha256: String(handoff.sha256 || '').trim().toLowerCase(), schemaId: String(handoff.schemaId || 'tiinex.handoff.v1') });
+}
+function sourceArtifactFromReference(reference, sha, schemaId) {
+  const raw = String(reference || '').trim();
+  const cross = raw.match(/^([^:/\\]+)::(.+)$/);
+  return Object.freeze({ workspaceId: cross ? cross[1] : '', path: raw, sha256: String(sha || '').toLowerCase(), schemaId: String(schemaId || '') });
+}
+function qualifiedHandoffPath(handoff) { return [String(handoff.workspaceId || ''), String(handoff.workspaceRelativePath || '').replace(/^\/+/, '')].filter(Boolean).join('/'); }
+function resolveReference(reference, ownerPath) {
+  const raw = String(reference || '').split('#')[0].trim().replace(/\\/g, '/');
+  const cross = raw.match(/^([^:/\\]+)::(.+)$/);
+  const candidate = cross ? `${cross[1]}/${cross[2].replace(/^\/+/, '')}` : raw.startsWith('/') ? raw.slice(1) : posix.join(posix.dirname(ownerPath), raw);
+  const normalized = posix.normalize(candidate).replace(/^\.\//, '');
+  return !normalized || normalized === '..' || normalized.startsWith('../') ? '' : normalized;
+}
+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 sha256(markdown) { return sha256Hex(new TextEncoder().encode(String(markdown || ''))); }
+function normalize(value) { return String(value || '').trim().toLowerCase(); }
+function empty(code) { return Object.freeze({ state: 'not-established', delegateCapabilityAuthority: null, processApplicability: null, delegationTargetAuthority: null, implementationSourceAuthority: null, delegationReturnReconciliationExpectation: null, unresolved: Object.freeze([Object.freeze({ code })]), provenance: null, boundary: 'No exact selected qualified Handoff authority was available for artifact-derived delegation projection.' }); }