hadara 0.3.0 → 0.3.1-rc.1

package/README.md

@@ -6,7 +6,7 @@
 
 <p align="center">
   <img alt="Stable npm release" src="https://img.shields.io/badge/npm-0.3.0-blue">
-  <img alt="Source version" src="https://img.shields.io/badge/source-0.3.0-orange">
+  <img alt="Source version" src="https://img.shields.io/badge/source-0.3.1--rc.1-orange">
   <img alt="Node.js" src="https://img.shields.io/badge/node-%3E%3D22-brightgreen">
   <img alt="License" src="https://img.shields.io/badge/license-MIT-lightgrey">
 </p>
@@ -27,26 +27,22 @@ Current stable npm release:
 hadara@0.3.0
 ```
 
-Previous npm release candidate:
+Current release candidate:
 
 ```text
-hadara@0.3.0-rc.2
+hadara@0.3.1-rc.1
 ```
 
-The 0.3.0 line is the Phase 7 Surface Refactor. It organizes HADARA's existing task, evidence, proof, lifecycle, release, and document surfaces so agents can distinguish primary lifecycle commands, diagnostics, advanced surfaces, canonical documents, historical documents, and safe Markdown update boundaries.
+The 0.3.1-rc.1 line is the Phase 8 State Governance release candidate. It hardens status-token vocabulary, document ownership/write boundaries, handoff close-state handling, installed-package finding guidance, and state consistency verification surfaces after the stable 0.3.0 publish/recycle.
 
-Phase 7.x labels are internal implementation phases, not npm release-candidate labels. The stable `0.3.0` package is published through the approval-gated release path with explicit operator confirmation.
+Phase 8.x labels are internal implementation phases, not npm release-candidate labels. The stable `0.3.0` package remains the default install target; the `0.3.1-rc.1` package is for explicit release-candidate evaluation.
 
 | Surface | Status |
 |---|---|
-| npm package | Primary release target. |
-| `hadara@0.2.0-rc.1` | Previous published npm RC. |
-| `hadara@0.2.0-rc.2` | Previous published npm RC. |
-| `hadara@0.2.0-rc.3` | Previous published npm RC. |
-| `hadara@0.3.0-rc.0` | Previous published npm RC; package metadata lacks the intended discovery fields. |
-| `hadara@0.3.0-rc.1` | Previous published npm RC; T-0301 publish evidence verified `npm view` returned `0.3.0-rc.1`. |
-| `hadara@0.3.0-rc.2` | Previous published npm RC; T-0310 publish evidence verified `npm view` returned `0.3.0-rc.2`. |
-| `hadara@0.3.0` | Current stable npm release. |
+| Current stable | [`hadara@0.3.0`](docs/RELEASE_NOTES.md#030) |
+| Current RC | [`hadara@0.3.1-rc.1`](docs/RELEASE_NOTES.md#031-rc1) |
+| Previous RC | [`hadara@0.3.0-rc.2`](docs/RELEASE_NOTES.md#030-rc2) |
+| Historical RCs | See [Release Notes](docs/RELEASE_NOTES.md). |
 | GitHub Release | Secondary target, approval-gated. |
 | Docker image | Deferred. |
 | PyPI/Python package | `hadara==0.2.0rc1` published preview bridge. |
@@ -73,6 +69,23 @@ npx hadara@0.3.0 help
 npx hadara@0.3.0 doctor --json
 ```
 
+Evaluate the release candidate explicitly:
+
+```bash
+npm install -g hadara@0.3.1-rc.1
+npx hadara@0.3.1-rc.1 help
+```
+
+For release or recycle evidence, prefer an isolated prefix install when PATH, global installs, or `npx` cache behavior may be stale:
+
+```bash
+tmp="$(mktemp -d)"
+npm --prefix "$tmp" install hadara@0.3.0
+"$tmp/node_modules/.bin/hadara" version --json
+```
+
+`npx hadara@0.3.0 ...` remains convenient for normal use. The isolated installed-bin path is stronger proof that the published package installed and executed from the intended package tree.
+
 ## What HADARA Gives You
 
 | Capability | Purpose |
@@ -219,7 +232,7 @@ Dashboard, TUI, Hermes, MCP, installer, package, release, and run commands stay
 
 ## Safety Boundaries
 
-HADARA 0.3.0 is not:
+HADARA 0.3.1-rc.1 is not:
 
 - a full agent runtime;
 - Rack/enterprise behavior;
@@ -292,19 +305,6 @@ node dist/cli/main.js doctor --json
 npm run check
 ```
 
-For HADARA-dev itself, Docker is the preferred validation path because host `node_modules` on mounted workspaces can be unreliable:
-
-```bash
-npm run dev:docker-check
-npm run dev:docker-sync-build
-```
-
-Focused validation:
-
-```bash
-npm run test:focused -- tests/unit/release-dry-run.test.ts
-```
-
 Optional integrations are not generated by `hadara init` and are not part of the default scaffold:
 
 ```bash

package/dist/cli/init.js

@@ -571,7 +571,7 @@ function sopRequiredReadingRowsForProfile(profile) {
         rows.push(['`docs/ARCHITECTURE.md`', 'Architecture, component, or boundary work', 'Current system shape and ownership boundaries.'], ['`docs/DEVELOPMENT_SLICES.md`', 'Starting, completing, or reclassifying slices', 'Roadmap ordering and completion evidence.'], ['`docs/DECISIONS.md`', 'Project-level decision work', 'Durable decisions that affect architecture or workflow.'], ['`docs/TEST_STRATEGY.md`', 'Validation planning or completion checks', 'Routine suites and special-case smoke boundaries.']);
     }
     if (profile === 'governed') {
-        rows.push(['`docs/SECURITY_MODEL.md`', 'Security, secret, permission, or evidence-safety work', 'Project security invariants and special checks.'], ['`docs/REFACTOR_LOG.md`', 'Refactor, migration, removal, or replacement work', 'Project-level refactor history.'], ['`docs/ROADMAP.md`', 'Roadmap, milestone, or scope planning', 'Longer-term priorities and deferred work.']);
+        rows.push(['`docs/SECURITY_MODEL.md`', 'Security, secret, permission, or evidence-safety work', 'Project security invariants and special checks.'], ['`docs/ROADMAP.md`', 'Roadmap, milestone, or scope planning', 'Longer-term priorities and deferred work.']);
     }
     return rows;
 }
@@ -587,7 +587,7 @@ function agentsRequiredReadingRowsForProfile(profile) {
         rows.push({ document: '`docs/ARCHITECTURE.md`', when: 'Architecture, component, or boundary work', purpose: 'Current system shape and ownership boundaries.' }, { document: '`docs/DEVELOPMENT_SLICES.md`', when: 'Starting, completing, or reclassifying a development slice', purpose: 'Roadmap ordering, prerequisites, and completion evidence.' }, { document: '`docs/DECISIONS.md`', when: 'Project-level decision work', purpose: 'Durable project decisions.' }, { document: '`docs/TEST_STRATEGY.md`', when: 'Validation planning or completion checks', purpose: 'Routine suites and special-case checks.' });
     }
     if (profile === 'governed') {
-        rows.push({ document: '`docs/SECURITY_MODEL.md`', when: 'Security, secret, permission, or evidence-safety work', purpose: 'Project security invariants.' }, { document: '`docs/REFACTOR_LOG.md`', when: 'Refactor, migration, removal, or replacement work', purpose: 'Project-level refactor history.' }, { document: '`docs/ROADMAP.md`', when: 'Roadmap, milestone, or scope planning', purpose: 'Longer-term priorities and deferred work.' });
+        rows.push({ document: '`docs/SECURITY_MODEL.md`', when: 'Security, secret, permission, or evidence-safety work', purpose: 'Project security invariants.' }, { document: '`docs/ROADMAP.md`', when: 'Roadmap, milestone, or scope planning', purpose: 'Longer-term priorities and deferred work.' });
     }
     return rows;
 }
@@ -710,7 +710,7 @@ function requiredDocsForProfile(profile) {
         docs.push('docs/ARCHITECTURE.md', 'docs/DEVELOPMENT_SLICES.md', 'docs/DECISIONS.md', 'docs/TEST_STRATEGY.md');
     }
     if (profile === 'governed') {
-        docs.push('docs/SECURITY_MODEL.md', 'docs/REFACTOR_LOG.md', 'docs/ROADMAP.md');
+        docs.push('docs/SECURITY_MODEL.md', 'docs/ROADMAP.md');
     }
     return docs;
 }
@@ -973,9 +973,6 @@ function createImplementationSopDoc(spec) {
     if (spec.docs.securityModel) {
         requiredReadingRows.push(['`docs/SECURITY_MODEL.md`', 'Security, secret, permission, or evidence-safety work', 'Project security invariants and special checks.']);
     }
-    if (spec.docs.refactorLog) {
-        requiredReadingRows.push(['`docs/REFACTOR_LOG.md`', 'Refactor, migration, removal, or replacement work', 'Project-level refactor history.']);
-    }
     if (spec.docs.roadmap) {
         requiredReadingRows.push(['`docs/ROADMAP.md`', 'Roadmap, milestone, release, or scope planning', 'Longer-term priorities and deferred work.']);
     }
@@ -1095,6 +1092,16 @@ Keep capsule docs current as work changes:
 
 Parallelize read-only discovery, \`rg\`/file inspection, independent validation commands, package or registry metadata inspection, read-only diagnostics, and draft preparation before writes. Serialize same-file writes, evidence append, Task Capsule doc writes, Task Board writes, Project State writes, Agent Handoff writes, before-hash execute operations, \`task finish --execute\`, \`task close --execute\`, and release artifact or publish operations.
 
+## Status Token And Document Ownership Policy
+
+Use distinct token families for persistent task state, close proof state, document registry state, and evidence outcomes. \`TaskStatus\` belongs to Task Capsule metadata, \`TASK.md\` Status/Status History, and command-owned \`docs/TASK_BOARD.md\` cells. Valid persistent task tokens are \`Draft\`, \`In Progress\`, \`Blocked\`, \`Done\`, \`Partial\`, \`Superseded\`, and \`Archived\`.
+
+\`CloseState\` is derived from close evidence and \`task audit-close\`; do not write close proof values as \`TaskStatus\`, and do not persist \`CloseState\` in task-local \`HANDOFF.md\` close-source current-state tables. Canonical close-state tokens are \`not-closed\`, \`closed-valid\`, \`closed-stale\`, \`closed-invalid\`, and \`unknown\`. Compatibility diagnostics such as \`close-evidence-found-invalid\`, \`close-evidence-malformed\`, and \`closed-with-drift-warnings\` are close-state details, not task status.
+
+\`DocStatus\` belongs only to the docs registry and uses \`canonical\`, \`active\`, \`reference\`, \`historical\`, \`superseded\`, and \`archived\`. Evidence outcomes are \`passed\`, \`failed\`, \`blocked\`, and \`unknown\`; preserve failed or blocked evidence and append newer corrective evidence instead of rewriting history.
+
+Ownership boundaries follow the lifecycle command model. \`task finish --execute\` owns bounded status bookkeeping in \`TASK.md\` and command-owned \`docs/TASK_BOARD.md\` cells. \`task close --execute\` owns only close evidence append. Operators own close-source prose and shared state docs before close, then rerun ready/close/audit after any intentional close-source edit.
+
 ## Standard Task Workflow Loop
 
 The authoritative command semantics live in \`docs/TASK_WORKFLOW_COMMANDS.md\`. For ordinary implementation capsules, use this loop:
@@ -1353,6 +1360,68 @@ The close model has three separate phases: validation proves readiness, close re
 
 \`task ready\` and \`task close\` include done-level Task Capsule validation. Use \`hadara harness validate --task T-XXXX --level done --json\` directly when debugging capsule format, status-history, acceptance, evidence, or handoff validation failures.
 
+## Status Token And Ownership Policy
+
+HADARA uses separate token families for persistent state, derived proof state, document registry state, and evidence outcomes. Do not collapse these families into a single Markdown \`Status\` field.
+
+### TaskStatus
+
+\`TaskStatus\` is persistent task lifecycle state in \`TASK.md\` metadata, the \`## Status\` section, Status History rows, and the command-owned cells of \`docs/TASK_BOARD.md\`.
+
+| Token | Meaning | Writer |
+|---|---|---|
+| \`Draft\` | Task capsule exists but implementation is not started or not yet ready for done-level validation. | \`task create\`, worker docs |
+| \`In Progress\` | Work is actively being performed. | Worker docs |
+| \`Blocked\` | Work cannot proceed without a recorded blocker. | Worker docs |
+| \`Done\` | Scoped work is implemented and ready for done-level validation/close. | \`task finish --execute\` |
+| \`Partial\` | Deliberate partial completion with remaining scope deferred or split. | Worker/coordinator docs |
+| \`Superseded\` | Task has been replaced by another task or line. | Worker/coordinator docs |
+| \`Archived\` | Task is no longer active state and is retained only for history. | Worker/coordinator docs |
+
+Reserved non-TaskStatus strings include \`Closed\`, \`Ready\`, \`Approved\`, \`Complete\`, \`closed-valid\`, \`not-closed\`, and phrases such as \`Done pending lifecycle close\`. Use \`TaskStatus: Done\`; get close proof state from \`task status\`, \`task audit-close\`, proof status, or \`state verify\` read models.
+
+### CloseState
+
+\`CloseState\` is derived proof state from close evidence and \`task audit-close\`; it is not written as persistent \`TaskStatus\` and should not be stored in task-local \`HANDOFF.md\` current-state tables.
+
+| Canonical Token | Meaning |
+|---|---|
+| \`not-closed\` | No valid close proof has been recorded. |
+| \`closed-valid\` | Close evidence exists and audit reports current/fresh proof. |
+| \`closed-stale\` | Close evidence exists but source or validation hashes drifted after close. |
+| \`closed-invalid\` | Close-like evidence exists but audit reports invalid shape, failed result, or mismatch. |
+| \`unknown\` | The projection cannot determine close state. |
+
+Current compatibility read models may expose more specific diagnostic values such as \`close-evidence-found-invalid\`, \`close-evidence-malformed\`, or \`closed-with-drift-warnings\`. Treat those as CloseState diagnostics, not TaskStatus values.
+
+### DocStatus
+
+\`DocStatus\` is stored in the document registry only.
+
+| Token | Meaning |
+|---|---|
+| \`canonical\` | Core scaffold/current-state document. |
+| \`active\` | Active working document or task-work document. |
+| \`reference\` | Conditional reference document. |
+| \`historical\` | Historical context, never default required reading. |
+| \`superseded\` | Replaced by another registered document. |
+| \`archived\` | Retained only as archive candidate/history. |
+
+### EvidenceOutcome
+
+Evidence outcome tokens are \`passed\`, \`failed\`, \`blocked\`, and \`unknown\`. Failed or blocked evidence must remain visible; add newer evidence that explains the fix or residual risk instead of editing old records.
+
+### Write Ownership
+
+| Surface | Ownership |
+|---|---|
+| \`TASK.md\` status metadata, \`## Status\`, and Status History | Command-owned for finish bookkeeping; worker-owned before finish. |
+| \`docs/TASK_BOARD.md\` ID/title/status/capsule cells | Command-owned by \`task finish\`; Notes and extra cells are mixed/human-owned. |
+| \`EVIDENCE.md\` and \`evidence.jsonl\` | Evidence writer-owned; do not hand-edit \`evidence.jsonl\`. |
+| \`HANDOFF.md\` managed current-state table | Managed/mixed; persist \`TaskStatus\` only. \`CloseState\` is derived by status/audit/proof/state read models and should not be written into close-source handoff tables. |
+| Shared state docs | Mixed/human-owned; update before close when they are close-source relevant. |
+| \`.hadara/docs-registry.json\` and \`docs/DOC_REGISTRY.md\` | Docs registry-owned; registry mutations should stay dry-run-first or explicitly scoped. |
+
 Before close, finish all close-source edits: Task Capsule docs, acceptance/tests/handoff notes, evidence summaries, \`docs/TASK_BOARD.md\`, and tracked state docs such as \`docs/PROJECT_STATE.md\`, \`docs/AGENT_HANDOFF.md\`, and roadmap/slice docs when they apply. After \`task close --execute --json\`, changing those documents changes the close source hash and requires rerunning \`task ready\`, \`task close\`, and \`task audit-close\`. Do not paste volatile close evidence ids into close-source docs; prefer stable wording such as "close evidence appended; audit returned closed-valid".
 
 ## Documentation Timing and Write Coordination
@@ -1415,8 +1484,6 @@ function createAgentsDoc(spec) {
         requiredReadingRows.push([String(order++), '`docs/TEST_STRATEGY.md`', 'Validation planning or completion checks', 'Routine suites and special-case checks.']);
     if (spec.docs.securityModel)
         requiredReadingRows.push([String(order++), '`docs/SECURITY_MODEL.md`', 'Security, secret, permission, or evidence-safety work', 'Project security invariants.']);
-    if (spec.docs.refactorLog)
-        requiredReadingRows.push([String(order++), '`docs/REFACTOR_LOG.md`', 'Refactor, migration, removal, or replacement work', 'Project-level refactor history.']);
     if (spec.docs.roadmap)
         requiredReadingRows.push([String(order++), '`docs/ROADMAP.md`', 'Roadmap, milestone, or scope planning', 'Longer-term priorities and deferred work.']);
     requiredReadingRows.push([String(order++), 'Active `tasks/T-*/TASK.md`', 'Working a task', 'Task-specific goal, scope, and status.'], [String(order++), 'Active Task Capsule docs', 'Working a task', 'Decisions, plan, context, acceptance, files, tests, risks, handoff, and evidence.'], [String(order++), 'Project-specific registered docs', 'When listed in `docs/IMPLEMENTATION_SOP.md`', 'Specs, contracts, or roadmap files explicitly added by this project.']);

package/dist/cli/main.js

@@ -173,6 +173,12 @@ async function main(args = process.argv.slice(2)) {
                 return;
             break;
         }
+        case 'state': {
+            const { handleStateCommand } = await Promise.resolve().then(() => __importStar(require('./state')));
+            if (handleStateCommand({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
         case 'dashboard': {
             const { handleDashboardCommand } = await Promise.resolve().then(() => __importStar(require('./dashboard')));
             if (handleDashboardCommand({ args, projectRoot: paths.projectRoot }))

package/dist/cli/state.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStateCommand = handleStateCommand;
+const state_projection_1 = require("../services/state-projection");
+function handleStateCommand(input) {
+    if (input.args[0] !== 'state' || input.args[1] !== 'verify')
+        return false;
+    const report = (0, state_projection_1.createStateProjectionReport)(input.projectRoot);
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log((0, state_projection_1.formatStateProjectionReport)(report));
+    }
+    return true;
+}

package/dist/cli/status.js

@@ -16,7 +16,7 @@ function handleOpsCommand(input) {
     return true;
 }
 function printStatus(projectRoot, jsonOutput) {
-    const report = (0, operations_status_service_1.createOpsStatusReport)(projectRoot);
+    const report = (0, operations_status_service_1.createOpsStatusReport)(projectRoot, { includeStateConsistency: true });
     if (jsonOutput) {
         console.log(JSON.stringify(report, null, 2));
     }

package/dist/core/schema.js

@@ -49,6 +49,7 @@ const release_gate_schema_json_1 = __importDefault(require("../schemas/release-g
 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 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_complete_flow_schema_json_1 = __importDefault(require("../schemas/task-complete-flow.schema.json"));
@@ -115,6 +116,7 @@ const registeredSchemas = {
     'hadara.releasePublish.v1': release_publish_schema_json_1.default,
     'hadara.runtime.version.v1': runtime_version_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.complete_flow.v1': task_complete_flow_schema_json_1.default,

package/dist/harness/validate.js

@@ -25,6 +25,8 @@ const REQUIRED_TASK_FILES = [
 const EVIDENCE_KINDS = new Set(['test-log', 'command-log', 'diff-summary', 'screenshot', 'note']);
 const EVIDENCE_RESULTS = new Set(['passed', 'failed', 'blocked', 'unknown']);
 const EVIDENCE_VISIBILITIES = new Set(['public', 'private']);
+const TASK_STATUS_TOKENS = new Set(['draft', 'in progress', 'blocked', 'done', 'partial', 'superseded', 'archived']);
+const STALE_PENDING_CLOSE_PATTERN = /\b(?:done\s+pending\s+lifecycle\s+close|pending\s+lifecycle\s+close)\b/i;
 const DONE_SEMANTIC_EVIDENCE_CODES = new Set([
     'TASK_DONE_WITHOUT_SUBSTANTIVE_EVIDENCE',
     'TASK_DONE_WITH_FAILED_EVIDENCE',
@@ -338,6 +340,8 @@ function validateDoneLevel(projectRoot, task, issues, checkedFiles) {
     validateEvidenceIndexHasRecords(projectRoot, task, issues);
     validateEvidenceSemanticGates(projectRoot, task, issues);
     validateHandoffDone(projectRoot, task, issues);
+    validateHandoffCurrentStateTokens(projectRoot, task, issues);
+    validatePlanStatusDrift(projectRoot, task, issues);
     validateTaskBoardDone(projectRoot, task, issues, checkedFiles);
 }
 function validateTaskMetadataComplete(projectRoot, task, issues) {
@@ -645,6 +649,112 @@ function validateHandoffDone(projectRoot, task, issues) {
         });
     }
 }
+function validateHandoffCurrentStateTokens(projectRoot, task, issues) {
+    const handoffPath = node_path_1.default.join(task.dir, 'HANDOFF.md');
+    if (!node_fs_1.default.existsSync(handoffPath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, handoffPath));
+    const currentState = readSectionBody(handoffPath, '## Current State');
+    const fields = handoffCurrentStateFields(currentState);
+    const taskStatus = fields.get('taskstatus') ?? fields.get('task status');
+    const legacyStatus = fields.get('status');
+    const closeState = fields.get('closestate') ?? fields.get('close state');
+    if (taskStatus && !isTaskStatusToken(taskStatus)) {
+        issues.push(handoffStatusIssue(relativePath, `HANDOFF.md TaskStatus uses non-canonical value "${taskStatus}".`));
+    }
+    if (legacyStatus) {
+        if (STALE_PENDING_CLOSE_PATTERN.test(legacyStatus)) {
+            issues.push(handoffStatusIssue(relativePath, 'HANDOFF.md legacy Status mixes lifecycle state with pending close proof wording.'));
+        }
+        else if (!isTaskStatusToken(legacyStatus)) {
+            issues.push(handoffStatusIssue(relativePath, `HANDOFF.md legacy Status uses non-canonical value "${legacyStatus}".`));
+        }
+    }
+    if (STALE_PENDING_CLOSE_PATTERN.test(currentState) && (!legacyStatus || !STALE_PENDING_CLOSE_PATTERN.test(legacyStatus))) {
+        issues.push(handoffStatusIssue(relativePath, 'HANDOFF.md Current State contains stale pending lifecycle close wording.'));
+    }
+    if (closeState) {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_HANDOFF_CLOSE_STATE_PERSISTED',
+            message: `HANDOFF.md persists derived CloseState value "${closeState}".`,
+            path: relativePath,
+            heading: 'Current State',
+            fixHint: 'Remove the CloseState row from task-local HANDOFF.md; use task status, audit-close, proof status, or state verify read models for derived close state.',
+            example: '| TaskStatus | Done |',
+            remediationHint: {
+                path: relativePath,
+                heading: 'Current State',
+                requiredChange: 'Remove persistent CloseState from this close-source handoff table.',
+                example: '| TaskStatus | Done |',
+                blocking: true
+            }
+        });
+    }
+}
+function handoffCurrentStateFields(currentState) {
+    const fields = new Map();
+    for (const cells of (0, markdown_table_1.parseMarkdownRows)(currentState)) {
+        if (cells.length < 2 || /^field$/i.test(cells[0] ?? ''))
+            continue;
+        fields.set(normalizeFieldName(cells[0] ?? ''), cells[1]?.trim() ?? '');
+    }
+    return fields;
+}
+function handoffStatusIssue(relativePath, message) {
+    return {
+        severity: 'error',
+        code: 'TASK_HANDOFF_STATUS_DRIFT',
+        message,
+        path: relativePath,
+        heading: 'Current State',
+        fixHint: 'Use `TaskStatus` for lifecycle state only; close proof state is derived from audit-close/proof/status read models.',
+        example: '| TaskStatus | Done |',
+        remediationHint: {
+            path: relativePath,
+            heading: 'Current State',
+            requiredChange: 'Replace ambiguous Status wording with canonical TaskStatus and remove close-proof wording from HANDOFF.md.',
+            example: '| TaskStatus | Done |',
+            blocking: true
+        }
+    };
+}
+function validatePlanStatusDrift(projectRoot, task, issues) {
+    const planPath = node_path_1.default.join(task.dir, 'PLAN.md');
+    if (!node_fs_1.default.existsSync(planPath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, planPath));
+    const rows = (0, markdown_table_1.parseMarkdownRows)(node_fs_1.default.readFileSync(planPath, 'utf8'));
+    const inProgressRows = rows.filter((cells) => {
+        if (/^step$/i.test(cells[0] ?? ''))
+            return false;
+        return (cells[2] ?? '').trim().toLowerCase() === 'in progress';
+    });
+    if (inProgressRows.length === 0)
+        return;
+    issues.push({
+        severity: 'error',
+        code: 'TASK_PLAN_STATUS_DRIFT',
+        message: `PLAN.md has ${inProgressRows.length} row(s) still marked In Progress while the task is Done.`,
+        path: relativePath,
+        heading: 'Plan',
+        fixHint: 'Before closing a Done task, mark completed plan rows Done or split/defer unfinished work explicitly instead of leaving rows In Progress.',
+        example: '| 3 | Commit the pre-publish preparation. | Done | `command:T-XXXX:check` |',
+        remediationHint: {
+            path: relativePath,
+            heading: 'Plan',
+            requiredChange: 'Update PLAN.md rows that are no longer active from In Progress to Done, Blocked, Partial, or a task-specific final status with evidence.',
+            example: '| 3 | Commit the pre-publish preparation. | Done | `command:T-XXXX:check` |',
+            blocking: true
+        }
+    });
+}
+function isTaskStatusToken(value) {
+    return TASK_STATUS_TOKENS.has(value.trim().toLowerCase());
+}
+function normalizeFieldName(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, ' ');
+}
 function validateTaskBoardDone(projectRoot, task, issues, checkedFiles) {
     const taskBoardPath = node_path_1.default.join(projectRoot, 'docs', 'TASK_BOARD.md');
     const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, taskBoardPath));

package/dist/schemas/schema-index.json

@@ -274,6 +274,13 @@
             "owner": "runtime/version",
             "notes": "Documents read-only CLI origin, package, git, Node, and build freshness reports from hadara version --verbose."
         },
+        {
+            "id": "hadara.stateProjection.v1",
+            "path": "src/schemas/state-projection.schema.json",
+            "status": "fixture",
+            "owner": "services/state-projection",
+            "notes": "Documents the Phase 8.4 read-only state consistency projection over Task Board, Task Capsules, handoff, close evidence, docs registry, and release readiness state."
+        },
         {
             "id": "hadara.releaseGate.v1",
             "path": "src/schemas/release-gate.schema.json",

package/dist/schemas/state-projection.schema.json

@@ -0,0 +1,115 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "hadara.stateProjection.v1",
+    "x-hadara-schema-id": "hadara.stateProjection.v1",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schemaVersion", "command", "ok", "generatedAt", "projectRoot", "summary", "sources", "tasks", "issues"],
+    "properties": {
+        "schemaVersion": {
+            "const": "hadara.stateProjection.v1"
+        },
+        "command": {
+            "const": "state.projection"
+        },
+        "ok": {
+            "type": "boolean"
+        },
+        "generatedAt": {
+            "type": "string"
+        },
+        "projectRoot": {
+            "type": "string"
+        },
+        "summary": {
+            "type": "object",
+            "required": ["consistent", "issueCounts", "latestDoneTaskId", "activeTaskIds", "checkedTasks"],
+            "additionalProperties": true,
+            "properties": {
+                "consistent": {
+                    "type": "boolean"
+                },
+                "issueCounts": {
+                    "type": "object"
+                },
+                "latestDoneTaskId": {
+                    "type": ["string", "null"]
+                },
+                "activeTaskIds": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "checkedTasks": {
+                    "type": "number"
+                }
+            }
+        },
+        "sources": {
+            "type": "object"
+        },
+        "tasks": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["id", "title", "capsule", "task", "taskBoard", "handoff", "plan", "closeProof"],
+                "additionalProperties": true,
+                "properties": {
+                    "id": {
+                        "type": "string"
+                    },
+                    "title": {
+                        "type": "string"
+                    },
+                    "capsule": {
+                        "type": "string"
+                    },
+                    "task": {
+                        "type": "object"
+                    },
+                    "taskBoard": {
+                        "type": "object"
+                    },
+                    "handoff": {
+                        "type": "object"
+                    },
+                    "plan": {
+                        "type": "object"
+                    },
+                    "closeProof": {
+                        "type": "object"
+                    }
+                }
+            }
+        },
+        "issues": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["severity", "code", "message", "fixHint"],
+                "additionalProperties": true,
+                "properties": {
+                    "severity": {
+                        "enum": ["error", "warning", "info"]
+                    },
+                    "code": {
+                        "type": "string"
+                    },
+                    "message": {
+                        "type": "string"
+                    },
+                    "path": {
+                        "type": "string"
+                    },
+                    "taskId": {
+                        "type": "string"
+                    },
+                    "fixHint": {
+                        "type": "string"
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/services/capability-registry.js

@@ -600,7 +600,7 @@ exports.HADARA_COMMAND_REGISTRY = [
     {
         id: 'ci.gate',
         command: 'hadara ci gate [--mode advisory|strict] [--task <task-id>] [--allow-empty] [--json]',
-        summary: 'Evaluate CI-style task proof gates.',
+        summary: 'Evaluate CI-style task proof gates with advisory state consistency signals.',
         canonical: true,
         appearsInDefaultHelp: false,
         family: 'proof-diagnostics',
@@ -614,7 +614,28 @@ exports.HADARA_COMMAND_REGISTRY = [
         status: 'stable',
         docs: ['docs/IMPLEMENTATION_SOP.md'],
         examples: [example('Run strict CI gate', 'hadara ci gate --mode strict --task T-0001 --json', 'In automated validation paths.')],
-        related: ['task.ready', 'proof.status'],
+        related: ['task.ready', 'proof.status', 'state.verify'],
+        conflictsWith: []
+    },
+    {
+        id: 'state.verify',
+        command: 'hadara state verify [--json]',
+        summary: 'Read the state consistency projection and concise drift issues.',
+        canonical: true,
+        appearsInDefaultHelp: false,
+        family: 'proof-diagnostics',
+        scope: 'project',
+        lifecycleStage: 'ready',
+        requiredness: 'diagnostic',
+        writeBoundary: 'read-only',
+        readOnly: true,
+        risk: 'low',
+        actor: 'agent-worker',
+        status: 'stable',
+        schemaVersion: 'hadara.stateProjection.v1',
+        docs: ['docs/COMMAND_SURFACE.md', 'docs/SCHEMAS.md'],
+        examples: [example('Verify state drift', 'hadara state verify --json', 'Before close or when shared-doc state looks inconsistent.')],
+        related: ['status', 'protocol.doctor', 'ci.gate'],
         conflictsWith: []
     },
     commandEntry({
@@ -677,7 +698,7 @@ exports.HADARA_COMMAND_REGISTRY = [
         schemaVersion: 'hadara.protocol.consistency.v1',
         docs: ['docs/IMPLEMENTATION_SOP.md'],
         examples: [example('Run protocol doctor', 'hadara protocol doctor --scope all --json', 'When project protocol files may be inconsistent.')],
-        related: ['protocol.remediate', 'doctor'],
+        related: ['protocol.remediate', 'doctor', 'state.verify'],
         conflictsWith: []
     }),
     commandEntry({
@@ -1185,7 +1206,7 @@ exports.HADARA_COMMAND_REGISTRY = [
         schemaVersion: 'hadara.ops.status.v1',
         docs: ['docs/PROJECT_STATE.md'],
         examples: [example('Read status', 'hadara status --json', 'When checking project health and active task signals.')],
-        related: ['ops.status', 'doctor'],
+        related: ['ops.status', 'doctor', 'state.verify'],
         conflictsWith: []
     }),
     commandEntry({

package/dist/services/ci-gate.js

@@ -9,6 +9,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const proof_status_1 = require("./proof-status");
 const evidence_lint_1 = require("./evidence-lint");
 const protocol_consistency_1 = require("./protocol-consistency");
+const state_projection_1 = require("./state-projection");
 const task_capsule_1 = require("../task/task-capsule");
 function createCiGateReport(projectRoot, mode, options = {}) {
     const allowEmpty = options.allowEmpty ?? false;
@@ -29,6 +30,27 @@ function createCiGateReport(projectRoot, mode, options = {}) {
         const target = issue.severity === 'error' ? blockers : warnings;
         target.push({ severity: issue.severity, source: 'protocol', code: issue.code, message: issue.message, path: issue.path });
     }
+    const stateProjection = (0, state_projection_1.createStateProjectionReport)(projectRoot);
+    const stateConsistency = (0, state_projection_1.toStateProjectionAdvisory)(stateProjection, 10);
+    checks.push({
+        id: 'state:consistency',
+        source: 'state',
+        ok: true,
+        summary: stateConsistency.consistent
+            ? 'State consistency projection found no drift.'
+            : `State consistency projection is advisory: warnings ${stateConsistency.issueCounts.warning}, errors ${stateConsistency.issueCounts.error}.`
+    });
+    for (const issue of stateConsistency.issues) {
+        warnings.push({
+            severity: issue.severity,
+            source: 'state',
+            code: issue.code,
+            message: issue.message,
+            taskId: issue.taskId,
+            path: issue.path,
+            fixHint: issue.fixHint
+        });
+    }
     for (const task of tasks) {
         const evidence = (0, evidence_lint_1.createEvidenceLintReport)(projectRoot, task.id);
         checks.push({
@@ -63,6 +85,7 @@ function createCiGateReport(projectRoot, mode, options = {}) {
         ok: mode === 'advisory' ? true : blockers.length === 0,
         mode,
         scope: { ...(options.taskId ? { taskId: options.taskId } : {}), taskCount: tasks.length, allowEmpty },
+        stateConsistency,
         checks,
         blockers,
         warnings

package/dist/services/docs-registry.js

@@ -14,6 +14,7 @@ exports.registryJson = registryJson;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const managed_sections_1 = require("./managed-sections");
+const markdown_table_1 = require("./markdown-table");
 exports.DOCS_REGISTRY_PATH = '.hadara/docs-registry.json';
 const VALID_STATUSES = ['canonical', 'active', 'reference', 'historical', 'superseded', 'archived'];
 const VALID_READ_WHEN = ['session-start', 'task-start', 'task-close', 'release-work', 'docs-work', 'debugging', 'integration-work', 'only-when-linked', 'never-default'];
@@ -294,7 +295,8 @@ function parseRequiredReading(projectRoot) {
     const found = new Set();
     for (const file of files) {
         const text = node_fs_1.default.existsSync(node_path_1.default.join(projectRoot, file)) ? node_fs_1.default.readFileSync(node_path_1.default.join(projectRoot, file), 'utf8') : '';
-        for (const match of text.matchAll(/`([^`]+\.(?:md|MD))`/g)) {
+        const requiredReading = (0, markdown_table_1.readMarkdownSection)(text, '## Required Reading');
+        for (const match of requiredReading.matchAll(/`([^`]+\.(?:md|MD))`/g)) {
             const value = normalizePath(match[1]);
             if (value !== 'AGENTS.md' && !value.startsWith('docs/') && value !== '.hadara/context/HADARA_CONTEXT.md')
                 continue;

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/package.json

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