@tiinex/core 0.1.1

package/src/schemas/capability.registry.js

@@ -0,0 +1,226 @@
+import { schemaRegistry } from './registry.js';
+import { resolveSchemaModule as resolveRegisteredSchemaModule } from './resolver.js';
+import { qualifyArtifactCreationCapability } from './creation.capability.js';
+import { buildSchemaFactoryDescriptor } from './schema.factory.descriptor.js';
+
+export const SCHEMA_CAPABILITY_REGISTRY_SCHEMA_ID = 'tiinex.schema.capability.registry.v1';
+export const SCHEMA_CAPABILITY_DESCRIPTOR_SCHEMA_ID = 'tiinex.schema.capability.descriptor.v1';
+export const SCHEMA_CAPABILITY_RESOLUTION_SCHEMA_ID = 'tiinex.schema.capability.resolution.v1';
+
+export const CapabilityStatus = Object.freeze({
+  implemented: 'implemented',
+  partial: 'partial',
+  unavailable: 'unavailable',
+  fallback: 'fallback'
+});
+
+export const CoreSchemaSurfaces = Object.freeze(['feed', 'tree', 'detail', 'lineage', 'preview', 'share', 'graph']);
+export const CoreSchemaActions = Object.freeze(['read', 'validate', 'present', 'create', 'continue', 'reference', 'fallback', 'findings', 'i18n', 'degrade']);
+
+export function buildSchemaCapabilityRegistry(registry = schemaRegistry) {
+  const modules = normalizeRegistryModules(registry).map((module) => describeSchemaCapabilities(module));
+  const findings = validateSchemaCapabilityDescriptors(modules);
+  return {
+    schema: SCHEMA_CAPABILITY_REGISTRY_SCHEMA_ID,
+    modules,
+    counts: {
+      modules: modules.length,
+      implementedSurfaces: modules.reduce((sum, module) => sum + countByStatus(module.surfaces, CapabilityStatus.implemented), 0),
+      implementedActions: modules.reduce((sum, module) => sum + countByStatus(module.actions, CapabilityStatus.implemented), 0),
+      fallbackCapable: modules.filter((module) => module.actions.fallback?.status === CapabilityStatus.implemented).length,
+      findings: findings.length,
+      errors: findings.filter((finding) => finding.severity === 'error').length,
+      warnings: findings.filter((finding) => finding.severity === 'warning').length
+    },
+    status: findings.some((finding) => finding.severity === 'error') ? 'invalid' : findings.some((finding) => finding.severity === 'warning') ? 'degraded' : 'clean',
+    findings
+  };
+}
+
+export function resolveSchemaCapabilities(input = {}, options = {}) {
+  const resolution = resolveRegisteredSchemaModule({ schemaId: input.schemaId, checksum: input.checksum });
+  const descriptor = describeSchemaCapabilities(resolution.module, { resolution, unresolvedSchemaId: resolution.unresolvedSchemaId || input.schemaId || '' });
+  return {
+    schema: SCHEMA_CAPABILITY_RESOLUTION_SCHEMA_ID,
+    requested: {
+      schemaId: input.schemaId || '',
+      checksum: input.checksum || ''
+    },
+    status: resolution.status,
+    fallbackUsed: Boolean(resolution.fallbackUsed),
+    unresolvedSchemaId: resolution.unresolvedSchemaId || '',
+    descriptor,
+    capability: options.capability ? getCapability(descriptor, options.capability) : null
+  };
+}
+
+export function describeSchemaCapabilities(module = {}, context = {}) {
+  const capabilityInput = module.capabilities || {};
+  const surfaces = makeSurfaceCapabilityMap(module, capabilityInput);
+  const generation = qualifyArtifactCreationCapability(module, 'create-artifact');
+  const actions = makeActionCapabilityMap(module, capabilityInput);
+  const implementation = {
+    validate: typeof module.validate === 'function' || hasQualifiedCompiledValidation(module),
+    present: typeof module.present === 'function',
+    generation: generation.implementation?.state === 'implemented',
+    transitions: Boolean(module.transitions && (typeof module.transitions === 'function' || Object.keys(module.transitions || {}).length)),
+    findings: Boolean(module.findings),
+    i18n: Boolean(module.i18n)
+  };
+  const findings = validateSingleSchemaCapabilityDescriptor({ module, surfaces, actions, implementation, context });
+  const factory = buildSchemaFactoryDescriptor(module, { surfaces, actions, implementation, generation, fallback: normalizeFallbackPolicy(module, capabilityInput), findings });
+  return {
+    schema: SCHEMA_CAPABILITY_DESCRIPTOR_SCHEMA_ID,
+    moduleId: module.id || '',
+    label: module.label || module.id || 'Unknown schema module',
+    kind: module.kind || 'unknown',
+    role: module.role || '',
+    parentSchemaId: module.parentSchemaId || null,
+    binding: {
+      schemaId: module.binding?.schemaId || '',
+      checksum: module.binding?.checksum?.value || module.binding?.checksum || '',
+      sourcePath: module.binding?.sourcePath || '',
+      sourceRepository: module.binding?.sourceRepository || '',
+      sourceCommit: module.binding?.sourceCommit || '',
+      originTrustRole: module.binding?.originTrustRole || module.originTrustRole || ''
+    },
+    resolution: context.resolution ? {
+      status: context.resolution.status || '',
+      fallbackUsed: Boolean(context.resolution.fallbackUsed),
+      unresolvedSchemaId: context.unresolvedSchemaId || context.resolution.unresolvedSchemaId || ''
+    } : null,
+    surfaces,
+    actions,
+    implementation,
+    factory,
+    availability: summarizeAvailability({ surfaces, actions, findings }),
+    boundaries: normalizeStringList(capabilityInput.boundaries),
+    sourceAccess: normalizeStringList(capabilityInput.sourceAccess),
+    fallback: normalizeFallbackPolicy(module, capabilityInput),
+    findings
+  };
+}
+
+export function getCapability(descriptor = {}, capabilityName = '') {
+  const name = String(capabilityName || '').trim();
+  if (!name) return null;
+  return descriptor.actions?.[name] || descriptor.surfaces?.[name] || null;
+}
+
+export function validateSchemaCapabilityDescriptors(descriptors = []) {
+  const findings = [];
+  const seen = new Set();
+  for (const descriptor of Array.isArray(descriptors) ? descriptors : []) {
+    if (!descriptor.moduleId) findings.push(error('schema.capability.moduleId.missing', 'Schema capability descriptor is missing moduleId.'));
+    if (seen.has(descriptor.moduleId)) findings.push(error('schema.capability.moduleId.duplicate', `Duplicate schema capability descriptor for ${descriptor.moduleId}.`));
+    seen.add(descriptor.moduleId);
+    findings.push(...(descriptor.findings || []));
+  }
+  return findings;
+}
+
+function normalizeRegistryModules(registry = {}) {
+  if (Array.isArray(registry.modules)) return registry.modules;
+  return Array.from(registry.byId?.values?.() || []);
+}
+
+
+function hasQualifiedCompiledValidation(module = {}) {
+  const qualification = typeof module?.schemaSource?.qualify === 'function' ? module.schemaSource.qualify() : null;
+  return Boolean(qualification?.state === 'qualified' && qualification?.compiledContract?.validationContract?.lineageQualification?.state === 'valid');
+}
+
+function makeSurfaceCapabilityMap(module = {}, capabilities = {}) {
+  const explicit = new Set([
+    ...normalizeStringList(capabilities.supportedSurfaces),
+    ...normalizeStringList(capabilities.surfaces)
+  ]);
+  const surfaces = {};
+  for (const surface of CoreSchemaSurfaces) {
+    surfaces[surface] = capability(surface, explicit.has(surface) || (module.id === 'tiinex.root.v1' && surface !== 'graph'), explicit.has(surface) ? 'declared surface support' : 'core schema surface not declared');
+  }
+  for (const surface of explicit) {
+    if (!surfaces[surface]) surfaces[surface] = capability(surface, true, 'declared schema/module surface');
+  }
+  return freezeCapabilityMap(surfaces);
+}
+
+function makeActionCapabilityMap(module = {}, capabilities = {}) {
+  const declaredActions = new Set(normalizeStringList(capabilities.actions));
+  const actions = {};
+  actions.read = capability('read', Boolean(module.id && module.binding), 'registered module with binding');
+  actions.validate = capability('validate', typeof module.validate === 'function' || hasQualifiedCompiledValidation(module), typeof module.validate === 'function' ? 'schema-specific validation implementation' : 'qualified compiled schema validation contract');
+  actions.present = capability('present', typeof module.present === 'function', 'presentation implementation');
+  const explicitWorkspaceCreate = declaredActions.has('create-workspace');
+  actions.create = capability('create', explicitWorkspaceCreate, explicitWorkspaceCreate
+    ? 'explicit non-artifact workspace action authority'
+    : 'invocable artifact creation requires separately qualified canonical Transition Definition applicability; Artifact Creation Contract authority alone is generation authority');
+  actions.continue = capability('continue', false, 'canonical Transition Definition owns Continue applicability; companion transition metadata is non-authoritative');
+  actions.reference = capability('reference', false, 'canonical Transition Definition owns Reference applicability; companion transition metadata is non-authoritative');
+  actions.fallback = capability('fallback', capabilities.canRenderFallback === true || Boolean(capabilities.fallback) || module.id === 'tiinex.root.v1', 'fallback policy');
+  actions.findings = capability('findings', Boolean(module.findings), 'findings companion');
+  actions.i18n = capability('i18n', Boolean(module.i18n), 'i18n companion');
+  actions.degrade = capability('degrade', actions.fallback.status === CapabilityStatus.implemented || typeof module.present === 'function', 'degraded projection via presenter/fallback');
+
+  for (const action of declaredActions) {
+    if (!actions[action]) actions[action] = capability(action, true, 'declared schema action');
+  }
+  return freezeCapabilityMap(actions);
+}
+
+function capability(name, supported, reason) {
+  return Object.freeze({ name, status: supported ? CapabilityStatus.implemented : CapabilityStatus.unavailable, reason });
+}
+
+function freezeCapabilityMap(map) {
+  return Object.freeze(Object.fromEntries(Object.entries(map).sort(([a], [b]) => a.localeCompare(b))));
+}
+
+function normalizeStringList(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map((item) => String(item || '').trim()).filter(Boolean);
+  return [String(value).trim()].filter(Boolean);
+}
+
+function normalizeFallbackPolicy(module = {}, capabilities = {}) {
+  if (module.id === 'tiinex.root.v1') return { status: CapabilityStatus.implemented, mode: 'root-envelope-display' };
+  if (capabilities.canRenderFallback === true) return { status: CapabilityStatus.implemented, mode: 'module-fallback' };
+  if (capabilities.fallback) return { status: CapabilityStatus.implemented, mode: String(capabilities.fallback) };
+  return { status: CapabilityStatus.fallback, mode: 'root-fallback-available-through-registry' };
+}
+
+function summarizeAvailability({ surfaces = {}, actions = {}, findings = [] }) {
+  const hasErrors = findings.some((finding) => finding.severity === 'error');
+  const implementedActions = countByStatus(actions, CapabilityStatus.implemented);
+  const implementedSurfaces = countByStatus(surfaces, CapabilityStatus.implemented);
+  if (hasErrors) return 'invalid';
+  if (implementedActions >= 3 && implementedSurfaces >= 1) return 'implemented';
+  if (implementedActions || implementedSurfaces) return 'partial';
+  return 'unavailable';
+}
+
+function countByStatus(map = {}, status = CapabilityStatus.implemented) {
+  return Object.values(map || {}).filter((entry) => entry?.status === status).length;
+}
+
+function validateSingleSchemaCapabilityDescriptor({ module = {}, surfaces = {}, actions = {}, implementation = {}, context = {} }) {
+  const findings = [];
+  if (!module.id) findings.push(error('schema.capability.id.missing', 'Schema module is missing id.'));
+  if (!module.binding?.schemaId) findings.push(error('schema.capability.binding.schemaId.missing', `${module.id || 'unknown module'} is missing binding.schemaId.`));
+  if (!module.binding?.checksum?.value && !module.binding?.checksum) findings.push(error('schema.capability.binding.checksum.missing', `${module.id || 'unknown module'} is missing binding checksum.`));
+  if (!implementation.validate) findings.push(warning('schema.capability.validate.missing', `${module.id || 'unknown module'} has no validate implementation.`));
+  if (!implementation.present) findings.push(warning('schema.capability.present.missing', `${module.id || 'unknown module'} has no presenter implementation.`));
+  if (module.id !== 'tiinex.root.v1' && actions.fallback?.status !== CapabilityStatus.implemented) {
+    findings.push(info('schema.capability.rootFallback.available', `${module.id || 'unknown module'} relies on root fallback when its own module is unavailable.`));
+  }
+  if (context.resolution?.fallbackUsed) {
+    findings.push(warning('schema.capability.rootFallback.used', `Requested schema ${context.unresolvedSchemaId || context.resolution.unresolvedSchemaId || 'unknown'} resolved through root fallback.`));
+  }
+  if (!Object.values(surfaces).some((surface) => surface.status === CapabilityStatus.implemented)) findings.push(warning('schema.capability.surface.none', `${module.id || 'unknown module'} declares no implemented surfaces.`));
+  return findings;
+}
+
+function finding(severity, code, message) { return { severity, code, message, source: SCHEMA_CAPABILITY_REGISTRY_SCHEMA_ID }; }
+function error(code, message) { return finding('error', code, message); }
+function warning(code, message) { return finding('warning', code, message); }
+function info(code, message) { return finding('info', code, message); }

package/src/schemas/companion.js

@@ -0,0 +1,245 @@
+import { parseArtifactMarkdown } from '../artifacts/artifact.parse.js';
+import { schemaIdForRecord } from './schema.identity.js';
+import { presentRecordActions, RecordActionKind } from '../actions/record.actions.js';
+import { resolveSchemaModule, schemaRegistry } from './registry.js';
+
+export const SCHEMA_COMPANION_CONTRACT_ID = 'tiinex.web.schema-companion.v1';
+
+const DEFAULT_READ_SECTIONS = Object.freeze(['Artifact Body', 'Summary', 'Content']);
+const DEFAULT_LINEAGE_ACTIONS = Object.freeze([
+  RecordActionKind.open,
+  RecordActionKind.markdown,
+  RecordActionKind.continue,
+  RecordActionKind.reference,
+  RecordActionKind.source
+]);
+
+export function companionForRecord(record = {}) {
+  const schemaId = schemaIdForRecord(record);
+  return resolveSchemaModule({ schemaId }) || schemaRegistry.fallback;
+}
+
+export function schemaReadPresentation(record = {}, options = {}) {
+  const parsed = parseRecordMarkdown(record);
+  const schema = schemaIdForRecord(record, { markdown: record.markdown || parsed?.body?.text || '' }) || String(parsed?.envelope?.current?.schema?.id || '').trim();
+  const exactCompanion = Boolean(schema && schemaRegistry.byId?.has(schema));
+  const companion = companionForRecord({ ...record, schemaId: schema });
+  const read = companion?.read || {};
+  const sections = extractMarkdownSections(parsed.body?.text || record.markdown || '');
+  const bodyAvailable = Boolean(String(record.markdown || parsed.body?.text || '').trim());
+  const fallbackUsed = Boolean(schema && !exactCompanion);
+  const readState = classifyReadState({ schema, companion, exactCompanion, fallbackUsed, bodyAvailable });
+  const schemaCoverage = classifySchemaCoverage({ schema, exactCompanion, fallbackUsed });
+  const bodyAvailability = bodyAvailable ? 'available' : 'unavailable-body';
+  const picked = fallbackUsed
+    ? rootFallbackReadSections({ parsed, record, schema, sections, options })
+    : schemaOwnedReadSections({ parsed, record, schema, sections, read, options });
+  const maxSections = Number(options.maxSections || 0);
+  const visibleSections = maxSections > 0 ? picked.slice(0, maxSections) : picked;
+  return {
+    schema,
+    companionId: companion?.id || 'tiinex.root.v1',
+    contract: SCHEMA_COMPANION_CONTRACT_ID,
+    label: fallbackUsed ? 'Root fallback' : (read.label || companion?.label || displaySchemaLabel(schema)),
+    title: record.title || parsed.title || 'Untitled artifact',
+    summary: record.summary || parsed.envelope?.current?.summary || '',
+    sections: visibleSections,
+    readMode: fallbackUsed ? 'root-fallback' : 'schema-owned',
+    readState,
+    schemaCoverage,
+    bodyAvailability,
+    fallbackUsed,
+    exactCompanion
+  };
+}
+
+export function classifyReadState({ schema = '', companion = null, exactCompanion = false, fallbackUsed = false, bodyAvailable = false } = {}) {
+  if (!bodyAvailable) return 'unavailable-body';
+  if (fallbackUsed) return 'root-fallback';
+  if (exactCompanion && (companion?.id === 'tiinex.root.v1' || String(schema || '') === 'tiinex.root.v1')) return 'root-readable';
+  if (exactCompanion) return 'schema-owned';
+  return 'unknown-schema';
+}
+
+export function classifySchemaCoverage({ schema = '', exactCompanion = false, fallbackUsed = false } = {}) {
+  if (!schema) return 'missing-schema';
+  if (fallbackUsed || !exactCompanion) return 'unknown-schema';
+  return 'exact-companion';
+}
+
+function schemaOwnedReadSections({ parsed, record, schema, sections, read, options }) {
+  const wanted = Array.isArray(read.sections) && read.sections.length ? read.sections : DEFAULT_READ_SECTIONS;
+  const picked = [];
+  for (const label of wanted) {
+    const value = sectionValueByName(sections, label);
+    if (value) picked.push({ label: displaySectionLabel(label), value: trimReadValue(value, options) });
+  }
+  if (!picked.length) {
+    for (const [label, value] of sections.entries()) {
+      if (isEnvelopeSection(label)) continue;
+      if (options.compact && isRedundantIdentitySection(label, value, record, read)) continue;
+      if (picked.length >= (options.compact ? 2 : 5)) break;
+      picked.push({ label: displaySectionLabel(label), value: trimReadValue(value, options) });
+    }
+  }
+  if (!picked.length && parsed.body?.text) picked.push({ label: 'Artifact body', value: trimReadValue(stripEnvelopeSectionText(parsed.body.text), options) });
+  return picked.filter((section) => String(section.value || '').trim());
+}
+
+function rootFallbackReadSections({ parsed, record, schema, sections, options }) {
+  const envelope = parsed.envelope || {};
+  const current = envelope.current || {};
+  const parent = envelope.parent || {};
+  const currentLines = compactLines([
+    schema ? `Schema: ${schema}` : '',
+    current.createdAt || record.currentCreatedAt ? `Created: ${current.createdAt || record.currentCreatedAt}` : '',
+    current.status || record.lifecycleStatus || record.status ? `Status: ${current.status || record.lifecycleStatus || record.status}` : '',
+    current.summary || record.summary ? `Summary: ${current.summary || record.summary}` : ''
+  ]);
+  const continuityLines = compactLines([
+    parent.schema?.id || record.parentSchemaId ? `Parent schema: ${parent.schema?.id || record.parentSchemaId}` : '',
+    parent.trace || record.trace ? `Trace: ${parent.trace || record.trace}` : '',
+    parent.origin || record.origin ? `Origin: ${parent.origin || record.origin}` : '',
+    parent.boundary || record.boundary ? `Boundary: ${parent.boundary || record.boundary}` : ''
+  ]);
+  const picked = [];
+  if (currentLines) picked.push({ label: 'Fallback status', value: trimReadValue(`Root fallback preserves ${schema || 'this schema'} because no exact schema-owned read companion is registered yet.\n${currentLines}`, options) });
+  if (continuityLines) picked.push({ label: 'Continuity', value: trimReadValue(continuityLines, options) });
+  const bodySections = Array.from(sections.entries()).filter(([label, value]) => !isEnvelopeSection(label) && !isRedundantIdentitySection(label, value, record, {}));
+  for (const [label, value] of bodySections) {
+    if (picked.length >= (options.compact ? 2 : 5)) break;
+    picked.push({ label: displaySectionLabel(label), value: trimReadValue(value, options) });
+  }
+  if (picked.length < (options.compact ? 2 : 5)) {
+    const body = stripEnvelopeSectionText(parsed.body?.text || record.markdown || '');
+    if (body && !picked.some((section) => section.value === body)) picked.push({ label: 'Readable body', value: trimReadValue(body, options) });
+  }
+  return picked.filter((section) => String(section.value || '').trim());
+}
+
+export function schemaReadSummaryItems(record = {}, limit = 2) {
+  const presentation = schemaReadPresentation(record, { compact: true, lineClamp: true });
+  return (presentation.sections || []).slice(0, limit).map((section) => ({
+    label: section.label,
+    value: trimReadValue(section.value, { compact: true }).replace(/\s+/g, ' ')
+  })).filter((section) => section.value);
+}
+
+export function schemaLineageActions(record = {}, context = {}) {
+  const companion = companionForRecord(record);
+  const allowed = companion?.viewActions?.lineage || companion?.viewActions?.default || DEFAULT_LINEAGE_ACTIONS;
+  const allowedSet = new Set(allowed);
+  return presentRecordActions(record).filter((action) => {
+    if (action.enabled === false) return false;
+    if (!allowedSet.has(action.id)) return false;
+    if (context.hideShare !== false && action.id === RecordActionKind.share) return false;
+    return true;
+  });
+}
+
+export function schemaCanonicalBinding(record = {}) {
+  const companion = companionForRecord(record);
+  const binding = companion?.binding || {};
+  return {
+    schemaId: companion?.id || schemaIdForRecord(record),
+    label: companion?.label || displaySchemaLabel(companion?.id || schemaIdForRecord(record)),
+    sourcePath: binding.sourcePath || '',
+    permalink: binding.permalink || '',
+    snapshot: binding.snapshot || '',
+    originTrustRole: binding.originTrustRole || 'canonical-core'
+  };
+}
+
+function parseRecordMarkdown(record = {}) {
+  try { return parseArtifactMarkdown(record.markdown || ''); }
+  catch (error) { return { title: record.title || '', envelope: {}, body: { text: record.markdown || '' } }; }
+}
+
+
+function extractMarkdownSections(markdown = '') {
+  const text = String(markdown || '').replace(/\r\n?/g, '\n').trim();
+  const map = new Map();
+  if (!text) return map;
+  const lines = text.split('\n');
+  let current = '';
+  let buffer = [];
+  const flush = () => {
+    if (!current) return;
+    const value = buffer.join('\n').trim();
+    if (value) map.set(current, value);
+  };
+  for (const line of lines) {
+    const match = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+    if (match) {
+      flush();
+      current = match[2].trim();
+      buffer = [];
+    } else if (current) {
+      buffer.push(line);
+    }
+  }
+  flush();
+  return map;
+}
+
+function sectionValueByName(sections = new Map(), label = '') {
+  const exact = sections.get(label);
+  if (exact) return exact;
+  const wanted = normalizeSectionName(label);
+  for (const [key, value] of sections.entries()) {
+    if (normalizeSectionName(key) === wanted) return value;
+  }
+  return '';
+}
+
+function normalizeSectionName(value = '') {
+  return String(value || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+}
+
+function displaySectionLabel(label = '') {
+  return String(label || '').replace(/\s+/g, ' ').trim().toUpperCase();
+}
+
+function displaySchemaLabel(schemaId = '') {
+  return String(schemaId || 'artifact').replace(/^tiinex\./, '').replace(/\.v\d+$/, '').replace(/[._-]+/g, ' ');
+}
+
+function isEnvelopeSection(label = '') {
+  return /^(continuity context|continuity integrity)$/i.test(String(label || '').trim());
+}
+
+function compactLines(lines = []) {
+  return lines.filter(Boolean).map((line) => `- ${line}`).join('\n');
+}
+
+function stripEnvelopeSectionText(text = '') {
+  const sections = extractMarkdownSections(text);
+  const kept = [];
+  for (const [label, value] of sections.entries()) {
+    if (isEnvelopeSection(label)) continue;
+    if (!String(value || '').trim()) continue;
+    kept.push(`## ${label}\n\n${value}`);
+  }
+  if (kept.length) return kept.join('\n\n');
+  return String(text || '').replace(/^#\s+Continuity Context[\s\S]*?(?=^#\s+|\Z)/m, '').replace(/^#\s+Continuity Integrity[\s\S]*?(?=^#\s+|\Z)/m, '').trim();
+}
+
+function trimReadValue(value = '', options = {}) {
+  const text = String(value || '').trim();
+  const max = options.compact ? 520 : 1800;
+  const clipped = text.length > max ? `${text.slice(0, max).trim()}\n…` : text;
+  if (!options.lineClamp) return clipped;
+  return clipped.split('\n').slice(0, options.compact ? 7 : 18).join('\n');
+}
+
+function isRedundantIdentitySection(label = '', value = '', record = {}, read = {}) {
+  const normalized = normalizeSectionName(label);
+  if (normalized === 'root') return true;
+  const title = normalizeSectionName(record.title || '');
+  const summary = normalizeSectionName(record.summary || '');
+  const body = normalizeSectionName(value).slice(0, 240);
+  if (title && body.startsWith(title) && summary && body.includes(summary.slice(0, 80))) return true;
+  const redundant = new Set((Array.isArray(read?.redundantIdentitySections) ? read.redundantIdentitySections : []).map(normalizeSectionName));
+  if (redundant.has(normalized)) return true;
+  return false;
+}

package/src/schemas/contracts.js

@@ -0,0 +1,6 @@
+export const SchemaKind = Object.freeze({ abstract: 'abstract', concrete: 'concrete', structural: 'structural' });
+
+export function defineSchemaModule(module) {
+  if (!module || !module.id || !module.kind) throw new Error('Invalid schema module');
+  return Object.freeze(module);
+}

package/src/schemas/coordination/handoff/tiinex.handoff.v1.schema.js

@@ -0,0 +1,14 @@
+import binding from './tiinex.handoff.v1.schema.json' with { type: 'json' };
+import { schemaSource } from './tiinex.handoff.v1.schema.source.js';
+import { defineGenericArtifactSchemaModule } from '../../generic.artifact.module.js';
+
+export const handoffSchemaModule = defineGenericArtifactSchemaModule({
+  id: 'tiinex.handoff.v1',
+  label: 'Handoff',
+  parentSchemaId: 'tiinex.root.v1',
+  kind: 'concrete',
+  role: 'workflow-handoff-artifact',
+  summary: 'Maintained declarative bounded work/responsibility transfer artifact.',
+  binding,
+  schemaSource
+});

package/src/schemas/coordination/handoff/tiinex.handoff.v1.schema.json

@@ -0,0 +1,23 @@
+{
+  "schemaId": "tiinex.handoff.v1",
+  "kind": "concrete",
+  "role": "workflow-handoff-artifact",
+  "module": "./tiinex.handoff.v1.schema.js",
+  "snapshot": "./tiinex.handoff.v1.schema.md",
+  "canonicalUri": "tiinex://schemas/coordination/handoff/tiinex.handoff.v1",
+  "permalink": "https://github.com/Tiinex/docs/blob/3988951208eb9a8926e84ab42625d4b42fa00c2d/.topics/.schemas/coordination/handoff/tiinex.handoff.v1.schema.md",
+  "rawUrl": "https://raw.githubusercontent.com/Tiinex/docs/3988951208eb9a8926e84ab42625d4b42fa00c2d/.topics/.schemas/coordination/handoff/tiinex.handoff.v1.schema.md",
+  "sourcePath": ".topics/.schemas/coordination/handoff/tiinex.handoff.v1.schema.md",
+  "sourceRepository": "Tiinex/docs",
+  "sourceCommit": "3988951208eb9a8926e84ab42625d4b42fa00c2d",
+  "sourceBlobSha": "2332023aecf690279805d34c7e512a9f9799c20d",
+  "checksum": {
+    "algorithm": "sha256",
+    "value": "2b936616989fbab2bcc8d1e6e4175369546cea5adffd5c9c9db236bc2340ef06"
+  },
+  "capabilityContract": "tiinex.schema.module.v1",
+  "snapshotCompleteness": "exact-canonical-docs-snapshot",
+  "bindingVersion": "tiinex.web.schema-binding.v1",
+  "originId": "tiinex-docs-39889512",
+  "originTrustRole": "canonical-core"
+}