hadara 0.3.0 → 0.3.2-rc.0

package/dist/services/evidence-list.js

@@ -8,6 +8,7 @@ exports.parseEvidenceIndexFile = parseEvidenceIndexFile;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const redaction_1 = require("../core/redaction");
+const normalizer_1 = require("../evidence/normalizer");
 const task_capsule_1 = require("../task/task-capsule");
 const DEFAULT_LIMIT = 50;
 function createEvidenceListReport(projectRoot, input) {
@@ -73,7 +74,7 @@ function parseEvidenceIndexFile(indexPath, taskId) {
                     });
                     return;
                 }
-                records.push(normalizeEvidenceIndexRecord(record));
+                records.push(normalizeEvidenceIndexRecord(record, index + 1));
                 return;
             }
             issues.push({
@@ -132,9 +133,10 @@ function isEvidenceV2IndexRecord(value) {
         isEvidenceResult(record.legacy.result) &&
         (record.legacy.evidencePath === undefined || typeof record.legacy.evidencePath === 'string'));
 }
-function normalizeEvidenceIndexRecord(record) {
+function normalizeEvidenceIndexRecord(record, sourceLine) {
     if (record.schemaVersion === 'hadara.evidence.v2')
-        return normalizeEvidenceV2IndexRecord(record);
+        return normalizeEvidenceV2IndexRecord(record, sourceLine);
+    const normalizedRecord = (0, normalizer_1.normalizeEvidenceRecord)(record, { lineNumber: sourceLine });
     const normalized = {
         schemaVersion: 'hadara.evidence.v1',
         time: record.time,
@@ -147,13 +149,29 @@ function normalizeEvidenceIndexRecord(record) {
     if (record.visibility === 'public' && record.evidencePath) {
         normalized.evidencePath = record.evidencePath;
     }
-    return normalized;
+    return {
+        ...normalized,
+        id: normalizedRecord.id,
+        sourceLine,
+        idSource: 'line-fallback',
+        idStability: 'unstable-on-reorder',
+        persistedSchemaVersion: 'hadara.evidence.v1',
+        category: normalizedRecord.category,
+        outcome: normalizedRecord.outcome,
+        tags: normalizedRecord.tags,
+        legacy: {
+            kind: normalized.kind,
+            result: normalized.result,
+            ...(normalized.evidencePath ? { evidencePath: normalized.evidencePath } : {})
+        }
+    };
 }
-function normalizeEvidenceV2IndexRecord(record) {
+function normalizeEvidenceV2IndexRecord(record, sourceLine) {
     return {
         schemaVersion: 'hadara.evidence.v2',
         id: record.id,
-        ...(record.sourceLine ? { sourceLine: record.sourceLine } : {}),
+        sourceLine: record.sourceLine ?? sourceLine,
+        persistedSchemaVersion: 'hadara.evidence.v2',
         fingerprint: record.fingerprint,
         idSource: 'persisted',
         idStability: 'durable',

package/dist/services/operational-debt.js

@@ -335,7 +335,7 @@ function checkPackageMetadataReadiness(packageJson, licenseText, testStrategy, r
         packageJson?.private === true &&
         bin.hadara === './dist/cli/main.js';
     const publishablePackageMetadataOk = packageJson?.name === 'hadara' &&
-        (/^0\.\d+\.0-rc\.\d+$/.test(String(packageJson?.version ?? '')) || /^0\.\d+\.0$/.test(String(packageJson?.version ?? ''))) &&
+        /^0\.\d+\.\d+(?:-rc\.\d+)?$/.test(String(packageJson?.version ?? '')) &&
         packageJson?.private === false &&
         packageJson?.license === 'MIT' &&
         bin.hadara === './dist/cli/main.js' &&
@@ -351,7 +351,7 @@ function checkPackageMetadataReadiness(packageJson, licenseText, testStrategy, r
         'Current binary remains `bin.hadara` at `./dist/cli/main.js`',
         'Current `files` whitelist is `dist/`, `README.md`, `LICENSE`, and `package.json`',
         'Bootstrap metadata mode: version `0.0.0-bootstrap`, `private: true`, no package publishability',
-        'Release-candidate metadata mode: version `0.x.0-rc.N`, `private: false`, `files` whitelist present, `LICENSE` present, package smoke evidence present',
+        'Release-candidate metadata mode: version `0.x.y-rc.N`, `private: false`, `files` whitelist present, `LICENSE` present, package smoke evidence present',
         'Scoped fallback decision: do not silently switch names',
         'Version policy:',
         'T-0142 transitions `private` to false only after the package files whitelist, root README, license decision, and package-smoke evidence gates exist',

package/dist/services/operations-status-service.js

@@ -12,6 +12,7 @@ const handoff_summary_parser_1 = require("./handoff-summary-parser");
 const markdown_table_1 = require("./markdown-table");
 const operational_debt_1 = require("./operational-debt");
 const project_read_model_1 = require("./project-read-model");
+const state_projection_1 = require("./state-projection");
 const task_capsule_1 = require("../task/task-capsule");
 const EMPTY_DEBT_AGGREGATE = {
     total: 0,
@@ -35,6 +36,9 @@ function createOpsStatusReport(projectRoot, options = {}) {
     const validation = (0, handoff_summary_parser_1.extractValidationBaselineSummary)(sources.handoff.content, sources.validationHistory.content);
     const activeRun = (0, active_run_state_1.safeCreateActiveRunProjection)(projectRoot);
     const debtAggregate = includeDebt ? (0, operational_debt_1.createOperationalDebtReport)(projectRoot).aggregate : EMPTY_DEBT_AGGREGATE;
+    const stateConsistency = options.includeStateConsistency
+        ? (0, state_projection_1.toStateProjectionAdvisory)((0, state_projection_1.createStateProjectionReport)(projectRoot), options.stateIssueLimit ?? 10)
+        : undefined;
     const issues = [...collectIssues(sources, validation), ...activeRun.issues];
     return {
         schemaVersion: 'hadara.ops.status.v1',
@@ -56,6 +60,7 @@ function createOpsStatusReport(projectRoot, options = {}) {
         validation,
         activeRun,
         debt: debtAggregate,
+        ...(stateConsistency ? { stateConsistency } : {}),
         mcp: {
             defaultMode: 'read-only',
             evidenceAttach: {
@@ -78,6 +83,12 @@ function formatOpsStatusReport(report) {
         `branch: ${report.project.branch}`,
         `tasks: ${counts}`,
         `debt: open ${report.debt.open}, highOpen ${report.debt.highOpen}`,
+        ...(report.stateConsistency
+            ? [
+                `stateConsistency: ${report.stateConsistency.consistent ? 'consistent' : 'drift'} ` +
+                    `(errors ${report.stateConsistency.issueCounts.error}, warnings ${report.stateConsistency.issueCounts.warning}, info ${report.stateConsistency.issueCounts.info})`
+            ]
+            : []),
         `lastCompleted: ${report.tasks.lastCompleted.join(', ') || 'none'}`,
         `nextRecommended: ${report.tasks.nextRecommended ?? 'none'}`
     ].join('\n');

package/dist/services/protocol-consistency.js

@@ -12,6 +12,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const protocol_profile_1 = require("./protocol-profile");
 const evidence_lint_1 = require("./evidence-lint");
 const markdown_table_1 = require("./markdown-table");
+const state_projection_1 = require("./state-projection");
 const task_capsule_1 = require("../task/task-capsule");
 const REQUIRED_TASK_FILES = Object.keys(task_capsule_1.TASK_FILES);
 const DONE_STATUSES = new Set(['done']);
@@ -126,6 +127,7 @@ function createAllProtocolConsistencyReport(projectRoot, now = new Date()) {
         }
     }
     const counts = countIssues(issues);
+    const stateConsistency = (0, state_projection_1.toStateProjectionAdvisory)((0, state_projection_1.createStateProjectionReport)(projectRoot, now), 10);
     return {
         schemaVersion: 'hadara.protocol.consistency.v1',
         command: 'protocol.doctor',
@@ -141,6 +143,7 @@ function createAllProtocolConsistencyReport(projectRoot, now = new Date()) {
             profile: profileReport.summary.profile,
             issueCounts: counts
         },
+        stateConsistency,
         issues,
         remediations
     };

package/dist/services/protocol-profile.js

@@ -217,7 +217,7 @@ function requiredDocsForProfile(profile) {
     return CORE_PROJECT_DOCS;
 }
 function requiredReadingDocsForProfile(profile) {
-    return requiredDocsForProfile(profile).filter((relativePath) => relativePath !== 'AGENTS.md');
+    return requiredDocsForProfile(profile).filter((relativePath) => relativePath !== 'AGENTS.md' && relativePath !== 'docs/REFACTOR_LOG.md');
 }
 function readProfileMetadata(projectRoot) {
     return {

package/dist/services/release-publish.js

@@ -10,11 +10,12 @@ const schema_1 = require("../core/schema");
 const audit_1 = require("../core/audit");
 const release_dry_run_1 = require("./release-dry-run");
 const CONFIRMATION_PHRASE = 'publish-deploy';
+const NPM_PUBLISHABLE_VERSION_PATTERN = /^0\.\d+\.\d+(?:-rc\.\d+)?$/;
 function createReleasePublishReport(options) {
     const mode = options.mode ?? 'dry-run';
     const env = options.env ?? process.env;
     const metadata = readPackageMetadata(options.projectRoot);
-    const metadataPublishable = !metadata.private && (/^0\.\d+\.0-rc\.\d+$/.test(metadata.packageVersion) || /^0\.\d+\.0$/.test(metadata.packageVersion));
+    const metadataPublishable = !metadata.private && NPM_PUBLISHABLE_VERSION_PATTERN.test(metadata.packageVersion);
     const dryRun = (0, release_dry_run_1.createReleaseDryRunReport)(options.projectRoot);
     const approval = {
         required: true,
@@ -35,7 +36,7 @@ function createReleasePublishReport(options) {
             status: metadataPublishable ? 'passed' : 'error',
             summary: metadataPublishable
                 ? 'Package metadata is in publishable version mode.'
-                : 'Package metadata must be 0.x.0-rc.N or 0.x.0 with private false before publish/deploy readiness can pass.'
+                : 'Package metadata must be 0.x.y-rc.N or 0.x.y with private false before publish/deploy readiness can pass.'
         },
         {
             code: 'APPROVAL_RECORD',

package/dist/services/state-projection.js

@@ -0,0 +1,406 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStateProjectionReport = createStateProjectionReport;
+exports.toStateProjectionAdvisory = toStateProjectionAdvisory;
+exports.formatStateProjectionReport = formatStateProjectionReport;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const evidence_1 = require("../evidence/evidence");
+const task_close_1 = require("../task/task-close");
+const task_capsule_1 = require("../task/task-capsule");
+const evidence_list_1 = require("./evidence-list");
+const markdown_table_1 = require("./markdown-table");
+const TASK_STATUS_TOKENS = new Set(['Draft', 'In Progress', 'Blocked', 'Done', 'Partial', 'Superseded', 'Archived']);
+const CLOSE_STATE_TOKENS = new Set(['not-closed', 'closed-valid', 'closed-stale', 'closed-invalid', 'unknown']);
+function createStateProjectionReport(projectRoot, now = new Date()) {
+    const issues = [];
+    const sourceTexts = readSources(projectRoot, issues);
+    const taskBoardRows = parseTaskBoardRows(sourceTexts.taskBoard.content);
+    const tasks = (0, task_capsule_1.listTaskCapsules)(projectRoot);
+    const taskById = new Map(tasks.map((task) => [task.id, task]));
+    const taskIds = new Set([...tasks.map((task) => task.id), ...taskBoardRows.map((row) => row.id)]);
+    const basicTaskStates = [...taskIds].sort().map((taskId) => ({
+        id: taskId,
+        taskStatus: taskById.get(taskId) ? readTaskStatus(node_path_1.default.join(taskById.get(taskId).dir, 'TASK.md')) : null,
+        taskBoardStatus: taskBoardRows.find((row) => row.id === taskId)?.status ?? null
+    }));
+    const latestDoneTaskId = latestTaskId(basicTaskStates.filter((task) => isDone(task.taskStatus) || isDone(task.taskBoardStatus)).map((task) => task.id));
+    const activeTaskIds = basicTaskStates.filter((task) => isActive(task.taskBoardStatus)).map((task) => task.id);
+    const deepCheckTaskIds = new Set([latestDoneTaskId, ...activeTaskIds].filter((value) => Boolean(value)));
+    const projectedTasks = [...taskIds]
+        .sort()
+        .map((taskId) => buildTaskProjection(projectRoot, taskId, taskById.get(taskId), taskBoardRows.find((row) => row.id === taskId), deepCheckTaskIds.has(taskId), issues));
+    checkLatestCloseProof(projectedTasks, latestDoneTaskId, issues);
+    const projectState = extractProjectState(sourceTexts.projectState);
+    const agentHandoff = extractAgentHandoff(sourceTexts.agentHandoff);
+    const developmentSlices = extractDevelopmentSlices(sourceTexts.developmentSlices);
+    const docsRegistry = extractDocsRegistry(projectRoot, issues);
+    const releaseReadiness = readSource(projectRoot, 'docs/RELEASE_READINESS.md');
+    if (!releaseReadiness.exists) {
+        issues.push(warning('STATE_RELEASE_READINESS_MISSING', releaseReadiness.path, 'docs/RELEASE_READINESS.md is missing.', 'Create or register release readiness docs before release work depends on this projection.'));
+    }
+    compareLatestTask('STATE_PROJECT_STATE_LATEST_MISMATCH', 'docs/PROJECT_STATE.md', projectState.latestCompletedTaskId, latestDoneTaskId, issues);
+    compareLatestTask('STATE_HANDOFF_LATEST_MISMATCH', 'docs/AGENT_HANDOFF.md', agentHandoff.latestCompletedTaskId, latestDoneTaskId, issues);
+    compareLatestTask('STATE_DEVELOPMENT_SLICES_LATEST_MISMATCH', 'docs/DEVELOPMENT_SLICES.md', developmentSlices.latestDoneTaskId, latestDoneTaskId, issues);
+    compareActiveTasks(projectState.activeTaskId, agentHandoff.activeTaskId, activeTaskIds, issues);
+    const counts = countIssues(issues);
+    return {
+        schemaVersion: 'hadara.stateProjection.v1',
+        command: 'state.projection',
+        ok: true,
+        generatedAt: now.toISOString(),
+        projectRoot,
+        summary: {
+            consistent: counts.error === 0 && counts.warning === 0,
+            issueCounts: counts,
+            latestDoneTaskId,
+            activeTaskIds,
+            checkedTasks: projectedTasks.length
+        },
+        sources: {
+            projectState: {
+                path: sourceTexts.projectState.path,
+                exists: sourceTexts.projectState.exists,
+                latestCompletedTaskId: projectState.latestCompletedTaskId,
+                activeTaskId: projectState.activeTaskId
+            },
+            agentHandoff: {
+                path: sourceTexts.agentHandoff.path,
+                exists: sourceTexts.agentHandoff.exists,
+                latestCompletedTaskId: agentHandoff.latestCompletedTaskId,
+                activeTaskId: agentHandoff.activeTaskId
+            },
+            taskBoard: {
+                path: sourceTexts.taskBoard.path,
+                exists: sourceTexts.taskBoard.exists,
+                rows: taskBoardRows.length,
+                latestDoneTaskId: latestTaskId(taskBoardRows.filter((row) => isDone(row.status)).map((row) => row.id)),
+                activeTaskIds
+            },
+            developmentSlices: {
+                path: sourceTexts.developmentSlices.path,
+                exists: sourceTexts.developmentSlices.exists,
+                latestDoneTaskId: developmentSlices.latestDoneTaskId
+            },
+            docsRegistry,
+            releaseReadiness: {
+                path: releaseReadiness.path,
+                exists: releaseReadiness.exists
+            }
+        },
+        tasks: projectedTasks,
+        issues
+    };
+}
+function toStateProjectionAdvisory(report, issueLimit = 10) {
+    const limit = Math.max(0, issueLimit);
+    return {
+        mode: 'advisory',
+        strictBlocking: false,
+        consistent: report.summary.consistent,
+        issueCounts: report.summary.issueCounts,
+        latestDoneTaskId: report.summary.latestDoneTaskId,
+        activeTaskIds: report.summary.activeTaskIds,
+        checkedTasks: report.summary.checkedTasks,
+        issues: report.issues.slice(0, limit),
+        truncatedIssues: Math.max(0, report.issues.length - limit)
+    };
+}
+function formatStateProjectionReport(report, issueLimit = 10) {
+    const advisory = toStateProjectionAdvisory(report, issueLimit);
+    const counts = `errors ${advisory.issueCounts.error}, warnings ${advisory.issueCounts.warning}, info ${advisory.issueCounts.info}`;
+    const lines = [
+        '[HADARA] State verify',
+        `consistent: ${advisory.consistent}`,
+        `issues: ${counts}`,
+        `latestDoneTaskId: ${advisory.latestDoneTaskId ?? 'none'}`,
+        `activeTaskIds: ${advisory.activeTaskIds.join(', ') || 'none'}`,
+        `checkedTasks: ${advisory.checkedTasks}`,
+        'rollout: advisory only; strict gates do not block on state projection drift yet.'
+    ];
+    for (const issue of advisory.issues) {
+        lines.push(`- ${issue.severity} ${issue.code}: ${issue.message}${issue.path ? ` (${issue.path})` : ''}`);
+    }
+    if (advisory.truncatedIssues > 0)
+        lines.push(`- ... ${advisory.truncatedIssues} more issue(s) omitted`);
+    return lines.join('\n');
+}
+function readSources(projectRoot, issues) {
+    const projectState = readSource(projectRoot, 'docs/PROJECT_STATE.md');
+    const agentHandoff = readSource(projectRoot, 'docs/AGENT_HANDOFF.md');
+    const taskBoard = readSource(projectRoot, 'docs/TASK_BOARD.md');
+    const developmentSlices = readSource(projectRoot, 'docs/DEVELOPMENT_SLICES.md');
+    for (const source of [projectState, agentHandoff, taskBoard, developmentSlices]) {
+        if (!source.exists)
+            issues.push(warning('STATE_SOURCE_MISSING', source.path, `${source.path} is missing.`, `Restore ${source.path} or run the relevant HADARA init/profile remediation.`));
+    }
+    return { projectState, agentHandoff, taskBoard, developmentSlices };
+}
+function readSource(projectRoot, relativePath) {
+    const absolutePath = node_path_1.default.join(projectRoot, relativePath);
+    const exists = node_fs_1.default.existsSync(absolutePath);
+    return {
+        path: relativePath,
+        exists,
+        content: exists ? node_fs_1.default.readFileSync(absolutePath, 'utf8') : ''
+    };
+}
+function parseTaskBoardRows(content) {
+    return (0, markdown_table_1.parseMarkdownRows)(content)
+        .filter((row) => /^T-\d{4}$/.test(row[0] ?? ''))
+        .map((row) => ({
+        id: row[0],
+        title: row[1] ?? '',
+        status: row[2] ?? '',
+        capsule: row[3] ?? ''
+    }));
+}
+function buildTaskProjection(projectRoot, taskId, task, taskBoard, deepCheck, issues) {
+    const taskPath = task ? toPortablePath(node_path_1.default.relative(projectRoot, node_path_1.default.join(task.dir, 'TASK.md'))) : '';
+    const handoffPath = task ? toPortablePath(node_path_1.default.relative(projectRoot, node_path_1.default.join(task.dir, 'HANDOFF.md'))) : '';
+    const planPath = task ? toPortablePath(node_path_1.default.relative(projectRoot, node_path_1.default.join(task.dir, 'PLAN.md'))) : '';
+    const taskStatus = task ? readTaskStatus(node_path_1.default.join(task.dir, 'TASK.md')) : null;
+    const taskHandoff = task && deepCheck ? readTaskHandoff(node_path_1.default.join(task.dir, 'HANDOFF.md')) : { exists: task ? node_fs_1.default.existsSync(node_path_1.default.join(task.dir, 'HANDOFF.md')) : false, taskStatus: null, closeState: null };
+    const plan = task && deepCheck ? readPlanState(node_path_1.default.join(task.dir, 'PLAN.md')) : { exists: task ? node_fs_1.default.existsSync(node_path_1.default.join(task.dir, 'PLAN.md')) : false, totalRows: 0, doneRows: 0, pendingRows: 0, inProgressRows: 0 };
+    const closeProof = task && deepCheck ? readCloseProof(projectRoot, task) : { path: task ? toPortablePath(node_path_1.default.relative(projectRoot, node_path_1.default.join(task.dir, 'evidence.jsonl'))) : '', state: 'unknown', sourceHash: null, currentSourceHash: null };
+    const capsule = task ? toPortablePath(node_path_1.default.relative(projectRoot, task.dir)) : taskBoard?.capsule ?? '';
+    if (!task && taskBoard) {
+        issues.push(warning('STATE_TASK_BOARD_CAPSULE_MISSING', 'docs/TASK_BOARD.md', `Task Board row ${taskId} points at ${taskBoard.capsule || '(empty)'}, but no matching capsule was found.`, `Create the missing capsule or update/remove the ${taskId} Task Board row.`, taskId));
+    }
+    if (task && !taskBoard) {
+        issues.push(warning('STATE_TASK_BOARD_ROW_MISSING', 'docs/TASK_BOARD.md', `Task Capsule ${taskId} exists but has no Task Board row.`, `Run task workflow remediation or add a Task Board row for ${taskId}.`, taskId));
+    }
+    if (task && taskBoard && taskBoard.capsule !== capsule) {
+        issues.push(warning('STATE_TASK_BOARD_CAPSULE_DRIFT', 'docs/TASK_BOARD.md', `Task Board capsule for ${taskId} is ${taskBoard.capsule || '(empty)'}, expected ${capsule}.`, `Update the Task Board capsule cell for ${taskId}.`, taskId, capsule, taskBoard.capsule || '(empty)'));
+    }
+    if (taskStatus && taskBoard?.status && taskStatus !== taskBoard.status) {
+        issues.push(warning('STATE_TASK_BOARD_STATUS_DRIFT', 'docs/TASK_BOARD.md', `Task Board status for ${taskId} is ${taskBoard.status}, but TASK.md status is ${taskStatus}.`, `Run hadara task finish --task ${taskId} --execute --json after the capsule is complete, or align the status source intentionally.`, taskId, taskStatus, taskBoard.status));
+    }
+    if (deepCheck && taskHandoff.taskStatus && !TASK_STATUS_TOKENS.has(taskHandoff.taskStatus)) {
+        issues.push(warning('STATE_TASK_HANDOFF_STATUS_INVALID', handoffPath, `Task handoff TaskStatus for ${taskId} is not a canonical task status token: ${taskHandoff.taskStatus}.`, 'Use a canonical TaskStatus token; close proof state belongs in audit-close/proof/status read models.', taskId));
+    }
+    if (deepCheck && taskHandoff.taskStatus && /pending lifecycle close|closed-valid|not-closed/i.test(taskHandoff.taskStatus)) {
+        issues.push(warning('STATE_TASK_HANDOFF_STATUS_CLOSE_STATE_MIXED', handoffPath, `Task handoff TaskStatus for ${taskId} appears to mix task status and close proof state.`, 'Use TaskStatus: Done only; derive CloseState from audit-close/proof/status read models.', taskId));
+    }
+    if (deepCheck && taskHandoff.closeState) {
+        issues.push(warning('STATE_TASK_HANDOFF_CLOSE_STATE_PERSISTED', handoffPath, `Task handoff persists derived CloseState for ${taskId}: ${taskHandoff.closeState}.`, 'Remove CloseState from task-local HANDOFF.md; use audit-close/proof/status read models for derived close state.', taskId));
+        if (!CLOSE_STATE_TOKENS.has(taskHandoff.closeState)) {
+            issues.push(warning('STATE_TASK_HANDOFF_CLOSE_STATE_INVALID', handoffPath, `Task handoff CloseState for ${taskId} is not canonical: ${taskHandoff.closeState}.`, 'Remove the CloseState row from task-local HANDOFF.md.', taskId));
+        }
+    }
+    if (deepCheck && (isDone(taskStatus) || isDone(taskBoard?.status)) && (plan.pendingRows > 0 || plan.inProgressRows > 0)) {
+        issues.push(warning('STATE_TASK_PLAN_DRIFT', planPath, `Done task ${taskId} has PLAN rows still Pending or In Progress.`, 'Update PLAN.md rows to Done or record an explicit residual-risk decision before closing.', taskId));
+    }
+    return {
+        id: taskId,
+        title: task?.title ?? taskBoard?.title ?? 'Unknown',
+        capsule,
+        task: {
+            path: taskPath,
+            exists: Boolean(task),
+            status: taskStatus
+        },
+        taskBoard: {
+            path: 'docs/TASK_BOARD.md',
+            present: Boolean(taskBoard),
+            status: taskBoard?.status ?? null,
+            capsule: taskBoard?.capsule ?? null
+        },
+        handoff: {
+            path: handoffPath,
+            exists: taskHandoff.exists,
+            taskStatus: taskHandoff.taskStatus,
+            closeState: taskHandoff.closeState
+        },
+        plan: {
+            ...plan,
+            path: planPath
+        },
+        closeProof
+    };
+}
+function readTaskStatus(taskPath) {
+    if (!node_fs_1.default.existsSync(taskPath))
+        return null;
+    const section = (0, markdown_table_1.readMarkdownSection)(node_fs_1.default.readFileSync(taskPath, 'utf8'), '## Status');
+    return section.trim().split(/\r?\n/)[0]?.trim() || null;
+}
+function readTaskHandoff(handoffPath) {
+    if (!node_fs_1.default.existsSync(handoffPath))
+        return { exists: false, taskStatus: null, closeState: null };
+    const rows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(node_fs_1.default.readFileSync(handoffPath, 'utf8'), '## Current State');
+    return {
+        exists: true,
+        taskStatus: (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'TaskStatus')?.[1] ?? (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Status')?.[1] ?? null,
+        closeState: (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'CloseState')?.[1] ?? null
+    };
+}
+function readPlanState(planPath) {
+    if (!node_fs_1.default.existsSync(planPath)) {
+        return { path: '', exists: false, totalRows: 0, doneRows: 0, pendingRows: 0, inProgressRows: 0 };
+    }
+    const rows = (0, markdown_table_1.parseMarkdownRows)(node_fs_1.default.readFileSync(planPath, 'utf8')).filter((row) => /^\d+$/.test(row[0] ?? ''));
+    return {
+        path: toPortablePath(planPath),
+        exists: true,
+        totalRows: rows.length,
+        doneRows: rows.filter((row) => normalizeStatus(row[2]) === 'done').length,
+        pendingRows: rows.filter((row) => normalizeStatus(row[2]) === 'pending').length,
+        inProgressRows: rows.filter((row) => normalizeStatus(row[2]) === 'inprogress').length
+    };
+}
+function readCloseProof(projectRoot, task) {
+    const evidencePath = node_path_1.default.join(task.dir, 'evidence.jsonl');
+    const relativeEvidencePath = toPortablePath(node_path_1.default.relative(projectRoot, evidencePath));
+    const records = (0, evidence_list_1.parseEvidenceIndexFile)(evidencePath, task.id).records.filter((record) => (0, evidence_1.persistedEvidenceKind)(record) === 'command-log' && /Task close validation .* before close evidence append/.test(record.summary));
+    const latest = records.at(-1);
+    const currentSourceHash = hashCloseRelevantSource(projectRoot, task.dir);
+    if (!latest)
+        return { path: relativeEvidencePath, state: 'not-closed', sourceHash: null, currentSourceHash };
+    const sourceHash = extractSourceHash(latest.summary);
+    const passed = (0, evidence_1.persistedEvidenceResult)(latest) === 'passed';
+    const state = !passed ? 'closed-invalid' : sourceHash && sourceHash !== currentSourceHash ? 'closed-stale' : 'closed-valid';
+    return { path: relativeEvidencePath, state, sourceHash, currentSourceHash };
+}
+function extractProjectState(source) {
+    const rows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(source.content, '## Metadata');
+    return {
+        latestCompletedTaskId: extractTaskId((0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Latest Completed Task')?.[1] ?? ''),
+        activeTaskId: extractTaskId((0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Active Task')?.[1] ?? '')
+    };
+}
+function extractAgentHandoff(source) {
+    const currentRows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(source.content, '## Current State');
+    const latest = (0, markdown_table_1.findMarkdownRowByCell)(currentRows, 0, 'Latest Completed Task')?.[1] ?? '';
+    const active = (0, markdown_table_1.findMarkdownRowByCell)(currentRows, 0, 'Active / Next Task')?.[1] ?? '';
+    const lastThreeRows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(source.content, '## Last 3 Completed Tasks');
+    return {
+        latestCompletedTaskId: extractTaskId(latest) ?? extractTaskId(lastThreeRows.find((row) => /^T-\d{4}/.test(row[0] ?? ''))?.[0] ?? ''),
+        activeTaskId: extractTaskId(active)
+    };
+}
+function extractDevelopmentSlices(source) {
+    const rows = (0, markdown_table_1.parseMarkdownRows)(source.content);
+    const doneIds = rows
+        .filter((row) => /^T-\d{4}$/.test(row[2] ?? '') && /^Done\b/.test(row[4] ?? ''))
+        .map((row) => row[2]);
+    return { latestDoneTaskId: latestTaskId(doneIds) };
+}
+function extractDocsRegistry(projectRoot, issues) {
+    const source = readSource(projectRoot, '.hadara/docs-registry.json');
+    if (!source.exists) {
+        issues.push(warning('STATE_DOCS_REGISTRY_MISSING', source.path, '.hadara/docs-registry.json is missing.', 'Run docs registry generation or protocol migration before relying on docs state projection.'));
+        return { path: source.path, exists: false, registeredDocuments: null, statusCounts: {} };
+    }
+    try {
+        const parsed = JSON.parse(source.content);
+        const documents = Array.isArray(parsed.documents) ? parsed.documents : [];
+        return {
+            path: source.path,
+            exists: true,
+            registeredDocuments: documents.length,
+            statusCounts: documents.reduce((acc, doc) => {
+                const status = doc.status ?? 'unknown';
+                acc[status] = (acc[status] ?? 0) + 1;
+                return acc;
+            }, {})
+        };
+    }
+    catch (error) {
+        issues.push(warning('STATE_DOCS_REGISTRY_INVALID_JSON', source.path, `.hadara/docs-registry.json could not be parsed: ${error instanceof Error ? error.message : String(error)}`, 'Repair the docs registry JSON before relying on document state projection.'));
+        return { path: source.path, exists: true, registeredDocuments: null, statusCounts: {} };
+    }
+}
+function compareLatestTask(code, sourcePath, actual, expected, issues) {
+    if (!actual || !expected || actual === expected)
+        return;
+    issues.push(warning(code, sourcePath, `${sourcePath} points to latest completed task ${actual}, but the projected latest Done task is ${expected}.`, `Update ${sourcePath} latest completed task state to ${expected} or correct the Done task source.`, undefined, expected, actual));
+}
+function compareActiveTasks(projectActive, handoffActive, activeTaskIds, issues) {
+    const expected = activeTaskIds[0] ?? null;
+    if (activeTaskIds.length > 1) {
+        issues.push(warning('STATE_MULTIPLE_ACTIVE_TASKS', 'docs/TASK_BOARD.md', `Task Board has multiple active tasks: ${activeTaskIds.join(', ')}.`, 'Keep only one In Progress task unless a future coordinator explicitly supports parallel active work.'));
+    }
+    if (expected && projectActive && projectActive !== expected) {
+        issues.push(warning('STATE_PROJECT_ACTIVE_TASK_MISMATCH', 'docs/PROJECT_STATE.md', `Project State active task is ${projectActive}, but Task Board active task is ${expected}.`, `Update Project State Active Task to ${expected} or finish/reclassify the Task Board row.`, undefined, expected, projectActive));
+    }
+    if (expected && handoffActive && handoffActive !== expected) {
+        issues.push(warning('STATE_HANDOFF_ACTIVE_TASK_MISMATCH', 'docs/AGENT_HANDOFF.md', `Agent Handoff active task is ${handoffActive}, but Task Board active task is ${expected}.`, `Update Agent Handoff Active / Next Task to ${expected} or finish/reclassify the Task Board row.`, undefined, expected, handoffActive));
+    }
+    if (!expected && projectActive) {
+        issues.push(warning('STATE_PROJECT_ACTIVE_TASK_STALE', 'docs/PROJECT_STATE.md', `Project State names active task ${projectActive}, but Task Board has no In Progress task.`, 'Set Active Task to None or mark the active Task Board row In Progress.', undefined, 'None', projectActive));
+    }
+}
+function checkLatestCloseProof(projectedTasks, latestDoneTaskId, issues) {
+    if (!latestDoneTaskId)
+        return;
+    const task = projectedTasks.find((candidate) => candidate.id === latestDoneTaskId);
+    if (!task)
+        return;
+    if (task.closeProof.state === 'closed-valid')
+        return;
+    if (task.closeProof.state === 'not-closed') {
+        issues.push(warning('STATE_LATEST_CLOSE_PROOF_MISSING', task.closeProof.path, `Latest Done task ${latestDoneTaskId} has no close proof.`, `Run hadara task ready --task ${latestDoneTaskId} --level done --json, then task close/audit-close.`, latestDoneTaskId));
+        return;
+    }
+    if (task.closeProof.state === 'closed-stale') {
+        issues.push(warning('STATE_LATEST_CLOSE_PROOF_STALE', task.closeProof.path, `Latest Done task ${latestDoneTaskId} has stale close proof.`, `Rerun hadara task ready --task ${latestDoneTaskId} --level done --json, then task close/audit-close after intentional close-source edits.`, latestDoneTaskId, task.closeProof.currentSourceHash ?? undefined, task.closeProof.sourceHash ?? undefined));
+        return;
+    }
+    issues.push(warning('STATE_LATEST_CLOSE_PROOF_INVALID', task.closeProof.path, `Latest Done task ${latestDoneTaskId} close proof is ${task.closeProof.state}.`, `Rerun task close/audit-close for ${latestDoneTaskId} after resolving validation blockers.`, latestDoneTaskId));
+}
+function hashCloseRelevantSource(projectRoot, taskDir) {
+    const payload = (0, task_close_1.closeRelevantSourceRelativePaths)(projectRoot, taskDir).map((relativePath) => {
+        const absolutePath = node_path_1.default.join(projectRoot, relativePath);
+        return {
+            path: relativePath,
+            exists: node_fs_1.default.existsSync(absolutePath),
+            sha256: node_fs_1.default.existsSync(absolutePath) ? node_crypto_1.default.createHash('sha256').update(node_fs_1.default.readFileSync(absolutePath)).digest('hex') : null
+        };
+    });
+    return `sha256:${node_crypto_1.default.createHash('sha256').update(JSON.stringify(payload), 'utf8').digest('hex')}`;
+}
+function extractSourceHash(summary) {
+    return summary.match(/sourceHash\s+(sha256:[a-f0-9]+)/)?.[1] ?? null;
+}
+function extractTaskId(value) {
+    return value.match(/\bT-\d{4}\b/)?.[0] ?? null;
+}
+function latestTaskId(ids) {
+    return ids.sort().at(-1) ?? null;
+}
+function normalizeStatus(value) {
+    return (value ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '');
+}
+function isDone(value) {
+    return normalizeStatus(value) === 'done';
+}
+function isActive(value) {
+    return normalizeStatus(value) === 'inprogress';
+}
+function countIssues(issues) {
+    return {
+        error: issues.filter((issue) => issue.severity === 'error').length,
+        warning: issues.filter((issue) => issue.severity === 'warning').length,
+        info: issues.filter((issue) => issue.severity === 'info').length
+    };
+}
+function warning(code, pathValue, message, fixHint, taskId, expected, actual) {
+    return {
+        severity: 'warning',
+        code,
+        path: pathValue,
+        ...(taskId ? { taskId } : {}),
+        message,
+        ...(expected ? { expected } : {}),
+        ...(actual ? { actual } : {}),
+        fixHint
+    };
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/task/task-capsule.js

@@ -26,7 +26,7 @@ exports.TASK_FILES = {
     'DECISIONS.md': () => `# Decisions\n\n| ID | Decision | Status | Rationale | Evidence |\n|---|---|---|---|---|\n`,
     'EVIDENCE.md': () => `# Evidence\n\n| Time | Kind | Summary | Result | Visibility | JSONL |\n|---|---|---|---|---|---|\n`,
     'evidence.jsonl': () => '',
-    'HANDOFF.md': (task) => `# Handoff\n\n## Current State\n\n${(0, managed_sections_1.managedSectionBlock)('task-handoff-current-state', { schema: 'hadara.managedSection.v1', owner: 'handoff.update', kind: 'key-value-table', mode: 'update-row', version: 1, required: true, closeSourceRole: 'included' }, `| Field | Value |\n|---|---|\n| Task | ${task.id} |\n| Status | Draft |\n| Last Updated | TBD |\n`)}\n\n## Last Completed\n\n| Item | Evidence |\n|---|---|\n| TBD | TBD |\n\n## Next Recommended Step\n\n| Step | Reason | Required Reading |\n|---|---|---|\n| TBD | TBD | TBD |\n\n## Carry Forward Warnings\n\n| Warning | Impact | Mitigation |\n|---|---|---|\n`
+    'HANDOFF.md': (task) => `# Handoff\n\n## Current State\n\n${(0, managed_sections_1.managedSectionBlock)('task-handoff-current-state', { schema: 'hadara.managedSection.v1', owner: 'handoff.update', kind: 'key-value-table', mode: 'update-row', version: 1, required: true, closeSourceRole: 'included' }, `| Field | Value |\n|---|---|\n| Task | ${task.id} |\n| TaskStatus | Draft |\n| Last Updated | TBD |\n`)}\n\n## Last Completed\n\n| Item | Evidence |\n|---|---|\n| TBD | TBD |\n\n## Next Recommended Step\n\n| Step | Reason | Required Reading |\n|---|---|---|\n| TBD | TBD | TBD |\n\n## Carry Forward Warnings\n\n| Warning | Impact | Mitigation |\n|---|---|---|\n`
 };
 function isTaskCapsuleScaffoldContent(task, fileName, content) {
     if (fileName === 'TASK.md') {
@@ -146,7 +146,11 @@ function listTaskCapsules(projectRoot) {
         return [];
     return node_fs_1.default
         .readdirSync(tasksDir, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory() && /^T-\d{4}-/.test(entry.name))
+        .filter((entry) => {
+        if (!entry.isDirectory() || !/^T-\d{4}-/.test(entry.name))
+            return false;
+        return node_fs_1.default.existsSync(node_path_1.default.join(tasksDir, entry.name, 'TASK.md'));
+    })
         .map((entry) => {
         const [id, ...slugParts] = entry.name.split('-');
         const number = slugParts.shift();
@@ -169,7 +173,9 @@ function findTaskCapsule(projectRoot, taskId) {
         return undefined;
     const entry = node_fs_1.default
         .readdirSync(tasksDir, { withFileTypes: true })
-        .find((candidate) => candidate.isDirectory() && candidate.name.startsWith(`${taskId}-`));
+        .find((candidate) => candidate.isDirectory() &&
+        candidate.name.startsWith(`${taskId}-`) &&
+        node_fs_1.default.existsSync(node_path_1.default.join(tasksDir, candidate.name, 'TASK.md')));
     if (!entry)
         return undefined;
     const slug = entry.name.slice(`${taskId}-`.length);

package/dist/tui/read-model.js

@@ -349,7 +349,7 @@ function createSelectedTaskReadModel(projectRoot, summary, options = {}) {
 }
 function createFastSelectedTaskReadModel(projectRoot, summary, options) {
     const detail = createTaskDocumentReadReportFromSummary(projectRoot, summary, { includePrivate: false });
-    const evidenceIndex = detail.evidenceIndex ?? [];
+    const evidenceIndex = (detail.evidenceIndex ?? []);
     const evidence = limitEvidenceListReport({
         schemaVersion: 'hadara.evidence.list.v1',
         command: 'evidence.list',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hadara",
-  "version": "0.3.0",
+  "version": "0.3.2-rc.0",
   "private": false,
   "license": "MIT",
   "description": "Portable AI-assisted development workbench for evidence-backed task capsules, handoffs, and release gates.",