hadara 0.3.2 → 0.3.3

package/dist/services/protocol-consistency.js

@@ -13,6 +13,7 @@ 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 acceptance_1 = require("../task/acceptance");
 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']);
@@ -656,25 +657,22 @@ function checkDoneAcceptance(projectRoot, task, taskLooksDone, issues) {
     if (!node_fs_1.default.existsSync(acceptancePath))
         return;
     const content = node_fs_1.default.readFileSync(acceptancePath, 'utf8');
-    const rows = (0, markdown_table_1.parseMarkdownRows)(content).filter((cells) => /^AC-\d+$/i.test(cells[0] ?? ''));
-    const pendingRows = rows.filter((cells) => {
-        const status = cells[2]?.trim().toLowerCase();
-        return !status || status === 'pending' || status === 'blocked';
-    });
+    const acceptance = (0, acceptance_1.analyzeAcceptanceReadiness)(content);
     const checklistPending = content
         .split(/\r?\n/)
         .map((line) => line.trim())
         .some((line) => /^-\s+\[\s\]/.test(line));
-    if (pendingRows.length > 0 || (rows.length === 0 && checklistPending)) {
+    if (acceptance.blockers.length > 0 || (acceptance.rows.length === 0 && checklistPending)) {
+        const blockerSummary = acceptance.blockers.length > 0 ? ` Blockers: ${acceptance.blockers.map((blocker) => `${blocker.code}(${blocker.row.id})`).join(', ')}.` : '';
         pushIssue(issues, {
             code: 'TASK_DONE_ACCEPTANCE_PENDING',
             severity: 'error',
             area: 'validation',
             taskId: task.id,
             path: toPortablePath(node_path_1.default.relative(projectRoot, acceptancePath)),
-            message: 'Task is marked Done but ACCEPTANCE.md still has pending or blocked criteria.',
+            message: `Task is marked Done but ACCEPTANCE.md still has pending, blocked, or in-progress criteria.${blockerSummary}`,
             expected: 'all acceptance criteria complete',
-            actual: 'pending criteria found'
+            actual: 'incomplete criteria found'
         });
     }
 }

package/dist/services/workbench-next-actions.js

@@ -5,6 +5,8 @@ exports.createWorkbenchNextAction = createWorkbenchNextAction;
 function buildWorkbenchNextActions(input) {
     const actions = new Map();
     for (const issue of input.issues) {
+        if (input.closed && issue.severity !== 'error' && issue.code.includes('HANDOFF'))
+            continue;
         addIssueAction(actions, input.taskId, issue);
     }
     if (input.evidenceRecords === 0) {

package/dist/task/acceptance.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeAcceptanceReadiness = analyzeAcceptanceReadiness;
+exports.parseAcceptanceRows = parseAcceptanceRows;
+const markdown_table_1 = require("../services/markdown-table");
+function analyzeAcceptanceReadiness(content) {
+    const rows = parseAcceptanceRows(content);
+    const blockers = rows.flatMap(blockersForAcceptanceRow);
+    return {
+        rows,
+        blockers,
+        summary: {
+            total: rows.length,
+            required: rows.filter((row) => row.required).length,
+            met: rows.filter((row) => row.status === 'Met').length,
+            unresolvedRequired: blockers.filter((blocker) => blocker.code === 'ACCEPTANCE_REQUIRED_UNRESOLVED').length,
+            deferred: rows.filter((row) => row.status === 'Deferred').length,
+            followUps: rows.filter((row) => row.status === 'Follow-up Created').length,
+            acceptedRisks: rows.filter((row) => row.status === 'Accepted Risk').length
+        }
+    };
+}
+function parseAcceptanceRows(content) {
+    const rows = (0, markdown_table_1.parseMarkdownRows)(content);
+    const headerIndex = rows.findIndex((row) => headerIndexFor(row, 'id') >= 0 && headerIndexFor(row, 'status') >= 0);
+    const header = headerIndex >= 0 ? rows[headerIndex] : [];
+    const dataRows = (headerIndex >= 0 ? rows.slice(headerIndex + 1) : rows).filter((cells) => /^AC-\d+$/i.test(cells[0] ?? ''));
+    return dataRows.map((cells) => {
+        const allText = cells.join(' ');
+        const status = normalizeAcceptanceStatus(cellByHeader(cells, header, 'status') ?? cells[2] ?? '');
+        return {
+            id: cells[0] ?? '',
+            criterion: cellByHeader(cells, header, 'criterion') ?? cells[1] ?? '',
+            origin: normalizeAcceptanceOrigin(cellByHeader(cells, header, 'origin')),
+            required: normalizeBooleanCell(cellByHeader(cells, header, 'required'), true),
+            deferrable: normalizeBooleanCell(cellByHeader(cells, header, 'deferrable'), false),
+            status,
+            rawStatus: cellByHeader(cells, header, 'status') ?? cells[2] ?? '',
+            evidenceRefs: extractRefs(allText, /\bev:T-\d{4}:[A-Za-z0-9]+\b/g),
+            decisionRefs: extractRefs(allText, /\bD-[A-Za-z0-9._-]+\b/g),
+            riskRefs: extractRefs(allText, /\bR-[A-Za-z0-9._-]+\b/g),
+            followUpRefs: extractRefs(allText, /\b(?:T-\d{4}|DEBT-[A-Za-z0-9._-]+|GH-\d+)\b|hadara\s+task\s+create\s+["'`][^"'`]+["'`]/gi)
+        };
+    });
+}
+function blockersForAcceptanceRow(row) {
+    const blockers = [];
+    if (row.required && ['Not Met', 'In Progress', 'Pending', 'TBD', 'Blocked', 'Partial'].includes(row.status)) {
+        blockers.push({
+            row,
+            code: 'ACCEPTANCE_REQUIRED_UNRESOLVED',
+            message: `${row.id} is required but remains ${row.status}.`
+        });
+    }
+    if (row.status === 'Unknown') {
+        blockers.push({
+            row,
+            code: 'ACCEPTANCE_STATUS_UNKNOWN',
+            message: `${row.id} has unknown acceptance status "${row.rawStatus}".`
+        });
+    }
+    if (['Deferred', 'Follow-up Created', 'Accepted Risk'].includes(row.status)) {
+        if (row.required && !row.deferrable) {
+            blockers.push({
+                row,
+                code: 'ACCEPTANCE_NONDEFERRABLE_DEFERRED',
+                message: `${row.id} is required and non-deferrable, so ${row.status} cannot close as Done.`
+            });
+        }
+        if (row.decisionRefs.length === 0) {
+            blockers.push({
+                row,
+                code: 'ACCEPTANCE_DEFERRED_WITHOUT_DECISION',
+                message: `${row.id} is ${row.status} without a decision reference.`
+            });
+        }
+    }
+    if (row.status === 'Follow-up Created' && row.followUpRefs.length === 0) {
+        blockers.push({
+            row,
+            code: 'ACCEPTANCE_FOLLOWUP_WITHOUT_FOLLOWUP',
+            message: `${row.id} is Follow-up Created without a concrete follow-up reference.`
+        });
+    }
+    if (row.status === 'Accepted Risk' && row.riskRefs.length === 0) {
+        blockers.push({
+            row,
+            code: 'ACCEPTANCE_ACCEPTED_RISK_WITHOUT_RISK_RECORD',
+            message: `${row.id} is Accepted Risk without a risk reference.`
+        });
+    }
+    return blockers;
+}
+function cellByHeader(cells, header, name) {
+    const index = headerIndexFor(header, name);
+    return index >= 0 ? cells[index] : undefined;
+}
+function headerIndexFor(header, name) {
+    const expected = normalizeHeader(name);
+    return header.findIndex((cell) => normalizeHeader(cell) === expected);
+}
+function normalizeHeader(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+function normalizeAcceptanceStatus(value) {
+    const normalized = value.trim().toLowerCase().replace(/[-_]+/g, ' ').replace(/\s+/g, ' ');
+    switch (normalized) {
+        case 'met':
+        case 'done':
+        case 'complete':
+        case 'completed':
+            return 'Met';
+        case 'not met':
+            return 'Not Met';
+        case 'in progress':
+            return 'In Progress';
+        case 'pending':
+            return 'Pending';
+        case 'tbd':
+            return 'TBD';
+        case 'deferred':
+            return 'Deferred';
+        case 'blocked':
+            return 'Blocked';
+        case 'partial':
+            return 'Partial';
+        case 'not applicable':
+        case 'n/a':
+        case 'na':
+            return 'Not Applicable';
+        case 'superseded':
+            return 'Superseded';
+        case 'follow up created':
+        case 'followup created':
+            return 'Follow-up Created';
+        case 'accepted risk':
+            return 'Accepted Risk';
+        default:
+            return 'Unknown';
+    }
+}
+function normalizeAcceptanceOrigin(value) {
+    const normalized = (value ?? '').trim().toLowerCase().replace(/[_\s]+/g, '-');
+    switch (normalized) {
+        case 'planned':
+            return 'planned';
+        case 'discovered':
+            return 'discovered';
+        case 'reviewer-feedback':
+            return 'reviewer-feedback';
+        case 'generated':
+            return 'generated';
+        case 'migration':
+            return 'migration';
+        default:
+            return 'original';
+    }
+}
+function normalizeBooleanCell(value, defaultValue) {
+    const normalized = (value ?? '').trim().toLowerCase();
+    if (!normalized)
+        return defaultValue;
+    if (['yes', 'y', 'true', '1', 'required'].includes(normalized))
+        return true;
+    if (['no', 'n', 'false', '0', 'optional'].includes(normalized))
+        return false;
+    return defaultValue;
+}
+function extractRefs(value, pattern) {
+    return [...new Set([...value.matchAll(pattern)].map((match) => match[0]))];
+}

package/dist/task/task-close-repair-plan.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskCloseRepairPlanReport = createTaskCloseRepairPlanReport;
+exports.formatTaskCloseRepairPlanReport = formatTaskCloseRepairPlanReport;
+const lifecycle_next_actions_1 = require("./lifecycle-next-actions");
+const task_close_1 = require("./task-close");
+function createTaskCloseRepairPlanReport(projectRoot, taskId, options = {}) {
+    const actor = options.actor ?? (0, lifecycle_next_actions_1.defaultTaskLifecycleActor)();
+    const reports = {
+        close: (0, task_close_1.createTaskCloseReport)(projectRoot, taskId, 'dry-run', { actor }),
+        audit: (0, task_close_1.createTaskAuditCloseReport)(projectRoot, taskId, { actor })
+    };
+    const classification = classifyRepair(reports);
+    const causes = collectCauses(reports, classification);
+    const nextActions = createRepairNextActions(taskId, classification, reports);
+    const issues = collectIssues(reports);
+    return {
+        schemaVersion: 'hadara.task.closeRepairPlan.v1',
+        command: 'task.close-repair-plan',
+        ok: !reports.close.issues.some((issue) => issue.code === 'TASK_NOT_FOUND') && !reports.audit.issues.some((issue) => issue.code === 'TASK_NOT_FOUND'),
+        readOnly: true,
+        taskId,
+        generatedAt: new Date().toISOString(),
+        actor,
+        classification,
+        repairNeeded: classification !== 'closed-valid',
+        summary: summarizeClassification(classification, reports),
+        evidence: createEvidenceSummary(reports.audit),
+        causes,
+        ...(nextActions[0] ? { primaryNextAction: nextActions[0] } : {}),
+        nextActions,
+        issues
+    };
+}
+function formatTaskCloseRepairPlanReport(report) {
+    const lines = [`[HADARA] task close-repair-plan ${report.taskId}: ${report.classification}`];
+    lines.push(`readOnly=${report.readOnly} repairNeeded=${report.repairNeeded} ok=${report.ok}`);
+    lines.push(report.summary);
+    if (report.primaryNextAction)
+        lines.push(`next=${report.primaryNextAction.command ?? report.primaryNextAction.summary ?? report.primaryNextAction.id}`);
+    for (const cause of report.causes)
+        lines.push(`[${cause.severity}] ${cause.code}: ${cause.summary}`);
+    return lines.join('\n');
+}
+function classifyRepair(reports) {
+    const audit = reports.audit;
+    if (reports.close.issues.some((issue) => issue.code === 'TASK_NOT_FOUND') || audit.issues.some((issue) => issue.code === 'TASK_NOT_FOUND'))
+        return 'unknown';
+    if (!audit.auditVerdict.closeEvidenceFound)
+        return 'not-closed';
+    if ((audit.closeEvidenceAudit?.duplicateCloseEvidenceCount ?? 0) > 0)
+        return 'duplicate-close-proof';
+    if (!audit.auditVerdict.closeEvidenceValid || audit.auditVerdict.verdict === 'close-evidence-invalid')
+        return 'closed-invalid';
+    if (audit.auditVerdict.reportHashMatches === false || audit.auditVerdict.sourceHashMatches === false || audit.auditVerdict.verdict === 'closed-with-drift-warnings')
+        return 'closed-stale';
+    if (audit.auditVerdict.verdict === 'closed-valid')
+        return 'closed-valid';
+    return 'unknown';
+}
+function summarizeClassification(classification, reports) {
+    switch (classification) {
+        case 'not-closed':
+            return 'No valid close evidence exists. Run ready if needed, then review and execute close.';
+        case 'closed-stale':
+            return 'Close evidence exists but recorded source or validation hashes no longer match current state.';
+        case 'closed-invalid':
+            return 'Close-like evidence exists but the latest close proof is invalid or malformed.';
+        case 'duplicate-close-proof':
+            return 'Multiple close proofs share conflicting or duplicate identity; inspect latest proof and append a fresh proof if needed.';
+        case 'closed-valid':
+            return 'Close proof is current and valid. No repair is needed.';
+        case 'unknown':
+            return reports.close.issues.some((issue) => issue.code === 'TASK_NOT_FOUND') ? 'Task was not found.' : 'Close repair state could not be classified.';
+    }
+}
+function createEvidenceSummary(audit) {
+    return {
+        closeEvidenceFound: audit.auditVerdict.closeEvidenceFound,
+        closeEvidenceValid: audit.auditVerdict.closeEvidenceValid,
+        closeEvidenceRecords: audit.summary.closeEvidenceRecords,
+        ...(audit.closeEvidenceAudit?.latestCloseEvidenceId ? { latestCloseEvidenceId: audit.closeEvidenceAudit.latestCloseEvidenceId } : {}),
+        ...(audit.closeEvidenceAudit ? { duplicateCloseEvidenceCount: audit.closeEvidenceAudit.duplicateCloseEvidenceCount, supersededCloseEvidenceIds: audit.closeEvidenceAudit.supersededCloseEvidenceIds } : {}),
+        ...(audit.auditVerdict.recordedValidationReportHash ? { recordedValidationReportHash: audit.auditVerdict.recordedValidationReportHash } : {}),
+        currentValidationReportHash: audit.auditVerdict.currentValidationReportHash,
+        ...(typeof audit.auditVerdict.reportHashMatches === 'boolean' ? { reportHashMatches: audit.auditVerdict.reportHashMatches } : {}),
+        ...(audit.auditVerdict.recordedSourceHash ? { recordedSourceHash: audit.auditVerdict.recordedSourceHash } : {}),
+        currentSourceHash: audit.auditVerdict.currentSourceHash,
+        ...(typeof audit.auditVerdict.sourceHashMatches === 'boolean' ? { sourceHashMatches: audit.auditVerdict.sourceHashMatches } : {})
+    };
+}
+function collectCauses(reports, classification) {
+    const causes = [];
+    if (classification === 'closed-valid') {
+        causes.push({ code: 'CLOSE_REPAIR_NOT_NEEDED', severity: 'info', summary: 'Audit reports closed-valid.', sourceReport: 'hadara.task.audit_close.v1' });
+        return causes;
+    }
+    if (classification === 'not-closed') {
+        causes.push({ code: 'CLOSE_REPAIR_NOT_CLOSED', severity: 'error', summary: 'No close evidence was found.', sourceReport: 'hadara.task.audit_close.v1' });
+    }
+    if (classification === 'duplicate-close-proof') {
+        causes.push({
+            code: 'CLOSE_REPAIR_DUPLICATE_PROOF',
+            severity: 'warning',
+            summary: `${reports.audit.closeEvidenceAudit?.duplicateCloseEvidenceCount ?? 0} duplicate close proof record(s) were found.`,
+            sourceReport: 'hadara.task.audit_close.v1'
+        });
+    }
+    if (reports.audit.auditVerdict.reportHashMatches === false) {
+        causes.push({ code: 'CLOSE_REPAIR_REPORT_HASH_DRIFT', severity: 'warning', summary: 'Recorded validation report hash differs from the current validation hash.', sourceReport: 'hadara.task.audit_close.v1' });
+    }
+    if (reports.audit.auditVerdict.sourceHashMatches === false) {
+        causes.push({ code: 'CLOSE_REPAIR_SOURCE_HASH_DRIFT', severity: 'warning', summary: 'Recorded close-source hash differs from the current close-source hash.', sourceReport: 'hadara.task.audit_close.v1' });
+    }
+    if (!reports.audit.auditVerdict.closeEvidenceValid && reports.audit.auditVerdict.closeEvidenceFound) {
+        causes.push({ code: 'CLOSE_REPAIR_INVALID_PROOF', severity: 'error', summary: 'Latest close evidence is not a passed command-log close proof.', sourceReport: 'hadara.task.audit_close.v1' });
+    }
+    for (const issue of reports.audit.issues) {
+        if (causes.some((cause) => cause.code === issue.code))
+            continue;
+        causes.push({ code: issue.code, severity: issue.severity, summary: issue.message, sourceReport: 'hadara.task.audit_close.v1', ...(issue.path ? { path: issue.path } : {}) });
+    }
+    if (causes.length === 0)
+        causes.push({ code: 'CLOSE_REPAIR_UNKNOWN', severity: 'warning', summary: 'Repair state is not closed-valid but no specific cause was available.', sourceReport: 'hadara.task.audit_close.v1' });
+    return causes;
+}
+function createRepairNextActions(taskId, classification, reports) {
+    if (classification === 'closed-valid')
+        return [];
+    if (classification === 'unknown') {
+        return [
+            (0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
+                id: 'inspect-task',
+                kind: 'review',
+                required: true,
+                message: `Inspect task ${taskId} before repairing close state.`,
+                writeBoundary: 'read-only',
+                recommendedActorRole: 'reviewer',
+                requiresBeforeHash: false,
+                stalePlanRisk: 'none'
+            })
+        ];
+    }
+    const actions = [];
+    if (!reports.close.ok) {
+        actions.push((0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
+            id: 'run-ready',
+            required: true,
+            command: `hadara task ready --task ${taskId} --level done --json`,
+            message: 'Resolve readiness blockers before appending a fresh close proof.',
+            writeBoundary: 'read-only',
+            recommendedActorRole: 'worker',
+            requiresBeforeHash: false,
+            stalePlanRisk: 'none'
+        }));
+    }
+    actions.push((0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
+        id: 'review-close-plan',
+        required: true,
+        command: `hadara task close --task ${taskId} --json`,
+        message: 'Review the current close plan before appending or replacing close evidence.',
+        writeBoundary: 'read-only',
+        recommendedActorRole: 'worker',
+        requiresBeforeHash: false,
+        stalePlanRisk: classification === 'closed-stale' ? 'medium' : 'low'
+    }));
+    actions.push((0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
+        id: 'audit-after-repair',
+        required: false,
+        command: `hadara task audit-close --task ${taskId} --json`,
+        message: 'After close execute, audit the repaired close proof.',
+        writeBoundary: 'read-only',
+        recommendedActorRole: 'reviewer',
+        requiresBeforeHash: false,
+        stalePlanRisk: 'none'
+    }));
+    return actions;
+}
+function collectIssues(reports) {
+    const seen = new Set();
+    const issues = [];
+    for (const issue of [...reports.close.issues, ...reports.audit.issues]) {
+        const key = `${issue.severity}:${issue.code}:${issue.path ?? ''}:${issue.message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        issues.push({ severity: issue.severity, code: issue.code, message: issue.message, ...(issue.path ? { path: issue.path } : {}) });
+    }
+    return issues;
+}

package/dist/task/task-close.js

@@ -175,7 +175,36 @@ function createNextActions(taskId, ok, mode, closeEvidenceWrite) {
             }
         ];
     }
-    const actions = [
+    if (ok) {
+        if (closeEvidenceWrite?.duplicateAction === 'no-op') {
+            return [
+                (0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
+                    id: 'audit-close',
+                    required: false,
+                    command: `hadara task audit-close --task ${taskId} --json`,
+                    message: 'Matching close evidence already exists; audit the existing close record.',
+                    writeBoundary: 'read-only',
+                    recommendedActorRole: 'reviewer',
+                    requiresBeforeHash: false,
+                    stalePlanRisk: 'none'
+                })
+            ];
+        }
+        return [
+            (0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
+                id: 'append-close-evidence',
+                required: true,
+                command: `hadara task close --task ${taskId} --execute --json`,
+                message: 'Append close audit evidence after reviewing this dry-run plan.',
+                writeBoundary: 'evidence-append',
+                recommendedActorRole: 'worker',
+                requiresBeforeHash: false,
+                stalePlanRisk: 'low',
+                loopBoundary: true
+            })
+        ];
+    }
+    return [
         (0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
             id: 'run-done-validation',
             required: true,
@@ -195,37 +224,8 @@ function createNextActions(taskId, ok, mode, closeEvidenceWrite) {
             recommendedActorRole: 'worker',
             requiresBeforeHash: false,
             stalePlanRisk: 'none'
-        })
-    ];
-    if (ok) {
-        if (closeEvidenceWrite?.duplicateAction === 'no-op') {
-            actions.push((0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
-                id: 'audit-close',
-                required: false,
-                command: `hadara task audit-close --task ${taskId} --json`,
-                message: 'Matching close evidence already exists; audit the existing close record.',
-                writeBoundary: 'read-only',
-                recommendedActorRole: 'reviewer',
-                requiresBeforeHash: false,
-                stalePlanRisk: 'none'
-            }));
-        }
-        else {
-            actions.push((0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
-                id: 'append-close-evidence',
-                required: true,
-                command: `hadara task close --task ${taskId} --execute --json`,
-                message: 'Append close audit evidence after reviewing this dry-run plan.',
-                writeBoundary: 'evidence-append',
-                recommendedActorRole: 'worker',
-                requiresBeforeHash: false,
-                stalePlanRisk: 'low',
-                loopBoundary: true
-            }));
-        }
-    }
-    else {
-        actions.push((0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
+        }),
+        (0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
             id: 'resolve-close-blockers',
             required: true,
             message: 'Resolve blocking issues before appending close evidence.',
@@ -234,9 +234,8 @@ function createNextActions(taskId, ok, mode, closeEvidenceWrite) {
             requiresBeforeHash: false,
             stalePlanRisk: 'none',
             kind: 'review'
-        }));
-    }
-    return actions;
+        })
+    ];
 }
 function buildMissingTaskReport(projectRoot, taskId, mode, issues, actor = (0, lifecycle_next_actions_1.defaultTaskLifecycleActor)()) {
     return {