@tiinex/core 0.1.1

package/src/tooling/portable/lifecycle/lifecycle.material.js

@@ -0,0 +1,173 @@
+import { resolveLineage } from '../../../lineage/lineage.resolve.js';
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+import { auditPortableRecord } from '../audit/audit.capability.js';
+import { normalizePortableInput } from '../input/portable.input.js';
+
+const QUALIFIED_PARENT_STATUSES = new Set(['verified', 'resolved']);
+const MAX_OBLIGATIONS = 64;
+
+export function prepareLifecycleMaterial(input = {}, options = {}) {
+  const material = normalizePortableInput(input.materials || input);
+  const records = [...(material.records || [])];
+  const index = recordIndex(records);
+  const requested = String(input.controllingTask || input.task || options.controllingTask || '').trim();
+  const taskResolution = resolveUniqueRecord(records, requested);
+  const task = taskResolution.record;
+  const auditCache = new Map();
+  const qualification = task ? qualifyRecord(task, auditCache) : unresolvedQualification(taskResolution.state);
+  const criteria = task ? taskCriteria(task) : Object.freeze({ state: 'unresolved', sections: Object.freeze([]), basis: '' });
+  const lineage = resolveLineage(records, { depth: 'portable-lifecycle-readiness' });
+  const automatic = task && qualification.state === 'qualified'
+    ? directTaskObligations(task, records, lineage, auditCache)
+    : [];
+  const explicit = explicitWorkObligations(input.workObligations || input.obligations || [], records, auditCache);
+  const obligations = dedupeObligations([...automatic, ...explicit]);
+  const overflow = obligations.length > MAX_OBLIGATIONS;
+  const bounded = obligations.slice(0, MAX_OBLIGATIONS);
+
+  return Object.freeze({
+    material,
+    records: Object.freeze(records),
+    index,
+    auditCache,
+    lineage,
+    controllingTask: Object.freeze({
+      requested,
+      state: task && qualification.state === 'qualified' && criteria.state === 'qualified' ? 'qualified' : 'unresolved',
+      resolutionState: taskResolution.state,
+      record: task ? identity(task) : null,
+      qualification,
+      criteria
+    }),
+    obligations: Object.freeze(bounded),
+    obligationsOmitted: overflow ? obligations.length - MAX_OBLIGATIONS : 0,
+    lineageIssues: Object.freeze(relevantLineageIssues(lineage, new Set([task?.id, ...bounded.map((item) => item.task?.id)].filter(Boolean)))),
+    findings: Object.freeze([...(material.findings || []), ...(lineage.findings || [])]),
+    boundary: Object.freeze({
+      automaticWorkScope: 'direct qualified tiinex.task.v1 Parent continuity only',
+      typedWorkScope: 'explicit normalized workObligations whose semanticState is qualified; arbitrary Relation Type text is not interpreted here',
+      currentness: 'not inferred from filenames, timestamps, Root Status, lexical lifecycleStatus/currentStatus, branch state, or file absence',
+      maxObligations: MAX_OBLIGATIONS
+    })
+  });
+}
+
+export function qualifyRecord(record = {}, cache = new Map()) {
+  const key = String(record.id || record.path || '');
+  if (cache.has(key)) return cache.get(key);
+  const audit = auditPortableRecord(record);
+  const errors = (audit.findings || []).filter((item) => item.severity === 'error');
+  const qualified = Boolean(record.hasContinuityContext && record.hasIntegrity && audit.qualification?.exact && !errors.length);
+  const result = Object.freeze({
+    state: qualified ? 'qualified' : 'unresolved',
+    exact: qualified,
+    schemaId: String(record.schemaId || ''),
+    auditStatus: String(audit.status || ''),
+    findingCodes: Object.freeze(errors.map((item) => String(item.code || '')).filter(Boolean))
+  });
+  cache.set(key, result);
+  return result;
+}
+
+export function resolveFactRecord(material = {}, requested = '') {
+  const resolution = resolveUniqueRecord(material.records || [], requested);
+  if (!resolution.record) return Object.freeze({ state: resolution.state, record: null, qualification: unresolvedQualification(resolution.state) });
+  return Object.freeze({ state: resolution.state, record: resolution.record, qualification: qualifyRecord(resolution.record, material.auditCache) });
+}
+
+function taskCriteria(record = {}) {
+  let parsed;
+  try { parsed = parseArtifactMarkdown(record.markdown || ''); } catch { return Object.freeze({ state: 'unresolved', sections: Object.freeze([]), basis: 'parse-failed' }); }
+  const text = String(parsed.body?.text || '');
+  const names = ['Done Criteria', 'Acceptance Criteria'];
+  const sections = names.map((name) => ({ name, text: section(text, name) })).filter((item) => item.text);
+  return Object.freeze({
+    state: String(record.schemaId || '') === 'tiinex.task.v1' && sections.length ? 'qualified' : 'unresolved',
+    sections: Object.freeze(sections.map((item) => Object.freeze({ name: item.name, text: compact(item.text, 360) }))),
+    basis: sections.length ? 'qualified controlling Task criteria section(s)' : 'no Done Criteria or Acceptance Criteria section is available'
+  });
+}
+
+function directTaskObligations(task, records, lineage, auditCache) {
+  const byId = new Map(records.map((record) => [String(record.id || record.path || ''), record]));
+  const out = [];
+  for (const edge of lineage.edges || []) {
+    if (edge.kind !== 'parent' || edge.from !== task.id || !edge.to) continue;
+    const child = byId.get(String(edge.to));
+    if (!child || String(child.schemaId || '') !== 'tiinex.task.v1') continue;
+    const childQualification = qualifyRecord(child, auditCache);
+    const edgeQualified = QUALIFIED_PARENT_STATUSES.has(String(edge.status || '')) && childQualification.state === 'qualified';
+    out.push(Object.freeze({
+      id: `task-continuity:${child.id}`,
+      state: edgeQualified ? 'qualified' : 'unresolved',
+      kind: 'task-continuity',
+      task: identity(child),
+      relation: Object.freeze({ kind: 'parent', state: edgeQualified ? 'qualified' : 'unresolved', status: String(edge.status || ''), from: String(edge.from || ''), to: String(edge.to || ''), target: String(edge.target || '') }),
+      basis: 'direct qualified Task Parent continuity; Parent is not generalized beyond this Task-to-Task edge'
+    }));
+  }
+  return out;
+}
+
+function explicitWorkObligations(values = [], records = [], auditCache = new Map()) {
+  const list = Array.isArray(values) ? values : [];
+  return list.map((value, index) => {
+    const taskResolution = resolveUniqueRecord(records, value.task || value.path || value.source || '');
+    const task = taskResolution.record;
+    const taskQualification = task ? qualifyRecord(task, auditCache) : unresolvedQualification(taskResolution.state);
+    const semanticState = String(value.semanticState || value.state || 'unresolved');
+    const qualified = Boolean(task && taskQualification.state === 'qualified' && String(task.schemaId || '') === 'tiinex.task.v1' && semanticState === 'qualified' && nonEmptyBasis(value.basis));
+    return Object.freeze({
+      id: String(value.id || `explicit-work:${index + 1}:${task?.id || value.task || value.path || 'unresolved'}`),
+      state: qualified ? 'qualified' : 'unresolved',
+      kind: 'declared-typed-work',
+      task: task ? identity(task) : Object.freeze({ id: '', path: String(value.task || value.path || ''), schemaId: '' }),
+      relation: Object.freeze({ kind: 'declared-typed-work', state: qualified ? 'qualified' : 'unresolved', semanticState, predicate: String(value.predicate || value.relationType || ''), basis: compactBasis(value.basis) }),
+      basis: qualified ? 'explicit upstream-qualified typed work/provenance semantic fact' : 'typed work/provenance meaning or target qualification is unresolved'
+    });
+  });
+}
+
+function dedupeObligations(values = []) {
+  const byTask = new Map();
+  for (const value of values) {
+    const key = String(value.task?.id || value.task?.path || value.id || '');
+    const current = byTask.get(key);
+    if (!current || (current.state !== 'qualified' && value.state === 'qualified')) byTask.set(key, value);
+  }
+  return [...byTask.values()];
+}
+
+function relevantLineageIssues(lineage = {}, ids = new Set()) {
+  const issues = [];
+  for (const edge of lineage.edges || []) {
+    if (edge.kind !== 'parent' || !ids.has(edge.to)) continue;
+    if (!edge.from || ['missing', 'mismatch', 'ambiguous', 'degraded'].includes(String(edge.status || ''))) issues.push(Object.freeze({ code: `lineage.parent.${edge.status || 'missing'}`, nodeId: String(edge.to || ''), target: String(edge.target || ''), status: String(edge.status || '') }));
+  }
+  for (const finding of lineage.findings || []) {
+    if (!ids.has(String(finding.nodeId || ''))) continue;
+    if (/ambiguous|missing|mismatch|outOfBoundary/i.test(String(finding.code || ''))) issues.push(Object.freeze({ code: String(finding.code || ''), nodeId: String(finding.nodeId || ''), target: String(finding.target || ''), status: 'unresolved' }));
+  }
+  return uniqueBy(issues, (item) => `${item.code}|${item.nodeId}|${item.target}`);
+}
+
+function resolveUniqueRecord(records = [], requested = '') {
+  const wanted = normalizePath(requested);
+  if (!wanted) return { state: 'missing', record: null };
+  const exact = records.filter((record) => normalizePath(record.path) === wanted || String(record.id || '') === requested);
+  if (exact.length === 1) return { state: 'exact', record: exact[0] };
+  if (exact.length > 1) return { state: 'ambiguous', record: null };
+  const suffix = records.filter((record) => normalizePath(record.path).endsWith(`/${wanted}`));
+  return suffix.length === 1 ? { state: 'suffix', record: suffix[0] } : { state: suffix.length > 1 ? 'ambiguous' : 'missing', record: null };
+}
+
+function recordIndex(records = []) { const map = new Map(); for (const record of records) map.set(String(record.id || record.path || ''), record); return map; }
+function identity(record = {}) { return Object.freeze({ id: String(record.id || record.path || ''), path: String(record.path || ''), title: String(record.title || ''), schemaId: String(record.schemaId || '') }); }
+function unresolvedQualification(reason = '') { return Object.freeze({ state: 'unresolved', exact: false, schemaId: '', auditStatus: '', findingCodes: Object.freeze(reason ? [String(reason)] : []) }); }
+function section(text = '', name = '') { const e = escape(name); return String(text).match(new RegExp(`(?:^|\\n)##\\s+${e}\\s*\\r?\\n([\\s\\S]*?)(?=\\n##\\s+|$)`, 'i'))?.[1]?.trim() || ''; }
+function compact(value = '', limit = 360) { const text = String(value || '').replace(/\s+/g, ' ').trim(); return text.length > limit ? `${text.slice(0, limit - 1).trimEnd()}…` : text; }
+function compactBasis(value) { return Array.isArray(value) ? Object.freeze(value.map((item) => typeof item === 'string' ? compact(item, 180) : Object.freeze({ ...item })).slice(0, 8)) : typeof value === 'string' ? compact(value, 360) : value && typeof value === 'object' ? Object.freeze({ ...value }) : null; }
+function nonEmptyBasis(value) { return Array.isArray(value) ? value.length > 0 : typeof value === 'string' ? Boolean(value.trim()) : Boolean(value && typeof value === 'object' && Object.keys(value).length); }
+function normalizePath(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '').trim(); }
+function escape(value = '') { return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+function uniqueBy(values, keyFn) { const seen = new Set(); return values.filter((value) => { const key = keyFn(value); if (seen.has(key)) return false; seen.add(key); return true; }); }

package/src/tooling/portable/lifecycle/lifecycle.operations.js

@@ -0,0 +1,34 @@
+import { portableOperationResult as operationResult } from '../operation.result.js';
+import { projectPortableLifecycleReadiness } from './lifecycle.readiness.js';
+
+export function projectPortableLifecycleReadinessOperation(input = {}, options = {}) {
+  const projection = projectPortableLifecycleReadiness(input, options);
+  return operationResult('project-lifecycle-readiness', {
+    status: projection.status,
+    resultSchema: projection.schema,
+    controllingTask: projection.controllingTask,
+    readiness: projection.readiness,
+    retest: projection.retest,
+    closure: projection.closure,
+    currentRepresentatives: projection.currentRepresentatives,
+    blockers: projection.blockers,
+    missingEvidence: projection.missingEvidence,
+    ambiguities: projection.ambiguities,
+    authorityBasis: projection.authorityBasis,
+    nextAction: projection.nextAction,
+    boundary: projection.boundary,
+    findings: projection.findings || []
+  });
+}
+
+export const portableLifecycleOperationDescriptors = Object.freeze([
+  Object.freeze({
+    name: 'project-lifecycle-readiness',
+    description: 'Project one exact controlling Task into separate derived readiness, authoritative re-test, and explicit closure surfaces from qualified Task continuity plus explicit normalized currentness/authority evidence, failing closed on ambiguity.',
+    safety: 'read-only-projection',
+    inputSchema: 'tiinex.portable.lifecycle-readiness.request.v1',
+    sourceMutation: false,
+    remoteWrite: false,
+    handler: projectPortableLifecycleReadinessOperation
+  })
+]);

package/src/tooling/portable/lifecycle/lifecycle.readiness.js

@@ -0,0 +1,247 @@
+import { portableFinding, summarizePortableFindings } from '../findings.js';
+import { prepareLifecycleMaterial, resolveFactRecord } from './lifecycle.material.js';
+import { nextLifecycleAction } from './lifecycle.action.js';
+
+export const PORTABLE_LIFECYCLE_READINESS_SCHEMA_ID = 'tiinex.portable.lifecycle-readiness.v1';
+const VALID_REP_STATES = new Set(['resolved', 'active', 'blocked', 'unresolved']);
+const VALID_RETEST = new Set(['passed', 'failed']);
+const MAX_FACTS = 96;
+
+export function projectPortableLifecycleReadiness(input = {}, options = {}) {
+  const material = prepareLifecycleMaterial(input, options);
+  const facts = normalizedFacts(input);
+  const missingEvidence = [];
+  const ambiguities = [];
+  const blockers = [];
+  const task = material.controllingTask;
+
+  if (task.state !== 'qualified') missingEvidence.push(issue('controlling-task-unqualified', 'The exact controlling Task and its completion/acceptance criteria must qualify before readiness can be projected.'));
+  if (material.obligationsOmitted) ambiguities.push(issue('obligation-set-over-bounded-limit', `${material.obligationsOmitted} required work obligation(s) exceed the bounded evaluator limit.`));
+  if (material.lineageIssues.length) ambiguities.push(...material.lineageIssues.map((item) => issue(item.code, `Relevant Parent lineage remains ${item.status || 'unresolved'} for ${item.nodeId || item.target || 'work evidence'}.`)));
+
+  const authority = criteriaAuthority(facts.authority);
+  if (authority.state !== 'qualified') missingEvidence.push(issue('criteria-authority-unresolved', 'The authority that owns the controlling criteria is not explicitly qualified.'));
+
+  const representativeProjection = projectRepresentatives(material, facts.representatives, missingEvidence, ambiguities, blockers);
+  const blockerProjection = projectBlockers(material, facts.blockers, ambiguities, blockers);
+  const inputProjection = projectRetestInputs(facts.retestInputs, missingEvidence, ambiguities, blockers);
+  const retest = projectRetest(material, facts.retests, authority);
+  if (retest.state === 'unresolved') ambiguities.push(...retest.ambiguities);
+  const closure = projectClosure(material, facts.closures, authority, retest);
+  if (closure.state === 'unresolved') ambiguities.push(...closure.ambiguities);
+
+  const readiness = readinessProjection({ material, retest, closure, missingEvidence, ambiguities, blockers });
+  const nextAction = nextLifecycleAction({ readiness, retest, closure, blockers, missingEvidence, ambiguities, controllingTask: task.record });
+  const findings = Object.freeze([
+    ...(material.findings || []),
+    ...missingEvidence.map((item) => portableFinding('warning', `portable.lifecycle.${item.code}`, item.detail, { ref: task.record?.path || task.requested || '' })),
+    ...ambiguities.map((item) => portableFinding('warning', `portable.lifecycle.${item.code}`, item.detail, { ref: task.record?.path || task.requested || '' }))
+  ]);
+
+  return Object.freeze({
+    schema: PORTABLE_LIFECYCLE_READINESS_SCHEMA_ID,
+    status: closure.state === 'closed' || (task.state === 'qualified' && readiness.state !== 'unresolved' && retest.state !== 'unresolved' && closure.state !== 'unresolved') ? 'qualified-projection' : 'unresolved',
+    controllingTask: Object.freeze({ state: task.state, requested: task.requested, record: task.record, criteria: task.criteria }),
+    readiness,
+    retest,
+    closure,
+    currentRepresentatives: representativeProjection.current,
+    blockers: Object.freeze(blockers),
+    missingEvidence: Object.freeze(missingEvidence),
+    ambiguities: Object.freeze(ambiguities),
+    authorityBasis: authority,
+    nextAction,
+    findingSummary: summarizePortableFindings(findings),
+    findings,
+    boundary: Object.freeze({
+      adapterNeutral: true,
+      sharedConsumers: Object.freeze(['CLI', 'LLM', 'Viewer', 'VS Code']),
+      projectionOnly: true,
+      canonicalArtifactTruthPersisted: false,
+      canonicalSchemaVocabularyChanged: false,
+      parentMeaning: 'direct Task continuity only where exact qualified Task-to-Task Parent evidence exists',
+      semanticFacts: 'representative/currentness/blocker/re-test/closure/authority facts must arrive as explicit upstream-qualified normalized evidence; free prose and lexical lifecycle tokens are not interpreted as authority',
+      reductionMeaning: 'Reduction may satisfy only representative/re-test-input availability within explicit normalized carry-forward/loss facts; Reduction existence is never completion proof',
+      destructiveReduction: false,
+      remoteWrite: false,
+      sourceMutation: false
+    })
+  });
+}
+
+function projectRepresentatives(material, values, missingEvidence, ambiguities, blockers) {
+  const current = [];
+  const byObligation = new Map();
+  for (const raw of values.slice(0, MAX_FACTS)) {
+    const obligation = matchObligation(material.obligations, raw.obligation || raw.task || '');
+    if (!obligation) { ambiguities.push(issue('representative-obligation-unresolved', `Representative fact targets unknown obligation ${raw.obligation || raw.task || '(empty)'}.`)); continue; }
+    const recordResolution = resolveFactRecord(material, raw.representative || raw.path || obligation.task.path);
+    const semanticQualified = String(raw.qualification || raw.semanticState || '') === 'qualified' && nonEmptyBasis(raw.basis);
+    const state = VALID_REP_STATES.has(String(raw.state || '')) ? String(raw.state) : 'unresolved';
+    const currentness = String(raw.currentness || 'unresolved');
+    const exactQualified = Boolean(recordResolution.record && recordResolution.qualification.state === 'qualified' && semanticQualified);
+    const projection = Object.freeze({
+      obligation: obligation.task,
+      representative: recordResolution.record ? identity(recordResolution.record) : Object.freeze({ id: '', path: String(raw.representative || raw.path || '') }),
+      state,
+      currentness,
+      qualification: exactQualified ? 'qualified' : 'unresolved',
+      retestInputState: String(raw.retestInputState || raw.inputState || 'unresolved'),
+      reduction: reductionBoundary(recordResolution.record, raw),
+      basis: compactBasis(raw.basis)
+    });
+    const list = byObligation.get(obligation.id) || [];
+    list.push(projection);
+    byObligation.set(obligation.id, list);
+  }
+
+  for (const obligation of material.obligations) {
+    if (obligation.state !== 'qualified') { ambiguities.push(issue('work-obligation-unqualified', `Required work obligation ${obligation.task?.path || obligation.id} is not qualified.`)); continue; }
+    const facts = byObligation.get(obligation.id) || [];
+    const currentFacts = facts.filter((item) => item.currentness === 'current');
+    const qualifiedCurrent = currentFacts.filter((item) => item.qualification === 'qualified');
+    if (!facts.length) { missingEvidence.push(issue('current-representative-missing', `No explicit current representative assessment exists for required work ${obligation.task.path}.`)); continue; }
+    if (currentFacts.some((item) => item.qualification !== 'qualified')) { ambiguities.push(issue('current-representative-unqualified', `An apparent current representative for ${obligation.task.path} is not qualified.`)); continue; }
+    if (qualifiedCurrent.length !== 1) { ambiguities.push(issue('current-representative-ambiguous', `${obligation.task.path} has ${qualifiedCurrent.length} qualified current representatives; exactly one is required.`)); continue; }
+    const rep = qualifiedCurrent[0];
+    current.push(rep);
+    if (rep.state === 'active' || rep.state === 'blocked') blockers.push(blocker('required-work-current', rep.representative.path || obligation.task.path, rep.state, rep.basis));
+    else if (rep.state === 'unresolved') ambiguities.push(issue('current-representative-state-unresolved', `Current representative ${rep.representative.path} has unresolved work state.`));
+    if (rep.state === 'resolved') assessRepresentativeInput(rep, blockers, ambiguities);
+  }
+  return Object.freeze({ current: Object.freeze(current), assessedObligations: byObligation.size });
+}
+
+function assessRepresentativeInput(rep, blockers, ambiguities) {
+  if (rep.reduction.isReduction) {
+    if (rep.reduction.lossState === 'material') blockers.push(blocker('reduction-material-loss', rep.representative.path, 'known-missing-required-input', rep.basis));
+    else if (rep.reduction.lossState !== 'none') ambiguities.push(issue('reduction-loss-unresolved', `Reduction representative ${rep.representative.path} has unresolved material loss for re-test inputs.`));
+  }
+  if (rep.retestInputState === 'missing') blockers.push(blocker('representative-retest-input-missing', rep.representative.path, 'known-missing-required-input', rep.basis));
+  else if (rep.retestInputState !== 'available') ambiguities.push(issue('representative-retest-input-unresolved', `Re-test input availability is unresolved for ${rep.representative.path}.`));
+}
+
+function projectBlockers(material, values, ambiguities, blockers) {
+  const projected = [];
+  for (const raw of values.slice(0, MAX_FACTS)) {
+    const state = String(raw.state || 'unresolved');
+    const qualification = String(raw.qualification || raw.semanticState || '');
+    const currentness = String(raw.currentness || 'unresolved');
+    if (currentness === 'historical') continue;
+    if (qualification !== 'qualified' || !nonEmptyBasis(raw.basis) || currentness !== 'current') {
+      ambiguities.push(issue('blocker-currentness-unresolved', `Apparent blocker ${raw.id || raw.label || '(unnamed)'} is not both qualified and current.`));
+      continue;
+    }
+    const item = blocker(String(raw.kind || 'declared-blocker'), String(raw.target || raw.id || ''), state, raw.basis);
+    projected.push(item);
+    if (['blocking', 'active', 'disputed', 'incomplete'].includes(state)) blockers.push(item);
+    else if (!['resolved', 'clear'].includes(state)) ambiguities.push(issue('blocker-state-unresolved', `Qualified current blocker fact ${raw.id || raw.label || '(unnamed)'} has unresolved state ${state}.`));
+  }
+  return Object.freeze({ items: Object.freeze(projected) });
+}
+
+function projectRetestInputs(values, missingEvidence, ambiguities, blockers) {
+  const projected = [];
+  for (const raw of values.slice(0, MAX_FACTS)) {
+    const qualification = String(raw.qualification || raw.semanticState || '');
+    const state = String(raw.state || 'unresolved');
+    if (qualification !== 'qualified' || !nonEmptyBasis(raw.basis)) { ambiguities.push(issue('retest-input-unqualified', `Required re-test input ${raw.id || raw.label || '(unnamed)'} is not qualified.`)); continue; }
+    const item = Object.freeze({ id: String(raw.id || raw.label || ''), state, basis: compactBasis(raw.basis) });
+    projected.push(item);
+    if (state === 'missing') blockers.push(blocker('required-retest-input-missing', item.id, 'known-missing-required-input', item.basis));
+    else if (state !== 'available') ambiguities.push(issue('retest-input-state-unresolved', `Required re-test input ${item.id || '(unnamed)'} has unresolved availability.`));
+  }
+  return Object.freeze({ items: Object.freeze(projected), declared: values.length, missing: missingEvidence.length });
+}
+
+function projectRetest(material, values, authority) {
+  const apparent = values.slice(0, MAX_FACTS).filter((raw) => String(raw.currentness || 'current') !== 'historical');
+  if (!apparent.length) return retestResult('not-observed', [], [], [], null);
+  const qualified = [];
+  const ambiguities = [];
+  for (const raw of apparent) {
+    const record = resolveFactRecord(material, raw.artifact || raw.path || '');
+    const state = String(raw.state || raw.outcome || '');
+    const exactTarget = matchesTask(material.controllingTask.record, raw.target || raw.scope || '');
+    const valid = Boolean(record.record && record.qualification.state === 'qualified' && VALID_RETEST.has(state) && String(raw.qualification || raw.semanticState || '') === 'qualified' && String(raw.currentness || '') === 'current' && nonEmptyBasis(raw.basis) && exactTarget && String(raw.criteriaCoverage || '') === 'complete' && String(raw.methodState || raw.methodQualification || '') === 'qualified' && authorityMatches(authority, raw));
+    if (!valid) {
+      ambiguities.push(issue('retest-outcome-unqualified', `Apparent re-test outcome ${raw.artifact || raw.path || '(unresolved artifact)'} cannot qualify exact target, criteria coverage, method, currentness, or authority.`));
+      continue;
+    }
+    qualified.push(Object.freeze({ state, artifact: identity(record.record), authorityRole: String(raw.authorityRole || ''), authorityBasis: compactBasis(raw.authorityBasis || raw.basis), basis: compactBasis(raw.basis) }));
+  }
+  const states = new Set(qualified.map((item) => item.state));
+  if (ambiguities.length || qualified.length !== 1 || states.size !== 1) return retestResult('unresolved', qualified, apparent, ambiguities.length ? ambiguities : [issue('retest-outcome-ambiguous', `${qualified.length} qualified current re-test outcomes are present.`)], authority);
+  return retestResult(qualified[0].state, qualified, apparent, [], authority);
+}
+
+function projectClosure(material, values, authority, retest) {
+  const apparent = values.slice(0, MAX_FACTS).filter((raw) => String(raw.currentness || 'current') !== 'historical');
+  if (!apparent.length) return closureResult('open', [], [], [], null);
+  const qualified = [];
+  const ambiguities = [];
+  for (const raw of apparent) {
+    const record = resolveFactRecord(material, raw.artifact || raw.path || '');
+    const targetOk = matchesTask(material.controllingTask.record, raw.target || raw.scope || '');
+    const explicitClosed = String(raw.state || '') === 'closed' && raw.explicit !== false;
+    const authorityOk = authorityMatches(authority, raw);
+    const passOk = closurePassBasis(raw, retest, material, authority);
+    const valid = Boolean(record.record && record.qualification.state === 'qualified' && String(raw.qualification || raw.semanticState || '') === 'qualified' && String(raw.currentness || '') === 'current' && nonEmptyBasis(raw.basis) && targetOk && explicitClosed && authorityOk && passOk);
+    if (!valid) { ambiguities.push(issue('closure-disposition-unqualified', `Apparent closure ${raw.artifact || raw.path || '(unresolved artifact)'} cannot qualify exact target, explicit closure, pass basis, currentness, or authority.`)); continue; }
+    qualified.push(Object.freeze({ artifact: identity(record.record), authorityRole: String(raw.authorityRole || ''), passBasis: compactBasis(raw.passBasis || raw.incorporatedPass), basis: compactBasis(raw.basis) }));
+  }
+  if (ambiguities.length || qualified.length !== 1) return closureResult('unresolved', qualified, apparent, ambiguities.length ? ambiguities : [issue('closure-disposition-ambiguous', `${qualified.length} qualified current closures are present.`)], authority);
+  return closureResult('closed', qualified, apparent, [], authority);
+}
+
+function closurePassBasis(raw, retest, material, authority) {
+  const referenced = String(raw.passBasisArtifact || raw.retestArtifact || '').trim();
+  if (retest.state === 'passed' && (!referenced || retest.basis.some((item) => item.artifact.path === referenced || item.artifact.id === referenced))) return true;
+  const incorporated = raw.incorporatedPass;
+  if (!incorporated || typeof incorporated !== 'object') return false;
+  const state = String(incorporated.state || incorporated.outcome || '');
+  const record = resolveFactRecord(material, incorporated.artifact || raw.artifact || raw.path || '');
+  return Boolean(record.record && record.qualification.state === 'qualified' && state === 'passed' && String(incorporated.qualification || '') === 'qualified' && matchesTask(material.controllingTask.record, incorporated.target || raw.target || '') && String(incorporated.criteriaCoverage || '') === 'complete' && String(incorporated.methodState || '') === 'qualified' && authorityMatches(authority, incorporated));
+}
+
+function readinessProjection({ material, retest, closure, missingEvidence, ambiguities, blockers }) {
+  if (closure.state === 'closed') return readinessResult('not-applicable', ['qualified explicit closure already governs the exact controlling Task'], blockers, missingEvidence, ambiguities, material);
+  if (missingEvidence.length || ambiguities.length || closure.state === 'unresolved' || retest.state === 'unresolved') return readinessResult('unresolved', ['required qualification/currentness/authority evidence is unresolved'], blockers, missingEvidence, ambiguities, material);
+  if (retest.state === 'failed') return readinessResult('not-ready-for-retest', ['current authoritative re-test failed and has not been explicitly superseded by a newer qualified cycle'], blockers, missingEvidence, ambiguities, material);
+  if (blockers.length) return readinessResult('not-ready-for-retest', ['qualified current blocking prerequisite remains'], blockers, missingEvidence, ambiguities, material);
+  return readinessResult('ready-for-retest', ['all declared required work representatives and re-test inputs are qualified/current enough and no qualified current blocker remains'], blockers, missingEvidence, ambiguities, material);
+}
+
+function normalizedFacts(input) {
+  const facts = input.facts && typeof input.facts === 'object' ? input.facts : input;
+  return Object.freeze({
+    authority: facts.authority || {},
+    representatives: bounded(facts.representatives),
+    blockers: bounded(facts.blockers),
+    retestInputs: bounded(facts.retestInputs || facts.inputs),
+    retests: bounded(facts.retests || facts.outcomes),
+    closures: bounded(facts.closures)
+  });
+}
+
+function criteriaAuthority(value = {}) {
+  const owner = value.criteriaOwner || value.owner || value;
+  const role = String(owner.role || owner.roleLabel || '').trim();
+  const state = String(owner.state || owner.qualification || 'unresolved');
+  const qualified = state === 'qualified' && Boolean(role) && nonEmptyBasis(owner.basis);
+  return Object.freeze({ state: qualified ? 'qualified' : 'unresolved', role, basis: compactBasis(owner.basis), boundary: 'Explicit upstream-qualified governing authority only; authorship, holder identity, human presence, and report existence are not authority.' });
+}
+
+function authorityMatches(authority, raw = {}) { return authority.state === 'qualified' && String(raw.authorityState || raw.authorityQualification || 'qualified') === 'qualified' && String(raw.authorityRole || '').trim() === authority.role && nonEmptyBasis(raw.authorityBasis || raw.basis); }
+function matchesTask(task, target) { const wanted = String(target || '').replace(/\\/g, '/').replace(/^\.\//, ''); return Boolean(task && wanted && [task.path, task.id].some((value) => value === wanted || String(value || '').endsWith(`/${wanted}`) || wanted.endsWith(`/${value}`))); }
+function matchObligation(obligations, requested) { const wanted = String(requested || '').replace(/\\/g, '/').replace(/^\.\//, ''); return obligations.find((item) => [item.id, item.task?.id, item.task?.path].some((value) => value === wanted || (wanted && String(value || '').endsWith(`/${wanted}`)))); }
+function reductionBoundary(record, raw) { const isReduction = String(record?.schemaId || '') === 'tiinex.reduction.v1'; return Object.freeze({ isReduction, carryForwardState: isReduction ? String(raw.carryForwardState || 'unresolved') : 'not-applicable', lossState: isReduction ? String(raw.lossState || 'unresolved') : 'not-applicable', validationState: isReduction ? String(raw.validationState || 'unresolved') : 'not-applicable', completionProof: false }); }
+function retestResult(state, qualified, apparent, ambiguities, authority) { return Object.freeze({ state, basis: Object.freeze(qualified), apparentCount: apparent.length, ambiguities: Object.freeze(ambiguities), authorityBasis: authority?.state === 'qualified' ? authority : null, boundary: 'Outcome requires exact qualified target/coverage/method/currentness and matching governing authority; report existence/authorship alone is evidence only.' }); }
+function closureResult(state, qualified, apparent, ambiguities, authority) { return Object.freeze({ state, basis: Object.freeze(qualified), apparentCount: apparent.length, ambiguities: Object.freeze(ambiguities), authorityBasis: state === 'closed' && authority?.state === 'qualified' ? authority : null, boundary: 'Closed requires explicit qualified governing disposition plus authoritative pass basis; convergence, cleanup, status, or pass alone do not close.' }); }
+function readinessResult(state, reasons, blockers, missingEvidence, ambiguities, material) { return Object.freeze({ state, basis: Object.freeze({ controllingTask: material.controllingTask.record, criteria: material.controllingTask.criteria.basis, obligationCount: material.obligations.length, lineage: material.boundary.automaticWorkScope }), reasons: Object.freeze(reasons), blockers: Object.freeze([...blockers]), missingEvidence: Object.freeze([...missingEvidence]), ambiguities: Object.freeze([...ambiguities]) }); }
+function blocker(code, target, state, basis) { return Object.freeze({ code, target: String(target || ''), state: String(state || ''), basis: compactBasis(basis) }); }
+function issue(code, detail) { return Object.freeze({ code: String(code || 'unresolved'), detail: String(detail || '') }); }
+function identity(record = {}) { return Object.freeze({ id: String(record.id || record.path || ''), path: String(record.path || ''), title: String(record.title || ''), schemaId: String(record.schemaId || '') }); }
+function bounded(value) { return Object.freeze((Array.isArray(value) ? value : []).slice(0, MAX_FACTS)); }
+function nonEmptyBasis(value) { return Array.isArray(value) ? value.length > 0 : typeof value === 'string' ? Boolean(value.trim()) : Boolean(value && typeof value === 'object' && Object.keys(value).length); }
+function compactBasis(value) { if (Array.isArray(value)) return Object.freeze(value.slice(0, 8).map((item) => typeof item === 'string' ? item.slice(0, 240) : Object.freeze({ ...item }))); if (typeof value === 'string') return value.slice(0, 720); if (value && typeof value === 'object') return Object.freeze({ ...value }); return null; }

package/src/tooling/portable/lineage/lineage.integrity.apply.audit.js

@@ -0,0 +1,22 @@
+import { auditPortableRecords } from '../audit/audit.capability.js';
+
+export function buildLineagePostRepairAudit(records = [], changedRecords = []) {
+  const postRepairAudit = auditPortableRecords(records);
+  const changedPathSet = new Set(changedRecords.map((record) => normalizePath(record.path || '')));
+  const changedAudits = Object.freeze((postRepairAudit.audits || []).filter((audit) => changedPathSet.has(normalizePath(audit.path || ''))));
+  const changedFindings = Object.freeze(changedAudits.flatMap((audit) => audit.findings || []));
+  return Object.freeze({
+    schema: 'tiinex.portable.lineage-integrity-post-repair-audit.v1',
+    status: postRepairAudit.status,
+    changedRecordStatus: changedRecords.length
+      ? (changedFindings.some((finding) => finding.severity === 'error') ? 'blocked' : changedFindings.some((finding) => finding.severity === 'warning') ? 'degraded' : 'clean')
+      : 'not-applicable',
+    changedAudits,
+    changedFindings,
+    findingSummary: postRepairAudit.findingSummary,
+    capabilityBoundary: postRepairAudit.boundary,
+    boundary: 'First-class post-application re-audit through the same shared audit capability used by CLI/LLM and Viewer consumers. Re-audit does not publish or mutate source material.'
+  });
+}
+
+function normalizePath(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+|\/+$/g, ''); }

package/src/tooling/portable/lineage/lineage.integrity.apply.evidence.js

@@ -0,0 +1,36 @@
+import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
+
+export function targetAuthorizedByDeclaredParent(record, step, approval, desiredTarget) {
+  let parsed;
+  try { parsed = parseArtifactMarkdown(record?.markdown || ''); } catch { return false; }
+  const trace = String(parsed.envelope?.parent?.trace || '').trim();
+  const browse = String((parsed.envelope?.parent?.originEntries || []).find((entry) => entry.label === 'browse + git')?.target || '');
+  if (step?.action === 'update-parent-origin-permalink') return true;
+  if (step?.action === 'review-parent-target-mismatch' && approval?.targetDisposition === 'repaired-local-parent') return Boolean(trace && desiredTarget === trace);
+  return desiredTarget === (browse || trace);
+}
+
+export function providerMaterialMatches(providerEvidence = {}, target = '', parentMarkdown = '', allowHistoricalMismatch = false) {
+  const locator = parseGithubBlobTarget(target);
+  if (!locator) return false;
+  for (const observation of providerEvidence.observations || []) {
+    for (const file of observation.files || []) {
+      if (file.source?.repository !== locator.repository) continue;
+      if (String(file.source?.commit || file.source?.ref || '') !== locator.commit) continue;
+      if (normalizePath(file.source?.path || file.path || '') !== normalizePath(locator.path)) continue;
+      if (allowHistoricalMismatch || file.content === String(parentMarkdown || '')) return true;
+    }
+  }
+  return false;
+}
+
+function parseGithubBlobTarget(value = '') {
+  try {
+    const url = new URL(String(value || ''));
+    if (url.protocol !== 'https:' || url.hostname !== 'github.com') return null;
+    const parts = url.pathname.split('/').filter(Boolean);
+    if (parts.length < 5 || parts[2] !== 'blob' || !/^[0-9a-f]{40}$/.test(parts[3])) return null;
+    return Object.freeze({ repository: `${parts[0]}/${parts[1]}`, commit: parts[3], path: parts.slice(4).join('/') });
+  } catch { return null; }
+}
+function normalizePath(value = '') { return String(value || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+|\/+$/g, ''); }