agentic-workflow-manager 8.3.0 → 8.5.0

package/dist/src/commands/doctor.js

@@ -15,6 +15,10 @@ const paths_1 = require("../core/paths");
 // read-only y el segundo auto-vivifica el archivo. Ver la nota en config.ts.
 const config_1 = require("../utils/config");
 const agent_targets_1 = require("../core/agent-targets");
+const collect_1 = require("../core/dashboard/collect");
+const render_html_1 = require("../core/dashboard/render-html");
+const render_terminal_1 = require("../core/dashboard/render-terminal");
+const write_html_1 = require("../core/dashboard/write-html");
 function glyph(status) {
     if (status === 'ok')
         return picocolors_1.default.green('✔');
@@ -123,6 +127,38 @@ function renderProviderReport(report) {
 }
 function runDoctor(opts = {}) {
     const resolveTargets = opts.resolveTargets ?? agent_targets_1.resolveAgentTargets;
+    const invalid = (message) => { process.stderr.write(`awm doctor: ${message}\n`); return 2; };
+    const htmlRequested = opts.html !== undefined;
+    if (opts.json && opts.full)
+        return invalid('--json cannot be combined with --full');
+    if (opts.json && htmlRequested)
+        return invalid('--json cannot be combined with --html');
+    if (opts.full && htmlRequested)
+        return invalid('--full cannot be combined with --html');
+    if (opts.force && !htmlRequested)
+        return invalid('--force requires --html');
+    if (opts.full || htmlRequested) {
+        try {
+            const cwd = opts.cwd ?? process.cwd();
+            const target = htmlRequested ? (0, write_html_1.resolveHtmlTarget)({ cwd, target: opts.html, force: opts.force }) : undefined;
+            const targets = resolveTargets({ prefs: (0, config_1.readPreferences)(), explicit: opts.agent });
+            const collectSnapshot = opts.collectSnapshot ?? collect_1.collectDashboardSnapshot;
+            const context = (0, context_1.gatherContext)({ cwd, agents: targets });
+            const snapshot = collectSnapshot({ cwd, now: new Date().toISOString(), adapters: {
+                    ...(0, collect_1.productionDashboardAdapters)(context),
+                } });
+            if (opts.full)
+                process.stdout.write((0, render_terminal_1.renderFullTerminal)(snapshot) + '\n');
+            if (htmlRequested) {
+                (0, write_html_1.writeHtmlAtomically)({ cwd, target: target, html: (0, render_html_1.renderDashboardHtml)(snapshot), force: opts.force });
+                process.stdout.write(`${target}\n`);
+            }
+            return snapshot.overall === 'healthy' ? 0 : 1;
+        }
+        catch (error) {
+            return invalid(error.message);
+        }
+    }
     // Validates --agent separately from the general diagnostic gathering below:
     // an unknown or disabled agent is a normal input-validation failure (the
     // user typo'd or forgot `awm init --agent <x>`), not an "internal error" —
@@ -159,8 +195,11 @@ function registerDoctorCommand(program) {
     program.command('doctor')
         .description('Read-only dashboard of the AWM harness state, per provider')
         .option('--json', 'Emit the diagnostic report as JSON')
+        .option('--full', 'Emit the full dashboard snapshot')
+        .option('--html [file]', 'Write the dashboard snapshot as HTML')
+        .option('--force', 'Allow replacing an existing HTML file')
         .option('-a, --agent <agent>', 'Target agent subset (comma-separated); defaults to every enabled agent')
         .action((options) => {
-        process.exitCode = runDoctor({ json: options.json, agent: options.agent });
+        process.exitCode = runDoctor({ json: options.json, full: options.full, html: typeof options.html === 'string' ? options.html : options.html === true ? '' : undefined, force: options.force, agent: options.agent });
     });
 }

package/dist/src/commands/evidence/index.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEvidenceCommand = registerEvidenceCommand;
+exports.runEvidenceCapture = runEvidenceCapture;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const capture_1 = require("../../core/evidence/capture");
+const store_1 = require("../../core/evidence/store");
+const store_2 = require("../../core/journal/store");
+const store_3 = require("../../core/ledger/store");
+function assertRepoRelativePlan(value) {
+    if (typeof value !== 'string' || !value || value.startsWith('--') || path_1.default.isAbsolute(value)
+        || value.includes('\\') || value.split('/').some((part) => part === '' || part === '.' || part === '..')) {
+        throw new Error('--plan requires a repo-relative path');
+    }
+    return value;
+}
+function registerEvidenceCommand(program) {
+    const evidence = program.command('evidence').description('durable privacy-preserving cycle observations');
+    evidence.command('capture')
+        .description('capture one local cycle observation')
+        .option('--plan <path>', 'repo-relative plan path')
+        .option('--pr-provider <provider>', 'github | gitlab | other')
+        .option('--pr-number <number>', 'pull request number')
+        .action((opts) => {
+        const result = runEvidenceCapture(process.cwd(), opts.plan, { prProvider: opts.prProvider, prNumber: opts.prNumber });
+        if (result.code === 0)
+            process.stdout.write(result.stdout);
+        else {
+            process.stderr.write(`awm evidence capture: ${result.error}\n`);
+            process.exitCode = 2;
+        }
+    });
+}
+function firstEvaluationGates(state) {
+    return state.cycleVerificationPlan.map((gate) => {
+        if (gate.kind === 'review') {
+            const verdict = state.verdicts.filter((candidate) => candidate.obligationId === gate.id)
+                .sort((left, right) => left.receivedAt.localeCompare(right.receivedAt) || left.id.localeCompare(right.id))[0];
+            return { required: true, passed: verdict?.result === 'pass' };
+        }
+        const evaluated = Object.values(state.jobs).filter((job) => job.satisfies?.includes(gate.id));
+        const first = evaluated.filter((job) => job.attemptOf === undefined || !evaluated.some((candidate) => candidate.id === job.attemptOf))
+            .sort((left, right) => jobTimestamp(left).localeCompare(jobTimestamp(right)) || left.id.localeCompare(right.id))[0];
+        return { required: true, passed: first?.verdict === 'pass' };
+    });
+}
+function jobTimestamp(job) {
+    const timestamp = job.result?.endedAt ?? job.phaseTimestamps.received ?? job.phaseTimestamps.exited;
+    if (typeof timestamp !== 'string' || Number.isNaN(Date.parse(timestamp)))
+        throw new Error(`gate job ${job.id} lacks a durable evaluation timestamp`);
+    return timestamp;
+}
+function repositoryIdentity(root, supplied) {
+    if (supplied !== undefined) {
+        if (typeof supplied !== 'string' || !supplied || supplied.length > 4096 || /[\r\n]/.test(supplied))
+            throw new Error('repository identity is invalid');
+        return supplied;
+    }
+    try {
+        const remote = (0, child_process_1.execFileSync)('git', ['config', '--get', 'remote.origin.url'], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 }).trim();
+        if (!remote || remote.length > 4096 || /[\r\n]/.test(remote))
+            throw new Error('invalid');
+        return remote;
+    }
+    catch {
+        throw new Error('repository identity unavailable: configure remote.origin.url');
+    }
+}
+function runEvidenceCapture(root, plan, overrides) {
+    try {
+        const planPath = assertRepoRelativePlan(plan);
+        if (!fs_1.default.existsSync(path_1.default.join(root, planPath)))
+            throw new Error('--plan must reference an existing file');
+        const branch = (0, store_3.detectBranch)(root);
+        const read = overrides?.journal === undefined ? (0, store_2.readJournal)(root, branch) : { corrupt: false, state: overrides.journal };
+        if (read.corrupt || !read.state)
+            throw new Error('current journal is unavailable or corrupt');
+        let pr;
+        if (overrides?.prProvider !== undefined || overrides?.prNumber !== undefined) {
+            if (overrides.prProvider === undefined || overrides.prNumber === undefined || typeof overrides.prNumber !== 'string' || !/^\d+$/.test(overrides.prNumber))
+                throw new Error('--pr-provider and --pr-number must be supplied together');
+            pr = { provider: overrides.prProvider, number: Number(overrides.prNumber) };
+        }
+        const saved = (0, store_1.writeCycleEvidence)(root, (0, capture_1.captureCycleEvidence)({ root, repositoryIdentity: repositoryIdentity(root, overrides?.repositoryIdentity), planPath, journal: read.state, gates: firstEvaluationGates(read.state), ledger: overrides?.ledger ?? (0, store_3.listEntries)(root, branch), pr }));
+        return { code: 0, stdout: `${saved.cycleId}\n` };
+    }
+    catch (error) {
+        return { code: 2, stdout: '', error: error.message };
+    }
+}

package/dist/src/core/dashboard/collect.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMEDIATION_BY_FINDING_ID = void 0;
+exports.productionDashboardAdapters = productionDashboardAdapters;
+exports.collectDashboardSnapshot = collectDashboardSnapshot;
+const profile_1 = require("../profile");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const history_1 = require("../evidence/history");
+const types_1 = require("../evidence/types");
+const sanitize_1 = require("./sanitize");
+const validate_1 = require("./validate");
+const plan_state_1 = require("./plan-state");
+exports.REMEDIATION_BY_FINDING_ID = {
+    'machine.preferences.missing': 'awm init',
+    'machine.registries.stale': 'awm update',
+    'project.profile.missing': 'awm init',
+    'project.sensors.unavailable': 'awm sensors status',
+    'project.preflight.degraded': 'awm preflight',
+    'planning.source.unavailable': 'awm preflight',
+    'execution.source.unavailable': 'awm sensors status',
+};
+const EMPTY_ADAPTERS = {
+    machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined,
+};
+const SAFE_REMEDIATIONS = new Set(['awm init', 'awm update', 'awm sync', 'awm sensors status', 'awm preflight']);
+const HEALTHY_PROVIDER_STATES = new Set(['supported', 'healthy', 'shared', 'delivered']);
+const INAPPLICABLE_PROVIDER_STATES = new Set(['unsupported']);
+function providerState(state) {
+    if (HEALTHY_PROVIDER_STATES.has(state))
+        return 'ok';
+    if (INAPPLICABLE_PROVIDER_STATES.has(state))
+        return 'not_applicable';
+    return 'attention';
+}
+/**
+ * Maps the already-gathered diagnostics matrix into the snapshot's read-only
+ * source seam. It deliberately does not re-read providers, execute sensors, or
+ * relay provider detail/remediation prose: those values can contain local paths,
+ * command output, or credentials. The fixed IDs are derived solely from the
+ * provider/check enums and therefore remain stable across runs.
+ */
+function productionDashboardAdapters(context) {
+    if (!context || typeof context !== 'object' || !Array.isArray(context.providers))
+        throw new Error('productionDashboardAdapters requires gathered provider diagnostics');
+    const machineFindings = context.providers.flatMap((provider) => provider.checks.flatMap((check) => {
+        const finding = {
+            id: `machine.provider.${provider.id}.${check.id}`,
+            // Provider labels are configuration prose. The provider id and check id
+            // are enum-controlled and sufficient for a stable public observation.
+            label: `Provider ${provider.id}: ${check.id}`,
+            state: providerState(check.state),
+            // Provider remediation is intentionally not forwarded. It is free-form
+            // diagnostics text, not a dashboard-approved canonical command.
+            remediationVerified: false,
+        };
+        // These two legacy diagnosis states are the only provider observations
+        // with a pre-existing, exact dashboard command mapping.
+        if (check.id === 'skills.global' && check.state === 'absent') {
+            return [finding, { id: 'machine.preferences.missing', label: 'Preferences', state: 'missing', remediationVerified: true }];
+        }
+        if (check.id === 'skills.global' && check.state === 'stale') {
+            return [finding, { id: 'machine.registries.stale', label: 'Registries', state: 'attention', remediationVerified: true }];
+        }
+        return [finding];
+    }));
+    const project = context.project;
+    const projectFindings = !project ? [] : [
+        { id: project.profile.present ? 'project.profile.present' : 'project.profile.missing', label: 'Profile', state: project.profile.present ? 'ok' : 'missing', remediation: 'awm init', remediationVerified: true },
+        { id: 'project.extensions.configured', label: 'Extensions', state: project.profile.extensions.length > 0 ? 'ok' : 'not_applicable' },
+        { id: 'project.registry-pins.present', label: 'Registry pins', state: project.profile.registries && Object.keys(project.profile.registries).length > 0 ? 'ok' : 'not_applicable' },
+        { id: 'project.bundles.coherent', label: 'Active bundles', state: project.activeBundles.broken.length === 0 ? 'ok' : 'attention', remediation: 'awm sync', remediationVerified: true },
+        { id: 'project.context.present', label: 'Project context', state: project.context.present ? 'ok' : 'missing', remediation: 'awm init', remediationVerified: true },
+        { id: 'project.constitution.present', label: 'Constitution', state: project.constitution.present ? 'ok' : 'missing' },
+        { id: project.sensors.present ? 'project.sensors.present' : 'project.sensors.unavailable', label: 'Sensors', state: project.sensors.present ? 'ok' : 'unavailable', remediation: 'awm sensors status', remediationVerified: true },
+        // `preflight()` is async because static tool inspection is async. Doctor's
+        // synchronous legacy API must not dispatch it here; make the absence of that
+        // observation explicit rather than inventing a readiness verdict.
+        { id: 'project.preflight.not_collected', label: 'Static preflight', state: 'not_applicable' },
+    ];
+    return {
+        machine: () => ({ findings: machineFindings }),
+        project: () => ({ label: 'Project detected', findings: projectFindings }),
+        plans: () => [],
+        execution: () => undefined,
+    };
+}
+function findings(items, optional = false) {
+    if (optional && items === undefined)
+        return [];
+    if (!Array.isArray(items))
+        throw new Error('Dashboard findings must be an array');
+    return items.flatMap((item) => {
+        if (!item || typeof item !== 'object' || typeof item.id !== 'string' || item.id.trim() === '' || typeof item.label !== 'string' || item.label.trim() === '')
+            throw new Error('Dashboard finding is invalid');
+        if (!['ok', 'attention', 'missing', 'unavailable', 'not_applicable'].includes(item.state))
+            throw new Error('Dashboard finding state is invalid');
+        const remediation = exports.REMEDIATION_BY_FINDING_ID[item.id]
+            ?? (item.remediationVerified === true && typeof item.remediation === 'string' && SAFE_REMEDIATIONS.has(item.remediation) ? item.remediation : undefined);
+        if (item.state !== 'ok' && item.state !== 'not_applicable' && !remediation)
+            return [];
+        return [{ id: item.id, label: item.label, state: item.state, ...(item.detail ? { detail: item.detail } : {}), ...(remediation ? { remediation } : {}) }];
+    }).sort((left, right) => left.id.localeCompare(right.id));
+}
+function section(id, availability, items = []) {
+    return { id, availability, items };
+}
+function optional(source) {
+    try {
+        return { value: source(), failed: false, failure: {} };
+    }
+    catch (error) {
+        const findingId = error && typeof error === 'object' && typeof error.findingId === 'string'
+            ? error.findingId : undefined;
+        const remediationVerified = error !== null && typeof error === 'object'
+            ? error.remediationVerified === true : false;
+        return { failed: true, failure: { findingId, remediationVerified } };
+    }
+}
+function canonicalOptionalFailure(failure) {
+    if (!failure.remediationVerified || !failure.findingId || !Object.hasOwn(exports.REMEDIATION_BY_FINDING_ID, failure.findingId))
+        return [];
+    return [{ id: failure.findingId, label: 'Optional source unavailable', state: 'unavailable', remediation: exports.REMEDIATION_BY_FINDING_ID[failure.findingId] }];
+}
+function evidenceHistoryItems(root) {
+    const awmDirectory = path_1.default.join(root, '.awm');
+    const evidenceDirectory = path_1.default.join(awmDirectory, 'evidence');
+    const directory = path_1.default.join(evidenceDirectory, 'cycles');
+    for (const ancestor of [awmDirectory, evidenceDirectory, directory]) {
+        let stat;
+        try {
+            stat = fs_1.default.lstatSync(ancestor);
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && error.code === 'ENOENT')
+                return { confidence: 'none', items: [] };
+            throw error;
+        }
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            throw new Error('evidence history directory is unsafe');
+    }
+    const seenCycleIds = new Set();
+    const records = fs_1.default.readdirSync(directory, { withFileTypes: true })
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .map((entry) => {
+        if (!entry.isFile() || !entry.name.endsWith('.json'))
+            throw new Error('evidence history contains an unsupported entry');
+        const file = path_1.default.join(directory, entry.name);
+        if (fs_1.default.lstatSync(file).isSymbolicLink())
+            throw new Error('evidence history file is unsafe');
+        const evidence = (0, types_1.validateCycleEvidence)(JSON.parse(fs_1.default.readFileSync(file, 'utf8')));
+        if (entry.name !== `${evidence.cycleId}.json` || seenCycleIds.has(evidence.cycleId))
+            throw new Error('evidence history filename is invalid');
+        seenCycleIds.add(evidence.cycleId);
+        return evidence;
+    });
+    const history = (0, history_1.buildEvidenceHistory)(records);
+    return {
+        confidence: history.confidence,
+        items: history.cycles.map((cycle) => {
+            const cures = cycle.cureEfficacy.length === 0 ? 'none' : cycle.cureEfficacy.map((cure) => cure.efficacy).join(', ');
+            return {
+                id: `history.cycle.${cycle.cycleId}`,
+                label: `Cycle ${cycle.cycleId.slice(0, 12)}`,
+                state: cycle.cycleState === 'blocked' ? 'attention' : 'ok',
+                detail: `plan ${cycle.plan.state}; tasks ${cycle.tasks.length}; retries ${cycle.retries}; QA ${cycle.qa.findings}/${cycle.qa.fixes}; first-pass ${cycle.gates.firstPass ? 'yes' : 'no'}; cures ${cures}`,
+            };
+        }),
+    };
+}
+function isolatedFindings(items) {
+    return optional(() => findings(items, true));
+}
+/** Pure read-only aggregation over injected source adapters. */
+function collectDashboardSnapshot(options) {
+    if (!options || typeof options.cwd !== 'string' || options.cwd.length === 0 || typeof options.now !== 'string' || Number.isNaN(Date.parse(options.now)))
+        throw new Error('collectDashboardSnapshot requires cwd and valid now');
+    const adapters = { ...EMPTY_ADAPTERS, ...(options.adapters ?? {}) };
+    const machine = adapters.machine({ cwd: options.cwd });
+    if (!Array.isArray(machine?.findings))
+        throw new Error('Dashboard findings must be an array');
+    const root = (0, profile_1.findProjectRoot)(options.cwd);
+    const machineItems = findings((0, sanitize_1.sanitizeDashboardSource)(machine).findings);
+    const machineSection = section('machine', 'available', machineItems);
+    if (!root) {
+        const degraded = machineSection.items.some((item) => item.state !== 'ok' && item.state !== 'not_applicable');
+        return (0, validate_1.validateDashboardSnapshotV1)({ schema: 1, generatedAt: options.now, overall: degraded ? 'degraded' : 'healthy', project: { detected: false, label: 'No project detected' }, confidence: 'none', sections: [machineSection] });
+    }
+    const projectResult = optional(() => (0, sanitize_1.sanitizeDashboardSource)(adapters.project({ root })));
+    const plansResult = optional(() => (0, sanitize_1.sanitizeDashboardSource)(adapters.plans({ root })));
+    const executionResult = optional(() => {
+        const source = adapters.execution({ root });
+        return source === undefined ? undefined : (0, sanitize_1.sanitizeDashboardSource)(source);
+    });
+    const projectSource = projectResult.value;
+    const execution = executionResult.value;
+    const projectItemsResult = projectSource ? isolatedFindings(projectSource.findings) : { value: [], failed: false, failure: {} };
+    const planItemsResult = plansResult.value ? optional(() => findings(plansResult.value.map((plan) => plan.lifecycle
+        ? { ...plan, detail: (0, plan_state_1.classifyPlanState)(plan.lifecycle) } : plan))) : { value: [], failed: false, failure: {} };
+    const executionItems = isolatedFindings(execution?.execution);
+    const qaItems = isolatedFindings(execution?.qa);
+    const retroItems = isolatedFindings(execution?.retro);
+    const evidenceResult = optional(() => evidenceHistoryItems(root));
+    const executionUnavailable = !executionResult.failed && execution === undefined;
+    const sections = [
+        machineSection,
+        section('project', projectResult.failed || projectItemsResult.failed ? 'unavailable' : 'available', projectResult.failed
+            ? canonicalOptionalFailure(projectResult.failure) : projectItemsResult.failed ? [] : projectItemsResult.value),
+        section('planning', plansResult.failed || planItemsResult.failed ? 'unavailable' : 'available', plansResult.failed
+            ? canonicalOptionalFailure(plansResult.failure) : planItemsResult.failed ? [] : planItemsResult.value),
+        section('execution', executionResult.failed || executionUnavailable || executionItems.failed ? 'unavailable' : 'available', executionResult.failed ? canonicalOptionalFailure(executionResult.failure) : executionUnavailable ? canonicalOptionalFailure({ findingId: 'execution.source.unavailable', remediationVerified: true }) : executionItems.value),
+        // There is no read-only QA, retro, or history adapter in Release A. An
+        // absent execution source is not evidence of a successful empty cycle.
+        section('qa', executionResult.failed || executionUnavailable || qaItems.failed ? 'unavailable' : 'available', qaItems.value),
+        section('retro', executionResult.failed || executionUnavailable || retroItems.failed ? 'unavailable' : 'available', retroItems.value),
+        section('history', evidenceResult.failed ? 'unavailable' : 'available', evidenceResult.failed ? [] : evidenceResult.value.items),
+    ];
+    const degraded = sections.some((entry) => entry.availability === 'unavailable' || entry.items.some((item) => item.state !== 'ok' && item.state !== 'not_applicable'));
+    return (0, validate_1.validateDashboardSnapshotV1)({ schema: 1, generatedAt: options.now, overall: degraded ? 'degraded' : 'healthy', project: { detected: true, label: projectSource?.label || 'Project detected' }, confidence: evidenceResult.failed ? 'none' : evidenceResult.value.confidence, sections });
+}

package/dist/src/core/dashboard/plan-state.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyPlanState = classifyPlanState;
+function assertRecord(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`Plan ${label} must be an object`);
+}
+function assertKeys(value, label, keys) {
+    if (Object.keys(value).some((key) => !keys.includes(key)))
+        throw new Error(`Plan ${label} has unsupported fields`);
+}
+function classifyPlanState(input) {
+    assertRecord(input, 'state input');
+    assertKeys(input, 'state input', ['journal', 'markers', 'tasks']);
+    assertRecord(input.markers, 'markers');
+    assertKeys(input.markers, 'markers', ['qaComplete', 'retroComplete']);
+    assertRecord(input.tasks, 'tasks');
+    assertKeys(input.tasks, 'tasks', ['total', 'completed']);
+    const markers = input.markers;
+    const tasks = input.tasks;
+    if (typeof markers.qaComplete !== 'boolean' || typeof markers.retroComplete !== 'boolean')
+        throw new Error('Plan markers must be boolean');
+    if (typeof tasks.total !== 'number' || typeof tasks.completed !== 'number' || !Number.isInteger(tasks.total) || !Number.isInteger(tasks.completed) || tasks.total < 0 || tasks.completed < 0 || tasks.completed > tasks.total)
+        throw new Error('Plan task counts are invalid');
+    let journalState;
+    if (input.journal !== undefined) {
+        assertRecord(input.journal, 'journal');
+        assertKeys(input.journal, 'journal', ['state']);
+        if (input.journal.state !== 'active' && input.journal.state !== 'blocked')
+            throw new Error('Plan journal state is invalid');
+        journalState = input.journal.state;
+    }
+    if (journalState === 'blocked')
+        return 'blocked';
+    if (journalState === 'active')
+        return 'active';
+    if (markers.retroComplete)
+        return 'executed';
+    if (markers.qaComplete)
+        return 'retro_pending';
+    if (tasks.total > 0 && tasks.completed === tasks.total)
+        return 'qa_pending';
+    return 'legacy_unverifiable';
+}

package/dist/src/core/dashboard/render-html.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDashboardHtml = renderDashboardHtml;
+const styles_1 = require("./styles");
+const validate_1 = require("./validate");
+const CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src data:; script-src 'none'; connect-src 'none'; frame-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'";
+const SECTION_TITLES = { machine: 'Machine / install', project: 'Project readiness', planning: 'Design / planning', execution: 'Execution', qa: 'QA', retro: 'Retro', history: 'Final / history' };
+const STATE_TEXT = { ok: 'OK', attention: 'Attention', missing: 'Missing', unavailable: 'Unavailable', not_applicable: 'Not applicable' };
+const STATE_GLYPH = { ok: '●', attention: '▲', missing: '×', unavailable: '⊘', not_applicable: '—' };
+function escapeHtml(value) { return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;'); }
+function sectionHtml(section, supplement = '') {
+    const title = SECTION_TITLES[section.id];
+    const availability = section.availability === 'available' ? '' : `<p class="availability ${section.availability}">⊘ Source ${escapeHtml(section.availability.replace('_', ' '))}</p>`;
+    const rows = section.items.length === 0 ? '<p class="empty">No observations reported.</p>' : `<table><thead><tr><th scope="col">Observation</th><th scope="col">State</th><th scope="col">Detail</th><th scope="col">Remediation</th></tr></thead><tbody>${section.items.map((item) => `<tr><td data-label="Observation">${escapeHtml(item.label)}</td><td data-label="State"><span class="state ${item.state}">${STATE_GLYPH[item.state]} ${STATE_TEXT[item.state]}</span></td><td data-label="Detail">${item.detail ? escapeHtml(item.detail) : '—'}</td><td data-label="Remediation">${item.remediation ? `<code>${escapeHtml(item.remediation)}</code>` : '—'}</td></tr>`).join('')}</tbody></table>`;
+    return `<section id="${section.id}" aria-label="${title}"><header><h2>${title}</h2><span class="eyebrow">${escapeHtml(section.availability.replace('_', ' '))}</span></header><div class="section-body">${availability}${supplement}${rows}</div></section>`;
+}
+function diagnosticCards(items, attribute) {
+    const labels = ['installation', 'sensors', 'permissions'];
+    const cards = items.slice(0, 3).map((item, index) => `<li data-diagnostic-card="${labels[index] ?? 'diagnostic'}"><span class="state ${item.state}">${STATE_GLYPH[item.state]} ${STATE_TEXT[item.state]}</span><strong>${escapeHtml(item.label)}</strong><span>${item.detail ? escapeHtml(item.detail) : 'No additional detail'}</span></li>`).join('') || '<li><span class="state not_applicable">— Not applicable</span><strong>No machine observations</strong><span>Machine diagnostics are not available.</span></li>';
+    if (attribute === 'data-machine-diagnostics')
+        return `<section data-machine-diagnostics aria-labelledby="machine-diagnostics-heading"><header><h2 id="machine-diagnostics-heading">Machine diagnostics</h2></header><div class="section-body"><ul class="diagnostic-grid">${cards}</ul></div></section>`;
+    return `<div class="machine-preparation-strip" data-machine-preparation role="group" aria-labelledby="machine-preparation-heading"><h3 id="machine-preparation-heading">Preparación de máquina</h3><ul class="diagnostic-grid">${cards}</ul></div>`;
+}
+function machineBento(items) {
+    const names = ['Instalación', 'Sensores globales', 'Persistencia'];
+    return `<div class="machine-bento" data-machine-bento>${names.map((name, index) => {
+        const item = items[index];
+        return `<article class="bento-card"><h2>${name}</h2>${item ? `<span class="state ${item.state}">${STATE_GLYPH[item.state]} ${STATE_TEXT[item.state]}</span><strong>${escapeHtml(item.label)}</strong><span>${item.detail ? escapeHtml(item.detail) : 'Sin detalle adicional'}</span>` : '<span class="state unavailable">⊘ Unavailable</span><span>Sin observación disponible</span>'}</article>`;
+    }).join('')}</div>`;
+}
+function nextActions(snapshot) {
+    const actionable = snapshot.sections.flatMap((section) => section.items.filter((item) => item.remediation)).slice(0, 2);
+    const rows = [...actionable, { id: 'setup.initialize', label: 'Inicializar proyecto', state: 'attention', remediation: 'awm init' }];
+    return `<div data-next-actions role="group" aria-labelledby="next-actions-heading"><h2 id="next-actions-heading">Siguiente acción requerida</h2><ol class="action-list">${rows.map((item) => `<li data-next-action="${escapeHtml(item.id)}"><span class="state ${item.state}">${STATE_GLYPH[item.state]} ${STATE_TEXT[item.state]}</span><span>${escapeHtml(item.label)}</span><code>${item.remediation}</code><button type="button" disabled aria-describedby="static-controls-note">Copy command (static)</button></li>`).join('')}</ol></div>`;
+}
+function privacyAndActions(snapshot) {
+    return `<section data-privacy-security aria-label="Privacy and security"><header><h2>Privacy &amp; security</h2></header><div class="section-body privacy-body"><div><p class="lede">This portable view contains sanitized states and exact operator remedies only. It excludes paths, identities, environment values, secret-like values, raw command output, ledger prose, and error stacks.</p><p id="privacy-toggle-note" class="static-note">Static export: this checked setting documents the enforced share-safe boundary and cannot be changed in this file.</p></div><label class="static-toggle" data-static-privacy-toggle><span>Share-safe sanitization</span><input type="checkbox" checked disabled aria-describedby="privacy-toggle-note"><span aria-hidden="true">Enabled</span></label></div></section>${nextActions(snapshot)}`;
+}
+function dashboardToolbar() {
+    return `<header class="dashboard-toolbar" data-dashboard-toolbar><p class="toolbar-brand">AWM <span>Doctor dashboard</span></p><form role="search" aria-label="Search dashboard"><label class="sr-only" for="dashboard-search">Search resources</label><input id="dashboard-search" type="search" placeholder="Search resources" disabled aria-describedby="static-controls-note"></form><div class="toolbar-actions"><button type="button" disabled aria-describedby="static-controls-note">Notifications (static)</button><button type="button" disabled aria-describedby="static-controls-note">Help (static)</button><button type="button" disabled aria-describedby="static-controls-note">Export dashboard (static)</button><button type="button" disabled aria-describedby="static-controls-note">New deployment (static)</button></div><p id="static-controls-note" class="sr-only">Controls are shown for reference only; this exported dashboard does not run scripts.</p></header>`;
+}
+function projectHeaderActions() {
+    return `<div class="project-header-actions" data-project-header-actions role="group" aria-label="Project actions"><button type="button" disabled aria-describedby="static-controls-note">Export evidence (static)</button><button type="button" disabled aria-describedby="static-controls-note">Attach evidence (static)</button></div>`;
+}
+function projectChrome(project) {
+    return `<div class="project-chrome"><p class="eyebrow" data-project-breadcrumb>AWM / Proyecto / ${project}</p><nav data-project-nav aria-label="Project navigation"><span aria-current="page">Proyecto</span><span>Ejecución</span><span>Configuración</span></nav></div>`;
+}
+function projectEvidenceComposition(snapshot) {
+    const planning = snapshot.sections.find((section) => section.id === 'planning')?.items ?? [];
+    const history = snapshot.sections.find((section) => section.id === 'history')?.items ?? [];
+    const planCards = planning.length === 0
+        ? `<div class="plan-card active" data-plan-card="active"><div><strong>Plan activo</strong><span class="state attention">Sin observación</span></div><p>Progreso: sin observación</p><button type="button" disabled aria-describedby="static-controls-note">Ver plan (estático)</button></div><div class="plan-card blocked" data-plan-card="blocked"><div><strong>Plan bloqueado</strong><span class="state unavailable">Sin observación</span></div><p>Progreso: sin observación</p><button type="button" disabled aria-describedby="static-controls-note">Ver plan (estático)</button></div>`
+        : planning.map((plan) => `<div class="plan-card ${plan.detail === 'blocked' ? 'blocked' : 'active'}" data-plan-card="${plan.detail === 'blocked' ? 'blocked' : 'active'}"><div><strong>${escapeHtml(plan.label)}</strong><span class="state ${plan.state}">${STATE_GLYPH[plan.state]} ${STATE_TEXT[plan.state]}</span></div><p>Estado: ${escapeHtml(plan.detail ?? 'sin observación')}</p><button type="button" disabled aria-describedby="static-controls-note">Ver plan (estático)</button></div>`).join('');
+    const evidenceRows = history.length === 0 ? '<tr><td colspan="4" class="empty">No hay evidencia de impacto disponible en este snapshot.</td></tr>' : history.map((item) => `<tr><td>ciclo</td><td>${escapeHtml(item.label)}</td><td><span class="state ${item.state}">${STATE_GLYPH[item.state]} ${STATE_TEXT[item.state]}</span><br>${escapeHtml(item.detail ?? '—')}</td><td>—</td></tr>`).join('');
+    return `<div data-project-evidence role="group" aria-labelledby="project-evidence-heading"><h3 id="project-evidence-heading" class="sr-only">Project evidence</h3><div class="evidence-grid compact-composition"><div><h3>Planes de trabajo</h3>${planCards}</div><div><h3>Impacto y trazabilidad</h3><table class="evidence-table"><thead><tr><th scope="col">Tipo</th><th scope="col">Fuente</th><th scope="col">Estado</th><th scope="col">Fecha</th></tr></thead><tbody>${evidenceRows}</tbody></table></div></div><div class="closure-actions" data-closure-actions role="group" aria-labelledby="closure-actions-heading"><div><h3 id="closure-actions-heading">Qué falta para cerrar el ciclo</h3><p class="empty">La ausencia de marcador no equivale a cero hallazgos.</p></div><div><button type="button" disabled aria-describedby="static-controls-note">Completar QA (estático)</button><button type="button" disabled aria-describedby="static-controls-note">Registrar retro (estático)</button><button type="button" disabled aria-describedby="static-controls-note">Adjuntar evidencia (estático)</button></div></div></div>`;
+}
+function projectComposition(snapshot) {
+    const stageSections = ['planning', 'execution', 'qa', 'retro', 'history'];
+    const byId = new Map(snapshot.sections.map((section) => [section.id, section]));
+    const stages = stageSections.map((id) => {
+        const section = byId.get(id);
+        const stage = id === 'history' ? 'evidence' : id;
+        const available = section?.availability === 'available';
+        return `<li data-stage="${stage}"><span aria-hidden="true" class="timeline-marker"></span><strong>${stage === 'evidence' ? 'Evidence' : SECTION_TITLES[id]}</strong><span class="state ${available ? 'ok' : 'unavailable'}">${available ? '● Available' : '⊘ Unavailable'}</span></li>`;
+    }).join('');
+    const provisional = snapshot.confidence === 'provisional' ? '<aside data-provisional-evidence aria-label="Provisional evidence"><strong>Provisional evidence</strong><span>Current observations are still being verified by downstream QA and evidence capture.</span></aside>' : '';
+    const prepItems = byId.get('machine')?.items ?? [];
+    const prepNames = ['installation', 'sensors', 'persistence'];
+    const preparation = `<div class="machine-preparation-strip" data-machine-preparation role="group" aria-labelledby="machine-preparation-heading"><h3 id="machine-preparation-heading">Preparación de máquina</h3><ul class="diagnostic-grid">${prepNames.map((name, index) => { const item = prepItems[index]; return `<li data-machine-preparation-card="${name}">${item ? `<span class="state ${item.state}">${STATE_GLYPH[item.state]} ${STATE_TEXT[item.state]}</span><strong>${escapeHtml(item.label)}</strong><span>${item.detail ? escapeHtml(item.detail) : 'Sin detalle adicional'}</span>` : '<span class="state unavailable">⊘ Unavailable</span><strong>Sin observación</strong><span>Fuente no disponible</span>'}</li>`; }).join('')}</ul></div>`;
+    const machineSupplement = `${preparation}<nav class="lifecycle-timeline" data-lifecycle-timeline aria-labelledby="lifecycle-timeline-heading"><h3 id="lifecycle-timeline-heading">Línea de ciclo</h3><ol class="timeline connected-timeline">${stages}</ol></nav>${provisional}`;
+    const historySupplement = projectEvidenceComposition(snapshot);
+    return snapshot.sections.map((section) => sectionHtml(section, section.id === 'machine' ? machineSupplement : section.id === 'history' ? historySupplement : '')).join('');
+}
+/** Renders a portable, static, share-safe dashboard document. */
+function renderDashboardHtml(input) {
+    const snapshot = (0, validate_1.validateDashboardSnapshotV1)(input);
+    const overall = escapeHtml(snapshot.overall);
+    const project = escapeHtml(snapshot.project.label);
+    const machineItems = snapshot.sections.find((section) => section.id === 'machine')?.items ?? [];
+    const sections = snapshot.project.detected ? projectComposition(snapshot) : `${machineBento(machineItems)}${privacyAndActions(snapshot)}${snapshot.sections.map((section) => sectionHtml(section)).join('')}`;
+    const links = '<li>Inicio</li><li>Estado</li><li class="active">Configuración</li><li>Terminal</li>';
+    const projectDetected = snapshot.project.detected;
+    const heading = projectDetected ? 'Project lifecycle' : 'Machine configuration';
+    const intro = projectDetected ? 'Readiness, lifecycle state, and eligible observations presented directly for operator review.' : 'Machine readiness and safe configuration state outside a project.';
+    const navLabel = projectDetected ? 'Dashboard sections' : 'Machine configuration sections';
+    const context = projectDetected ? `Project: ${project}` : 'No project detected';
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta http-equiv="Content-Security-Policy" content="${CSP}"><title>AWM Doctor dashboard</title><style>${styles_1.DASHBOARD_STYLES}</style></head><body><div class="shell"><nav data-operational-sidebar aria-label="${navLabel}"><p class="brand">AWM<small>Doctor dashboard</small></p><ul>${links}</ul><button data-sidebar-diagnose type="button" disabled aria-describedby="static-controls-note">Ejecutar diagnóstico</button><div data-sidebar-operator-controls><span>Operaciones</span><button type="button" disabled aria-describedby="static-controls-note">Soporte</button><button type="button" disabled aria-describedby="static-controls-note">Cerrar sesión</button></div></nav><main>${dashboardToolbar()}<div class="dashboard-content"><header class="page-header">${projectDetected ? projectChrome(project) : ''}<p class="eyebrow">Read-only diagnostic evidence</p><h1>${heading}</h1><p class="lede">${intro}</p><p><span class="status ${overall}">● ${overall}</span> <span class="status">Confidence: ${escapeHtml(snapshot.confidence)}</span></p><p class="eyebrow">${context}</p>${projectDetected ? projectHeaderActions() : ''}</header>${sections}<footer>Generated ${escapeHtml(snapshot.generatedAt)} · Static share-safe dashboard</footer></div></main></div></body></html>\n`;
+}

package/dist/src/core/dashboard/render-terminal.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFullTerminal = renderFullTerminal;
+const validate_1 = require("./validate");
+const SECTION_TITLES = {
+    machine: 'Machine / install',
+    project: 'Project readiness',
+    planning: 'Design / planning',
+    execution: 'Execution',
+    qa: 'QA',
+    retro: 'Retro',
+    history: 'Final / history',
+};
+const STATE_PRESENTATION = {
+    ok: { glyph: '✔', text: 'ok' },
+    attention: { glyph: '⚠', text: 'attention' },
+    missing: { glyph: '✖', text: 'missing' },
+    unavailable: { glyph: '⊘', text: 'unavailable' },
+    not_applicable: { glyph: '—', text: 'not applicable' },
+};
+/** Renders a complete, color-free dashboard suitable for terminals and logs. */
+function renderFullTerminal(input) {
+    const snapshot = (0, validate_1.validateDashboardSnapshotV1)(input);
+    const lines = [
+        `AWM dashboard · ${snapshot.overall}`,
+        `Project: ${snapshot.project.label}`,
+        `Confidence: ${snapshot.confidence}`,
+    ];
+    for (const section of snapshot.sections) {
+        lines.push('', SECTION_TITLES[section.id]);
+        if (section.id === 'history')
+            lines.push(`  Eligible evidence rows: ${section.items.length}`);
+        if (section.availability !== 'available')
+            lines.push(`  ⊘ source ${section.availability.replace('_', ' ')}`);
+        if (section.items.length === 0)
+            lines.push('  No observations reported.');
+        for (const item of section.items) {
+            const presentation = STATE_PRESENTATION[item.state];
+            lines.push(`  ${presentation.glyph} ${item.label} [${item.id}]${item.detail ? ` — ${item.detail}` : ` — ${presentation.text}`}`);
+            if (item.remediation)
+                lines.push(`    → ${item.remediation}`);
+        }
+    }
+    return lines.join('\n');
+}