hadara 0.3.3 → 0.3.4-rc.0

package/dist/services/release-closeout.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReleaseCloseoutReport = createReleaseCloseoutReport;
+exports.formatReleaseCloseoutReport = formatReleaseCloseoutReport;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const task_capsule_1 = require("../task/task-capsule");
+const SHARED_FILES = [
+    { path: 'docs/RELEASE_READINESS.md', kind: 'release-readiness', role: 'source-readiness' },
+    { path: 'docs/RELEASE_NOTES.md', kind: 'release-notes', role: 'publish' },
+    { path: 'docs/PROJECT_STATE.md', kind: 'project-state', role: 'shared-state' },
+    { path: 'docs/AGENT_HANDOFF.md', kind: 'agent-handoff', role: 'shared-state' },
+    { path: 'docs/TASK_BOARD.md', kind: 'task-board', role: 'shared-state' },
+    { path: 'docs/DEVELOPMENT_SLICES.md', kind: 'development-slices', role: 'shared-state' }
+];
+const CAPSULE_FILES = ['TASK.md', 'ACCEPTANCE.md', 'TESTS.md', 'EVIDENCE.md', 'HANDOFF.md'];
+function createReleaseCloseoutReport(projectRoot, input) {
+    const version = input.version ?? null;
+    const taskId = input.taskId ?? null;
+    const issues = [];
+    if (!version)
+        issues.push({ severity: 'error', code: 'RELEASE_CLOSEOUT_VERSION_REQUIRED', message: 'release closeout requires --version <version>.' });
+    if (!taskId)
+        issues.push({ severity: 'error', code: 'RELEASE_CLOSEOUT_TASK_REQUIRED', message: 'release closeout requires --task <task-id>.' });
+    const task = taskId ? (0, task_capsule_1.listTaskCapsules)(projectRoot).find((candidate) => candidate.id === taskId) : undefined;
+    if (taskId && !task)
+        issues.push({ severity: 'warning', code: 'RELEASE_CLOSEOUT_TASK_NOT_FOUND', message: `Task Capsule not found: ${taskId}.`, path: `tasks/${taskId}` });
+    const surfaces = [
+        ...SHARED_FILES.map((surface) => analyzeSharedSurface(projectRoot, surface, version, taskId)),
+        ...CAPSULE_FILES.map((fileName) => analyzeCapsuleSurface(projectRoot, task?.dir, fileName, version, taskId))
+    ];
+    const suggestedFragments = createSuggestedFragments(version, taskId);
+    const current = surfaces.filter((surface) => surface.status === 'current').length;
+    const stale = surfaces.filter((surface) => surface.status === 'stale').length;
+    const missing = surfaces.filter((surface) => surface.status === 'missing').length;
+    return {
+        schemaVersion: 'hadara.releaseCloseout.v1',
+        command: 'release.closeout',
+        ok: !issues.some((issue) => issue.severity === 'error'),
+        readOnly: true,
+        generatedAt: new Date().toISOString(),
+        input: { version, taskId },
+        summary: {
+            files: surfaces.length,
+            current,
+            stale,
+            missing,
+            suggestedFragments: suggestedFragments.length
+        },
+        surfaces,
+        suggestedFragments,
+        issues
+    };
+}
+function formatReleaseCloseoutReport(report) {
+    const lines = [`[HADARA] release closeout ${report.input.version ?? '(missing-version)'}: ${report.ok ? 'ok' : 'issues'}`];
+    lines.push(`files=${report.summary.files} current=${report.summary.current} stale=${report.summary.stale} missing=${report.summary.missing}`);
+    for (const surface of report.surfaces)
+        lines.push(`${surface.status}\t${surface.path}\t${surface.summary}`);
+    for (const issue of report.issues)
+        lines.push(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+    return lines.join('\n');
+}
+function analyzeSharedSurface(projectRoot, surface, version, taskId) {
+    const absolutePath = node_path_1.default.join(projectRoot, surface.path);
+    const content = node_fs_1.default.existsSync(absolutePath) ? node_fs_1.default.readFileSync(absolutePath, 'utf8') : '';
+    const expectedSignals = expectedSharedSignals(surface.kind, version, taskId);
+    return buildSurface(surface, content, expectedSignals);
+}
+function analyzeCapsuleSurface(projectRoot, taskDir, fileName, version, taskId) {
+    const relativePath = taskDir ? toPortablePath(node_path_1.default.relative(projectRoot, node_path_1.default.join(taskDir, fileName))) : `tasks/${taskId ?? 'T-XXXX'}/${fileName}`;
+    const absolutePath = taskDir ? node_path_1.default.join(taskDir, fileName) : '';
+    const content = absolutePath && node_fs_1.default.existsSync(absolutePath) ? node_fs_1.default.readFileSync(absolutePath, 'utf8') : '';
+    return buildSurface({
+        path: relativePath,
+        kind: 'task-capsule',
+        role: 'capsule'
+    }, content, [taskId, version].filter((value) => Boolean(value)));
+}
+function buildSurface(surface, content, expectedSignals) {
+    const matchedSignals = expectedSignals.filter((signal) => content.includes(signal));
+    const missingSignals = expectedSignals.filter((signal) => !content.includes(signal));
+    const status = !content ? 'missing' : missingSignals.length === 0 ? 'current' : 'stale';
+    return {
+        ...surface,
+        status,
+        expectedSignals,
+        matchedSignals,
+        missingSignals,
+        summary: status === 'current' ? 'Expected closeout signals are present.' : status === 'missing' ? 'File is missing or task capsule was not found.' : `Missing closeout signals: ${missingSignals.join(', ')}.`
+    };
+}
+function expectedSharedSignals(kind, version, taskId) {
+    const signals = [version, taskId].filter((value) => Boolean(value));
+    if (kind === 'release-readiness')
+        return signals;
+    if (kind === 'release-notes')
+        return [version].filter((value) => Boolean(value));
+    return signals;
+}
+function createSuggestedFragments(version, taskId) {
+    const displayVersion = version ?? '<version>';
+    const displayTask = taskId ?? '<task-id>';
+    return [
+        {
+            path: 'docs/RELEASE_READINESS.md',
+            sectionHint: 'Current release section',
+            purpose: 'Record source readiness, publish, GitHub Release, and installed-package recycle state.',
+            suggestedMarkdown: `| ${displayVersion} closeout | ${displayTask} | Record readiness, publish verification, GitHub Release decision, installed-package recycle, and residual risks. |`
+        },
+        {
+            path: 'docs/RELEASE_NOTES.md',
+            sectionHint: displayVersion,
+            purpose: 'Summarize the released version for package consumers.',
+            suggestedMarkdown: `## ${displayVersion}\n\n- Summarize user-facing changes.\n- Record npm publish/recycle status and any explicit deferrals.`
+        },
+        {
+            path: 'docs/PROJECT_STATE.md',
+            sectionHint: 'Follow-up note',
+            purpose: 'Carry forward release state into current project status.',
+            suggestedMarkdown: `${displayTask} follow-up note: ${displayVersion} release closeout state was reviewed. Record readiness, publish, GitHub Release, recycle, and next release-line decision.`
+        },
+        {
+            path: 'docs/AGENT_HANDOFF.md',
+            sectionHint: 'Current State / Last 3 Completed Tasks',
+            purpose: 'Route the next agent after release closeout.',
+            suggestedMarkdown: `| Latest Completed Task | ${displayTask} ${displayVersion} release closeout | Record closeout result and next release-line task. |`
+        }
+    ];
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/task/task-finalize.js

@@ -14,7 +14,7 @@ function createTaskFinalizeReport(projectRoot, taskId, options = {}) {
     const actor = options.actor ?? (0, lifecycle_next_actions_1.defaultTaskLifecycleActor)();
     const reports = createFinalizeReports(projectRoot, taskId, actor);
     const steps = createSteps(taskId, reports);
-    const issues = collectIssues(reports);
+    const issues = collectIssues(taskId, reports);
     const planHash = hashPlan(taskId, steps);
     if (options.executeRequested)
         return executeFinalizePlan(projectRoot, taskId, actor, reports, steps, issues, planHash, options.planHash);
@@ -100,7 +100,7 @@ function executeFinalizePlan(projectRoot, taskId, actor, initialReports, initial
 function createPostExecutionReport(projectRoot, taskId, actor, requestedPlanHash, reviewedPlanHash, executedSteps, stoppedAt) {
     const reports = createFinalizeReports(projectRoot, taskId, actor);
     const steps = createSteps(taskId, reports);
-    const issues = collectIssues(reports);
+    const issues = collectIssues(taskId, reports);
     const nextAction = createPrimaryNextAction(taskId, steps, issues);
     const finalAudit = reports.audit?.auditVerdict.verdict === 'closed-valid';
     const execution = {
@@ -178,7 +178,7 @@ function createSteps(taskId, reports) {
                 ? 'required'
                 : 'blocked'
         : 'pending';
-    const auditStatus = reports.audit ? (reports.audit.auditVerdict.closeEvidenceFound ? (reports.audit.ok ? 'satisfied' : 'required') : 'pending') : 'pending';
+    const auditStatus = reports.audit ? (reports.audit.auditVerdict.closeEvidenceFound ? (reports.audit.auditVerdict.verdict === 'closed-valid' ? 'satisfied' : 'required') : 'pending') : 'pending';
     return [
         {
             id: 'finish',
@@ -216,7 +216,13 @@ function createSteps(taskId, reports) {
         {
             id: 'audit-close',
             status: auditStatus,
-            summary: auditStatus === 'satisfied' ? 'Close audit passed.' : auditStatus === 'pending' ? 'Audit waits for close evidence.' : 'Run close audit and repair any drift.',
+            summary: auditStatus === 'satisfied'
+                ? 'Close audit passed.'
+                : auditStatus === 'pending'
+                    ? 'Audit waits for close evidence.'
+                    : reports.audit?.auditVerdict.verdict === 'closed-with-drift-warnings'
+                        ? 'Close audit found close-source drift; review repair plan, then append fresh close proof.'
+                        : 'Run close audit and repair any drift.',
             command: `hadara task audit-close --task ${taskId} --json`,
             mode: 'read-only',
             writeBoundary: 'read-only',
@@ -226,7 +232,7 @@ function createSteps(taskId, reports) {
         }
     ];
 }
-function collectIssues(reports) {
+function collectIssues(taskId, reports) {
     const seen = new Set();
     const issues = [];
     const reportIssues = [...reports.finish.issues, ...(reports.ready?.issues ?? []), ...(reports.close?.issues ?? []), ...(reports.audit?.issues ?? [])];
@@ -255,6 +261,15 @@ function collectIssues(reports) {
             example: 'hadara evidence add-command --task T-XXXX --summary "Focused validation passed." --result passed --category validation --json'
         });
     }
+    if (issues.some(isCloseDriftIssue)) {
+        issues.push({
+            severity: 'info',
+            code: 'TASK_FINALIZE_CLOSE_SOURCE_DRIFT_GUIDANCE',
+            message: 'Close-source files changed after the recorded close proof. Review the repair plan, finish intended doc edits, then append a fresh close proof and audit it.',
+            fixHint: 'Use close-repair-plan for the read-only diagnosis, then rerun the guarded close/finalize path after close-source edits are complete.',
+            example: `hadara task close-repair-plan --task ${taskId} --json`
+        });
+    }
     return issues;
 }
 function createPrimaryNextAction(taskId, steps, issues) {
@@ -274,6 +289,19 @@ function createPrimaryNextAction(taskId, steps, issues) {
             stalePlanRisk: 'low'
         });
     }
+    if (nextStep.id === 'audit-close' && issues.some(isCloseDriftIssue)) {
+        return (0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
+            id: 'finalize-review-close-repair-plan',
+            kind: 'command',
+            required: true,
+            command: `hadara task close-repair-plan --task ${taskId} --json`,
+            message: 'Close-source drift was detected. Review the close repair plan before appending fresh close proof.',
+            writeBoundary: 'read-only',
+            recommendedActorRole: 'reviewer',
+            requiresBeforeHash: false,
+            stalePlanRisk: 'none'
+        });
+    }
     return (0, lifecycle_next_actions_1.createTaskLifecycleNextAction)({
         id: `finalize-${nextStep.id}`,
         kind: nextStep.status === 'blocked' ? 'review' : 'command',
@@ -286,6 +314,9 @@ function createPrimaryNextAction(taskId, steps, issues) {
         stalePlanRisk: nextStep.writeBoundary === 'read-only' ? 'none' : 'low'
     });
 }
+function isCloseDriftIssue(issue) {
+    return issue.code === 'TASK_CLOSE_AUDIT_SOURCE_HASH_DRIFT' || issue.code === 'TASK_CLOSE_AUDIT_CURRENT_REPORT_HASH_DRIFT';
+}
 function summarizeSteps(steps, reports) {
     const evaluatedReports = evaluatedReportNames(steps, reports);
     const skippedReports = ['finish', 'ready', 'close', 'audit-close'].filter((name) => !evaluatedReports.includes(name));

package/dist/task/task-lifecycle.js

@@ -61,7 +61,7 @@ function createChecks(taskId, reports) {
             status: reports.finish.ok ? (reports.finish.summary.plannedWrites > 0 ? 'required' : 'satisfied') : 'blocked',
             summary: reports.finish.summary.plannedWrites > 0 ? 'Task status bookkeeping has planned writes.' : reports.finish.ok ? 'Task finish bookkeeping is current.' : 'Task finish blockers exist.',
             sourceReport: 'hadara.task.finish.v1',
-            command: reports.finish.summary.plannedWrites > 0 ? `hadara task finish --task ${taskId} --json` : undefined
+            ...(reports.finish.summary.plannedWrites > 0 ? { command: `hadara task finish --task ${taskId} --json` } : {})
         },
         sharedDocs: {
             status: sharedDocsPending.length > 0 ? 'warning' : reports.finish.ok ? 'satisfied' : 'pending',
@@ -78,11 +78,11 @@ function createChecks(taskId, reports) {
             status: reports.audit.auditVerdict.closeEvidenceFound ? 'satisfied' : reports.close.ok ? 'required' : 'blocked',
             summary: reports.audit.auditVerdict.closeEvidenceFound ? 'Close evidence exists.' : reports.close.ok ? 'Close evidence has not been appended.' : 'Close preconditions have blockers.',
             sourceReport: 'hadara.task.close.v1',
-            command: reports.audit.auditVerdict.closeEvidenceFound ? undefined : `hadara task close --task ${taskId} --json`
+            ...(reports.audit.auditVerdict.closeEvidenceFound ? {} : { command: `hadara task close --task ${taskId} --json` })
         },
         audit: {
-            status: reports.audit.ok ? 'satisfied' : reports.audit.auditVerdict.closeEvidenceFound ? 'required' : 'pending',
-            summary: reports.audit.ok ? 'Close audit passed.' : reports.audit.auditVerdict.closeEvidenceFound ? 'Close audit requires repair.' : 'Audit waits for close evidence.',
+            status: reports.audit.auditVerdict.verdict === 'closed-valid' ? 'satisfied' : reports.audit.auditVerdict.closeEvidenceFound ? 'required' : 'pending',
+            summary: reports.audit.auditVerdict.verdict === 'closed-valid' ? 'Close audit passed.' : reports.audit.auditVerdict.closeEvidenceFound ? 'Close audit requires repair.' : 'Audit waits for close evidence.',
             sourceReport: 'hadara.task.audit_close.v1',
             command: `hadara task audit-close --task ${taskId} --json`
         }
@@ -103,7 +103,7 @@ function choosePhase(reports, checks, repair) {
         return 'ready-required';
     if (!reports.audit.auditVerdict.closeEvidenceFound)
         return 'close-required';
-    if (reports.audit.ok)
+    if (reports.audit.auditVerdict.verdict === 'closed-valid')
         return 'closed-valid';
     if (repair && repair.classification !== 'closed-valid')
         return 'repair-required';
@@ -133,7 +133,7 @@ function chooseNextAction(taskId, phase, reports, checks, repair) {
     return undefined;
 }
 function createRepair(taskId, audit) {
-    if (audit.ok) {
+    if (audit.auditVerdict.verdict === 'closed-valid') {
         return {
             classification: 'closed-valid',
             summary: 'Close proof is current and valid.',

package/package.json

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