@tiinex/core 0.19.0 → 0.21.0

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

@@ -11,6 +11,8 @@ import { runPortableOperation } from '../../operation.catalog.js';
 import { markPortableBootstrapCanonicalSource } from '../../providers/schema.bootstrap.provenance.js';
 import { allocateContinuationPath, allocateDirectoryArtifactPath } from '../../../../transitions/record.transitions.js';
 import { classifyParentRecoveryReference } from '../../../../lineage/parentRecoveryReference.js';
+import { creationSchemaReferenceValidationContext } from '../../draft/draft.validation-context.js';
+import { isQualifiedIdentifierOnlyHistoricalSchemaReferenceAuthority, qualifiedIdentifierOnlyHistoricalSchemaReferenceAuthority } from '../../../../schemas/schema.reference.js';
 
 const STATE_RELATIVE_PATH = '.tiinex/continuation.json';
 
@@ -66,16 +68,21 @@ export async function runCommonAuthorCli(parsed = {}, runtime = {}) {
     await writeFile(artifactPath, markdown, { encoding: 'utf8', flag: flags.overwrite ? 'w' : 'wx' });
     wrote = true;
     const auditMaterial = await loadNodePortableInput(
-      [artifactPath, ...(parentPath ? [parentPath] : [])],
+      [artifactPath],
       { maxFiles: flags['max-files'], maxTextBytes: flags['max-text-bytes'] }
     );
-    const audit = await runPortableOperation('audit', auditMaterial, {});
+    const candidateAudit = await runPortableOperation('audit', auditMaterial, {});
+    const parentAudit = parentPath
+      ? await runHistoricalParentAudit(parentPath, parentRecord, contract, flags)
+      : null;
+    const audit = mergeAuthorAuditResults(candidateAudit, parentAudit);
     const stageMaterial = await loadNodePortableInput(
       normalizeRuntimePaths(runtime.defaultSchemaMaterialPaths),
       { maxFiles: flags['max-files'], maxTextBytes: flags['max-text-bytes'] }
     );
     const stage = await runPortableOperation('stage-draft', {
       ...stageMaterial,
+      schemaReferenceAuthorities: creationSchemaReferenceValidationContext(contract, parentRecord),
       draft: { path: artifactRelativePath, markdown, schemaId, sourceMode: 'local-common-author', source: null }
     }, {});
     const blocking = Number(audit?.findingSummary?.counts?.error || 0) + Number(stage?.findingSummary?.counts?.error || 0);
@@ -87,7 +94,7 @@ export async function runCommonAuthorCli(parsed = {}, runtime = {}) {
         schema: 'tiinex.portable.common-author.result.v1',
         operation: 'author',
         status: 'blocked',
-        artifact: Object.freeze({ path: artifactRelativePath, schemaId, written: false }),
+        artifact: Object.freeze({ path: artifactRelativePath, schemaId, written: false, parentPath: parentReference, parentSource: parentSource || '', parentSchemaReferenceAuthority: projectHistoricalParentReferenceAuthority(parentRecord) }),
         audit,
         stage,
         findingSummary: mergeFindingSummaries(audit?.findingSummary, stage?.findingSummary),
@@ -105,7 +112,7 @@ export async function runCommonAuthorCli(parsed = {}, runtime = {}) {
       schema: 'tiinex.portable.common-author.result.v1',
       operation: 'author',
       status: 'qualified',
-      artifact: Object.freeze({ path: artifactRelativePath, absolutePath: artifactPath, schemaId, parentPath: parentReference, parentSource: parentSource || '', selfIntegrity: selfIntegrity.state, written: true }),
+      artifact: Object.freeze({ path: artifactRelativePath, absolutePath: artifactPath, schemaId, parentPath: parentReference, parentSource: parentSource || '', parentSchemaReferenceAuthority: projectHistoricalParentReferenceAuthority(parentRecord), selfIntegrity: selfIntegrity.state, written: true }),
       qualification: Object.freeze({ audit: audit.status, stage: stage.status, exportReady: Boolean(stage?.stagedArtifact?.qualification?.exportReady) }),
       findingSummary: mergeFindingSummaries(audit?.findingSummary, stage?.findingSummary),
       nextAction: schemaId === 'tiinex.handoff.v1'
@@ -120,6 +127,88 @@ export async function runCommonAuthorCli(parsed = {}, runtime = {}) {
   }
 }
 
+async function runHistoricalParentAudit(parentPath, parentRecord = {}, contract = {}, flags = {}) {
+  const material = await loadNodePortableInput(
+    [parentPath],
+    { maxFiles: flags['max-files'], maxTextBytes: flags['max-text-bytes'] }
+  );
+  const exactCurrentMatch = sameExactSchemaReferenceAuthority(
+    parentRecord.schemaReferenceAuthority || null,
+    contract?.schemaReferences?.current || null,
+    parentRecord.schemaId || parentRecord.currentSchemaId || ''
+  );
+  return runPortableOperation('audit', material, {
+    schemaReferenceContext: 'historical',
+    schemaReferenceAuthorities: Object.freeze({ current: parentRecord.schemaReferenceAuthority || null }),
+    ...(exactCurrentMatch ? {} : {
+      schemaValidationAuthority: historicalParentSchemaValidationAuthority(parentRecord)
+    })
+  });
+}
+
+export function sameExactSchemaReferenceAuthority(parentAuthority = null, currentAuthority = null, schemaId = '') {
+  if (!parentAuthority || !currentAuthority) return false;
+  const expectedSchemaId = String(schemaId || '').trim();
+  const parentSchemaId = String(parentAuthority.schemaId || '').trim();
+  const currentSchemaId = String(currentAuthority.schemaId || '').trim();
+  if (!expectedSchemaId || parentSchemaId !== expectedSchemaId || currentSchemaId !== expectedSchemaId) return false;
+  if (String(parentAuthority.resolutionState || parentAuthority.state || '') !== 'qualified') return false;
+  if (String(currentAuthority.resolutionState || currentAuthority.state || '') !== 'qualified') return false;
+  const parentTargets = exactSchemaReferenceTargets(parentAuthority);
+  const currentTargets = new Set(exactSchemaReferenceTargets(currentAuthority));
+  return parentTargets.length > 0 && parentTargets.some((target) => currentTargets.has(target));
+}
+
+function exactSchemaReferenceTargets(authority = {}) {
+  return [...new Set([
+    ...(Array.isArray(authority.exactTargets) ? authority.exactTargets : []),
+    authority.preferredTarget || authority.target || ''
+  ].map((item) => String(item || '').trim()).filter(Boolean))];
+}
+
+function historicalParentSchemaValidationAuthority(parentRecord = {}) {
+  const schemaId = String(parentRecord.schemaId || parentRecord.currentSchemaId || '').trim();
+  const target = String(parentRecord.schemaReferenceAuthority?.preferredTarget || parentRecord.schemaReferenceAuthority?.target || '').trim();
+  const identifierOnly = isQualifiedIdentifierOnlyHistoricalSchemaReferenceAuthority(parentRecord.schemaReferenceAuthority || {});
+  return Object.freeze({
+    schema: 'tiinex.portable.historical-parent-schema-validation-authority.v1',
+    state: 'unavailable',
+    reason: identifierOnly ? 'historical-parent-schema-revision-unresolved-identifier-only' : 'historical-parent-schema-revision-not-qualified-as-current-candidate-authority',
+    schemaId,
+    currentReference: Object.freeze({
+      state: identifierOnly ? 'historical-identifier-only-preserved' : target ? 'historical-exact-reference-preserved' : 'unavailable',
+      basis: identifierOnly ? 'historical-parent-declared-schema-identifier-only' : 'historical-parent-declared-schema-reference',
+      raw: '',
+      target,
+      exactRevisionState: identifierOnly ? 'unresolved' : target ? 'declared-exact-reference' : 'unavailable'
+    }),
+    lineage: Object.freeze([]),
+    findings: Object.freeze([
+      identifierOnly
+        ? `Historical Parent ${parentRecord.path || parentRecord.id || '(parent)'} preserves only the declared ${schemaId || 'Current Schema'} identifier; exact historical schema revision remains unresolved and current candidate schema validation is withheld for the Parent.`
+        : `Historical Parent ${parentRecord.path || parentRecord.id || '(parent)'} is preserved under its exact declared ${schemaId || 'Current Schema'} reference${target ? ` ${target}` : ''}; current candidate schema validation is withheld because exact same-revision current authority is not qualified.`
+    ]),
+    compiledContract: null,
+    boundary: 'Historical Parent validation still runs Root readability, exact declared schema-identifier/reference-shape checks, recovery and integrity. Identifier-only authority never becomes exact historical schema-revision authority; current schema-specific machine/companion validation is applied only when the Parent and current creation contract share exact qualified schema-revision authority.'
+  });
+}
+
+function mergeAuthorAuditResults(candidateAudit = {}, parentAudit = null) {
+  if (!parentAudit) return candidateAudit;
+  const audits = Object.freeze([...(candidateAudit.audits || []), ...(parentAudit.audits || [])]);
+  const findings = Object.freeze([...(candidateAudit.findings || []), ...(parentAudit.findings || [])]);
+  return Object.freeze({
+    ...candidateAudit,
+    audits,
+    findings,
+    findingSummary: mergeFindingSummaries(candidateAudit.findingSummary, parentAudit.findingSummary),
+    boundary: Object.freeze({
+      ...(candidateAudit.boundary || {}),
+      historicalParentAudit: 'separate exact-byte historical audit; current schema-specific validation only when exact same-revision authority is qualified'
+    })
+  });
+}
+
 async function parentRecordFromArtifact(parentPath, parentRelativePath, context = {}) {
   const markdown = await readFile(parentPath, 'utf8');
   const parsed = parseArtifactMarkdown(markdown);
@@ -131,8 +220,11 @@ async function parentRecordFromArtifact(parentPath, parentRelativePath, context
   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: 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.`);
+    : qualifiedIdentifierOnlyHistoricalSchemaReferenceAuthority(schemaId, {
+      basis: 'exact-historical-parent-current-schema-identifier',
+      parentPath: String(parentRelativePath || ''),
+      parentSha256: sha256Hex(utf8Bytes(markdown))
+    });
   return Object.freeze({
     id: parentRelativePath,
     path: parentRelativePath,
@@ -146,6 +238,25 @@ async function parentRecordFromArtifact(parentPath, parentRelativePath, context
   });
 }
 
+function projectHistoricalParentReferenceAuthority(parentRecord = {}) {
+  const authority = parentRecord?.schemaReferenceAuthority || null;
+  if (!authority || !String(parentRecord?.schemaId || parentRecord?.currentSchemaId || '').trim()) return null;
+  const schemaId = String(parentRecord.schemaId || parentRecord.currentSchemaId || '').trim();
+  const target = String(authority.preferredTarget || authority.target || '').trim();
+  const identifierOnly = isQualifiedIdentifierOnlyHistoricalSchemaReferenceAuthority(authority);
+  return Object.freeze({
+    state: String(authority.resolutionState || authority.state || 'unavailable'),
+    kind: identifierOnly ? 'identifier-only' : target ? 'exact-target' : 'unresolved',
+    schemaId,
+    target,
+    exactRevisionState: identifierOnly ? 'unresolved' : target ? 'declared-exact-reference' : 'unresolved',
+    provenance: Object.freeze({ ...(authority.resolutionEvidence || authority.evidence || {}) }),
+    boundary: identifierOnly
+      ? 'Exact historical Parent artifact identity/integrity and declared schema identifier are qualified; no exact historical schema representation target is claimed or inferred.'
+      : 'Historical Parent schema-reference authority is projected only at the exact strength carried by the supplied Parent bytes.'
+  });
+}
+
 function projectAuthorActionableFindings(audit = {}, stage = {}) {
   const findings = [
     ...(audit.findings || audit.actionableFindings || []),

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

@@ -104,6 +104,7 @@ function projectGroundDefault(result = {}, parsed = {}) {
     readiness: compactReadiness(result.readiness),
     authority: compactGroundAuthority(result.authority),
     orchestrationReadiness: compactOrchestrationReadiness(result.orchestrationReadiness),
+    delegationReadiness: compactDelegationReadiness(result.delegationReadiness),
     requiredContext: Object.freeze({
       declared: Number(required.declared || 0),
       matchedInWorkspaceSnapshots: Number(required.matchedInWorkspaceSnapshots || 0),
@@ -300,6 +301,24 @@ function compactGroundAuthority(authority = {}) {
   });
 }
 
+
+function compactDelegationReadiness(value = {}) {
+  if (!value || typeof value !== 'object') return null;
+  return Object.freeze({
+    state: String(value.state || ''),
+    delegateCapabilityAuthority: value.delegateCapabilityAuthority ? Object.freeze({ ...value.delegateCapabilityAuthority }) : null,
+    processApplicability: value.processApplicability ? Object.freeze({ ...value.processApplicability }) : null,
+    targetAuthority: value.targetAuthority ? Object.freeze({ ...value.targetAuthority }) : null,
+    sourceAuthority: value.sourceAuthority ? Object.freeze({ ...value.sourceAuthority }) : null,
+    returnReconciliationExpectation: value.returnReconciliationExpectation ? Object.freeze({ ...value.returnReconciliationExpectation }) : null,
+    blockers: Object.freeze((value.blockers || []).slice(0, 8).map((item) => Object.freeze({ ...item }))),
+    plainChatFallbackPermitted: Boolean(value.plainChatFallbackPermitted),
+    repositoryScanningFallbackPermitted: Boolean(value.repositoryScanningFallbackPermitted),
+    nextOperations: Object.freeze((value.nextOperations || []).slice(0, 4).map((item) => Object.freeze({ ...item }))),
+    boundary: String(value.boundary || '')
+  });
+}
+
 function compactOrchestrationReadiness(value = {}) {
   if (!value || typeof value !== 'object') return null;
   const wider = value.widerOrchestration || {};

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, projectRequiredContextWorkspaceSelectionPreflight } from './handoff.manufacture.packageParent.js';
+import { preparePackageParentExactMaterialProvider, preparePackageParentWorkspaceReuse, projectPackageParentMaterialClosurePreflight, projectRequiredContextWorkspaceSelectionPreflight, resolvePackageParentRequirementMaterials } from './handoff.manufacture.packageParent.js';
 import { qualifyPortableSourceReconciliationProofForManufacture } from '../../comparison/sourceFrontierReconciliationProof.js';
 import { qualifyPortableManufactureSchemaReferenceCandidate } from '../../handoff/schemaReferencePreflight.js';
 import { qualifyDelegationReturnReservation } from '../../handoff/delegationReturnReservation.js';
@@ -69,6 +69,12 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
     workspaceIds: input.packageParentWorkspaceIds || input.reusePackageParentWorkspaceIds || [],
     workspaceAliases: input.packageParentWorkspaceAliases || input.workspaceAliases || {}
   });
+  const packageParentExactMaterialProvider = preparePackageParentExactMaterialProvider({
+    bundle: input.packageParentBundle || null,
+    currentWorkspaceIds: [...seenWorkspaceIds],
+    parentPackagePath: input.packageParentPath || '',
+    parentPackageSha256: input.packageParentSha256 || ''
+  });
   const handoffMarkdown = await handoffMarkdownPromise;
   const requiredContextWorkspaceSelectionPreflight = projectRequiredContextWorkspaceSelectionPreflight({
     handoffMarkdown,
@@ -169,16 +175,18 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
 
   const routeSpecs = transportRoutes.length ? transportRoutes : Object.freeze([{ workspaceId, path: handoffPath }]);
   let requirements = await projectManufacturingRequirements({ handoff, workspaceId, handoffPath, routeSpecs, workspaceRuntimeById });
+  const packageParentMaterialClosurePreflight = projectPackageParentMaterialClosurePreflight(requirements, packageParentExactMaterialProvider);
   let materials = await resolveWorkspaceRequirementMaterials(requirements, workspaceRuntimeById, input.materialBindings || {});
+  materials = appendMissingRequirementMaterials(materials, resolvePackageParentRequirementMaterials(requirements, packageParentExactMaterialProvider));
   const dependencyClosure = await expandPointerDependencyClosure({ requirements, materials, workspaceRuntimeById, bindings: input.materialBindings || {} });
   requirements = dependencyClosure.requirements;
-  materials = dependencyClosure.materials;
+  materials = appendMissingRequirementMaterials(dependencyClosure.materials, resolvePackageParentRequirementMaterials(requirements, packageParentExactMaterialProvider));
   const routeParentBoundaryClosure = expandRouteParentBoundaryClosure({ requirements, materials, workspaceMaterializations, workspaceRuntimeById, routeSpecs });
   requirements = routeParentBoundaryClosure.requirements;
-  materials = routeParentBoundaryClosure.materials;
+  materials = appendMissingRequirementMaterials(routeParentBoundaryClosure.materials, resolvePackageParentRequirementMaterials(requirements, packageParentExactMaterialProvider));
   const parentBoundaryClosure = expandBoundedParentBoundaryClosure({ requirements, materials, workspaceMaterializations, workspaceRuntimeById });
   requirements = parentBoundaryClosure.requirements;
-  materials = parentBoundaryClosure.materials;
+  materials = appendMissingRequirementMaterials(parentBoundaryClosure.materials, resolvePackageParentRequirementMaterials(requirements, packageParentExactMaterialProvider));
   const toolingBootstrapResult = await toolingBootstrapPromise;
   if (toolingBootstrapResult.error) throw toolingBootstrapResult.error;
   const toolingBootstrap = toolingBootstrapResult.value;
@@ -233,6 +241,7 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
         workspaceAliases: Object.freeze([...(packageParentReuse.workspaceAliases || [])].map((item) => Object.freeze({ ...item }))),
         boundary: String(packageParentReuse.boundary || '')
       }),
+      packageParentMaterialClosurePreflight,
       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.' })
     }),
@@ -241,6 +250,19 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
 }
 
 
+function appendMissingRequirementMaterials(existing = [], additional = []) {
+  const out = [...(existing || [])];
+  const alreadyBound = new Set(out.map((item) => String(item.requirementId || '')).filter(Boolean));
+  for (const item of additional || []) {
+    const id = String(item.requirementId || '');
+    if (id && alreadyBound.has(id)) continue;
+    out.push(item);
+    if (id) alreadyBound.add(id);
+  }
+  return Object.freeze(out);
+}
+
+
 function mergeWorkspaceTargetBindings(explicit = [], inherited = []) {
   const out = [];
   const seen = new Set();

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

@@ -5,6 +5,8 @@ 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';
 
@@ -16,9 +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 implementationSourceAuthority = projectGroundingImplementationSourceAuthority({ authority, records, contextAudit, requiredContext });
   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)),
@@ -34,24 +39,43 @@ export function projectGroundingCapsule({ authority = null, continuation = null,
       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 : '';