agentic-workflow-manager 8.5.2 → 9.0.1

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

@@ -28,12 +28,19 @@ function currentRelease(lines) {
     return releases.length > 1 ? releases.at(-1) : undefined;
 }
 function marker(lines, name, release) {
-    const expression = new RegExp(`^\\s*<!--\\s*${name}(?:\\s*:\\s*[^\\r\\n]*?)?\\s*-->\\s*$`);
+    // Split into two non-overlapping alternatives (no-colon vs colon) so no `\s*`
+    // ever sits directly adjacent to the lazy `[^\r\n]*?` group — that adjacency
+    // is what turns a long unterminated marker line into catastrophic backtracking.
+    const expression = new RegExp(`^\\s*<!--\\s*${name}(?:\\s*-->\\s*$|\\s*:[^\\r\\n]*?-->\\s*$)`);
     if (release === undefined)
         return lines.some((line) => expression.test(line));
     const releaseExpression = new RegExp(`\\bRelease\\s+${release.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&')}\\b`, 'i');
     return lines.some((line) => expression.test(line) && releaseExpression.test(line));
 }
+/** `docs_pending` es un estado vivo del dashboard; el registro durable no lo conoce (schema 1). */
+function forEvidence(state) {
+    return state === 'docs_pending' ? 'retro_pending' : state;
+}
 /** Reads only structural lifecycle syntax; plan prose never crosses into evidence. */
 function planState(root, planPath, journal) {
     const file = path_1.default.join(root, planPath);
@@ -78,11 +85,15 @@ function planState(root, planPath, journal) {
     if (status !== 'IN_PROGRESS' && status !== 'COMPLETE' && status !== 'BLOCKED')
         throw new Error('journal cycle status is invalid');
     const release = currentRelease(visibleLines);
-    return (0, plan_state_1.classifyPlanState)({
+    return forEvidence((0, plan_state_1.classifyPlanState)({
         ...(status === 'IN_PROGRESS' ? { journal: { state: 'active' } } : status === 'BLOCKED' ? { journal: { state: 'blocked' } } : {}),
-        markers: { qaComplete: marker(visibleLines, 'awm-qa-complete', release), retroComplete: marker(visibleLines, 'awm-retro-complete', release) },
+        markers: {
+            qaComplete: marker(visibleLines, 'awm-qa-complete', release),
+            docsComplete: marker(visibleLines, 'awm-docs-complete', release),
+            retroComplete: marker(visibleLines, 'awm-retro-complete', release),
+        },
         tasks: { total, completed },
-    });
+    }));
 }
 function registerEvidenceCommand(program) {
     const evidence = program.command('evidence').description('durable privacy-preserving cycle observations');

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REMEDIATION_BY_FINDING_ID = void 0;
 exports.productionDashboardAdapters = productionDashboardAdapters;
+exports.lifecycleForCycle = lifecycleForCycle;
 exports.collectDashboardSnapshot = collectDashboardSnapshot;
 const profile_1 = require("../profile");
 const fs_1 = __importDefault(require("fs"));
@@ -122,6 +123,7 @@ function productionDashboardAdapters(context) {
             return {
                 execution: history.cycles.map((cycle) => cycleFinding('execution', 'Static preflight', cycle, cycle.cycleState === 'blocked')),
                 qa: history.cycles.map((cycle) => cycleFinding('qa', 'Sensors', cycle, cycle.qa.fixes < cycle.qa.findings)),
+                docs: history.cycles.map((cycle) => cycleFinding('docs', 'Documentation', cycle, !lifecycleForCycle(cycle).markers.docsComplete)),
                 retro: history.cycles.map((cycle) => cycleFinding('retro', 'Project context', cycle, cycle.plan.state !== 'executed')),
             };
         },
@@ -144,25 +146,32 @@ function journalExecutionFinding(overlay) {
                 id: 'execution.current-journal', label: 'Static preflight', state: blocked ? 'attention' : 'ok',
                 ...(blocked ? { remediation: BLOCKED_CYCLE_REMEDIATION, remediationVerified: true } : {}),
             }],
-        qa: [], retro: [],
+        qa: [], docs: [], retro: [],
     };
 }
 function lifecycleForJournal(overlay) {
-    return { journal: { state: overlay.state }, markers: { qaComplete: false, retroComplete: false }, tasks: overlay.tasks };
+    return { journal: { state: overlay.state }, markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: overlay.tasks };
 }
+/** Reconstructs a PlanStateInput (markers + tasks) from a stored historical
+ * evidence record's plan.state for display purposes — the inverse of the
+ * live→durable direction. `retro_pending` predates the docs phase: that
+ * evidence was written before `docsComplete` existed, so treating it as
+ * docs-done is the only non-regressive reading; reconstructing it as
+ * `docsComplete: false` would invent retroactive docs debt on every
+ * historical cycle. */
 function lifecycleForCycle(cycle) {
     const total = cycle.tasks.length;
     if (cycle.plan.state === 'blocked' || cycle.cycleState === 'blocked')
-        return { journal: { state: 'blocked' }, markers: { qaComplete: false, retroComplete: false }, tasks: { total, completed: 0 } };
+        return { journal: { state: 'blocked' }, markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total, completed: 0 } };
     if (cycle.plan.state === 'active')
-        return { journal: { state: 'active' }, markers: { qaComplete: false, retroComplete: false }, tasks: { total, completed: 0 } };
+        return { journal: { state: 'active' }, markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total, completed: 0 } };
     if (cycle.plan.state === 'executed')
-        return { markers: { qaComplete: true, retroComplete: true }, tasks: { total, completed: total } };
+        return { markers: { qaComplete: true, docsComplete: true, retroComplete: true }, tasks: { total, completed: total } };
     if (cycle.plan.state === 'retro_pending')
-        return { markers: { qaComplete: true, retroComplete: false }, tasks: { total, completed: total } };
+        return { markers: { qaComplete: true, docsComplete: true, retroComplete: false }, tasks: { total, completed: total } };
     if (cycle.plan.state === 'qa_pending')
-        return { markers: { qaComplete: false, retroComplete: false }, tasks: { total, completed: total } };
-    return { markers: { qaComplete: false, retroComplete: false }, tasks: { total: 0, completed: 0 } };
+        return { markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total, completed: total } };
+    return { markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total: 0, completed: 0 } };
 }
 function cycleFinding(section, label, cycle, actionable) {
     return {
@@ -330,7 +339,7 @@ function collectDashboardSnapshot(options) {
     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] });
+        return (0, validate_1.validateDashboardSnapshotV1)({ schema: 2, 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 })));
@@ -345,6 +354,7 @@ function collectDashboardSnapshot(options) {
         ? { ...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 docsItems = isolatedFindings(execution?.docs);
     const retroItems = isolatedFindings(execution?.retro);
     const evidenceResult = optional(() => evidenceHistoryItems(root));
     const executionUnavailable = !executionResult.failed && execution === undefined;
@@ -355,12 +365,17 @@ function collectDashboardSnapshot(options) {
         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
+        // There is no read-only QA, docs, 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('docs', executionResult.failed || executionUnavailable || docsItems.failed ? 'unavailable' : 'available', docsItems.value),
         section('retro', executionResult.failed || executionUnavailable || retroItems.failed ? 'unavailable' : 'available', retroItems.value),
         section('history', evidenceResult.failed ? 'unavailable' : 'available', evidenceResult.failed ? [] : evidenceResult.value.items),
+        // `processes` is a reserved section id with no adapter yet: a later
+        // release (R1) populates it. `not_applicable` here means exactly
+        // "this section doesn't apply here", not dead code.
+        section('processes', 'not_applicable', []),
     ];
     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 });
+    return (0, validate_1.validateDashboardSnapshotV1)({ schema: 2, 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

@@ -13,12 +13,12 @@ function classifyPlanState(input) {
     assertRecord(input, 'state input');
     assertKeys(input, 'state input', ['journal', 'markers', 'tasks']);
     assertRecord(input.markers, 'markers');
-    assertKeys(input.markers, 'markers', ['qaComplete', 'retroComplete']);
+    assertKeys(input.markers, 'markers', ['qaComplete', 'docsComplete', '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')
+    if (typeof markers.qaComplete !== 'boolean' || typeof markers.docsComplete !== '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');
@@ -36,8 +36,10 @@ function classifyPlanState(input) {
         return 'active';
     if (markers.retroComplete)
         return 'executed';
-    if (markers.qaComplete)
+    if (markers.docsComplete)
         return 'retro_pending';
+    if (markers.qaComplete)
+        return 'docs_pending';
     if (tasks.total > 0 && tasks.completed === tasks.total)
         return 'qa_pending';
     return 'legacy_unverifiable';

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

@@ -4,7 +4,7 @@ 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 SECTION_TITLES = { machine: 'Machine / install', project: 'Project readiness', planning: 'Design / planning', execution: 'Execution', qa: 'QA', docs: 'Docs', retro: 'Retro', history: 'Final / history', processes: 'Processes' };
 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;'); }
@@ -55,7 +55,7 @@ function projectEvidenceComposition(snapshot) {
     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 stageSections = ['planning', 'execution', 'qa', 'docs', 'retro', 'history'];
     const byId = new Map(snapshot.sections.map((section) => [section.id, section]));
     const stages = stageSections.map((id) => {
         const section = byId.get(id);

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

@@ -8,8 +8,10 @@ const SECTION_TITLES = {
     planning: 'Design / planning',
     execution: 'Execution',
     qa: 'QA',
+    docs: 'Docs',
     retro: 'Retro',
     history: 'Final / history',
+    processes: 'Processes',
 };
 const STATE_PRESENTATION = {
     ok: { glyph: '✔', text: 'ok' },

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

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanitizeDashboardSource = sanitizeDashboardSource;
 const crypto_1 = require("crypto");
 const STATES = new Set(['ok', 'attention', 'missing', 'unavailable', 'not_applicable', 'active', 'blocked']);
-const ALLOWED_KEYS = new Set(['findings', 'label', 'id', 'state', 'detail', 'remediation', 'remediationVerified', 'execution', 'qa', 'retro', 'history', 'lifecycle', 'journal', 'markers', 'tasks', 'total', 'completed', 'qaComplete', 'retroComplete']);
+const ALLOWED_KEYS = new Set(['findings', 'label', 'id', 'state', 'detail', 'remediation', 'remediationVerified', 'execution', 'qa', 'docs', 'retro', 'history', 'lifecycle', 'journal', 'markers', 'tasks', 'total', 'completed', 'qaComplete', 'docsComplete', 'retroComplete']);
 const CANONICAL_LABELS = new Set([
     'Preferences', 'Registries', 'Profile', 'Sensors', 'Optional source unavailable',
-    'Extensions', 'Registry pins', 'Active bundles', 'Project context', 'Constitution', 'Static preflight',
+    'Extensions', 'Registry pins', 'Active bundles', 'Project context', 'Constitution', 'Static preflight', 'Documentation',
 ]);
 const CANONICAL_FINDING_IDS = new Set([
     'machine.preferences.missing', 'machine.registries.stale', 'project.profile.missing',

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dashboardSnapshot = dashboardSnapshot;
-const PROJECT_SECTION_IDS = ['machine', 'project', 'planning', 'execution', 'qa', 'retro', 'history'];
+const PROJECT_SECTION_IDS = ['machine', 'project', 'planning', 'execution', 'qa', 'docs', 'retro', 'history', 'processes'];
 /** Safe, deterministic V1 fixture and renderer input. */
 function dashboardSnapshot(overrides = {}) {
     const { project: projectOverride, sections: sectionsOverride, ...rest } = overrides;
@@ -10,7 +10,7 @@ function dashboardSnapshot(overrides = {}) {
         ? PROJECT_SECTION_IDS.map((id) => ({ id, availability: id === 'machine' ? 'available' : 'not_applicable', items: [] }))
         : [{ id: 'machine', availability: 'available', items: [] }]);
     return {
-        schema: 1,
+        schema: 2,
         generatedAt: '2026-08-22T00:00:00.000Z',
         overall: 'healthy',
         project,

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DashboardValidationError = void 0;
 exports.validateDashboardSnapshotV1 = validateDashboardSnapshotV1;
-const SECTION_ORDER = ['machine', 'project', 'planning', 'execution', 'qa', 'retro', 'history'];
+const SECTION_ORDER = ['machine', 'project', 'planning', 'execution', 'qa', 'docs', 'retro', 'history', 'processes'];
 const ITEM_STATES = ['ok', 'attention', 'missing', 'unavailable', 'not_applicable'];
 const AVAILABILITIES = ['available', 'unavailable', 'not_applicable'];
 const OVERALLS = ['healthy', 'degraded'];
@@ -42,8 +42,8 @@ function assertEnum(value, values, path) {
 function validateDashboardSnapshotV1(value) {
     assertRecord(value, 'snapshot');
     assertOnlyKeys(value, ['schema', 'generatedAt', 'overall', 'project', 'confidence', 'sections'], 'snapshot');
-    if (value.schema !== 1)
-        throw new DashboardValidationError('schema must be version 1');
+    if (value.schema !== 2)
+        throw new DashboardValidationError('schema must be version 2');
     assertNonEmptyString(value.generatedAt, 'generatedAt');
     if (Number.isNaN(Date.parse(value.generatedAt)))
         throw new DashboardValidationError('generatedAt must be a valid date-time');

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

@@ -5,11 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const collect_1 = require("../../../src/core/dashboard/collect");
 const sanitize_1 = require("../../../src/core/dashboard/sanitize");
+const plan_state_1 = require("../../../src/core/dashboard/plan-state");
 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"));
+function lifecycleForCycleFixture(planState) {
+    const cycle = { ...(0, evidence_fixtures_1.cycleEvidenceFixture)(), schema: 1, plan: { ref: 'plans/current.md', state: planState }, retries: 0, cureEfficacy: [] };
+    return (0, collect_1.lifecycleForCycle)(cycle);
+}
 const fixedNow = '2026-08-22T00:00:00.000Z';
 describe('collectDashboardSnapshot', () => {
     it('returns only a healthy machine section outside a project', () => {
@@ -46,12 +51,22 @@ describe('collectDashboardSnapshot', () => {
                 execution: () => ({}),
             },
         });
-        expect(snapshot.sections.map((section) => section.id)).toEqual(['machine', 'project', 'planning', 'execution', 'qa', 'retro', 'history']);
+        expect(snapshot.sections.map((section) => section.id)).toEqual(// verifies R6.3
+        ['machine', 'project', 'planning', 'execution', 'qa', 'docs', 'retro', 'history', 'processes']);
         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(0);
         expect(JSON.stringify(snapshot)).not.toMatch(/score|ranking/i);
     });
+    it('el snapshot declara schema 2', () => {
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        expect(snapshot.schema).toBe(2);
+    });
+    it('processes queda declarada no aplicable hasta R1', () => {
+        const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined } });
+        const processes = snapshot.sections.find((section) => section.id === 'processes');
+        expect(processes).toEqual({ id: 'processes', availability: 'not_applicable', items: [] });
+    });
     it('isolates optional adapter failures and omits unverified remediation', () => {
         const snapshot = (0, collect_1.collectDashboardSnapshot)({
             cwd: process.cwd(), now: fixedNow,
@@ -70,7 +85,7 @@ describe('collectDashboardSnapshot', () => {
             cwd: process.cwd(), now: fixedNow,
             adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [], execution: () => undefined },
         });
-        for (const id of ['execution', 'qa', 'retro']) {
+        for (const id of ['execution', 'qa', 'docs', 'retro']) {
             expect(snapshot.sections.find((section) => section.id === id)?.availability).toBe('unavailable');
         }
     });
@@ -91,7 +106,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'])('isolates malformed %s findings', (key) => {
+    it.each(['execution', 'qa', 'docs', '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');
     });
@@ -133,12 +148,12 @@ describe('collectDashboardSnapshot', () => {
         expect(snapshot.sections[0].items.map((item) => item.id)).toEqual(['machine.preferences.missing', 'machine.registries.stale']);
     });
     it.each(['blocked', 'active', 'executed', 'retro_pending', 'qa_pending', 'legacy_unverifiable'])('integrates lifecycle state %s into plan detail', (expected) => {
-        const lifecycle = expected === 'blocked' ? { journal: { state: 'blocked' }, markers: { qaComplete: false, retroComplete: false }, tasks: { total: 1, completed: 0 } }
-            : expected === 'active' ? { journal: { state: 'active' }, markers: { qaComplete: false, retroComplete: false }, tasks: { total: 1, completed: 0 } }
-                : expected === 'executed' ? { markers: { qaComplete: true, retroComplete: true }, tasks: { total: 1, completed: 1 } }
-                    : expected === 'retro_pending' ? { markers: { qaComplete: true, retroComplete: false }, tasks: { total: 1, completed: 1 } }
-                        : expected === 'qa_pending' ? { markers: { qaComplete: false, retroComplete: false }, tasks: { total: 1, completed: 1 } }
-                            : { markers: { qaComplete: false, retroComplete: false }, tasks: { total: 0, completed: 0 } };
+        const lifecycle = expected === 'blocked' ? { journal: { state: 'blocked' }, markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total: 1, completed: 0 } }
+            : expected === 'active' ? { journal: { state: 'active' }, markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total: 1, completed: 0 } }
+                : expected === 'executed' ? { markers: { qaComplete: true, docsComplete: true, retroComplete: true }, tasks: { total: 1, completed: 1 } }
+                    : expected === 'retro_pending' ? { markers: { qaComplete: true, docsComplete: true, retroComplete: false }, tasks: { total: 1, completed: 1 } }
+                        : expected === 'qa_pending' ? { markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total: 1, completed: 1 } }
+                            : { markers: { qaComplete: false, docsComplete: false, retroComplete: false }, tasks: { total: 0, completed: 0 } };
         const snapshot = (0, collect_1.collectDashboardSnapshot)({ cwd: process.cwd(), now: fixedNow, adapters: { machine: () => ({ findings: [] }), project: () => ({ findings: [] }), plans: () => [{ id: 'plan.lifecycle', label: 'Profile', state: 'ok', lifecycle }], execution: () => undefined } });
         expect(snapshot.sections.find((section) => section.id === 'planning')?.items[0].detail).toBe(expected);
     });
@@ -246,6 +261,19 @@ describe('sanitizeDashboardSource', () => {
         expect(JSON.stringify(safe)).not.toMatch(/Error|ghp_|\/tmp|TOKEN=/i);
         expect(JSON.stringify(safe)).not.toContain('detail');
     });
+    it('sanitize conserva docsComplete', () => {
+        const cleaned = (0, sanitize_1.sanitizeDashboardSource)({
+            lifecycle: { markers: { qaComplete: true, docsComplete: true, retroComplete: false }, tasks: { total: 1, completed: 1 } },
+        });
+        expect(cleaned.lifecycle.markers.docsComplete).toBe(true);
+    });
+    it('un ciclo historico retro_pending no retrocede a docs_pending', () => {
+        // Evidencia escrita antes de que existiera la fase: docs se considera hecho.
+        expect((0, plan_state_1.classifyPlanState)(lifecycleForCycleFixture('retro_pending'))).toBe('retro_pending');
+    });
+    it.each(['blocked', 'active', 'executed', 'qa_pending', 'legacy_unverifiable'])('lifecycleForCycle reconstruye %s de forma que classifyPlanState lo re-deriva igual', (planState) => {
+        expect((0, plan_state_1.classifyPlanState)(lifecycleForCycleFixture(planState))).toBe(planState);
+    });
 });
 test('exports canonical remediation commands', () => {
     expect(collect_1.REMEDIATION_BY_FINDING_ID['machine.preferences.missing']).toBe('awm init');

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

@@ -4,7 +4,7 @@ const validate_1 = require("../../../src/core/dashboard/validate");
 const types_1 = require("../../../src/core/dashboard/types");
 function snapshot() {
     return {
-        schema: 1,
+        schema: 2,
         generatedAt: '2026-08-22T00:00:00.000Z',
         overall: 'healthy',
         project: { detected: true, label: 'Demo project' },
@@ -15,15 +15,17 @@ function snapshot() {
             { id: 'planning', availability: 'not_applicable', items: [] },
             { id: 'execution', availability: 'not_applicable', items: [] },
             { id: 'qa', availability: 'not_applicable', items: [] },
+            { id: 'docs', availability: 'not_applicable', items: [] },
             { id: 'retro', availability: 'not_applicable', items: [] },
             { id: 'history', availability: 'not_applicable', items: [] },
+            { id: 'processes', availability: 'not_applicable', items: [] },
         ],
     };
 }
 describe('validateDashboardSnapshotV1', () => {
     it('creates the safe deterministic dashboard snapshot default', () => {
         expect((0, types_1.dashboardSnapshot)()).toEqual({
-            schema: 1,
+            schema: 2,
             generatedAt: '2026-08-22T00:00:00.000Z',
             overall: 'healthy',
             project: { detected: false, label: 'No project detected' },
@@ -36,7 +38,7 @@ describe('validateDashboardSnapshotV1', () => {
     });
     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']);
+        expect((0, validate_1.validateDashboardSnapshotV1)(value).sections.map((section) => section.id)).toEqual(['machine', 'project', 'planning', 'execution', 'qa', 'docs', 'retro', 'history', 'processes']);
     });
     it('returns a valid V1 snapshot', () => {
         expect((0, validate_1.validateDashboardSnapshotV1)(snapshot())).toEqual(snapshot());
@@ -53,7 +55,7 @@ describe('validateDashboardSnapshotV1', () => {
     });
     it('rejects an invalid schema version', () => {
         const value = snapshot();
-        value.schema = 2;
+        value.schema = 3;
         expect(() => (0, validate_1.validateDashboardSnapshotV1)(value)).toThrow(validate_1.DashboardValidationError);
     });
     it('rejects invalid public enums', () => {

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

@@ -1,17 +1,17 @@
 "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 } };
+const base = { journal: undefined, markers: { qaComplete: false, docsComplete: 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');
+        expect((0, plan_state_1.classifyPlanState)({ ...base, journal: { state: 'blocked' }, markers: { qaComplete: true, docsComplete: 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');
+        expect((0, plan_state_1.classifyPlanState)({ ...base, journal: { state: 'active' }, markers: { qaComplete: true, docsComplete: 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, markers: { qaComplete: true, docsComplete: true, retroComplete: true } }, 'executed'],
+        [{ ...base, markers: { qaComplete: true, docsComplete: true, retroComplete: false } }, 'retro_pending'],
         [{ ...base, tasks: { total: 2, completed: 2 } }, 'qa_pending'],
         [base, 'legacy_unverifiable'],
     ])('classifies lifecycle state %s', (input, expected) => {
@@ -30,3 +30,41 @@ describe('classifyPlanState', () => {
         expect(() => (0, plan_state_1.classifyPlanState)(input)).toThrow(error);
     });
 });
+describe('fase de documentacion', () => {
+    it('clasifica docs_pending con QA hecha y documentacion pendiente', () => {
+        expect((0, plan_state_1.classifyPlanState)({
+            markers: { qaComplete: true, docsComplete: false, retroComplete: false },
+            tasks: { total: 3, completed: 3 },
+        })).toBe('docs_pending');
+    });
+    it('vuelve a retro_pending cuando la documentacion esta hecha', () => {
+        expect((0, plan_state_1.classifyPlanState)({
+            markers: { qaComplete: true, docsComplete: true, retroComplete: false },
+            tasks: { total: 3, completed: 3 },
+        })).toBe('retro_pending');
+    });
+    it('conserva executed con retro hecho — el significado no cambia', () => {
+        expect((0, plan_state_1.classifyPlanState)({
+            markers: { qaComplete: true, docsComplete: true, retroComplete: true },
+            tasks: { total: 3, completed: 3 },
+        })).toBe('executed');
+    });
+    it('rechaza un marker desconocido', () => {
+        expect(() => (0, plan_state_1.classifyPlanState)({
+            markers: { qaComplete: true, docsComplete: false, retroComplete: false, bogusComplete: true },
+            tasks: { total: 1, completed: 1 },
+        })).toThrow(/unsupported fields/);
+    });
+    it('rechaza docsComplete no booleano', () => {
+        expect(() => (0, plan_state_1.classifyPlanState)({
+            markers: { qaComplete: true, docsComplete: 'yes', retroComplete: false },
+            tasks: { total: 1, completed: 1 },
+        })).toThrow(/must be boolean/);
+    });
+    it('docsComplete solo, sin qaComplete, ya alcanza retro_pending — el orden de la cadena no exige qaComplete primero', () => {
+        expect((0, plan_state_1.classifyPlanState)({
+            markers: { qaComplete: false, docsComplete: true, retroComplete: false },
+            tasks: { total: 3, completed: 3 },
+        })).toBe('retro_pending');
+    });
+});

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

@@ -99,11 +99,29 @@ describe('productionDashboardAdapters', () => {
         expect(snapshot.sections.find((section) => section.id === 'qa')?.items).toEqual([
             expect.objectContaining({ state: 'ok' }),
         ]);
+        expect(snapshot.sections.find((section) => section.id === 'docs')?.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('flags the docs section as attention when a captured cycle has not documented yet', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-dashboard-docs-attention-'));
+        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: 'qa_pending' },
+        });
+        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 === 'docs')?.items).toEqual([
+            expect.objectContaining({ state: 'attention' }),
+        ]);
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
     it.each([
         ['IN_PROGRESS', 'active', 'ok'],
         ['BLOCKED', 'blocked', 'attention'],

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

@@ -13,8 +13,10 @@ function snapshot(overrides = {}) {
             { id: 'planning', availability: 'available', items: [] },
             { id: 'execution', availability: 'available', items: [] },
             { id: 'qa', availability: 'available', items: [] },
+            { id: 'docs', availability: 'available', items: [] },
             { id: 'retro', availability: 'available', items: [] },
             { id: 'history', availability: 'available', items: [] },
+            { id: 'processes', availability: 'not_applicable', items: [] },
         ],
         ...overrides,
     });
@@ -27,7 +29,9 @@ describe('renderDashboardHtml', () => {
                 { 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: 'docs', availability: 'not_applicable', items: [] },
                 { id: 'retro', availability: 'not_applicable', items: [] }, { id: 'history', availability: 'not_applicable', items: [] },
+                { id: 'processes', 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'">`);
@@ -153,7 +157,7 @@ describe('renderDashboardHtml', () => {
     });
     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 ids = ['machine', 'project', 'planning', 'execution', 'qa', 'docs', 'retro', 'history', 'processes'];
         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);
@@ -162,7 +166,7 @@ describe('renderDashboardHtml', () => {
         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) => ({
+        const sections = ['machine', 'project', 'planning', 'execution', 'qa', 'docs', 'retro', 'history', 'processes'].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' })) : [],
         }));
@@ -178,8 +182,9 @@ describe('renderDashboardHtml', () => {
             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: 'execution', availability: 'available', items: [] }, { id: 'qa', availability: 'available', items: [] }, { id: 'docs', 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' }] },
+                { id: 'processes', availability: 'not_applicable', items: [] },
             ],
         })));
         expect(html).toContain('Confidence: supported');

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

@@ -14,8 +14,10 @@ function completeSnapshot(overrides = {}) {
             { 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: 'docs', availability: 'available', items: [{ id: 'docs.marker', label: 'Documentation', state: 'not_applicable' }] },
             { 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' }] },
+            { id: 'processes', availability: 'not_applicable', items: [] },
         ],
         ...overrides,
     });
@@ -23,7 +25,7 @@ function completeSnapshot(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'];
+        const headings = ['Machine / install', 'Project readiness', 'Design / planning', 'Execution', 'QA', 'Docs', 'Retro', 'Final / history', 'Processes'];
         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]));
@@ -53,8 +55,10 @@ describe('renderFullTerminal', () => {
                 { id: 'planning', availability: 'available', items: [] },
                 { id: 'execution', availability: 'available', items: execution },
                 { id: 'qa', availability: 'available', items: [] },
+                { id: 'docs', availability: 'available', items: [] },
                 { id: 'retro', availability: 'available', items: [] },
                 { id: 'history', availability: 'available', items: history },
+                { id: 'processes', availability: 'not_applicable', items: [] },
             ] }));
         const first = (0, render_terminal_1.renderFullTerminal)(snapshot);
         expect((0, render_terminal_1.renderFullTerminal)(snapshot)).toBe(first);

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

@@ -7,6 +7,8 @@ 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");
+const types_1 = require("../../../src/core/evidence/types");
+const completeJournal = { journalId: 'ignored', cycle: { status: 'COMPLETE', startedAt: '2026-08-22T10:00:00.000Z', completedAt: '2026-08-22T10:00:01.000Z' }, tasks: [], verdicts: [], fixes: [], jobs: {}, cycleVerificationPlan: [] };
 describe('evidence capture CLI boundary', () => {
     let root;
     beforeEach(() => { root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-evidence-command-')); });
@@ -57,4 +59,54 @@ describe('evidence capture CLI boundary', () => {
         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) }));
     });
+    test('sin el marker de docs, el estado vivo seria docs_pending — se remapea a retro_pending en la evidencia', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# Plan\n<!-- awm-qa-complete: 2026-08-23 -->\n- [x] Task 1\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: completeJournal, 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('lee el marker awm-docs-complete del plan — sin awm-qa-complete, docsComplete solo alcanza para retro_pending', () => {
+        // Discrimina de verdad: si el parser NO leyera awm-docs-complete, este plan (sin qa-complete,
+        // sin retro-complete) clasificaria qa_pending por conteo de tasks. Si SI lo lee, va directo a
+        // retro_pending — la unica forma de que este resultado ocurra es que el marker se haya parseado.
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# Plan\n<!-- awm-docs-complete: 2026-08-23 -->\n- [x] Task 1\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: completeJournal, 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('no deja que un awm-docs-complete de otro release clasifique el release actual', () => {
+        // Mismo patron que el test analogo de qa/retro: el marker debe respetar el scoping por release.
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# plan\n<!-- awm-docs-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('no filtra docs_pending al registro durable de evidencia', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# Plan\n<!-- awm-qa-complete: 2026-08-23 -->\n- [x] Task 1\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: completeJournal, ledger: [] });
+        expect(result.code).toBe(0);
+        expect(types_1.PLAN_STATES).not.toContain('docs_pending');
+        const state = JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, '.awm', 'evidence', 'cycles', result.stdout.trim() + '.json'), 'utf8')).plan.state;
+        expect(types_1.PLAN_STATES).toContain(state);
+    });
+    test('con docs y retro completos el estado sigue siendo executed', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), '# Plan\n<!-- awm-qa-complete: 2026-08-23 -->\n<!-- awm-docs-complete: 2026-08-23 -->\n<!-- awm-retro-complete: 2026-08-23 -->\n- [x] Task 1\n');
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: completeJournal, 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('executed');
+    });
+    test('un marker sin cerrar y muy largo no cuelga el parseo (ReDoS)', () => {
+        // Regresion: el regex original tenia \s* adyacente al grupo lazo [^\r\n]*?,
+        // lo que producia backtracking catastrofico ante una linea larga sin "-->".
+        const unterminated = `<!-- awm-qa-complete: ${' '.repeat(200000)}`;
+        fs_1.default.writeFileSync(path_1.default.join(root, 'plan.md'), `# Plan\n${unterminated}\n- [x] Task 1\n`);
+        const start = Date.now();
+        const result = (0, evidence_1.runEvidenceCapture)(root, 'plan.md', { repositoryIdentity: 'git@example.test:team/repository.git', journal: completeJournal, ledger: [] });
+        const elapsedMs = Date.now() - start;
+        expect(elapsedMs).toBeLessThan(1000);
+        expect(result.code).toBe(0);
+        // linea sin cerrar: el marker no matchea, y sin awm-qa-complete el plan
+        // no llega a docs_pending/retro_pending por conteo de tasks (1/1 completa).
+        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');
+    });
 });

package/dist/tests/structural/documentation-phase-is-mechanized.test.js

@@ -0,0 +1,29 @@
+"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 path_1 = __importDefault(require("path"));
+const ROOT = path_1.default.resolve(__dirname, '../../..');
+const read = (file) => fs_1.default.readFileSync(path_1.default.join(ROOT, file), 'utf8');
+describe('la fase de documentacion esta mecanizada, no solo enunciada', () => {
+    it('CONSTITUTION.md enuncia la regla y nombra el marker', () => {
+        const text = read('CONSTITUTION.md');
+        expect(text).toMatch(/awm-docs-complete/);
+        expect(text).toMatch(/post-implementation-docs/);
+    });
+    it('CONSTITUTION.md apunta al mecanismo, no lo reemplaza', () => {
+        const text = read('CONSTITUTION.md');
+        // debe citar el archivo que efectivamente hace cumplir la regla
+        expect(text).toMatch(/plan-state\.ts/);
+        expect(text).toMatch(/development-process/);
+    });
+    it('el enunciado NO es el unico lugar donde la fase existe', () => {
+        // Si esto pasa solo por CONSTITUTION.md, la regla es decorativa.
+        expect(read('cli/src/core/dashboard/plan-state.ts')).toMatch(/docsComplete/);
+        expect(read('cli/src/core/dashboard/plan-state.ts')).toMatch(/docs_pending/);
+        expect(read('cli/src/core/dashboard/sanitize.ts')).toMatch(/docsComplete/);
+        expect(read('cli/src/commands/evidence/index.ts')).toMatch(/awm-docs-complete/);
+    });
+});

package/dist/tests/structural/r3-cli-major-version.test.js

@@ -8,7 +8,6 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const CLI_ROOT = path_1.default.resolve(__dirname, '../..');
 const DIST_ENTRYPOINT = path_1.default.join(CLI_ROOT, 'dist', 'src', 'index.js');
-const R3_MAJOR_VERSION = 8;
 function readJson(file) {
     return JSON.parse(fs_1.default.readFileSync(path_1.default.join(CLI_ROOT, file), 'utf8'));
 }
@@ -22,13 +21,19 @@ function runCompiledCli(...args) {
     return `${result.stdout}${result.stderr}`;
 }
 describe('R3 public major CLI release contract', () => {
-    it('retains the R3 major version consistently in package metadata and the lockfile root', () => {
+    // #92: the bump wrote only package.json, so the lockfile trailed by one
+    // version on EVERY release. This is the real invariant — package.json,
+    // package-lock.json, and its root entry must always agree. A hardcoded
+    // expected major (originally 8, from when this test was written) goes
+    // stale on every legitimate `!:`/BREAKING major bump and was never the
+    // actual contract, so it isn't asserted here.
+    it('retains a consistent version across package metadata and the lockfile root', () => {
         const pkg = readJson('package.json');
         const lock = readJson('package-lock.json');
         const root = lock.packages[''];
         const version = pkg.version;
         expect(typeof version).toBe('string');
-        expect(version).toMatch(new RegExp(`^${R3_MAJOR_VERSION}\\.`));
+        expect(version).toMatch(/^\d+\.\d+\.\d+$/);
         expect(lock.version).toBe(version);
         expect(root.version).toBe(version);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "8.5.2",
+  "version": "9.0.1",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"