hadara 0.4.0-rc.0 → 0.4.0

package/dist/harness/validate.js

@@ -26,9 +26,11 @@ const SOURCE_DOCUMENT_ROLE_TOKENS = new Set(['implementation-source', 'reference
 const SOURCE_DOCUMENT_AUTHORITY_TOKENS = new Set(['exploratory', 'proposed', 'approved', 'normative', 'implementation-source', 'reference-only', 'historical']);
 const SOURCE_DOCUMENT_STATUS_TOKENS = new Set(['draft', 'review', 'approved', 'implementing', 'implemented', 'superseded', 'drift-risk', 'archived']);
 const ACCEPTANCE_REQUIRED_TOKENS = new Set(['Yes', 'No']);
-const ACCEPTANCE_STATUS_TOKENS = new Set(['Pending', 'Met', 'Not Met', 'Blocked', 'Not Applicable']);
+const ACCEPTANCE_DECISION_TOKENS = new Set(['Must', 'Optional', 'Follow-up', 'Accepted Risk', 'Not Applicable', 'Superseded']);
+const ACCEPTANCE_STATUS_TOKENS = new Set(['Pending', 'In Progress', 'Met', 'Not Met', 'Blocked', 'Partial', 'Deferred', 'Follow-up Created', 'Accepted Risk', 'Not Applicable', 'Superseded']);
 const ACCEPTANCE_DISPOSITION_TOKENS = new Set(['Required', 'Optional', 'Deferred', 'Accepted Risk', 'Not Applicable', 'Superseded']);
 const ACCEPTANCE_DISPOSITIONS_REQUIRING_REFERENCE = new Set(['Deferred', 'Accepted Risk', 'Not Applicable', 'Superseded']);
+const ACCEPTANCE_DECISIONS_REQUIRING_REFERENCE = new Set(['Follow-up', 'Accepted Risk', 'Not Applicable', 'Superseded']);
 const VALIDATION_REQUIRED_TOKENS = new Set(['Yes', 'No']);
 const VALIDATION_RESULT_TOKENS = new Set(['Not Run', 'Passed', 'Failed', 'Blocked', 'Skipped', 'Not Applicable']);
 const RISK_KIND_TOKENS = new Set(['Risk', 'Follow-up', 'Question']);
@@ -49,6 +51,7 @@ function validateTaskCapsule(projectRoot, taskId, options = {}) {
             schemaVersion: 'hadara.harness.validate.v1',
             command: 'harness.validate',
             ok: false,
+            taskId,
             level,
             task: { id: taskId, title: '', capsule: '' },
             checkedFiles: [],
@@ -93,6 +96,7 @@ function validateTaskCapsule(projectRoot, taskId, options = {}) {
         schemaVersion: 'hadara.harness.validate.v1',
         command: 'harness.validate',
         ok: !issues.some((issue) => issue.severity === 'error'),
+        taskId: task.id,
         level,
         task: {
             id: task.id,
@@ -112,24 +116,11 @@ function validateTaskMarkdown(projectRoot, task, issues, level) {
         return;
     const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, taskPath));
     const content = node_fs_1.default.readFileSync(taskPath, 'utf8');
-    for (const heading of ['## Identity', '## Source Documents', '## Goal', '## Plan', '## Acceptance', '## Validation', '## Change Summary', '## Risks / Follow-ups']) {
-        if (!content.includes(heading)) {
-            issues.push({
-                severity: 'error',
-                code: 'TASK_SECTION_MISSING',
-                message: `TASK.md is missing required section: ${heading}`,
-                path: relativePath,
-                heading,
-                fixHint: `Add the ${heading} section to TASK.md and fill it with task-specific content.`,
-                remediationHint: {
-                    path: relativePath,
-                    heading,
-                    requiredChange: `Add the missing ${heading} section to TASK.md.`,
-                    blocking: true
-                }
-            });
-        }
+    for (const heading of ['## Identity', '## Goal', '## Plan', '## Acceptance', '## Validation', '## Risks / Follow-ups']) {
+        requireTaskSection(content, relativePath, issues, heading);
     }
+    requireAnyTaskSection(content, relativePath, issues, ['## Inputs / Constraints', '## Source Documents']);
+    requireAnyTaskSection(content, relativePath, issues, ['## Changes', '## Change Summary']);
     validateTaskIdentityTable(content, relativePath, issues);
     validateTaskSourceDocumentsTable(projectRoot, content, relativePath, issues, level);
     validateTaskPlanTable(content, relativePath, issues);
@@ -137,6 +128,7 @@ function validateTaskMarkdown(projectRoot, task, issues, level) {
     validateTaskValidationTable(content, relativePath, issues);
     validateTaskChangeSummaryTable(content, relativePath, issues);
     validateTaskRisksTable(content, relativePath, issues);
+    validateTaskHistoryTable(content, relativePath, issues);
     validateTaskCloseStateBoundaries(content, relativePath, issues);
 }
 function validateTaskIdentityTable(content, relativePath, issues) {
@@ -155,19 +147,29 @@ function validateTaskIdentityTable(content, relativePath, issues) {
     }
 }
 function validateTaskSourceDocumentsTable(projectRoot, content, relativePath, issues, level) {
-    const heading = '## Source Documents';
+    const heading = sectionHeading(content, ['## Inputs / Constraints', '## Source Documents']);
     const table = sectionTable(content, heading);
-    if (!requireTableHeader(table.rows, ['Path', 'Role', 'Authority', 'Status', 'Source Hash', 'Notes'], relativePath, heading, issues))
+    const recognizedHeader = requireAnyTableHeader(table.rows, [
+        ['Source', 'Role', 'State', 'Notes'],
+        ['Path / Source', 'Type', 'Authority', 'State', 'Notes', 'Hash'],
+        ['Path', 'Role', 'Authority', 'Status', 'Source Hash', 'Notes']
+    ], relativePath, heading, issues);
+    if (!recognizedHeader)
         return;
+    const hasHashColumn = table.header.includes('Hash') || table.header.includes('Source Hash');
+    const hasAuthorityColumn = table.header.includes('Authority');
     for (const row of table.dataRows) {
-        const pathCell = tableCell(row, table.header, 'Path');
+        const pathCell = tableCellAny(row, table.header, ['Source', 'Path / Source', 'Path']);
         const sourcePath = normalizeSourceDocumentPathCell(pathCell);
         if (!sourcePath || /^TBD$/i.test(sourcePath))
             continue;
-        checkToken(tableCell(row, table.header, 'Role'), SOURCE_DOCUMENT_ROLE_TOKENS, 'TASK_SOURCE_DOCUMENT_ROLE_INVALID_TOKEN', relativePath, heading, issues);
-        checkToken(tableCell(row, table.header, 'Authority'), SOURCE_DOCUMENT_AUTHORITY_TOKENS, 'TASK_SOURCE_DOCUMENT_AUTHORITY_INVALID_TOKEN', relativePath, heading, issues);
-        checkToken(tableCell(row, table.header, 'Status'), SOURCE_DOCUMENT_STATUS_TOKENS, 'TASK_SOURCE_DOCUMENT_STATUS_INVALID_TOKEN', relativePath, heading, issues);
-        const hash = tableCell(row, table.header, 'Source Hash');
+        checkToken(tableCellAny(row, table.header, ['Type', 'Role']), SOURCE_DOCUMENT_ROLE_TOKENS, 'TASK_SOURCE_DOCUMENT_ROLE_INVALID_TOKEN', relativePath, heading, issues);
+        if (hasAuthorityColumn)
+            checkToken(tableCell(row, table.header, 'Authority'), SOURCE_DOCUMENT_AUTHORITY_TOKENS, 'TASK_SOURCE_DOCUMENT_AUTHORITY_INVALID_TOKEN', relativePath, heading, issues);
+        checkToken(tableCellAny(row, table.header, ['State', 'Status']), SOURCE_DOCUMENT_STATUS_TOKENS, 'TASK_SOURCE_DOCUMENT_STATUS_INVALID_TOKEN', relativePath, heading, issues);
+        if (!hasHashColumn)
+            continue;
+        const hash = tableCellAny(row, table.header, ['Hash', 'Source Hash']);
         if (!isSourceHashCell(hash)) {
             issues.push(taskTableIssue('TASK_SOURCE_DOCUMENT_MISSING_HASH', `Source document "${sourcePath}" must use Source Hash "TBD" or "sha256:<hex>".`, relativePath, heading));
             continue;
@@ -213,7 +215,7 @@ function hashFile(filePath) {
 function validateTaskPlanTable(content, relativePath, issues) {
     const heading = '## Plan';
     const table = sectionTable(content, heading);
-    if (!requireTableHeader(table.rows, ['Step', 'Action', 'Status', 'Evidence'], relativePath, heading, issues))
+    if (!requireAnyTableHeader(table.rows, [['Step', 'Action', 'Status'], ['Step', 'Action', 'Status', 'Evidence']], relativePath, heading, issues))
         return;
     for (const row of table.dataRows) {
         if (!row.some(Boolean))
@@ -224,7 +226,11 @@ function validateTaskPlanTable(content, relativePath, issues) {
 function validateTaskAcceptanceTable(content, relativePath, issues) {
     const heading = '## Acceptance';
     const table = sectionTable(content, heading);
-    if (!requireTableHeader(table.rows, ['ID', 'Criterion', 'Required', 'Status', 'Evidence', 'Disposition', 'Reference'], relativePath, heading, issues))
+    if (!requireAnyTableHeader(table.rows, [
+        ['ID', 'Criterion', 'State', 'Evidence', 'Reference'],
+        ['ID', 'Criterion', 'Decision', 'State', 'Evidence', 'Reference'],
+        ['ID', 'Criterion', 'Required', 'Status', 'Evidence', 'Disposition', 'Reference']
+    ], relativePath, heading, issues))
         return;
     for (const row of table.dataRows) {
         const id = tableCell(row, table.header, 'ID');
@@ -233,6 +239,19 @@ function validateTaskAcceptanceTable(content, relativePath, issues) {
         if (!/^AC-\d+$/.test(id)) {
             issues.push(taskTableIssue('ACCEPTANCE_ID_INVALID_TOKEN', `Acceptance ID must use AC-1, AC-2, ...; got "${id}".`, relativePath, heading));
         }
+        const hasStateColumn = table.header.includes('State');
+        const hasDecisionColumn = table.header.includes('Decision');
+        const decision = tableCell(row, table.header, 'Decision');
+        if (hasStateColumn) {
+            if (hasDecisionColumn && decision) {
+                checkToken(decision, ACCEPTANCE_DECISION_TOKENS, 'ACCEPTANCE_DECISION_INVALID_TOKEN', relativePath, heading, issues);
+                if (ACCEPTANCE_DECISIONS_REQUIRING_REFERENCE.has(decision) && isMissingReference(tableCell(row, table.header, 'Reference'))) {
+                    issues.push(taskTableIssue('ACCEPTANCE_DECISION_REFERENCE_MISSING', `${id} decision "${decision}" requires a concrete reference.`, relativePath, heading));
+                }
+            }
+            checkToken(tableCell(row, table.header, 'State'), ACCEPTANCE_STATUS_TOKENS, 'ACCEPTANCE_STATUS_INVALID_TOKEN', relativePath, heading, issues);
+            continue;
+        }
         checkToken(tableCell(row, table.header, 'Required'), ACCEPTANCE_REQUIRED_TOKENS, 'ACCEPTANCE_REQUIRED_INVALID_TOKEN', relativePath, heading, issues);
         checkToken(tableCell(row, table.header, 'Status'), ACCEPTANCE_STATUS_TOKENS, 'ACCEPTANCE_STATUS_INVALID_TOKEN', relativePath, heading, issues);
         const disposition = tableCell(row, table.header, 'Disposition');
@@ -245,20 +264,34 @@ function validateTaskAcceptanceTable(content, relativePath, issues) {
 function validateTaskValidationTable(content, relativePath, issues) {
     const heading = '## Validation';
     const table = sectionTable(content, heading);
-    if (!requireTableHeader(table.rows, ['Check', 'Command / Method', 'Required', 'Latest Result', 'Evidence'], relativePath, heading, issues))
+    if (!requireAnyTableHeader(table.rows, [
+        ['Check', 'Gate', 'Result', 'Evidence'],
+        ['Check', 'Command / Method', 'Required', 'Latest Result', 'Evidence']
+    ], relativePath, heading, issues))
         return;
     for (const row of table.dataRows) {
         if (!row.some(Boolean))
             continue;
-        checkToken(tableCell(row, table.header, 'Required'), VALIDATION_REQUIRED_TOKENS, 'VALIDATION_REQUIRED_INVALID_TOKEN', relativePath, heading, issues);
-        checkToken(tableCell(row, table.header, 'Latest Result'), VALIDATION_RESULT_TOKENS, 'VALIDATION_RESULT_INVALID_TOKEN', relativePath, heading, issues);
+        checkToken(tableCellAny(row, table.header, ['Gate', 'Required']), VALIDATION_REQUIRED_TOKENS, 'VALIDATION_REQUIRED_INVALID_TOKEN', relativePath, heading, issues);
+        checkToken(tableCellAny(row, table.header, ['Result', 'Latest Result']), VALIDATION_RESULT_TOKENS, 'VALIDATION_RESULT_INVALID_TOKEN', relativePath, heading, issues);
     }
 }
 function validateTaskChangeSummaryTable(content, relativePath, issues) {
-    const heading = '## Change Summary';
+    const heading = sectionHeading(content, ['## Changes', '## Change Summary']);
     const table = sectionTable(content, heading);
     if (!requireChangeSummaryHeader(table.rows, relativePath, heading, issues))
         return;
+    if (table.header[0] === 'Area') {
+        for (const row of table.dataRows) {
+            if (!row.some(Boolean))
+                continue;
+            const area = tableCell(row, table.header, 'Area');
+            if (!area) {
+                issues.push(taskTableIssue('CHANGE_SUMMARY_AREA_MISSING', 'Changes rows require an Area value.', relativePath, heading, 'module:task status'));
+            }
+        }
+        return;
+    }
     if (table.header[1] === 'Area') {
         for (const row of table.dataRows) {
             if (!row.some(Boolean))
@@ -284,33 +317,88 @@ function validateTaskChangeSummaryTable(content, relativePath, issues) {
 }
 function requireChangeSummaryHeader(rows, relativePath, heading, issues) {
     const actual = rows[0] ?? [];
+    const summaryHeader = ['Area', 'Summary'];
+    const summaryWithEvidenceHeader = ['Area', 'Summary', 'Evidence'];
     const areaHeader = ['Path', 'Area', 'Change', 'Reason', 'Evidence'];
     const legacyLinesHeader = ['Path', 'Lines', 'Change', 'Reason', 'Evidence'];
-    if (areaHeader.every((cell, index) => actual[index] === cell) || legacyLinesHeader.every((cell, index) => actual[index] === cell))
+    if (summaryHeader.every((cell, index) => actual[index] === cell) ||
+        summaryWithEvidenceHeader.every((cell, index) => actual[index] === cell) ||
+        areaHeader.every((cell, index) => actual[index] === cell) ||
+        legacyLinesHeader.every((cell, index) => actual[index] === cell))
         return true;
-    issues.push(taskTableIssue('TASK_TABLE_SCHEMA_INVALID', `${heading} table header must be: | ${areaHeader.join(' | ')} |`, relativePath, heading, `| ${areaHeader.join(' | ')} |`));
+    issues.push(taskTableIssue('TASK_TABLE_SCHEMA_INVALID', `${heading} table header must be: | ${summaryHeader.join(' | ')} |`, relativePath, heading, `| ${summaryHeader.join(' | ')} |`));
     return false;
 }
 function validateTaskRisksTable(content, relativePath, issues) {
     const heading = '## Risks / Follow-ups';
     const table = sectionTable(content, heading);
-    if (!requireTableHeader(table.rows, ['ID', 'Kind', 'Summary', 'State', 'Reference'], relativePath, heading, issues))
+    if (!requireAnyTableHeader(table.rows, [
+        ['ID', 'Type', 'Summary', 'State', 'Link'],
+        ['ID', 'Kind', 'Summary', 'State', 'Reference']
+    ], relativePath, heading, issues))
         return;
     for (const row of table.dataRows) {
         if (!row.some(Boolean))
             continue;
-        checkToken(tableCell(row, table.header, 'Kind'), RISK_KIND_TOKENS, 'TASK_RISK_KIND_INVALID_TOKEN', relativePath, heading, issues);
+        checkToken(tableCellAny(row, table.header, ['Type', 'Kind']), RISK_KIND_TOKENS, 'TASK_RISK_KIND_INVALID_TOKEN', relativePath, heading, issues);
         checkToken(tableCell(row, table.header, 'State'), RISK_STATE_TOKENS, 'TASK_RISK_STATE_INVALID_TOKEN', relativePath, heading, issues);
     }
 }
+function validateTaskHistoryTable(content, relativePath, issues) {
+    if (!content.includes('## History'))
+        return;
+    const heading = '## History';
+    const table = sectionTable(content, heading);
+    requireTableHeader(table.rows, ['Date', 'State', 'Note'], relativePath, heading, issues);
+}
 function validateTaskCloseStateBoundaries(content, relativePath, issues) {
     if (/^\|\s*CloseState\s*\|/im.test(content) || /^\|\s*Close State\s*\|/im.test(content)) {
         issues.push(taskTableIssue('TASK_CLOSE_STATE_PERSISTED_IN_TASK', 'TASK.md must not persist derived CloseState values.', relativePath, 'TASK.md'));
     }
-    if (/\n##\s*Close Proof\b/i.test(content) || /\baudit-close\b/i.test((0, markdown_table_1.readMarkdownSection)(content, '## Change Summary'))) {
+    if (/\n##\s*Close Proof\b/i.test(content) || /\baudit-close\b/i.test((0, markdown_table_1.readMarkdownSection)(content, sectionHeading(content, ['## Changes', '## Change Summary'])))) {
         issues.push(taskTableIssue('TASK_CLOSE_PROOF_IN_CLOSE_SOURCE', 'TASK.md must not include close proof or audit-close result tables.', relativePath, 'TASK.md'));
     }
 }
+function requireTaskSection(content, relativePath, issues, heading) {
+    if (content.includes(heading))
+        return;
+    issues.push({
+        severity: 'error',
+        code: 'TASK_SECTION_MISSING',
+        message: `TASK.md is missing required section: ${heading}`,
+        path: relativePath,
+        heading,
+        fixHint: `Add the ${heading} section to TASK.md and fill it with task-specific content.`,
+        remediationHint: {
+            path: relativePath,
+            heading,
+            requiredChange: `Add the missing ${heading} section to TASK.md.`,
+            blocking: true
+        }
+    });
+}
+function requireAnyTaskSection(content, relativePath, issues, headings) {
+    if (headings.some((heading) => content.includes(heading)))
+        return;
+    const heading = headings[0];
+    issues.push({
+        severity: 'error',
+        code: 'TASK_SECTION_MISSING',
+        message: `TASK.md is missing required section: ${headings.join(' or ')}`,
+        path: relativePath,
+        heading,
+        fixHint: `Add the ${heading} section to TASK.md and fill it with task-specific content.`,
+        remediationHint: {
+            path: relativePath,
+            heading,
+            requiredChange: `Add one of these sections to TASK.md: ${headings.join(', ')}.`,
+            blocking: true
+        }
+    });
+}
+function sectionHeading(content, headings) {
+    return headings.find((heading) => content.includes(heading)) ?? headings[0];
+}
 function sectionRows(content, heading) {
     return (0, markdown_table_1.parseMarkdownRows)((0, markdown_table_1.readMarkdownSection)(content, heading));
 }
@@ -329,10 +417,26 @@ function requireTableHeader(rows, expected, relativePath, heading, issues) {
     issues.push(taskTableIssue('TASK_TABLE_SCHEMA_INVALID', `${heading} table header must be: | ${expected.join(' | ')} |`, relativePath, heading, `| ${expected.join(' | ')} |`));
     return false;
 }
+function requireAnyTableHeader(rows, expectedHeaders, relativePath, heading, issues) {
+    const actual = rows[0] ?? [];
+    if (expectedHeaders.some((expected) => expected.every((cell, index) => actual[index] === cell)))
+        return true;
+    const preferred = expectedHeaders[0];
+    issues.push(taskTableIssue('TASK_TABLE_SCHEMA_INVALID', `${heading} table header must be: | ${preferred.join(' | ')} |`, relativePath, heading, `| ${preferred.join(' | ')} |`));
+    return false;
+}
 function tableCell(row, header, name) {
     const index = header.findIndex((cell) => cell === name);
     return index >= 0 ? (row[index] ?? '').trim() : '';
 }
+function tableCellAny(row, header, names) {
+    for (const name of names) {
+        const value = tableCell(row, header, name);
+        if (value)
+            return value;
+    }
+    return '';
+}
 function checkToken(value, allowed, code, relativePath, heading, issues) {
     if (allowed.has(value))
         return;

package/dist/services/capability-registry.js

@@ -300,8 +300,8 @@ exports.HADARA_COMMAND_REGISTRY = [
     },
     {
         id: 'task.status',
-        command: 'hadara task status [--task <task-id>] [--detail fast|full] [--json]',
-        summary: 'Read the phase-aware task cockpit: next-work selection without --task, fast selected-capsule loop guidance with --task, or explicit full diagnostics with --detail full.',
+        command: 'hadara task status [--task <task-id>] [--detail fast|full] [--json|--summary-json]',
+        summary: 'Read the phase-aware task cockpit: next-work selection without --task, fast selected-capsule loop guidance with --task, compact selected-capsule summary with --summary-json, or explicit full diagnostics with --detail full.',
         canonical: true,
         appearsInDefaultHelp: true,
         family: 'capsule-lifecycle',
@@ -318,6 +318,7 @@ exports.HADARA_COMMAND_REGISTRY = [
         examples: [
             example('Select next work', 'hadara task status --json', 'At session start or after a capsule closes.'),
             example('Inspect capsule status', 'hadara task status --task T-0001 --json', 'At loop boundaries for a selected capsule.'),
+            example('Inspect compact capsule status', 'hadara task status --task T-0001 --summary-json', 'When shell automation or humans only need phase, readiness, counts, and next action.'),
             example('Inspect full diagnostics', 'hadara task status --task T-0001 --detail full --json', 'When explicit close/protocol diagnostics are needed without finalize planning.')
         ],
         related: ['task.next', 'evidence.list', 'proof.status'],
@@ -1868,9 +1869,9 @@ exports.HADARA_COMMAND_REGISTRY = [
         testFiles: ['tests/unit/package-recycle.test.ts'],
         docs: ['docs/RELEASE_READINESS.md', 'docs/CLI_JSON_CONTRACT.md'],
         examples: [
-            example('Preview installed-package recycle', 'hadara package recycle --package hadara@latest --expected-version 0.3.3 --json', 'Before running registry-backed consumer install validation.'),
-            example('Execute installed-package recycle', 'hadara package recycle --execute --package hadara@latest --expected-version 0.3.3 --task T-XXXX --attach-evidence --json', 'After an npm publish when verifying consumer install paths.'),
-            example('Execute recycle with graph diagnostics', 'hadara package recycle --execute --package hadara@latest --expected-version 0.3.3 --include-graph --json', 'When intentionally running the broader context graph smoke.')
+            example('Preview installed-package recycle', 'hadara package recycle --package hadara@latest --expected-version 0.4.0 --json', 'Before running registry-backed consumer install validation.'),
+            example('Execute installed-package recycle', 'hadara package recycle --execute --package hadara@latest --expected-version 0.4.0 --task T-XXXX --attach-evidence --json', 'After an npm publish when verifying consumer install paths.'),
+            example('Execute recycle with graph diagnostics', 'hadara package recycle --execute --package hadara@latest --expected-version 0.4.0 --include-graph --json', 'When intentionally running the broader context graph smoke.')
         ],
         related: ['package.smoke', 'release.closeout', 'release.publish'],
         conflictsWith: [],

package/dist/services/ci-gate.js

@@ -83,6 +83,7 @@ function createCiGateReport(projectRoot, mode, options = {}) {
         schemaVersion: 'hadara.ci.gate.v1',
         command: 'ci.gate',
         ok: mode === 'advisory' ? true : blockers.length === 0,
+        ...(options.taskId ? { taskId: options.taskId } : {}),
         mode,
         scope: { ...(options.taskId ? { taskId: options.taskId } : {}), taskCount: tasks.length, allowEmpty },
         stateConsistency,

package/dist/services/clean-checkout-smoke.js

@@ -9,6 +9,7 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const schema_1 = require("../core/schema");
+const timing_1 = require("../core/timing");
 const smoke_evidence_1 = require("./smoke-evidence");
 function createCleanCheckoutSmokeReport(options) {
     const issues = [];
@@ -153,6 +154,7 @@ function createCleanCheckoutSmokeReport(options) {
         schemaVersion: 'hadara.cleanCheckoutSmoke.v1',
         command: 'smoke.cleanCheckout',
         ok: issues.every((issue) => issue.severity !== 'error') && steps.every((step) => step.status !== 'failed'),
+        ...(options.taskId ? { taskId: options.taskId } : {}),
         mode: 'execute',
         execution,
         workspace: {
@@ -328,7 +330,7 @@ function cleanupWorkspace(workspace, keepTemp) {
     }
 }
 function runCommand(command, args, options) {
-    const started = Date.now();
+    const timer = (0, timing_1.startMonotonicTimer)();
     const result = (0, node_child_process_1.spawnSync)(command, args, {
         cwd: options.cwd,
         env: options.env ?? process.env,
@@ -341,7 +343,7 @@ function runCommand(command, args, options) {
         signal: result.signal,
         stdout: result.stdout ?? '',
         stderr: result.stderr ?? '',
-        elapsedMs: Date.now() - started,
+        elapsedMs: timer.elapsedMs(),
         timedOut: result.error?.name === 'TimeoutError' || result.signal === 'SIGTERM'
     };
 }

package/dist/services/dashboard-bootstrap.js

@@ -21,7 +21,7 @@ function createDashboardBootstrapReport(projectRoot, input = {}, now = new Date(
     ];
     const selectedTaskId = input.selectedTaskId?.trim();
     const selectedTask = selectedTaskId ? createSelectedTaskSummary(projectRoot, selectedTaskId, now, issues) : null;
-    return {
+    const report = {
         schemaVersion: 'hadara.dashboard.bootstrap.v1',
         command: 'dashboard.bootstrap',
         ok: !issues.some((issue) => issue.severity === 'error'),
@@ -65,6 +65,7 @@ function createDashboardBootstrapReport(projectRoot, input = {}, now = new Date(
         selectedTask,
         issues
     };
+    return redactArtifactPaths(report);
 }
 function createSelectedTaskSummary(projectRoot, taskId, now, aggregateIssues) {
     const workbench = (0, task_workbench_1.createTaskWorkbenchReport)(projectRoot, taskId, now, { detail: 'fast' });
@@ -136,3 +137,17 @@ function proofStatusFrom(semanticIssueCodes, substantivePositive) {
         return 'sufficient';
     return 'unknown';
 }
+function redactArtifactPaths(value) {
+    if (typeof value === 'string') {
+        return value.replace(/\b\S*artifacts\/\S*/g, '[artifact-path-redacted]');
+    }
+    if (Array.isArray(value))
+        return value.map((item) => redactArtifactPaths(item));
+    if (value && typeof value === 'object') {
+        const next = {};
+        for (const [key, child] of Object.entries(value))
+            next[key] = redactArtifactPaths(child);
+        return next;
+    }
+    return value;
+}

package/dist/services/dashboard-task-detail.js

@@ -77,6 +77,7 @@ function createFastTaskWorkbenchReport(projectRoot, taskId, evidenceLint, eviden
         schemaVersion: 'hadara.task.workbench.v1',
         command: 'task.status',
         ok: task.present && blockers === 0,
+        taskId,
         generatedAt,
         projectRoot,
         task: {

package/dist/services/package-recycle.js

@@ -11,6 +11,7 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const schema_1 = require("../core/schema");
+const timing_1 = require("../core/timing");
 const smoke_evidence_1 = require("./smoke-evidence");
 const DEFAULT_PACKAGE_SPECIFIER = 'hadara@latest';
 function createPackageRecycleReport(options) {
@@ -24,6 +25,7 @@ function createPackageRecycleDryRunReport(options) {
         schemaVersion: 'hadara.packageRecycle.v1',
         command: 'package.recycle',
         ok: issues.every((issue) => issue.severity !== 'error'),
+        ...(options.taskId ? { taskId: options.taskId } : {}),
         mode: 'dry-run',
         readOnly: true,
         package: packageInfo,
@@ -194,6 +196,7 @@ function createPackageRecycleExecuteReport(options) {
         schemaVersion: 'hadara.packageRecycle.v1',
         command: 'package.recycle',
         ok: issues.every((issue) => issue.severity !== 'error') && steps.every((step) => step.status !== 'failed'),
+        ...(options.taskId ? { taskId: options.taskId } : {}),
         mode: 'execute',
         readOnly: false,
         package: packageInfo,
@@ -661,7 +664,7 @@ function failStep(step, summary) {
     step.summary = summary;
 }
 function runCommand(command, args, options) {
-    const start = Date.now();
+    const timer = (0, timing_1.startMonotonicTimer)();
     const result = (0, node_child_process_1.spawnSync)(command, args, {
         cwd: options.cwd,
         env: options.env ?? process.env,
@@ -674,7 +677,7 @@ function runCommand(command, args, options) {
         signal: result.signal,
         stdout: result.stdout ?? '',
         stderr: result.stderr ?? '',
-        elapsedMs: Date.now() - start,
+        elapsedMs: timer.elapsedMs(),
         timedOut: result.error?.name === 'Error' && /timed out/i.test(result.error.message)
     };
 }

package/dist/services/package-smoke.js

@@ -10,6 +10,7 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const schema_1 = require("../core/schema");
+const timing_1 = require("../core/timing");
 const smoke_evidence_1 = require("./smoke-evidence");
 const release_targets_1 = require("./release-targets");
 function createPackageSmokeDryRunReport(options) {
@@ -35,6 +36,7 @@ function createPackageSmokeDryRunReport(options) {
         schemaVersion: 'hadara.packageSmoke.v1',
         command: 'package.smoke',
         ok: false,
+        ...(options.taskId ? { taskId: options.taskId } : {}),
         mode: 'dry-run',
         readOnly: true,
         provider: {
@@ -295,6 +297,7 @@ function createPackageSmokeLocalReport(options) {
         schemaVersion: 'hadara.packageSmoke.v1',
         command: 'package.smoke',
         ok: issues.every((issue) => issue.severity !== 'error') && steps.every((step) => step.status !== 'failed'),
+        ...(options.taskId ? { taskId: options.taskId } : {}),
         mode: 'local',
         readOnly: false,
         provider: {
@@ -365,6 +368,7 @@ function createPythonPackageSmokeDryRunReport(options) {
         schemaVersion: 'hadara.packageSmoke.v1',
         command: 'package.smoke',
         ok: issues.every((issue) => issue.severity !== 'error'),
+        ...(options.taskId ? { taskId: options.taskId } : {}),
         mode: 'dry-run',
         readOnly: true,
         provider: {
@@ -627,6 +631,7 @@ function createPythonPackageSmokeLocalReport(options) {
         schemaVersion: 'hadara.packageSmoke.v1',
         command: 'package.smoke',
         ok: issues.every((issue) => issue.severity !== 'error') && steps.every((step) => step.status !== 'failed'),
+        ...(options.taskId ? { taskId: options.taskId } : {}),
         mode: 'local',
         readOnly: false,
         provider: {
@@ -981,7 +986,7 @@ function cleanupWorkspace(workspace, keepTemp) {
     }
 }
 function runCommand(command, args, options) {
-    const started = Date.now();
+    const timer = (0, timing_1.startMonotonicTimer)();
     const result = (0, node_child_process_1.spawnSync)(command, args, {
         cwd: options.cwd,
         env: options.env ?? process.env,
@@ -994,7 +999,7 @@ function runCommand(command, args, options) {
         signal: result.signal,
         stdout: result.stdout ?? '',
         stderr: result.stderr ?? '',
-        elapsedMs: Date.now() - started,
+        elapsedMs: timer.elapsedMs(),
         timedOut: result.error?.name === 'TimeoutError' || result.signal === 'SIGTERM'
     };
 }

package/dist/services/proof-status.js

@@ -17,6 +17,7 @@ function createProofStatusReport(projectRoot, taskId, mode = 'status') {
             schemaVersion: mode === 'explain' ? 'hadara.proof.explain.v1' : 'hadara.proof.status.v1',
             command: mode === 'explain' ? 'proof.explain' : 'proof.status',
             ok: false,
+            taskId,
             target: { kind: 'task', taskId },
             claim: 'task-readiness',
             verdict: 'unknown',
@@ -48,6 +49,7 @@ function createProofStatusReport(projectRoot, taskId, mode = 'status') {
         schemaVersion: mode === 'explain' ? 'hadara.proof.explain.v1' : 'hadara.proof.status.v1',
         command: mode === 'explain' ? 'proof.explain' : 'proof.status',
         ok: blockers.length === 0,
+        taskId,
         target: { kind: 'task', taskId },
         claim: 'task-readiness',
         verdict,

package/dist/services/protocol-consistency.js

@@ -32,7 +32,7 @@ function createTaskProtocolConsistencyReport(projectRoot, taskId, now = new Date
             taskId,
             message: `Task Capsule not found: ${taskId}`
         });
-        return buildReport(projectRoot, now, issues, checkedDocs, undefined, null);
+        return buildReport(projectRoot, now, issues, checkedDocs, undefined, null, undefined, { taskId });
     }
     const capsulePath = toPortablePath(node_path_1.default.relative(projectRoot, task.dir));
     const taskStatus = readTaskStatus(task);
@@ -155,6 +155,7 @@ function buildReport(projectRoot, now, issues, checkedDocs, task, taskBoardStatu
         schemaVersion: 'hadara.protocol.consistency.v1',
         command: 'protocol.doctor',
         ok: counts.error === 0,
+        ...(options?.taskId ? { taskId: options.taskId } : task ? { taskId: task.id } : {}),
         scope: options?.scope ?? 'tasks',
         projectRoot,
         generatedAt: now.toISOString(),

package/dist/services/protocol-migration.js

@@ -33,6 +33,7 @@ function createProtocolMigrationReport(input) {
         schemaVersion: 'hadara.protocol.migration.v1',
         command: 'protocol.migrate',
         ok: issues.every((issue) => issue.severity !== 'error'),
+        ...(input.taskId ? { taskId: input.taskId } : {}),
         mode: input.mode,
         target: { protocolVersion: input.target },
         scope: { kind: input.taskId ? 'task' : 'project', taskId: input.taskId ?? null },

package/dist/services/release-artifact.js

@@ -11,6 +11,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const fs_1 = require("../core/fs");
 const schema_1 = require("../core/schema");
+const timing_1 = require("../core/timing");
 const RELEASE_PACKAGE_DESCRIPTION = 'Portable AI-assisted development workbench for evidence-backed task capsules, handoffs, and release gates.';
 const RELEASE_PACKAGE_KEYWORDS = [
     'ai',
@@ -434,7 +435,7 @@ function cleanupDirectory(directory, cleanup) {
         node_fs_1.default.rmSync(directory, { recursive: true, force: true });
 }
 function runCommand(command, args, options) {
-    const started = Date.now();
+    const timer = (0, timing_1.startMonotonicTimer)();
     const result = (0, node_child_process_1.spawnSync)(command, args, {
         cwd: options.cwd,
         env: options.env,
@@ -447,7 +448,7 @@ function runCommand(command, args, options) {
         signal: result.signal,
         stdout: result.stdout ?? '',
         stderr: result.stderr ?? '',
-        elapsedMs: Date.now() - started,
+        elapsedMs: timer.elapsedMs(),
         timedOut: result.error?.name === 'TimeoutError' || result.signal === 'SIGTERM'
     };
 }

package/dist/services/release-closeout.js

@@ -40,6 +40,7 @@ function createReleaseCloseoutReport(projectRoot, input) {
         schemaVersion: 'hadara.releaseCloseout.v1',
         command: 'release.closeout',
         ok: !issues.some((issue) => issue.severity === 'error'),
+        taskId,
         readOnly: true,
         generatedAt: new Date().toISOString(),
         input: { version, taskId },

package/dist/services/release-diagnostics.js

@@ -3,15 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.timeStage = timeStage;
 exports.applyStageStatuses = applyStageStatuses;
 exports.createDiagnostics = createDiagnostics;
+const timing_1 = require("../core/timing");
 function timeStage(timings, stage, fn) {
-    const startedAt = Date.now();
+    const timer = (0, timing_1.startMonotonicTimer)();
     try {
         return fn();
     }
     finally {
         timings.push({
             stage,
-            durationMs: Date.now() - startedAt,
+            durationMs: timer.elapsedMs(),
             status: 'passed',
             summary: `${stage} completed.`
         });
@@ -30,11 +31,11 @@ function applyStageStatuses(timings, releaseGateOk, checks) {
         }
     }
 }
-function createDiagnostics(generatedAt, startedAt, stageTimings, releaseTargetConfiguration) {
+function createDiagnostics(generatedAt, timer, stageTimings, releaseTargetConfiguration) {
     const thresholdMs = 5000;
     return {
         generatedAt,
-        durationMs: Date.now() - startedAt,
+        durationMs: timer.elapsedMs(),
         advisories: releaseTargetConfiguration.issues.map((issue) => ({
             area: 'release-target-configuration',
             severity: 'warning',