hadara 0.1.0-rc.0

package/dist/cli/main.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const paths_1 = require("../core/paths");
+const doctor_1 = require("./doctor");
+const init_1 = require("./init");
+const harness_1 = require("./harness");
+const evidence_1 = require("./evidence");
+const policy_1 = require("./policy");
+const hermes_1 = require("./hermes");
+const handoff_1 = require("./handoff");
+const task_1 = require("./task");
+const mcp_1 = require("./mcp");
+const run_1 = require("./run");
+const run_state_1 = require("./run-state");
+const status_1 = require("./status");
+const dashboard_1 = require("./dashboard");
+const tools_1 = require("./tools");
+const debt_1 = require("./debt");
+const release_gate_1 = require("./release-gate");
+const release_artifact_1 = require("./release-artifact");
+const release_dry_run_1 = require("./release-dry-run");
+const release_publish_1 = require("./release-publish");
+const write_preflight_1 = require("./write-preflight");
+const tui_1 = require("./tui");
+const install_1 = require("./install");
+const smoke_1 = require("./smoke");
+const package_smoke_1 = require("./package-smoke");
+const args_1 = require("./args");
+const errors_1 = require("./errors");
+function printHelp() {
+    console.log(`HADARA bootstrap CLI
+
+Usage:
+  hadara init [--project <path>] [--profile minimal|full|hadara-protocol]
+  hadara doctor
+  hadara task create <title>
+  hadara task list
+  hadara task show <task-id>
+  hadara evidence collect --task <task-id> [--kind note|test-log|command-log|diff-summary|screenshot] [--path <path>] [--summary <text>] [--result passed|failed|blocked|unknown] [--private|--visibility public|private]
+  hadara evidence list --task <task-id> [--limit <n>] [--include-private] [--json]
+  hadara debt list [--json]
+  hadara debt show <id> [--json]
+  hadara tools list [--json]
+  hadara handoff update --task <task-id> [--summary <text>] [--next <text>]
+  hadara write preflight <command...> [--json]
+  hadara policy check-shell <command> [--mode readonly|assisted|trusted|auto|release]
+  hadara policy preflight-shell <command> [--mode readonly|assisted|trusted|auto|release] [--json]
+  hadara harness validate --task <task-id> [--level draft|done] [--json]
+  hadara harness replay <scenario.jsonl> [--json]
+  hadara hermes detect
+  hadara hermes export-context
+  hadara mcp serve [--enable-evidence-attach]
+  hadara status [--json]
+  hadara ops status [--json]
+  hadara run-state show [--json]
+  hadara run-state resume [--json]  # read-only guidance; does not resume a process
+  hadara install plan [--platform linux|windows|wsl|usb|posix] [--source <path>] [--source-kind tarball|directory|portable-bundle] [--target <path>] [--usb-root <path>] [--prefix <path>] [--launcher <path>] [--mode dry-run|execute] [--json]
+  hadara smoke run [--profile core|release-readiness] [--json]
+  hadara smoke clean-checkout --execute [--workspace <dir>] [--task <task-id>] [--timeout <seconds>] [--keep-temp] [--no-evidence|--attach-evidence] [--json]
+  hadara package smoke [--dry-run|--execute] [--from <tarball|dir>] [--workspace <dir>] [--task <task-id>] [--timeout <seconds>] [--keep-temp] [--no-evidence|--attach-evidence] [--private-logs] [--json]
+  hadara release dry-run [--json]
+  hadara release publish [--mode dry-run|execute] [--approval-actor <name>] [--approval-reason <text>] [--confirm publish-deploy] [--json]
+  hadara release artifact --execute [--output <dir>] [--task <task-id>] [--attach-evidence] [--timeout <seconds>] [--keep-temp] [--json]
+  hadara release gate [--mode advisory|strict] [--json]
+  hadara dashboard serve [--host <host>] [--port <port>]
+  hadara tui [--snapshot] [--compact] [--width <n>] [--height <n>] [--json]
+  hadara run scaffold --task <task-id> --command <command> [--stdout <text>] [--stderr <text>] [--exit-code <n>] [--json]
+  hadara run [request] --script <script.json> [--task <task-id>] [--fake-shell-fixtures <fixtures.json>] [--mode readonly|assisted|trusted|auto|release] [--max-steps <n>] [--json]
+
+Environment:
+  HADARA_HOME           Portable/USB root. Defaults to current working directory.
+  HADARA_PROJECT_ROOT   Project repo root. Defaults to current working directory.
+`);
+}
+async function main(args = process.argv.slice(2)) {
+    const command = args[0];
+    if (!command || command === '--help' || command === '-h') {
+        printHelp();
+        return;
+    }
+    const paths = (0, paths_1.resolveHadaraPaths)({ projectRoot: (0, args_1.getStringOption)(args, '--project') });
+    const jsonOutput = (0, args_1.getFlag)(args, '--json');
+    switch (command) {
+        case 'init': {
+            if ((0, init_1.handleInitCommand)({ args, projectRoot: paths.projectRoot }))
+                return;
+            break;
+        }
+        case 'doctor': {
+            if ((0, doctor_1.handleDoctorCommand)({ paths, jsonOutput }))
+                return;
+            break;
+        }
+        case 'task': {
+            if ((0, task_1.handleTaskCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'evidence': {
+            if ((0, evidence_1.handleEvidenceCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'tools': {
+            if ((0, tools_1.handleToolsCommand)({ args, jsonOutput }))
+                return;
+            break;
+        }
+        case 'debt': {
+            if ((0, debt_1.handleDebtCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'handoff': {
+            if ((0, handoff_1.handleHandoffCommand)({ args, projectRoot: paths.projectRoot }))
+                return;
+            break;
+        }
+        case 'write': {
+            if ((0, write_preflight_1.handleWriteCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'policy': {
+            if ((0, policy_1.handlePolicyCommand)({ args, jsonOutput }))
+                return;
+            break;
+        }
+        case 'hermes': {
+            if ((0, hermes_1.handleHermesCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'harness': {
+            if (await (0, harness_1.handleHarnessCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'mcp': {
+            if ((0, mcp_1.handleMcpCommand)({ args, projectRoot: paths.projectRoot }))
+                return;
+            break;
+        }
+        case 'status': {
+            if ((0, status_1.handleStatusCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'dashboard': {
+            if ((0, dashboard_1.handleDashboardCommand)({ args, projectRoot: paths.projectRoot }))
+                return;
+            break;
+        }
+        case 'tui': {
+            if ((0, tui_1.handleTuiCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'ops': {
+            if ((0, status_1.handleOpsCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'run': {
+            if (await (0, run_1.handleRunCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'run-state': {
+            if ((0, run_state_1.handleRunStateCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'release': {
+            if ((0, release_dry_run_1.handleReleaseDryRunCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            if ((0, release_publish_1.handleReleasePublishCommand)({ args, paths, jsonOutput }))
+                return;
+            if ((0, release_artifact_1.handleReleaseArtifactCommand)({ args, paths, jsonOutput }))
+                return;
+            if ((0, release_gate_1.handleReleaseGateCommand)({ args, projectRoot: paths.projectRoot, jsonOutput }))
+                return;
+            break;
+        }
+        case 'install': {
+            if ((0, install_1.handleInstallCommand)({ args, jsonOutput }))
+                return;
+            break;
+        }
+        case 'smoke': {
+            if ((0, smoke_1.handleSmokeCommand)({ args, paths, jsonOutput }))
+                return;
+            break;
+        }
+        case 'package': {
+            if ((0, package_smoke_1.handlePackageCommand)({ args, paths, jsonOutput }))
+                return;
+            break;
+        }
+    }
+    printHelp();
+    process.exitCode = 1;
+}
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    main(args).catch((error) => {
+        if (args.includes('--json')) {
+            console.log(JSON.stringify((0, errors_1.createCliErrorReport)(args, error), null, 2));
+            process.exitCode = (0, errors_1.cliErrorExitCode)(args, error);
+            return;
+        }
+        console.error(`[HADARA] ERROR: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = (0, errors_1.cliErrorExitCode)(args, error);
+    });
+}

package/dist/cli/mcp.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMcpCommand = handleMcpCommand;
+const server_1 = require("../mcp/server");
+const args_1 = require("./args");
+function handleMcpCommand(input) {
+    const sub = input.args[1];
+    if (sub !== 'serve')
+        return false;
+    (0, server_1.startMcpStdioServer)({
+        projectRoot: input.projectRoot,
+        enableEvidenceAttach: (0, args_1.getFlag)(input.args, '--enable-evidence-attach')
+    });
+    return true;
+}

package/dist/cli/package-smoke.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePackageCommand = handlePackageCommand;
+const package_smoke_1 = require("../services/package-smoke");
+const args_1 = require("./args");
+function handlePackageCommand(input) {
+    if (input.args[0] !== 'package' || input.args[1] !== 'smoke')
+        return false;
+    const options = {
+        paths: input.paths,
+        dryRun: !(0, args_1.getFlag)(input.args, '--execute'),
+        from: (0, args_1.getStringOption)(input.args, '--from'),
+        workspace: (0, args_1.getStringOption)(input.args, '--workspace'),
+        taskId: (0, args_1.getStringOption)(input.args, '--task'),
+        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'),
+        privateLogs: (0, args_1.getFlag)(input.args, '--private-logs'),
+        timeoutSeconds: (0, args_1.getIntegerOption)(input.args, '--timeout', { min: 1 })
+    };
+    const report = (0, args_1.getFlag)(input.args, '--execute') ? (0, package_smoke_1.createPackageSmokeLocalReport)(options) : (0, package_smoke_1.createPackageSmokeDryRunReport)(options);
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(`${report.ok ? 'passed' : 'failed'} | package smoke | ${report.mode}`);
+        for (const step of report.steps) {
+            console.log(`${step.status} | ${step.label} | ${step.summary}`);
+        }
+        for (const issue of report.issues) {
+            console.log(`${issue.severity} | ${issue.code} | ${issue.message}`);
+        }
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}

package/dist/cli/policy-json.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPolicyCheckReport = void 0;
+exports.extractPolicyCommandText = extractPolicyCommandText;
+var policy_service_1 = require("../services/policy-service");
+Object.defineProperty(exports, "createPolicyCheckReport", { enumerable: true, get: function () { return policy_service_1.createPolicyCheckReport; } });
+function extractPolicyCommandText(args, mode) {
+    const commandParts = [];
+    for (let index = 2; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === '--json')
+            continue;
+        if (value === '--mode') {
+            index += 1;
+            continue;
+        }
+        if (value === mode && args[index - 1] === '--mode')
+            continue;
+        commandParts.push(value);
+    }
+    return commandParts.join(' ').trim();
+}

package/dist/cli/policy.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePolicyCommand = handlePolicyCommand;
+const policy_1 = require("../policy/policy");
+const policy_service_1 = require("../services/policy-service");
+const args_1 = require("./args");
+const policy_json_1 = require("./policy-json");
+function handlePolicyCommand(input) {
+    const sub = input.args[1];
+    if (sub === 'check-shell') {
+        const mode = (0, policy_1.parsePermissionMode)((0, args_1.getStringOption)(input.args, '--mode', 'assisted') ?? 'assisted');
+        const commandText = (0, policy_json_1.extractPolicyCommandText)(input.args, mode);
+        if (!commandText)
+            throw new Error('policy check-shell requires <command>');
+        const report = (0, policy_json_1.createPolicyCheckReport)(commandText, mode);
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(JSON.stringify(report.decision, null, 2));
+        }
+        if (!report.ok)
+            process.exitCode = 2;
+        return true;
+    }
+    if (sub === 'preflight-shell') {
+        const mode = (0, policy_1.parsePermissionMode)((0, args_1.getStringOption)(input.args, '--mode', 'assisted') ?? 'assisted');
+        const commandText = (0, policy_json_1.extractPolicyCommandText)(input.args, mode);
+        if (!commandText)
+            throw new Error('policy preflight-shell requires <command>');
+        const report = (0, policy_service_1.createPolicyEvaluateReport)(commandText, mode);
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`[HADARA] Shell preflight: ${report.execution.status} (${report.decision.risk}) - ${report.decision.reason}`);
+        }
+        if (!report.ok)
+            process.exitCode = 2;
+        return true;
+    }
+    return false;
+}

package/dist/cli/release-artifact.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleReleaseArtifactCommand = handleReleaseArtifactCommand;
+const release_artifact_evidence_1 = require("../services/release-artifact-evidence");
+const release_artifact_1 = require("../services/release-artifact");
+const args_1 = require("./args");
+function handleReleaseArtifactCommand(input) {
+    if (input.args[0] !== 'release' || input.args[1] !== 'artifact')
+        return false;
+    const report = (0, release_artifact_1.createReleaseArtifactReport)({
+        paths: input.paths,
+        execute: (0, args_1.getFlag)(input.args, '--execute'),
+        output: (0, args_1.getStringOption)(input.args, '--output'),
+        keepTemp: (0, args_1.getFlag)(input.args, '--keep-temp'),
+        timeoutSeconds: (0, args_1.getIntegerOption)(input.args, '--timeout', { min: 1 })
+    });
+    const taskId = (0, args_1.getStringOption)(input.args, '--task');
+    const attachEvidence = (0, args_1.getFlag)(input.args, '--attach-evidence');
+    if (attachEvidence && !taskId) {
+        throw new Error('release artifact --attach-evidence requires --task <task-id>');
+    }
+    const attachment = attachEvidence && taskId
+        ? (0, release_artifact_evidence_1.attachReleaseArtifactEvidence)({
+            projectRoot: input.paths.projectRoot,
+            taskId,
+            summary: 'hadara release artifact --execute --attach-evidence --json generated tarball/checksum/manifest metadata, retained public report artifact, and emitted hadara.releaseArtifact.v1.',
+            report
+        })
+        : undefined;
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(attachment ? { ...report, attachedEvidence: attachment } : report, null, 2));
+    }
+    else {
+        console.log(`${report.ok ? 'passed' : 'failed'} | release artifact | ${report.output.retention}`);
+        if (attachment)
+            console.log(`evidence | ${attachment.evidence.taskId} | ${attachment.evidence.evidencePath ?? 'no-artifact'}`);
+        for (const artifact of report.artifacts) {
+            console.log(`${artifact.kind} | ${artifact.fileName} | ${artifact.hash ?? 'no-hash'}`);
+        }
+        for (const issue of report.issues) {
+            console.log(`${issue.severity} | ${issue.code} | ${issue.message}`);
+        }
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}

package/dist/cli/release-dry-run.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleReleaseDryRunCommand = handleReleaseDryRunCommand;
+const release_dry_run_1 = require("../services/release-dry-run");
+function handleReleaseDryRunCommand(input) {
+    if (input.args[0] !== 'release' || input.args[1] !== 'dry-run')
+        return false;
+    const report = (0, release_dry_run_1.createReleaseDryRunReport)(input.projectRoot);
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(`${report.ok ? 'passed' : 'failed'} | release dry-run | ${report.current.packageVersion}`);
+        for (const check of report.checks) {
+            console.log(`${check.status} | ${check.name} | ${check.summary}`);
+        }
+        for (const issue of report.issues) {
+            console.log(`${issue.severity} | ${issue.code} | ${issue.message}`);
+        }
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}

package/dist/cli/release-gate.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleReleaseGateCommand = handleReleaseGateCommand;
+const operational_debt_1 = require("../services/operational-debt");
+const args_1 = require("./args");
+function handleReleaseGateCommand(input) {
+    if (input.args[0] !== 'release' || input.args[1] !== 'gate')
+        return false;
+    const mode = parseReleaseGateMode(input.args);
+    const report = (0, operational_debt_1.createReleaseGateReport)(input.projectRoot, mode);
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        for (const check of report.checks) {
+            console.log(`${check.status} | ${check.name} | ${check.summary}`);
+        }
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}
+function parseReleaseGateMode(args) {
+    const value = (0, args_1.getStringOption)(args, '--mode', 'advisory');
+    if (value === 'advisory' || value === 'strict')
+        return value;
+    throw new Error(`unsupported release gate mode: ${value}`);
+}

package/dist/cli/release-publish.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleReleasePublishCommand = handleReleasePublishCommand;
+const release_publish_1 = require("../services/release-publish");
+const args_1 = require("./args");
+function handleReleasePublishCommand(input) {
+    if (input.args[0] !== 'release' || input.args[1] !== 'publish')
+        return false;
+    const mode = parseMode(input.args);
+    const report = (0, release_publish_1.createReleasePublishReport)({
+        projectRoot: input.paths.projectRoot,
+        auditDir: input.paths.auditDir,
+        mode,
+        approvalActor: (0, args_1.getStringOption)(input.args, '--approval-actor'),
+        approvalReason: (0, args_1.getStringOption)(input.args, '--approval-reason'),
+        confirm: (0, args_1.getStringOption)(input.args, '--confirm')
+    });
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(`${report.ok ? 'passed' : 'blocked'} | release publish | ${report.mode} | ${report.current.packageVersion}`);
+        for (const check of report.checks) {
+            console.log(`${check.status} | ${check.name} | ${check.summary}`);
+        }
+        for (const issue of report.issues) {
+            console.log(`${issue.severity} | ${issue.code} | ${issue.message}`);
+        }
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}
+function parseMode(args) {
+    if ((0, args_1.getFlag)(args, '--execute'))
+        return 'execute';
+    const mode = (0, args_1.getStringOption)(args, '--mode', 'dry-run');
+    if (mode === 'dry-run' || mode === 'execute')
+        return mode;
+    throw new Error(`unsupported release publish mode: ${mode}`);
+}

package/dist/cli/run-scaffold.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffoldRunScenario = scaffoldRunScenario;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const fs_1 = require("../core/fs");
+function scaffoldRunScenario(projectRoot, input) {
+    const scenarioDir = node_path_1.default.join(projectRoot, '.hadara', 'scenarios');
+    (0, fs_1.ensureDir)(scenarioDir);
+    const fileBase = `${safeScenarioPart(input.taskId)}-${safeScenarioPart(input.command)}`;
+    const scriptPath = node_path_1.default.join(scenarioDir, `${fileBase}.script.json`);
+    const fixturesPath = node_path_1.default.join(scenarioDir, `${fileBase}.fixtures.json`);
+    const matchText = `Run ${input.taskId} scaffolded command`;
+    const script = [
+        {
+            match: matchText,
+            response: JSON.stringify({ type: 'tool_request', tool: 'fake_shell', command: input.command }),
+            finishReason: 'tool_call'
+        },
+        {
+            match: input.stdout,
+            response: `Scaffolded fake-shell command completed: ${input.command}`
+        }
+    ];
+    const fixtures = {
+        [input.command]: {
+            exitCode: input.exitCode,
+            stdout: input.stdout,
+            stderr: input.stderr
+        }
+    };
+    const portableScriptPath = toPortablePath(node_path_1.default.relative(projectRoot, scriptPath));
+    const portableFixturesPath = toPortablePath(node_path_1.default.relative(projectRoot, fixturesPath));
+    if (node_fs_1.default.existsSync(scriptPath)) {
+        throw new Error(`scenario already exists: ${portableScriptPath}`);
+    }
+    if (node_fs_1.default.existsSync(fixturesPath)) {
+        throw new Error(`scenario already exists: ${portableFixturesPath}`);
+    }
+    if (!(0, fs_1.writeFileIfMissing)(scriptPath, `${JSON.stringify(script, null, 2)}\n`)) {
+        throw new Error(`scenario already exists: ${portableScriptPath}`);
+    }
+    if (!(0, fs_1.writeFileIfMissing)(fixturesPath, `${JSON.stringify(fixtures, null, 2)}\n`)) {
+        throw new Error(`scenario already exists: ${portableFixturesPath}`);
+    }
+    return {
+        schemaVersion: 'hadara.run.scaffold.v1',
+        command: 'run.scaffold',
+        ok: true,
+        taskId: input.taskId,
+        shellCommand: input.command,
+        scriptPath: portableScriptPath,
+        fixturesPath: portableFixturesPath
+    };
+}
+function safeScenarioPart(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80) || 'scenario';
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/cli/run-state.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRunStateCommand = handleRunStateCommand;
+const active_run_state_1 = require("../services/active-run-state");
+function handleRunStateCommand(input) {
+    if (input.args[0] !== 'run-state')
+        return false;
+    const sub = input.args[1];
+    if (sub !== 'show' && sub !== 'resume')
+        return false;
+    if (sub === 'resume') {
+        const report = (0, active_run_state_1.createActiveRunResumeReport)(input.projectRoot);
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+            return true;
+        }
+        console.log(formatResumeText(report));
+        return true;
+    }
+    const report = (0, active_run_state_1.safeCreateActiveRunProjection)(input.projectRoot);
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+        return true;
+    }
+    console.log(formatProjectionText(report));
+    return true;
+}
+function formatProjectionText(report) {
+    if (!report.activeRun)
+        return '[HADARA] Active run: none';
+    return [
+        '[HADARA] Active run',
+        `task: ${report.activeRun.taskId}`,
+        `status: ${report.activeRun.status}`,
+        `capsule: ${report.activeRun.capsule || report.path}`,
+        `next: ${report.resume?.nextAction ?? 'none'}`
+    ].join('\n');
+}
+function formatResumeText(report) {
+    return ['[HADARA] Active run resume', report.resumePrompt.summary, ...report.resumePrompt.nextActions.map((action) => `- ${action}`)].join('\n');
+}