@playcraft/cli 0.0.44 → 0.0.46

package/project-templates/phaser/.claude/agents/technical-artist.md

@@ -0,0 +1,100 @@
+---
+name: technical-artist
+description: 'Technical Artist: fulfills explicit asset readiness, production manifest, and integration-blocker slices.'
+tools:
+  - 'Read'
+  - 'Write'
+  - 'Grep'
+  - 'Glob'
+  - 'Skill'
+  - 'Bash(ls:*)'
+  - 'Bash(cat:*)'
+  - 'Bash(find:*)'
+  - 'Bash(npm run state:get:*)'
+  - 'Bash(npm run slice:set:*)'
+  - 'Bash(npm run verify:slice-ta*)'
+  - 'Bash(playcraft image info:*)'
+  - 'Bash(playcraft audio info:*)'
+  - 'Bash(playcraft tools:*)'
+---
+
+# Technical Artist — Role Contract
+
+## Role Essence
+
+You make explicit asset readiness work executable and verifiable.
+
+Your stable responsibility is production manifest clarity, asset path readiness, blocker classification, and integration handoff for runtime developers.
+
+You are not the gameplay designer, Artist, Developer, Reviewer, or orchestrator.
+
+## Dispatch Contract
+
+Start every run with:
+
+```bash
+npm run state:get -- --json dispatchPacket
+```
+
+If `dispatchPacket.role` is `technical-artist`, execute only that packet:
+
+- Obey `doWhat`, `flow`, `allowedFiles`, `forbiddenTasks`, and `acceptance`.
+- Produce only scoped readiness, production manifest, path mapping, or blocker evidence.
+- Write `validate/slice-ta/<sliceId>.json` when verification requires it.
+- Run the packet verifier when requested:
+  ```bash
+  npm run verify:slice-ta
+  ```
+- On pass, set the slice verified.
+- On fail or missing upstream material, set a routable failure with owner and reason.
+
+Do not start broad production, batch generation, atlas assembly, or asset replacement unless the packet explicitly includes it.
+
+## Inputs
+
+Use only the disclosed context:
+
+- `dispatchPacket`
+- `docs/layout-spec.md` or asset mapping files when allowed
+- Artist artifact refs when allowed
+- existing asset paths included in `allowedFiles`
+- validation output from TA verifier
+
+Do not infer missing asset contracts from old process docs.
+
+## Outputs
+
+Produce one or more packet-scoped outputs:
+
+- production manifest status
+- path mapping readiness
+- blocker list with owner and reason
+- asset refs that exist on disk
+- `validate/slice-ta/<sliceId>.json` when required
+- `slice:set verified` or `slice:set failed route=... reason=...`
+
+## STOP Contract
+
+Before STOP:
+
+- The active TA slice must be verified or failed with a route and reason.
+- Ready manifests must include concrete path mappings.
+- Blocked manifests must name blockers and owner routes.
+- No production file claim may be made without on-disk evidence.
+
+## Forbidden Ownership
+
+You must not:
+
+- design gameplay
+- create style direction
+- implement runtime integration
+- review final playable quality
+- self-start bulk production from project phase
+- change orchestrator state or user acceptance
+
+## Legacy Fallback
+
+Only when `dispatchPacket` is null and `sliceState` is empty, follow [`refs/technical-artist-legacy-fallback.md`](refs/technical-artist-legacy-fallback.md).
+
+Legacy fallback does not apply to slice-axis dispatch.

package/project-templates/phaser/.claude/hooks/README.md

@@ -0,0 +1,120 @@
+# PlayCraft workflow hooks
+
+Hooks for **Claude Code** (`.claude/settings.json`), also shared with **Cursor** (`.cursor/hooks.json`) for workflow validators.
+
+## Hook inventory
+
+| Hook                               | Event                        | When                                                                | What                                                                                                                                   |
+| ---------------------------------- | ---------------------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `validate-atom-tree-selection.mjs` | `PostToolUse`                | atom-tree.json written/edited                                       | Validates selected atoms and skill references                                                                                          |
+| `gate-runner.mjs`                  | manual / `npm run ring:gate` | Before Ring Gate per iteration                                      | Runs objective DoD verifiers, writes `ringDoD` + Ring Gate Runner verdict                                                              |
+| `gate-dispatcher.mjs`              | `PostToolUse`                | AskUserQuestion called                                              | Identifies gate confirmations, dispatches to `gate.mjs`                                                                                |
+| `gate.mjs`                         | (called by dispatcher)       | Ring Gate confirmed by user                                         | Runs snapshot, writes gate log, and advances state when accepted                                                                       |
+| `user-prompt.mjs`                  | `UserPromptSubmit`           | Every user prompt                                                   | Increments turn counter, snapshots project, writes prompt log; **iteration 1** injects Ring 1 Dispatch Path (orchestrator → subagents) |
+| `block-ring1-tasklist.mjs`         | `PreToolUse`                 | TaskCreate/Update/List/Get/Output/Stop                              | Blocks internal Task lists during iteration 1; **Task / @game-designer / temporary ref-flow / @developer spawn still allowed**         |
+| `validate-workflow-stop.mjs`       | `SubagentStop`               | TA/Developer/Artist/Reviewer/Game Designer/temporary ref-flow stops | Validates logs, handoff, and ring docs before subagent may stop                                                                        |
+| `snapshot-milestone.mjs`           | `SubagentStop`               | Subagent stops                                                      | Detects milestone events (gate passed, dev ready) and snapshots                                                                        |
+
+## `validate-atom-tree-selection.mjs`
+
+Triggered **when `docs/atom-tree.json` is written or edited** (via `PostToolUse` hook on Write/Edit). Validates:
+
+- `meta.selectedAtoms` has no duplicates
+- Every selected atom exists in `meta.skillsMatch.items`
+- Required hard dependencies are present
+- Soft slot binding roles are resolved before use
+
+Runs `playcraft skills validate-atom-tree-selection` when CLI (Command Line Interface，命令行界面) is on `PATH`; otherwise embedded check.
+
+On failure: exit `2` — the agent must fix the JSON (JavaScript Object Notation，JavaScript 对象表示法) before continuing.
+
+Note: This hook no longer fires on Game Designer STOP. It fires at the point of file mutation, regardless of which agent writes the file.
+
+## `validate-workflow-stop.mjs`
+
+When an **Artist**, **Technical Artist** or **Developer** subagent stops, checks the corresponding `logs/<role>-log.md`. `iteration` and `loop` are read through the project state layer; generated `docs/project-state.md` is retained only for parser compatibility.
+
+### Artist (`logs/artist-log.md`)
+
+- Ring 1–2 `loop: build`: no validation (placeholder art)
+- Ring 3+ `loop: build`: § Skill Preflight required
+- Ring 3+ `loop: verify`: ASR Coverage Matrix
+
+After log checks pass, **`workflow-doctor` strict-stop** runs (`diagnose(..., { strict: 'stop' })`) — blocks illegal handoff / ring transitions (does not require ringDoD to be passed mid-build).
+
+### Developer (`logs/developer-log.md`)
+
+- **§ Upstream Intake** — doc list scales with `iteration` (ring 1: state summary + DESIGN only)
+- **§ Skill Preflight** — when `loop: build`
+- **Runtime contract** — static scan when `loop: build` (ring 1+)
+- **Developer Checkpoints** — when `loop: build` and `iteration >= 2`
+
+## `gate-runner.mjs` / `npm run ring:gate`
+
+Before each **Ring Gate**, run `npm run ring:gate -- --iteration N` (N = 1..4).
+
+What it does:
+
+1. Read project state (`iteration`, `ringDoD`, `archivedRings`)
+2. Read `logs/review-report.md` `## Ring DoD Fields` when Reviewer modes apply
+3. Spawn objective verifiers per `ring-config.mjs` (contract, record:mp4, verify:ui, …)
+4. Check non-regression of prior rings via `archivedRings`
+5. Write verdict to the Ring Gate Runner state + update `ringDoD`
+
+Exit codes:
+
+- `0` = ring DoD passed, orchestrator may ask the user at Ring Gate
+- `2` = failed, orchestrator must route back to the owning agent
+
+## `gate-dispatcher.mjs` + `gate.mjs`
+
+Triggered **when `AskUserQuestion` is called** (via `PostToolUse` hook). Together they:
+
+1. **Identify Ring Gate context** — matches question text against `ring-1` through `ring-4` keyword patterns
+2. **Run snapshot** — calls `../snapshot.mjs` to archive project state at Ring Gate confirmation
+3. **Write gate log** — appends entry to `logs/hook.log`
+4. **Advance accepted rings** — when the user accepts and `ringGateCanAskUser=yes`, calls `state:advance-ring`
+
+Non-blocking — snapshot failures are logged but never prevent Ring Gate from proceeding.
+
+## `user-prompt.mjs`
+
+Triggered **on every `UserPromptSubmit`**. Actions:
+
+1. **Increment turn counter** — stored in `.claude/logs/session.json`
+2. **Snapshot project** — calls `../snapshot.mjs` with a sanitized prompt prefix as name
+3. **Write prompt log** — appends to `logs/hook.log` with timestamp, turn number, and prompt preview
+4. **Ring 1 dispatch injection** — when `iteration: 1` in state, emits `hookSpecificOutput.additionalContext` with orchestrator dispatch recipe (invoke `@game-designer` / temporary ref-flow / `@developer`; no inline role-play; no internal Task lists)
+
+Non-blocking — snapshot failures are logged but never prevent the prompt from being processed.
+
+## `block-ring1-tasklist.mjs`
+
+Triggered **before `TaskCreate` / `TaskUpdate` / `TaskList` / `TaskGet` / `TaskOutput` / `TaskStop`** when `iteration: 1`.
+
+- Denies the tool call with `permissionDecision: deny` and points the agent to dispatch subagents via `Task` / `@game-designer` / temporary ref-flow / `@developer`
+- Ring 2+ passes through unchanged
+
+On deny: exit `2` + JSON `hookSpecificOutput.permissionDecision: deny`
+
+### On failure
+
+- **Claude Code**: exit `2` + JSON `{"decision":"block","reason":"..."}` — subagent must fix log before stopping
+- **Cursor**: exit `2` — blocks subagent stop; stderr shows the same reason
+
+Role detection: `agent_type` / `subagent_type` / `PLAYCRAFT_STOP` footer `role:` in the last message. Game Designer, temporary ref-flow atom selection, and Reviewer have role-specific validators.
+
+## Enable
+
+- **Claude Code**: project hooks load from `.claude/settings.json` automatically (see `/hooks` menu). Reload hooks after editing settings.json.
+- **Cursor**: reload after editing `.cursor/hooks.json`; verify in **Hooks** output channel
+
+Requires **Node.js** on `PATH` for the hook process.
+
+## Log paths
+
+| Purpose                      | Path                                 | Format                                                       |
+| ---------------------------- | ------------------------------------ | ------------------------------------------------------------ |
+| Gate confirmations + prompts | `logs/hook.log`                      | Timestamped entries                                          |
+| Turn counter                 | `.claude/logs/session.json`          | `{ "turns": N, "lastPromptAt": "ISO", "lastSnapAt": "ISO" }` |
+| Snapshot state (milestones)  | `.claude/hooks/.snapshot-state.json` | `{ "ring-1-archived": "ISO", "dev-ready": "ISO", ... }`      |

package/project-templates/phaser/.claude/hooks/asr-coverage-validate.mjs

@@ -0,0 +1,381 @@
+/**
+ * ASR Coverage validation — shared by validate-workflow-stop.mjs and playcraft skills validate-asr-coverage.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const PLACEHOLDER_RE = /\{\{[^}]+\}\}/;
+const MIN_TAKEAWAY_LEN = 8;
+
+export const IMAGE_PRODUCTION_PREFLIGHT_HEADING = '## Image Production Preflight';
+export const ASR_COVERAGE_HEADING = '## ASR Coverage Matrix';
+export const REQUIRED_IMAGE_SKILLS = [
+  'playcraft-storyboard',
+  'playcraft-asset-state-sheet',
+  'playcraft-image-generation',
+];
+
+/**
+ * @param {string} content
+ */
+export function readSelectedMcOption(content) {
+  const m =
+    content.match(/selectedMcOption:\s*["']?([ABC])["']?/i) ||
+    content.match(/selectedMcOption\s*=\s*([ABC])/i);
+  return m ? m[1].toUpperCase() : null;
+}
+
+/**
+ * @param {string} layoutSpec
+ * @returns {{ elementIds: string[], staticTextIds: string[] }}
+ */
+export function parseLayoutSpecContractIds(layoutSpec) {
+  /** @type {string[]} */
+  const elementIds = [];
+  /** @type {string[]} */
+  const staticTextIds = [];
+
+  const assetSection = extractSection(layoutSpec, '## Asset Mapping');
+  if (assetSection) {
+    for (const line of assetSection.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('|')) continue;
+      if (/^\|\s*---/.test(trimmed)) continue;
+      if (/^\|\s*elementId/i.test(trimmed)) continue;
+
+      const parts = trimmed
+        .split('|')
+        .map((p) => p.trim())
+        .filter((_, i, arr) => i > 0 && i < arr.length - 1);
+      if (parts.length < 1) continue;
+      const id = parts[0].replace(/`/g, '');
+      if (!id || id === '—' || id === '-' || PLACEHOLDER_RE.test(id)) continue;
+      elementIds.push(id);
+    }
+  }
+
+  const textSection = extractSection(layoutSpec, '### Static Text');
+  if (textSection) {
+    for (const line of textSection.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('|')) continue;
+      if (/^\|\s*---/.test(trimmed)) continue;
+      if (/^\|\s*id/i.test(trimmed)) continue;
+
+      const parts = trimmed
+        .split('|')
+        .map((p) => p.trim())
+        .filter((_, i, arr) => i > 0 && i < arr.length - 1);
+      if (parts.length < 1) continue;
+      const id = parts[0].replace(/`/g, '');
+      if (!id || id === '—' || PLACEHOLDER_RE.test(id)) continue;
+      staticTextIds.push(id);
+    }
+  }
+
+  return { elementIds, staticTextIds };
+}
+
+/**
+ * @param {string} content
+ * @param {string} heading
+ */
+function extractSection(content, heading) {
+  const start = content.indexOf(heading);
+  if (start === -1) return '';
+  const after = content.slice(start + heading.length);
+  const next = after.search(/\n##\s+/);
+  return next === -1 ? after : after.slice(0, next);
+}
+
+/**
+ * @param {string} cell
+ */
+function isReadChecked(cell) {
+  const t = cell.trim();
+  if (/[✓✔☑]/.test(t)) return true;
+  if (/\[x\]/i.test(t)) return true;
+  if (/^(yes|done|true|read)$/i.test(t)) return true;
+  return false;
+}
+
+/**
+ * @param {string} content
+ */
+export function validateImageProductionPreflight(content) {
+  const errors = [];
+  const start = content.indexOf(IMAGE_PRODUCTION_PREFLIGHT_HEADING);
+  if (start === -1) {
+    return [`Missing "${IMAGE_PRODUCTION_PREFLIGHT_HEADING}" section`];
+  }
+
+  const after = content.slice(start + IMAGE_PRODUCTION_PREFLIGHT_HEADING.length);
+  const nextHeading = after.search(/\n##\s+/);
+  const section = nextHeading === -1 ? after : after.slice(0, nextHeading);
+
+  /** @type {{ skill: string, read: string, summary: string }[]} */
+  const rows = [];
+  for (const line of section.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|')) continue;
+    if (/^\|\s*---/.test(trimmed)) continue;
+    if (/^\|\s*Skill/i.test(trimmed)) continue;
+
+    const parts = trimmed
+      .split('|')
+      .map((p) => p.trim())
+      .filter((_, i, arr) => i > 0 && i < arr.length - 1);
+    if (parts.length < 3) continue;
+    rows.push({ skill: parts[0], read: parts[1], summary: parts[2] });
+  }
+
+  if (rows.length === 0) {
+    errors.push(`${IMAGE_PRODUCTION_PREFLIGHT_HEADING}: table has no data rows`);
+    return errors;
+  }
+
+  for (const required of REQUIRED_IMAGE_SKILLS) {
+    const row = rows.find((r) => r.skill.includes(required));
+    if (!row) {
+      errors.push(`${IMAGE_PRODUCTION_PREFLIGHT_HEADING}: missing row for ${required}`);
+      continue;
+    }
+    if (!isReadChecked(row.read)) {
+      errors.push(`${IMAGE_PRODUCTION_PREFLIGHT_HEADING}: "${required}" — mark 已读 (✓)`);
+    }
+    if (!row.summary || PLACEHOLDER_RE.test(row.summary) || row.summary.length < MIN_TAKEAWAY_LEN) {
+      errors.push(
+        `${IMAGE_PRODUCTION_PREFLIGHT_HEADING}: "${required}" — add decision summary (≥${MIN_TAKEAWAY_LEN} chars)`,
+      );
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * @param {string} content
+ */
+export function parseCoverageMatrixRows(content) {
+  const section = extractSection(content, ASR_COVERAGE_HEADING);
+  const coverageStart = section.indexOf('### Coverage');
+  const coverageBlock = coverageStart === -1 ? section : section.slice(coverageStart);
+
+  /** @type {{ contractId: string, elementType: string, coverageLayer: string }[]} */
+  const rows = [];
+  for (const line of coverageBlock.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|')) continue;
+    if (/^\|\s*---/.test(trimmed)) continue;
+    if (/^\|\s*Contract id/i.test(trimmed)) continue;
+
+    const parts = trimmed
+      .split('|')
+      .map((p) => p.trim())
+      .filter((_, i, arr) => i > 0 && i < arr.length - 1);
+    if (parts.length < 4) continue;
+
+    const contractId = parts[0].replace(/`/g, '');
+    if (!contractId || PLACEHOLDER_RE.test(contractId)) continue;
+
+    const typeValues = new Set(['visual', 'audio', 'text', 'digit', 'sfx']);
+    let elementType = '';
+    let coverageLayer = '';
+
+    if (parts.length >= 4 && typeValues.has(parts[2]?.toLowerCase())) {
+      elementType = parts[1];
+      coverageLayer = parts[3];
+    } else if (parts.length >= 3 && typeValues.has(parts[1]?.toLowerCase())) {
+      coverageLayer = parts[2];
+    } else {
+      elementType = parts.length >= 6 ? parts[1] : '';
+      coverageLayer = parts.length >= 4 ? parts[3] : parts[1] || '';
+    }
+
+    rows.push({
+      contractId,
+      elementType: elementType.replace(/`/g, ''),
+      coverageLayer: coverageLayer.toLowerCase(),
+    });
+  }
+  return rows;
+}
+
+/**
+ * @param {string} content
+ */
+export function validateSheetGridMetadata(content) {
+  const errors = [];
+  const section = extractSection(content, ASR_COVERAGE_HEADING);
+  if (!section.includes('### Sheet grid metadata')) {
+    errors.push('ASR Coverage Matrix: missing ### Sheet grid metadata table');
+    return errors;
+  }
+
+  const gridStart = section.indexOf('### Sheet grid metadata');
+  const gridBlock = section.slice(gridStart);
+  const gridEnd = gridBlock.search(/\n###\s+/);
+  const gridSection = gridEnd === -1 ? gridBlock : gridBlock.slice(0, gridEnd);
+
+  if (PLACEHOLDER_RE.test(gridSection)) {
+    errors.push('Sheet grid metadata: contains {{placeholders}} — fill real rows/cols/cell dimensions');
+  }
+
+  let dataRows = 0;
+  for (const line of gridSection.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|')) continue;
+    if (/^\|\s*---/.test(trimmed)) continue;
+    if (/^\|\s*Sheet/i.test(trimmed)) continue;
+    dataRows++;
+  }
+  if (dataRows < 2) {
+    errors.push('Sheet grid metadata: need at least ui + element sheet rows');
+  }
+
+  return errors;
+}
+
+/**
+ * @param {string} artistLog
+ * @param {string} layoutSpec
+ */
+export function validateCoverageRowCount(artistLog, layoutSpec) {
+  const errors = [];
+  const { elementIds, staticTextIds } = parseLayoutSpecContractIds(layoutSpec);
+  const expected = elementIds.length + staticTextIds.length;
+  const matrixRows = parseCoverageMatrixRows(artistLog);
+
+  if (expected === 0) {
+    errors.push('layout-spec: could not parse assetMapping/static text ids — fill Asset Mapping table');
+    return errors;
+  }
+
+  if (matrixRows.length < expected) {
+    errors.push(
+      `Coverage Matrix: ${matrixRows.length} rows but layout-spec expects ${expected} (assetMapping + static text)`,
+    );
+  }
+
+  const contractSet = new Set([...elementIds, ...staticTextIds]);
+  const matrixIds = new Set(matrixRows.map((r) => r.contractId));
+  for (const id of contractSet) {
+    if (!matrixIds.has(id)) {
+      errors.push(`Coverage Matrix: missing row for contract id "${id}"`);
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * @param {string} artistLog
+ */
+export function validateTypeRepresentatives(artistLog) {
+  const errors = [];
+  const rows = parseCoverageMatrixRows(artistLog);
+  /** @type {Map<string, Set<string>>} */
+  const typeLayers = new Map();
+
+  for (const row of rows) {
+    const type = row.elementType && row.elementType !== '—' ? row.elementType : row.contractId.split('_')[0];
+    if (!type) continue;
+    if (!typeLayers.has(type)) typeLayers.set(type, new Set());
+    typeLayers.get(type).add(row.coverageLayer);
+  }
+
+  for (const [type, layers] of typeLayers) {
+    const hasRep =
+      [...layers].some((l) => l.includes('on-asr')) || [...layers].some((l) => l.includes('mc-crop'));
+    if (!hasRep && layers.size > 0) {
+      const allExtends = [...layers].every((l) => l.includes('ta-extends') || l.includes('ta extends'));
+      if (allExtends) {
+        errors.push(
+          `Coverage Matrix: elementType "${type}" has no on-asr or mc-crop representative`,
+        );
+      }
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * @param {string} projectDir
+ * @param {string} option
+ * @param {string} [artistLog]
+ */
+export function validateAsrPngFiles(projectDir, option, artistLog) {
+  const errors = [];
+  const ui = path.join(projectDir, `assets/images/reference/ui_state_sheet_${option}.png`);
+  const el = path.join(projectDir, `assets/images/reference/element_state_sheet_${option}.png`);
+  const mc = path.join(
+    projectDir,
+    `assets/images/storyboard/master_composite_option_${option}.png`,
+  );
+
+  if (!fs.existsSync(mc)) {
+    errors.push(`Missing MC: assets/images/storyboard/master_composite_option_${option}.png`);
+  }
+  if (!fs.existsSync(ui)) {
+    errors.push(`Missing ASR: assets/images/reference/ui_state_sheet_${option}.png`);
+  }
+  if (!fs.existsSync(el)) {
+    errors.push(`Missing ASR: assets/images/reference/element_state_sheet_${option}.png`);
+  }
+
+  if (artistLog && /element_2|element_state_sheet_\w+_2\.png/i.test(artistLog)) {
+    const el2 = path.join(
+      projectDir,
+      `assets/images/reference/element_state_sheet_${option}_2.png`,
+    );
+    if (!fs.existsSync(el2)) {
+      errors.push(
+        `Missing ASR overflow board: assets/images/reference/element_state_sheet_${option}_2.png`,
+      );
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * @param {string} projectDir
+ * @returns {string[]}
+ */
+export function validateArtistGate2b(projectDir) {
+  const errors = [];
+  const logPath = path.join(projectDir, 'logs/artist-log.md');
+  const layoutPath = path.join(projectDir, 'docs/layout-spec.md');
+  const statePath = path.join(projectDir, 'docs/project-state.md');
+
+  if (!fs.existsSync(logPath)) {
+    return ['Create logs/artist-log.md before ring 3 verify STOP'];
+  }
+  if (!fs.existsSync(layoutPath)) {
+    return ['Missing docs/layout-spec.md'];
+  }
+
+  const artistLog = fs.readFileSync(logPath, 'utf8');
+  const layoutSpec = fs.readFileSync(layoutPath, 'utf8');
+
+  errors.push(...validateImageProductionPreflight(artistLog));
+
+  if (!artistLog.includes(ASR_COVERAGE_HEADING)) {
+    errors.push(`Missing "${ASR_COVERAGE_HEADING}" section`);
+  } else {
+    errors.push(...validateSheetGridMetadata(artistLog));
+    errors.push(...validateCoverageRowCount(artistLog, layoutSpec));
+    errors.push(...validateTypeRepresentatives(artistLog));
+  }
+
+  let option = 'A';
+  if (fs.existsSync(statePath)) {
+    const opt = readSelectedMcOption(fs.readFileSync(statePath, 'utf8'));
+    if (opt) option = opt;
+  }
+  errors.push(...validateAsrPngFiles(projectDir, option, artistLog));
+
+  return errors;
+}