hadara 0.3.4-rc.0 → 0.4.0

package/dist/cli/legacy-boundary.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLegacyMutationBlockedReport = createLegacyMutationBlockedReport;
+exports.printLegacyMutationBlockedReport = printLegacyMutationBlockedReport;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function createLegacyMutationBlockedReport(projectRoot, command) {
+    const scaffoldPath = node_path_1.default.join(projectRoot, '.hadara', 'scaffold.json');
+    if (!node_fs_1.default.existsSync(scaffoldPath)) {
+        return report(command, null, {
+            severity: 'error',
+            code: 'HADARA_PROTOCOL_MISSING',
+            path: '.hadara/scaffold.json',
+            message: 'This project does not declare HADARA protocol metadata. 0.4 mutation commands are disabled.'
+        });
+    }
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(scaffoldPath, 'utf8'));
+        if (parsed.hadaraProtocol === '0.4')
+            return null;
+        return report(command, typeof parsed.hadaraProtocol === 'string' ? parsed.hadaraProtocol : null, {
+            severity: 'error',
+            code: 'HADARA_PROTOCOL_UNSUPPORTED',
+            path: '.hadara/scaffold.json',
+            message: `.hadara/scaffold.json must declare hadaraProtocol "0.4" before running 0.4 mutation commands.`
+        });
+    }
+    catch (error) {
+        return report(command, null, {
+            severity: 'error',
+            code: 'HADARA_PROTOCOL_UNSUPPORTED',
+            path: '.hadara/scaffold.json',
+            message: `.hadara/scaffold.json could not be parsed: ${error instanceof Error ? error.message : String(error)}`
+        });
+    }
+}
+function printLegacyMutationBlockedReport(report, jsonOutput) {
+    if (jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    console.log(`[HADARA] ${report.command} blocked: legacy or unsupported HADARA project`);
+    for (const issue of report.issues)
+        console.log(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+}
+function report(command, detectedProtocol, issue) {
+    return {
+        schemaVersion: 'hadara.legacyProjectBoundary.v1',
+        command,
+        ok: false,
+        mutationAllowed: false,
+        detectedProtocol,
+        supportedProtocol: '0.4',
+        issues: [
+            issue,
+            {
+                severity: 'error',
+                code: 'HADARA_LEGACY_PROJECT_MUTATION_BLOCKED',
+                path: '.hadara/scaffold.json',
+                message: `${command} is a 0.4 mutation command and will not write into a legacy or unsupported project.`
+            }
+        ],
+        nextActions: [
+            {
+                label: 'Use the previous HADARA line for this project',
+                command: 'npx hadara@0.3.3 doctor --json'
+            },
+            {
+                label: 'Initialize a new HADARA 0.4 project',
+                command: 'hadara init --json'
+            }
+        ]
+    };
+}

package/dist/cli/main.js

@@ -34,11 +34,33 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGlobalArgs = normalizeGlobalArgs;
+exports.main = main;
 const paths_1 = require("../core/paths");
 const args_1 = require("./args");
 const errors_1 = require("./errors");
 const help_1 = require("./help");
+const GLOBAL_FLAGS = new Set(['--json']);
+const GLOBAL_OPTIONS_WITH_VALUES = new Set(['--project']);
+function normalizeGlobalArgs(args) {
+    let commandIndex = -1;
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (GLOBAL_FLAGS.has(value) || value === '--help' || value === '-h')
+            continue;
+        if (GLOBAL_OPTIONS_WITH_VALUES.has(value)) {
+            index += 1;
+            continue;
+        }
+        commandIndex = index;
+        break;
+    }
+    if (commandIndex <= 0)
+        return args;
+    return [args[commandIndex], ...args.slice(commandIndex + 1), ...args.slice(0, commandIndex)];
+}
 async function main(args = process.argv.slice(2)) {
+    args = normalizeGlobalArgs(args);
     const command = args[0];
     if (!command || command === '--help' || command === '-h') {
         console.log((0, help_1.renderDefaultHelp)());
@@ -101,6 +123,12 @@ async function main(args = process.argv.slice(2)) {
                 return;
             break;
         }
+        case 'validation': {
+            const { handleValidationCommand } = await Promise.resolve().then(() => __importStar(require('./validation')));
+            if (handleValidationCommand({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
         case 'proof': {
             const { handleProofCommand } = await Promise.resolve().then(() => __importStar(require('./proof')));
             if (handleProofCommand({ args, projectRoot: paths.projectRoot, jsonOutput }))

package/dist/cli/package-smoke.js

@@ -18,6 +18,7 @@ function handlePackageCommand(input) {
             attachEvidence: (0, args_1.getFlag)(input.args, '--attach-evidence'),
             noEvidence: (0, args_1.getFlag)(input.args, '--no-evidence'),
             keepTemp: (0, args_1.getFlag)(input.args, '--keep-temp'),
+            includeGraph: (0, args_1.getFlag)(input.args, '--include-graph'),
             timeoutSeconds: (0, args_1.getIntegerOption)(input.args, '--timeout', { min: 1 })
         });
         if (input.jsonOutput) {

package/dist/cli/release-artifact.js

@@ -5,9 +5,18 @@ const evidence_1 = require("../evidence/evidence");
 const release_artifact_evidence_1 = require("../services/release-artifact-evidence");
 const release_artifact_1 = require("../services/release-artifact");
 const args_1 = require("./args");
+const legacy_boundary_1 = require("./legacy-boundary");
 function handleReleaseArtifactCommand(input) {
     if (input.args[0] !== 'release' || input.args[1] !== 'artifact')
         return false;
+    if ((0, args_1.getFlag)(input.args, '--execute')) {
+        const legacyReport = (0, legacy_boundary_1.createLegacyMutationBlockedReport)(input.paths.projectRoot, 'release.artifact');
+        if (legacyReport) {
+            (0, legacy_boundary_1.printLegacyMutationBlockedReport)(legacyReport, input.jsonOutput);
+            process.exitCode = 6;
+            return true;
+        }
+    }
     const report = (0, release_artifact_1.createReleaseArtifactReport)({
         paths: input.paths,
         execute: (0, args_1.getFlag)(input.args, '--execute'),
@@ -29,7 +38,7 @@ function handleReleaseArtifactCommand(input) {
         })
         : undefined;
     if (input.jsonOutput) {
-        console.log(JSON.stringify(attachment ? { ...report, attachedEvidence: attachment } : report, null, 2));
+        console.log(JSON.stringify(attachment && taskId ? { ...report, taskId, attachedEvidence: attachment } : report, null, 2));
     }
     else {
         console.log(`${report.ok ? 'passed' : 'failed'} | release artifact | ${report.output.retention}`);

package/dist/cli/release-publish.js

@@ -3,10 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleReleasePublishCommand = handleReleasePublishCommand;
 const release_publish_1 = require("../services/release-publish");
 const args_1 = require("./args");
+const legacy_boundary_1 = require("./legacy-boundary");
 function handleReleasePublishCommand(input) {
     if (input.args[0] !== 'release' || input.args[1] !== 'publish')
         return false;
     const mode = parseMode(input.args);
+    if (mode === 'execute') {
+        const legacyReport = (0, legacy_boundary_1.createLegacyMutationBlockedReport)(input.paths.projectRoot, 'release.publish');
+        if (legacyReport) {
+            (0, legacy_boundary_1.printLegacyMutationBlockedReport)(legacyReport, input.jsonOutput);
+            process.exitCode = 6;
+            return true;
+        }
+    }
     const report = (0, release_publish_1.createReleasePublishReport)({
         projectRoot: input.paths.projectRoot,
         auditDir: input.paths.auditDir,

package/dist/cli/task.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleTaskCommand = handleTaskCommand;
 exports.extractTaskCreateTitle = extractTaskCreateTitle;
 const task_close_1 = require("../task/task-close");
-const task_close_repair_plan_1 = require("../task/task-close-repair-plan");
 const task_complete_flow_1 = require("../task/task-complete-flow");
 const task_create_1 = require("../task/task-create");
 const task_finalize_1 = require("../task/task-finalize");
@@ -13,12 +12,17 @@ const task_finish_1 = require("../task/task-finish");
 const task_next_1 = require("../task/task-next");
 const task_upgrade_scaffold_1 = require("../task/task-upgrade-scaffold");
 const task_workbench_1 = require("../services/task-workbench");
+const timing_1 = require("../core/timing");
 const actor_1 = require("./actor");
 const args_1 = require("./args");
+const legacy_boundary_1 = require("./legacy-boundary");
 const task_json_1 = require("./task-json");
 function handleTaskCommand(input) {
+    const timer = (0, timing_1.startMonotonicTimer)();
     const sub = input.args[1];
     if (sub === 'create') {
+        if (blockLegacyMutation(input, 'task.create'))
+            return true;
         const title = extractTaskCreateTitle(input.args);
         if (!title)
             throw new Error('task create requires a title');
@@ -44,9 +48,9 @@ function handleTaskCommand(input) {
         return true;
     }
     if (sub === 'show') {
-        const id = input.args[2];
-        if (!id)
-            throw new Error('task show requires <task-id>');
+        const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
+        if (!id || id.startsWith('--'))
+            throw new Error('task show requires --task <task-id>');
         const report = (0, task_json_1.createTaskShowReport)(input.projectRoot, id);
         if (input.jsonOutput) {
             console.log(JSON.stringify(report, null, 2));
@@ -74,6 +78,8 @@ function handleTaskCommand(input) {
         return true;
     }
     if (sub === 'upgrade-scaffold') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.upgrade-scaffold'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task upgrade-scaffold requires --task <task-id>');
@@ -91,6 +97,8 @@ function handleTaskCommand(input) {
         return true;
     }
     if (sub === 'close') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.close'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task close requires --task <task-id>');
@@ -112,14 +120,56 @@ function handleTaskCommand(input) {
             process.exitCode = 6;
         return true;
     }
-    if (sub === 'status') {
+    if (sub === 'close-source') {
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
-            throw new Error('task status requires --task <task-id>');
-        const report = (0, task_workbench_1.createTaskWorkbenchReport)(input.projectRoot, id);
+            throw new Error('task close-source requires --task <task-id>');
+        const report = (0, task_close_1.createTaskCloseSourceReport)(input.projectRoot, id);
         if (input.jsonOutput) {
             console.log(JSON.stringify(report, null, 2));
         }
+        else {
+            console.log(`[HADARA] task close-source ${id}: ${report.ok ? 'ok' : 'issues'}`);
+            console.log(`sourceHash\t${report.sourceHash}`);
+            for (const unit of report.sourceUnits)
+                console.log(`${unit.closeSourceRole}\t${unit.kind}\t${unit.path}\t${unit.selector ?? ''}\t${unit.sha256}`);
+            for (const issue of report.issues)
+                console.log(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+        }
+        if (!report.ok)
+            process.exitCode = 6;
+        return true;
+    }
+    if (sub === 'status') {
+        const summaryJsonOutput = (0, args_1.getFlag)(input.args, '--summary-json');
+        const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
+        if (!id || id.startsWith('--')) {
+            const report = (0, task_workbench_1.createTaskStatusSelectionReport)(input.projectRoot);
+            attachCliDiagnostics(report, timer, 'task.status');
+            if (summaryJsonOutput) {
+                console.log(JSON.stringify(createTaskStatusSummaryReport(report), null, 2));
+            }
+            else if (input.jsonOutput) {
+                console.log(JSON.stringify(report, null, 2));
+            }
+            else {
+                console.log((0, task_workbench_1.formatTaskStatusSelectionReport)(report));
+            }
+            if (!report.ok)
+                process.exitCode = 6;
+            return true;
+        }
+        const detail = (0, args_1.getStringOption)(input.args, '--detail');
+        if (detail && detail !== 'fast' && detail !== 'full')
+            throw new Error('task status --detail must be fast or full');
+        const report = (0, task_workbench_1.createTaskWorkbenchReport)(input.projectRoot, id, new Date(), { detail: detail === 'full' ? 'full' : 'fast' });
+        attachCliDiagnostics(report, timer, 'task.status');
+        if (summaryJsonOutput) {
+            console.log(JSON.stringify(createTaskStatusSummaryReport(report), null, 2));
+        }
+        else if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
         else {
             console.log((0, task_workbench_1.formatTaskWorkbenchReport)(report));
         }
@@ -128,6 +178,8 @@ function handleTaskCommand(input) {
         return true;
     }
     if (sub === 'complete') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.complete'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task complete requires --task <task-id>');
@@ -143,14 +195,19 @@ function handleTaskCommand(input) {
         return true;
     }
     if (sub === 'finalize') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.finalize'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task finalize requires --task <task-id>');
+        const executeRequested = (0, args_1.getFlag)(input.args, '--execute');
         const report = (0, task_finalize_1.createTaskFinalizeReport)(input.projectRoot, id, {
-            executeRequested: (0, args_1.getFlag)(input.args, '--execute'),
+            executeRequested,
             planHash: (0, args_1.getStringOption)(input.args, '--plan-hash'),
-            actor: (0, actor_1.getActorContextOption)(input.args)
+            actor: (0, actor_1.getActorContextOption)(input.args),
+            onProgress: executeRequested ? createTaskFinalizeProgressWriter(id) : undefined
         });
+        attachCliDiagnostics(report, timer, 'task.finalize');
         if (input.jsonOutput) {
             console.log(JSON.stringify(report, null, 2));
         }
@@ -176,22 +233,9 @@ function handleTaskCommand(input) {
             process.exitCode = 6;
         return true;
     }
-    if (sub === 'close-repair-plan') {
-        const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
-        if (!id || id.startsWith('--'))
-            throw new Error('task close-repair-plan requires --task <task-id>');
-        const report = (0, task_close_repair_plan_1.createTaskCloseRepairPlanReport)(input.projectRoot, id, { actor: (0, actor_1.getActorContextOption)(input.args) });
-        if (input.jsonOutput) {
-            console.log(JSON.stringify(report, null, 2));
-        }
-        else {
-            console.log((0, task_close_repair_plan_1.formatTaskCloseRepairPlanReport)(report));
-        }
-        if (!report.ok)
-            process.exitCode = 6;
-        return true;
-    }
     if (sub === 'finish') {
+        if ((0, args_1.getFlag)(input.args, '--execute') && blockLegacyMutation(input, 'task.finish'))
+            return true;
         const id = (0, args_1.getStringOption)(input.args, '--task') ?? input.args[2];
         if (!id || id.startsWith('--'))
             throw new Error('task finish requires --task <task-id>');
@@ -245,6 +289,80 @@ function handleTaskCommand(input) {
     }
     return false;
 }
+function createTaskStatusSummaryReport(report) {
+    if (report.schemaVersion === 'hadara.task.status.v1') {
+        return {
+            schemaVersion: 'hadara.task.status.summary.v1',
+            command: 'task.status',
+            ok: report.ok,
+            mode: 'select-work',
+            phase: report.loop.phase,
+            recommendations: report.summary.recommendations,
+            ...(report.loop.primaryNextAction ? { primaryNextAction: report.loop.primaryNextAction } : {}),
+            ...(report.diagnostics ? { diagnostics: report.diagnostics } : {}),
+            issues: report.issues
+        };
+    }
+    return {
+        schemaVersion: 'hadara.task.status.summary.v1',
+        command: 'task.status',
+        ok: report.ok,
+        mode: 'selected-task',
+        taskId: report.taskId,
+        task: {
+            title: report.task.title,
+            capsule: report.task.capsule,
+            taskStatus: report.task.taskStatus,
+            taskBoardStatus: report.task.taskBoardStatus
+        },
+        phase: report.loop.phase,
+        readiness: {
+            status: report.state.readiness.status,
+            ready: report.state.ready,
+            closeProofValid: report.state.readiness.closeProofValid,
+            summary: report.state.readiness.summary
+        },
+        counts: {
+            blockers: report.summary.blockers,
+            warnings: report.summary.warnings,
+            evidenceRecords: report.summary.evidenceRecords,
+            validationChecks: report.sources.evidenceList.validationAttempts?.checks ?? 0,
+            unresolvedValidation: report.sources.evidenceList.validationAttempts?.unresolvedFailedOrBlocked ?? 0,
+            nextActions: report.summary.nextActions
+        },
+        ...(report.loop.primaryNextAction ? { primaryNextAction: report.loop.primaryNextAction } : {}),
+        ...(report.diagnostics ? { diagnostics: report.diagnostics } : {}),
+        issues: report.issues
+    };
+}
+function createTaskFinalizeProgressWriter(taskId) {
+    return (event) => {
+        const ok = event.ok === undefined ? '' : ` ok=${event.ok}`;
+        process.stderr.write(`[HADARA] task finalize ${taskId}: ${event.step} ${event.phase}${ok} - ${event.summary}\n`);
+    };
+}
+function attachCliDiagnostics(report, timer, commandPath) {
+    const durationMs = timer.elapsedMs();
+    const slowThresholdMs = 10000;
+    const slow = durationMs >= slowThresholdMs;
+    report.diagnostics = {
+        generatedBy: 'cli',
+        commandPath,
+        durationMs,
+        slowThresholdMs,
+        slow,
+        ...(slow ? { note: 'This command was slow enough to affect interactive agent UX; prefer narrower diagnostics or progress-aware follow-up work if this repeats.' } : {})
+    };
+    return report;
+}
+function blockLegacyMutation(input, command) {
+    const report = (0, legacy_boundary_1.createLegacyMutationBlockedReport)(input.projectRoot, command);
+    if (!report)
+        return false;
+    (0, legacy_boundary_1.printLegacyMutationBlockedReport)(report, input.jsonOutput);
+    process.exitCode = 6;
+    return true;
+}
 function extractTaskCreateTitle(args) {
     const explicitTitle = (0, args_1.getStringOption)(args, '--title');
     if (explicitTitle)

package/dist/cli/validation.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleValidationCommand = handleValidationCommand;
+const validation_run_1 = require("../services/validation-run");
+const args_1 = require("./args");
+const legacy_boundary_1 = require("./legacy-boundary");
+function handleValidationCommand(input) {
+    const sub = input.args[1];
+    if (sub !== 'run')
+        return false;
+    if (blockLegacyMutation(input, 'validation.run'))
+        return true;
+    const separator = input.args.indexOf('--');
+    const commandArgs = separator >= 0 ? input.args.slice(separator + 1) : [];
+    const optionArgs = separator >= 0 ? input.args.slice(0, separator) : input.args;
+    const taskId = (0, args_1.getRequiredStringOption)(optionArgs, '--task');
+    const check = (0, args_1.getRequiredStringOption)(optionArgs, '--check');
+    const report = (0, validation_run_1.createValidationRunReport)(input.projectRoot, {
+        taskId,
+        check,
+        argv: commandArgs,
+        tags: resolutionTagsFromArgs(optionArgs),
+        timeoutMs: (0, args_1.getIntegerOption)(optionArgs, '--timeout-ms', { min: 1, max: 3_600_000 }),
+        updateTask: (0, args_1.getFlag)(optionArgs, '--update-task')
+    });
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(`[HADARA] validation run ${taskId}: ${report.result}`);
+        console.log(`[HADARA] child command`);
+        console.log(`command=${report.argv.join(' ')}`);
+        console.log(`exitCode=${report.execution.exitCode ?? 'null'} signal=${report.execution.signal ?? 'null'} durationMs=${report.execution.durationMs}`);
+        console.log(`stdoutHash=${report.execution.stdoutHash}`);
+        console.log(`stderrHash=${report.execution.stderrHash}`);
+        console.log(`childOutput=not printed; stdout/stderr hashes are recorded in HADARA evidence`);
+        console.log(`[HADARA] evidence`);
+        if (report.evidence)
+            console.log(`id=${report.evidence.id}`);
+        console.log(`result=${report.result}`);
+        console.log(`taskValidationRow=${report.taskValidationRow.mode}${report.taskValidationRow.updated ? ' updated' : ' not-updated'}`);
+        console.log(`acceptanceRows=not-updated`);
+        for (const issue of report.issues)
+            console.log(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+        if (report.nextActions.length > 0)
+            console.log(`[HADARA] next actions`);
+        for (const action of report.nextActions)
+            console.log(`${action.id}=${action.command ?? action.message}`);
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}
+function blockLegacyMutation(input, command) {
+    const report = (0, legacy_boundary_1.createLegacyMutationBlockedReport)(input.projectRoot, command);
+    if (!report)
+        return false;
+    (0, legacy_boundary_1.printLegacyMutationBlockedReport)(report, input.jsonOutput);
+    process.exitCode = 6;
+    return true;
+}
+function resolutionTagsFromArgs(args) {
+    const tags = [];
+    for (const id of getRepeatedStringOptions(args, '--resolves'))
+        tags.push(`resolves:${id}`);
+    for (const id of getRepeatedStringOptions(args, '--supersedes'))
+        tags.push(`supersedes:${id}`);
+    return tags.length > 0 ? tags : undefined;
+}
+function getRepeatedStringOptions(args, option) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== option)
+            continue;
+        const value = args[index + 1];
+        if (!value || value.startsWith('--'))
+            throw new Error(`missing value for ${option}`);
+        values.push(value);
+    }
+    return values;
+}