hadara 0.3.4-rc.0 → 0.4.0

package/dist/context/context-pack.js

@@ -10,6 +10,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const context_graph_builder_1 = require("./context-graph-builder");
 const context_slice_boundary_1 = require("./context-slice-boundary");
 const extractor_contract_1 = require("./extractor-contract");
+const docs_registry_1 = require("../services/docs-registry");
 exports.CONTEXT_PACK_SCHEMA_ID = 'hadara.contextPack.v1';
 exports.CONTEXT_PACK_COMMAND = 'context.pack';
 exports.CONTEXT_PACK_DEFAULT_BUDGET = {
@@ -62,31 +63,43 @@ function buildContextPackReport(input) {
         });
     }
     const connectedIds = taskId ? connectedNodeIds(graphReport.edges, (0, extractor_contract_1.createTaskNodeId)(taskId)) : new Set();
+    const docsReadMap = resolveDocsReadMap(input, taskId);
+    const readMapExcludedPaths = new Set((docsReadMap?.doNotReadByDefault ?? []).map((entry) => entry.path));
     const rankedNodes = rankContextPackNodes(graphReport.nodes, graphReport.edges, connectedIds, taskNode);
-    const readFirstRanked = rankedNodes.filter((ranked) => isReadFirstAllowed(ranked.node));
-    const readFirst = readFirstRanked
-        .slice(0, budget.maxReadFirstItems)
-        .map((ranked) => itemFromRankedNode(ranked, true, input.projectRoot));
-    if (readFirstRanked.length > readFirst.length) {
+    const readFirstRanked = rankedNodes
+        .filter((ranked) => isReadFirstAllowed(ranked.node))
+        .filter((ranked) => !isExcludedByReadMap(ranked.node, readMapExcludedPaths));
+    const graphReadFirst = readFirstRanked.map((ranked) => itemFromRankedNode(ranked, true, input.projectRoot));
+    const readFirstCandidates = mergeContextPackItems([
+        ...graphReadFirst.filter((item) => item.id === `task:${taskId}`),
+        ...readMapItems(docsReadMap?.readFirst ?? [], input.projectRoot, true),
+        ...graphReadFirst.filter((item) => item.id !== `task:${taskId}`)
+    ]);
+    const readFirst = readFirstCandidates.slice(0, budget.maxReadFirstItems);
+    if (readFirstCandidates.length > readFirst.length) {
         issues.push({
             severity: 'warning',
             code: 'CONTEXT_PACK_BUDGET_TRUNCATED',
-            message: `Context pack readFirst items were truncated from ${readFirstRanked.length} to ${readFirst.length}.`
+            message: `Context pack readFirst items were truncated from ${readFirstCandidates.length} to ${readFirst.length}.`
         });
     }
     const selectedIds = new Set(readFirst.map((item) => item.id));
+    const selectedPaths = new Set(readFirst.map((item) => item.path).filter((value) => Boolean(value)));
     const maxReadIfNeeded = Math.max(0, (budget.maxItems ?? 30) - readFirst.length);
     const readIfNeededRanked = rankedNodes
-        .filter((ranked) => !selectedIds.has(ranked.node.id))
+        .filter((ranked) => !selectedIds.has(ranked.node.id) && (!ranked.node.path || !selectedPaths.has(ranked.node.path)))
+        .filter((ranked) => !isExcludedByReadMap(ranked.node, readMapExcludedPaths))
         .filter((ranked) => !isDoNotReadByDefault(ranked.node));
-    const readIfNeeded = readIfNeededRanked
-        .slice(0, maxReadIfNeeded)
-        .map((ranked) => itemFromRankedNode(ranked, false, input.projectRoot));
-    if (readIfNeededRanked.length > readIfNeeded.length) {
+    const readIfNeededCandidates = mergeContextPackItems([
+        ...readMapItems(docsReadMap?.readIfNeeded ?? [], input.projectRoot, false),
+        ...readIfNeededRanked.map((ranked) => itemFromRankedNode(ranked, false, input.projectRoot))
+    ]).filter((item) => !selectedIds.has(item.id) && (!item.path || !selectedPaths.has(item.path)));
+    const readIfNeeded = readIfNeededCandidates.slice(0, maxReadIfNeeded);
+    if (readIfNeededCandidates.length > readIfNeeded.length) {
         issues.push({
             severity: 'warning',
             code: 'CONTEXT_PACK_BUDGET_TRUNCATED',
-            message: `Context pack readIfNeeded items were truncated from ${readIfNeededRanked.length} to ${readIfNeeded.length}.`
+            message: `Context pack readIfNeeded items were truncated from ${readIfNeededCandidates.length} to ${readIfNeeded.length}.`
         });
     }
     const doNotReadByDefault = graphReport.nodes
@@ -137,16 +150,86 @@ function buildContextPackReport(input) {
             graphAvailable: true,
             codeIndexAvailable: codeIndexAvailable(graphReport),
             stateProjectionAvailable: true,
-            docsRegistryAvailable: graphReport.stateProjection.sources.some((source) => source.kind === 'docs-registry'),
+            docsRegistryAvailable: Boolean(docsReadMap?.source.registryPresent) || graphReport.stateProjection.sources.some((source) => source.kind === 'docs-registry'),
             commandRegistryAvailable: graphReport.nodes.some((node) => node.type === 'Command'),
             degraded: graphReport.summary.degraded || issues.some((issue) => issue.severity !== 'info'),
             graphSourceHash: graphReport.sourceHash,
-            sourcesRead: graphReport.summary.sourcesRead
+            sourcesRead: graphReport.summary.sourcesRead,
+            docsReadMapAvailable: Boolean(docsReadMap),
+            docsReadMapReadFirstCount: docsReadMap?.readFirst.length ?? 0,
+            docsReadMapDoNotReadByDefaultCount: docsReadMap?.doNotReadByDefault.length ?? 0
         },
         cache,
         issues
     };
 }
+function resolveDocsReadMap(input, taskId) {
+    if (input.docsReadMap)
+        return input.docsReadMap;
+    if (input.graphReport || !taskId)
+        return undefined;
+    if (!node_fs_1.default.existsSync(node_path_1.default.join(input.projectRoot, '.hadara', 'docs-registry.json')))
+        return undefined;
+    return (0, docs_registry_1.createDocsReadMapReport)(input.projectRoot, taskId);
+}
+function readMapItems(entries, projectRoot, required) {
+    return [...entries].sort(compareReadMapEntriesForContextPack).map((entry) => {
+        const sourceHash = sourceHashForPath(projectRoot, entry.path);
+        return {
+            id: `doc:${entry.path}`,
+            type: 'Document',
+            path: entry.path,
+            title: entry.title,
+            reason: `Docs read-map ${entry.readTier}: ${entry.reason}`,
+            confidence: entry.readTier === 'active-task' || entry.readTier === 'active-spec' ? 'explicit' : 'derived',
+            ...(sourceHash ? { sourceHash } : {}),
+            estimatedTokens: estimateTokensForPath(entry.path, entry.title),
+            required,
+            sourceAccess: sourceAccessForPath(entry.path)
+        };
+    });
+}
+function compareReadMapEntriesForContextPack(a, b) {
+    return readMapTierPriority(a.readTier) - readMapTierPriority(b.readTier) || a.path.localeCompare(b.path);
+}
+function readMapTierPriority(tier) {
+    if (tier === 'active-task')
+        return 0;
+    if (tier === 'active-spec')
+        return 1;
+    if (tier === 'current-state')
+        return 2;
+    if (tier === 'workflow-reference')
+        return 3;
+    if (tier === 'conditional-reference')
+        return 4;
+    if (tier === 'implemented-reference')
+        return 5;
+    if (tier === 'drift-review')
+        return 6;
+    if (tier === 'historical')
+        return 7;
+    return 8;
+}
+function mergeContextPackItems(items) {
+    const seenIds = new Set();
+    const seenPaths = new Set();
+    const merged = [];
+    for (const item of items) {
+        if (seenIds.has(item.id))
+            continue;
+        if (item.path && seenPaths.has(item.path))
+            continue;
+        seenIds.add(item.id);
+        if (item.path)
+            seenPaths.add(item.path);
+        merged.push(item);
+    }
+    return merged;
+}
+function isExcludedByReadMap(node, excludedPaths) {
+    return Boolean(node.path && excludedPaths.has(node.path));
+}
 function normalizeContextBudget(input = {}) {
     const maxReadFirstItems = positiveInteger(input.maxReadFirstItems) ?? exports.CONTEXT_PACK_DEFAULT_BUDGET.maxReadFirstItems;
     return {
@@ -284,19 +367,24 @@ function itemFromRankedNode(ranked, required, projectRoot) {
 function sourceHashForItem(projectRoot, node) {
     if (!node.path || !(0, context_slice_boundary_1.isContextSliceProjectRelativePath)(node.path))
         return node.source.hash;
-    const normalized = (0, context_slice_boundary_1.normalizeContextSliceInputPath)(node.path);
+    return sourceHashForPath(projectRoot, node.path) ?? node.source.hash;
+}
+function sourceHashForPath(projectRoot, relativePath) {
+    if (!(0, context_slice_boundary_1.isContextSliceProjectRelativePath)(relativePath))
+        return undefined;
+    const normalized = (0, context_slice_boundary_1.normalizeContextSliceInputPath)(relativePath);
     const root = node_path_1.default.resolve(projectRoot);
     const absolutePath = node_path_1.default.resolve(root, normalized);
     if (absolutePath !== root && !absolutePath.startsWith(`${root}${node_path_1.default.sep}`))
-        return node.source.hash;
+        return undefined;
     try {
         const stat = node_fs_1.default.statSync(absolutePath);
         if (!stat.isFile())
-            return node.source.hash;
+            return undefined;
         return (0, extractor_contract_1.hashContextGraphText)(node_fs_1.default.readFileSync(absolutePath, 'utf8'));
     }
     catch {
-        return node.source.hash;
+        return undefined;
     }
 }
 function sourceAccessForNode(node) {
@@ -306,7 +394,10 @@ function sourceAccessForNode(node) {
             reason: 'This context item has no project file path for raw context slicing.'
         };
     }
-    if ((0, context_slice_boundary_1.isContextSliceProjectRelativePath)(node.path)) {
+    return sourceAccessForPath(node.path);
+}
+function sourceAccessForPath(relativePath) {
+    if ((0, context_slice_boundary_1.isContextSliceProjectRelativePath)(relativePath)) {
         return {
             rawSlice: 'sliceable',
             reason: 'This item path is inside the raw context-slice read boundary.'
@@ -322,6 +413,9 @@ function estimateTokens(node) {
     const pathCost = node.path ? Math.ceil(node.path.length / 4) : 0;
     return Math.max(24, labelCost + pathCost + 16);
 }
+function estimateTokensForPath(relativePath, title) {
+    return Math.max(24, Math.ceil(title.length / 4) + Math.ceil(relativePath.length / 4) + 16);
+}
 function validationSuggestionsForTask(taskId, graphReport) {
     const suggestions = new Map();
     if (taskId) {

package/dist/context/session-start.js

@@ -7,6 +7,8 @@ const context_graph_builder_1 = require("./context-graph-builder");
 const context_cache_store_1 = require("./context-cache-store");
 const source_manifest_1 = require("./source-manifest");
 const code_graph_extractor_1 = require("./code-graph-extractor");
+const validate_1 = require("../harness/validate");
+const docs_registry_1 = require("../services/docs-registry");
 exports.SESSION_START_SCHEMA_ID = 'hadara.sessionStart.v1';
 exports.SESSION_START_COMMAND = 'session.start';
 function buildSessionStartReport(input) {
@@ -41,6 +43,7 @@ function buildSessionStartReport(input) {
         lifecycle,
         allowLiveContextPack: Boolean(input.allowLiveContextPack)
     });
+    const docsReadMap = taskId ? createSessionStartDocsReadMap(input.projectRoot, taskId, input.budget?.maxReadFirstItems ?? 7) : undefined;
     return {
         schemaVersion: exports.SESSION_START_SCHEMA_ID,
         command: exports.SESSION_START_COMMAND,
@@ -56,6 +59,7 @@ function buildSessionStartReport(input) {
         contextPack,
         lifecycle,
         guidance,
+        ...(docsReadMap ? { docsReadMap } : {}),
         knownProblems: contextPack.knownProblems,
         sourceSummary: contextPack.sourceSummary,
         cache: contextPack.cache,
@@ -70,6 +74,43 @@ function buildSessionStartReport(input) {
         issues
     };
 }
+function createSessionStartDocsReadMap(projectRoot, taskId, maxReadFirst) {
+    const readMap = (0, docs_registry_1.createDocsReadMapReport)(projectRoot, taskId);
+    const sourceValidation = (0, validate_1.validateTaskCapsule)(projectRoot, taskId, { level: 'done' });
+    const sourceDocumentDrift = sourceValidation.issues
+        .filter((issue) => issue.code === 'TASK_SOURCE_DOCUMENT_CHANGED' || issue.code === 'TASK_SOURCE_DOCUMENT_MISSING_HASH')
+        .map((issue) => ({
+        code: issue.code,
+        message: issue.message,
+        ...(issue.path ? { path: issue.path } : {}),
+        ...(issue.heading ? { heading: issue.heading } : {})
+    }));
+    return {
+        taskId: readMap.taskId,
+        command: `node dist/cli/main.js docs read-map --task ${taskId} --json`,
+        source: readMap.source,
+        task: readMap.task,
+        readFirstCount: readMap.readFirst.length,
+        readIfNeededCount: readMap.readIfNeeded.length,
+        doNotReadByDefaultCount: readMap.doNotReadByDefault.length,
+        driftWarningCount: readMap.driftWarnings.length,
+        sourceDocumentDriftCount: sourceDocumentDrift.length,
+        readFirst: readMap.readFirst.slice(0, maxReadFirst).map((entry) => ({
+            path: entry.path,
+            readTier: entry.readTier,
+            authority: entry.authority,
+            reason: entry.reason
+        })),
+        driftWarnings: readMap.driftWarnings.slice(0, 10),
+        sourceDocumentDrift,
+        issues: readMap.issues.map((issue) => ({
+            severity: issue.severity,
+            code: issue.code,
+            message: issue.message,
+            ...(issue.path ? { path: issue.path } : {})
+        }))
+    };
+}
 function buildWarmCachedContextPackReport(input) {
     const cachedManifest = (0, context_cache_store_1.readContextSourceManifestCache)(input.projectRoot);
     if (cachedManifest.status !== 'valid' || !cachedManifest.manifest)
@@ -134,11 +175,10 @@ function buildWarmCachedContextPackReport(input) {
 function lifecycleForSessionStart(taskId, contextPack) {
     const primaryNextCommands = taskId
         ? [
-            `node dist/cli/main.js task lifecycle --task ${taskId} --json`,
             `node dist/cli/main.js task status --task ${taskId} --json`,
             `node dist/cli/main.js context pack --task ${taskId} --json`
         ]
-        : ['node dist/cli/main.js task next --json'];
+        : ['node dist/cli/main.js task status --json'];
     for (const suggestion of contextPack.validateWith) {
         if (suggestion.requiredForClose && !primaryNextCommands.includes(suggestion.command)) {
             primaryNextCommands.push(suggestion.command);
@@ -179,42 +219,36 @@ function guidanceForSessionStart(input) {
     let primaryAction;
     if (!taskId) {
         primaryAction = {
-            id: 'task-next',
+            id: 'task-status',
             label: 'Select the next task',
-            command: 'node dist/cli/main.js task next --json',
-            args: ['task', 'next', '--json'],
+            command: 'node dist/cli/main.js task status --json',
+            args: ['task', 'status', '--json'],
             reason: 'No task id is available, so the next useful step is to select a concrete task before reading task-scoped context.',
             writeBoundary: 'read-only',
             recommendedActorRole: 'agent-worker'
         };
         commands.push({
-            id: 'task-next',
-            command: 'node dist/cli/main.js task next --json',
-            args: ['task', 'next', '--json'],
+            id: 'task-status',
+            command: 'node dist/cli/main.js task status --json',
+            args: ['task', 'status', '--json'],
             reason: 'Choose the next task before requesting task-scoped context.'
         });
     }
     else {
         primaryAction = {
-            id: 'task-lifecycle',
-            label: 'Inspect task lifecycle phase',
-            command: `node dist/cli/main.js task lifecycle --task ${taskId} --json`,
-            args: ['task', 'lifecycle', '--task', taskId, '--json'],
-            reason: 'A task id is available, so the fastest safe first step is to inspect lifecycle phase and blockers before editing files.',
+            id: 'task-status',
+            label: 'Inspect task loop phase',
+            command: `node dist/cli/main.js task status --task ${taskId} --json`,
+            args: ['task', 'status', '--task', taskId, '--json'],
+            reason: 'A task id is available, so the fastest safe first step is to inspect loop phase, blockers, and the primary next action before editing files.',
             writeBoundary: 'read-only',
             recommendedActorRole: 'agent-worker'
         };
-        commands.push({
-            id: 'task-lifecycle',
-            command: `node dist/cli/main.js task lifecycle --task ${taskId} --json`,
-            args: ['task', 'lifecycle', '--task', taskId, '--json'],
-            reason: 'Inspect the task phase and the one primary lifecycle next action before editing.'
-        });
         commands.push({
             id: 'task-status',
             command: `node dist/cli/main.js task status --task ${taskId} --json`,
             args: ['task', 'status', '--task', taskId, '--json'],
-            reason: 'Inspect task readiness, evidence, and lifecycle state.'
+            reason: 'Inspect task readiness, evidence, loop phase, and the primary next action.'
         });
         commands.push({
             id: 'context-pack',
@@ -222,6 +256,12 @@ function guidanceForSessionStart(input) {
             args: ['context', 'pack', '--task', taskId, '--json'],
             reason: 'Inspect the bounded task read plan without slicing raw source text.'
         });
+        commands.push({
+            id: 'docs-read-map',
+            command: `node dist/cli/main.js docs read-map --task ${taskId} --json`,
+            args: ['docs', 'read-map', '--task', taskId, '--json'],
+            reason: 'Inspect registry-backed task reading guidance and drift warnings before broad manual reads.'
+        });
     }
     commands.push({
         id: 'cache-warm',
@@ -278,7 +318,7 @@ function buildBoundedContextPackReport(input) {
                 severity: 'warning',
                 code: 'CONTEXT_PACK_TASK_NOT_FOUND',
                 message: 'No task id was supplied. Bounded session start returned task-selection guidance without running live project discovery.',
-                fixHint: 'Run hadara task next --json, then rerun hadara session start --task <task-id> --json.'
+                fixHint: 'Run hadara task status --json, then rerun hadara session start --task <task-id> --json.'
             }];
     const readFirst = input.taskId
         ? [{

package/dist/context/task-extractors.js

@@ -138,8 +138,9 @@ function readTaskStatus(content) {
     const sectionStatus = (0, markdown_table_1.readMarkdownSection)(content, '## Status').trim().split(/\r?\n/)[0]?.trim();
     if (sectionStatus)
         return sectionStatus;
-    const rows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(content, '## Metadata');
-    return (0, markdown_table_1.findMarkdownRowByCell)(rows, 0, 'Status')?.[1] ?? null;
+    const identityRows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(content, '## Identity');
+    const metadataRows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(content, '## Metadata');
+    return (0, markdown_table_1.findMarkdownRowByCell)(identityRows, 0, 'Status')?.[1] ?? (0, markdown_table_1.findMarkdownRowByCell)(metadataRows, 0, 'Status')?.[1] ?? null;
 }
 function readTaskHandoffStatus(content) {
     const rows = (0, markdown_table_1.parseMarkdownRowsUnderHeading)(content, '## Current State');

package/dist/core/schema.js

@@ -12,6 +12,7 @@ const actor_context_schema_json_1 = __importDefault(require("../schemas/actor-co
 const active_run_projection_schema_json_1 = __importDefault(require("../schemas/active-run-projection.schema.json"));
 const active_run_resume_schema_json_1 = __importDefault(require("../schemas/active-run-resume.schema.json"));
 const clean_checkout_smoke_schema_json_1 = __importDefault(require("../schemas/clean-checkout-smoke.schema.json"));
+const close_source_schema_json_1 = __importDefault(require("../schemas/close-source.schema.json"));
 const code_index_schema_json_1 = __importDefault(require("../schemas/code-index.schema.json"));
 const context_cache_record_schema_json_1 = __importDefault(require("../schemas/context-cache-record.schema.json"));
 const context_cache_status_schema_json_1 = __importDefault(require("../schemas/context-cache-status.schema.json"));
@@ -29,13 +30,17 @@ const dev_docker_check_schema_json_1 = __importDefault(require("../schemas/dev-d
 const docs_archive_plan_schema_json_1 = __importDefault(require("../schemas/docs-archive-plan.schema.json"));
 const docs_doctor_schema_json_1 = __importDefault(require("../schemas/docs-doctor.schema.json"));
 const docs_explain_schema_json_1 = __importDefault(require("../schemas/docs-explain.schema.json"));
+const docs_inbox_schema_json_1 = __importDefault(require("../schemas/docs-inbox.schema.json"));
 const docs_list_schema_json_1 = __importDefault(require("../schemas/docs-list.schema.json"));
 const docs_mark_schema_json_1 = __importDefault(require("../schemas/docs-mark.schema.json"));
 const docs_patch_plan_schema_json_1 = __importDefault(require("../schemas/docs-patch-plan.schema.json"));
+const docs_read_map_schema_json_1 = __importDefault(require("../schemas/docs-read-map.schema.json"));
+const docs_register_schema_json_1 = __importDefault(require("../schemas/docs-register.schema.json"));
 const docs_required_reading_schema_json_1 = __importDefault(require("../schemas/docs-required-reading.schema.json"));
 const evidence_lint_schema_json_1 = __importDefault(require("../schemas/evidence-lint.schema.json"));
 const evidence_list_schema_json_1 = __importDefault(require("../schemas/evidence-list.schema.json"));
 const evidence_migration_preview_schema_json_1 = __importDefault(require("../schemas/evidence-migration-preview.schema.json"));
+const evidence_projection_schema_json_1 = __importDefault(require("../schemas/evidence-projection.schema.json"));
 const evidence_summary_schema_json_1 = __importDefault(require("../schemas/evidence-summary.schema.json"));
 const event_schema_json_1 = __importDefault(require("../schemas/event.schema.json"));
 const feature_smoke_schema_json_1 = __importDefault(require("../schemas/feature-smoke.schema.json"));
@@ -74,9 +79,11 @@ const task_finish_schema_json_1 = __importDefault(require("../schemas/task-finis
 const task_lifecycle_schema_json_1 = __importDefault(require("../schemas/task-lifecycle.schema.json"));
 const task_next_schema_json_1 = __importDefault(require("../schemas/task-next.schema.json"));
 const task_ready_schema_json_1 = __importDefault(require("../schemas/task-ready.schema.json"));
+const task_status_schema_json_1 = __importDefault(require("../schemas/task-status.schema.json"));
 const task_upgrade_scaffold_schema_json_1 = __importDefault(require("../schemas/task-upgrade-scaffold.schema.json"));
 const task_workbench_schema_json_1 = __importDefault(require("../schemas/task-workbench.schema.json"));
 const tools_list_schema_json_1 = __importDefault(require("../schemas/tools-list.schema.json"));
+const validation_run_schema_json_1 = __importDefault(require("../schemas/validation-run.schema.json"));
 const write_preflight_schema_json_1 = __importDefault(require("../schemas/write-preflight.schema.json"));
 class SchemaValidationError extends Error {
     schemaId;
@@ -96,6 +103,7 @@ const registeredSchemas = {
     'hadara.active_run.projection.v1': active_run_projection_schema_json_1.default,
     'hadara.active_run.resume.v1': active_run_resume_schema_json_1.default,
     'hadara.cleanCheckoutSmoke.v1': clean_checkout_smoke_schema_json_1.default,
+    'hadara.closeSource.v1': close_source_schema_json_1.default,
     'hadara.codeIndex.v1': code_index_schema_json_1.default,
     'hadara.context.cacheRecord.v1': context_cache_record_schema_json_1.default,
     'hadara.context.cacheStatus.v1': context_cache_status_schema_json_1.default,
@@ -113,13 +121,17 @@ const registeredSchemas = {
     'hadara.docs.archivePlan.v1': docs_archive_plan_schema_json_1.default,
     'hadara.docs.doctor.v1': docs_doctor_schema_json_1.default,
     'hadara.docs.explain.v1': docs_explain_schema_json_1.default,
+    'hadara.docs.inbox.v1': docs_inbox_schema_json_1.default,
     'hadara.docs.list.v1': docs_list_schema_json_1.default,
     'hadara.docs.mark.v1': docs_mark_schema_json_1.default,
     'hadara.docs.patchPlan.v1': docs_patch_plan_schema_json_1.default,
+    'hadara.docs.readMap.v1': docs_read_map_schema_json_1.default,
+    'hadara.docs.register.v1': docs_register_schema_json_1.default,
     'hadara.docs.requiredReading.v1': docs_required_reading_schema_json_1.default,
     'hadara.evidence.lint.v1': evidence_lint_schema_json_1.default,
     'hadara.evidence.list.v1': evidence_list_schema_json_1.default,
     'hadara.evidence.migration_preview.v1': evidence_migration_preview_schema_json_1.default,
+    'hadara.evidence.projection.v1': evidence_projection_schema_json_1.default,
     'hadara.evidence.summary.v1': evidence_summary_schema_json_1.default,
     'hadara.event.v1': event_schema_json_1.default,
     'hadara.featureSmoke.v1': feature_smoke_schema_json_1.default,
@@ -158,9 +170,11 @@ const registeredSchemas = {
     'hadara.task.lifecycle.v1': task_lifecycle_schema_json_1.default,
     'hadara.task.next.v1': task_next_schema_json_1.default,
     'hadara.task.ready.v1': task_ready_schema_json_1.default,
+    'hadara.task.status.v1': task_status_schema_json_1.default,
     'hadara.task.upgrade_scaffold.v1': task_upgrade_scaffold_schema_json_1.default,
     'hadara.task.workbench.v1': task_workbench_schema_json_1.default,
     'hadara.tools.list.v1': tools_list_schema_json_1.default,
+    'hadara.validation.run.v1': validation_run_schema_json_1.default,
     'hadara.write.preflight.v1': write_preflight_schema_json_1.default
 };
 function loadSchema(schemaId) {

package/dist/core/timing.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMonotonicTimer = startMonotonicTimer;
+const node_perf_hooks_1 = require("node:perf_hooks");
+function startMonotonicTimer(now = () => node_perf_hooks_1.performance.now()) {
+    const started = now();
+    return {
+        elapsedMs() {
+            return Math.max(0, Math.round(now() - started));
+        }
+    };
+}

package/dist/dev/docker-check.js

@@ -9,6 +9,7 @@ const node_child_process_1 = require("node:child_process");
 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 timing_1 = require("../core/timing");
 const lifecycle_next_actions_1 = require("../task/lifecycle-next-actions");
 function createDevDockerCheckReport(projectRoot, options = {}, runner = defaultRunner) {
     const focusedTests = normalizeFocusedTests(options.focusedTests ?? []);
@@ -47,9 +48,9 @@ function createDevDockerCheckReport(projectRoot, options = {}, runner = defaultR
             steps.push({ id: step.id, status: 'skipped', summary: step.runWhen ? 'Skipped because an earlier step failed.' : step.summary });
             continue;
         }
-        const started = Date.now();
+        const timer = (0, timing_1.startMonotonicTimer)();
         const result = runner.run('docker', dockerExecArgs(container, step.script), env);
-        const elapsedMs = Date.now() - started;
+        const elapsedMs = timer.elapsedMs();
         if (result.ok) {
             steps.push({ id: step.id, status: 'passed', elapsedMs, summary: step.summary });
             if (step.mark)