cabloy 5.1.200 → 5.1.202

package/repo-agent-governance/tools/spec-audit/audit.mjs

@@ -4,6 +4,8 @@ import { fileURLToPath } from 'node:url';
 
 import {
   findIdentifiers,
+  isPlanningCompleteEligible,
+  isPrerequisiteSatisfied,
   markdownLines,
   parseDefinitions,
   parseProgress,
@@ -71,6 +73,46 @@ function addMapping(groups, edges, definitions) {
   }
 }
 
+function traceabilityException(definition, report, annotatedLines) {
+  const fields = markdownLines(definition.body ?? '').flatMap(({ text, line }) =>
+    Array.from(text.matchAll(/\bTraceability\s+exception\b/gi), match => ({
+      text,
+      line,
+      start: match.index,
+    })),
+  );
+  if (!fields.length) return null;
+  for (const field of fields) {
+    const line = definition.line + field.line - (definition.kind === 'WBS' ? 0 : 1);
+    annotatedLines.add(`${definition.file}:${line}`);
+  }
+  const field = fields[0];
+  const value =
+    definition.kind === 'bullet' && field.line === 1
+      ? field.text.slice(field.start).trim()
+      : field.text.trim();
+  const match = value.match(/^Traceability exception:\s*(technical-only|authority-only)\s+—\s+/i);
+  const exception = match?.[1].toLowerCase();
+  const rationale = match && value.slice(match[0].length);
+  const validOwner =
+    (exception === 'technical-only' &&
+      definition.id.startsWith('SRS-') &&
+      definition.kind === 'bullet' &&
+      field.line === 1) ||
+    (exception === 'authority-only' && definition.id.startsWith('WBS-'));
+  if (fields.length !== 1 || !validOwner || !/[\p{L}\p{N}]/u.test(rationale ?? '')) {
+    report(
+      'traceability-exception',
+      definition.file,
+      definition.line + field.line - (definition.kind === 'WBS' ? 0 : 1),
+      'Invalid Traceability exception: use one declaration-local technical-only SRS or authority-only WBS field with a rationale.',
+      definition.id,
+    );
+    return null;
+  }
+  return exception;
+}
+
 function collectMappings(records, definitions) {
   const edges = new Map(Array.from(definitions.keys(), id => [id, new Set()]));
   for (const definition of definitions.values()) {
@@ -120,6 +162,116 @@ function collectMappings(records, definitions) {
   return edges;
 }
 
+function acceptedDecision(markdown) {
+  if (!markdown) return false;
+  const lines = markdownLines(markdown);
+  const statuses = [];
+  let section = null;
+  for (const [index, { text, heading }] of lines.entries()) {
+    if (heading?.level === 2) section = heading.text;
+    const field = text.match(/^\s*-\s*\*\*Status:\*\*/i);
+    if (field && (section === null || /^Status$/i.test(section)))
+      statuses.push(text.slice(field[0].length).trim());
+    if (!heading || !/^Status$/i.test(heading.text)) continue;
+    const value = lines.slice(index + 1).find(record => {
+      if (record.heading && record.heading.level <= heading.level) return true;
+      return record.text.trim();
+    });
+    if (value && !(value.heading && value.heading.level <= heading.level))
+      statuses.push(value.text.trim());
+  }
+  return statuses.length > 0 && statuses.every(status => /^Accepted\.?$/i.test(status));
+}
+
+function planningBaselineGates(records, wbs, edges, exceptions, report) {
+  const gates = new Set();
+  const field = /^\s*(?:-\s*)?(?:\*\*)?Traceability mode(?:\*\*)?\s*:/i;
+  const declarations = new Map();
+  for (const [file, markdown] of records) {
+    for (const { text, line } of markdownLines(markdown)) {
+      if (!field.test(text)) continue;
+      const task =
+        file === 'pdp-wbs.md'
+          ? wbs?.tasks.find(candidate => candidate.line < line && candidate.endLine >= line)
+          : null;
+      if (!task) {
+        report(
+          'traceability-mode',
+          file,
+          line,
+          'Traceability mode must be declared inside a WBS task.',
+        );
+        continue;
+      }
+      if (!declarations.has(task.id)) declarations.set(task.id, []);
+      declarations.get(task.id).push({ text, line });
+    }
+  }
+  for (const task of wbs?.tasks ?? []) {
+    const declared = declarations.get(task.id);
+    if (!declared) continue;
+    const [{ text, line }] = declared;
+    const mode = text.replace(field, '').trim().replace(/`/g, '');
+    const body = markdownLines(task.body).map(record => record.text);
+    const deliveryAction =
+      /(?:^|[,;]\s*|\b(?:and|then|to)\s+)(?:implement|deploy|migrate|release|regenerate|develop|ship|code|build\b(?!\s+risks?\b)|create|run\s+(?:an?\s+)?(?:migrations?|tests?|ATP-|scenarios?)|execute\s+(?:an?\s+)?(?:ATP-|tests?|scenarios?))\b/i;
+    const mixedScope =
+      deliveryAction.test(task.title) ||
+      body.some(value => {
+        const bullet = value.match(/^\s*[-*]\s+(.*)/);
+        return bullet && deliveryAction.test(bullet[1].replace(/^\*\*[^*]+\*\*\s*/, ''));
+      });
+    const hasItems = label =>
+      body.some((value, index) => {
+        if (value.trim().toLowerCase() !== `${label}:`) return false;
+        const next = body.slice(index + 1).find(line => line.trim());
+        return Boolean(next?.trim().match(/^[-*] \S/));
+      });
+    const authorities = body.flatMap(value => {
+      const match = value.match(/^\s*(?:-\s*)?(?:\*\*)?Review authority(?:\*\*)?\s*:/i);
+      return match ? [value.replace(match[0], '').trim()] : [];
+    });
+    const authority = authorities[0]?.match(
+      /^\[([^\]]+)\]\((\.\/decisions\/[^/()]+\.md)\)(?:\s*\([^\n]*\))?\s*\.?$/,
+    );
+    const adr = authority?.[2].slice(2);
+    const decision = adr && records.get(adr);
+    const mappedIncoming = [...edges].some(
+      ([id, targets]) => id.startsWith('SRS-') && targets.has(task.id),
+    );
+    const valid =
+      declared.length === 1 &&
+      mode === 'planning-baseline-review' &&
+      task.phase.number === '10' &&
+      /\b(?:review|freeze)\b/i.test(task.title) &&
+      /\bbaseline\b/i.test(task.title) &&
+      hasItems('tasks') &&
+      hasItems('acceptance checks') &&
+      !mixedScope &&
+      !findIdentifiers(task.title, 'SRS-').length &&
+      !findIdentifiers(task.title, 'ATP-').length &&
+      !findIdentifiers(task.body, 'SRS-').length &&
+      !findIdentifiers(task.body, 'ATP-').length &&
+      !mappedIncoming &&
+      !edges.get(task.id)?.size &&
+      !exceptions.has(task.id) &&
+      authorities.length === 1 &&
+      acceptedDecision(decision);
+    if (!valid) {
+      report(
+        'traceability-mode',
+        'pdp-wbs.md',
+        line,
+        'Planning-baseline review requires one valid mode, Phase 10 baseline review, substantive review-only Tasks and Acceptance checks, no individual SRS/ATP mapping or other traceability exception, and one accepted local ADR review authority.',
+        task.id,
+      );
+      continue;
+    }
+    gates.add(task.id);
+  }
+  return gates;
+}
+
 function headingIds(markdown) {
   const slugs = new Set();
   const counts = new Map();
@@ -271,8 +423,22 @@ export async function auditPlanning(
       report('declaration', file, 1, error.message);
     }
   }
+  const exceptions = new Map();
+  const annotatedLines = new Set();
+  for (const definition of definitions.values()) {
+    const exception = traceabilityException(definition, report, annotatedLines);
+    if (exception) exceptions.set(definition.id, exception);
+  }
   for (const [file, markdown] of records) {
     for (const { text, line } of markdownLines(markdown)) {
+      if (/\bTraceability\s+exception\b/i.test(text) && !annotatedLines.has(`${file}:${line}`)) {
+        report(
+          'traceability-exception',
+          file,
+          line,
+          'Traceability exception must be in its own formal declaration.',
+        );
+      }
       for (const prefix of OWNERS.keys()) {
         for (const id of findIdentifiers(referenceText(text), prefix)) {
           if (!definitions.has(id)) {
@@ -308,10 +474,23 @@ export async function auditPlanning(
               task.id,
             );
           }
-          if (['implementation-complete', 'verified'].includes(rows.get(task.id))) {
+          if (rows.get(task.id) === 'planning-complete' && !isPlanningCompleteEligible(task)) {
+            report(
+              'completion-mode',
+              'progress.md',
+              locations?.get(task.id)?.line ?? 1,
+              'Planning-complete requires a declaration-local Completion mode: planning-only field.',
+              task.id,
+            );
+          }
+          if (
+            ['planning-complete', 'implementation-complete', 'verified'].includes(rows.get(task.id))
+          ) {
             for (const dependency of task.dependencyIds) {
+              const predecessor = wbs.tasks.find(item => item.id === dependency);
               if (
-                ['not-started', 'in-progress', 'blocked', 'deferred'].includes(rows.get(dependency))
+                rows.has(dependency) &&
+                !isPrerequisiteSatisfied(predecessor, rows.get(dependency))
               ) {
                 report(
                   'dependency-state',
@@ -344,10 +523,11 @@ export async function auditPlanning(
   }
   if (!lightweight) {
     const edges = collectMappings(records, definitions);
+    const gates = planningBaselineGates(records, wbs, edges, exceptions, report);
     const incoming = new Set([...edges.values()].flatMap(values => [...values]));
     for (const [id, definition] of definitions) {
-      if (definition.status === 'deferred' || definition.deferred) continue;
-      if (!id.startsWith('PRD-') && !incoming.has(id)) {
+      if (definition.status === 'deferred' || definition.deferred || gates.has(id)) continue;
+      if (!id.startsWith('PRD-') && !incoming.has(id) && exceptions.get(id) !== 'technical-only') {
         report(
           'traceability-incoming',
           definition.file,
@@ -356,7 +536,11 @@ export async function auditPlanning(
           id,
         );
       }
-      if (!id.startsWith('ATP-') && !edges.get(id).size) {
+      if (
+        !id.startsWith('ATP-') &&
+        !edges.get(id).size &&
+        exceptions.get(id) !== 'authority-only'
+      ) {
         report(
           'traceability-outgoing',
           definition.file,

package/repo-agent-governance/tools/spec-charts/generate-implementation-charts.mjs

@@ -2,12 +2,20 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { basename, resolve } from 'node:path';
 
-import { markdownLines, parseAtpIds, parseProgress, parseWbs } from './spec-parser.mjs';
+import {
+  isPlanningCompleteEligible,
+  isPrerequisiteSatisfied,
+  markdownLines,
+  parseAtpIds,
+  parseProgress,
+  parseWbs,
+} from './spec-parser.mjs';
 export { parseAtpIds, parseProgress, parseWbs } from './spec-parser.mjs';
 
 const STATUS_COLORS = {
   'not-started': 'var(--blue)',
   'in-progress': 'var(--orange)',
+  'planning-complete': 'var(--teal)',
   'implementation-complete': 'var(--violet)',
   'verified': 'var(--aqua)',
   'blocked': 'var(--red)',
@@ -47,6 +55,7 @@ const COPY = {
     statuses: {
       'not-started': 'Not started',
       'in-progress': 'In progress',
+      'planning-complete': 'Planning complete',
       'implementation-complete': 'Implementation complete',
       'verified': 'Verified',
       'blocked': 'Blocked',
@@ -104,6 +113,7 @@ const COPY = {
     statuses: {
       'not-started': '未开始',
       'in-progress': '进行中',
+      'planning-complete': '规划完成',
       'implementation-complete': '实施完成',
       'verified': '已核验',
       'blocked': '受阻',
@@ -248,6 +258,11 @@ export function createChartModel({ readme, wbs, progress, testPlan }) {
     }
     task.recordedStatus = task.status;
     task.status = progressStatus;
+    if (task.status === 'planning-complete' && !isPlanningCompleteEligible(task)) {
+      throw new Error(
+        `${task.id} has planning-complete status without Completion mode: planning-only.`,
+      );
+    }
     if (task.deferred && task.status !== 'deferred') {
       throw new Error(
         `${task.id} is marked deferred in pdp-wbs.md but has progress status ${task.status}.`,
@@ -274,10 +289,10 @@ export function createChartModel({ readme, wbs, progress, testPlan }) {
   };
 }
 
-function style() {
+function style(planningComplete) {
   return `<style>
-    :root { --surface:#fcfcfb;--page:#f9f9f7;--ink:#0b0b0b;--secondary:#52514e;--muted:#898781;--grid:#e1e0d9;--axis:#c3c2b7;--blue:#2a78d6;--orange:#eb6834;--aqua:#1baf7a;--violet:#4a3aa7;--red:#e34948;--yellow:#eda100;--blue-wash:#eaf3fd;--aqua-wash:#e7f7f0; }
-    @media (prefers-color-scheme:dark) { :root { --surface:#1a1a19;--page:#0d0d0d;--ink:#fff;--secondary:#c3c2b7;--muted:#a09f99;--grid:#2c2c2a;--axis:#383835;--blue:#3987e5;--orange:#d95926;--aqua:#199e70;--violet:#9085e9;--red:#e66767;--yellow:#c98500;--blue-wash:#172435;--aqua-wash:#122b23; } }
+    :root { --surface:#fcfcfb;--page:#f9f9f7;--ink:#0b0b0b;--secondary:#52514e;--muted:#898781;--grid:#e1e0d9;--axis:#c3c2b7;--blue:#2a78d6;--orange:#eb6834;${planningComplete ? '--teal:#087f83;' : ''}--aqua:#1baf7a;--violet:#4a3aa7;--red:#e34948;--yellow:#eda100;--blue-wash:#eaf3fd;--aqua-wash:#e7f7f0; }
+    @media (prefers-color-scheme:dark) { :root { --surface:#1a1a19;--page:#0d0d0d;--ink:#fff;--secondary:#c3c2b7;--muted:#a09f99;--grid:#2c2c2a;--axis:#383835;--blue:#3987e5;--orange:#d95926;${planningComplete ? '--teal:#29aeb0;' : ''}--aqua:#199e70;--violet:#9085e9;--red:#e66767;--yellow:#c98500;--blue-wash:#172435;--aqua-wash:#122b23; } }
     .canvas{fill:var(--page)}.card{fill:var(--surface);stroke:var(--grid);stroke-width:1}.title{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:27px;font-weight:700}.subtitle{fill:var(--secondary);font-family:Arial,Helvetica,sans-serif;font-size:14px}.heading{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:13px;font-weight:700}.phase{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:10px;font-weight:700}.task{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:10px}.small{fill:var(--muted);font-family:Arial,Helvetica,sans-serif;font-size:9px}.caption{fill:var(--secondary);font-family:Arial,Helvetica,sans-serif;font-size:11px}.num{fill:var(--ink);font-family:Arial,Helvetica,sans-serif;font-size:11px;font-weight:700;font-variant-numeric:tabular-nums}.grid{stroke:var(--grid);stroke-width:1;shape-rendering:crispEdges}.axis{stroke:var(--axis);stroke-width:1;shape-rendering:crispEdges}.row:focus{outline:2px solid var(--ink);outline-offset:2px}
   </style>`;
 }
@@ -302,13 +317,13 @@ function renderChartTextLines(className, x, y, lines, lineHeight) {
   return `<text class="${className}" x="${x}" y="${y}">${lines.map((line, lineIndex) => `<tspan x="${x}" dy="${lineIndex ? lineHeight : 0}">${escapeXml(line)}</tspan>`).join('')}</text>`;
 }
 
-function svgDocument(title, desc, body, height, metadata) {
+function svgDocument(title, desc, body, height, metadata, planningComplete = false) {
   return `<?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" width="1600" height="${height}" viewBox="0 0 1600 ${height}" role="img" aria-labelledby="chart-title chart-desc">
   <title id="chart-title">${escapeXml(title)}</title>
   <desc id="chart-desc">${escapeXml(desc)}</desc>
   <metadata>${escapeXml(metadata)}</metadata>
-  ${style()}
+  ${style(planningComplete)}
   ${body}
 </svg>
 `;
@@ -392,9 +407,12 @@ export function renderGantt(model, suiteName) {
       },
     )
     .join('\n');
-  const completed = new Set(tasks.filter(task => task.status === 'verified').map(task => task.id));
+  const completed = new Set(
+    tasks.filter(task => isPrerequisiteSatisfied(task, task.status)).map(task => task.id),
+  );
   const nextTask = tasks.find(
     task =>
+      task.status !== 'planning-complete' &&
       task.status !== 'verified' &&
       task.status !== 'deferred' &&
       task.status !== 'waived' &&
@@ -418,6 +436,7 @@ export function renderGantt(model, suiteName) {
     body,
     height,
     t.metadata,
+    tasks.some(task => task.status === 'planning-complete'),
   );
 }
 

package/repo-agent-governance/tools/spec-charts/generate-implementation-charts.test.mjs

@@ -152,6 +152,88 @@ test('creates a mixed-status model with deferred scope separated', () => {
   assert.equal(model.activeTasks.length, 2);
   assert.equal(model.deferredTasks.length, 1);
   assert.equal(model.verified, 0);
+  assert.doesNotMatch(renderGantt(model, 'Demo'), /--teal:/);
+});
+
+test('planning completion requires an explicit task mode and preserves verified-only metrics', () => {
+  const wbs = files['pdp-wbs.md'].replace(
+    '#### WBS-10-01: Freeze the baseline',
+    '#### WBS-10-01: Freeze the baseline\n\nCompletion mode: planning-only.',
+  );
+  const progress = files['progress.md'].replace('`not-started`', '`planning-complete`');
+  assert.throws(
+    () =>
+      createChartModel({
+        readme: files['README.md'],
+        wbs: files['pdp-wbs.md'],
+        progress,
+        testPlan: files['test-plan.md'],
+      }),
+    /planning-complete status without Completion mode/,
+  );
+  const model = createChartModel({
+    readme: files['README.md'],
+    wbs,
+    progress,
+    testPlan: files['test-plan.md'],
+  });
+  assert.equal(model.tasks[0].completionMode, 'planning-only');
+  assert.equal(model.verified, 0);
+  const gantt = renderGantt(model, 'Demo');
+  assert.match(gantt, /Planning complete/);
+  assert.match(gantt, /--teal:#087f83/);
+  assert.doesNotMatch(renderBurndown(model, 'Demo'), /--teal:/);
+  assert.match(gantt, /class="caption" x="96" y="195">WBS-20-01: Deliver/);
+  assert.doesNotMatch(gantt, /class="caption" x="96" y="195">WBS-10-01/);
+  assert.match(renderBurndown(model, 'Demo'), />2 remaining · 0 verified</);
+  const blocked = createChartModel({
+    readme: files['README.md'],
+    wbs,
+    progress: progress.replace('`in-progress`', '`blocked`'),
+    testPlan: files['test-plan.md'],
+  });
+  assert.match(renderGantt(blocked, 'Demo'), /No dependency-ready WBS candidate is recorded/);
+  assert.equal(blocked.verified, 0);
+  const chinese = createChartModel({
+    readme: '# 中文规划\n\n完整中文记录。',
+    wbs,
+    progress,
+    testPlan: files['test-plan.md'],
+  });
+  assert.match(renderGantt(chinese, '示例'), /规划完成/);
+  assert.match(renderBurndown(chinese, '示例'), /2 剩余 · 0 已核验/);
+});
+
+test('completion mode must be unique, supported and task-local', () => {
+  const wbs = files['pdp-wbs.md'];
+  for (const value of ['unknown.', '', 'planning-only.\nCompletion mode: planning-only.']) {
+    assert.throws(
+      () => parseWbs(wbs.replace('Tasks:', `Completion mode: ${value}\n\nTasks:`)),
+      /Completion mode/,
+    );
+  }
+  assert.throws(
+    () =>
+      parseWbs(
+        wbs.replace('Dependencies: none.', 'Dependencies: none.\nCompletion mode: planning-only.'),
+      ),
+    /Completion mode must belong to a formal WBS task/,
+  );
+  assert.throws(
+    () => parseWbs(`Completion mode: planning-only.\n${wbs}`),
+    /Completion mode must belong to a formal WBS task/,
+  );
+  const progress = files['progress.md'].replace('`not-started`', '`planning-complete`');
+  assert.throws(
+    () =>
+      createChartModel({
+        readme: files['README.md'],
+        wbs: wbs.replace('Tasks:', 'Status: in-progress.\nCompletion mode: planning-only.\nTasks:'),
+        progress,
+        testPlan: files['test-plan.md'],
+      }),
+    /explicit.*Status in-progress.*planning-complete/,
+  );
 });
 
 test('selects the earliest dependency-ready WBS item', async t => {

package/repo-agent-governance/tools/spec-charts/spec-parser.mjs

@@ -2,6 +2,7 @@
 export const STATUS_ORDER = [
   'not-started',
   'in-progress',
+  'planning-complete',
   'implementation-complete',
   'verified',
   'blocked',
@@ -306,6 +307,16 @@ function normalizeStatus(value) {
   return normalized;
 }
 
+export function isPlanningCompleteEligible(task) {
+  return task.completionMode === 'planning-only';
+}
+
+export function isPrerequisiteSatisfied(task, status) {
+  return (
+    status === 'verified' || (status === 'planning-complete' && isPlanningCompleteEligible(task))
+  );
+}
+
 function reviewDateFromLine(line) {
   return (
     line.match(/(?:last reviewed|最后审查日期)\s*(?:[:：]\s*)?(\d{4}-\d{2}-\d{2})/i)?.[1] ?? null
@@ -360,7 +371,7 @@ export function parseProgress(markdown, { file } = {}) {
 }
 
 function labeledValue(record, labels) {
-  const match = record.text.trim().match(/^([A-Z]+)\s*:(.*)$/i);
+  const match = record.text.trim().match(/^([A-Z]+(?:\s+[A-Z]+)*)\s*:(.*)$/i);
   return match && labels.includes(match[1].toLowerCase()) ? match[2].trim() : null;
 }
 
@@ -502,6 +513,11 @@ export function parseWbs(markdown, { file } = {}) {
       task = null;
       inPhase = false;
     }
+    if (!task && labeledValue(record, ['completion mode']) !== null) {
+      throw new Error(
+        `Completion mode must belong to a formal WBS task at ${atLocation(record, file)}.`,
+      );
+    }
     if (!inPhase) continue;
     if (task) task.body.push(record);
     else if (!phase.tasks.length) phase.preamble.push(record);
@@ -519,6 +535,29 @@ export function parseWbs(markdown, { file } = {}) {
         ? { line: dependency.line, ...(file ? { file } : {}) }
         : undefined;
       task.phase = { number: phase.number, title: phase.title };
+      const modeRecords = task.body.filter(
+        record => labeledValue(record, ['completion mode']) !== null,
+      );
+      if (modeRecords.length > 1) {
+        throw new Error(
+          `Multiple ${task.id} Completion mode fields at ${atLocation(modeRecords[1], file)}.`,
+        );
+      }
+      const mode = modeRecords.length
+        ? labeledValue(modeRecords[0], ['completion mode'])
+            .replace(/`/g, '')
+            .replace(/\.$/, '')
+            .toLowerCase()
+        : undefined;
+      if (mode && mode !== 'planning-only') {
+        throw new Error(
+          `Unsupported ${task.id} Completion mode at ${atLocation(modeRecords[0], file)}.`,
+        );
+      }
+      if (modeRecords.length && !mode) {
+        throw new Error(`Empty ${task.id} Completion mode at ${atLocation(modeRecords[0], file)}.`);
+      }
+      task.completionMode = mode;
       const statusRecords = task.body.filter(record => labeledValue(record, ['status']) !== null);
       if (statusRecords.length > 1) {
         throw new Error(

package/repo-docs/ai/ai-spec-driven-development.md

@@ -53,6 +53,7 @@ For the detailed authority table, identifiers, and chart boundary, see [Generate
 
 **Evidence-gated delivery** means delivery status stays precise about what is known and what has been proven.
 
+- `planning-complete` means an explicitly `planning-only` WBS task's documentary checks have a named-reviewer, revision-scoped closure disposition and retained planning proof. It satisfies that task's prerequisite edge, not implementation, ATP, successor approval, or release.
 - `implementation-complete` means the source work is complete, while required ATP or release proof remains.
 - `verified` means all applicable WBS checks and ATPs have durable, linked, redacted observed evidence.
 

package/repo-docs/ai/playbook-spec-execution.md

@@ -109,11 +109,12 @@ Use the narrowest approved check first, then follow the linked ATP procedures an
 
 Use status precisely:
 
-- `in-progress` — approved implementation or verification has actually begun
+- `in-progress` — approved work or verification has actually begun
+- `planning-complete` — only an opted-in documentary/design WBS task with a named-reviewer, revision-scoped closure disposition and linked planning proof; no source or ATP closure
 - `implementation-complete` — source work is complete, but required ATP or release proof remains
 - `verified` — all applicable WBS checks and ATPs have durable, linked, redacted observed evidence
 
-A successful build, generation command, hook, manual walkthrough, screenshot, or unrelated test run is not by itself `verified` unless the authoritative test plan defines it as sufficient retained proof. Evidence is revision- and authority-scoped; mark old proof superseded or requiring rerun when relevant source or authority changes.
+`planning-complete` satisfies a predecessor dependency edge but does not unblock a task still recorded `blocked` or grant an execution dossier. Charts count only `verified` toward verified/remaining metrics. A successful build, generation command, hook, manual walkthrough, screenshot, or unrelated test run is not by itself `verified` unless the authoritative test plan defines it as sufficient retained proof. Evidence is revision- and authority-scoped; mark old proof superseded or requiring rerun when relevant source or authority changes.
 
 ## Refresh derived charts last
 

package/repo-docs/ai/playbook-spec-generation.md

@@ -115,7 +115,7 @@ PRD → SRS → WBS → ATP → Evidence
 
 A product or technical change belongs in its PRD, SRS, or accepted ADR before its WBS, acceptance, progress, evidence, and chart implications are updated. A progress entry or chart cannot introduce a requirement, resolve a contract conflict, or accept an ADR.
 
-Planning records and derived charts do not establish `implementation-complete` or `verified`. `verified` requires the applicable acceptance procedure and retained, redacted observed evidence. A generated plan, planned command, scaffold, screenshot, or unrelated check is not automatically sufficient proof.
+A WBS task may declare `Completion mode: planning-only.` only for documentary/design-only checks. It can reach `planning-complete` after an explicit named-reviewer, revision-scoped closure disposition and linked planning proof; this satisfies its dependency edge without executing source, passing future ATPs, unblocking a recorded `blocked` successor, or counting as `verified` in charts. Planning records and derived charts do not establish `implementation-complete` or `verified`. `verified` requires the applicable acceptance procedure and retained, redacted observed evidence. A generated plan, planned command, scaffold, screenshot, or unrelated check is not automatically sufficient proof.
 
 ## Check planning without claiming implementation
 

package/repo-docs/index.md

@@ -30,6 +30,12 @@ features:
     details: Organize capabilities for SSR, SPA, Web, and Admin applications with shared conventions.
 ---
 
+## Demonstrations(Videos)
+
+### 1. Can an Admin Site Use SSR? CabloyJS in Three Practical Demos (Duration: 1:16)
+
+[![CabloyJS Admin SSR video](./assets/img/cabloy-admin-ssr-cover-en.png)](https://youtu.be/786IQhRdr1I)
+
 ## Choose a reading path
 
 ### Start a project