@playcraft/cli 0.0.55 → 0.0.56

package/project-template/.claude/hooks/validate-workflow-stop.mjs

@@ -19,6 +19,9 @@ import {
 } from '../../skills/_shared/scripts/ring-config.mjs';
 import { normalizeSliceState, readState, stateExists, isSliceResolved } from '../../skills/_shared/scripts/state-store.mjs';
 import { validateBuildArtifactForSlice } from '../../skills/playable-record/scripts/lib/build-artifact.mjs';
+import { verifyDesignConsistency, validateAnimationSpine, validateStorySpine } from '../../skills/_shared/scripts/verify-design-consistency.mjs';
+import { validateSkillFidelity } from '../../skills/_shared/scripts/lib/skill-fidelity.mjs';
+import { isMechanismLocked } from '../../skills/_shared/scripts/disclosure-config.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const require = createRequire(import.meta.url);
@@ -43,9 +46,26 @@ const PLAN_REQUIRED_SUBS = {
 const PLACEHOLDER_RE = /\{\{[^}]+\}\}/;
 const MIN_TAKEAWAY_LEN = 8;
 
+function isCreativeDirectorSplitEnabledForStop() {
+  const raw = String(process.env.CREATIVE_DIRECTOR_SPLIT ?? '1').trim().toLowerCase();
+  return raw !== '0' && raw !== 'false' && raw !== 'off';
+}
+
+/** GD mechanism-lock STOP (before north-star exists). */
+function isGameDesignerMechanismPhase(projectDir) {
+  if (!isCreativeDirectorSplitEnabledForStop()) return false;
+  if (fs.existsSync(path.join(projectDir, 'docs/north-star.md'))) return false;
+  const state = readState(projectDir);
+  const ctx = state.handoffContext || {};
+  const primarySkill = String(ctx.primaryGameplaySkill ?? '').trim();
+  if (!primarySkill || primarySkill === 'unset') return false;
+  if (fs.existsSync(path.join(projectDir, 'docs/level-sketch.json'))) return false;
+  return isMechanismLocked(projectDir, ctx);
+}
+
 /** Required upstream docs scale with growth ring — ring 1 stays minimal (DESIGN only; design-brief is optional scratch). */
 const DEV_REQUIRED_DOCS_BY_RING = {
-  1: ['docs/project-state.md', 'docs/DESIGN.md'],
+  1: ['docs/project-state.md', 'docs/DESIGN.md', 'docs/atom-tree.json'],
   2: [
     'docs/project-state.md',
     'docs/design-brief.md',
@@ -95,6 +115,7 @@ const ROLE_LOG = {
   artist: { log: 'logs/artist-log.md', label: 'Artist' },
   reviewer: { log: 'logs/review-report.md', label: 'Reviewer' },
   'game-designer': { log: null, label: 'Game Designer' },
+  'creative-director': { log: null, label: 'Creative Director' },
   'skill-selector': { log: null, label: 'Temporary Atom Selector' },
 };
 
@@ -488,6 +509,7 @@ function detectRole(input) {
     if (n === 'developer-lead' || n === 'developer' || n === 'dev') return 'developer';
     if (n === 'artist') return 'artist';
     if (n === 'reviewer' || n === 'review') return 'reviewer';
+    if (n === 'creative-director' || n === 'creative director') return 'creative-director';
     if (n === 'game-designer' || n === 'game designer' || n === 'designer') return 'game-designer';
     if (n === 'skill-selector' || n === 'skill selector' || n === 'ref-flow') return 'skill-selector';
   }
@@ -803,6 +825,88 @@ function validateReviewerStop(projectDir) {
   return errors;
 }
 
+/**
+ * @param {string} projectDir
+ */
+function validateCreativeDirectorStop(projectDir) {
+  const errors = [];
+  const handoff = readHandoff(projectDir);
+  const state = readState(projectDir);
+
+  if (handoff.subagent_stop !== 'true') {
+    errors.push('Creative Director STOP requires subagent_stop: true');
+  }
+  if ((handoff.waiting_for || '').toLowerCase() !== 'orchestrator') {
+    errors.push('Creative Director STOP requires waiting_for: orchestrator');
+  }
+  if (!handoff.next_orchestrator_action || handoff.next_orchestrator_action === 'null') {
+    errors.push('Creative Director STOP requires next_orchestrator_action (Invoke @game-designer — ring 1 design spec)');
+  }
+
+  for (const doc of ['docs/north-star.md', 'docs/creative-process.md']) {
+    errors.push(...validateDocFile(projectDir, doc));
+  }
+
+  const northPath = path.join(projectDir, 'docs/north-star.md');
+  if (fs.existsSync(northPath)) {
+    const north = fs.readFileSync(northPath, 'utf8');
+    if (!/One-liner|一句话/i.test(north) || north.replace(/\s/g, '').length < 80) {
+      errors.push('docs/north-star.md: missing substantive One-liner / north star fields');
+    }
+    if (!/Rejected vibe|拒绝/i.test(north)) {
+      errors.push('docs/north-star.md: missing Rejected vibe section');
+    }
+    if (!/Micro-Story\s*Spine/i.test(north)) {
+      errors.push('docs/north-star.md: missing Micro-Story Spine section');
+    }
+  }
+
+  const cpPath = path.join(projectDir, 'docs/creative-process.md');
+  let creativeProcessText = '';
+  if (fs.existsSync(cpPath)) {
+    creativeProcessText = fs.readFileSync(cpPath, 'utf8');
+    const candidates = (creativeProcessText.match(/###\s*Candidate\s+[ABC]/gi) || []).length;
+    if (candidates < 3) {
+      errors.push('docs/creative-process.md: Phase 1 requires ≥3 candidates (A/B/C)');
+    }
+  }
+
+  if (fs.existsSync(northPath)) {
+    const north = fs.readFileSync(northPath, 'utf8');
+    const spineResult = validateStorySpine(north, '', creativeProcessText);
+    for (const p of spineResult.problems) {
+      errors.push(`docs/north-star.md: ${p}`);
+    }
+    if (spineResult.metrics.narrativeLevel === 'L3') {
+      errors.push('docs/north-star.md: Narrative level L3 forbidden — use L2 or below');
+    }
+  }
+
+  if (fs.existsSync(path.join(projectDir, 'docs/DESIGN.md'))) {
+    const designLen = fs.readFileSync(path.join(projectDir, 'docs/DESIGN.md'), 'utf8').length;
+    if (designLen > 200) {
+      errors.push('Creative Director must not write substantive docs/DESIGN.md — spec phase is @game-designer');
+    }
+  }
+
+  const primarySkill = String(state?.handoffContext?.primaryGameplaySkill ?? '').trim();
+  if (!primarySkill || primarySkill === 'unset') {
+    errors.push('Creative Director STOP requires handoffContext.primaryGameplaySkill (set during mechanism lock)');
+  }
+
+  if (fs.existsSync(northPath)) {
+    const north = fs.readFileSync(northPath, 'utf8');
+    const fidelity = validateSkillFidelity(projectDir, { northStarMd: north, payoffOnly: true });
+    if (!fidelity.skipped && !fidelity.pass) {
+      for (const reason of fidelity.driftReasons) {
+        errors.push(`CD PGS fidelity: ${reason}`);
+      }
+    }
+  }
+
+  return errors;
+}
+
 /**
  * @param {string} projectDir
  */
@@ -826,8 +930,41 @@ function validateGameDesignerStop(projectDir) {
     return errors;
   }
 
-  const ring = Math.min(Math.max(iteration, 1), 4);
   const state = readState(projectDir);
+  const ring = Math.min(Math.max(iteration, 1), 4);
+  const mechanismPhase = ring === 1 && isGameDesignerMechanismPhase(projectDir);
+
+  if (mechanismPhase) {
+    const ctx = state.handoffContext || {};
+    const primarySkill = String(ctx.primaryGameplaySkill ?? '').trim();
+    if (!primarySkill || primarySkill === 'unset') {
+      errors.push('Mechanism lock STOP requires handoffContext.primaryGameplaySkill');
+    }
+    if (!isMechanismLocked(projectDir, ctx)) {
+      errors.push('Mechanism lock STOP requires docs/atom-tree.json meta.skillsMatch.items non-empty');
+    }
+    const atomTreePath = path.join(projectDir, 'docs/atom-tree.json');
+    if (!fs.existsSync(atomTreePath)) {
+      errors.push('Mechanism lock STOP requires docs/atom-tree.json');
+    } else {
+      errors.push(...validateHandoffContext(projectDir, 'game-designer'));
+      const refs = ctx.lastRole?.artifactRefs || [];
+      if (!refs.some((r) => String(r).includes('atom-tree.json'))) {
+        errors.push('handoffContext.lastRole.artifactRefs must include docs/atom-tree.json');
+      }
+    }
+    if (fs.existsSync(path.join(projectDir, 'docs/north-star.md'))) {
+      errors.push('Mechanism phase must not write docs/north-star.md — creative-director owns north-star');
+    }
+    if (fs.existsSync(path.join(projectDir, 'docs/DESIGN.md'))) {
+      const designLen = fs.readFileSync(path.join(projectDir, 'docs/DESIGN.md'), 'utf8').length;
+      if (designLen > 200) {
+        errors.push('Mechanism phase must not write substantive docs/DESIGN.md');
+      }
+    }
+    return errors;
+  }
+
   const ss = normalizeSliceState(state.sliceState || {});
   const sliceAxisClarify = ss.slices.length > 0 && (ring === 1 || ring === 2);
 
@@ -841,7 +978,25 @@ function validateGameDesignerStop(projectDir) {
   if (ring === 1) {
     const designPath = path.join(projectDir, 'docs/DESIGN.md');
     if (fs.existsSync(designPath)) {
-      errors.push(...validatePlayableSeedDesign(fs.readFileSync(designPath, 'utf8')));
+      const designContent = fs.readFileSync(designPath, 'utf8');
+      errors.push(...validatePlayableSeedDesign(designContent));
+      errors.push(...validateDesignFusionSection(designContent));
+    }
+    const sketchPath = path.join(projectDir, 'docs/level-sketch.json');
+    if (!fs.existsSync(sketchPath) && sliceAxisClarify) {
+      errors.push('Ring 1 clarify requires docs/level-sketch.json (executable level sketch)');
+    }
+    if (ring === 1 && sliceAxisClarify && fs.existsSync(sketchPath)) {
+      if (fs.existsSync(designPath)) {
+        const designContent = fs.readFileSync(designPath, 'utf8');
+        errors.push(...validateAnimationSpine(designContent));
+      }
+      const designCheck = verifyDesignConsistency(projectDir);
+      if (!designCheck.ok) {
+        for (const p of designCheck.problems) {
+          errors.push(`verify:design: ${p}`);
+        }
+      }
     }
   }
 
@@ -1318,6 +1473,9 @@ function validateRole(projectDir, role) {
   if (role === 'reviewer') {
     return validateReviewerStop(projectDir);
   }
+  if (role === 'creative-director') {
+    return validateCreativeDirectorStop(projectDir);
+  }
   if (role === 'game-designer') {
     return validateGameDesignerStop(projectDir);
   }
@@ -1393,20 +1551,28 @@ function validateRole(projectDir, role) {
 }
 
 /** Selected atoms that must be linked into .claude/skills/ (excludes bundled playcraft-* skills). */
-function readSelectedAtomsForLink(projectDir) {
+function readAtomTreeForPreflight(projectDir) {
   const jsonPath = path.join(projectDir, 'docs/atom-tree.json');
-  if (!fs.existsSync(jsonPath)) return [];
+  if (!fs.existsSync(jsonPath)) return { exists: false, parseError: false, atoms: [] };
   try {
     const tree = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
     const atoms = Array.isArray(tree?.meta?.selectedAtoms) ? tree.meta.selectedAtoms : [];
-    return atoms
-      .map((a) => (typeof a === 'string' ? a.trim() : ''))
-      .filter((a) => a && !a.startsWith('{{') && !a.startsWith('playcraft-'));
+    return {
+      exists: true,
+      parseError: false,
+      atoms: atoms
+        .map((a) => (typeof a === 'string' ? a.trim() : ''))
+        .filter((a) => a && !a.startsWith('{{') && !a.startsWith('playcraft-')),
+    };
   } catch {
-    return [];
+    return { exists: true, parseError: true, atoms: [] };
   }
 }
 
+function readSelectedAtomsForLink(projectDir) {
+  return readAtomTreeForPreflight(projectDir).atoms;
+}
+
 /** Extract a markdown section body from `heading` up to the next same-or-higher-level heading. */
 function extractMarkdownSection(content, heading) {
   const start = content.indexOf(heading);
@@ -1437,6 +1603,21 @@ function countFilledTableRows(section) {
   return count;
 }
 
+function missingSelectedAtomPreflightRows(content, atoms) {
+  const missing = [];
+  if (!content.includes('docs/atom-tree.json')) missing.push('docs/atom-tree.json');
+  const preflight = extractMarkdownSection(content, '## Skill Preflight');
+  if (!preflight) {
+    missing.push('logs/developer-log.md § Skill Preflight');
+    return missing;
+  }
+  for (const atom of atoms) {
+    const skillPath = `.claude/skills/${atom}/SKILL.md`;
+    if (!preflight.includes(atom) || !preflight.includes(skillPath)) missing.push(skillPath);
+  }
+  return missing;
+}
+
 /**
  * Shared skill-link + Skill Preflight + placeholder materialization evidence gate.
  * Applied at every ring's Developer build STOP so "use placeholders / implement per skill"
@@ -1447,7 +1628,15 @@ function countFilledTableRows(section) {
  */
 function validateSkillAndPlaceholderEvidence(projectDir, content) {
   const errors = [];
-  const atoms = readSelectedAtomsForLink(projectDir);
+  const atomTree = readAtomTreeForPreflight(projectDir);
+  const atoms = atomTree.atoms;
+
+  if (!atomTree.exists) {
+    errors.push('Skill Preflight: missing docs/atom-tree.json — dispatchPacket.requiredContext cannot disclose selected atom Skills');
+  }
+  if (atomTree.parseError) {
+    errors.push('Skill Preflight: docs/atom-tree.json must be valid JSON before Developer STOP');
+  }
 
   // 1. Skill link evidence: selected atoms materialized under .claude/skills/
   const skillsDir = path.join(projectDir, '.claude/skills');
@@ -1458,13 +1647,19 @@ function validateSkillAndPlaceholderEvidence(projectDir, content) {
     );
   }
 
-  // 2. Skill Preflight filled (one non-template row per atom)
+  // 2. Skill Preflight filled (one exact-path row per atom)
   const preflight = extractMarkdownSection(content, '## Skill Preflight');
   if (!preflight || countFilledTableRows(preflight) < Math.max(1, atoms.length)) {
     errors.push(
       'Skill Preflight: developer-log.md § Skill Preflight is not filled — add one non-template row per selected atom (read .claude/skills/<atom>/SKILL.md: what it provides + how you use it)',
     );
   }
+  const missingRows = missingSelectedAtomPreflightRows(content, atoms);
+  if (missingRows.length > 0) {
+    errors.push(
+      `Skill Preflight: missing required reading evidence for ${missingRows.join(', ')} — read docs/atom-tree.json and add one exact .claude/skills/<atom>/SKILL.md row for every meta.selectedAtoms item`,
+    );
+  }
 
   // 3. Placeholder materialization evidence (placeholder-first, not code-draw-only)
   const placeholder = extractMarkdownSection(content, '### Placeholder materialization');
@@ -1779,6 +1974,8 @@ export {
   validateGameDesignerSeedContext,
   validateGameDesignerSliceQueueSeed,
   validateSkillsMatchSliceRefs,
+  validateSkillAndPlaceholderEvidence,
+  missingSelectedAtomPreflightRows,
   validateDesignFusionSection,
   validateReviewerHandoff,
   validateReviewReportDoD,
@@ -1797,7 +1994,6 @@ export {
   PLAN_HEADING,
   PLAN_REQUIRED_SUBS,
   ROLE_LOG,
-  validateSkillAndPlaceholderEvidence,
   validateDevUrlDebugFlag,
   readSelectedAtomsForLink,
   extractMarkdownSection,
@@ -1809,6 +2005,7 @@ async function main() {
   const input = parseHookInput(stdin);
 
   const projectDir =
+    process.env.CODEBUDDY_PROJECT_DIR ||
     process.env.CLAUDE_PROJECT_DIR ||
     process.env.CURSOR_PROJECT_DIR ||
     process.cwd();

package/project-template/.claude/settings.json

@@ -1,5 +1,5 @@
 {
-  "defaultMode": "acceptEdits",
+  "defaultMode": "bypassPermissions",
   "env": {
     "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
   },
@@ -54,7 +54,7 @@
     ],
     "SubagentStop": [
       {
-        "matcher": "artist|technical-artist|developer|reviewer|game-designer|skill-selector",
+        "matcher": "artist|technical-artist|developer|reviewer|game-designer|creative-director|skill-selector",
         "hooks": [
           {
             "type": "command",

package/project-template/.claude/skills/playcraft-playable-optimization/SKILL.md

@@ -51,35 +51,35 @@ PlayCraft 是 **Vite** 项目，`ensure-project` 会检测到 `vite.config.ts` +
 
 ## 与 PlayCraft growth-rings 的接点
 
-| iteration / loop               | 谁调用                  | 调用什么                                   | 产出                           |
-| ------------------------------ | ----------------------- | ------------------------------------------ | ------------------------------ |
-| ring 1 `loop: build`（收尾）   | Developer               | `state:get` 披露的 contract/lifecycle/firstwin | 轻量 HOOK 生命周期 + 首关可胜 |
-| ring 2+ `loop: build`（收尾）  | Developer               | 仅运行 `state:get.nextCommands` 中的 `verify:ui` / `record:mp4` | 当前 Ring 证据 |
-| ring 4 `loop: verify`          | Reviewer                | `verify:ui` → `playwright-cli` 截图        | asset/layout 先行拦截          |
-| ring 4 verify ui_diff fail     | Developer / TA / Artist | 读 `playable-validate` 子 skill 做最小 fix | 修复后重跑 verify + record     |
-| ring 4 optional optimization   | Reviewer / Orchestrator | `playable-validate` loop                   | `validate/PLAYABLE-*.md` + MP4 |
+| iteration / loop              | 谁调用                  | 调用什么                                                        | 产出                           |
+| ----------------------------- | ----------------------- | --------------------------------------------------------------- | ------------------------------ |
+| ring 1 `loop: build`（收尾）  | Developer               | `state:get` 披露的 contract/lifecycle/firstwin                  | 轻量 HOOK 生命周期 + 首关可胜  |
+| ring 2+ `loop: build`（收尾） | Developer               | 仅运行 `state:get.nextCommands` 中的 `verify:ui` / `record:mp4` | 当前 Ring 证据                 |
+| ring 4 `loop: verify`         | Reviewer                | `verify:ui` → `playwright-cli` 截图                             | asset/layout 先行拦截          |
+| ring 4 verify ui_diff fail    | Developer / TA / Artist | 读 `playable-validate` 子 skill 做最小 fix                      | 修复后重跑 verify + record     |
+| ring 4 optional optimization  | Reviewer / Orchestrator | `playable-validate` loop                                        | `validate/PLAYABLE-*.md` + MP4 |
 
 ---
 
 ## 一句话指令表
 
-| 用户/Agent 意图          | 命令/入口                                                              |
-| ------------------------ | ---------------------------------------------------------------------- |
-| 查看当前可运行命令       | `npm run state:get -- --json`                                          |
-| 整片优化到可交付         | 读 `skills/playable-validate/SKILL.md` § Agent 入口                    |
-| 检查 UI / atlas / layout | 仅当 `state:get.nextCommands` 披露：`npm run verify:ui`                |
+| 用户/Agent 意图          | 命令/入口                                                                     |
+| ------------------------ | ----------------------------------------------------------------------------- |
+| 查看当前可运行命令       | `npm run state:get -- --json`                                                 |
+| 整片优化到可交付         | 读 `skills/playable-validate/SKILL.md` § Agent 入口                           |
+| 检查 UI / atlas / layout | 仅当 `state:get.nextCommands` 披露：`npm run verify:ui`                       |
 | 录完整局 headed MP4      | 仅当 `state:get.nextCommands` 披露：`npm run record:mp4 -- --headed --fps=60` |
-| 只录某个 focus zone      | `npm run record:focus -- --scope=PHASE --fixture=endcard-win --headed` |
-| 优化 match 碎裂 FX       | 读 `skills/playable-fx-decompose/SKILL.md`                             |
-| 优化帧光效 / burst       | 读 `skills/playable-fx-peak/SKILL.md`                                  |
-| 优化动效手感             | 读 `skills/playable-animate/SKILL.md`                                  |
-| 局部 L→G 穷举            | `npm run sweep:L1` / `npm run sweep:G1`                                |
+| 只录某个 focus zone      | `npm run record:focus -- --scope=PHASE --fixture=endcard-win --headed`        |
+| 优化 match 碎裂 FX       | 读 `skills/playable-fx-decompose/SKILL.md`                                    |
+| 优化帧光效 / burst       | 读 `skills/playable-fx-peak/SKILL.md`                                         |
+| 优化动效手感             | 读 `skills/playable-animate/SKILL.md`                                         |
+| 局部 L→G 穷举            | `npm run sweep:L1` / `npm run sweep:G1`                                       |
 
 ---
 
 ## Vite 项目注意事项
 
-PlayCraft 项目用 Vite，`record:mp4` 默认脚本已经带了 `--use-dev --url=http://localhost:3000/`。只在当前 Ring 已披露 `record:mp4` 时运行：
+PlayCraft 项目用 Vite，`record:mp4` 默认脚本已经带了 `--use-dev --url=http://localhost:5173/`。只在当前 Ring 已披露 `record:mp4` 时运行：
 
 ```bash
 npm run record:mp4 -- --headed --fps=60
@@ -88,10 +88,10 @@ npm run record:mp4 -- --headed --fps=60
 这会：
 
 1. 在当前目录启动 `npm run dev`。
-2. 等待 `http://localhost:3000/` 可访问。
+2. 等待 `http://localhost:5173/` 可访问。
 3. 用 Playwright 打开该 URL 并录制。
 
-如果 Vite 端口不是 3000，改 `package.json` 里的 `record:mp4` 脚本，或手动：
+如果 Vite 端口不是 5173，改 `package.json` 里的 `record:mp4` 脚本，或手动：
 
 ```bash
 # 终端 1

package/project-template/.claude/skills/session-analyzer/scripts/resolve-session.mjs

@@ -27,7 +27,6 @@ if (!keyword) {
 const home = homedir();
 const stores = [
   { name: 'Claude Code', path: join(home, '.claude', 'projects') },
-  { name: 'Claude Internal', path: join(home, '.claude-internal', 'projects') },
   { name: 'CodeBuddy', path: join(home, '.codebuddy', 'projects') },
 ];
 

package/project-template/.claude/snapshot.mjs

@@ -86,7 +86,6 @@ function findSessions(projectCwd) {
   const home = homedir();
   const stores = [
     { name: 'claude-code',     path: join(home, '.claude', 'projects') },
-    { name: 'claude-internal', path: join(home, '.claude-internal', 'projects') },
     { name: 'codebuddy',       path: join(home, '.codebuddy', 'projects') },
   ];
 

package/project-template/.codebuddy/settings.json

@@ -1,5 +1,5 @@
 {
-  "defaultMode": "acceptEdits",
+  "defaultMode": "bypassPermissions",
   "env": {
     "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
   },

package/project-template/.cursor/rules/playcraft-orchestrator.mdc

@@ -123,7 +123,7 @@ When executing `next_orchestrator_action`, **also** update `iteration` / `loop`
 
 | iteration | loop | Typical `next_orchestrator_action` |
 | --------- | ---- | ---------------------------------- |
-| 1 | clarify | Invoke `@game-designer` — engine root + core loop spec |
+| 1 | clarify | `@game-designer` mechanism lock → read `creative-director-kickoff-guide.md` → `@creative-director` (PGS wrap) → `@game-designer` spec; `CREATIVE_DIRECTOR_SPLIT=0` for monolithic control |
 | 1 | build | Invoke `@developer` — engine boot + placeholder core gameplay |
 | 1 | verify | Developer self-gate → `npm run ring:gate -- --iteration 1` → Ring Gate (no `@reviewer`) |
 | 2 | clarify | `@game-designer` — periphery atoms (HUD / flow) |

package/project-template/CLAUDE.md

@@ -50,15 +50,15 @@ When **`dispatchPacket` is null** (`dispatchMode: false`): use the legacy growth
 
 When `state:get` reports `iteration: 1`, **stay orchestrator** — invoke role subagents; do not inline their work.
 
-| `loop`                | Orchestrator does                                                                                                                                                                                                                                                                  |
-| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `clarify`             | **Invoke `@game-designer`** — ring 1 clarify (single concise `docs/DESIGN.md`). Do not write `DESIGN.md` yourself.                                                                                                                                                                 |
-| (after GD STOP)       | **Spawn a temporary ref-flow atom-selection subagent** — create the minimal ring 1 atom-tree package: engine decision, compact gameplay trunk, selected atoms, and ring 1 verifier metadata. Do not make main orchestrator select atoms inline.                                    |
-| (after selector STOP) | Run scaffold gate: `validate-atom-tree-selection` → `init-template --from-atom-tree` → `npm install` → `npm run verify:contract` → `npm run verify:lifecycle`. Set `loop: build`, then **Invoke `@developer`**.                                                                    |
-| `build`               | **Invoke `@developer`** — ring 1 build only the smallest verifiable playable spine (placeholder art, one player-reachable action loop, `window.__playable`). Developer self-gates with `verify:contract` + `verify:lifecycle` + `verify:firstwin` + `verify:placeholders` on STOP. |
-| `verify`              | Run `npm run ring:gate -- --iteration 1` (no `@reviewer` in ring 1).                                                                                                                                                                                                               |
-
-Follow `next_orchestrator_action` from handoff when `subagent_stop: true`. See `docs/team/collaboration.md` § Ring 1 engine scaffold.
+| `loop`                | Orchestrator does                                                                                    |
+| --------------------- | ---------------------------------------------------------------------------------------------------- |
+| `clarify`             | **Invoke `@game-designer`**. Do not write design docs or select atoms inline.                        |
+| (after GD STOP)       | **Spawn a temporary ref-flow atom-selection subagent**. Do not select atoms inline.                  |
+| (after selector STOP) | Run scaffold gate (follow `state:get` → `nextCommands`). Set `loop: build`. **Invoke `@developer`**. |
+| `build`               | **Invoke `@developer`**.                                                                             |
+| `verify`              | Run `npm run ring:gate -- --iteration 1`.                                                            |
+
+Follow `next_orchestrator_action` from handoff when `subagent_stop: true`. Sub-agents receive only the user's original intent — they read their own role cards for workflow, constraints, and output requirements. See `docs/team/collaboration.md` § Ring 1 engine scaffold.
 
 ## Deeper References
 

package/project-template/docs/project-state.md

@@ -55,7 +55,7 @@
 
 Each iteration runs inner loops: `clarify` → `build` → `verify` → **Ring Gate** (user acceptance) → next iteration.
 
-<!-- Iteration definitions: see CLAUDE.md § Growth-Ring Model -->
+<!-- Iteration definitions: see docs/team/collaboration.md (growth-rings-v1) -->
 
 ## Ring DoD (current iteration)
 

package/project-template/docs/team/agent-conduct.md

@@ -26,24 +26,24 @@ On every invoke, in order:
 
 ## Orchestrator only
 
-|              | Rule                                                                                                                                                                                              |
-| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **MUST**     | Be the **only** role that uses `AskUserQuestion` for **Ring Gate** confirmations (one per growth ring)                                                                                            |
-| **MUST**     | After any sub-agent STOP, run `npm run state:get` to read `contextPacket` and routing handoff before spawn / resume / Ring Gate                                                                   |
-| **MUST**     | After any sub-agent STOP, verify: `handoffContext` complete, ring DoD evidence complete, logs filled, required preflight done                                                                     |
-| **MUST**     | If `waiting_for: user_gate` and `subagent_stop: true` and `ringGateCanAskUser: yes`, run **only** Ring Gate (`AskUserQuestion`) — **do not** invoke sub-agents                                    |
-| **MUST**     | If `subagent_stop: true` and `waiting_for: orchestrator`, execute **only** `next_orchestrator_action`                                                                                             |
-| **MUST**     | Before invoke: reset handoff (`subagent_stop: false`, `waiting_for: none`, set `subagent` to target role)                                                                                         |
-| **MUST**     | Dispatch = WHAT + skill refs + constraints only; do NOT write detailed production steps for sub-agents                                                                                            |
-| **MUST**     | Before Ring Gate: run `npm run ring:gate -- --iteration N` — do **not** ask user until the script returns pass                                                                                    |
-| **MUST**     | Before **ring 1 `loop: build`**: ensure `playcraft remix init-template --from-atom-tree` has run, `.playcraft-engine` matches `meta.engineDecision.adapter`, and `npm run verify:contract` passes |
-| **MUST**     | After ring 1 Game Designer STOP, spawn a temporary ref-flow atom-selection subagent before scaffold; do not select atoms inline as orchestrator                                                   |
-| **MUST**     | Archive Ring Gate snapshots through `ring:gate` / state helpers so the next ring inherits stable decisions, not prior-ring process noise                                                          |
-| **MUST NOT** | Role-play all five agents in one session when sub-agent invoke is available                                                                                                                       |
-| **MUST NOT** | Advance `iteration` without archiving prior ring in `archivedRings` (non-regression)                                                                                                              |
-| **MUST NOT** | Invoke `@technical-artist` before ring 4 Artist Wave 1 is `done`                                                                                                                                  |
-| **MUST NOT** | Advance `iteration` when a sub-agent could do it — **orchestrator owns** `iteration` / `loop` transitions                                                                                         |
-| **MUST NOT** | Advance to next iteration if post-STOP verification fails (required package, logs/evidence, Skill Preflight)                                                                                      |
+|              | Rule                                                                                                                                                                                                                                                                                           |
+| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **MUST**     | Be the **only** role that uses `AskUserQuestion` for **Ring Gate** confirmations (one per growth ring)                                                                                                                                                                                         |
+| **MUST**     | After any sub-agent STOP, run `npm run state:get` to read `contextPacket` and routing handoff before spawn / resume / Ring Gate                                                                                                                                                                |
+| **MUST**     | After any sub-agent STOP, verify: `handoffContext` complete, ring DoD evidence complete, logs filled, required preflight done                                                                                                                                                                  |
+| **MUST**     | If `waiting_for: user_gate` and `subagent_stop: true` and `ringGateCanAskUser: yes`, run **only** Ring Gate (`AskUserQuestion`) — **do not** invoke sub-agents                                                                                                                                 |
+| **MUST**     | If `subagent_stop: true` and `waiting_for: orchestrator`, execute **only** `next_orchestrator_action`                                                                                                                                                                                          |
+| **MUST**     | Before invoke: reset handoff (`subagent_stop: false`, `waiting_for: none`, set `subagent` to target role)                                                                                                                                                                                      |
+| **MUST**     | Dispatch sub-agents with **only** the user's original intent. Never add: design decisions, engine suggestions, workflow steps, CLI commands, role card summaries, platform constraints, or "you should..." guidance. Sub-agents read their own role cards — orchestrator does not repeat them. |
+| **MUST**     | Before Ring Gate: run `npm run ring:gate -- --iteration N` — do **not** ask user until the script returns pass                                                                                                                                                                                 |
+| **MUST**     | Before **ring 1 `loop: build`**: ensure `playcraft remix init-template --from-atom-tree` has run, `.playcraft-engine` matches `meta.engineDecision.adapter`, and `npm run verify:contract` passes                                                                                              |
+| **MUST**     | After ring 1 Game Designer STOP, spawn a temporary ref-flow atom-selection subagent before scaffold; do not select atoms inline as orchestrator                                                                                                                                                |
+| **MUST**     | Archive Ring Gate snapshots through `ring:gate` / state helpers so the next ring inherits stable decisions, not prior-ring process noise                                                                                                                                                       |
+| **MUST NOT** | Role-play all five agents in one session when sub-agent invoke is available                                                                                                                                                                                                                    |
+| **MUST NOT** | Advance `iteration` without archiving prior ring in `archivedRings` (non-regression)                                                                                                                                                                                                           |
+| **MUST NOT** | Invoke `@technical-artist` before ring 4 Artist Wave 1 is `done`                                                                                                                                                                                                                               |
+| **MUST NOT** | Advance `iteration` when a sub-agent could do it — **orchestrator owns** `iteration` / `loop` transitions                                                                                                                                                                                      |
+| **MUST NOT** | Advance to next iteration if post-STOP verification fails (required package, logs/evidence, Skill Preflight)                                                                                                                                                                                   |
 
 ## Sub-agents only (Game Designer, Artist, TA, Developer, Reviewer)
 

package/project-template/docs/team/collaboration.md

@@ -90,12 +90,22 @@ See [core-model.md § Command Contract](core-model.md#command-contract) and [har
 
 ### Per-ring flow
 
-| Step | Loop    | Agent(s)                                        | STOP → next                                                                                                                                                                                           |
-| ---- | ------- | ----------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| 1    | clarify | `@game-designer` → temporary ref-flow selector  | Orchestrator → ring 1: context packet + compact atom selection → `init-template` + `verify:contract` first → `loop: build` → `@developer`                                                             |
-| 2    | build   | `@developer` (+ Artist/TA per ring)             | Ring 1: Developer self-gate (`verify:contract` + `verify:lifecycle` + `verify:firstwin` + `verify:placeholders`) → `loop: verify` → orchestrator `ring:gate`; ring 2+: → `loop: verify` → `@reviewer` |
-| 3    | verify  | ring 1: orchestrator only; ring 2+: `@reviewer` | Orchestrator → `npm run ring:gate -- --iteration N`                                                                                                                                                   |
-| 4    | —       | **Orchestrator only**                           | If pass → Ring Gate `AskUserQuestion` at devUrl → archive ring → `iteration+1`, `loop: clarify`                                                                                                       |
+| Step | Loop    | Agent(s)                                                                                                                | STOP → next                                                                                                                                                                      |
+| ---- | ------- | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 1    | clarify | `@game-designer` mechanism lock → `@creative-director` (PGS wrap) → `@game-designer` spec → temporary ref-flow selector | Orchestrator → primaryGameplaySkill → north star → design spec (verbatim §0 + PGS) → compact atom selection → `init-template` + `verify:contract` → `loop: build` → `@developer` |
+
+#### Ring 1 clarify — `@creative-director` outputs (`CREATIVE_DIRECTOR_SPLIT=1`)
+
+| Artifact                   | Required fields                                                                                                                                        | Notes                                                                        |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------- |
+| `docs/north-star.md`       | **Micro-Story Spine** (Narrative level, Who, Situation, Stakes, Payoff image, Emotional arc) + One-liner + System Dynamic + Why fusion + Rejected vibe | Creative source of truth; default L1/L2; L0 only when user opts out of story |
+| `docs/creative-process.md` | Phase 1 ≥3 candidates (each with Story hook) + Phase 3 Narrative level rationale + Phase 4 Design Intent                                               | L0 opt-out must cite user wording in Phase 3                                 |
+
+Orchestrator spawn brief: translate user mechanism seed → **Creative question** per `creative-director-kickoff-guide.md`. `@game-designer` spec copies §0 One-liner **verbatim** and Micro-Story Spine **field-value match** into `docs/DESIGN.md` §0.
+
+| 2 | build | `@developer` (+ Artist/TA per ring) | Ring 1: Developer self-gate (`verify:contract` + `verify:lifecycle` + `verify:firstwin` + `verify:placeholders`) → `loop: verify` → orchestrator `ring:gate`; ring 2+: → `loop: verify` → `@reviewer` |
+| 3 | verify | ring 1: orchestrator only; ring 2+: `@reviewer` | Orchestrator → `npm run ring:gate -- --iteration N` |
+| 4 | — | **Orchestrator only** | If pass → Ring Gate `AskUserQuestion` at devUrl → archive ring → `iteration+1`, `loop: clarify` |
 
 ### Ring DoD by iteration
 
@@ -312,7 +322,9 @@ Full detail: `.claude/agents/<role>.md` § Goals.
 │
 ├── docs/project-state.json         ⏳ state-store machine truth
 ├── docs/project-state.md           ⏳ generated read-only view
-├── docs/DESIGN.md                  ⏳ Ring 1 clarify（唯一交付物）
+├── docs/DESIGN.md                  ⏳ Ring 1 clarify（Game Designer spec 交付物）
+├── docs/north-star.md              ⏳ Ring 1 clarify（Creative Director 交付物）
+├── docs/creative-process.md        ⏳ Ring 1 clarify（Creative Director 交付物）
 ├── docs/design-brief.md            ⏳ Ring 2+ 过程日志（Ring 1 不创建）
 ├── docs/atom-tree.json             ⏳ 逐环增长
 ├── docs/layout-spec.md             ⏳ Ring 2+ clarify

package/project-template/docs/team/workflow-changelog.md

@@ -6,6 +6,21 @@ Template workflow spec versions for `packages/cli/project-template`. New project
 
 **Effective**: project-template default for new playable-ad projects (template `0.3.2-alpha.0`).
 
+### 2026-06-28 — Creative Director v2 Micro-Story
+
+- **Enhancement**: Ring 1 creative discovery now defaults to **Micro-Story Spine** (Narrative level / Who / Situation / Stakes / Payoff image / Emotional arc) in `docs/north-star.md` § Micro-Story Spine; L1/L2 are default, L0 only on explicit user opt-out.
+- **Orchestrator kickoff**: read `creative-director-kickoff-guide.md` and inject **Creative question** (Hook frame / pressure meaning / first payoff) — do not forward mechanism spec verbatim to `@creative-director`.
+- **Methodology disclosure**: `disclosure-config` `1:creative` exposes `referenceReads` (five-axis-framework, design-methodology, creative-north-star-examples); agents read via `npm run state:get` summary.
+- **`verify:design`**: independent `validateStorySpine()` + `STORY_SPINE_MODE` (default `warn`); L0 exempts mechanism-chain heuristic; CD STOP hook requires Micro-Story Spine section.
+
+### 2026-06-25 — Creative Director split (Ring 1 creative isolation)
+
+- **Fix**: North Star v2 alone still produced mechanism-chain §0 when Game Designer optimized validators. Ring 1 clarify now routes `@creative-director` → `@game-designer` spec (default `CREATIVE_DIRECTOR_SPLIT=1`).
+- **Outputs**: `docs/north-star.md` (creative source of truth) + `docs/creative-process.md` before DESIGN / skills / verify.
+- **`disclosure-config`**: new `1:creative` and `1:spec` keys; monolithic `1:clarify` when `CREATIVE_DIRECTOR_SPLIT=0` (harness control arm).
+- **Mechanism-first (2026-07)**: adds `1:mechanism` (GD skills read lock) before creative; `verify:design` `mechanismFidelity` vs primary skill PGS — no `mechanism-spine.md`.
+- **`verify:design`**: mechanism-chain heuristic + north-star ↔ DESIGN §0 verbatim sync when split enabled.
+
 ### 2026-06-23 — Ring 1 responsibility split
 
 - **Fix**: split atom-tree selection out of the orchestrator and Game Designer. Ring 1 now routes `@game-designer` → temporary ref-flow atom-selection subagent → scaffold gate → `@developer`.