agentic-workflow-manager 8.2.1 → 8.4.0

package/dist/tests/core/dashboard/contracts.test.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validate_1 = require("../../../src/core/dashboard/validate");
+const types_1 = require("../../../src/core/dashboard/types");
+function snapshot() {
+    return {
+        schema: 1,
+        generatedAt: '2026-08-22T00:00:00.000Z',
+        overall: 'healthy',
+        project: { detected: true, label: 'Demo project' },
+        confidence: 'none',
+        sections: [
+            { id: 'machine', availability: 'available', items: [{ id: 'cli', label: 'CLI', state: 'ok' }] },
+            { id: 'project', availability: 'not_applicable', items: [] },
+            { id: 'planning', availability: 'not_applicable', items: [] },
+            { id: 'execution', availability: 'not_applicable', items: [] },
+            { id: 'qa', availability: 'not_applicable', items: [] },
+            { id: 'retro', availability: 'not_applicable', items: [] },
+            { id: 'history', availability: 'not_applicable', items: [] },
+        ],
+    };
+}
+describe('validateDashboardSnapshotV1', () => {
+    it('creates the safe deterministic dashboard snapshot default', () => {
+        expect((0, types_1.dashboardSnapshot)()).toEqual({
+            schema: 1,
+            generatedAt: '2026-08-22T00:00:00.000Z',
+            overall: 'healthy',
+            project: { detected: false, label: 'No project detected' },
+            confidence: 'none',
+            sections: [{ id: 'machine', availability: 'available', items: [] }],
+        });
+    });
+    it('allows callers to override snapshot defaults', () => {
+        expect((0, types_1.dashboardSnapshot)({ overall: 'degraded' }).overall).toBe('degraded');
+    });
+    it('builds a complete canonical section set when callers select a project', () => {
+        const value = (0, types_1.dashboardSnapshot)({ project: { detected: true, label: 'Demo project' }, confidence: 'provisional' });
+        expect((0, validate_1.validateDashboardSnapshotV1)(value).sections.map((section) => section.id)).toEqual(['machine', 'project', 'planning', 'execution', 'qa', 'retro', 'history']);
+    });
+    it('returns a valid V1 snapshot', () => {
+        expect((0, validate_1.validateDashboardSnapshotV1)(snapshot())).toEqual(snapshot());
+    });
+    it.each(['attention', 'missing', 'unavailable'])('rejects actionable %s without remediation', (state) => {
+        const value = snapshot();
+        value.sections[0].items[0].state = state;
+        expect(() => (0, validate_1.validateDashboardSnapshotV1)(value)).toThrow(validate_1.DashboardValidationError);
+    });
+    it('rejects project before machine', () => {
+        const value = snapshot();
+        value.sections.reverse();
+        expect(() => (0, validate_1.validateDashboardSnapshotV1)(value)).toThrow(/section order/i);
+    });
+    it('rejects an invalid schema version', () => {
+        const value = snapshot();
+        value.schema = 2;
+        expect(() => (0, validate_1.validateDashboardSnapshotV1)(value)).toThrow(validate_1.DashboardValidationError);
+    });
+    it('rejects invalid public enums', () => {
+        const value = snapshot();
+        value.overall = 'unknown';
+        expect(() => (0, validate_1.validateDashboardSnapshotV1)(value)).toThrow(validate_1.DashboardValidationError);
+    });
+    it('rejects duplicate item ids', () => {
+        const value = snapshot();
+        value.sections[0].items.push({ id: 'cli', label: 'Duplicate', state: 'not_applicable' });
+        expect(() => (0, validate_1.validateDashboardSnapshotV1)(value)).toThrow(validate_1.DashboardValidationError);
+    });
+    it('rejects remediation on not applicable items', () => {
+        const value = snapshot();
+        value.sections[0].items[0] = { id: 'cli', label: 'CLI', state: 'not_applicable', remediation: 'remove' };
+        expect(() => (0, validate_1.validateDashboardSnapshotV1)(value)).toThrow(validate_1.DashboardValidationError);
+    });
+    it('rejects lifecycle sections when no project is detected', () => {
+        const value = (0, types_1.dashboardSnapshot)({
+            project: { detected: false, label: 'No project detected' },
+            sections: [
+                { id: 'machine', availability: 'available', items: [] },
+                { id: 'planning', availability: 'not_applicable', items: [] },
+            ],
+        });
+        expect(() => (0, validate_1.validateDashboardSnapshotV1)(value)).toThrow(/no project.*machine/i);
+    });
+    it('rejects a detected project without the complete canonical lifecycle sections', () => {
+        const value = (0, types_1.dashboardSnapshot)({
+            project: { detected: true, label: 'Demo project' },
+            confidence: 'provisional',
+            sections: [{ id: 'machine', availability: 'available', items: [] }],
+        });
+        expect(() => (0, validate_1.validateDashboardSnapshotV1)(value)).toThrow(/detected project.*canonical lifecycle/i);
+    });
+});

package/dist/tests/core/dashboard/plan-state.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plan_state_1 = require("../../../src/core/dashboard/plan-state");
+const base = { journal: undefined, markers: { qaComplete: false, retroComplete: false }, tasks: { total: 2, completed: 0 } };
+describe('classifyPlanState', () => {
+    it('gives blocked journal state highest precedence', () => {
+        expect((0, plan_state_1.classifyPlanState)({ ...base, journal: { state: 'blocked' }, markers: { qaComplete: true, retroComplete: true }, tasks: { total: 2, completed: 2 } })).toBe('blocked');
+    });
+    it('gives active journal state precedence over completed markers', () => {
+        expect((0, plan_state_1.classifyPlanState)({ ...base, journal: { state: 'active' }, markers: { qaComplete: true, retroComplete: true }, tasks: { total: 2, completed: 2 } })).toBe('active');
+    });
+    it.each([
+        [{ ...base, markers: { qaComplete: true, retroComplete: true } }, 'executed'],
+        [{ ...base, markers: { qaComplete: true, retroComplete: false } }, 'retro_pending'],
+        [{ ...base, tasks: { total: 2, completed: 2 } }, 'qa_pending'],
+        [base, 'legacy_unverifiable'],
+    ])('classifies lifecycle state %s', (input, expected) => {
+        expect((0, plan_state_1.classifyPlanState)(input)).toBe(expected);
+    });
+    it.each([
+        [null, /input/i],
+        [{ markers: null, tasks: base.tasks }, /markers/i],
+        [{ markers: base.markers, tasks: null }, /task/i],
+        [{ ...base, journal: null }, /journal/i],
+        [{ ...base, journal: { state: 'invented' } }, /journal/i],
+        [{ ...base, markers: { qaComplete: 'yes', retroComplete: false } }, /markers/i],
+        [{ ...base, tasks: { total: 1, completed: 2 } }, /counts/i],
+        [{ ...base, tasks: { total: Number.NaN, completed: 0 } }, /counts/i],
+    ])('rejects invalid public input %p', (input, error) => {
+        expect(() => (0, plan_state_1.classifyPlanState)(input)).toThrow(error);
+    });
+});

package/dist/tests/core/dashboard/production-adapters.test.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const collect_1 = require("../../../src/core/dashboard/collect");
+function context() {
+    return {
+        machine: {},
+        project: {
+            root: '/private/project',
+            profile: { present: true, extensions: ['delivery'], registries: { base: '1.2.3' } },
+            activeBundles: { expected: ['delivery'], linked: ['delivery'], broken: [] },
+            orphanLinks: { repairable: [], dead: [], usurped: [] },
+            sensors: { present: true }, constitution: { present: true }, context: { present: true, file: 'AGENTS.md' },
+        },
+        providers: [{
+                id: 'codex', label: 'Codex', tier: 'hooks-native', checks: [
+                    { id: 'binary.version', state: 'supported', target: '0.145.0' },
+                    { id: 'hook.trust', state: 'pending-trust', remediationCode: 'awm hooks trust --agent codex' },
+                ],
+            }],
+    };
+}
+describe('productionDashboardAdapters', () => {
+    it('maps existing diagnostics into canonical, share-safe machine and project facts', () => {
+        const adapters = (0, collect_1.productionDashboardAdapters)(context());
+        const machine = adapters.machine({ cwd: '/private/project' });
+        const project = adapters.project({ root: '/private/project' });
+        expect(machine.findings).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'machine.provider.codex.binary.version', state: 'ok' }),
+            expect.objectContaining({ id: 'machine.provider.codex.hook.trust', state: 'attention' }),
+        ]));
+        expect(project.findings).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'project.profile.present', state: 'ok' }),
+            expect.objectContaining({ id: 'project.extensions.configured', state: 'ok' }),
+            expect.objectContaining({ id: 'project.registry-pins.present', state: 'ok' }),
+            expect.objectContaining({ id: 'project.context.present', state: 'ok' }),
+            expect.objectContaining({ id: 'project.constitution.present', state: 'ok' }),
+            expect.objectContaining({ id: 'project.sensors.present', state: 'ok' }),
+        ]));
+        expect(JSON.stringify({ machine, project })).not.toMatch(/private|0\.145\.0|hooks trust/i);
+    });
+    it('reports only source-verified remediation and leaves unavailable lifecycle sources explicit', () => {
+        const adapters = (0, collect_1.productionDashboardAdapters)({ ...context(), project: null });
+        expect(adapters.machine({ cwd: '/tmp' }).findings).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'machine.provider.codex.hook.trust', remediationVerified: false }),
+        ]));
+        expect(adapters.execution({ root: '/tmp' })).toBeUndefined();
+    });
+    it('contains no diagnostic prose or raw source details', () => {
+        const facts = context();
+        facts.providers[0].checks[1].detail = 'token=secret /private/path <script>';
+        const serialized = JSON.stringify((0, collect_1.productionDashboardAdapters)(facts).machine({ cwd: '/private/project' }));
+        expect(serialized).not.toMatch(/token|secret|private|script/i);
+    });
+    it('retains stable provider ids after collection and maps a verified bundle remedy', () => {
+        const facts = context();
+        facts.project.activeBundles.broken = ['delivery'];
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({
+            cwd: process.cwd(), now: '2026-08-22T00:00:00.000Z', adapters: (0, collect_1.productionDashboardAdapters)(facts),
+        });
+        const machine = snapshot.sections.find((section) => section.id === 'machine');
+        const project = snapshot.sections.find((section) => section.id === 'project');
+        expect(machine.items).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'machine.provider.codex.binary.version', state: 'ok' }),
+        ]));
+        expect(project.items).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'project.bundles.coherent', remediation: 'awm sync' }),
+        ]));
+        expect(JSON.stringify(snapshot)).not.toMatch(/remediationVerified|private|0\.145\.0|token/i);
+    });
+});

package/dist/tests/core/dashboard/render-html.test.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const render_html_1 = require("../../../src/core/dashboard/render-html");
+const types_1 = require("../../../src/core/dashboard/types");
+const validate_1 = require("../../../src/core/dashboard/validate");
+function snapshot(overrides = {}) {
+    return (0, types_1.dashboardSnapshot)({
+        project: { detected: true, label: 'doctor-dashboard' },
+        confidence: 'observing',
+        sections: [
+            { id: 'machine', availability: 'available', items: [{ id: 'machine.cli', label: 'CLI', state: 'ok', detail: 'v8.1.6' }] },
+            { id: 'project', availability: 'available', items: [{ id: 'project.context', label: 'Context', state: 'attention', remediation: 'awm sync' }] },
+            { id: 'planning', availability: 'available', items: [] },
+            { id: 'execution', availability: 'available', items: [] },
+            { id: 'qa', availability: 'available', items: [] },
+            { id: 'retro', availability: 'available', items: [] },
+            { id: 'history', availability: 'available', items: [] },
+        ],
+        ...overrides,
+    });
+}
+describe('renderDashboardHtml', () => {
+    it('emits a self-contained scriptless document with the exact restrictive CSP and escaped dynamic values', () => {
+        const html = (0, render_html_1.renderDashboardHtml)((0, validate_1.validateDashboardSnapshotV1)(snapshot({
+            project: { detected: true, label: '<img src=x onerror=alert(1)>' },
+            sections: [
+                { id: 'machine', availability: 'available', items: [{ id: 'hostile', label: '<script>alert(1)</script>', state: 'attention', detail: '"quoted"', remediation: 'awm sync && echo <unsafe>' }] },
+                { id: 'project', availability: 'not_applicable', items: [] }, { id: 'planning', availability: 'not_applicable', items: [] },
+                { id: 'execution', availability: 'not_applicable', items: [] }, { id: 'qa', availability: 'not_applicable', items: [] },
+                { id: 'retro', availability: 'not_applicable', items: [] }, { id: 'history', availability: 'not_applicable', items: [] },
+            ],
+        })));
+        expect(html).toContain(`<meta http-equiv="Content-Security-Policy" content="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'">`);
+        expect(html).toContain('&lt;script&gt;alert(1)&lt;/script&gt;');
+        expect(html).toContain('&lt;img src=x onerror=alert(1)&gt;');
+        expect(html).toContain('awm sync &amp;&amp; echo &lt;unsafe&gt;');
+        expect(html).not.toMatch(/<script|https?:\/\//i);
+    });
+    it('uses semantic landmarks and ordered sections with text state, focus, print, responsive, and reduced-motion support', () => {
+        const html = (0, render_html_1.renderDashboardHtml)((0, validate_1.validateDashboardSnapshotV1)(snapshot()));
+        expect(html).toMatch(/<header[\s>]/);
+        expect(html).toContain('data-operational-sidebar aria-label="Dashboard sections"');
+        expect(html).toMatch(/<main[\s>]/);
+        expect(html).toMatch(/<footer[\s>]/);
+        for (const heading of ['Machine / install', 'Project readiness', 'Design / planning', 'Execution', 'QA', 'Retro', 'Final / history'])
+            expect(html).toContain(`<h2>${heading}</h2>`);
+        expect(html).toContain('<table>');
+        expect(html).toContain('<th scope="col">State</th>');
+        expect(html).not.toMatch(/<span class="state [^"]+" aria-label=/);
+        expect(html).toContain(':focus-visible');
+        expect(html).toContain('@media print');
+        expect(html).toContain('@media (max-width: 720px)');
+        expect(html).toContain('@media (prefers-reduced-motion: reduce)');
+        expect(html).not.toMatch(/score|ranking/i);
+    });
+    it('matches the machine-only diagnostic composition with cards, privacy boundary, and prioritized remedies', () => {
+        const html = (0, render_html_1.renderDashboardHtml)((0, validate_1.validateDashboardSnapshotV1)(snapshot({
+            project: { detected: false, label: 'No project detected' },
+            sections: [{ id: 'machine', availability: 'available', items: [
+                        { id: 'machine.cli', label: 'Installation', state: 'ok', detail: 'v8.1.6' },
+                        { id: 'machine.sensors', label: 'Sensors', state: 'attention', remediation: 'awm sensors run' },
+                        { id: 'machine.permissions', label: 'Permissions', state: 'missing', remediation: 'awm init' },
+                    ] }],
+        })));
+        expect(html).toContain('data-machine-bento');
+        expect(html.match(/class="bento-card"/g)).toHaveLength(3);
+        expect(html).toContain('<h2>Instalación</h2>');
+        expect(html).not.toContain('<article class="bento-card"><h3>Instalación</h3>');
+        expect(html).toContain('Privacy &amp; security');
+        expect(html).toContain('data-static-privacy-toggle');
+        expect(html).toContain('type="checkbox" checked disabled');
+        expect(html).toContain('Siguiente acción requerida');
+        expect(html).toContain('Copy command (static)');
+        expect(html).toContain('data-machine-bento');
+        expect(html).toContain('data-next-actions');
+        expect(html.match(/data-next-action=/g)).toHaveLength(3);
+        expect(html).toContain('Inicializar proyecto');
+        expect(html).toContain('<code>awm init</code>');
+        expect(html.indexOf('awm sensors run')).toBeLessThan(html.indexOf('awm init'));
+    });
+    it('uses neutral machine configuration semantics when no project is detected', () => {
+        const html = (0, render_html_1.renderDashboardHtml)((0, validate_1.validateDashboardSnapshotV1)(snapshot({
+            project: { detected: false, label: 'No project detected' },
+            sections: [{ id: 'machine', availability: 'available', items: [] }],
+        })));
+        expect(html).toContain('<h1>Machine configuration</h1>');
+        expect(html).toContain('Machine readiness and safe configuration state outside a project.');
+        expect(html).toContain('aria-label="Machine configuration sections"');
+        expect(html).not.toContain('Project lifecycle');
+        expect(html).not.toContain('Dashboard sections');
+    });
+    it('matches the project lifecycle composition with machine preparation, timeline, provisional evidence, plans, and history', () => {
+        const html = (0, render_html_1.renderDashboardHtml)((0, validate_1.validateDashboardSnapshotV1)(snapshot({ confidence: 'provisional' })));
+        expect(html).toContain('class="machine-preparation-strip" data-machine-preparation');
+        expect(html).toContain('data-machine-preparation role="group" aria-labelledby="machine-preparation-heading"');
+        expect(html).toContain('class="lifecycle-timeline" data-lifecycle-timeline');
+        expect(html).toContain('data-lifecycle-timeline aria-labelledby="lifecycle-timeline-heading"');
+        expect(html).toContain('class="timeline connected-timeline"');
+        expect(html).toContain('<span aria-hidden="true" class="timeline-marker"></span>');
+        for (const stage of ['Planning', 'Execution', 'QA', 'Retro', 'Evidence'])
+            expect(html).toContain(`data-stage="${stage.toLowerCase()}"`);
+        expect(html).toContain('Provisional evidence');
+        expect(html).toContain('data-project-evidence role="group" aria-labelledby="project-evidence-heading"');
+        expect(html).toContain('Planes de trabajo');
+        expect(html).toContain('Impacto y trazabilidad');
+        expect(html).toContain('data-project-header-actions role="group" aria-label="Project actions"');
+        expect(html).toContain('data-project-breadcrumb');
+        expect(html).toContain('data-project-nav');
+        expect(html).toContain('data-machine-preparation-card="installation"');
+        expect(html).toContain('data-machine-preparation-card="sensors"');
+        expect(html).toContain('data-machine-preparation-card="persistence"');
+        expect(html).toContain('data-plan-card="active"');
+        expect(html).toContain('data-plan-card="blocked"');
+        expect(html).toContain('Progreso: sin observación');
+        expect(html).toContain('Ver plan (estático)');
+        expect(html).toContain('<th scope="col">Tipo</th>');
+        expect(html).toContain('<th scope="col">Fuente</th>');
+        expect(html).toContain('<th scope="col">Estado</th>');
+        expect(html).toContain('<th scope="col">Fecha</th>');
+        expect(html).toContain('No hay evidencia de impacto disponible en este snapshot.');
+        expect(html).toContain('data-closure-actions role="group" aria-labelledby="closure-actions-heading"');
+    });
+    it('uses the compact approved desktop composition rather than stretched generic cards', () => {
+        const html = (0, render_html_1.renderDashboardHtml)((0, validate_1.validateDashboardSnapshotV1)(snapshot({ confidence: 'provisional' })));
+        expect(html).toContain('<div class="dashboard-content">');
+        expect(html).toContain('width:min(100%,72rem)');
+        expect(html).toContain('.machine-preparation-strip {');
+        expect(html).toContain('.connected-timeline { border-top:1px solid var(--border);');
+        expect(html).toContain('.timeline-marker {');
+        expect(html).not.toContain('.timeline li::before');
+        expect(html).not.toContain('.connected-timeline::before');
+        expect(html).toContain('.timeline .state.unavailable { background:#38141c; color:#fff0ed;');
+        expect(html).toContain('.evidence-grid.compact-composition');
+        expect(html).toContain('font:14px/1.35');
+    });
+    it('includes the artifact-aligned, noninteractive machine toolbar without weakening static CSP', () => {
+        const html = (0, render_html_1.renderDashboardHtml)((0, validate_1.validateDashboardSnapshotV1)(snapshot({
+            project: { detected: false, label: 'No project detected' },
+            sections: [{ id: 'machine', availability: 'available', items: [] }],
+        })));
+        expect(html).toContain('data-dashboard-toolbar');
+        expect(html).toContain('data-operational-sidebar');
+        for (const label of ['Inicio', 'Estado', 'Configuración', 'Terminal'])
+            expect(html).toContain(`>${label}<`);
+        expect(html).toContain('data-sidebar-diagnose');
+        expect(html).toContain('data-sidebar-operator-controls');
+        expect(html).toContain('aria-label="Search dashboard"');
+        expect(html).toContain('placeholder="Search resources" disabled');
+        for (const label of ['Notifications (static)', 'Help (static)', 'Export dashboard (static)', 'New deployment (static)']) {
+            expect(html).toContain(label);
+        }
+        expect(html).toContain("script-src 'none'");
+    });
+    it('renders every canonical project section once and in lifecycle order', () => {
+        const html = (0, render_html_1.renderDashboardHtml)((0, validate_1.validateDashboardSnapshotV1)(snapshot({ confidence: 'provisional' })));
+        const ids = ['machine', 'project', 'planning', 'execution', 'qa', 'retro', 'history'];
+        const positions = ids.map((id) => html.indexOf(`<section id="${id}"`));
+        expect(positions.every((position) => position >= 0)).toBe(true);
+        expect([...positions].sort((left, right) => left - right)).toEqual(positions);
+        for (const id of ids)
+            expect(html.match(new RegExp(`<section id="${id}"`, 'g'))).toHaveLength(1);
+        expect(html.match(/<section[\s>]/g)).toHaveLength(ids.length);
+    });
+    it('is deterministic and preserves every history and task observation without privacy leakage', () => {
+        const sections = ['machine', 'project', 'planning', 'execution', 'qa', 'retro', 'history'].map((id) => ({
+            id: id, availability: 'available',
+            items: id === 'history' ? Array.from({ length: 500 }, (_, index) => ({ id: `history.${index}`, label: `Cycle ${index}`, state: 'ok' })) : id === 'execution' ? Array.from({ length: 2000 }, (_, index) => ({ id: `execution.${index}`, label: `Task ${index}`, state: 'ok' })) : [],
+        }));
+        const value = (0, validate_1.validateDashboardSnapshotV1)(snapshot({ sections }));
+        const first = (0, render_html_1.renderDashboardHtml)(value);
+        expect((0, render_html_1.renderDashboardHtml)(value)).toBe(first);
+        expect(first).toContain('Cycle 499');
+        expect(first).toContain('Task 1999');
+    });
+});

package/dist/tests/core/dashboard/render-terminal.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const render_terminal_1 = require("../../../src/core/dashboard/render-terminal");
+const types_1 = require("../../../src/core/dashboard/types");
+const validate_1 = require("../../../src/core/dashboard/validate");
+function completeSnapshot(overrides = {}) {
+    return (0, types_1.dashboardSnapshot)({
+        project: { detected: true, label: 'agentic-workflow' },
+        confidence: 'provisional',
+        overall: 'degraded',
+        sections: [
+            { id: 'machine', availability: 'available', items: [{ id: 'machine.cli', label: 'CLI installation', state: 'ok', detail: 'v8.1.6' }] },
+            { id: 'project', availability: 'available', items: [{ id: 'project.sensors', label: 'Sensors', state: 'attention', detail: '2 stale', remediation: 'awm sync' }] },
+            { id: 'planning', availability: 'available', items: [{ id: 'planning.plan', label: 'Active plan', state: 'ok', detail: 'executing' }] },
+            { id: 'execution', availability: 'unavailable', items: [{ id: 'execution.source', label: 'Execution source', state: 'unavailable', remediation: 'awm doctor --full' }] },
+            { id: 'qa', availability: 'available', items: [{ id: 'qa.gate', label: 'Verification gate', state: 'missing', remediation: 'awm sensors' }] },
+            { id: 'retro', availability: 'available', items: [{ id: 'retro.cure', label: 'Cure observations', state: 'not_applicable' }] },
+            { id: 'history', availability: 'available', items: [{ id: 'history.cycle', label: 'Eligible cycle', state: 'ok', detail: '5 minutes' }] },
+        ],
+        ...overrides,
+    });
+}
+describe('renderFullTerminal', () => {
+    it('renders all lifecycle sections in canonical order with status and remediation', () => {
+        const output = (0, render_terminal_1.renderFullTerminal)((0, validate_1.validateDashboardSnapshotV1)(completeSnapshot()));
+        const headings = ['Machine / install', 'Project readiness', 'Design / planning', 'Execution', 'QA', 'Retro', 'Final / history'];
+        expect(headings.map((heading) => output.indexOf(heading))).toEqual([...headings.map((_, index) => expect.any(Number))].map((_, index) => expect.any(Number)));
+        for (let index = 1; index < headings.length; index++)
+            expect(output.indexOf(headings[index])).toBeGreaterThan(output.indexOf(headings[index - 1]));
+        expect(output).toContain('⚠ Sensors [project.sensors] — 2 stale');
+        expect(output).toContain('→ awm sync');
+        expect(output).toContain('⊘ Execution source [execution.source] — unavailable');
+        expect(output).toContain('✖ Verification gate [qa.gate] — missing');
+    });
+    it('renders machine-only, unavailable, provisional, and empty states honestly without ANSI color', () => {
+        const output = (0, render_terminal_1.renderFullTerminal)((0, validate_1.validateDashboardSnapshotV1)((0, types_1.dashboardSnapshot)({
+            overall: 'degraded',
+            confidence: 'provisional',
+            sections: [{ id: 'machine', availability: 'unavailable', items: [] }],
+        })));
+        expect(output).toContain('Project: No project detected');
+        expect(output).toContain('Confidence: provisional');
+        expect(output).toContain('source unavailable');
+        expect(output).toContain('No observations reported.');
+        expect(output).not.toMatch(/\u001b\[/);
+    });
+    it('keeps every long-history and large-task observation visible deterministically', () => {
+        const history = Array.from({ length: 500 }, (_, index) => ({ id: `history.${index}`, label: `Cycle ${index}`, state: 'ok', detail: `${index} retries` }));
+        const execution = Array.from({ length: 2000 }, (_, index) => ({ id: `execution.${index}`, label: `Task ${index}`, state: 'ok' }));
+        const snapshot = (0, validate_1.validateDashboardSnapshotV1)(completeSnapshot({ sections: [
+                { id: 'machine', availability: 'available', items: [] },
+                { id: 'project', availability: 'available', items: [] },
+                { id: 'planning', availability: 'available', items: [] },
+                { id: 'execution', availability: 'available', items: execution },
+                { id: 'qa', availability: 'available', items: [] },
+                { id: 'retro', availability: 'available', items: [] },
+                { id: 'history', availability: 'available', items: history },
+            ] }));
+        const first = (0, render_terminal_1.renderFullTerminal)(snapshot);
+        expect((0, render_terminal_1.renderFullTerminal)(snapshot)).toBe(first);
+        expect(first).toContain('Task 1999');
+        expect(first).toContain('Cycle 499');
+        expect(first).not.toMatch(/score|ranking/i);
+    });
+});

package/dist/tests/core/dashboard/write-html.test.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const write_html_1 = require("../../../src/core/dashboard/write-html");
+describe('writeHtmlAtomically', () => {
+    let root;
+    beforeEach(() => { root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-html-')); });
+    afterEach(() => fs_1.default.rmSync(root, { recursive: true, force: true }));
+    it.each(['', '--flag'])('rejects invalid target %s', (target) => {
+        expect(() => (0, write_html_1.resolveHtmlTarget)({ cwd: root, target })).toThrow();
+    });
+    it('resolves relative targets and refuses overwrite without force', () => {
+        const target = (0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'report.html' });
+        (0, write_html_1.writeHtmlAtomically)({ cwd: root, target, html: '<h1>one</h1>' });
+        expect(fs_1.default.readFileSync(target, 'utf8')).toBe('<h1>one</h1>');
+        expect(() => (0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'report.html' })).toThrow(/exists/i);
+        expect((0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'report.html', force: true })).toBe(target);
+    });
+    it('rejects directories and symlinks', () => {
+        fs_1.default.mkdirSync(path_1.default.join(root, 'dir'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'real.html'), 'x');
+        fs_1.default.symlinkSync(path_1.default.join(root, 'real.html'), path_1.default.join(root, 'link.html'));
+        expect(() => (0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'dir', force: true })).toThrow();
+        expect(() => (0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'link.html', force: true })).toThrow();
+    });
+    it('rejects a symlinked parent but accepts an ordinary nested directory', () => {
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-html-outside-'));
+        try {
+            fs_1.default.mkdirSync(path_1.default.join(root, 'safe', 'nested'), { recursive: true });
+            fs_1.default.symlinkSync(outside, path_1.default.join(root, 'escape'));
+            expect((0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'safe/nested/report.html' })).toBe(path_1.default.join(root, 'safe', 'nested', 'report.html'));
+            expect(() => (0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'escape/report.html' })).toThrow('HTML parent directory must not contain a symbolic link');
+        }
+        finally {
+            fs_1.default.rmSync(outside, { recursive: true, force: true });
+        }
+    });
+    it('rejects absent parents and non-regular existing targets', () => {
+        expect(() => (0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'missing/report.html' })).toThrow(/parent/i);
+        fs_1.default.mkdirSync(path_1.default.join(root, 'regular-dir'));
+        expect(() => (0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'regular-dir', force: true })).toThrow(/regular/i);
+    });
+    it('rejects an injected unwritable parent before creating any temporary file', () => {
+        const operations = { ...fs_1.default, accessSync: jest.fn(() => { throw new Error('denied'); }) };
+        expect(() => (0, write_html_1.resolveHtmlTarget)({ cwd: root, target: 'report.html' }, operations)).toThrow(/writable/i);
+        expect(fs_1.default.readdirSync(root)).toEqual([]);
+    });
+    it('accepts a new absolute target and force-replaces only regular files', () => {
+        const target = path_1.default.join(root, 'absolute.html');
+        expect((0, write_html_1.resolveHtmlTarget)({ cwd: root, target })).toBe(target);
+        fs_1.default.writeFileSync(target, 'old');
+        expect((0, write_html_1.resolveHtmlTarget)({ cwd: root, target, force: true })).toBe(target);
+    });
+    it('rejects an existing target at the exported writer boundary without force', () => {
+        const target = path_1.default.join(root, 'existing.html');
+        fs_1.default.writeFileSync(target, 'previous');
+        expect(() => (0, write_html_1.writeHtmlAtomically)({ cwd: root, target, html: 'replacement' })).toThrow(/exists.*force/i);
+        expect(fs_1.default.readFileSync(target, 'utf8')).toBe('previous');
+    });
+    it.each(['openSync', 'writeFileSync', 'fsyncSync', 'closeSync', 'renameSync'])('preserves old target and cleans only owned temp when %s fails', (failedOperation) => {
+        const target = path_1.default.join(root, 'report.html');
+        fs_1.default.writeFileSync(target, 'previous');
+        const operations = { ...fs_1.default };
+        operations[failedOperation] = jest.fn(() => { throw new Error('injected'); });
+        expect(() => (0, write_html_1.writeHtmlAtomically)({ cwd: root, target, html: 'new', force: true }, operations)).toThrow('injected');
+        expect(fs_1.default.readFileSync(target, 'utf8')).toBe('previous');
+        expect(fs_1.default.readdirSync(root).filter((name) => name.includes('.tmp'))).toEqual([]);
+    });
+    it('uses Windows inherited-ACL open semantics without a POSIX mode', () => {
+        const target = path_1.default.join(root, 'windows.html');
+        const open = jest.spyOn(fs_1.default, 'openSync');
+        const original = process.platform;
+        try {
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            (0, write_html_1.writeHtmlAtomically)({ cwd: root, target, html: 'ok' });
+            expect(open.mock.calls[0]).toHaveLength(2);
+        }
+        finally {
+            Object.defineProperty(process, 'platform', { value: original, configurable: true });
+            open.mockRestore();
+        }
+    });
+    it('uses mode 0600 for a POSIX adjacent temporary file', () => {
+        if (process.platform === 'win32')
+            return;
+        const target = path_1.default.join(root, 'posix.html');
+        const open = jest.spyOn(fs_1.default, 'openSync');
+        try {
+            (0, write_html_1.writeHtmlAtomically)({ cwd: root, target, html: 'ok' });
+            expect(open.mock.calls[0][2]).toBe(0o600);
+        }
+        finally {
+            open.mockRestore();
+        }
+    });
+    it.each([
+        [{ cwd: '', target: path_1.default.join(os_1.default.tmpdir(), 'report.html'), html: 'ok' }, 'writeHtmlAtomically requires a non-empty cwd'],
+        [{ target: '', html: 'ok' }, 'writeHtmlAtomically requires a non-empty absolute target'],
+        [{ target: `${path_1.default.sep}tmp${path_1.default.sep}report\0.html`, html: 'ok' }, 'writeHtmlAtomically target must not contain NUL'],
+        [{ target: 'relative.html', html: 'ok' }, 'writeHtmlAtomically requires a non-empty absolute target'],
+        [{ target: path_1.default.join(os_1.default.tmpdir(), 'report.html'), html: '' }, 'writeHtmlAtomically requires non-empty html'],
+        [{ target: path_1.default.join(os_1.default.tmpdir(), 'report.html'), html: 'ok', force: 'yes' }, 'writeHtmlAtomically force must be boolean'],
+        [{ target: path_1.default.join(os_1.default.tmpdir(), 'report.html'), html: 'ok', platform: 'bad platform' }, 'writeHtmlAtomically platform must be a valid platform'],
+    ])('validates its public input before filesystem calls', (input, message) => {
+        expect(() => (0, write_html_1.writeHtmlAtomically)({ cwd: root, ...input })).toThrow(message);
+    });
+});