hadara 0.1.0-rc.0

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

@@ -0,0 +1,393 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCleanCheckoutSmokeReport = createCleanCheckoutSmokeReport;
+const node_fs_1 = __importDefault(require("node:fs"));
+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 smoke_evidence_1 = require("./smoke-evidence");
+function createCleanCheckoutSmokeReport(options) {
+    const issues = [];
+    validateTimeout(options.timeoutSeconds, issues);
+    if (options.execute !== true) {
+        issues.push({
+            severity: 'error',
+            code: 'CLEAN_CHECKOUT_SMOKE_EXECUTION_REQUIRED',
+            message: 'Clean-checkout smoke requires explicit --execute because it runs npm commands in a disposable copy.'
+        });
+    }
+    const workspaceSetup = prepareWorkspace(options.paths.projectRoot, options.workspace, options.keepTemp === true, issues);
+    const execution = {
+        sourceCopied: false,
+        dependencyInstallExecuted: false,
+        buildExecuted: false,
+        checkExecuted: false,
+        builtCliSmokeExecuted: false,
+        packageInstallExecuted: false,
+        releaseMutationExecuted: false,
+        publishExecuted: false
+    };
+    const steps = [];
+    const runner = options.runner ?? runCommand;
+    const timeoutMs = (options.timeoutSeconds ?? 180) * 1000;
+    validateTaskId(options.taskId, issues);
+    try {
+        if (issues.some((issue) => issue.severity === 'error') || !workspaceSetup.ok) {
+            pushSkippedSteps(steps);
+        }
+        else {
+            try {
+                copySourceCheckout(options.paths.projectRoot, workspaceSetup.path);
+                execution.sourceCopied = true;
+                steps.push({
+                    id: 'copy-source',
+                    label: 'Copy source checkout',
+                    command: 'copy source checkout to <redacted-disposable-workspace>',
+                    status: 'passed',
+                    summary: 'Source checkout was copied into a disposable workspace without including dependency, build, local, or private store directories.'
+                });
+            }
+            catch {
+                issues.push({
+                    severity: 'error',
+                    code: 'CLEAN_CHECKOUT_SOURCE_COPY_FAILED',
+                    message: 'Source checkout could not be copied into the disposable workspace.',
+                    stepId: 'copy-source'
+                });
+                steps.push({
+                    id: 'copy-source',
+                    label: 'Copy source checkout',
+                    command: 'copy source checkout to <redacted-disposable-workspace>',
+                    status: 'failed',
+                    summary: 'Source checkout copy failed.'
+                });
+            }
+            if (execution.sourceCopied) {
+                const plannedSteps = [
+                    {
+                        id: 'npm-ci',
+                        label: 'Clean dependency install',
+                        command: 'npm ci',
+                        args: ['ci'],
+                        mark: () => {
+                            execution.dependencyInstallExecuted = true;
+                        }
+                    },
+                    {
+                        id: 'build',
+                        label: 'Build clean checkout',
+                        command: 'npm run build',
+                        args: ['run', 'build'],
+                        mark: () => {
+                            execution.buildExecuted = true;
+                        }
+                    },
+                    {
+                        id: 'check',
+                        label: 'Check clean checkout',
+                        command: 'npm run check',
+                        args: ['run', 'check'],
+                        mark: () => {
+                            execution.checkExecuted = true;
+                        }
+                    }
+                ];
+                for (const step of plannedSteps) {
+                    if (issues.some((issue) => issue.severity === 'error')) {
+                        steps.push(skippedStep(step.id, step.label, step.command, 'Skipped because a previous clean-checkout step failed.'));
+                        continue;
+                    }
+                    step.mark();
+                    const result = runner(npmCommand(), step.args, { cwd: workspaceSetup.path, timeoutMs });
+                    steps.push(commandStep(step.id, step.label, step.command, result, issues));
+                }
+                for (const step of builtCliSteps()) {
+                    if (issues.some((issue) => issue.severity === 'error')) {
+                        steps.push(skippedStep(step.id, step.label, step.command, 'Skipped because a previous clean-checkout step failed.'));
+                        continue;
+                    }
+                    execution.builtCliSmokeExecuted = true;
+                    const result = runner(nodeCommand(), step.args, { cwd: workspaceSetup.path, timeoutMs });
+                    const smokeStep = commandStep(step.id, step.label, step.command, result, issues);
+                    if (result.status === 0 && !isOkJsonReport(result.stdout)) {
+                        smokeStep.status = 'failed';
+                        smokeStep.summary = `${step.label} did not return an ok reduced JSON report.`;
+                        issues.push({
+                            severity: 'error',
+                            code: 'CLEAN_CHECKOUT_BUILT_CLI_JSON_NOT_OK',
+                            message: `${step.command} did not return an ok reduced JSON report.`,
+                            stepId: step.id
+                        });
+                    }
+                    steps.push(smokeStep);
+                }
+            }
+            else {
+                pushSkippedExecutionAfterCopy(steps);
+            }
+        }
+    }
+    finally {
+        const cleanup = cleanupWorkspace(workspaceSetup, options.keepTemp === true);
+        steps.push({
+            id: 'cleanup',
+            label: 'Cleanup disposable workspace',
+            command: 'remove <redacted-disposable-workspace>',
+            status: cleanup.ok ? 'passed' : 'failed',
+            summary: cleanup.summary
+        });
+        if (!cleanup.ok) {
+            issues.push({
+                severity: 'warning',
+                code: 'CLEAN_CHECKOUT_CLEANUP_FAILED',
+                message: 'Clean-checkout smoke cleanup could not remove the disposable workspace.',
+                stepId: 'cleanup'
+            });
+        }
+    }
+    const report = {
+        schemaVersion: 'hadara.cleanCheckoutSmoke.v1',
+        command: 'smoke.cleanCheckout',
+        ok: issues.every((issue) => issue.severity !== 'error') && steps.every((step) => step.status !== 'failed'),
+        mode: 'execute',
+        execution,
+        workspace: {
+            kind: 'disposable-clean-checkout',
+            displayPath: workspaceSetup.displayPath,
+            pathRedacted: true,
+            ...(workspaceSetup.relativePath ? { relativePath: workspaceSetup.relativePath } : {}),
+            retention: options.keepTemp === true ? 'kept-temporary' : 'deleted'
+        },
+        source: {
+            kind: 'source-checkout',
+            displayPath: '.',
+            pathRedacted: true,
+            relativePath: '.',
+            mutated: false
+        },
+        steps,
+        artifacts: [],
+        privacy: {
+            rawLogsIncluded: false,
+            privatePathsIncluded: false,
+            environmentSecretsIncluded: false,
+            privateStorePathsIncluded: false
+        },
+        issues
+    };
+    if (options.attachEvidence === true && options.taskId && options.noEvidence !== true) {
+        const evidence = (0, smoke_evidence_1.attachReducedSmokeEvidence)({
+            projectRoot: options.paths.projectRoot,
+            taskId: options.taskId,
+            category: 'clean-checkout-smoke',
+            kind: 'command-log',
+            summary: `Clean-checkout smoke ${report.ok ? 'passed' : 'failed'} with reduced public evidence.`,
+            result: report.ok ? 'passed' : 'failed',
+            report
+        });
+        report.artifacts.push(evidence.artifact);
+        report.steps.push({
+            id: 'evidence',
+            label: 'Attach reduced public evidence',
+            command: 'write reduced public smoke evidence summary',
+            status: 'passed',
+            summary: 'Reduced clean-checkout smoke summary was attached as public evidence after redaction checks.'
+        });
+    }
+    (0, schema_1.assertSchema)('hadara.cleanCheckoutSmoke.v1', report);
+    return report;
+}
+function builtCliSteps() {
+    return [
+        {
+            id: 'doctor',
+            label: 'Built CLI doctor',
+            command: 'node dist/cli/main.js doctor --json --project <redacted-clean-checkout>',
+            args: ['dist/cli/main.js', 'doctor', '--json', '--project', '.']
+        },
+        {
+            id: 'ops-status',
+            label: 'Built CLI operations status',
+            command: 'node dist/cli/main.js ops status --json --project <redacted-clean-checkout>',
+            args: ['dist/cli/main.js', 'ops', 'status', '--json', '--project', '.']
+        },
+        {
+            id: 'release-gate-strict',
+            label: 'Built CLI strict release gate',
+            command: 'node dist/cli/main.js release gate --mode strict --json --project <redacted-clean-checkout>',
+            args: ['dist/cli/main.js', 'release', 'gate', '--mode', 'strict', '--json', '--project', '.']
+        }
+    ];
+}
+function commandStep(id, label, command, result, issues) {
+    const status = result.status === 0 && !result.timedOut ? 'passed' : 'failed';
+    if (status === 'failed') {
+        issues.push({
+            severity: 'error',
+            code: result.timedOut ? 'CLEAN_CHECKOUT_STEP_TIMEOUT' : 'CLEAN_CHECKOUT_STEP_FAILED',
+            message: result.timedOut ? `${command} timed out during clean-checkout smoke.` : `${command} failed during clean-checkout smoke.`,
+            stepId: id
+        });
+    }
+    return {
+        id,
+        label,
+        command,
+        status,
+        exitCode: result.status,
+        elapsedMs: result.elapsedMs,
+        summary: status === 'passed' ? `${label} completed successfully.` : `${label} failed with a reduced exit summary.`
+    };
+}
+function skippedStep(id, label, command, summary) {
+    return { id, label, command, status: 'skipped', summary };
+}
+function pushSkippedSteps(steps) {
+    steps.push(skippedStep('copy-source', 'Copy source checkout', 'copy source checkout to <redacted-disposable-workspace>', 'Skipped because clean-checkout smoke setup failed.'));
+    pushSkippedExecutionAfterCopy(steps);
+}
+function pushSkippedExecutionAfterCopy(steps) {
+    steps.push(skippedStep('npm-ci', 'Clean dependency install', 'npm ci', 'Skipped because source copy failed.'), skippedStep('build', 'Build clean checkout', 'npm run build', 'Skipped because source copy failed.'), skippedStep('check', 'Check clean checkout', 'npm run check', 'Skipped because source copy failed.'), skippedStep('doctor', 'Built CLI doctor', 'node dist/cli/main.js doctor --json --project <redacted-clean-checkout>', 'Skipped because source copy failed.'), skippedStep('ops-status', 'Built CLI operations status', 'node dist/cli/main.js ops status --json --project <redacted-clean-checkout>', 'Skipped because source copy failed.'), skippedStep('release-gate-strict', 'Built CLI strict release gate', 'node dist/cli/main.js release gate --mode strict --json --project <redacted-clean-checkout>', 'Skipped because source copy failed.'));
+}
+function prepareWorkspace(projectRoot, workspace, keepTemp, issues) {
+    const resolved = workspace ? node_path_1.default.resolve(projectRoot, workspace) : node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'hadara-clean-checkout-'));
+    const relativePath = safeRelativePath(workspace);
+    if (isInsideProject(projectRoot, resolved)) {
+        issues.push({
+            severity: 'error',
+            code: 'CLEAN_CHECKOUT_WORKSPACE_INSIDE_PROJECT',
+            message: 'Clean-checkout smoke workspace must be outside the source workspace.'
+        });
+        return {
+            ok: false,
+            path: resolved,
+            displayPath: relativePath ? `./${relativePath}` : '<redacted-clean-checkout-workspace>',
+            ...(relativePath ? { relativePath } : {}),
+            cleanupAllowed: false
+        };
+    }
+    try {
+        node_fs_1.default.mkdirSync(resolved, { recursive: true });
+        return {
+            ok: true,
+            path: resolved,
+            displayPath: relativePath ? `./${relativePath}` : '<redacted-clean-checkout-workspace>',
+            ...(relativePath ? { relativePath } : {}),
+            cleanupAllowed: !keepTemp
+        };
+    }
+    catch {
+        issues.push({
+            severity: 'error',
+            code: 'CLEAN_CHECKOUT_WORKSPACE_CREATE_FAILED',
+            message: 'Clean-checkout smoke workspace could not be created.'
+        });
+        return {
+            ok: false,
+            path: resolved,
+            displayPath: relativePath ? `./${relativePath}` : '<redacted-clean-checkout-workspace>',
+            ...(relativePath ? { relativePath } : {}),
+            cleanupAllowed: false
+        };
+    }
+}
+function copySourceCheckout(sourceRoot, targetRoot) {
+    node_fs_1.default.cpSync(sourceRoot, targetRoot, {
+        recursive: true,
+        dereference: false,
+        filter: (source) => {
+            const relative = node_path_1.default.relative(sourceRoot, source).split(node_path_1.default.sep).join('/');
+            if (!relative)
+                return true;
+            return !(relative === 'node_modules' ||
+                relative.startsWith('node_modules/') ||
+                relative === 'dist' ||
+                relative.startsWith('dist/') ||
+                relative === '.hadara/local' ||
+                relative.startsWith('.hadara/local/') ||
+                relative === '.git' ||
+                relative.startsWith('.git/'));
+        }
+    });
+}
+function cleanupWorkspace(workspace, keepTemp) {
+    if (keepTemp)
+        return { ok: true, summary: 'Disposable clean checkout retained because --keep-temp was set; retained files are local/private only and should not be committed.' };
+    if (!workspace.cleanupAllowed)
+        return { ok: true, summary: 'No disposable workspace cleanup was required.' };
+    try {
+        node_fs_1.default.rmSync(workspace.path, { recursive: true, force: true });
+        return { ok: true, summary: 'Disposable clean checkout was removed.' };
+    }
+    catch {
+        return { ok: false, summary: 'Disposable clean checkout cleanup failed.' };
+    }
+}
+function runCommand(command, args, options) {
+    const started = Date.now();
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        cwd: options.cwd,
+        env: options.env ?? process.env,
+        encoding: 'utf8',
+        timeout: options.timeoutMs,
+        maxBuffer: 1024 * 1024 * 8
+    });
+    return {
+        status: typeof result.status === 'number' ? result.status : null,
+        signal: result.signal,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+        elapsedMs: Date.now() - started,
+        timedOut: result.error?.name === 'TimeoutError' || result.signal === 'SIGTERM'
+    };
+}
+function isOkJsonReport(stdout) {
+    try {
+        const parsed = JSON.parse(stdout);
+        return parsed.ok === true;
+    }
+    catch {
+        return false;
+    }
+}
+function validateTimeout(timeoutSeconds, issues) {
+    if (timeoutSeconds !== undefined && (!Number.isSafeInteger(timeoutSeconds) || timeoutSeconds < 1)) {
+        issues.push({
+            severity: 'error',
+            code: 'CLEAN_CHECKOUT_TIMEOUT_INVALID',
+            message: 'Clean-checkout smoke timeout must be a positive integer number of seconds.'
+        });
+    }
+}
+function validateTaskId(taskId, issues) {
+    if (taskId !== undefined && !/^T-[0-9]{4}$/.test(taskId)) {
+        issues.push({
+            severity: 'error',
+            code: 'CLEAN_CHECKOUT_TASK_ID_INVALID',
+            message: 'Clean-checkout smoke task id must look like T-0000.'
+        });
+    }
+}
+function npmCommand() {
+    return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+function nodeCommand() {
+    return process.execPath;
+}
+function safeRelativePath(value) {
+    if (!value || node_path_1.default.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith('~') || value.startsWith('<') || value.includes('%')) {
+        return undefined;
+    }
+    const normalized = value.split(/[\\/]+/).filter(Boolean).join('/');
+    if (!normalized || normalized === '.' || normalized.startsWith('..'))
+        return undefined;
+    return normalized;
+}
+function isInsideProject(projectRoot, child) {
+    const relative = node_path_1.default.relative(node_path_1.default.resolve(projectRoot), node_path_1.default.resolve(child));
+    return relative === '' || (!relative.startsWith('..') && !node_path_1.default.isAbsolute(relative));
+}

package/dist/services/evidence-list.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.createEvidenceListReport = createEvidenceListReport;
+exports.parseEvidenceIndexFile = parseEvidenceIndexFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const redaction_1 = require("../core/redaction");
+const task_capsule_1 = require("../task/task-capsule");
+const DEFAULT_LIMIT = 50;
+function createEvidenceListReport(projectRoot, input) {
+    const task = (0, task_capsule_1.listTaskCapsules)(projectRoot).find((item) => item.id === input.taskId);
+    if (!task) {
+        return {
+            schemaVersion: 'hadara.evidence.list.v1',
+            command: 'evidence.list',
+            ok: false,
+            taskId: input.taskId,
+            count: 0,
+            records: [],
+            issues: [
+                {
+                    severity: 'error',
+                    code: 'TASK_NOT_FOUND',
+                    message: `Task Capsule not found: ${input.taskId}`
+                }
+            ]
+        };
+    }
+    const parsed = parseEvidenceIndexFile(node_path_1.default.join(task.dir, 'evidence.jsonl'), input.taskId);
+    const limit = normalizeLimit(input.limit);
+    const includePrivate = input.includePrivate === true;
+    const records = parsed.records.filter((record) => includePrivate || record.visibility !== 'private').slice(0, limit);
+    return {
+        schemaVersion: 'hadara.evidence.list.v1',
+        command: 'evidence.list',
+        ok: !parsed.issues.some((issue) => issue.severity === 'error'),
+        taskId: input.taskId,
+        count: records.length,
+        records,
+        issues: parsed.issues
+    };
+}
+function parseEvidenceIndexFile(indexPath, taskId) {
+    if (!node_fs_1.default.existsSync(indexPath)) {
+        return {
+            records: [],
+            issues: [
+                {
+                    severity: 'warning',
+                    code: 'EVIDENCE_INDEX_MISSING',
+                    message: 'evidence.jsonl is missing.'
+                }
+            ]
+        };
+    }
+    const content = node_fs_1.default.readFileSync(indexPath, 'utf8').trim();
+    if (!content)
+        return { records: [], issues: [] };
+    const records = [];
+    const issues = [];
+    content.split(/\r?\n/).forEach((line, index) => {
+        try {
+            const record = JSON.parse(line);
+            if (isEvidenceIndexRecord(record)) {
+                if (record.taskId !== taskId) {
+                    issues.push({
+                        severity: 'warning',
+                        code: 'EVIDENCE_RECORD_TASK_MISMATCH',
+                        message: `evidence.jsonl line ${index + 1} has taskId ${record.taskId}, expected ${taskId}.`
+                    });
+                    return;
+                }
+                records.push(normalizeEvidenceIndexRecord(record));
+                return;
+            }
+            issues.push({
+                severity: 'warning',
+                code: 'EVIDENCE_RECORD_INVALID',
+                message: `evidence.jsonl line ${index + 1} is not a supported evidence record.`
+            });
+        }
+        catch {
+            issues.push({
+                severity: 'warning',
+                code: 'EVIDENCE_INDEX_JSON_INVALID',
+                message: `evidence.jsonl line ${index + 1} is not valid JSON.`
+            });
+        }
+    });
+    return { records, issues };
+}
+function isEvidenceIndexRecord(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const record = value;
+    return (record.schemaVersion === 'hadara.evidence.v1' &&
+        typeof record.time === 'string' &&
+        typeof record.taskId === 'string' &&
+        isEvidenceKind(record.kind) &&
+        typeof record.summary === 'string' &&
+        isEvidenceResult(record.result) &&
+        isEvidenceVisibility(record.visibility) &&
+        (record.evidencePath === undefined || typeof record.evidencePath === 'string'));
+}
+function normalizeEvidenceIndexRecord(record) {
+    const normalized = {
+        schemaVersion: 'hadara.evidence.v1',
+        time: record.time,
+        taskId: record.taskId,
+        kind: record.kind,
+        summary: (0, redaction_1.redactSecrets)(record.summary),
+        result: record.result,
+        visibility: record.visibility
+    };
+    if (record.visibility === 'public' && record.evidencePath) {
+        normalized.evidencePath = record.evidencePath;
+    }
+    return normalized;
+}
+function isEvidenceKind(value) {
+    return value === 'test-log' || value === 'command-log' || value === 'diff-summary' || value === 'screenshot' || value === 'note';
+}
+function isEvidenceResult(value) {
+    return value === 'passed' || value === 'failed' || value === 'blocked' || value === 'unknown';
+}
+function isEvidenceVisibility(value) {
+    return value === 'public' || value === 'private';
+}
+function normalizeLimit(value) {
+    if (value === undefined)
+        return DEFAULT_LIMIT;
+    return Math.max(0, Math.floor(value));
+}

package/dist/services/feature-smoke.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeatureSmokeReport = createFeatureSmokeReport;
+const schema_1 = require("../core/schema");
+const doctor_1 = require("../cli/doctor");
+const operational_debt_1 = require("./operational-debt");
+const operations_status_service_1 = require("./operations-status-service");
+const task_read_model_1 = require("./task-read-model");
+const tools_list_1 = require("./tools-list");
+const read_model_1 = require("../tui/read-model");
+const snapshot_1 = require("../tui/snapshot");
+function createFeatureSmokeReport(options) {
+    const issues = [];
+    const profile = parseProfile(options.profile, issues);
+    const steps = profile === 'core' && issues.length === 0 ? createCoreSteps(options.paths, issues) : [];
+    if (profile === 'release-readiness' && issues.length === 0) {
+        issues.push({
+            severity: 'error',
+            code: 'FEATURE_SMOKE_PROFILE_DEFERRED',
+            message: 'The release-readiness smoke profile is deferred until package, install matrix, and release artifact evidence exist.'
+        });
+    }
+    const report = {
+        schemaVersion: 'hadara.featureSmoke.v1',
+        command: 'feature-smoke.run',
+        ok: issues.every((issue) => issue.severity !== 'error') && steps.every((step) => step.status === 'passed'),
+        profile,
+        readOnly: true,
+        executionMode: 'service-read-model',
+        binaryExecuted: false,
+        launcherChecked: false,
+        packageInstallChecked: false,
+        steps,
+        issues
+    };
+    (0, schema_1.assertSchema)('hadara.featureSmoke.v1', report);
+    return report;
+}
+function parseProfile(value, issues) {
+    if (value === undefined || value === 'core')
+        return 'core';
+    if (value === 'release-readiness')
+        return 'release-readiness';
+    issues.push({
+        severity: 'error',
+        code: 'FEATURE_SMOKE_PROFILE_UNSUPPORTED',
+        message: `Unsupported feature smoke profile: ${value}`
+    });
+    return 'core';
+}
+function createCoreSteps(paths, issues) {
+    return [
+        runStep(issues, {
+            id: 'doctor',
+            command: 'hadara doctor --json',
+            schemaVersion: 'hadara.doctor.v1',
+            run: () => (0, doctor_1.createDoctorReport)(paths),
+            summarize: (report) => `Doctor completed with ${report.checks.length} path checks.`
+        }),
+        runStep(issues, {
+            id: 'status',
+            command: 'hadara status --json',
+            schemaVersion: 'hadara.ops.status.v1',
+            run: () => (0, operations_status_service_1.createOpsStatusReport)(paths.projectRoot),
+            summarize: (report) => `Operations status completed with health ${report.health}.`
+        }),
+        runStep(issues, {
+            id: 'task-list',
+            command: 'hadara task list --json',
+            schemaVersion: 'hadara.task.list.v1',
+            run: () => (0, task_read_model_1.createTaskListReport)(paths.projectRoot),
+            summarize: (report) => `Task list completed with ${report.count} tasks.`
+        }),
+        runStep(issues, {
+            id: 'tools-list',
+            command: 'hadara tools list --json',
+            schemaVersion: 'hadara.tools.list.v1',
+            run: () => (0, tools_list_1.createToolsListReport)(),
+            summarize: (report) => `Tools list completed with ${report.surfaces.cli.length} CLI surfaces.`
+        }),
+        runStep(issues, {
+            id: 'tui-snapshot',
+            command: 'hadara tui --snapshot --json',
+            schemaVersion: 'hadara.tui.snapshot.cli.v1',
+            run: () => {
+                (0, snapshot_1.renderTuiSnapshot)((0, read_model_1.createTuiReadModel)(paths.projectRoot), { width: 86, height: 24, widthPolicy: 'compact', theme: 'none' });
+                return { ok: true };
+            },
+            summarize: () => 'TUI snapshot completed as a reduced no-color render.'
+        }),
+        runStep(issues, {
+            id: 'release-gate-advisory',
+            command: 'hadara release gate --mode advisory --json',
+            schemaVersion: 'hadara.releaseGate.v1',
+            run: () => (0, operational_debt_1.createReleaseGateReport)(paths.projectRoot, 'advisory'),
+            summarize: (report) => `Advisory release gate completed with ${report.checks.length} checks.`
+        })
+    ];
+}
+function runStep(issues, step) {
+    try {
+        const result = step.run();
+        const schemaStatus = validateRegisteredStepSchema(step.schemaVersion, result);
+        if (schemaStatus === 'invalid') {
+            issues.push({
+                severity: 'error',
+                code: 'FEATURE_SMOKE_STEP_SCHEMA_INVALID',
+                message: `${step.command} produced a reduced report that failed its registered schema.`,
+                stepId: step.id
+            });
+        }
+        if (!result.ok) {
+            issues.push({
+                severity: 'error',
+                code: 'FEATURE_SMOKE_STEP_FAILED',
+                message: `${step.command} returned a non-ok reduced report.`,
+                stepId: step.id
+            });
+        }
+        return {
+            id: step.id,
+            command: step.command,
+            executionMode: 'service-read-model',
+            status: result.ok && schemaStatus !== 'invalid' ? 'passed' : 'failed',
+            schemaVersion: step.schemaVersion,
+            schemaStatus,
+            summary: step.summarize(result)
+        };
+    }
+    catch {
+        issues.push({
+            severity: 'error',
+            code: 'FEATURE_SMOKE_STEP_THREW',
+            message: `${step.command} failed before producing a reduced report.`,
+            stepId: step.id
+        });
+        return {
+            id: step.id,
+            command: step.command,
+            executionMode: 'service-read-model',
+            status: 'failed',
+            schemaVersion: step.schemaVersion,
+            summary: 'Step failed before producing a reduced report.'
+        };
+    }
+}
+function validateRegisteredStepSchema(schemaVersion, value) {
+    try {
+        const result = (0, schema_1.validateSchema)(schemaVersion, value);
+        return result.ok ? 'validated' : 'invalid';
+    }
+    catch {
+        return 'not-registered';
+    }
+}