@juangcarmona/lighthouse-sdlc 0.2.0 → 0.3.0

package/README.md

@@ -2,10 +2,14 @@
 
 This package provides the provider-neutral delivery contract for Lighthouse adopters.
 
-It owns the six lifecycle skills, their command entrypoints, route and gate descriptors, control-plane schema and deterministic package check.
+It owns the six lifecycle skills, their command entrypoints, route and gate descriptors, the triage schema and verifier, the control-plane schema and deterministic package check.
 
 It does not run agents, store transcripts, dispatch work between repositories or replace ProductShape, ArcShape, OpenSpec or an agent host.
 
 Install it with the Lighthouse CLI or run `lighthouse-sdlc verify` from the package installation to check the distributed contract.
 
+Run `lighthouse-sdlc triage --input <file>` to validate one structured triage result and receive its proposed workflow and classification labels. The command is read-only by default; `--apply --labels-file <file>` writes only after the report is ready and the labels file still matches the input.
+
+Evidence is explicit: an absent field appears in `missingEvidence`, a check that cannot run appears in `unavailableChecks`, and a judgement awaiting review appears in `pendingReview`. Only `provided` evidence can make a report ready to apply.
+
 The package is a source of lifecycle instructions and contracts; an adopter's host adapter decides where provider-specific projections are installed.

package/commands/triage.md

@@ -1,3 +1,9 @@
 # `/lighthouse:triage`
 
 Run the `lighthouse-sdlc-triage` skill for one work item and stop at the `triaged` gate.
+
+The structured result records `size`, `urgency`, `impact`, `risk`, `blast-radius`, dependencies, route, owner, confidence and evidence, then proposes workflow and classification labels from the project's configuration.
+
+Use `lighthouse-sdlc triage --input <file>` for deterministic validation. The command is read-only unless an explicit `--apply --labels-file <file>` request is supplied.
+
+Represent evidence with `status: provided`, `status: unavailable` or `status: pending-review`; omit the item when evidence is absent. The report keeps those cases in `missingEvidence`, `unavailableChecks` and `pendingReview` respectively.

package/contract.json

@@ -17,6 +17,7 @@
   "assets": {
     "routes": "routes.json",
     "gates": "gates.json",
-    "controlPlaneSchema": "schemas/control-plane.schema.json"
+    "controlPlaneSchema": "schemas/control-plane.schema.json",
+    "triageSchema": "schemas/triage.schema.json"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juangcarmona/lighthouse-sdlc",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "Provider-neutral SDLC skills, commands and route contracts for Lighthouse adopters",
   "repository": {
@@ -35,7 +35,9 @@
   },
   "exports": {
     ".": "./src/sdlc.mjs",
+    "./triage": "./src/triage.mjs",
     "./contract.json": "./contract.json",
-    "./schemas/control-plane.schema.json": "./schemas/control-plane.schema.json"
+    "./schemas/control-plane.schema.json": "./schemas/control-plane.schema.json",
+    "./schemas/triage.schema.json": "./schemas/triage.schema.json"
   }
 }

package/schemas/sdlc-contract.schema.json

@@ -17,11 +17,12 @@
     "assets": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["routes", "gates", "controlPlaneSchema"],
+      "required": ["routes", "gates", "controlPlaneSchema", "triageSchema"],
       "properties": {
         "routes": { "type": "string" },
         "gates": { "type": "string" },
-        "controlPlaneSchema": { "type": "string" }
+        "controlPlaneSchema": { "type": "string" },
+        "triageSchema": { "type": "string" }
       }
     }
   },

package/schemas/triage.schema.json

@@ -0,0 +1,62 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/juangcarmona/lighthouse/schemas/lighthouse-sdlc-triage.schema.json",
+  "title": "Lighthouse triage input",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "workItem", "currentLabels", "assessment", "configuration"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "workItem": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "title"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "title": { "type": "string", "minLength": 1 },
+        "type": { "type": "string", "minLength": 1 }
+      }
+    },
+    "currentLabels": { "type": "array", "items": { "type": "string" } },
+    "assessment": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["size", "urgency", "impact", "risk", "blastRadius", "dependencies", "route", "nextState", "owner", "confidence", "evidence"],
+      "properties": {
+        "size": { "enum": ["S", "M", "L", "XL"] },
+        "urgency": { "enum": ["normal", "asap", "now"] },
+        "impact": { "enum": ["low", "medium", "high"] },
+        "risk": { "enum": ["low", "medium", "high"] },
+        "blastRadius": { "enum": ["low", "medium", "high", "unknown"] },
+        "dependencies": { "type": "array" },
+        "route": { "enum": ["supervised", "plan-only", "unattended", "hotfix", "stacked"] },
+        "nextState": { "type": "string", "minLength": 1 },
+        "owner": { "type": "string", "minLength": 1 },
+        "confidence": { "type": "object" },
+        "evidence": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["field"],
+            "properties": {
+              "field": { "enum": ["size", "urgency", "impact", "risk", "blast-radius"] },
+              "status": { "enum": ["provided", "unavailable", "pending-review"] },
+              "source": { "type": "string", "minLength": 1 },
+              "reason": { "type": "string", "minLength": 1 }
+            }
+          }
+        }
+      }
+    },
+    "configuration": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["labels", "transitions"],
+      "properties": {
+        "labels": { "type": "array" },
+        "transitions": { "type": "array" }
+      }
+    }
+  }
+}

package/skills/triage/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: lighthouse-sdlc-triage
-description: Use when a work item enters the Lighthouse lifecycle and needs urgency, impact, dependencies, risk, complexity, blast radius and a delivery route.
+description: Use when a work item enters the Lighthouse lifecycle and needs size, urgency, impact, dependencies, risk, blast radius and a delivery route.
 ---
 
 # Triage
@@ -11,10 +11,11 @@ Classify one work item before refinement.
 
 1. Read the work item, its linked Product Change and the repository control plane.
 2. Inspect the affected code and architecture evidence with the available repository tools.
-3. Record urgency, impact, dependencies, risk, complexity, blast radius, route and owner with a confidence note for each estimate.
-4. Apply only the project's declared tracker labels and report the label changes.
-5. Return the structured triage record and stop at the `triaged` gate.
+3. Record size, urgency, impact, dependencies, risk, blast radius, route and owner with confidence and evidence for each assessment.
+4. Mark each evidence field as provided, unavailable or pending-review; leave absent fields without an evidence item.
+5. Propose only the project's declared workflow and classification labels and report the transition.
+6. Return the structured triage record and stop at the `triaged` gate.
 
 ## Completion
 
-The record names the route, owner, labels, estimates, confidence and next decision, and no later stage has started.
+The record names the route, owner, labels, assessments, confidence, evidence and next decision, and no later stage has started.

package/src/sdlc.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { access, readFile } from 'node:fs/promises';
+import { access, readFile, writeFile } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { applyTriageLabels, buildTriageReport } from './triage.mjs';
 
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const contractPath = resolve(packageRoot, 'contract.json');
@@ -28,10 +29,10 @@ async function verifyContract() {
   for (const stage of stages) {
     for (const asset of [stage.skill, stage.command]) if (!(await exists(resolve(packageRoot, asset)))) problems.push(`missing stage asset ${asset}`);
   }
-  for (const asset of [contract.assets?.routes, contract.assets?.gates, contract.assets?.controlPlaneSchema]) {
+  for (const asset of [contract.assets?.routes, contract.assets?.gates, contract.assets?.controlPlaneSchema, contract.assets?.triageSchema]) {
     if (!asset || !(await exists(resolve(packageRoot, asset)))) problems.push(`missing contract asset ${asset ?? '(empty)'}`);
   }
-  for (const asset of ['routes.json', 'gates.json', 'schemas/routes.schema.json', 'schemas/gates.schema.json', 'schemas/control-plane.schema.json']) {
+  for (const asset of ['routes.json', 'gates.json', 'schemas/routes.schema.json', 'schemas/gates.schema.json', 'schemas/control-plane.schema.json', 'schemas/triage.schema.json', 'src/triage.mjs']) {
     if (!(await exists(resolve(packageRoot, asset)))) problems.push(`missing package asset ${asset}`);
   }
   try {
@@ -49,13 +50,70 @@ async function verifyContract() {
   return problems;
 }
 
+function option(args, name) {
+  const index = args.indexOf(name);
+  if (index !== -1) return args[index + 1];
+  const prefix = `${name}=`;
+  return args.find((arg) => arg.startsWith(prefix))?.slice(prefix.length);
+}
+
+function triageText(report) {
+  const lines = [
+    `Triage: ${report.status}`,
+    `Work item: ${report.workItem?.id ?? '(unknown)'} — ${report.workItem?.title ?? '(untitled)'}`,
+    `Size: ${report.assessment.size}`,
+    `Urgency: ${report.assessment.urgency}`,
+    `Impact: ${report.assessment.impact}`,
+    `Risk: ${report.assessment.risk}`,
+    `Blast radius: ${report.assessment.blastRadius}`,
+    `Route: ${report.assessment.route ?? '(unknown)'}`,
+    `Transition: ${report.transition.from ?? '(unknown)'} -> ${report.transition.to ?? '(unknown)'}`,
+    `Labels: ${report.labels.proposed.join(', ') || '(none)'}`,
+  ];
+  if (report.missingEvidence.length) lines.push(`Missing evidence: ${report.missingEvidence.join(', ')}`);
+  if (report.unavailableChecks.length) lines.push(`Unavailable checks: ${report.unavailableChecks.join(', ')}`);
+  if (report.pendingReview.length) lines.push(`Pending review: ${report.pendingReview.join(', ')}`);
+  for (const error of report.errors) lines.push(`Error: ${error.message}`);
+  lines.push(report.applied ? 'Applied: yes' : 'Applied: no (read-only)');
+  return `${lines.join('\n')}\n`;
+}
+
+async function runTriage(args) {
+  const inputPath = option(args, '--input');
+  const configPath = option(args, '--config');
+  const labelsPath = option(args, '--labels-file');
+  const format = option(args, '--format') ?? 'text';
+  const apply = args.includes('--apply');
+  if (!inputPath || !['text', 'json'].includes(format) || (apply && !labelsPath)) {
+    console.error('Usage: lighthouse-sdlc triage --input <file> [--config <file>] [--format <text|json>] [--apply --labels-file <file>]');
+    process.exit(2);
+  }
+  const input = await readJson(resolve(process.cwd(), inputPath));
+  if (configPath) input.configuration = await readJson(resolve(process.cwd(), configPath));
+  const report = buildTriageReport(input);
+  report.applied = false;
+  if (apply && report.canApply) {
+    const labelsFile = resolve(process.cwd(), labelsPath);
+    const current = await readJson(labelsFile);
+    const expected = JSON.stringify(report.labels.current);
+    if (!Array.isArray(current) || JSON.stringify([...new Set(current)].sort()) !== expected) throw new Error('labels file does not match currentLabels; refusing to apply the triage projection');
+    await writeFile(labelsFile, `${JSON.stringify(applyTriageLabels(report), null, 2)}\n`);
+    report.applied = true;
+  }
+  if (format === 'json') console.log(JSON.stringify(report, null, 2));
+  else process.stdout.write(triageText(report));
+  if (report.status !== 'ready') process.exit(1);
+}
+
 const command = process.argv[2] ?? 'verify';
-if (!['contract', 'verify'].includes(command)) {
-  console.error('Usage: lighthouse-sdlc <contract|verify>');
+if (!['contract', 'verify', 'triage'].includes(command)) {
+  console.error('Usage: lighthouse-sdlc <contract|verify|triage>');
   process.exit(2);
 }
 if (command === 'contract') {
   console.log(await readFile(contractPath, 'utf8'));
+} else if (command === 'triage') {
+  await runTriage(process.argv.slice(3));
 } else {
   const problems = await verifyContract();
   if (problems.length) {
@@ -65,4 +123,4 @@ if (command === 'contract') {
   console.log('Lighthouse SDLC package contract is valid.');
 }
 
-export { contractPath, verifyContract };
+export { contractPath, runTriage, verifyContract };

package/src/triage.mjs

@@ -0,0 +1,284 @@
+const DIMENSIONS = Object.freeze({
+  size: ['S', 'M', 'L', 'XL'],
+  urgency: ['normal', 'asap', 'now'],
+  impact: ['low', 'medium', 'high'],
+  risk: ['low', 'medium', 'high'],
+  'blast-radius': ['low', 'medium', 'high'],
+});
+
+const CONFIDENCE = new Set(['low', 'medium', 'high']);
+const ROLES = new Set(['state', 'command', 'classification']);
+const ROUTES = new Set(['supervised', 'plan-only', 'unattended', 'hotfix', 'stacked']);
+const DEPENDENCY_STATES = new Set(['resolved', 'open', 'unknown']);
+const EVIDENCE_STATES = new Set(['provided', 'unavailable', 'pending-review']);
+const HEX = /^[0-9a-f]{6}$/iu;
+const EVIDENCE_FIELDS = ['size', 'urgency', 'impact', 'risk', 'blast-radius'];
+
+export const suggestedLabelColors = Object.freeze({
+  'size-s': 'BFE3FF',
+  'size-m': '80C2FF',
+  'size-l': '4DA3FF',
+  'size-xl': '1F6FEB',
+  'urgency-normal': '8B949E',
+  'urgency-asap': 'D29922',
+  'urgency-now': 'CF222E',
+  'impact-low': 'E9D5FF',
+  'impact-medium': 'A371F7',
+  'impact-high': '6E40C9',
+  'risk-low': 'FFEBE9',
+  'risk-medium': 'F0883E',
+  'risk-high': 'CF222E',
+  'blast-radius-low': 'C7F0E8',
+  'blast-radius-medium': '4FB3A4',
+  'blast-radius-high': '0F766E',
+});
+
+function isRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizedValue(dimension, value) {
+  if (dimension === 'size') return String(value ?? '').toUpperCase();
+  return String(value ?? '').toLowerCase();
+}
+
+function labelFor(dimension, value) {
+  return `${dimension}-${normalizedValue(dimension, value).toLowerCase()}`;
+}
+
+function issue(code, message, field) {
+  return field ? { code, field, message } : { code, message };
+}
+
+function addIssue(issues, code, message, field) {
+  issues.push(issue(code, message, field));
+}
+
+function validateConfiguration(configuration) {
+  const errors = [];
+  const labels = Array.isArray(configuration?.labels) ? configuration.labels : null;
+  const byName = new Map();
+  const classifications = new Map();
+  const stateLabels = new Set();
+  const commandLabels = new Set();
+
+  if (!labels) addIssue(errors, 'configuration.labels', 'configuration.labels must be an array', 'configuration.labels');
+  for (const descriptor of labels ?? []) {
+    if (!isRecord(descriptor) || typeof descriptor.name !== 'string' || !descriptor.name.trim()) {
+      addIssue(errors, 'label.invalid', 'every label descriptor needs a non-empty name', 'configuration.labels');
+      continue;
+    }
+    const name = descriptor.name.trim();
+    if (byName.has(name)) addIssue(errors, 'label.duplicate', `label ${name} is declared more than once`, 'configuration.labels');
+    byName.set(name, descriptor);
+    if (!ROLES.has(descriptor.role)) {
+      addIssue(errors, 'label.role', `label ${name} must use role state, command or classification`, 'configuration.labels');
+      continue;
+    }
+    if (descriptor.role === 'state') stateLabels.add(name);
+    if (descriptor.role === 'command') commandLabels.add(name);
+    if (descriptor.role !== 'classification') continue;
+    const dimension = String(descriptor.dimension ?? '').toLowerCase();
+    const value = normalizedValue(dimension, descriptor.value);
+    if (!Object.hasOwn(DIMENSIONS, dimension) || !DIMENSIONS[dimension].includes(value)) {
+      addIssue(errors, 'label.classification', `label ${name} has an invalid classification dimension or value`, 'configuration.labels');
+      continue;
+    }
+    if (labelFor(dimension, value) !== name) {
+      addIssue(errors, 'label.syntax', `classification label ${name} must use the ${labelFor(dimension, value)} syntax`, 'configuration.labels');
+    }
+    const key = `${dimension}:${value}`;
+    if (classifications.has(key)) addIssue(errors, 'label.classification-duplicate', `classification ${key} is declared more than once`, 'configuration.labels');
+    classifications.set(key, name);
+    if (descriptor.color !== undefined && (typeof descriptor.color !== 'string' || !HEX.test(descriptor.color))) {
+      addIssue(errors, 'label.color', `classification label ${name} color must be six hexadecimal characters`, 'configuration.labels');
+    }
+  }
+
+  const transitions = Array.isArray(configuration?.transitions) ? configuration.transitions : [];
+  const transitionSet = new Set();
+  for (const transition of transitions) {
+    if (!isRecord(transition) || typeof transition.from !== 'string' || typeof transition.to !== 'string') {
+      addIssue(errors, 'transition.invalid', 'every transition needs from and to labels', 'configuration.transitions');
+      continue;
+    }
+    const key = `${transition.from}->${transition.to}`;
+    if (transitionSet.has(key)) addIssue(errors, 'transition.duplicate', `transition ${key} is declared more than once`, 'configuration.transitions');
+    transitionSet.add(key);
+  }
+
+  return { errors, byName, classifications, stateLabels, commandLabels, transitionSet };
+}
+
+function validateWorkItem(workItem, errors) {
+  if (!isRecord(workItem)) {
+    addIssue(errors, 'work-item.invalid', 'workItem must be an object', 'workItem');
+    return;
+  }
+  for (const field of ['id', 'title']) {
+    if (typeof workItem[field] !== 'string' || !workItem[field].trim()) addIssue(errors, `work-item.${field}`, `workItem.${field} must be a non-empty string`, `workItem.${field}`);
+  }
+  if (workItem.type !== undefined && (typeof workItem.type !== 'string' || !workItem.type.trim())) addIssue(errors, 'work-item.type', 'workItem.type must be a non-empty string when provided', 'workItem.type');
+}
+
+function validateAssessment(assessment, errors) {
+  if (!isRecord(assessment)) {
+    addIssue(errors, 'assessment.invalid', 'assessment must be an object', 'assessment');
+    return;
+  }
+  for (const dimension of Object.keys(DIMENSIONS)) {
+    const value = normalizedValue(dimension, assessment[dimension === 'blast-radius' ? 'blastRadius' : dimension]);
+    if (!DIMENSIONS[dimension].includes(value) && !(dimension === 'blast-radius' && value === 'unknown')) {
+      addIssue(errors, `assessment.${dimension}`, `${dimension} has an unsupported value`, `assessment.${dimension}`);
+    }
+  }
+  if (!ROUTES.has(assessment.route)) addIssue(errors, 'assessment.route', `route must be one of ${[...ROUTES].join(', ')}`, 'assessment.route');
+  if (typeof assessment.nextState !== 'string' || !assessment.nextState.trim()) addIssue(errors, 'assessment.next-state', 'nextState must be a non-empty string', 'assessment.nextState');
+  if (typeof assessment.owner !== 'string' || !assessment.owner.trim()) addIssue(errors, 'assessment.owner', 'owner must be a non-empty string', 'assessment.owner');
+  if (!isRecord(assessment.confidence)) {
+    addIssue(errors, 'assessment.confidence', 'confidence must be an object with one value per triage dimension', 'assessment.confidence');
+  } else {
+    for (const dimension of EVIDENCE_FIELDS) if (!CONFIDENCE.has(assessment.confidence[dimension])) addIssue(errors, `assessment.confidence.${dimension}`, `${dimension} confidence must be low, medium or high`, `assessment.confidence.${dimension}`);
+  }
+  if (!Array.isArray(assessment.dependencies)) {
+    addIssue(errors, 'assessment.dependencies', 'dependencies must be an array', 'assessment.dependencies');
+  } else {
+    for (const dependency of assessment.dependencies) {
+      if (!isRecord(dependency) || typeof dependency.id !== 'string' || !DEPENDENCY_STATES.has(dependency.status)) addIssue(errors, 'assessment.dependency', 'each dependency needs an id and a resolved, open or unknown status', 'assessment.dependencies');
+    }
+  }
+  if (!Array.isArray(assessment.evidence)) {
+    addIssue(errors, 'assessment.evidence', 'evidence must be an array', 'assessment.evidence');
+  } else {
+    const fields = new Set();
+    for (const evidence of assessment.evidence) {
+      const status = evidence?.status ?? 'provided';
+      const valid = isRecord(evidence) && EVIDENCE_FIELDS.includes(evidence.field) && EVIDENCE_STATES.has(status);
+      if (!valid) {
+        addIssue(errors, 'assessment.evidence-item', 'each evidence item needs a known field and a provided, unavailable or pending-review status', 'assessment.evidence');
+        continue;
+      }
+      if (fields.has(evidence.field)) addIssue(errors, 'assessment.evidence-duplicate', `${evidence.field} has more than one evidence status`, 'assessment.evidence');
+      fields.add(evidence.field);
+      if (status === 'provided' && (typeof evidence.source !== 'string' || !evidence.source.trim())) addIssue(errors, 'assessment.evidence-source', 'provided evidence needs a non-empty source', 'assessment.evidence');
+      if (status !== 'provided' && (typeof evidence.reason !== 'string' || !evidence.reason.trim())) addIssue(errors, 'assessment.evidence-reason', `${status} evidence needs a non-empty reason`, 'assessment.evidence');
+    }
+  }
+}
+
+function currentState(labels, configuration) {
+  const states = labels.filter((label) => configuration.stateLabels.has(label));
+  return { states, value: states.length === 1 ? states[0] : null };
+}
+
+function classificationState(labels, configuration) {
+  const byDimension = new Map();
+  for (const label of labels) {
+    const descriptor = configuration.byName.get(label);
+    if (!descriptor || descriptor.role !== 'classification') continue;
+    const list = byDimension.get(descriptor.dimension) ?? [];
+    list.push(label);
+    byDimension.set(descriptor.dimension, list);
+  }
+  return byDimension;
+}
+
+function proposedLabels(currentLabels, assessment, configuration) {
+  const result = new Set(currentLabels.filter((label) => {
+    const descriptor = configuration.byName.get(label);
+    return !descriptor || (descriptor.role !== 'state' && descriptor.role !== 'classification' && descriptor.role !== 'command');
+  }));
+  for (const label of configuration.stateLabels) if (currentLabels.includes(label)) result.add(label);
+  for (const label of configuration.commandLabels) if (currentLabels.includes(label)) result.delete(label);
+  const state = currentState(currentLabels, configuration).value;
+  if (state) result.delete(state);
+  if (assessment.nextState) result.add(assessment.nextState);
+  for (const dimension of Object.keys(DIMENSIONS)) {
+    const key = dimension === 'blast-radius' ? 'blastRadius' : dimension;
+    const value = normalizedValue(dimension, assessment[key]);
+    for (const label of configuration.classifications.values()) {
+      const descriptor = configuration.byName.get(label);
+      if (descriptor?.dimension === dimension) result.delete(label);
+    }
+    if (value !== 'UNKNOWN') {
+      const label = configuration.classifications.get(`${dimension}:${value}`);
+      if (label) result.add(label);
+    }
+  }
+  return [...result].sort((a, b) => a.localeCompare(b));
+}
+
+export function buildTriageReport(input) {
+  const errors = [];
+  if (!isRecord(input)) return { schemaVersion: 1, status: 'invalid', valid: false, canApply: false, errors: [issue('input.invalid', 'triage input must be an object')], warnings: [], missingEvidence: [], unavailableChecks: [], pendingReview: [], labels: { current: [], proposed: [] } };
+  if (input.schemaVersion !== 1) addIssue(errors, 'input.schema-version', 'schemaVersion must be 1', 'schemaVersion');
+  const configuration = validateConfiguration(input.configuration);
+  errors.push(...configuration.errors);
+  const currentLabels = Array.isArray(input.currentLabels) ? [...new Set(input.currentLabels.filter((label) => typeof label === 'string'))].sort() : [];
+  if (!Array.isArray(input.currentLabels)) addIssue(errors, 'labels.invalid', 'currentLabels must be an array', 'currentLabels');
+  validateWorkItem(input.workItem, errors);
+  validateAssessment(input.assessment, errors);
+
+  const state = currentState(currentLabels, configuration);
+  if (state.states.length > 1) addIssue(errors, 'state.ambiguous', `work item has multiple workflow state labels: ${state.states.join(', ')}`, 'currentLabels');
+  if (state.states.length === 0) addIssue(errors, 'state.missing', 'work item needs one configured workflow state label', 'currentLabels');
+  const assessment = isRecord(input.assessment) ? input.assessment : {};
+  if (state.value && typeof assessment.nextState === 'string' && configuration.stateLabels.has(assessment.nextState)) {
+    if (state.value !== assessment.nextState && !configuration.transitionSet.has(`${state.value}->${assessment.nextState}`)) addIssue(errors, 'transition.illegal', `transition ${state.value}->${assessment.nextState} is not configured`, 'assessment.nextState');
+  } else if (typeof assessment.nextState === 'string' && assessment.nextState && !configuration.stateLabels.has(assessment.nextState)) {
+    addIssue(errors, 'transition.unconfigured', `next state ${assessment.nextState} is not configured`, 'assessment.nextState');
+  }
+  const currentClassifications = classificationState(currentLabels, configuration);
+  for (const [dimension, values] of currentClassifications) if (values.length > 1) addIssue(errors, 'classification.ambiguous', `work item has multiple ${dimension} classification labels: ${values.join(', ')}`, 'currentLabels');
+  for (const dimension of Object.keys(DIMENSIONS)) {
+    const value = normalizedValue(dimension, assessment[dimension === 'blast-radius' ? 'blastRadius' : dimension]);
+    if (value !== 'UNKNOWN' && configuration.classifications.has(`${dimension}:${value}`) === false) addIssue(errors, 'classification.unconfigured', `${labelFor(dimension, value)} is not configured`, `assessment.${dimension}`);
+  }
+
+  const evidence = Array.isArray(assessment.evidence) ? assessment.evidence : [];
+  const evidenceFields = new Set(evidence.filter(isRecord).map((item) => item.field));
+  const missingEvidence = EVIDENCE_FIELDS.filter((field) => !evidenceFields.has(field));
+  const unavailableChecks = evidence.filter((item) => isRecord(item) && item.status === 'unavailable').map((item) => item.field);
+  const pendingReview = evidence.filter((item) => isRecord(item) && item.status === 'pending-review').map((item) => item.field);
+  const warnings = [
+    ...missingEvidence.map((field) => issue('evidence.missing', `${field} has no evidence record`, field)),
+    ...unavailableChecks.map((field) => issue('evidence.unavailable', `${field} could not be checked`, field)),
+    ...pendingReview.map((field) => issue('evidence.pending-review', `${field} is waiting for judgement`, field)),
+  ];
+  const proposed = proposedLabels(currentLabels, assessment, configuration);
+  const status = errors.length ? 'invalid' : warnings.length ? 'blocked' : 'ready';
+  return {
+    schemaVersion: 1,
+    status,
+    valid: errors.length === 0,
+    canApply: status === 'ready',
+    workItem: input.workItem ?? null,
+    assessment: {
+      size: normalizedValue('size', assessment.size),
+      urgency: normalizedValue('urgency', assessment.urgency),
+      impact: normalizedValue('impact', assessment.impact),
+      risk: normalizedValue('risk', assessment.risk),
+      blastRadius: normalizedValue('blast-radius', assessment.blastRadius),
+      dependencies: assessment.dependencies ?? [],
+      route: assessment.route ?? null,
+      owner: assessment.owner ?? null,
+      confidence: assessment.confidence ?? {},
+      evidence,
+    },
+    transition: { from: state.value, to: assessment.nextState ?? null },
+    labels: { current: currentLabels, proposed },
+    missingEvidence,
+    unavailableChecks,
+    pendingReview,
+    suggestedColors: suggestedLabelColors,
+    errors,
+    warnings,
+  };
+}
+
+export function applyTriageLabels(report) {
+  if (!report?.canApply) throw new Error('Triage report is not ready to apply. Resolve its errors or outstanding evidence state first.');
+  return [...report.labels.proposed];
+}
+
+export { DIMENSIONS, ROUTES, validateConfiguration };