hadara 0.3.2 → 0.3.3-rc.0

package/dist/context/state-projection.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContextStateProjectionReport = createContextStateProjectionReport;
+const TASK_ID_PATTERN = /\bT-\d{4}\b/;
+function createContextStateProjectionReport(input) {
+    const stateSources = input.extractionResults.flatMap((result) => result.stateSources ?? []);
+    const nodes = input.extractionResults.flatMap((result) => result.nodes);
+    const graphIssues = input.extractionResults.flatMap((result) => result.issues);
+    const taskIndex = indexTaskNodes(nodes);
+    const latestCompleted = chooseTaskHint(latestCompletedCandidates(stateSources));
+    const active = chooseTaskHint(activeTaskCandidates(stateSources));
+    const latestClosed = latestClosedTask(stateSources);
+    const issues = [
+        ...stateSourceConsistencyIssues(stateSources),
+        ...taskPresenceIssues(taskIndex),
+        ...closeProofIssues(stateSources),
+        ...graphIssues.map(graphIssueToStateIssue)
+    ].filter((issue) => Boolean(issue));
+    return {
+        schemaVersion: 'hadara.stateProjection.v1',
+        command: 'state.projection',
+        ok: issues.every((issue) => issue.severity !== 'error'),
+        generatedAt: input.generatedAt,
+        summary: {
+            ...(latestCompleted ? { latestCompletedTask: latestCompleted } : {}),
+            ...(active ? { activeTask: active } : {}),
+            ...(latestClosed ? { latestClosedTask: latestClosed } : {}),
+            releaseState: releaseState(stateSources),
+            stateConsistency: stateConsistency(issues)
+        },
+        sources: dedupeStateSources(stateSources),
+        issues
+    };
+}
+function stateSourceConsistencyIssues(stateSources) {
+    const issues = [];
+    const latestCandidates = latestCompletedCandidates(stateSources);
+    const activeCandidates = activeTaskCandidates(stateSources);
+    if (uniqueTaskIds(latestCandidates).length > 1) {
+        issues.push(issue('warning', 'STATE_LATEST_TASK_MISMATCH', `Latest completed task differs across state sources: ${formatCandidates(latestCandidates)}.`, latestCandidates.map((candidate) => candidate.path), 'Update PROJECT_STATE, AGENT_HANDOFF, and Task Board latest Done state so they point at the same task.'));
+    }
+    if (uniqueTaskIds(activeCandidates).length > 1) {
+        issues.push(issue('warning', 'STATE_ACTIVE_TASK_MISMATCH', `Active task differs across state sources: ${formatCandidates(activeCandidates)}.`, activeCandidates.map((candidate) => candidate.path), 'Update active task state in PROJECT_STATE, AGENT_HANDOFF, and Task Board, or clear it when no concrete task is active.'));
+    }
+    if (!stateSources.some((source) => source.kind === 'release-readiness')) {
+        issues.push(issue('warning', 'STATE_RELEASE_EVIDENCE_STALE', 'Release readiness state source is missing from context extraction.', ['docs/RELEASE_READINESS.md'], 'Run or include release readiness extraction before relying on release-state context routing.'));
+    }
+    return issues;
+}
+function taskPresenceIssues(taskIndex) {
+    const issues = [];
+    for (const taskId of taskIndex.taskBoardTaskIds) {
+        if (taskIndex.taskCapsuleTaskIds.has(taskId))
+            continue;
+        issues.push(issue('warning', 'STATE_TASK_CAPSULE_MISSING', `Task Board references ${taskId}, but no matching Task Capsule node was extracted.`, [taskIndex.taskBoardPaths.get(taskId) ?? 'docs/TASK_BOARD.md'], `Create the missing ${taskId} capsule or update the Task Board row.`));
+    }
+    for (const taskId of taskIndex.taskCapsuleTaskIds) {
+        if (taskIndex.taskBoardTaskIds.has(taskId))
+            continue;
+        issues.push(issue('warning', 'STATE_TASK_BOARD_MISSING_ROW', `Task Capsule ${taskId} exists, but no matching Task Board row was extracted.`, [taskIndex.taskCapsulePaths.get(taskId) ?? `tasks/${taskId}/TASK.md`, 'docs/TASK_BOARD.md'], `Add or repair the Task Board row for ${taskId}.`));
+    }
+    return issues;
+}
+function closeProofIssues(stateSources) {
+    const latest = chooseTaskHint(latestCompletedCandidates(stateSources));
+    const closed = latestClosedTask(stateSources);
+    if (!latest || closed === latest)
+        return [];
+    return [issue('warning', 'STATE_CLOSE_PROOF_STALE', closed
+            ? `Latest close proof is ${closed}, but latest completed task is ${latest}.`
+            : `No close proof state source was extracted for latest completed task ${latest}.`, evidenceSourcePaths(stateSources, latest), `Run task ready/close/audit-close for ${latest}, or include current evidence extraction before relying on close-proof state.`)];
+}
+function graphIssueToStateIssue(graphIssue) {
+    if (graphIssue.severity === 'info')
+        return null;
+    return issue(graphIssue.severity, 'STATE_UNKNOWN', graphIssue.message, graphIssue.path ? [graphIssue.path] : [], graphIssue.fixHint ?? 'Resolve the underlying context graph extraction issue.');
+}
+function latestCompletedCandidates(stateSources) {
+    return [
+        candidateFromSource(stateSources, 'task-board', 'latestDoneTask'),
+        candidateFromSource(stateSources, 'project-state', 'latestCompletedTask'),
+        candidateFromSource(stateSources, 'agent-handoff', 'latestCompletedTask')
+    ].filter((candidate) => Boolean(candidate?.taskId));
+}
+function activeTaskCandidates(stateSources) {
+    const taskBoard = stateSources.find((source) => source.kind === 'task-board');
+    const activeTasks = Array.isArray(taskBoard?.extracted.activeTasks)
+        ? (taskBoard?.extracted.activeTasks).map((value) => normalizeTaskId(String(value))).filter((value) => Boolean(value))
+        : [];
+    return [
+        activeTasks.length === 1 && taskBoard ? { source: taskBoard.kind, path: taskBoard.path, taskId: activeTasks[0] } : null,
+        candidateFromSource(stateSources, 'project-state', 'activeTask'),
+        candidateFromSource(stateSources, 'agent-handoff', 'activeTask')
+    ].filter((candidate) => Boolean(candidate?.taskId));
+}
+function candidateFromSource(stateSources, kind, field) {
+    const source = stateSources.find((item) => item.kind === kind);
+    if (!source)
+        return null;
+    const taskId = normalizeTaskId(source.extracted[field]);
+    return taskId ? { source: kind, path: source.path, taskId } : null;
+}
+function chooseTaskHint(candidates) {
+    return candidates[0]?.taskId ?? null;
+}
+function uniqueTaskIds(candidates) {
+    return Array.from(new Set(candidates.map((candidate) => candidate.taskId).filter((value) => Boolean(value)))).sort();
+}
+function formatCandidates(candidates) {
+    return candidates.map((candidate) => `${candidate.source}=${candidate.taskId}`).join(', ');
+}
+function normalizeTaskId(value) {
+    if (typeof value !== 'string')
+        return null;
+    if (/^(none|n\/a|tbd)\b/i.test(value.trim()))
+        return null;
+    return value.match(TASK_ID_PATTERN)?.[0] ?? null;
+}
+function latestClosedTask(stateSources) {
+    return stateSources
+        .filter((source) => source.kind === 'evidence' && Number(source.extracted.closeProofs ?? 0) > 0)
+        .map((source) => normalizeTaskId(source.extracted.taskId))
+        .filter((taskId) => Boolean(taskId))
+        .sort()
+        .at(-1) ?? null;
+}
+function releaseState(stateSources) {
+    const source = stateSources.find((item) => item.kind === 'release-readiness');
+    if (!source)
+        return 'unknown';
+    const checks = Number(source.extracted.checks ?? 0);
+    if (checks <= 0)
+        return 'unknown';
+    const statusCounts = source.extracted.statusCounts;
+    if (isRecord(statusCounts) && Number(statusCounts.blocked ?? 0) > 0)
+        return 'blocked';
+    if (isRecord(statusCounts) && Number(statusCounts.current ?? 0) > 0)
+        return 'current';
+    return 'documented';
+}
+function indexTaskNodes(nodes) {
+    const taskBoardTaskIds = new Set();
+    const taskCapsuleTaskIds = new Set();
+    const taskBoardPaths = new Map();
+    const taskCapsulePaths = new Map();
+    for (const node of nodes) {
+        if (node.type !== 'Task')
+            continue;
+        const taskId = normalizeTaskId(node.id);
+        if (!taskId)
+            continue;
+        if (node.kind === 'task-board-row') {
+            taskBoardTaskIds.add(taskId);
+            taskBoardPaths.set(taskId, node.source.path);
+        }
+        if (node.kind === 'task-capsule') {
+            taskCapsuleTaskIds.add(taskId);
+            taskCapsulePaths.set(taskId, node.path ?? node.source.path);
+        }
+    }
+    return { taskBoardTaskIds, taskCapsuleTaskIds, taskBoardPaths, taskCapsulePaths };
+}
+function evidenceSourcePaths(stateSources, latestTaskId) {
+    const paths = stateSources.filter((source) => source.kind === 'evidence').map((source) => source.path);
+    return paths.length > 0 ? paths : [`tasks/${latestTaskId}/evidence.jsonl`];
+}
+function stateConsistency(issues) {
+    if (issues.some((item) => item.severity === 'error'))
+        return 'error';
+    if (issues.some((item) => item.severity === 'warning'))
+        return 'warning';
+    return 'consistent';
+}
+function dedupeStateSources(stateSources) {
+    const seen = new Set();
+    const result = [];
+    for (const source of stateSources) {
+        if (seen.has(source.id))
+            continue;
+        seen.add(source.id);
+        result.push(source);
+    }
+    return result;
+}
+function issue(severity, code, message, paths, fixHint) {
+    return {
+        severity,
+        code,
+        message,
+        paths: Array.from(new Set(paths)).sort(),
+        fixHint
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/context/task-extractors.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTaskBoard = extractTaskBoard;
+exports.extractTaskCapsules = extractTaskCapsules;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const extractor_contract_1 = require("./extractor-contract");
+const markdown_table_1 = require("../services/markdown-table");
+const task_capsule_1 = require("../task/task-capsule");
+function extractTaskBoard(projectRoot) {
+    const relativePath = 'docs/TASK_BOARD.md';
+    const absolutePath = node_path_1.default.join(projectRoot, relativePath);
+    const content = readOptionalText(absolutePath);
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractTaskBoard', [{ path: relativePath, content }]);
+    if (content == null) {
+        result.issues.push(sourceMissingIssue(relativePath, 'Task Board is missing; task graph nodes cannot be extracted from docs/TASK_BOARD.md.'));
+        return result;
+    }
+    const sourceHash = (0, extractor_contract_1.hashContextGraphText)(content);
+    const rows = parseTaskBoardRows(content);
+    result.nodes.push(...rows.map((row) => taskBoardNode(row, sourceHash)));
+    result.stateSources?.push(taskBoardStateSource(rows, sourceHash));
+    return result;
+}
+function extractTaskCapsules(projectRoot) {
+    const capsules = (0, task_capsule_1.listTaskCapsules)(projectRoot);
+    const sources = capsules.flatMap((task) => [
+        readSourceInput(projectRoot, node_path_1.default.join(task.dir, 'TASK.md')),
+        readSourceInput(projectRoot, node_path_1.default.join(task.dir, 'HANDOFF.md'))
+    ]);
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractTaskCapsules', sources);
+    const stateSources = [];
+    for (const task of capsules) {
+        const taskPath = (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, node_path_1.default.join(task.dir, 'TASK.md'));
+        const taskContent = readOptionalText(node_path_1.default.join(task.dir, 'TASK.md'));
+        if (taskContent == null) {
+            result.issues.push(sourceMissingIssue(taskPath, `Task Capsule ${task.id} is missing TASK.md.`));
+            continue;
+        }
+        const handoffPath = (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, node_path_1.default.join(task.dir, 'HANDOFF.md'));
+        const handoffContent = readOptionalText(node_path_1.default.join(task.dir, 'HANDOFF.md'));
+        const taskStatus = readTaskStatus(taskContent);
+        const handoffStatus = handoffContent == null ? null : readTaskHandoffStatus(handoffContent);
+        const taskHash = (0, extractor_contract_1.hashContextGraphText)(taskContent);
+        const source = (0, extractor_contract_1.createContextGraphSourceRef)({
+            path: taskPath,
+            extractor: 'extractTaskCapsules',
+            line: 1,
+            hash: taskHash
+        });
+        result.nodes.push({
+            id: (0, extractor_contract_1.createTaskNodeId)(task.id),
+            type: 'Task',
+            label: `${task.id} ${task.title}`,
+            path: taskPath,
+            status: taskStatus ?? undefined,
+            kind: 'task-capsule',
+            metadata: {
+                capsule: (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, task.dir),
+                ...(handoffStatus ? { handoffTaskStatus: handoffStatus } : {}),
+                handoffPath,
+                handoffPresent: handoffContent != null
+            },
+            source
+        });
+        stateSources.push({
+            id: `state-source:task-capsule:${task.id}`,
+            path: taskPath,
+            kind: 'task-capsule',
+            hash: taskHash,
+            extracted: {
+                taskId: task.id,
+                title: task.title,
+                status: taskStatus,
+                handoffTaskStatus: handoffStatus,
+                capsule: (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, task.dir)
+            }
+        });
+    }
+    result.stateSources?.push(...stateSources);
+    return result;
+}
+function taskBoardNode(row, sourceHash) {
+    return {
+        id: (0, extractor_contract_1.createTaskNodeId)(row.id),
+        type: 'Task',
+        label: `${row.id} ${row.title}`.trim(),
+        path: (0, extractor_contract_1.normalizeContextGraphPath)(node_path_1.default.posix.join(row.capsule, 'TASK.md')),
+        status: row.status,
+        kind: 'task-board-row',
+        metadata: {
+            capsule: (0, extractor_contract_1.normalizeContextGraphPath)(row.capsule)
+        },
+        source: (0, extractor_contract_1.createContextGraphSourceRef)({
+            path: 'docs/TASK_BOARD.md',
+            extractor: 'extractTaskBoard',
+            line: row.line,
+            hash: sourceHash
+        })
+    };
+}
+function taskBoardStateSource(rows, sourceHash) {
+    return {
+        id: 'state-source:task-board',
+        path: 'docs/TASK_BOARD.md',
+        kind: 'task-board',
+        hash: sourceHash,
+        extracted: {
+            rows: rows.length,
+            latestDoneTask: latestTaskId(rows.filter((row) => row.status === 'Done').map((row) => row.id)),
+            activeTasks: rows.filter((row) => row.status === 'In Progress').map((row) => row.id)
+        }
+    };
+}
+function parseTaskBoardRows(content) {
+    const rows = [];
+    content.split(/\r?\n/).forEach((line, index) => {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('|') || !trimmed.endsWith('|') || /^\|\s*:?-+/.test(trimmed))
+            return;
+        const cells = trimmed.slice(1, -1).split('|').map((cell) => cell.trim());
+        if (!/^T-\d{4}$/.test(cells[0] ?? ''))
+            return;
+        rows.push({
+            id: cells[0],
+            title: cells[1] ?? '',
+            status: cells[2] ?? '',
+            capsule: cells[3] ?? '',
+            line: index + 1
+        });
+    });
+    return rows;
+}
+function readTaskStatus(content) {
+    const sectionStatus = (0, markdown_table_1.readMarkdownSection)(content, '## Status').trim().split(/\r?\n/)[0]?.trim();
+    if (sectionStatus)
+        return sectionStatus;
+    const rows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(content, '## Metadata');
+    return (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Status')?.[1] ?? null;
+}
+function readTaskHandoffStatus(content) {
+    const rows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(content, '## Current State');
+    return (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'TaskStatus')?.[1] ?? (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Status')?.[1] ?? null;
+}
+function readSourceInput(projectRoot, absolutePath) {
+    return {
+        path: (0, extractor_contract_1.toProjectRelativeContextPath)(projectRoot, absolutePath),
+        content: readOptionalText(absolutePath)
+    };
+}
+function readOptionalText(absolutePath) {
+    return node_fs_1.default.existsSync(absolutePath) ? node_fs_1.default.readFileSync(absolutePath, 'utf8') : null;
+}
+function sourceMissingIssue(relativePath, message) {
+    return {
+        severity: 'warning',
+        code: 'CONTEXT_GRAPH_SOURCE_MISSING',
+        path: relativePath,
+        message,
+        fixHint: `Restore ${relativePath} or run the relevant HADARA workflow before relying on context graph extraction.`
+    };
+}
+function latestTaskId(ids) {
+    return ids.sort().at(-1) ?? null;
+}

package/dist/core/schema.js

@@ -12,6 +12,14 @@ const actor_context_schema_json_1 = __importDefault(require("../schemas/actor-co
 const active_run_projection_schema_json_1 = __importDefault(require("../schemas/active-run-projection.schema.json"));
 const active_run_resume_schema_json_1 = __importDefault(require("../schemas/active-run-resume.schema.json"));
 const clean_checkout_smoke_schema_json_1 = __importDefault(require("../schemas/clean-checkout-smoke.schema.json"));
+const code_index_schema_json_1 = __importDefault(require("../schemas/code-index.schema.json"));
+const context_cache_record_schema_json_1 = __importDefault(require("../schemas/context-cache-record.schema.json"));
+const context_cache_status_schema_json_1 = __importDefault(require("../schemas/context-cache-status.schema.json"));
+const context_cache_warm_schema_json_1 = __importDefault(require("../schemas/context-cache-warm.schema.json"));
+const context_source_manifest_schema_json_1 = __importDefault(require("../schemas/context-source-manifest.schema.json"));
+const context_pack_schema_json_1 = __importDefault(require("../schemas/context-pack.schema.json"));
+const context_slice_schema_json_1 = __importDefault(require("../schemas/context-slice.schema.json"));
+const context_graph_schema_json_1 = __importDefault(require("../schemas/context-graph.schema.json"));
 const context_export_schema_json_1 = __importDefault(require("../schemas/context-export.schema.json"));
 const dashboard_bootstrap_schema_json_1 = __importDefault(require("../schemas/dashboard-bootstrap.schema.json"));
 const dashboard_core_schema_json_1 = __importDefault(require("../schemas/dashboard-core.schema.json"));
@@ -48,13 +56,18 @@ const release_dry_run_schema_json_1 = __importDefault(require("../schemas/releas
 const release_gate_schema_json_1 = __importDefault(require("../schemas/release-gate.schema.json"));
 const release_publish_schema_json_1 = __importDefault(require("../schemas/release-publish.schema.json"));
 const runtime_version_schema_json_1 = __importDefault(require("../schemas/runtime-version.schema.json"));
+const session_start_schema_json_1 = __importDefault(require("../schemas/session-start.schema.json"));
 const smoke_evidence_summary_schema_json_1 = __importDefault(require("../schemas/smoke-evidence-summary.schema.json"));
 const state_projection_schema_json_1 = __importDefault(require("../schemas/state-projection.schema.json"));
 const task_audit_close_schema_json_1 = __importDefault(require("../schemas/task-audit-close.schema.json"));
 const task_close_schema_json_1 = __importDefault(require("../schemas/task-close.schema.json"));
+const task_close_repair_plan_schema_json_1 = __importDefault(require("../schemas/task-close-repair-plan.schema.json"));
 const task_complete_flow_schema_json_1 = __importDefault(require("../schemas/task-complete-flow.schema.json"));
+const task_context_schema_json_1 = __importDefault(require("../schemas/task-context.schema.json"));
 const task_create_schema_json_1 = __importDefault(require("../schemas/task-create.schema.json"));
+const task_finalize_schema_json_1 = __importDefault(require("../schemas/task-finalize.schema.json"));
 const task_finish_schema_json_1 = __importDefault(require("../schemas/task-finish.schema.json"));
+const task_lifecycle_schema_json_1 = __importDefault(require("../schemas/task-lifecycle.schema.json"));
 const task_next_schema_json_1 = __importDefault(require("../schemas/task-next.schema.json"));
 const task_ready_schema_json_1 = __importDefault(require("../schemas/task-ready.schema.json"));
 const task_upgrade_scaffold_schema_json_1 = __importDefault(require("../schemas/task-upgrade-scaffold.schema.json"));
@@ -79,7 +92,15 @@ const registeredSchemas = {
     'hadara.active_run.projection.v1': active_run_projection_schema_json_1.default,
     'hadara.active_run.resume.v1': active_run_resume_schema_json_1.default,
     'hadara.cleanCheckoutSmoke.v1': clean_checkout_smoke_schema_json_1.default,
+    'hadara.codeIndex.v1': code_index_schema_json_1.default,
+    'hadara.context.cacheRecord.v1': context_cache_record_schema_json_1.default,
+    'hadara.context.cacheStatus.v1': context_cache_status_schema_json_1.default,
+    'hadara.context.cacheWarm.v1': context_cache_warm_schema_json_1.default,
+    'hadara.context.sourceManifest.v1': context_source_manifest_schema_json_1.default,
+    'hadara.contextPack.v1': context_pack_schema_json_1.default,
+    'hadara.contextSlice.v1': context_slice_schema_json_1.default,
     'hadara.context.export.v1': context_export_schema_json_1.default,
+    'hadara.contextGraph.v1': context_graph_schema_json_1.default,
     'hadara.dashboard.bootstrap.v1': dashboard_bootstrap_schema_json_1.default,
     'hadara.dashboard.core.v1': dashboard_core_schema_json_1.default,
     'hadara.dashboard.task_detail.v1': dashboard_task_detail_schema_json_1.default,
@@ -115,13 +136,18 @@ const registeredSchemas = {
     'hadara.releaseGate.v1': release_gate_schema_json_1.default,
     'hadara.releasePublish.v1': release_publish_schema_json_1.default,
     'hadara.runtime.version.v1': runtime_version_schema_json_1.default,
+    'hadara.sessionStart.v1': session_start_schema_json_1.default,
     'hadara.smokeEvidenceSummary.v1': smoke_evidence_summary_schema_json_1.default,
     'hadara.stateProjection.v1': state_projection_schema_json_1.default,
     'hadara.task.audit_close.v1': task_audit_close_schema_json_1.default,
     'hadara.task.close.v1': task_close_schema_json_1.default,
+    'hadara.task.closeRepairPlan.v1': task_close_repair_plan_schema_json_1.default,
     'hadara.task.complete_flow.v1': task_complete_flow_schema_json_1.default,
+    'hadara.taskContext.v1': task_context_schema_json_1.default,
     'hadara.task.create.v1': task_create_schema_json_1.default,
+    'hadara.task.finalize.v1': task_finalize_schema_json_1.default,
     'hadara.task.finish.v1': task_finish_schema_json_1.default,
+    'hadara.task.lifecycle.v1': task_lifecycle_schema_json_1.default,
     'hadara.task.next.v1': task_next_schema_json_1.default,
     'hadara.task.ready.v1': task_ready_schema_json_1.default,
     'hadara.task.upgrade_scaffold.v1': task_upgrade_scaffold_schema_json_1.default,

package/dist/harness/validate.js

@@ -8,6 +8,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const markdown_table_1 = require("../services/markdown-table");
 const evidence_lint_1 = require("../services/evidence-lint");
+const acceptance_1 = require("../task/acceptance");
 const task_capsule_1 = require("../task/task-capsule");
 const REQUIRED_TASK_FILES = [
     'TASK.md',
@@ -127,7 +128,7 @@ function validateTaskMarkdown(projectRoot, task, issues) {
 function validateCapsuleFormatMarkdown(projectRoot, task, issues) {
     validateMarkdownFile(projectRoot, task, issues, 'ACCEPTANCE.md', [
         { code: 'ACCEPTANCE_HEADING_INVALID', anyText: ['# Acceptance Criteria'] },
-        { code: 'ACCEPTANCE_CHECKLIST_MISSING', anyText: ['- [ ]', '- [x]', '| ID | Criterion | Status | Evidence |'] }
+        { code: 'ACCEPTANCE_CHECKLIST_MISSING', anyText: ['- [ ]', '- [x]', '| ID | Criterion | Status | Evidence |', '| ID | Criterion | Origin | Required | Deferrable | Status | Evidence |'] }
     ]);
     validateMarkdownFile(projectRoot, task, issues, 'FILES.md', [
         { code: 'FILES_TABLE_INVALID', anyText: ['| Path | Action | Reason |', '| Path | Action | Reason | Status |'] },
@@ -455,18 +456,16 @@ function validateAcceptanceDone(projectRoot, task, issues) {
     const checklistLines = content
         .split(/\r?\n/)
         .filter((line) => /^-\s+\[[ xX]\]/.test(line.trim()));
-    const tableRows = (0, markdown_table_1.parseMarkdownRows)(content).filter((cells) => /^AC-\d+$/i.test(cells[0] ?? ''));
-    const tableIncomplete = tableRows.length > 0 &&
-        tableRows.some((cells) => {
-            const status = cells[2]?.trim().toLowerCase();
-            return status === 'pending' || status === 'blocked' || !status;
-        });
+    const acceptance = (0, acceptance_1.analyzeAcceptanceReadiness)(content);
+    const tableRows = acceptance.rows;
+    const tableIncomplete = tableRows.length > 0 && acceptance.blockers.length > 0;
     const checklistIncomplete = checklistLines.length > 0 && checklistLines.some((line) => /^-\s+\[\s\]/.test(line.trim()));
     if ((tableRows.length > 0 && tableIncomplete) || (tableRows.length === 0 && (checklistLines.length === 0 || checklistIncomplete))) {
+        const blockerSummary = acceptance.blockers.length > 0 ? ` Blockers: ${acceptance.blockers.map((blocker) => `${blocker.code}(${blocker.row.id})`).join(', ')}.` : '';
         issues.push({
             severity: 'error',
             code: 'ACCEPTANCE_INCOMPLETE',
-            message: 'Done-level validation requires all acceptance criteria to be complete.',
+            message: `Done-level validation requires all acceptance criteria to be complete.${blockerSummary}`,
             path: relativePath,
             heading: 'Acceptance Criteria',
             fixHint: 'Mark each acceptance criterion complete with concrete evidence, or replace placeholder checklist rows with completed task-specific criteria.',

package/dist/schemas/code-index.schema.json

@@ -0,0 +1,173 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "hadara.codeIndex.v1",
+    "x-hadara-schema-id": "hadara.codeIndex.v1",
+    "title": "HADARA Code Index Report",
+    "type": "object",
+    "additionalProperties": true,
+    "required": [
+        "schemaVersion",
+        "command",
+        "ok",
+        "generatedAt",
+        "projectRoot",
+        "sourceHash",
+        "files",
+        "symbols",
+        "edges",
+        "summary",
+        "issues"
+    ],
+    "properties": {
+        "schemaVersion": { "const": "hadara.codeIndex.v1" },
+        "command": { "const": "code.index" },
+        "ok": { "type": "boolean" },
+        "generatedAt": { "type": "string" },
+        "projectRoot": { "type": "string" },
+        "sourceHash": { "type": "string", "minLength": 1 },
+        "files": { "type": "array", "items": { "$ref": "#/$defs/file" } },
+        "symbols": { "type": "array", "items": { "$ref": "#/$defs/symbol" } },
+        "edges": { "type": "array", "items": { "$ref": "#/$defs/edge" } },
+        "summary": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["sourceFiles", "testFiles", "fixtureFiles", "configFiles", "symbols", "edges", "degraded"],
+            "properties": {
+                "sourceFiles": { "type": "number" },
+                "testFiles": { "type": "number" },
+                "fixtureFiles": { "type": "number" },
+                "configFiles": { "type": "number" },
+                "symbols": { "type": "number" },
+                "edges": { "type": "number" },
+                "degraded": { "type": "boolean" }
+            }
+        },
+        "budget": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": [
+                "maxIndexedFiles",
+                "maxIndexedBytes",
+                "maxSingleFileBytes",
+                "indexedFiles",
+                "indexedBytes",
+                "skippedFiles"
+            ],
+            "properties": {
+                "maxIndexedFiles": { "type": "number" },
+                "maxIndexedBytes": { "type": "number" },
+                "maxSingleFileBytes": { "type": "number" },
+                "indexedFiles": { "type": "number" },
+                "indexedBytes": { "type": "number" },
+                "skippedFiles": { "type": "number" }
+            }
+        },
+        "cache": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["used", "hit"],
+            "properties": {
+                "used": { "type": "boolean" },
+                "hit": { "type": "boolean" },
+                "manifestHash": { "type": "string" },
+                "createdAt": { "type": "string" },
+                "cachePath": { "type": "string" }
+            }
+        },
+        "issues": { "type": "array", "items": { "$ref": "#/$defs/issue" } }
+    },
+    "$defs": {
+        "confidence": { "enum": ["explicit", "derived", "heuristic"] },
+        "fileKind": { "enum": ["source", "test", "fixture", "script", "config", "unknown"] },
+        "language": { "enum": ["typescript", "javascript", "json", "markdown", "unknown"] },
+        "symbolKind": { "enum": ["function", "class", "type", "interface", "const", "handler", "unknown"] },
+        "edgeType": {
+            "enum": [
+                "IMPORTS",
+                "EXPORTS",
+                "DEFINES_SYMBOL",
+                "TESTS_FILE",
+                "IMPLEMENTS_COMMAND",
+                "REFERENCED_BY_DOC",
+                "VALIDATED_BY_EVIDENCE"
+            ]
+        },
+        "source": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["path", "extractor"],
+            "properties": {
+                "path": { "type": "string", "minLength": 1 },
+                "line": { "type": "number" },
+                "hash": { "type": "string" },
+                "extractor": { "type": "string", "minLength": 1 }
+            }
+        },
+        "file": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["id", "path", "kind", "language", "hash", "lineCount", "exports", "imports", "commandFamilies"],
+            "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "path": { "type": "string", "minLength": 1 },
+                "kind": { "$ref": "#/$defs/fileKind" },
+                "language": { "$ref": "#/$defs/language" },
+                "hash": { "type": "string", "minLength": 1 },
+                "lineCount": { "type": "number" },
+                "exports": { "type": "array", "items": { "type": "string" } },
+                "imports": { "type": "array", "items": { "type": "string" } },
+                "commandFamilies": { "type": "array", "items": { "type": "string" } }
+            }
+        },
+        "symbol": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["id", "name", "kind", "path", "exported"],
+            "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "name": { "type": "string", "minLength": 1 },
+                "kind": { "$ref": "#/$defs/symbolKind" },
+                "path": { "type": "string", "minLength": 1 },
+                "exported": { "type": "boolean" },
+                "line": { "type": "number" },
+                "endLine": { "type": "number" }
+            }
+        },
+        "edge": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["id", "from", "to", "type", "confidence", "reason", "source"],
+            "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "from": { "type": "string", "minLength": 1 },
+                "to": { "type": "string", "minLength": 1 },
+                "type": { "$ref": "#/$defs/edgeType" },
+                "confidence": { "$ref": "#/$defs/confidence" },
+                "reason": { "type": "string", "minLength": 1 },
+                "source": { "$ref": "#/$defs/source" }
+            }
+        },
+        "issue": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["severity", "code", "message"],
+            "properties": {
+                "severity": { "enum": ["info", "warning", "error"] },
+                "code": {
+                    "enum": [
+                        "CODE_INDEX_FILE_READ_FAILED",
+                        "CODE_INDEX_PARSE_DEGRADED",
+                        "CODE_INDEX_TOO_LARGE",
+                        "CODE_INDEX_UNSUPPORTED_LANGUAGE",
+                        "CODE_INDEX_IMPORT_UNRESOLVED",
+                        "CODE_INDEX_FILE_CACHE_CORRUPT",
+                        "CODE_INDEX_FILE_CACHE_SCHEMA_MISMATCH"
+                    ]
+                },
+                "message": { "type": "string", "minLength": 1 },
+                "path": { "type": "string" },
+                "fixHint": { "type": "string" }
+            }
+        }
+    }
+}