@tiinex/core 0.1.1

package/src/adapters/archive/archive.transport.js

@@ -0,0 +1,124 @@
+const BOOTSTRAP_ROOT = '.bootstrap/';
+const PORTABLE_MANIFEST_SCHEMAS = new Set([
+  'tiinex.portable.artifact-set.manifest.v1',
+  'tiinex.portable.changeset.manifest.v1'
+]);
+const PORTABLE_CHECKSUM_SCHEMAS = new Set([
+  'tiinex.portable.artifact-set.checksums.v1',
+  'tiinex.portable.changeset.checksums.v1'
+]);
+
+export function isBootstrapTransportPath(value = '') {
+  const path = cleanPath(value);
+  return path === '.bootstrap' || path.startsWith(BOOTSTRAP_ROOT);
+}
+
+export async function filterArchiveTransportEntries(entries = [], options = {}) {
+  const source = Array.isArray(entries) ? entries : [];
+  const bootstrap = source.filter((entry) => isBootstrapTransportPath(entry.path));
+  const ordinary = source.filter((entry) => !isBootstrapTransportPath(entry.path));
+  const manifestEntry = ordinary.find((entry) => entry.path === 'manifest.json');
+  const checksumsEntry = ordinary.find((entry) => entry.path === 'checksums.json');
+  const manifest = parseJson(manifestEntry?.content);
+  const checksums = parseJson(checksumsEntry?.content);
+  const portableControl = Boolean(PORTABLE_MANIFEST_SCHEMAS.has(manifest?.schema) && PORTABLE_CHECKSUM_SCHEMAS.has(checksums?.schema));
+  const stripBootstrap = options.stripBootstrapTransport !== false;
+  const stripPortableControl = options.stripPortableControl !== false;
+  const filtered = source.filter((entry) => {
+    if (stripBootstrap && isBootstrapTransportPath(entry.path)) return false;
+    if (stripPortableControl && portableControl && (entry.path === 'manifest.json' || entry.path === 'checksums.json')) return false;
+    return true;
+  });
+  const mergePreflight = portableControl
+    ? await preflightPortableChangeset(manifest, ordinary, options.existingRecords || [])
+    : neutralMergePreflight();
+  return Object.freeze({
+    entries: Object.freeze(filtered),
+    manifest,
+    checksums,
+    portableControl,
+    mergePreflight,
+    diagnostics: Object.freeze({
+      bootstrapDetected: bootstrap.length > 0,
+      bootstrapStrippedCount: stripBootstrap ? bootstrap.length : 0,
+      bootstrapManifestSchema: parseJson(bootstrap.find((entry) => entry.path === '.bootstrap/manifest.json')?.content)?.schema || '',
+      portableControlDetected: portableControl,
+      portableControlStrippedCount: stripPortableControl && portableControl ? Number(Boolean(manifestEntry)) + Number(Boolean(checksumsEntry)) : 0,
+      mergePreflight
+    })
+  });
+}
+
+export async function preflightPortableChangeset(manifest = {}, entries = [], existingRecords = []) {
+  if (!PORTABLE_MANIFEST_SCHEMAS.has(manifest?.schema)) return neutralMergePreflight();
+  const existing = indexExistingRecords(existingRecords);
+  const included = new Map((entries || []).map((entry) => [cleanPath(entry.path), entry]));
+  const conflicts = [];
+  const matched = [];
+  const availableContext = [];
+  const missing = [];
+
+  for (const parent of manifest.lineage?.knownParents || []) {
+    const path = cleanPath(parent.path);
+    const expected = String(parent.sha256 || '').trim().toLowerCase();
+    const current = existing.get(path) || existing.get(String(parent.id || '').trim());
+    if (current) {
+      const digest = await sha256Hex(String(current.markdown || current.content || ''));
+      if (expected && digest !== expected) conflicts.push(conflict('archive.merge.parent-drift', path, expected, digest));
+      else matched.push(path);
+      continue;
+    }
+    const packaged = included.get(path);
+    if (packaged && parent.included !== false) {
+      const digest = await sha256Hex(packaged.bytes || packaged.content || '');
+      if (expected && digest !== expected) conflicts.push(conflict('archive.merge.context-checksum-mismatch', path, expected, digest));
+      else availableContext.push(path);
+      continue;
+    }
+    missing.push(path);
+    conflicts.push(conflict('archive.merge.parent-missing', path, expected, 'missing'));
+  }
+
+  for (const material of manifest.material || []) {
+    if (material.role !== 'modified') continue;
+    const path = cleanPath(material.path);
+    const current = existing.get(path);
+    const expectedBase = String(material.baseSha256 || '').trim().toLowerCase();
+    if (!current) conflicts.push(conflict('archive.merge.modified-base-missing', path, expectedBase, 'missing'));
+    else {
+      const digest = await sha256Hex(String(current.markdown || current.content || ''));
+      if (expectedBase && digest !== expectedBase) conflicts.push(conflict('archive.merge.modified-base-drift', path, expectedBase, digest));
+    }
+  }
+
+  return Object.freeze({
+    schema: 'tiinex.archive.merge-preflight.v1',
+    status: conflicts.length ? 'blocked' : 'ready',
+    checkedParents: (manifest.lineage?.knownParents || []).length,
+    matchedParents: matched.length,
+    availableContext: availableContext.length,
+    missingParents: missing.length,
+    conflicts: Object.freeze(conflicts)
+  });
+}
+
+function neutralMergePreflight() {
+  return Object.freeze({ schema: 'tiinex.archive.merge-preflight.v1', status: 'not-applicable', checkedParents: 0, matchedParents: 0, availableContext: 0, missingParents: 0, conflicts: Object.freeze([]) });
+}
+function conflict(code, path, expected, actual) { return Object.freeze({ code, path, expected, actual }); }
+function parseJson(value) { try { return value ? JSON.parse(String(value)) : null; } catch { return null; } }
+function cleanPath(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/{2,}/g, '/').replace(/^\/+|\/+$/g, ''); }
+function indexExistingRecords(records = []) {
+  const map = new Map();
+  for (const record of Array.isArray(records) ? records : []) {
+    const path = cleanPath(record.path);
+    if (path) map.set(path, record);
+    if (record.id) map.set(String(record.id), record);
+  }
+  return map;
+}
+async function sha256Hex(value) {
+  const bytes = value instanceof Uint8Array ? value : value instanceof ArrayBuffer ? new Uint8Array(value) : new TextEncoder().encode(String(value || ''));
+  const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+}

package/src/artifacts/artifact.localDraft.js

@@ -0,0 +1,27 @@
+import { schemaIdForRecord } from '../schemas/schema.identity.js';
+
+export const LOCAL_DRAFT_ARTIFACT_POLICY_ID = 'tiinex.artifact.local-draft-policy.v1';
+export const EDITABLE_LOCAL_DRAFT_SCHEMA_IDS = Object.freeze(['tiinex.task.v1']);
+
+export function localDraftArtifactPolicy(record = {}) {
+  const source = record?.source || {};
+  const sourceMode = String(record?.sourceMode || '').trim().toLowerCase();
+  const status = String(record?.status || record?.lifecycleStatus || record?.currentStatus || record?.envelope?.current?.status || '').trim().toLowerCase();
+  const schemaId = artifactSchemaId(record);
+  const localSource = source.adapterId === 'local' || source.kind === 'local-session' || source.kind === 'local' || source.sourceKind === 'local.session';
+  const draftLike = sourceMode.startsWith('local-transition') || sourceMode.startsWith('local-reference') || sourceMode.startsWith('local-draft') || status === 'draft' || status === 'local' || status === 'draft/local';
+  const localDraft = Boolean(localSource && draftLike && record?.id);
+  return Object.freeze({
+    schema: LOCAL_DRAFT_ARTIFACT_POLICY_ID,
+    localDraft,
+    schemaId,
+    editLocalDraft: Boolean(localDraft && EDITABLE_LOCAL_DRAFT_SCHEMA_IDS.includes(schemaId)),
+    discardLocalDraft: localDraft,
+    sourceBacked: !localSource
+  });
+}
+
+export function canEditLocalDraft(record = {}) { return localDraftArtifactPolicy(record).editLocalDraft; }
+export function canDiscardLocalDraft(record = {}) { return localDraftArtifactPolicy(record).discardLocalDraft; }
+
+export function artifactSchemaId(record = {}) { return schemaIdForRecord(record); }

package/src/artifacts/artifact.normalize.js

@@ -0,0 +1,28 @@
+import { createRootFallbackModel } from '../schemas/tiinex.root.v1.fallback.js';
+import { schemaBadgeClass, schemaKey } from '../schemas/tiinex.root.v1.classify.js';
+
+export function normalizeArtifact(parsedArtifact, schemaResolution, validation = []) {
+  const currentSchemaId = parsedArtifact.envelope.current.schema.id || 'unknown';
+  const fallbackModel = createRootFallbackModel(parsedArtifact, schemaResolution, validation);
+  return {
+    title: parsedArtifact.title,
+    schemaId: currentSchemaId,
+    envelopeSchemaId: parsedArtifact.envelope.envelopeSchema.id || 'unknown',
+    moduleId: schemaResolution.module.id,
+    resolutionStatus: schemaResolution.status,
+    fallbackUsed: schemaResolution.fallbackUsed,
+    createdAt: parsedArtifact.envelope.current.createdAt || 'unknown',
+    parentSchemaId: parsedArtifact.envelope.parent.schema.id || null,
+    trace: parsedArtifact.envelope.parent.trace || '',
+    traceLabel: parsedArtifact.envelope.parent.traceLabel || '',
+    origin: parsedArtifact.envelope.parent.origin || parsedArtifact.envelope.origin || '',
+    boundary: parsedArtifact.envelope.parent.boundary || parsedArtifact.envelope.boundary || '',
+    schemaKey: schemaKey(currentSchemaId),
+    badgeClass: schemaBadgeClass(currentSchemaId),
+    rootReadable: fallbackModel.rootReadable,
+    rootDisclosure: fallbackModel.disclosure,
+    fallbackModel,
+    sections: parsedArtifact.body.sections,
+    validation
+  };
+}

package/src/artifacts/artifact.parse.js

@@ -0,0 +1,207 @@
+export function parseArtifactMarkdown(markdown = '') {
+  const text = normalizeLineEndings(markdown);
+  const envelopeBoundary = findFirstHorizontalRule(text);
+  const envelopeText = envelopeBoundary === -1 ? text : text.slice(0, envelopeBoundary).trimEnd();
+  const remainder = envelopeBoundary === -1 ? '' : text.slice(envelopeBoundary).replace(/^---\s*\n?/, '');
+  const integrityIndex = remainder.search(/^# Continuity Integrity\s*$/m);
+  const bodySlice = integrityIndex === -1 ? remainder : remainder.slice(0, integrityIndex);
+  const bodyText = stripCanonicalFooterDivider(bodySlice).trim();
+  const integrityText = integrityIndex === -1 ? '' : remainder.slice(integrityIndex).trim();
+
+  const envelope = parseContinuityEnvelope(envelopeText);
+  const body = parseBody(bodyText);
+  const integrity = parseIntegrity(integrityText);
+
+  return {
+    markdown: text,
+    title: body.title || envelope.current.summary || 'Untitled artifact',
+    envelope,
+    body,
+    integrity,
+    hasContinuityContext: /^# Continuity Context\s*$/m.test(envelopeText),
+    hasIntegrity: integrity.methods.length > 0
+  };
+}
+
+export function parseContinuityEnvelope(envelopeText = '') {
+  const parentBlock = blockAfterTopLevelList(envelopeText, 'Parent');
+  const currentBlock = blockAfterTopLevelList(envelopeText, 'Current');
+  return {
+    envelopeSchema: extractSchemaField(envelopeText, 'Envelope Schema'),
+    parent: {
+      schema: extractSchemaField(parentBlock, 'Parent Schema'),
+      createdAt: extractListField(parentBlock, 'Created At'),
+      trace: extractListField(parentBlock, 'Trace', { preferLinkTarget: true }),
+      traceLabel: extractListField(parentBlock, 'Trace'),
+      traceRaw: extractListField(parentBlock, 'Trace', { preserveRaw: true }),
+      origin: extractListField(parentBlock, 'Origin', { preferLinkTarget: true }),
+      originEntries: Object.freeze(extractNestedLinkEntries(parentBlock, 'Origin')),
+      boundary: extractListField(parentBlock, 'Boundary')
+    },
+    current: {
+      schema: extractSchemaField(currentBlock, 'Current Schema'),
+      createdAt: extractListField(currentBlock, 'Created At'),
+      summary: extractListField(currentBlock, 'Summary'),
+      authors: extractListField(currentBlock, 'Authors'),
+      status: extractListField(currentBlock, 'Status'),
+      why: extractListField(currentBlock, 'Why')
+    },
+    repairsDeclared: /^\s*-\s*Repairs:/m.test(envelopeText),
+    origin: extractListField(envelopeText, 'Origin', { preferLinkTarget: true }),
+    boundary: extractListField(envelopeText, 'Boundary')
+  };
+}
+
+export function parseBody(bodyText = '') {
+  const headings = [...bodyText.matchAll(/^(#{1,6})\s+(.+)\s*$/gm)].map((match) => ({ level: match[1].length, text: match[2].trim() }));
+  const firstHeading = headings.find((heading) => heading.level === 1 && heading.text !== 'Continuity Context' && heading.text !== 'Continuity Integrity');
+  return {
+    title: firstHeading?.text || '',
+    headings,
+    sections: headings.filter((heading) => heading.level === 2).map((heading) => heading.text),
+    text: bodyText
+  };
+}
+
+export function parseIntegrity(integrityText = '') {
+  const entries = parseIntegrityEntries(integrityText);
+  const methods = entries.flatMap((entry) => [entry.method, entry.declaredMethod]).filter(Boolean);
+  const values = entries.map((entry) => entry.value).filter(Boolean);
+  return { methods, values, entries, text: integrityText };
+}
+
+function parseIntegrityEntries(integrityText = '') {
+  const lines = String(integrityText || '').split('\n');
+  const entries = [];
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    const method = current.label || '';
+    const declaredMethod = current.fields.Method || '';
+    entries.push({
+      method: stripMarkdown(method),
+      declaredMethod: stripMarkdown(declaredMethod),
+      methodRaw: method,
+      towards: normalizeFieldValue(current.fields.Towards || '', { preferLinkTarget: true }),
+      towardsLabel: normalizeFieldValue(current.fields.Towards || ''),
+      value: stripMarkdown(current.fields.Value || ''),
+      raw: current.lines.join('\n')
+    });
+    current = null;
+  };
+  for (const line of lines) {
+    const top = line.match(/^-\s+(.+?)\s*$/);
+    if (top) {
+      flush();
+      current = { label: top[1].trim(), fields: {}, lines: [line] };
+      continue;
+    }
+    if (!current) continue;
+    current.lines.push(line);
+    const field = line.match(/^\s+-\s*([A-Za-z][A-Za-z0-9 _+-]{0,40}):\s*(.+?)\s*$/);
+    if (!field) continue;
+    current.fields[field[1].trim()] = field[2].trim();
+  }
+  flush();
+  return entries.filter((entry) => entry.method || entry.value || entry.towards);
+}
+
+function extractSchemaField(text, label) {
+  const raw = extractListField(text, label, { preserveRaw: true });
+  const link = markdownLink(raw);
+  return { raw, id: link?.label || raw, target: link?.href || '', form: link ? 'markdown-link' : raw ? 'plain-schema-id' : 'empty' };
+}
+
+
+function extractListField(text, label, options = {}) {
+  const lines = String(text || '').split('\n');
+  const escaped = escapeRegExp(label);
+  for (let i = 0; i < lines.length; i += 1) {
+    const match = lines[i].match(new RegExp(`^(\\s*)-\\s*${escaped}:\\s*(.*)$`));
+    if (!match) continue;
+    const parentIndent = match[1].length;
+    const inline = match[2].trim();
+    if (inline) return normalizeFieldValue(inline, options);
+    const nested = firstNestedListValue(lines, i + 1, parentIndent);
+    if (nested) return normalizeFieldValue(nested, options);
+    return '';
+  }
+  return '';
+}
+
+function firstNestedListValue(lines, start, parentIndent) {
+  for (let i = start; i < lines.length; i += 1) {
+    const line = lines[i];
+    const indent = leadingSpaces(line);
+    if (/^\s*-\s+\S/.test(line) && indent <= parentIndent) return '';
+    const item = line.match(/^\s*-\s+(.+?)\s*$/);
+    if (!item) continue;
+    const raw = item[1].trim();
+    // Origin blocks commonly use labelled nested entries, e.g.
+    //   - relative: ../parent.trace.md
+    //   - [github git file](https://github.com/...)
+    // Returning the value portion keeps parent/origin resolution from treating
+    // the label as part of the path while still preserving markdown links for
+    // normalizeFieldValue(..., { preferLinkTarget: true }).
+    const labelled = raw.match(/^([A-Za-z][A-Za-z0-9 _+-]{0,40}):\s*(.+)$/);
+    return (labelled ? labelled[2] : raw).trim();
+  }
+  return '';
+}
+
+function extractNestedLinkEntries(text, label) {
+  const lines = String(text || '').split('\n');
+  const escaped = escapeRegExp(label);
+  const start = lines.findIndex((line) => line.match(new RegExp(`^(\\s*)-\\s*${escaped}:\\s*$`)));
+  if (start < 0) return [];
+  const parentIndent = leadingSpaces(lines[start]);
+  const out = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    const line = lines[i];
+    const indent = leadingSpaces(line);
+    if (/^\s*-\s+\S/.test(line) && indent <= parentIndent) break;
+    const item = line.match(/^\s*-\s+(\[[^\]]+\]\([^)]+\))\s*$/);
+    if (!item) continue;
+    const link = markdownLink(item[1]);
+    if (!link) continue;
+    out.push(Object.freeze({ label: link.label, target: link.href, raw: item[1] }));
+  }
+  return out;
+}
+
+function normalizeFieldValue(value, options = {}) {
+  const raw = String(value || '').trim();
+  if (options.preserveRaw) return raw;
+  const link = markdownLink(raw);
+  if (link && options.preferLinkTarget) return link.href || link.label || raw;
+  return link?.label || stripMarkdown(raw);
+}
+
+function blockAfterTopLevelList(text, label) {
+  const lines = String(text || '').split('\n');
+  const start = lines.findIndex((line) => line.trim() === `- ${label}`);
+  if (start === -1) return '';
+  const out = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^-\s+\S/.test(lines[i])) break;
+    out.push(lines[i]);
+  }
+  return out.join('\n');
+}
+
+
+function stripCanonicalFooterDivider(value) {
+  const text = String(value || '').replace(/\s+$/, '');
+  return text.replace(/(?:^|\n)---\s*$/, '');
+}
+function normalizeLineEndings(value) { return String(value || '').replace(/\r\n?/g, '\n'); }
+function findFirstHorizontalRule(text) { const match = /^---\s*$/m.exec(text); return match ? match.index : -1; }
+function markdownLink(value) {
+  const match = String(value || '').match(/^\[([^\]]+)\]\(([^)]+)\)$/);
+  if (!match) return null;
+  return { label: match[1].trim(), href: match[2].trim() };
+}
+function markdownLabel(value) { return markdownLink(value)?.label || ''; }
+function stripMarkdown(value) { return String(value || '').replace(/^\[([^\]]+)\]\([^)]+\)$/, '$1').trim(); }
+function leadingSpaces(value) { return String(value || '').match(/^\s*/)?.[0]?.length || 0; }
+function escapeRegExp(value) { return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }

package/src/artifacts/artifact.record.js

@@ -0,0 +1,83 @@
+import { parseArtifactMarkdown } from './artifact.parse.js';
+import { schemaBadgeClass, schemaKey } from '../schemas/tiinex.root.v1.classify.js';
+import { createRootFallbackModel } from '../schemas/tiinex.root.v1.fallback.js';
+import { inferRecordMaterialRole } from '../workspaces/workspace.materialRole.js';
+import { collectOriginReferencesFromMarkdown } from '../sources/origin.references.js';
+
+export function createRecordFromMarkdown(markdown = '', meta = {}) {
+  const parsed = parseArtifactMarkdown(markdown || '');
+  const title = bestRecordTitle(parsed, meta);
+  const envelope = parsed.envelope || {};
+  const current = envelope.current || {};
+  const parent = envelope.parent || {};
+  const schemaId = current.schema?.id || '';
+  const resolvedKind = schemaId || (parsed.hasContinuityContext ? 'tiinex.root.v1' : 'markdown');
+  const fallbackModel = createRootFallbackModel(parsed, meta.schemaResolution || { status: schemaId ? 'declared' : 'unknown', fallbackUsed: !schemaId }, meta.findings || []);
+  const originReferences = collectOriginReferencesFromMarkdown(markdown || '');
+  return {
+    title,
+    summary: current.summary || parsed.body?.sections?.slice(0, 3).join(' · ') || meta.path || 'Local Markdown artifact.',
+    kind: resolvedKind,
+    schemaId: schemaId || '',
+    envelopeSchemaId: envelope.envelopeSchema?.id || '',
+    schemaKey: schemaKey(schemaId),
+    schemaBadgeClass: schemaBadgeClass(schemaId),
+    status: parsed.hasIntegrity ? 'schema ok' : 'local',
+    lifecycleStatus: current.status || meta.lifecycleStatus || '',
+    currentCreatedAt: current.createdAt || '',
+    path: meta.path || meta.name || '',
+    markdown,
+    sourceMode: meta.sourceMode || 'local-manual',
+    hasContinuityContext: parsed.hasContinuityContext,
+    hasIntegrity: parsed.hasIntegrity,
+    integrity: parsed.integrity || { methods: [], values: [], entries: [], text: '' },
+    parentSchemaId: parent.schema?.id || '',
+    parentCreatedAt: parent.createdAt || '',
+    trace: parent.trace || '',
+    traceLabel: parent.traceLabel || '',
+    origin: parent.origin || envelope.origin || '',
+    originReferences,
+    boundary: parent.boundary || envelope.boundary || '',
+    repairsDeclared: Boolean(envelope.repairsDeclared),
+    rootReadable: fallbackModel.rootReadable,
+    rootDisclosure: fallbackModel.disclosure,
+    rootFallback: fallbackModel,
+    materialRole: inferRecordMaterialRole({
+      path: meta.path || meta.name || '',
+      kind: resolvedKind,
+      schemaId: schemaId || '',
+      envelopeSchemaId: envelope.envelopeSchema?.id || '',
+      hasContinuityContext: parsed.hasContinuityContext,
+      hasIntegrity: parsed.hasIntegrity,
+      parentSchemaId: parent.schema?.id || '',
+      trace: parent.trace || '',
+      origin: parent.origin || envelope.origin || '',
+      markdown
+    })
+  };
+}
+
+function bestRecordTitle(parsed = {}, meta = {}) {
+  const parsedTitle = String(parsed.title || '').trim();
+  if (parsedTitle && parsedTitle !== 'Untitled artifact') return parsedTitle;
+  const fallback = titleFromPath(meta.path || meta.name || '');
+  return fallback || parsedTitle || 'Untitled artifact';
+}
+
+function titleFromPath(path = '') {
+  const name = String(path || '').split('/').filter(Boolean).pop() || '';
+  const withoutKnownSuffix = name
+    .replace(/\.trace\.md$/i, '')
+    .replace(/\.schema\.md$/i, '')
+    .replace(/\.validator\.md$/i, '')
+    .replace(/\.workspace\.md$/i, '')
+    .replace(/\.(?:md|markdown)$/i, '');
+  const cleaned = withoutKnownSuffix
+    .replace(/^\d+[-_\s.]*/, '')
+    .replace(/[-_.]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!cleaned) return '';
+  return cleaned.replace(/\b[a-zåäö]/gi, (m) => m.toUpperCase()).slice(0, 96);
+}
+

package/src/audit/audit.run.js

@@ -0,0 +1,103 @@
+import { parseArtifactMarkdown } from '../artifacts/artifact.parse.js';
+import { resolveSchemaModule } from '../schemas/resolver.js';
+import { validateArtifact, validationTruthFor } from '../validation/validateArtifact.js';
+import { summarizeFindings } from './audit.summary.js';
+
+export function runAudit(scope = {}) {
+  const record = scope.record || null;
+  const markdown = typeof scope.markdown === 'string' ? scope.markdown : (typeof record?.markdown === 'string' ? record.markdown : '');
+  const availability = materialAvailabilityFor(scope, record, markdown);
+  if (!availability.available) return unavailableAuditResult(record, availability);
+
+  const parsed = parseArtifactMarkdown(markdown);
+  if (isPlainSupportingMarkdown(parsed, record)) return supportingMarkdownAuditResult(record, parsed, availability);
+
+  const schemaId = parsed.envelope.current.schema.id || record?.schemaId || record?.currentSchemaId || '';
+  const validationResult = validateArtifact({ parsed, schemaId, record, markdown, schemaReferenceAuthorities: scope.schemaReferenceAuthorities || null, validationContractOverride: scope.validationContractOverride || null, schemaValidationAuthority: scope.schemaValidationAuthority || null });
+  const findings = validationResult.findings;
+  return {
+    status: findings.some((finding) => finding.severity === 'error') ? 'invalid-or-incomplete' : validationResult.resolution.fallbackUsed ? 'degraded' : 'readable',
+    parsed,
+    resolution: validationResult.resolution,
+    artifact: validationResult.artifact,
+    findings,
+    summary: summarizeFindings(findings),
+    materialAvailability: availability,
+    contractValidation: validationResult.contractValidation,
+    schemaValidationAuthority: validationResult.schemaValidationAuthority || null,
+    validation: validationResult.validation
+  };
+}
+
+
+function isPlainSupportingMarkdown(parsed = {}, record = {}) {
+  const declaredSchema = parsed?.envelope?.current?.schema?.id || record?.schemaId || '';
+  const kind = String(record?.kind || '').trim().toLowerCase();
+  return !parsed?.hasContinuityContext && !declaredSchema && (!kind || kind === 'markdown');
+}
+
+function supportingMarkdownAuditResult(record = {}, parsed = {}, availability = {}) {
+  const finding = {
+    severity: 'info',
+    code: 'audit.markdown.supporting-material',
+    message: 'Plain Markdown is retained as supporting local material; it is not classified as an invalid Tiinex leaf.',
+    source: 'tiinex.audit.v1'
+  };
+  return {
+    status: 'supporting-material',
+    parsed,
+    resolution: {
+      schemaId: 'markdown',
+      module: { id: 'tiinex.markdown.supporting.v1' },
+      fallbackUsed: false
+    },
+    artifact: {
+      title: record?.title || parsed?.title || 'Markdown material',
+      summary: record?.summary || parsed?.body?.sections?.slice(0, 3).join(' · ') || '',
+      schemaId: 'markdown',
+      moduleId: 'tiinex.markdown.supporting.v1',
+      fallbackUsed: false
+    },
+    findings: [finding],
+    summary: summarizeFindings([finding]),
+    materialAvailability: availability,
+    validation: validationTruthFor({ parsed, schemaId: 'markdown', resolution: { module: { id: 'tiinex.markdown.supporting.v1' }, fallbackUsed: false }, validator: null, availability, supporting: true })
+  };
+}
+
+function materialAvailabilityFor(scope = {}, record = {}, markdown = '') {
+  const sourceBacked = Boolean(scope.sourceBacked || record?.sourceBacked || (record?.source?.adapterId && record.source.adapterId !== 'local'));
+  const cacheState = String(scope.cacheState || record?.cacheState || '').trim();
+  const materialAvailability = String(scope.materialAvailability || record?.materialAvailability || '').trim();
+  const metadataOnly = cacheState === 'metadata-only' || materialAvailability === 'metadata-only' || materialAvailability === 'unavailable' || materialAvailability === 'material-unavailable';
+  if (String(markdown || '').trim()) return { status: 'available', available: true, sourceBacked, cacheState, materialAvailability };
+  if (sourceBacked || metadataOnly) return { status: 'pending-unavailable', available: false, sourceBacked, cacheState: cacheState || 'metadata-only', materialAvailability: materialAvailability || 'material-unavailable' };
+  return { status: 'empty-invalid', available: true, sourceBacked, cacheState, materialAvailability };
+}
+
+function unavailableAuditResult(record = {}, availability = {}) {
+  const schemaId = record?.schemaId || record?.currentSchemaId || '';
+  const resolution = resolveSchemaModule({ schemaId });
+  const finding = {
+    severity: 'info',
+    code: 'audit.material.unavailable',
+    message: 'Material is metadata-only or not loaded in this session; audit is pending and must not classify it as invalid.',
+    source: 'tiinex.audit.v1'
+  };
+  return {
+    status: 'pending-unavailable',
+    parsed: null,
+    resolution,
+    artifact: {
+      title: record?.title || 'Unavailable material',
+      summary: record?.summary || '',
+      schemaId,
+      moduleId: resolution.module?.id || 'tiinex.root.v1',
+      fallbackUsed: Boolean(resolution.fallbackUsed)
+    },
+    findings: [finding],
+    summary: summarizeFindings([finding]),
+    materialAvailability: availability,
+    validation: validationTruthFor({ parsed: null, schemaId, resolution, validator: null, availability })
+  };
+}

package/src/audit/audit.summary.js

@@ -0,0 +1,7 @@
+export function summarizeFindings(findings = []) {
+  const summary = { error: 0, warning: 0, info: 0, preserve: 0 };
+  for (const finding of findings) {
+    if (Object.hasOwn(summary, finding.severity)) summary[finding.severity] += 1;
+  }
+  return summary;
+}