@tiinex/core 0.11.0 → 0.13.0

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

@@ -15,8 +15,14 @@ export function manufactureRecipientRelativeHandoffPackage(input = {}, options =
     carrierProfile: input.carrierProfile || null
   }, input.carrierLineage || upgraded.carrierProjection?.lineage || baseline.carrierProjection?.lineage || {});
   const majorFindings = majorReadiness.state === 'blocked' ? [Object.freeze({ severity: 'error', code: 'portable.handoff-carrier-lineage.major.not-self-contained', message: 'Major Handoff carrier requires complete replacement-capable carried Workspace snapshots.' })] : [];
+  const reconciliationProofQualification = input.reconciliationProofQualification || input.manufacturingEvidence?.reconciliationProof || null;
+  const reconciliationBlocked = String(reconciliationProofQualification?.state || '') === 'blocked';
+  const schemaReferencePreflight = input.schemaReferencePreflight || input.manufacturingEvidence?.schemaReferencePreflight || null;
+  const schemaReferenceBlocked = String(schemaReferencePreflight?.state || '') === 'blocked';
   const findings = Object.freeze([
     ...majorFindings,
+    ...(schemaReferencePreflight?.findings || []),
+    ...(reconciliationProofQualification?.findings || []),
     ...(baseline.findings || []),
     ...(upgraded.findings || []),
     ...(upgraded.inspection?.findings || []),
@@ -28,7 +34,7 @@ export function manufactureRecipientRelativeHandoffPackage(input = {}, options =
     ...(upgraded.roundtrip?.findings || []),
     ...(toolingBootstrapInspection?.findings || [])
   ]);
-  const status = baseline.status !== 'blocked' && upgraded.status !== 'blocked' && toolingBootstrapInspection?.status === 'valid' && majorReadiness.state !== 'blocked' ? upgraded.status : 'blocked';
+  const status = baseline.status !== 'blocked' && upgraded.status !== 'blocked' && toolingBootstrapInspection?.status === 'valid' && majorReadiness.state !== 'blocked' && !schemaReferenceBlocked && !reconciliationBlocked ? upgraded.status : 'blocked';
   return Object.freeze({
     schema: 'tiinex.portable.handoff-manufacturing.v2',
     status,
@@ -45,7 +51,9 @@ export function manufactureRecipientRelativeHandoffPackage(input = {}, options =
       coldConsumerEntrypointInspection: String(upgraded.coldConsumerEntrypointInspection?.status || 'unavailable'),
       companionInspection: String(upgraded.companionInspection?.status || 'unavailable'),
       roundtrip: upgraded.roundtrip ? String(upgraded.roundtrip.status || 'unknown') : 'not-requested',
-      toolingBootstrap: String(toolingBootstrapInspection?.status || 'unavailable')
+      toolingBootstrap: String(toolingBootstrapInspection?.status || 'unavailable'),
+      schemaReferencePreflight: String(schemaReferencePreflight?.state || 'not-run'),
+      reconciliationProof: String(reconciliationProofQualification?.state || 'not-required')
     }),
     plan: baseline.plan,
     bundle: upgraded.bundle || baseline.bundle,
@@ -63,6 +71,8 @@ export function manufactureRecipientRelativeHandoffPackage(input = {}, options =
     roundtrip: upgraded.roundtrip || null,
     toolingBootstrap: input.toolingBootstrap || null,
     manufacturingEvidence: input.manufacturingEvidence || null,
+    schemaReferencePreflight,
+    reconciliationProofQualification,
     toolingBootstrapInspection,
     carrierLineage: upgraded.carrierProjection?.lineage || baseline.carrierProjection?.lineage || input.carrierLineage || null,
     majorReadiness,
@@ -73,12 +83,14 @@ export function manufactureRecipientRelativeHandoffPackage(input = {}, options =
       sourceMutation: false,
       remoteMutation: false,
       physicalRoundtripVerification: upgraded.roundtrip ? String(upgraded.roundtrip.status || 'unknown') : 'not-requested',
+      schemaReferencePreflight: String(schemaReferencePreflight?.state || 'not-run'),
+      reconciliationProof: String(reconciliationProofQualification?.state || 'not-required'),
       hostBehaviorAuthority: 'none'
     }),
     migration: upgraded.migration || null,
     baseline: Object.freeze({ schema: baseline.schema, status: baseline.status, packageRepresentationSha256: String(baseline.bundle?.packageRepresentationSha256 || ''), representation: 'semantic-control-plus-detached-material-without-exploded-workspace-carrier' }),
     findings,
     findingSummary: summarizePortableFindings(findings),
-    boundary: 'Canonical archive-backed Handoff manufacturing facade. It fails closed unless each carrier workspace is bound to one exact carried tiinex.workspace.v1 artifact and one independently verified complete workspace archive.'
+    boundary: 'Canonical archive-backed Handoff manufacturing facade. It fails closed unless each carrier workspace is bound to one exact carried tiinex.workspace.v1 artifact and one independently verified complete workspace archive; the actively selected local Handoff candidate must satisfy prospective per-field exact schema-reference authority, and when reconciliation proof is required/supplied, the exact source selected for manufacture must also match the qualified candidate reconciled frontier.'
   });
 }

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

@@ -1,6 +1,8 @@
 import { packageFileBytes, sha256Hex, utf8Bytes } from '../../../export/package.bytes.js';
 import { canonicalC14nV2SelfState, sealC14nV2Self } from '../../../integrity/integrity.c14nV2.js';
 import { C14N_V2_VALIDATOR_TARGET } from '../../../integrity/integrity.methodReference.js';
+import { schemaReferenceAuthorityForRegisteredSchema } from '../../../schemas/creation.schemaReferences.js';
+import { renderSchemaReference } from '../../../schemas/schema.reference.js';
 import { inspectHandoffCarrierProjection } from './carrierProjection.js';
 import { qualifyTiinexRouteArtifact } from './routeArtifactConformance.js';
 
@@ -8,6 +10,7 @@ export const HANDOFF_POINTER_ENTRYPOINT_PROJECTION_SCHEMA_ID = 'tiinex.portable.
 export const HANDOFF_POINTER_ENTRYPOINT_INSPECTION_SCHEMA_ID = 'tiinex.portable.handoff-pointer-entrypoints.inspection.v1';
 export const HANDOFF_POINTER_ENTRYPOINT_PREFIX = 'handoff-entrypoint-';
 export const CANONICAL_POINTER_SCHEMA_TARGET = 'https://github.com/Tiinex/docs/blob/3988951208eb9a8926e84ab42625d4b42fa00c2d/.topics/.schemas/core/pointer/tiinex.pointer.v1.schema.md';
+const CANONICAL_ROOT_SCHEMA_REFERENCE = renderSchemaReference(schemaReferenceAuthorityForRegisteredSchema('tiinex.root.v1'));
 
 const BOUNDARY = 'Generated package-root tiinex.pointer.v1 orientation only. Pointer filename, prose, and placement have no Parent, assignment, acceptance, completion, source, package-identity, or route-selection authority; qualified package carrier/closure truth remains controlling.';
 
@@ -83,7 +86,7 @@ export function isHandoffPointerEntrypointPath(value = '') {
 function buildPointerEntry(route = {}, createdAt = '') {
   const path = pointerPath(route);
   const title = `Handoff route pointer — ${String(route.parties?.to || route.workspaceId || 'recipient')}`;
-  const unsigned = `# Continuity Context\n\n- Envelope Schema: tiinex.root.v1\n- Current\n  - Current Schema: [tiinex.pointer.v1](${CANONICAL_POINTER_SCHEMA_TARGET})\n  - Created At: ${createdAt}\n  - Summary: Thin package-local pointer to one qualified Handoff route.\n\n---\n\n# ${title}\n\nThis generated pointer exposes one next hop only. Package carrier and closure controls remain the authority for whether that Handoff route is qualified.\n\n## Destinations\n\n- Qualified Handoff route: [${route.workspaceRelativePath}](${route.pointerTarget || route.packagePath})\n\n# Continuity Integrity\n\n- [sha256-base64url-c14n-v2](${C14N_V2_VALIDATOR_TARGET})\n  - Towards: self\n  - Value: \n`;
+  const unsigned = `# Continuity Context\n\n- Envelope Schema: ${CANONICAL_ROOT_SCHEMA_REFERENCE}\n- Current\n  - Current Schema: [tiinex.pointer.v1](${CANONICAL_POINTER_SCHEMA_TARGET})\n  - Created At: ${createdAt}\n  - Summary: Thin package-local pointer to one qualified Handoff route.\n\n---\n\n# ${title}\n\nThis generated pointer exposes one next hop only. Package carrier and closure controls remain the authority for whether that Handoff route is qualified.\n\n## Destinations\n\n- Qualified Handoff route: [${route.workspaceRelativePath}](${route.pointerTarget || route.packagePath})\n\n# Continuity Integrity\n\n- [sha256-base64url-c14n-v2](${C14N_V2_VALIDATOR_TARGET})\n  - Towards: self\n  - Value: \n`;
   const sealed = sealC14nV2Self(unsigned);
   if (sealed.state !== 'sealed') throw new Error(`portable.handoff-pointer.integrity.seal-failed:${sealed.reason || sealed.state}`);
   return deepFreeze({

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

@@ -0,0 +1,26 @@
+import { runAudit } from '../../../audit/audit.run.js';
+import { summarizePortableFindings } from '../findings.js';
+
+export const PORTABLE_HANDOFF_SCHEMA_REFERENCE_PREFLIGHT_SCHEMA_ID = 'tiinex.portable.handoff-schema-reference-preflight.v1';
+
+export function qualifyPortableManufactureSchemaReferenceCandidate(record = {}) {
+  const markdown = String(record.markdown || '');
+  const path = String(record.path || record.id || '');
+  const audit = runAudit({
+    record: Object.freeze({ ...record, path, markdown }),
+    markdown,
+    schemaReferenceContext: 'candidate'
+  });
+  const findings = Object.freeze((audit.findings || []).filter((finding) => String(finding?.code || '').startsWith('schema.reference.')));
+  const findingSummary = summarizePortableFindings(findings);
+  const blocked = Number(findingSummary?.counts?.error || 0) > 0;
+  return Object.freeze({
+    schema: PORTABLE_HANDOFF_SCHEMA_REFERENCE_PREFLIGHT_SCHEMA_ID,
+    state: blocked ? 'blocked' : 'qualified',
+    status: blocked ? 'blocked' : findingSummary?.counts?.warning ? 'degraded' : 'ready',
+    path,
+    findings,
+    findingSummary,
+    boundary: 'Prospective manufacture gate for the actively selected local Handoff candidate only. Existing/historical carried Workspace artifacts remain preservation inputs and are not reclassified as new candidates by package carriage.'
+  });
+}

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

@@ -7,6 +7,11 @@ import { qualifySecureTransportV1Envelope } from '../../../transport/secureTrans
 export const TRANSPORT_ENVELOPE_V1_SCHEMA_ID = 'tiinex.transport.envelope.v1';
 export const TRANSPORT_ENVELOPE_V1_ROLE = 'password-sealed-workspace-transport-envelope';
 
+// Bounded exception: the Transport Envelope schema is intentionally not assigned a
+// published immutable canonical locator. Keep the plain schema id until such authority
+// exists; do not substitute a mutable branch/latest URL. Secure-transport regressions
+// lock this fail-closed representation choice.
+
 export function renderTransportEnvelopeV1(input = {}) {
   const envelope = input.envelope || {};
   const q = qualifySecureTransportV1Envelope(envelope);

package/src/tooling/portable/index.js

@@ -54,3 +54,4 @@ export * from './handoff/transportEnvelopeV1.js';
 export * from './handoff/recipientV2.packageV1.js';
 
 export * from './comparison/sourceFrontierComparison.js';
+export * from './comparison/sourceFrontierReconciliationProof.js';

package/src/tooling/portable/operation.catalog.js

@@ -39,10 +39,18 @@ import { projectPortableOperatingOverview } from './overview/operatingOverview.j
 import { projectPortableGroundingReadiness } from './grounding/grounding.readiness.js';
 import { createPortablePackageOperationEntries } from './operation.catalog.package.js';
 import { compareOrReconcilePortableSourceFrontiers } from './comparison/sourceFrontierComparison.js';
+import { provePortableSourceReconciliation } from './comparison/sourceFrontierReconciliationProof.js';
 
 export const PORTABLE_OPERATION_CATALOG_SCHEMA_ID = 'tiinex.portable.operation.catalog.v1';
 
 export const portableOperationCatalog = Object.freeze({
+  'prove-source-reconciliation': operation({
+    name: 'prove-source-reconciliation',
+    description: 'Fail closed unless qualified base/incoming/current source plus explicit conflict/deletion dispositions are preserved by one exact candidate reconciled frontier suitable for manufacture requalification.',
+    safety: 'read-only-mechanical-proof',
+    inputSchema: 'tiinex.portable.source-frontier-reconciliation-proof.request.v1',
+    handler: (input = {}) => wrapPortableResult('prove-source-reconciliation', provePortableSourceReconciliation(input))
+  }),
   'compare-source-frontiers': operation({
     name: 'compare-source-frontiers',
     description: 'Compare normalized exact Workspace source frontiers two-way or reconcile base/incoming/current three-way without merge, semantic inference, remote acquisition, or source mutation.',

package/src/tooling/portable/source/sourceEligibility.js

@@ -0,0 +1,108 @@
+export const PORTABLE_SOURCE_ELIGIBILITY_SCHEMA_ID = 'tiinex.portable.source-eligibility.v1';
+
+export const PORTABLE_GENERATED_SOURCE_EXCLUDED_DIRECTORY_NAMES = Object.freeze(['__pycache__']);
+export const PORTABLE_GENERATED_SOURCE_EXCLUDED_FILE_SUFFIXES = Object.freeze(['.pyc', '.pyo']);
+export const DEFAULT_PORTABLE_SOURCE_EXCLUDED_DIRECTORIES = Object.freeze([
+  '.git',
+  '.tiinex',
+  'node_modules',
+  '.site-publish',
+  '.release',
+  '.outgoing-handoff-packages',
+  ...PORTABLE_GENERATED_SOURCE_EXCLUDED_DIRECTORY_NAMES
+]);
+export const DEFAULT_PORTABLE_SOURCE_EXCLUDED_RELATIVE_PATHS = Object.freeze(['.vscode/link']);
+
+/**
+ * Host-neutral source eligibility for one Workspace-relative path.
+ *
+ * This is a mechanical durable-source boundary only. Exclusion means a path is not
+ * part of source-frontier identity; it does not grant deletion, merge, acceptance,
+ * or semantic authority over bytes carried as historical transport evidence.
+ */
+export function qualifyPortableSourcePath(pathInput = '', options = {}) {
+  const entryKind = String(options.entryKind || 'file').trim().toLowerCase() === 'directory' ? 'directory' : 'file';
+  const path = normalizePortableSourcePath(pathInput);
+  const policy = portableSourceEligibilityPolicy(options);
+  if (!path) return freezeQualification(path, true, 'empty-or-unqualified-path', '', entryKind, policy);
+
+  const segments = path.split('/').filter(Boolean);
+  const directorySegments = entryKind === 'directory' ? segments : segments.slice(0, -1);
+  for (const name of directorySegments) {
+    if (!policy.excludedDirectories.includes(name)) continue;
+    return freezeQualification(path, false, 'excluded-directory', name, entryKind, policy);
+  }
+
+  for (const relativePath of policy.excludedRelativePaths) {
+    if (path === relativePath || path.startsWith(`${relativePath}/`)) {
+      return freezeQualification(path, false, 'excluded-relative-path', relativePath, entryKind, policy);
+    }
+  }
+
+  if (entryKind === 'file') {
+    const basename = String(segments.at(-1) || '').toLowerCase();
+    for (const suffix of policy.excludedFileSuffixes) {
+      if (!basename.endsWith(suffix)) continue;
+      return freezeQualification(path, false, 'compiled-python-cache', suffix, entryKind, policy);
+    }
+  }
+
+  return freezeQualification(path, true, 'eligible-source', '', entryKind, policy);
+}
+
+export function isPortableSourceEligiblePath(pathInput = '', options = {}) {
+  return qualifyPortableSourcePath(pathInput, options).eligible;
+}
+
+export function portableSourceEligibilityPolicy(options = {}) {
+  const requestedDirectories = options.excludeDirectories == null
+    ? DEFAULT_PORTABLE_SOURCE_EXCLUDED_DIRECTORIES
+    : options.excludeDirectories;
+  const requestedRelativePaths = options.excludeRelativePaths == null
+    ? DEFAULT_PORTABLE_SOURCE_EXCLUDED_RELATIVE_PATHS
+    : options.excludeRelativePaths;
+
+  const excludedDirectories = uniqueSorted([
+    ...PORTABLE_GENERATED_SOURCE_EXCLUDED_DIRECTORY_NAMES,
+    ...iterableStrings(requestedDirectories)
+  ]);
+  const excludedRelativePaths = uniqueSorted(iterableStrings(requestedRelativePaths).map(normalizePortableSourcePath).filter(Boolean));
+  const excludedFileSuffixes = uniqueSorted(PORTABLE_GENERATED_SOURCE_EXCLUDED_FILE_SUFFIXES.map((value) => String(value).toLowerCase()));
+
+  return Object.freeze({
+    schema: PORTABLE_SOURCE_ELIGIBILITY_SCHEMA_ID,
+    excludedDirectories: Object.freeze(excludedDirectories),
+    excludedRelativePaths: Object.freeze(excludedRelativePaths),
+    excludedFileSuffixes: Object.freeze(excludedFileSuffixes),
+    boundary: 'Mechanical durable-source eligibility only. Historical transport bytes remain evidence; exclusion grants no semantic deletion or merge authority.'
+  });
+}
+
+export function normalizePortableSourcePath(value = '') {
+  return String(value || '').trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '').replace(/\/+$/, '');
+}
+
+function freezeQualification(path, eligible, reason, matchedRule, entryKind, policy) {
+  return Object.freeze({
+    schema: PORTABLE_SOURCE_ELIGIBILITY_SCHEMA_ID,
+    state: eligible ? 'eligible' : 'excluded',
+    eligible,
+    path,
+    entryKind,
+    reason,
+    matchedRule,
+    policy,
+    boundary: 'Path classification is mechanical source eligibility only; it is not a semantic disposition.'
+  });
+}
+
+function iterableStrings(value) {
+  if (Array.isArray(value)) return value.map(String);
+  if (value instanceof Set) return [...value].map(String);
+  if (value == null) return [];
+  return [String(value)];
+}
+
+function uniqueSorted(values) {
+  return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))].sort();
+}

package/src/validation/validateArtifact.js

@@ -1,10 +1,11 @@
 import { parseArtifactMarkdown } from '../artifacts/artifact.parse.js';
 import { normalizeArtifact } from '../artifacts/artifact.normalize.js';
 import { resolveSchemaModule } from '../schemas/resolver.js';
+import { schemaRegistry } from '../schemas/registry.js';
 import { rootValidate, rootFallbackFinding } from '../schemas/tiinex.root.v1.validate.js';
 import { validateIntegrity } from '../integrity/integrity.validate.js';
 import { validatePortableContractInstance } from '../tooling/portable/schema/contract.validate.js';
-import { qualifySchemaReferenceValue, schemaReferenceAuthorityFromBinding } from '../schemas/schema.reference.js';
+import { qualifySchemaReferenceValue, qualifiedExactSchemaReferenceTarget, schemaReferenceAuthorityFromBinding } from '../schemas/schema.reference.js';
 import { normalizeFindings, normalizeFinding } from './findings.js';
 
 export const ARTIFACT_VALIDATION_PIPELINE_ID = 'tiinex.artifact.validation.pipeline.v1';
@@ -18,7 +19,7 @@ export function validateArtifact(input = {}, options = {}) {
   const schemaValidationAuthority = input.schemaValidationAuthority || null;
   const machineContract = runMachineContractValidation({ markdown: markdown || parsed?.markdown || '', schemaId, resolution, validationContractOverride: input.validationContractOverride || null, schemaValidationAuthority });
   const contractFindings = normalizeFindings(machineContract.findings, { schemaId: machineContract.schemaId || schemaId, qualification: 'machine-contract' });
-  const schemaReferenceFindings = normalizeFindings(validateDeclaredSchemaReferences(parsed, input.schemaReferenceAuthorities || null), { qualification: 'schema-reference' });
+  const schemaReferenceFindings = normalizeFindings(validateDeclaredSchemaReferences(parsed, input.schemaReferenceAuthorities || null, { context: input.schemaReferenceContext || 'historical' }), { qualification: 'schema-reference' });
   const integrityFindings = normalizeFindings(validateIntegrity(parsed, options.integrity), { schemaId: 'tiinex.root.v1', qualification: 'integrity' });
   const schemaAuthorityFindings = normalizeFindings(schemaValidationAuthorityFindings(schemaValidationAuthority, schemaId), { schemaId, qualification: 'schema-validation-authority' });
   const childValidation = runExactSchemaValidator({ parsed, schemaId, resolution, schemaValidationAuthority });
@@ -39,7 +40,7 @@ export function validateArtifact(input = {}, options = {}) {
   });
 }
 
-function validateDeclaredSchemaReferences(parsed = {}, contextualAuthorities = null) {
+function validateDeclaredSchemaReferences(parsed = {}, contextualAuthorities = null, options = {}) {
   const references = [
     { role: 'Envelope Schema', value: parsed?.envelope?.envelopeSchema?.raw || '', schemaId: parsed?.envelope?.envelopeSchema?.id || '' },
     { role: 'Current Schema', value: parsed?.envelope?.current?.schema?.raw || '', schemaId: parsed?.envelope?.current?.schema?.id || '' }
@@ -59,21 +60,76 @@ function validateDeclaredSchemaReferences(parsed = {}, contextualAuthorities = n
     const contextualAuthority = contextualSchemaReferenceAuthority(contextualAuthorities, reference.role, reference.schemaId);
     const authority = contextualAuthority || registeredAuthority;
     const qualification = qualifySchemaReferenceValue(reference.value, authority);
+    const context = String(options?.context || 'historical').trim() === 'candidate' ? 'candidate' : 'historical';
+    const exactTarget = qualifiedExactSchemaReferenceTarget(authority);
+    if (qualification.schemaIdState === 'qualified' && qualification.observed?.form === 'plain-schema-id' && exactTarget) {
+      const prospective = context === 'candidate';
+      findings.push({
+        severity: prospective ? 'error' : 'warning',
+        code: 'schema.reference.exact-target-omitted',
+        message: prospective
+          ? `${reference.role}: qualified immutable exact schema-reference authority exists for ${reference.schemaId}; a new candidate must use Markdown Link form targeting ${exactTarget} before sealing, staging, acceptance, or manufacture.`
+          : `${reference.role}: a qualified immutable exact schema-reference target is currently available for ${reference.schemaId}, but this existing artifact uses only the schema id. Preserve the historical bytes; treat this as reference-quality debt rather than an in-place rewrite instruction.`,
+        source: 'tiinex.schema.reference.validation.v1',
+        state: prospective ? 'blocking-prospective-reference-omission' : 'historical-reference-debt',
+        params: { field: reference.role, schemaId: reference.schemaId, exactTarget, context }
+      });
+      continue;
+    }
     if (qualification.state === 'qualified') continue;
     if (qualification.schemaIdState !== 'qualified') {
-      findings.push({ severity: 'error', code: 'schema.reference.identity-contradiction', message: `${reference.role}: Declared schema identifier contradicts current semantic schema identity authority. ${qualification.findings.join(' ')}`, source: 'tiinex.schema.reference.validation.v1', params: { field: reference.role } });
+      findings.push({ severity: 'error', code: 'schema.reference.identity-contradiction', message: `${reference.role}: Declared schema identifier contradicts current semantic schema identity authority. ${qualification.findings.join(' ')}`, source: 'tiinex.schema.reference.validation.v1', params: { field: reference.role, schemaId: reference.schemaId, context } });
       continue;
     }
     if (qualification.observed?.form === 'markdown-link' && qualification.targetState === 'unqualified') {
-      findings.push({ severity: 'info', code: 'schema.reference.locator.unresolved', message: `${reference.role}: Declared schema representation locator is preserved but is not resolved by current exact material authority. Locator resolution is separate from semantic schema identity.`, source: 'tiinex.schema.reference.validation.v1' });
+      const observedTarget = String(qualification.observed?.target || '');
+      const targetIdentity = qualifiedRegisteredSchemaIdentitiesForTarget(observedTarget);
+      const contradictory = targetIdentity.length > 0 && !targetIdentity.includes(reference.schemaId);
+      if (contradictory) {
+        findings.push({
+          severity: 'error',
+          code: 'schema.reference.material-identity-contradiction',
+          message: `${reference.role}: the declared schema representation locator is positively qualified as ${targetIdentity.join(', ')}, not ${reference.schemaId}; resolved material identity contradictions are blocking even for preserved historical artifacts.`,
+          source: 'tiinex.schema.reference.validation.v1',
+          state: 'blocking-resolved-material-identity-contradiction',
+          params: { field: reference.role, schemaId: reference.schemaId, observedTarget, resolvedSchemaIds: targetIdentity, context }
+        });
+        continue;
+      }
+      const prospective = context === 'candidate';
+      findings.push({
+        severity: prospective ? 'error' : 'info',
+        code: prospective ? 'schema.reference.target-unqualified' : 'schema.reference.locator.unresolved',
+        message: prospective
+          ? `${reference.role}: the declared schema representation locator is not qualified for the exact governing schema material and cannot be carried into a new candidate unchanged.`
+          : `${reference.role}: Declared schema representation locator is preserved but is not resolved by current exact material authority. Locator resolution is separate from semantic schema identity.`,
+        source: 'tiinex.schema.reference.validation.v1',
+        state: prospective ? 'blocking-prospective-reference-contradiction' : 'historical-locator-unresolved',
+        params: { field: reference.role, schemaId: reference.schemaId, observedTarget, exactTarget, context }
+      });
       continue;
     }
-    findings.push({ severity: 'error', code: 'schema.reference.unqualified', message: `${reference.role}: ${qualification.findings.join(' ')}`, source: 'tiinex.schema.reference.validation.v1', params: { field: reference.role } });
+    findings.push({ severity: 'error', code: 'schema.reference.unqualified', message: `${reference.role}: ${qualification.findings.join(' ')}`, source: 'tiinex.schema.reference.validation.v1', params: { field: reference.role, schemaId: reference.schemaId, context } });
   }
   return findings;
 }
 
 
+function qualifiedRegisteredSchemaIdentitiesForTarget(target = '') {
+  const observedTarget = String(target || '').trim();
+  if (!observedTarget) return Object.freeze([]);
+  const schemaIds = [];
+  for (const module of schemaRegistry.modules || []) {
+    const schemaId = String(module?.id || '').trim();
+    if (!schemaId) continue;
+    const sourceQualification = typeof module?.schemaSource?.qualify === 'function' ? module.schemaSource.qualify() : null;
+    const authority = schemaReferenceAuthorityFromBinding(schemaId, module?.binding || {}, sourceQualification?.authority || null, sourceQualification);
+    if (qualifiedExactSchemaReferenceTarget(authority) === observedTarget) schemaIds.push(schemaId);
+  }
+  return Object.freeze([...new Set(schemaIds)]);
+}
+
+
 function contextualSchemaReferenceAuthority(value = null, role = '', schemaId = '') {
   if (!value || typeof value !== 'object') return null;
   const key = role === 'Envelope Schema' ? 'envelope' : role === 'Current Schema' ? 'current' : role === 'Parent Schema' ? 'parent' : '';