agentic-workflow-manager 8.4.0 → 8.5.1

package/dist/src/core/evidence/types.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAN_STATES = void 0;
+exports.validateCycleEvidence = validateCycleEvidence;
+exports.PLAN_STATES = ['active', 'blocked', 'qa_pending', 'retro_pending', 'executed', 'legacy_unverifiable'];
+const DIGEST = /^[a-f0-9]{64}$/;
+const SAFE_ID = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+function record(value, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${label} must be an object`);
+    return value;
+}
+function keys(value, label, allowed) {
+    if (Object.keys(value).some((key) => !allowed.includes(key)))
+        throw new Error(`${label} has unsupported fields`);
+}
+function timestamp(value, label) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) || Number.isNaN(Date.parse(value)) || new Date(value).toISOString() !== value)
+        throw new Error(`${label} must be a canonical ISO timestamp`);
+    return value;
+}
+function count(value, label) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        throw new Error(`${label} must be a non-negative integer`);
+    return value;
+}
+function digest(value, label) {
+    if (typeof value !== 'string' || !DIGEST.test(value))
+        throw new Error(`${label} must be a SHA-256 digest`);
+    return value;
+}
+function relativePlanRef(value) {
+    if (typeof value !== 'string' || !value || value.includes('\\') || value.startsWith('/') || /^[A-Za-z]:/.test(value)
+        || value.split('/').some((part) => part === '' || part === '.' || part === '..'))
+        throw new Error('plan.ref must be repo-relative');
+    return value;
+}
+/** Strict public durable-boundary validator: accepted evidence intentionally has no prose or identities. */
+function validateCycleEvidence(input) {
+    const value = record(input, 'cycle evidence');
+    keys(value, 'cycle evidence', ['schema', 'cycleId', 'startedAt', 'endedAt', 'durationMs', 'cycleState', 'plan', 'tasks', 'qa', 'gates', 'cures', 'pr']);
+    if (value.schema !== 1)
+        throw new Error('cycle evidence schema must be 1');
+    const startedAt = timestamp(value.startedAt, 'startedAt');
+    const endedAt = timestamp(value.endedAt, 'endedAt');
+    const durationMs = count(value.durationMs, 'durationMs');
+    if (Date.parse(endedAt) < Date.parse(startedAt) || durationMs !== Date.parse(endedAt) - Date.parse(startedAt))
+        throw new Error('cycle duration is invalid');
+    if (value.cycleState !== 'completed' && value.cycleState !== 'blocked')
+        throw new Error('cycleState is invalid');
+    const plan = record(value.plan, 'plan');
+    keys(plan, 'plan', ['ref', 'state']);
+    if (typeof plan.state !== 'string' || !exports.PLAN_STATES.includes(plan.state))
+        throw new Error('plan state is invalid');
+    if (!Array.isArray(value.tasks))
+        throw new Error('tasks must be an array');
+    const tasks = value.tasks.map((item, index) => {
+        const task = record(item, `tasks[${index}]`);
+        keys(task, `tasks[${index}]`, ['id', 'attempts', 'retries']);
+        if (typeof task.id !== 'string' || !SAFE_ID.test(task.id))
+            throw new Error('task id is invalid');
+        const attempts = count(task.attempts, 'task attempts');
+        const retries = count(task.retries, 'task retries');
+        if (retries !== Math.max(attempts - 1, 0))
+            throw new Error('task retries must derive from attempts');
+        return { id: task.id, attempts, retries };
+    });
+    const qa = record(value.qa, 'qa');
+    keys(qa, 'qa', ['findings', 'fixes', 'signatures']);
+    if (!Array.isArray(qa.signatures))
+        throw new Error('qa signatures must be an array');
+    const signatures = qa.signatures.map((signature, index) => digest(signature, `qa.signatures[${index}]`));
+    const findings = count(qa.findings, 'qa findings');
+    const fixes = count(qa.fixes, 'qa fixes');
+    if (signatures.length !== findings || fixes > findings)
+        throw new Error('qa counts are inconsistent');
+    const gates = record(value.gates, 'gates');
+    keys(gates, 'gates', ['required', 'firstEvaluationsPassed', 'firstPass']);
+    const required = count(gates.required, 'required gates');
+    if (!Array.isArray(gates.firstEvaluationsPassed) || !gates.firstEvaluationsPassed.every((passed) => typeof passed === 'boolean') || gates.firstEvaluationsPassed.length !== required || typeof gates.firstPass !== 'boolean' || gates.firstPass !== gates.firstEvaluationsPassed.every(Boolean))
+        throw new Error('gate evaluations are inconsistent');
+    if (!Array.isArray(value.cures))
+        throw new Error('cures must be an array');
+    const cures = value.cures.map((item, index) => { const cure = record(item, `cures[${index}]`); keys(cure, `cures[${index}]`, ['signature', 'curedAt']); return { signature: digest(cure.signature, 'cure signature'), curedAt: timestamp(cure.curedAt, 'curedAt') }; });
+    let pr;
+    if (value.pr !== undefined) {
+        const raw = record(value.pr, 'pr');
+        keys(raw, 'pr', ['provider', 'number']);
+        if (raw.provider !== 'github' && raw.provider !== 'gitlab' && raw.provider !== 'other')
+            throw new Error('pr provider is invalid');
+        const number = count(raw.number, 'pr number');
+        if (number < 1)
+            throw new Error('pr number is invalid');
+        pr = { provider: raw.provider, number };
+    }
+    return { schema: 1, cycleId: digest(value.cycleId, 'cycleId'), startedAt, endedAt, durationMs, cycleState: value.cycleState, plan: { ref: relativePlanRef(plan.ref), state: plan.state }, tasks, qa: { findings, fixes, signatures }, gates: { required, firstEvaluationsPassed: [...gates.firstEvaluationsPassed], firstPass: gates.firstPass }, cures, ...(pr ? { pr } : {}) };
+}

package/dist/src/index.js

@@ -41,6 +41,7 @@ const agent_1 = require("./commands/agent");
 const job_1 = require("./commands/job");
 const watch_1 = require("./commands/watch");
 const track_1 = require("./commands/track");
+const evidence_1 = require("./commands/evidence");
 const add_1 = require("./commands/add");
 const sync_1 = require("./commands/sync");
 const update_1 = require("./commands/update");
@@ -733,6 +734,7 @@ miroCmd.command('sync <storyMapPath>')
 (0, job_1.registerJobCommand)(program);
 (0, watch_1.registerWatchCommand)(program);
 (0, track_1.registerTrackCommand)(program);
+(0, evidence_1.registerEvidenceCommand)(program);
 // Commander only waits for async action handlers through parseAsync().  The CLI has
 // async commands (including `sensors coverage`), so returning its promise keeps the
 // process alive until their JSON/output contract has been completed.

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

@@ -1,7 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const collect_1 = require("../../../src/core/dashboard/collect");
 const sanitize_1 = require("../../../src/core/dashboard/sanitize");
+const store_1 = require("../../../src/core/evidence/store");
+const evidence_fixtures_1 = require("../../helpers/evidence-fixtures");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
 const fixedNow = '2026-08-22T00:00:00.000Z';
 describe('collectDashboardSnapshot', () => {
     it('returns only a healthy machine section outside a project', () => {
@@ -35,13 +43,13 @@ describe('collectDashboardSnapshot', () => {
                 machine: () => ({ findings: [{ id: 'machine.preferences.missing', label: 'Preferences', state: 'missing' }] }),
                 project: () => ({ label: 'Demo', findings: [{ id: 'project.profile.missing', label: 'Profile', state: 'missing' }] }),
                 plans: () => Array.from({ length: 2000 }, (_, index) => ({ id: `plan.${index}`, label: `Plan ${index}`, state: 'ok' })),
-                execution: () => ({ history: Array.from({ length: 500 }, (_, index) => ({ id: `history.${index}`, label: `History ${index}`, state: 'ok' })) }),
+                execution: () => ({}),
             },
         });
         expect(snapshot.sections.map((section) => section.id)).toEqual(['machine', 'project', 'planning', 'execution', 'qa', 'retro', 'history']);
         expect(snapshot.sections.find((section) => section.id === 'machine')?.items[0].remediation).toBe('awm init');
         expect(snapshot.sections.find((section) => section.id === 'planning')?.items).toHaveLength(2000);
-        expect(snapshot.sections.find((section) => section.id === 'history')?.items).toHaveLength(500);
+        expect(snapshot.sections.find((section) => section.id === 'history')?.items).toHaveLength(0);
         expect(JSON.stringify(snapshot)).not.toMatch(/score|ranking/i);
     });
     it('isolates optional adapter failures and omits unverified remediation', () => {
@@ -62,7 +70,7 @@ describe('collectDashboardSnapshot', () => {
             cwd: process.cwd(), now: fixedNow,
             adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined },
         });
-        for (const id of ['execution', 'qa', 'retro', 'history']) {
+        for (const id of ['execution', 'qa', 'retro']) {
             expect(snapshot.sections.find((section) => section.id === id)?.availability).toBe('unavailable');
         }
     });
@@ -83,7 +91,7 @@ describe('collectDashboardSnapshot', () => {
         expect(snapshot.sections.find((section) => section.id === 'project')?.availability).toBe('unavailable');
         expect(snapshot.sections.find((section) => section.id === 'planning')?.availability).toBe('available');
     });
-    it.each(['execution', 'qa', 'retro', 'history'])('isolates malformed %s findings', (key) => {
+    it.each(['execution', 'qa', 'retro'])('isolates malformed %s findings', (key) => {
         const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => ({ [key]: [{ id: '', label: 'Profile', state: 'ok' }] }) } });
         expect(snapshot.sections.find((section) => section.id === key)?.availability).toBe('unavailable');
     });
@@ -142,6 +150,77 @@ describe('collectDashboardSnapshot', () => {
         expect(snapshot.sections.map((section) => section.id)).toEqual(['machine']);
         expect(snapshot.overall).toBe('degraded');
     });
+    it('loads validated local evidence only after a project is detected and renders every cycle fact', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-dashboard-'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        (0, store_1.writeCycleEvidence)(root, (0, evidence_fixtures_1.cycleEvidenceFixture)());
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        const history = snapshot.sections.find((section) => section.id === 'history');
+        expect(snapshot.confidence).toBe('provisional');
+        expect(history?.availability).toBe('available');
+        expect(history?.items[0]?.detail).toContain('retries 1; QA 1/1; first-pass yes; cures awaiting_observation');
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    it('renders a blocked evidence cycle as an actionable history item with a verified remedy', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-dashboard-'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        (0, store_1.writeCycleEvidence)(root, { ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), cycleState: 'blocked', plan: { ref: 'docs/plans/current.md', state: 'blocked' } });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        expect(snapshot.sections.find((section) => section.id === 'history')?.items).toEqual([
+            expect.objectContaining({ state: 'attention', remediation: 'awm preflight' }),
+        ]);
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    it.each(['.awm', 'evidence', 'cycles'])('does not follow a symlinked %s evidence ancestor', (ancestor) => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-dashboard-'));
+        const external = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-external-'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        const externalCycles = ancestor === '.awm' ? path_1.default.join(external, 'evidence', 'cycles') : path_1.default.join(external, 'cycles');
+        fs_1.default.mkdirSync(externalCycles, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(externalCycles, `${'a'.repeat(64)}.json`), JSON.stringify((0, evidence_fixtures_1.cycleEvidenceFixture)()));
+        if (ancestor === '.awm')
+            fs_1.default.symlinkSync(external, path_1.default.join(root, '.awm'));
+        else if (ancestor === 'evidence') {
+            fs_1.default.mkdirSync(path_1.default.join(root, '.awm'));
+            fs_1.default.symlinkSync(external, path_1.default.join(root, '.awm', 'evidence'));
+        }
+        else {
+            fs_1.default.mkdirSync(path_1.default.join(root, '.awm', 'evidence'), { recursive: true });
+            fs_1.default.symlinkSync(external, path_1.default.join(root, '.awm', 'evidence', 'cycles'));
+        }
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        const history = snapshot.sections.find((section) => section.id === 'history');
+        expect(history).toEqual(expect.objectContaining({ availability: 'unavailable', items: [] }));
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+        fs_1.default.rmSync(external, { recursive: true, force: true });
+    });
+    it('does not follow a symlinked evidence file', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-dashboard-'));
+        const external = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-external-'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        const cycleId = 'a'.repeat(64);
+        const externalFile = path_1.default.join(external, `${cycleId}.json`);
+        fs_1.default.writeFileSync(externalFile, JSON.stringify((0, evidence_fixtures_1.cycleEvidenceFixture)()));
+        const directory = path_1.default.join(root, '.awm', 'evidence', 'cycles');
+        fs_1.default.mkdirSync(directory, { recursive: true });
+        fs_1.default.symlinkSync(externalFile, path_1.default.join(directory, `${cycleId}.json`));
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        expect(snapshot.sections.find((section) => section.id === 'history')).toEqual(expect.objectContaining({ availability: 'unavailable', items: [] }));
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+        fs_1.default.rmSync(external, { recursive: true, force: true });
+    });
+    it.each(['duplicate', 'mismatch'])('does not accept %s evidence filenames', (caseName) => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-dashboard-'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        (0, store_1.writeCycleEvidence)(root, (0, evidence_fixtures_1.cycleEvidenceFixture)());
+        const directory = path_1.default.join(root, '.awm', 'evidence', 'cycles');
+        const record = (0, evidence_fixtures_1.cycleEvidenceFixture)();
+        const filename = caseName === 'duplicate' ? `${'b'.repeat(64)}.json` : `${'b'.repeat(64)}.json`;
+        fs_1.default.writeFileSync(path_1.default.join(directory, filename), JSON.stringify(caseName === 'duplicate' ? record : { ...record, cycleId: 'c'.repeat(64) }));
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: root, now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        expect(snapshot.sections.find((section) => section.id === 'history')).toEqual(expect.objectContaining({ availability: 'unavailable', items: [] }));
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
 });
 describe('sanitizeDashboardSource', () => {
     it('removes hostile paths and secrets before rendering', () => {

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

@@ -1,6 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const collect_1 = require("../../../src/core/dashboard/collect");
+const store_1 = require("../../../src/core/evidence/store");
+const store_2 = require("../../../src/core/journal/store");
+const types_1 = require("../../../src/core/journal/types");
+const evidence_fixtures_1 = require("../../helpers/evidence-fixtures");
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
 function context() {
     return {
         machine: {},
@@ -67,4 +78,82 @@ describe('productionDashboardAdapters', () => {
         ]));
         expect(JSON.stringify(snapshot)).not.toMatch(/remediationVerified|private|0\.145\.0|token/i);
     });
+    it('derives plan lifecycle and execution evidence from validated local cycle records', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-dashboard-production-evidence-'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        (0, store_1.writeCycleEvidence)(root, {
+            ...(0, evidence_fixtures_1.cycleEvidenceFixture)(),
+            plan: { ref: 'docs/plans/current.md', state: 'executed' },
+            tasks: [{ id: 'task-1', attempts: 2, retries: 1 }],
+            qa: { findings: 1, fixes: 1, signatures: ['a'.repeat(64)] },
+        });
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({
+            cwd: root, now: '2026-08-22T00:00:00.000Z', adapters: (0, collect_1.productionDashboardAdapters)(context()),
+        });
+        expect(snapshot.sections.find((section) => section.id === 'planning')?.items).toEqual([
+            expect.objectContaining({ detail: 'executed', state: 'ok' }),
+        ]);
+        expect(snapshot.sections.find((section) => section.id === 'execution')?.items).toEqual([
+            expect.objectContaining({ state: 'ok' }),
+        ]);
+        expect(snapshot.sections.find((section) => section.id === 'qa')?.items).toEqual([
+            expect.objectContaining({ state: 'ok' }),
+        ]);
+        expect(snapshot.sections.find((section) => section.id === 'retro')?.items).toEqual([
+            expect.objectContaining({ state: 'ok' }),
+        ]);
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    it.each([
+        ['IN_PROGRESS', 'active', 'ok'],
+        ['BLOCKED', 'blocked', 'attention'],
+    ])('overlays the current branch journal %s over prior executed evidence', (status, expectedLifecycle, expectedState) => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-dashboard-journal-overlay-'));
+        const branch = 'dashboard-overlay';
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        (0, child_process_1.execFileSync)('git', ['init', '--initial-branch', branch], { cwd: root, stdio: 'ignore' });
+        (0, child_process_1.execFileSync)('git', ['config', 'user.email', 'dashboard@example.test'], { cwd: root, stdio: 'ignore' });
+        (0, child_process_1.execFileSync)('git', ['config', 'user.name', 'Dashboard Test'], { cwd: root, stdio: 'ignore' });
+        (0, child_process_1.execFileSync)('git', ['commit', '--allow-empty', '-m', 'fixture'], { cwd: root, stdio: 'ignore' });
+        (0, store_1.writeCycleEvidence)(root, { ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), plan: { ref: 'docs/plans/current.md', state: 'executed' } });
+        (0, store_2.initJournal)(root, branch);
+        const journal = (0, types_1.emptyState)(branch);
+        journal.cycle.status = status;
+        (0, store_2.writeJournal)(root, branch, journal);
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({
+            cwd: root, now: '2026-08-22T00:00:00.000Z', adapters: (0, collect_1.productionDashboardAdapters)(context()),
+        });
+        expect(snapshot.sections.find((section) => section.id === 'planning')?.items).toEqual([
+            expect.objectContaining({ detail: expectedLifecycle, state: expectedState }),
+        ]);
+        expect(JSON.stringify(snapshot)).not.toMatch(/dashboard-overlay|dashboard@example|Dashboard Test/i);
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    it.each([
+        ['IN_PROGRESS', 'active', 'ok'],
+        ['BLOCKED', 'blocked', 'attention'],
+    ])('renders the current branch journal %s without prior evidence', (status, expectedLifecycle, expectedState) => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-dashboard-journal-only-'));
+        const branch = 'dashboard-journal-only';
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), '{}');
+        (0, child_process_1.execFileSync)('git', ['init', '--initial-branch', branch], { cwd: root, stdio: 'ignore' });
+        (0, child_process_1.execFileSync)('git', ['config', 'user.email', 'dashboard@example.test'], { cwd: root, stdio: 'ignore' });
+        (0, child_process_1.execFileSync)('git', ['config', 'user.name', 'Dashboard Test'], { cwd: root, stdio: 'ignore' });
+        (0, child_process_1.execFileSync)('git', ['commit', '--allow-empty', '-m', 'fixture'], { cwd: root, stdio: 'ignore' });
+        (0, store_2.initJournal)(root, branch);
+        const journal = (0, types_1.emptyState)(branch);
+        journal.cycle.status = status;
+        (0, store_2.writeJournal)(root, branch, journal);
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({
+            cwd: root, now: '2026-08-22T00:00:00.000Z', adapters: (0, collect_1.productionDashboardAdapters)(context()),
+        });
+        expect(snapshot.sections.find((section) => section.id === 'planning')?.items).toEqual([
+            expect.objectContaining({ detail: expectedLifecycle, state: expectedState }),
+        ]);
+        expect(snapshot.sections.find((section) => section.id === 'execution')).toEqual(expect.objectContaining({
+            availability: 'available', items: [expect.objectContaining({ state: expectedState })],
+        }));
+        expect(JSON.stringify(snapshot)).not.toMatch(/dashboard-journal-only|dashboard@example|Dashboard Test/i);
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
 });

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

@@ -172,4 +172,20 @@ describe('renderDashboardHtml', () => {
         expect(first).toContain('Cycle 499');
         expect(first).toContain('Task 1999');
     });
+    it('renders supplied plans and evidence facts in the dense project panels', () => {
+        const html = (0, render_html_1.renderDashboardHtml)((0, validate_1.validateDashboardSnapshotV1)(snapshot({
+            confidence: 'supported',
+            sections: [
+                { id: 'machine', availability: 'available', items: [] }, { id: 'project', availability: 'available', items: [] },
+                { id: 'planning', availability: 'available', items: [{ id: 'plan.alpha', label: 'Impact plan', state: 'ok', detail: 'executed' }] },
+                { id: 'execution', availability: 'available', items: [] }, { id: 'qa', availability: 'available', items: [] }, { id: 'retro', availability: 'available', items: [] },
+                { id: 'history', availability: 'available', items: [{ id: 'history.cycle.abc', label: 'Cycle abc', state: 'ok', detail: 'plan executed; tasks 3; retries 2; QA 2/2; first-pass yes; cures supported' }] },
+            ],
+        })));
+        expect(html).toContain('Confidence: supported');
+        expect(html).toContain('Impact plan');
+        expect(html).toContain('Cycle abc');
+        expect(html).toContain('retries 2; QA 2/2; first-pass yes; cures supported');
+        expect(html).not.toContain('Progreso: sin observación');
+    });
 });

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

@@ -62,4 +62,11 @@ describe('renderFullTerminal', () => {
         expect(first).toContain('Cycle 499');
         expect(first).not.toMatch(/score|ranking/i);
     });
+    it('renders explicit confidence and every evidence metric without improvement claims', () => {
+        const output = (0, render_terminal_1.renderFullTerminal)((0, validate_1.validateDashboardSnapshotV1)(completeSnapshot({ confidence: 'supported' })));
+        expect(output).toContain('Confidence: supported');
+        expect(output).toContain('Eligible evidence rows: 1');
+        expect(output).toContain('5 minutes');
+        expect(output).not.toMatch(/trend|percentage|improvement/i);
+    });
 });

package/dist/tests/core/evidence/capture.test.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const capture_1 = require("../../../src/core/evidence/capture");
+describe('captureCycleEvidence', () => {
+    test('derives counts and opaque signatures without journal prose or identities', () => {
+        const evidence = (0, capture_1.captureCycleEvidence)({
+            root: process.cwd(), repositoryIdentity: 'git@example.test:team/repository.git',
+            planPath: 'plans/release.md',
+            journal: {
+                cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:10.000Z' },
+                journalId: 'local-repository-identity',
+                tasks: [{ id: 'task-a', attempts: 3 }],
+                verdicts: [{ id: 'v1', result: 'fail', fingerprint: 'unsafe-input', detail: 'Alice saw secret prompt', receivedAt: '2026-08-22T10:00:05.000Z' }],
+                fixes: [{ verdictId: 'v1', closed: true }],
+            },
+            gates: [{ required: true, passed: true }],
+            ledger: [{ signature: 'unsafe-input', polarity: 'win', ts: '2026-08-22T10:00:06.000Z' }],
+            pr: { provider: 'github', number: 12 },
+        });
+        expect(evidence).toMatchObject({
+            schema: 1, cycleState: 'completed', durationMs: 10_000,
+            plan: { ref: 'plans/release.md' }, tasks: [{ id: 'task-a', attempts: 3, retries: 2 }],
+            qa: { findings: 1, fixes: 1 }, gates: { required: 1, firstEvaluationsPassed: [true], firstPass: true },
+            pr: { provider: 'github', number: 12 },
+        });
+        expect(evidence.cycleId).toMatch(/^[a-f0-9]{64}$/);
+        expect(evidence.qa.signatures[0]).toMatch(/^[a-f0-9]{64}$/);
+        expect(evidence.cures[0]).toMatchObject({ signature: expect.stringMatching(/^[a-f0-9]{64}$/) });
+        expect(evidence.cures[0].signature).toBe(evidence.qa.signatures[0]);
+        expect(JSON.stringify(evidence)).not.toContain('Alice');
+        expect(JSON.stringify(evidence)).not.toContain('secret prompt');
+    });
+    test('derives cycle identity from stable repository identity, not checkout or journal identity', () => {
+        const source = {
+            planPath: 'plans/release.md', journal: { journalId: 'repository-identity', cycle: { status: 'BLOCKED', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], verdicts: [], fixes: [] }, gates: [], ledger: [],
+        };
+        const first = (0, capture_1.captureCycleEvidence)({ ...source, root: process.cwd(), repositoryIdentity: 'git@example.test:team/repository.git' });
+        const second = (0, capture_1.captureCycleEvidence)({ ...source, root: process.cwd(), repositoryIdentity: 'git@example.test:team/repository.git', journal: { ...source.journal, journalId: 'different-journal-identity' } });
+        const distinct = (0, capture_1.captureCycleEvidence)({ ...source, root: process.cwd(), repositoryIdentity: 'git@example.test:other/repository.git' });
+        expect(first.cycleId).toBe(second.cycleId);
+        expect(first.cycleId).not.toBe(distinct.cycleId);
+        expect(first.cycleState).toBe('blocked');
+    });
+    test('captures a blocked cycle from its durable controller heartbeat when completedAt is absent', () => {
+        const evidence = (0, capture_1.captureCycleEvidence)({ root: process.cwd(), repositoryIdentity: 'git@example.test:team/repository.git', planPath: 'plans/release.md', journal: { cycle: { status: 'BLOCKED', startedAt: '2026-08-22T10:00:00.000Z' }, controllerHeartbeatAt: '2026-08-22T10:00:03.000Z', tasks: [], verdicts: [], fixes: [] }, gates: [], ledger: [] });
+        expect(evidence).toMatchObject({ cycleState: 'blocked', endedAt: '2026-08-22T10:00:03.000Z', durationMs: 3_000 });
+    });
+    test('counts inconclusive verdicts as adverse findings because they create fix obligations', () => {
+        const evidence = (0, capture_1.captureCycleEvidence)({
+            root: process.cwd(), repositoryIdentity: 'git@example.test:team/repository.git', planPath: 'plans/release.md',
+            journal: {
+                cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' },
+                tasks: [], verdicts: [{ id: 'v1', result: 'inconclusive', fingerprint: 'probe-unavailable', receivedAt: '2026-08-22T10:00:00.000Z' }],
+                fixes: [{ verdictId: 'v1', closed: true }],
+            }, gates: [], ledger: [],
+        });
+        expect(evidence.qa).toMatchObject({ findings: 1, fixes: 1, signatures: [expect.stringMatching(/^[a-f0-9]{64}$/)] });
+    });
+    test('counts only closed fixes that reference an adverse verdict', () => {
+        const evidence = (0, capture_1.captureCycleEvidence)({
+            root: process.cwd(), repositoryIdentity: 'git@example.test:team/repository.git', planPath: 'plans/release.md',
+            journal: {
+                cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [],
+                verdicts: [
+                    { id: 'v-fail', result: 'fail', fingerprint: 'failure', receivedAt: '2026-08-22T10:00:00.000Z' },
+                    { id: 'v-inconclusive', result: 'inconclusive', fingerprint: 'unknown', receivedAt: '2026-08-22T10:00:00.000Z' },
+                ],
+                fixes: [{ verdictId: 'v-fail', closed: true }, { verdictId: 'v-inconclusive', closed: false }],
+            }, gates: [], ledger: [],
+        });
+        expect(evidence.qa).toMatchObject({ findings: 2, fixes: 1 });
+    });
+    test.each([
+        { verdicts: [], verdictId: 'missing' },
+        { verdicts: [{ id: 'v-pass', result: 'pass', fingerprint: 'passed', receivedAt: '2026-08-22T10:00:00.000Z' }], verdictId: 'v-pass' },
+    ])('rejects a fix whose verdict reference is absent or not adverse', ({ verdicts, verdictId }) => {
+        expect(() => (0, capture_1.captureCycleEvidence)({
+            root: process.cwd(), repositoryIdentity: 'git@example.test:team/repository.git', planPath: 'plans/release.md',
+            journal: { cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], verdicts, fixes: [{ verdictId, closed: true }] }, gates: [], ledger: [],
+        })).toThrow(/fix verdictId/i);
+    });
+});

package/dist/tests/core/evidence/command.test.js

@@ -0,0 +1,60 @@
+"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 evidence_1 = require("../../../src/commands/evidence");
+describe('evidence capture CLI boundary', () => {
+    let root;
+    beforeEach(() => { root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-command-')); });
+    afterEach(() => { fs_1.default.rmSync(root, { recursive: true, force: true }); });
+    test('returns exit 2 for a missing or invalid plan', () => {
+        expect((0, evidence_1.runEvidenceCapture)(root, undefined).code).toBe(2);
+        expect((0, evidence_1.runEvidenceCapture)(root, '../secret.md').code).toBe(2);
+    });
+    test('returns exactly the captured cycle id on success', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# plan\n');
+        expect((0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: { journalId: 'ignored', cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], verdicts: [], fixes: [], jobs: {}, cycleVerificationPlan: [] }, ledger: [] })).toEqual(expect.objectContaining({ code: 0, stdout: expect.stringMatching(/^[a-f0-9]{64}\n$/) }));
+    });
+    test('uses the first attempted gate evaluation instead of final satisfaction', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# plan\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: { journalId: 'ignored', cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], verdicts: [], fixes: [], cycleVerificationPlan: [{ id: 'gate', kind: 'test', satisfiedBy: 'retry' }], jobs: { first: { id: 'first', satisfies: ['gate'], verdict: 'fail', phaseTimestamps: { received: '2026-08-22T10:00:00.000Z' } }, retry: { id: 'retry', satisfies: ['gate'], attemptOf: 'first', verdict: 'pass', phaseTimestamps: { received: '2026-08-22T10:00:01.000Z' } } } }, ledger: [] });
+        expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, '.awm', 'evidence', 'cycles', result.stdout.trim() + '.json'), 'utf8')).gates.firstEvaluationsPassed).toEqual([false]);
+    });
+    test('orders independent root evaluations by durable timestamp then id', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# plan\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: { journalId: 'ignored', cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:03.000Z' }, tasks: [], verdicts: [], fixes: [], cycleVerificationPlan: [{ id: 'gate', kind: 'test', satisfiedBy: 'late-pass' }], jobs: { late: { id: 'late-pass', satisfies: ['gate'], verdict: 'pass', phaseTimestamps: { received: '2026-08-22T10:00:02.000Z' } }, early: { id: 'early-fail', satisfies: ['gate'], verdict: 'fail', phaseTimestamps: { received: '2026-08-22T10:00:01.000Z' } } } }, ledger: [] });
+        expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, '.awm', 'evidence', 'cycles', result.stdout.trim() + '.json'), 'utf8')).gates.firstEvaluationsPassed).toEqual([false]);
+    });
+    test('uses the first review verdict rather than satisfiedBy final verdict', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# plan\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: { journalId: 'ignored', cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], fixes: [], cycleVerificationPlan: [{ id: 'review-gate', kind: 'review', satisfiedBy: 'final' }], jobs: {}, verdicts: [{ id: 'first', obligationId: 'review-gate', result: 'fail', fingerprint: 'review-gate', receivedAt: '2026-08-22T10:00:00.000Z' }, { id: 'final', obligationId: 'review-gate', result: 'pass', fingerprint: 'review-gate', receivedAt: '2026-08-22T10:00:01.000Z' }] }, ledger: [] });
+        expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, '.awm', 'evidence', 'cycles', result.stdout.trim() + '.json'), 'utf8')).gates.firstEvaluationsPassed).toEqual([false]);
+    });
+    test('derives retro_pending from completed checklist tasks and the QA marker in the plan file', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# plan\n<!-- awm-qa-complete: 2026-08-22 -->\n- [x] Build\n- [X] Verify\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: { journalId: 'ignored', cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], verdicts: [], fixes: [], jobs: {}, cycleVerificationPlan: [] }, ledger: [] });
+        expect(result.code).toBe(0);
+        expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, '.awm', 'evidence', 'cycles', result.stdout.trim() + '.json'), 'utf8')).plan.state).toBe('retro_pending');
+    });
+    test('uses a blocked journal state over completed plan markers', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# plan\n<!-- awm-qa-complete: 2026-08-22 -->\n<!-- awm-retro-complete: 2026-08-22 -->\n- [x] Build\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: { journalId: 'ignored', cycle: { status: 'BLOCKED', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], verdicts: [], fixes: [], jobs: {}, cycleVerificationPlan: [] }, ledger: [] });
+        expect(result.code).toBe(0);
+        expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, '.awm', 'evidence', 'cycles', result.stdout.trim() + '.json'), 'utf8')).plan.state).toBe('blocked');
+    });
+    test('does not let Release A markers classify a multi-release plan whose current Release B has no lifecycle markers', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# plan\n<!-- awm-qa-complete: Release A / #86 -->\n<!-- awm-retro-complete: Release A / #86 -->\n\n## Delivery order\n1. **Release A / #86:** dashboard\n2. **Release B / #87:** evidence\n\n- [x] Release B task\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: { journalId: 'ignored', cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], verdicts: [], fixes: [], jobs: {}, cycleVerificationPlan: [] }, ledger: [] });
+        expect(result.code).toBe(0);
+        expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, '.awm', 'evidence', 'cycles', result.stdout.trim() + '.json'), 'utf8')).plan.state).toBe('qa_pending');
+    });
+    test('rejects a malformed checklist instead of silently classifying a plan', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# plan\n- [z] Unknown state\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: { journalId: 'ignored', cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], verdicts: [], fixes: [], jobs: {}, cycleVerificationPlan: [] }, ledger: [] });
+        expect(result).toEqual(expect.objectContaining({ code: 2, error: expect.stringMatching(/invalid checklist/i) }));
+    });
+});

package/dist/tests/core/evidence/history.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const history_1 = require("../../../src/core/evidence/history");
+const evidence_fixtures_1 = require("../../helpers/evidence-fixtures");
+describe('evidence history', () => {
+    it.each([[0, 'none'], [1, 'provisional'], [2, 'observing'], [4, 'observing'], [5, 'supported']])('classifies %i eligible cycles as %s', (count, expected) => expect((0, history_1.confidenceForCycles)(count)).toBe(expected));
+    it.each([
+        [0, false, 'awaiting_observation'], [1, false, 'observing'], [2, false, 'observing'],
+        [3, false, 'supported'], [1, true, 'recurred'],
+    ])('classifies cure observation honestly', (laterEligibleCycles, recurred, expected) => {
+        expect((0, history_1.classifyCure)({ laterEligibleCycles, recurred })).toBe(expected);
+    });
+    it('validates every record, retains every eligible row, and sorts stably by timestamp and cycle id', () => {
+        const later = { ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), cycleId: 'd'.repeat(64), startedAt: '2026-08-22T11:00:00.000Z', endedAt: '2026-08-22T11:01:00.000Z', cures: [] };
+        const sameTimestamp = { ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), cycleId: '0'.repeat(64), cures: [] };
+        const history = (0, history_1.buildEvidenceHistory)([later, (0, evidence_fixtures_1.cycleEvidenceFixture)(), sameTimestamp]);
+        expect(history.confidence).toBe('observing');
+        expect(history.empty).toBe(false);
+        expect(history.cycles.map((cycle) => cycle.cycleId)).toEqual(['0'.repeat(64), 'a'.repeat(64), 'd'.repeat(64)]);
+        expect(() => (0, history_1.buildEvidenceHistory)([{ ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), durationMs: -1 }])).toThrow(/duration/i);
+    });
+    it('reports zero cycles explicitly without a trend, percentage, or improvement claim', () => {
+        const history = (0, history_1.buildEvidenceHistory)([]);
+        expect(history).toEqual(expect.objectContaining({ empty: true, confidence: 'none', cycles: [] }));
+        expect(JSON.stringify(history)).not.toMatch(/trend|percentage|improvement/i);
+    });
+    it('retains blocked records but excludes them from confidence and cure observation windows', () => {
+        const blocked = Array.from({ length: 5 }, (_, index) => ({
+            ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), cycleId: `${index}`.repeat(64), cycleState: 'blocked', cures: [],
+        }));
+        const history = (0, history_1.buildEvidenceHistory)(blocked);
+        expect(history.cycles).toHaveLength(5);
+        expect(history.confidence).toBe('none');
+        const cured = { ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), cycleId: 'c'.repeat(64), endedAt: '2026-08-22T10:01:00.000Z' };
+        const laterBlocked = { ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), cycleId: 'd'.repeat(64), cycleState: 'blocked', startedAt: '2026-08-22T11:00:00.000Z', endedAt: '2026-08-22T11:01:00.000Z', cures: [] };
+        const laterCompleted = { ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), cycleId: 'e'.repeat(64), startedAt: '2026-08-22T12:00:00.000Z', endedAt: '2026-08-22T12:01:00.000Z', cures: [] };
+        const mixed = (0, history_1.buildEvidenceHistory)([cured, laterBlocked, laterCompleted]);
+        expect(mixed.confidence).toBe('observing');
+        expect(mixed.cycles[0].cureEfficacy[0].efficacy).toBe('observing');
+    });
+});

package/dist/tests/core/evidence/store.test.js

@@ -0,0 +1,32 @@
+"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 evidence_fixtures_1 = require("../../helpers/evidence-fixtures");
+const store_1 = require("../../../src/core/evidence/store");
+describe('cycle evidence store', () => {
+    let root;
+    beforeEach(() => { root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-')); });
+    afterEach(() => { fs_1.default.rmSync(root, { recursive: true, force: true }); });
+    test('durably replaces one observation for the same opaque cycle id', () => {
+        const evidence = (0, evidence_fixtures_1.cycleEvidenceFixture)();
+        (0, store_1.writeCycleEvidence)(root, evidence);
+        (0, store_1.writeCycleEvidence)(root, { ...evidence, qa: { ...evidence.qa, fixes: 0 } });
+        const dir = path_1.default.join(root, '.awm', 'evidence', 'cycles');
+        expect(fs_1.default.readdirSync(dir)).toEqual([`${evidence.cycleId}.json`]);
+        expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, `${evidence.cycleId}.json`), 'utf8')).qa.fixes).toBe(0);
+    });
+    test('rejects symlinked evidence ancestors without writing outside root', () => {
+        if (process.platform === 'win32')
+            return;
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-outside-'));
+        fs_1.default.symlinkSync(outside, path_1.default.join(root, '.awm'));
+        expect(() => (0, store_1.writeCycleEvidence)(root, (0, evidence_fixtures_1.cycleEvidenceFixture)())).toThrow(/symlink/);
+        expect(fs_1.default.readdirSync(outside)).toEqual([]);
+        fs_1.default.rmSync(outside, { recursive: true, force: true });
+    });
+});