@tiinex/core 0.30.0 → 0.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.30.0",
+  "version": "0.32.0",
   "description": "Shared host-neutral Tiinex implementation core for artifacts, schemas, validation, lineage, grounding, Handoffs, provenance and deterministic workflows.",
   "type": "module",
   "sideEffects": true,
@@ -173,12 +173,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "5d51273d4c10f8a15367c32bcef8bbce11484ca8",
+  "gitHead": "036df699dd3a0455f849c4c4e421fee7c969e85a",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "5d51273d4c10f8a15367c32bcef8bbce11484ca8",
-    "sourceTree": "1372b29b40dbee5e11d2a52d9cac7731f41941a2",
+    "sourceCommit": "036df699dd3a0455f849c4c4e421fee7c969e85a",
+    "sourceTree": "540c88695f9de86c928a737e1ea2c51b5be5cd82",
     "repository": "Tiinex/core",
-    "previousVersion": "0.29.0"
+    "previousVersion": "0.31.0"
   }
 }

package/src/schemas/schema.lineageAuthority.js

@@ -0,0 +1,120 @@
+export const SCHEMA_LINEAGE_SOURCE_AUTHORITY_QUALIFICATION_SCHEMA_ID = 'tiinex.core.schema-lineage-source-authority-qualification.v1';
+
+export function qualifyCompiledSchemaLineageSourceAuthority(validationContract = {}) {
+  const lineage = Array.isArray(validationContract?.lineage) ? validationContract.lineage.map((item) => String(item || '').trim()) : [];
+  const projected = Array.isArray(validationContract?.lineageAuthority) ? validationContract.lineageAuthority : [];
+  const findings = [];
+  const edges = [];
+
+  if (!lineage.length || validationContract?.lineageQualification?.state !== 'valid') {
+    findings.push('Compiled validation lineage is unavailable or not valid.');
+  }
+  if (projected.length !== lineage.length) {
+    findings.push(`Compiled validation lineage source authority cardinality is ${projected.length}; expected ${lineage.length}.`);
+  }
+
+  const count = Math.min(projected.length, lineage.length);
+  for (let index = 0; index < count; index += 1) {
+    const entry = projected[index] || {};
+    const expectedSchemaId = lineage[index] || '';
+    const actualSchemaId = String(entry?.schemaId || '').trim();
+    if (!actualSchemaId || actualSchemaId !== expectedSchemaId) {
+      findings.push(`Compiled lineage source authority identity mismatch at index ${index}: expected ${expectedSchemaId || '(missing schema id)'} but observed ${actualSchemaId || '(missing schema id)'}.`);
+    }
+  }
+
+  for (let index = 1; index < count; index += 1) {
+    const parent = projected[index - 1] || {};
+    const child = projected[index] || {};
+    const parentSchemaId = String(parent?.schemaId || '').trim();
+    const childSchemaId = String(child?.schemaId || '').trim();
+    const declaredParentSchemaId = String(child?.parentSchemaId || '').trim();
+    const parentSource = normalizeSourceTuple(parent?.source || {});
+    const candidates = Object.freeze((Array.isArray(child?.parentSourceCandidates) ? child.parentSourceCandidates : []).map(normalizeSourceTuple));
+
+    if (!declaredParentSchemaId || declaredParentSchemaId !== parentSchemaId) {
+      findings.push(`Compiled lineage identity is incoherent across ${parentSchemaId || '(unknown parent)'} -> ${childSchemaId || '(unknown child)'}.`);
+      edges.push(freezeEdge({ state: 'contradictory', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'parent-schema-identity-mismatch' }));
+      continue;
+    }
+
+    if (isQualifiedLocalUnpublishedSchemaSource(parent?.source || {})) {
+      edges.push(freezeEdge({ state: 'qualified-local-supersession', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'qualified-local-unpublished-parent-authority' }));
+      continue;
+    }
+
+    const exactCandidates = candidates.filter(completeSourceTuple);
+    if (candidates.length !== 1 || exactCandidates.length !== 1) {
+      const reason = candidates.length > 1 ? 'ambiguous-parent-source-authority' : 'parent-source-authority-unavailable';
+      findings.push(candidates.length > 1
+        ? `Declared parent source authority is ambiguous for ${childSchemaId}: ${candidates.length} exact pinned candidates.`
+        : `Declared parent source authority is unavailable for ${childSchemaId} -> ${parentSchemaId}.`);
+      edges.push(freezeEdge({ state: 'unresolved', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason }));
+      continue;
+    }
+
+    const expected = exactCandidates[0];
+    if (!sameSourceTuple(parentSource, expected)) {
+      findings.push(`Compiled lineage substitutes source authority for ${childSchemaId} -> ${parentSchemaId}: declared ${formatSource(expected)} but compiled ${formatSource(parentSource)}.`);
+      edges.push(freezeEdge({ state: 'contradictory', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'compiled-parent-source-substitution' }));
+      continue;
+    }
+
+    edges.push(freezeEdge({ state: 'qualified', parentSchemaId, childSchemaId, actual: parentSource, candidates, reason: 'exact-parent-source-match' }));
+  }
+
+  const contradictory = edges.some((edge) => edge.state === 'contradictory') || findings.some((finding) => finding.includes('identity mismatch') || finding.includes('identity is incoherent') || finding.includes('substitutes source authority'));
+  const unresolved = !contradictory && (findings.length > 0 || edges.some((edge) => edge.state === 'unresolved'));
+  const state = contradictory ? 'contradictory' : unresolved ? 'unresolved' : 'qualified';
+  return deepFreeze({
+    schema: SCHEMA_LINEAGE_SOURCE_AUTHORITY_QUALIFICATION_SCHEMA_ID,
+    state,
+    complete: state === 'qualified',
+    lineage: Object.freeze([...lineage]),
+    edges: Object.freeze(edges),
+    findings: Object.freeze(findings),
+    boundary: 'Exact runtime validation authority requires source-coherent compiled inheritance. Qualified local unpublished Parent authority may intentionally supersede published Parent locators; all other inheritance edges require one exact declared Parent source tuple matching the compiled Parent material.'
+  });
+}
+
+export function isQualifiedLocalUnpublishedSchemaSource(source = {}) {
+  return String(source?.publicationState || '').trim().toLowerCase() === 'accepted-local-unpublished'
+    && String(source?.snapshotCompleteness || '').trim() === 'exact-axiom-canonical-unpublished-bounded-workspace-contract';
+}
+
+function normalizeSourceTuple(value = {}) {
+  return Object.freeze({
+    repository: String(value?.repository || '').trim(),
+    commit: String(value?.commit || '').trim().toLowerCase(),
+    path: String(value?.path || '').trim()
+  });
+}
+
+function completeSourceTuple(value = {}) {
+  return Boolean(value.repository && /^[0-9a-f]{40}$/.test(value.commit) && value.path);
+}
+
+function sameSourceTuple(left = {}, right = {}) {
+  return left.repository === right.repository && left.commit === right.commit && left.path === right.path;
+}
+
+function formatSource(value = {}) {
+  return `${value.repository || '(unknown repo)'}@${value.commit || '(unknown commit)'}/${value.path || '(unknown path)'}`;
+}
+
+function freezeEdge(value = {}) {
+  return Object.freeze({
+    state: String(value.state || 'unresolved'),
+    parentSchemaId: String(value.parentSchemaId || ''),
+    childSchemaId: String(value.childSchemaId || ''),
+    actual: value.actual || Object.freeze({ repository: '', commit: '', path: '' }),
+    candidates: value.candidates || Object.freeze([]),
+    reason: String(value.reason || '')
+  });
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}

package/src/schemas/schema.source.js

@@ -1,5 +1,6 @@
 import { sha256Hex, utf8Bytes } from '../export/package.bytes.js';
 import { qualifyGithubSchemaSourceProvider } from './schema.githubSourceTarget.js';
+import { qualifyCompiledSchemaLineageSourceAuthority } from './schema.lineageAuthority.js';
 
 export const BUNDLED_SCHEMA_SOURCE_SCHEMA_ID = 'tiinex.site.bundled-schema-source.v1';
 export const SCHEMA_RUNTIME_PROJECTION_SCHEMA_ID = 'tiinex.site.schema-runtime-projection.v1';
@@ -48,6 +49,7 @@ export function defineBundledSchemaSource(binding = {}, projection = {}, options
         ...(!loadedBlobSha ? ['Loaded schema Git-blob identity is unavailable from the runtime projection.'] : [])
       ])
     });
+    const validationLineageAuthority = qualifyCompiledSchemaLineageSourceAuthority(runtimeProjection.validationContract || {});
     const validationContract = projectionExact && runtimeProjection.validationContract?.schemaId === schemaId && runtimeProjection.validationContract?.lineageQualification?.state === 'valid'
       ? runtimeProjection.validationContract
       : null;
@@ -85,6 +87,7 @@ export function defineBundledSchemaSource(binding = {}, projection = {}, options
       authority,
       bindingMaterialCoherence,
       materialIdentity,
+      validationLineageAuthority,
       compiledContract,
       projection: runtimeProjection,
       findings: Object.freeze([
@@ -93,7 +96,8 @@ export function defineBundledSchemaSource(binding = {}, projection = {}, options
         ...(runtimeProjection.sourceChecksum !== expectedChecksum ? ['Schema runtime projection source checksum does not match binding.'] : []),
         ...(runtimeProjection.bindingChecksum !== expectedChecksum ? ['Schema runtime projection binding checksum does not match binding.'] : []),
         ...(runtimeProjection.validationContract && runtimeProjection.validationContract?.schemaId !== schemaId ? ['Schema runtime validation projection identity does not match binding.'] : []),
-        ...(runtimeProjection.validationContract && runtimeProjection.validationContract?.lineageQualification?.state !== 'valid' ? ['Schema runtime validation projection lineage is not exact/valid.'] : [])
+        ...(runtimeProjection.validationContract && runtimeProjection.validationContract?.lineageQualification?.state !== 'valid' ? ['Schema runtime validation projection lineage is not exact/valid.'] : []),
+        ...(validationLineageAuthority.state !== 'qualified' ? validationLineageAuthority.findings : [])
       ])
     });
     return cached;

package/src/tooling/portable/adapters/cli/cli.handoff-sibling-allocation.js

@@ -30,7 +30,26 @@ export function deriveHandoffSiblingAllocation({ parentInspection = null, select
     workspaceId: String(route.workspaceId || '').trim(),
     workspaceRelativeHandoffPath: String(route.workspaceRelativeHandoffPath || '').trim()
   }));
-  if (!routes.length) return blocked('qualified-parent-route-topology-empty');
+  if (!routes.length) {
+    const siblingIndex = 1;
+    if (explicit && explicit !== siblingIndex) return blocked('explicit-sibling-index-conflicts-with-qualified-pointerless-topology', { expectedSiblingIndex: siblingIndex });
+    return freeze({
+      state: 'qualified',
+      siblingIndex,
+      childDimension: parentDimension ? `${String(parentDimension).trim()}-${siblingIndex}` : '',
+      allocationMode: 'qualified-parent-pointerless-default',
+      explicitOverride: explicit ? 'matched-derived-value' : 'not-supplied',
+      reasonCode: '',
+      provenance: {
+        ...provenanceBase({ parentPackagePath, parentPackageSha256, parentDimension, explicitSiblingIndex: explicit }),
+        basis: 'qualified-parent-pointerless-default',
+        routeOrdinal: siblingIndex,
+        qualifiedRouteCount: 0,
+        pointerOrder: []
+      },
+      boundary: allocationBoundary()
+    });
+  }
 
   const qualified = [];
   const seenDimensions = new Set();

package/src/tooling/portable/editor/authoring.parent.js

@@ -2,6 +2,7 @@ import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
 import { auditPortableRecord } from '../audit/audit.capability.js';
 import { classifyParentRecoveryReference } from '../../../lineage/parentRecoveryReference.js';
 import { buildArtifactCreationContract } from '../../../schemas/creation.contracts.js';
+import { canonicalC14nV2SelfState } from '../../../integrity/integrity.c14nV2.js';
 
 export const PORTABLE_AUTHORING_PARENT_SCHEMA_ID = 'tiinex.portable.authoring-parent.v1';
 
@@ -12,8 +13,15 @@ export function projectPortableAuthoringParent(input = {}) {
   let parsed;
   try { parsed = parseArtifactMarkdown(record.markdown); }
   catch { return freeze({ schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID, status: 'blocked', parentRecord: null, findings: [{ severity: 'error', code: 'portable.authoring-parent.parse-failed', message: 'Selected Parent bytes are not a readable Tiinex artifact.' }], operationBoundary: boundary() }); }
-  const audit = auditPortableRecord({ ...record, title: parsed.title, schemaId: parsed.envelope?.current?.schema?.id, currentSchemaId: parsed.envelope?.current?.schema?.id, parent: parsed.envelope?.parent });
-  if (audit.status !== 'readable' || audit.qualification?.exact !== true || (audit.findings || []).some((item) => item.severity === 'error')) return freeze({ schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID, status: 'blocked', parentRecord: null, findings: [{ severity: 'error', code: 'portable.authoring-parent.unqualified', message: 'Selected Parent must pass exact shared audit before it can be used for native authoring.' }], operationBoundary: boundary() });
+  const audit = auditPortableRecord({ ...record, title: parsed.title, schemaId: parsed.envelope?.current?.schema?.id, currentSchemaId: parsed.envelope?.current?.schema?.id, parent: parsed.envelope?.parent }, { requireExactSchemaAuthority: true });
+  const auditErrors = (audit.findings || []).filter((item) => item.severity === 'error');
+  const historicalParentRecoveryDebt = auditErrors.length > 0 && auditErrors.every((item) => String(item.code || '') === 'root.parent.recovery.workspace-qualified.malformed');
+  const selfIntegrity = canonicalC14nV2SelfState(record.markdown || '');
+  const directParentUsableWithHistoricalDebt = historicalParentRecoveryDebt
+    && audit.qualification?.exact === true
+    && audit.schemaValidationAuthority?.state === 'qualified'
+    && selfIntegrity.state === 'verified';
+  if ((audit.status !== 'readable' && !directParentUsableWithHistoricalDebt) || audit.qualification?.exact !== true || (auditErrors.length && !directParentUsableWithHistoricalDebt)) return freeze({ schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID, status: 'blocked', parentRecord: null, findings: [{ severity: 'error', code: 'portable.authoring-parent.unqualified', message: 'Selected Parent must pass exact shared audit before it can be used for native authoring.' }], operationBoundary: boundary() });
   const schemaId = String(parsed.envelope?.current?.schema?.id || audit.schemaId || '');
   const schemaTarget = String(parsed.envelope?.current?.schema?.target || '');
   const createdAt = String(parsed.envelope?.current?.createdAt || audit.artifact?.createdAt || '');
@@ -36,9 +44,11 @@ export function projectPortableAuthoringParent(input = {}) {
       markdown: record.markdown, sourceMode: String(record.sourceMode || 'portable-node-local'),
       schemaReferenceAuthority
     },
-    findings: [],
+    findings: directParentUsableWithHistoricalDebt ? [{ severity: 'warning', code: 'portable.authoring-parent.historical-ancestor-recovery-debt', message: 'Selected Parent has historical malformed Workspace-qualified recovery references to its own ancestor. Direct child authoring is allowed from the Parent exact current bytes and verified self integrity; that ancestor debt is not repaired, inherited, or upgraded.' }] : [],
     operationBoundary: boundary(),
-    boundary: 'Projects exact supplied Parent bytes and declared current schema locator into shared draft-authoring input. A declared schema locator remains unresolved and is not upgraded to publication or canonical reference authority.'
+    boundary: directParentUsableWithHistoricalDebt
+      ? 'Projects exact supplied Parent current bytes for direct continuation while preserving unresolved historical ancestor-recovery debt on the Parent itself. The child does not inherit or repair that ancestor locator.'
+      : 'Projects exact supplied Parent bytes and declared current schema locator into shared draft-authoring input. A declared schema locator remains unresolved and is not upgraded to publication or canonical reference authority.'
   });
 }
 

package/src/tooling/portable/editor/editor.assistance.js

@@ -5,6 +5,7 @@ import { integrityMethodReferenceAuthorityForCreation } from '../../../integrity
 import { inspectPortableLineageIntegrity } from '../lineage/lineage.integrity.plan.js';
 import { portableFinding } from '../findings.js';
 import { qualifyTiinexRouteArtifact } from '../handoff/routeArtifactConformance.js';
+import { classifyParentRecoveryReference } from '../../../lineage/parentRecoveryReference.js';
 
 export const PORTABLE_EDITOR_ASSISTANCE_SCHEMA_ID = 'tiinex.portable.editor-assistance.v1';
 
@@ -49,6 +50,28 @@ function projectDocument(record = {}, records = [], lineageInspection = null) {
     diagnosticCodes: workspacePackagingRepair.diagnosticCodes,
     boundary: 'Repairs only a tiinex.workspace.v1 artifact whose replacement independently qualifies through the same exact registered Workspace contract and c14n-v2 self-integrity requirements used by Handoff package manufacture. Existing resolver-capable Current Schema references are preserved; permalink refresh is a separate resolution operation and must not be inferred from integrity repair.'
   }));
+  const referenceRepair = deterministicReferenceHygieneRepair(record, audit, markdown);
+  const referenceQualification = referenceRepair.state === 'ready'
+    ? qualifyReplacementAgainstSharedGuardrails(record, records, referenceRepair.markdown, {
+      allowQualifiedExternalParentUnresolved: true,
+      allowExistingWarningCodes: (audit.findings || []).filter((item) => item.severity === 'warning').map((item) => String(item.code || ''))
+    })
+    : { state: 'unavailable' };
+  if (referenceRepair.state === 'ready' && referenceRepair.markdown !== markdown && referenceQualification.state === 'qualified') actions.push(freeze({
+    id: 'repair-qualified-references-and-self-integrity',
+    title: referenceRepair.parentReferenceChanged && referenceRepair.schemaReferenceChanged
+      ? 'Repair Tiinex Parent/schema references and self integrity'
+      : referenceRepair.parentReferenceChanged
+        ? 'Repair Tiinex Parent references and self integrity'
+        : 'Repair Tiinex schema reference and self integrity',
+    kind: 'replace-document',
+    qualification: 'deterministic-shared-core',
+    sourceSha256: sha256Hex(new TextEncoder().encode(markdown)),
+    replacementMarkdown: referenceRepair.markdown,
+    diagnosticCodes: referenceRepair.diagnosticCodes,
+    boundary: 'Repairs only deterministically malformed Workspace-qualified Parent recovery locators and/or a bare Current Schema id when exact qualified current-schema source authority exists; reseals self integrity and exposes the replacement only after shared audit and loaded-descendant guardrails re-qualify it. External Parent availability is not invented.'
+  }));
+
   const integrityRepair = deterministicIntegrityHygieneRepair(markdown, audit.findings || []);
   const repairQualification = integrityRepair.state === 'ready'
     ? qualifyReplacementAgainstSharedGuardrails(record, records, integrityRepair.markdown)
@@ -117,25 +140,119 @@ function deterministicWorkspacePackagingRepair(record = {}, audit = {}, markdown
   return freeze({ state: 'ready', markdown: candidate, schemaReferenceChanged, diagnosticCodes });
 }
 
-function qualifyReplacementAgainstSharedGuardrails(record = {}, records = [], replacementMarkdown = '') {
+function qualifyReplacementAgainstSharedGuardrails(record = {}, records = [], replacementMarkdown = '', options = {}) {
   const focusPath = norm(record.path || record.id || '');
   if (!focusPath || !replacementMarkdown) return freeze({ state: 'unavailable', reason: 'replacement-or-focus-unavailable' });
   const replacedRecords = records.map((item) => norm(item.path || item.id || '') === focusPath ? { ...item, markdown: replacementMarkdown } : item);
   const replacementRecord = replacedRecords.find((item) => norm(item.path || item.id || '') === focusPath);
   if (!replacementRecord) return freeze({ state: 'unavailable', reason: 'focused-record-unavailable' });
   const replacementAudit = auditPortableRecord(replacementRecord, { requireExactSchemaAuthority: true });
-  const auditBlockers = [...(replacementAudit.findings || [])].filter((item) => item.severity === 'error' || item.severity === 'warning');
+  const allowedWarnings = new Set((options.allowExistingWarningCodes || []).map((item) => String(item || '')));
+  const auditBlockers = [...(replacementAudit.findings || [])].filter((item) => {
+    if (item.severity === 'error') return true;
+    if (item.severity !== 'warning') return false;
+    return !allowedWarnings.has(String(item.code || ''));
+  });
   if (auditBlockers.length) return freeze({ state: 'blocked', reason: 'replacement-shared-audit-not-clean', blockerCodes: auditBlockers.map((item) => String(item.code || '')) });
 
   const before = inspectPortableLineageIntegrity({ records });
   const after = inspectPortableLineageIntegrity({ records: replacedRecords });
   const beforeFocus = (before.artifacts || []).find((item) => norm(item.path || '') === focusPath);
   const affectedPaths = new Set([focusPath, ...((beforeFocus?.downstreamDescendants || []).map((item) => norm(item.path || '')).filter(Boolean))]);
-  const lineageBlockers = (after.artifacts || []).filter((item) => affectedPaths.has(norm(item.path || '')) && item.state !== 'healthy');
+  const lineageBlockers = (after.artifacts || []).filter((item) => {
+    if (!affectedPaths.has(norm(item.path || '')) || item.state === 'healthy') return false;
+    if (options.allowQualifiedExternalParentUnresolved === true && norm(item.path || '') === focusPath && item.state === 'parent-unresolved' && hasQualifiedWorkspaceParentReference(replacementMarkdown)) return false;
+    return true;
+  });
   if (lineageBlockers.length) return freeze({ state: 'blocked', reason: 'replacement-shared-lineage-not-clean', blockers: lineageBlockers.map((item) => ({ path: item.path, state: item.state })) });
   return freeze({ state: 'qualified', affectedPaths: [...affectedPaths] });
 }
 
+function deterministicReferenceHygieneRepair(record = {}, audit = {}, markdown = '') {
+  const source = String(markdown || '');
+  if (!source) return freeze({ state: 'unavailable' });
+  let candidate = source;
+  let parentReferenceChanged = false;
+  let schemaReferenceChanged = false;
+  const diagnosticCodes = [];
+
+  const lines = candidate.replace(/\r\n?/g, '\n').split('\n');
+  const parentStart = lines.findIndex((line) => /^\s*-\s+Parent\s*$/.test(line));
+  if (parentStart >= 0) {
+    let parentEnd = lines.length;
+    for (let index = parentStart + 1; index < lines.length; index += 1) {
+      if (/^-\s+\S/.test(lines[index])) { parentEnd = index; break; }
+    }
+    for (let index = parentStart + 1; index < parentEnd; index += 1) {
+      lines[index] = lines[index].replace(/\]\(([^)]+::[^)]+)\)/g, (whole, target) => {
+        const normalized = normalizeMalformedWorkspaceQualifiedTarget(target);
+        if (!normalized || normalized === target) return whole;
+        parentReferenceChanged = true;
+        return `](${normalized})`;
+      });
+    }
+  }
+  if (parentReferenceChanged) {
+    candidate = lines.join('\n');
+    const integrityLines = candidate.replace(/\r\n?/g, '\n').split('\n');
+    const integrityStart = integrityLines.findIndex((line) => line.trim() === '# Continuity Integrity');
+    if (integrityStart >= 0) {
+      for (let index = integrityStart + 1; index < integrityLines.length; index += 1) {
+        integrityLines[index] = integrityLines[index].replace(/\]\(([^)]+::[^)]+)\)/g, (whole, target) => {
+          const normalized = normalizeMalformedWorkspaceQualifiedTarget(target);
+          return normalized && normalized !== target ? `](${normalized})` : whole;
+        });
+      }
+      candidate = integrityLines.join('\n');
+    }
+    diagnosticCodes.push('root.parent.recovery.workspace-qualified.malformed', 'portable.lineage-integrity.parent-unresolved');
+  }
+
+  const exactTarget = String(audit?.schemaValidationAuthority?.currentReference?.target || '').trim();
+  const schemaId = String(audit?.schemaId || '').trim();
+  const schemaWarning = (audit?.findings || []).some((item) => String(item?.code || '') === 'schema.reference.exact-target-omitted');
+  if (schemaWarning && schemaId && exactTarget && audit?.schemaValidationAuthority?.currentReference?.state === 'qualified') {
+    const schemaLines = candidate.replace(/\r\n?/g, '\n').split('\n');
+    const index = schemaLines.findIndex((line) => /^\s*-\s+Current Schema:\s*/.test(line));
+    if (index >= 0) {
+      const match = schemaLines[index].match(/^(\s*-\s+Current Schema:\s*)([^\s].*)$/);
+      const raw = String(match?.[2] || '').trim();
+      if (match && raw === schemaId) {
+        schemaLines[index] = `${match[1]}[${schemaId}](${exactTarget})`;
+        candidate = schemaLines.join('\n');
+        schemaReferenceChanged = true;
+        diagnosticCodes.push('schema.reference.exact-target-omitted');
+      }
+    }
+  }
+
+  if (!parentReferenceChanged && !schemaReferenceChanged) return freeze({ state: 'unavailable' });
+  const sealed = sealC14nV2Self(candidate);
+  if (sealed.state !== 'sealed' && sealed.state !== 'unchanged') return freeze({ state: 'unavailable' });
+  return freeze({ state: 'ready', markdown: String(sealed.markdown || candidate), parentReferenceChanged, schemaReferenceChanged, diagnosticCodes: [...new Set(diagnosticCodes)] });
+}
+
+function normalizeMalformedWorkspaceQualifiedTarget(value = '') {
+  const raw = String(value || '').trim();
+  if (classifyParentRecoveryReference(raw).kind !== 'malformed-workspace-qualified') return raw;
+  const stripped = raw.replace(/^(?:\.\.\/)+/, '').replace(/^\.\//, '');
+  return classifyParentRecoveryReference(stripped).kind === 'workspace-qualified' ? stripped : raw;
+}
+
+function hasQualifiedWorkspaceParentReference(markdown = '') {
+  const source = String(markdown || '');
+  const parentStart = source.split(/\r?\n/).findIndex((line) => /^\s*-\s+Parent\s*$/.test(line));
+  if (parentStart < 0) return false;
+  const lines = source.split(/\r?\n/);
+  let parentEnd = lines.length;
+  for (let index = parentStart + 1; index < lines.length; index += 1) if (/^-\s+\S/.test(lines[index])) { parentEnd = index; break; }
+  const targets = [];
+  for (let index = parentStart + 1; index < parentEnd; index += 1) {
+    for (const match of lines[index].matchAll(/\]\(([^)]+)\)/g)) targets.push(String(match[1] || ''));
+  }
+  return targets.some((target) => classifyParentRecoveryReference(target).kind === 'workspace-qualified');
+}
+
 function projectDiagnostic(finding = {}, markdown = '') {
   const located = locateFindingLine(finding, markdown);
   return freeze({

package/src/tooling/portable/schema/qualifiedLocalRoot.runtime.js

@@ -13,10 +13,19 @@ export function portableRuntimeValidationContractForSchema(schemaId = '', resolu
   const resolution = resolutionInput || resolveSchemaModule({ schemaId });
   if (resolution?.fallbackUsed || !resolution?.module) return unavailable('registered-schema-resolution-unavailable', { resolution });
   const qualification = typeof resolution.module.schemaSource?.qualify === 'function' ? resolution.module.schemaSource.qualify() : null;
+  const lineageAuthority = qualification?.validationLineageAuthority || null;
+  if (qualification?.state === 'qualified' && lineageAuthority && lineageAuthority.state !== 'qualified') {
+    return unavailable('compiled-validation-lineage-source-authority-unqualified', {
+      resolution,
+      findings: Object.freeze([...(lineageAuthority.findings || [])]),
+      lineageAuthority,
+      baseQualificationState: String(qualification?.state || 'unavailable')
+    });
+  }
   const baseContract = qualification?.state === 'qualified' ? qualification?.compiledContract?.validationContract || null : null;
-  if (!baseContract) return unavailable(qualification?.state === 'qualified' ? 'compiled-validation-contract-unavailable' : 'schema-source-unqualified', { resolution });
+  if (!baseContract) return unavailable(qualification?.state === 'qualified' ? 'compiled-validation-contract-unavailable' : 'schema-source-unqualified', { resolution, findings: Object.freeze([...(qualification?.findings || [])]), baseQualificationState: String(qualification?.state || 'unavailable') });
   const projected = projectPortableValidationContractWithQualifiedLocalRoot(baseContract);
-  return deepFreeze({ ...projected, resolution, baseQualificationState: String(qualification?.state || 'unavailable') });
+  return deepFreeze({ ...projected, resolution, lineageAuthority, baseQualificationState: String(qualification?.state || 'unavailable') });
 }
 
 export function portableRuntimeValidationAuthorityForRecord(record = {}) {
@@ -26,7 +35,10 @@ export function portableRuntimeValidationAuthorityForRecord(record = {}) {
   const schemaId = String(declaredSchema.id || record?.schemaId || record?.currentSchemaId || '').trim();
   const runtime = portableRuntimeValidationContractForSchema(schemaId);
   if (runtime.state !== 'qualified' || !runtime.compiledContract) {
-    return unavailableAuthority(schemaId, runtime, ['Registered compiled validation authority is unavailable for the declared Current Schema.']);
+    const runtimeFindings = Array.isArray(runtime?.findings) && runtime.findings.length
+      ? runtime.findings
+      : ['Registered compiled validation authority is unavailable for the declared Current Schema.'];
+    return unavailableAuthority(schemaId, runtime, runtimeFindings);
   }
 
   const findings = [];