@polymorphism-tech/morph-spec 7.9.4 → 8.0.0

package/src/utils/hooks-installer.js

@@ -15,7 +15,7 @@ import { homedir } from 'os';
 import { execSync } from 'child_process';
 
 /** Current hooks schema version — bump when hook definitions change */
-const HOOKS_VERSION = '3.1.0';
+const HOOKS_VERSION = '3.2.0';
 
 /** Marker for old dispatch.js (v1) */
 const OLD_DISPATCH_COMMAND = 'node framework/hooks/agent-teams/dispatch.js';
@@ -26,22 +26,24 @@ const OLD_DISPATCH_COMMAND = 'node framework/hooks/agent-teams/dispatch.js';
  * state.json is NOT in deny because the agent edits it directly as a
  * fallback to the state-sync hook (per v7 hybrid state model). The
  * framework/ tree remains read-only — only the installer touches it.
+ *
+ * `Edit(path)` ONLY — never a matching `Write(path)`. Claude Code matches file
+ * permissions on `Edit(path)` rules alone; an `Edit` rule covers every
+ * file-editing tool, Write included, while a `Write(path)` rule matches nothing
+ * and is reported as a warning on every session start. Verified empirically, not
+ * assumed: with `Edit(.morph/framework/**)` as the ONLY deny entry, the Write
+ * tool was refused and the target file was never created.
  */
 const MORPH_DENY = [
   // Framework files — installer-managed, immutable at runtime
-  'Write(.morph/framework/**)',
   'Edit(.morph/framework/**)',
   // .claude/CLAUDE.md (managed copy — source is framework/CLAUDE.md)
-  'Write(.claude/CLAUDE.md)',
   'Edit(.claude/CLAUDE.md)',
   // .claude/rules/ (copied from framework/rules/)
-  'Write(.claude/rules/**)',
   'Edit(.claude/rules/**)',
   // .claude/agents/morph-* (generated by agents-installer)
-  'Write(.claude/agents/morph-*)',
   'Edit(.claude/agents/morph-*)',
   // .claude/skills/ (copied from framework/skills/)
-  'Write(.claude/skills/**)',
   'Edit(.claude/skills/**)',
 ];
 
@@ -51,15 +53,16 @@ const MORPH_DENY = [
  * Pre-authorizes operations the agent legitimately performs during the
  * morph-spec flow, so the user does not get permission prompts on every
  * proposal.md / spec.md / tasks.json write.
+ *
+ * `Edit(path)` ONLY, for the same reason as MORPH_DENY: the `Edit` rule already
+ * covers Write, and a `Write(path)` rule is inert noise.
  */
 const MORPH_ALLOW = [
   // Feature artifacts — the agent's working directory during proposal/plan/implement/review
-  'Write(.morph/features/**)',
   'Edit(.morph/features/**)',
   // state.json — fallback path when state-sync hook can't cover a case
   'Edit(.morph/state.json)',
   // Long-lived architectural context — agent may reconcile during brainstorming
-  'Write(.morph/context/**)',
   'Edit(.morph/context/**)',
   // Folder creation under .morph
   'Bash(mkdir:.morph/**)',
@@ -74,6 +77,19 @@ const MORPH_PERMISSIONS = MORPH_DENY;
  * Each entry maps to a Claude Code hook event.
  */
 const MORPH_HOOKS = [
+  // === SessionStart — worktree feature identity (secondary worktree) or
+  // active-feature summary (primary root). Fulfills the SessionStart
+  // injection role long documented but never wired (inject-morph-context.js). ===
+  {
+    event: 'SessionStart',
+    matcher: null,
+    hooks: [{
+      type: 'command',
+      command: 'node framework/hooks/claude-code/core/worktree-context.js',
+      timeout: 5000
+    }]
+  },
+
   // === PreToolUse: Write|Edit — phase + spec protection (silent on success) ===
   {
     event: 'PreToolUse',
@@ -266,11 +282,21 @@ export async function installClaudeHooks(targetPath) {
   settings.permissions.deny = settings.permissions.deny || [];
   settings.permissions.allow = settings.permissions.allow || [];
 
-  // Stale-entry cleanup: remove old morph-managed deny entries (e.g. state.json
-  // was previously in deny — v7 moves it to allow)
+  // Stale-entry cleanup: remove morph-managed entries we no longer install.
+  // The filters below drop `MORPH_*.includes(p)` before re-adding, so an entry
+  // that LEFT those lists would otherwise survive forever in an existing
+  // install — the upgrade path has to name it explicitly to reclaim it.
+  //   - state.json: was in deny pre-v7, now lives in allow.
+  //   - Write(...): matched nothing and made Claude Code warn on every session
+  //     start; the paired Edit(...) rule is what actually enforced them.
   const STALE_DENY = [
     'Write(.morph/state.json)',
     'Edit(.morph/state.json)',
+    'Write(.morph/framework/**)',
+    'Write(.claude/CLAUDE.md)',
+    'Write(.claude/rules/**)',
+    'Write(.claude/agents/morph-*)',
+    'Write(.claude/skills/**)',
   ];
   settings.permissions.deny = settings.permissions.deny.filter(
     p => !MORPH_DENY.includes(p) && !STALE_DENY.includes(p)
@@ -279,8 +305,12 @@ export async function installClaudeHooks(targetPath) {
     settings.permissions.deny.push(perm);
   }
 
+  const STALE_ALLOW = [
+    'Write(.morph/features/**)',
+    'Write(.morph/context/**)',
+  ];
   settings.permissions.allow = settings.permissions.allow.filter(
-    p => !MORPH_ALLOW.includes(p)
+    p => !MORPH_ALLOW.includes(p) && !STALE_ALLOW.includes(p)
   );
   for (const perm of MORPH_ALLOW) {
     settings.permissions.allow.push(perm);

package/src/utils/skills-installer.js

@@ -1,174 +1,174 @@
-/**
- * Skills Installer
- *
- * Copies framework skills to .claude/skills/ during morph-spec init.
- * Installs only the `core/` skill set — the canonical NLH skills referenced by
- * MORPH.md (morph-brainstorming, morph-stack-scan, morph-plan, morph-implement,
- * morph-eval, morph-review, morph-standards). The 3-tier system was collapsed
- * into a single source of truth in framework/skills/core/.
- *
- * Source skills are directory-based: framework/skills/core/{skill-name}/SKILL.md
- * (plus optional scripts/, references/, assets/ subdirectories).
- *
- * Directory-based skills have their entire directory copied so Claude Code can
- * execute scripts and load references on demand.
- */
-
-import { mkdirSync, copyFileSync, existsSync, readdirSync, statSync, readFileSync, rmSync } from 'fs';
-import { join } from 'path';
-import { fileURLToPath } from 'url';
-import { parseStacks, shouldInstall } from '../lib/stack-filter.js';
-
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
-const FRAMEWORK_SKILLS_DIR = join(__dirname, '..', '..', 'framework', 'skills');
-
-/**
- * Skill levels to install in .claude/skills/.
- * Only `core/` survives — single source of truth aligned with MORPH.md.
- */
-const SKILL_LEVELS_TO_INSTALL = ['core'];
-
-/**
- * Check if a skill should be installed based on its stacks: frontmatter.
- * @param {string} skillContent - Raw SKILL.md content
- * @param {string[]} projectTags - Stack tags from config
- * @returns {boolean}
- */
-export function shouldInstallSkill(skillContent, projectTags) {
-  return shouldInstall(parseStacks(skillContent), projectTags);
-}
-
-/**
- * Recursively copy a directory tree from src to dest.
- * Creates dest if it doesn't exist. Skips README.md files.
- *
- * @param {string} src - Source directory path
- * @param {string} dest - Destination directory path
- */
-function copyDirectory(src, dest) {
-  mkdirSync(dest, { recursive: true });
-  for (const entry of readdirSync(src)) {
-    if (entry === 'README.md') continue;
-    const srcPath = join(src, entry);
-    const destPath = join(dest, entry);
-    if (statSync(srcPath).isDirectory()) {
-      copyDirectory(srcPath, destPath);
-    } else {
-      copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-/**
- * Walk srcDir and install skills into destDir.
- *
- * Handles two source formats:
- *   1. Directory-based skill: srcDir/{skill-name}/SKILL.md
- *      → copies entire directory (SKILL.md + scripts/ + references/ + assets/)
- *      → destDir/{skill-name}/
- *
- *   2. Flat .md skill (legacy): srcDir/{skill-name}.md
- *      → destDir/{skill-name}/SKILL.md
- *
- * The `core/` level directory is traversed recursively. A directory is
- * recognized as a skill directory when it contains a SKILL.md file.
- *
- * @param {string} srcDir - Source directory to walk
- * @param {string} destDir - Destination base directory (.claude/skills/)
- */
-function installSkillsFromDir(srcDir, destDir, projectTags) {
-  const entries = readdirSync(srcDir);
-  for (const entry of entries) {
-    const srcPath = join(srcDir, entry);
-    const stat = statSync(srcPath);
-
-    if (stat.isDirectory()) {
-      const skillMdPath = join(srcPath, 'SKILL.md');
-      if (existsSync(skillMdPath)) {
-        // Directory-based skill — check stack filter before copying
-        const content = readFileSync(skillMdPath, 'utf-8');
-        if (!shouldInstallSkill(content, projectTags)) continue;
-        const skillDestDir = join(destDir, entry);
-        copyDirectory(srcPath, skillDestDir);
-      } else {
-        // Level/category directory — recurse
-        installSkillsFromDir(srcPath, destDir, projectTags);
-      }
-    } else if (entry.endsWith('.md') && entry !== 'README.md') {
-      // Legacy flat .md skill — check stack filter before copying
-      const content = readFileSync(srcPath, 'utf-8');
-      if (!shouldInstallSkill(content, projectTags)) continue;
-      const skillName = entry.slice(0, -3);
-      const skillDir = join(destDir, skillName);
-      mkdirSync(skillDir, { recursive: true });
-      copyFileSync(srcPath, join(skillDir, 'SKILL.md'));
-    }
-  }
-}
-
-function collectSourceSkillNames() {
-  const names = new Set();
-  for (const level of SKILL_LEVELS_TO_INSTALL) {
-    const levelDir = join(FRAMEWORK_SKILLS_DIR, level);
-    if (!existsSync(levelDir)) continue;
-    collectNamesFromDir(levelDir, names);
-  }
-  return names;
-}
-
-function collectNamesFromDir(dir, names) {
-  for (const entry of readdirSync(dir)) {
-    const fullPath = join(dir, entry);
-    if (!statSync(fullPath).isDirectory()) continue;
-    if (existsSync(join(fullPath, 'SKILL.md'))) {
-      names.add(entry);
-    } else {
-      collectNamesFromDir(fullPath, names);
-    }
-  }
-}
-
-/**
- * Install morph framework skills to .claude/skills/ in the target project.
- * Skills are copied into subdirectories as SKILL.md files so Claude Code can
- * discover them natively via /<skill-name> syntax (e.g., /phase-design,
- * /nextjs-expert). Directory-based skills also get their scripts/,
- * references/, and assets/ subdirectories copied for on-demand loading.
- *
- * Stack filtering: if projectTags is provided, only skills whose `stacks:`
- * frontmatter matches the project tags are installed. Skills without a
- * `stacks:` field are always installed (universal).
- *
- * @param {string} projectDir - Target project root directory
- * @param {Object} [options]
- * @param {string[]} [options.projectTags=[]] - Stack tags from config
- */
-export async function installSkills(projectDir, { projectTags = [] } = {}) {
-  const claudeSkillsDir = join(projectDir, '.claude', 'skills');
-  mkdirSync(claudeSkillsDir, { recursive: true });
-
-  for (const level of SKILL_LEVELS_TO_INSTALL) {
-    const levelDir = join(FRAMEWORK_SKILLS_DIR, level);
-    if (!existsSync(levelDir)) continue;
-    installSkillsFromDir(levelDir, claudeSkillsDir, projectTags);
-  }
-
-  // Collect installed morph-* skill names
-  const installed = new Set();
-  for (const entry of readdirSync(claudeSkillsDir)) {
-    if (existsSync(join(claudeSkillsDir, entry, 'SKILL.md'))) {
-      installed.add(entry);
-    }
-  }
-
-  // Cleanup orphan morph-* skill dirs that exist in source but were filtered out
-  const allSourceSkills = collectSourceSkillNames();
-  for (const entry of readdirSync(claudeSkillsDir)) {
-    if (!entry.startsWith('morph-')) continue;
-    if (!installed.has(entry) && allSourceSkills.has(entry)) {
-      rmSync(join(claudeSkillsDir, entry), { recursive: true, force: true });
-    }
-  }
-
-  return { installed: installed.size };
-}
+/**
+ * Skills Installer
+ *
+ * Copies framework skills to .claude/skills/ during morph-spec init.
+ * Installs only the `core/` skill set — the canonical NLH skills referenced by
+ * MORPH.md (morph-brainstorming, morph-stack-scan, morph-plan, morph-implement,
+ * morph-eval, morph-review, morph-standards). The 3-tier system was collapsed
+ * into a single source of truth in framework/skills/core/.
+ *
+ * Source skills are directory-based: framework/skills/core/{skill-name}/SKILL.md
+ * (plus optional scripts/, references/, assets/ subdirectories).
+ *
+ * Directory-based skills have their entire directory copied so Claude Code can
+ * execute scripts and load references on demand.
+ */
+
+import { mkdirSync, copyFileSync, existsSync, readdirSync, statSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { parseStacks, shouldInstall } from '../lib/stack-filter.js';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const FRAMEWORK_SKILLS_DIR = join(__dirname, '..', '..', 'framework', 'skills');
+
+/**
+ * Skill levels to install in .claude/skills/.
+ * Only `core/` survives — single source of truth aligned with MORPH.md.
+ */
+const SKILL_LEVELS_TO_INSTALL = ['core'];
+
+/**
+ * Check if a skill should be installed based on its stacks: frontmatter.
+ * @param {string} skillContent - Raw SKILL.md content
+ * @param {string[]} projectTags - Stack tags from config
+ * @returns {boolean}
+ */
+export function shouldInstallSkill(skillContent, projectTags) {
+  return shouldInstall(parseStacks(skillContent), projectTags);
+}
+
+/**
+ * Recursively copy a directory tree from src to dest.
+ * Creates dest if it doesn't exist. Skips README.md files.
+ *
+ * @param {string} src - Source directory path
+ * @param {string} dest - Destination directory path
+ */
+function copyDirectory(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  for (const entry of readdirSync(src)) {
+    if (entry === 'README.md') continue;
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    if (statSync(srcPath).isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Walk srcDir and install skills into destDir.
+ *
+ * Handles two source formats:
+ *   1. Directory-based skill: srcDir/{skill-name}/SKILL.md
+ *      → copies entire directory (SKILL.md + scripts/ + references/ + assets/)
+ *      → destDir/{skill-name}/
+ *
+ *   2. Flat .md skill (legacy): srcDir/{skill-name}.md
+ *      → destDir/{skill-name}/SKILL.md
+ *
+ * The `core/` level directory is traversed recursively. A directory is
+ * recognized as a skill directory when it contains a SKILL.md file.
+ *
+ * @param {string} srcDir - Source directory to walk
+ * @param {string} destDir - Destination base directory (.claude/skills/)
+ */
+function installSkillsFromDir(srcDir, destDir, projectTags) {
+  const entries = readdirSync(srcDir);
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry);
+    const stat = statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      const skillMdPath = join(srcPath, 'SKILL.md');
+      if (existsSync(skillMdPath)) {
+        // Directory-based skill — check stack filter before copying
+        const content = readFileSync(skillMdPath, 'utf-8');
+        if (!shouldInstallSkill(content, projectTags)) continue;
+        const skillDestDir = join(destDir, entry);
+        copyDirectory(srcPath, skillDestDir);
+      } else {
+        // Level/category directory — recurse
+        installSkillsFromDir(srcPath, destDir, projectTags);
+      }
+    } else if (entry.endsWith('.md') && entry !== 'README.md') {
+      // Legacy flat .md skill — check stack filter before copying
+      const content = readFileSync(srcPath, 'utf-8');
+      if (!shouldInstallSkill(content, projectTags)) continue;
+      const skillName = entry.slice(0, -3);
+      const skillDir = join(destDir, skillName);
+      mkdirSync(skillDir, { recursive: true });
+      copyFileSync(srcPath, join(skillDir, 'SKILL.md'));
+    }
+  }
+}
+
+function collectSourceSkillNames() {
+  const names = new Set();
+  for (const level of SKILL_LEVELS_TO_INSTALL) {
+    const levelDir = join(FRAMEWORK_SKILLS_DIR, level);
+    if (!existsSync(levelDir)) continue;
+    collectNamesFromDir(levelDir, names);
+  }
+  return names;
+}
+
+function collectNamesFromDir(dir, names) {
+  for (const entry of readdirSync(dir)) {
+    const fullPath = join(dir, entry);
+    if (!statSync(fullPath).isDirectory()) continue;
+    if (existsSync(join(fullPath, 'SKILL.md'))) {
+      names.add(entry);
+    } else {
+      collectNamesFromDir(fullPath, names);
+    }
+  }
+}
+
+/**
+ * Install morph framework skills to .claude/skills/ in the target project.
+ * Skills are copied into subdirectories as SKILL.md files so Claude Code can
+ * discover them natively via /<skill-name> syntax (e.g., /phase-design,
+ * /nextjs-expert). Directory-based skills also get their scripts/,
+ * references/, and assets/ subdirectories copied for on-demand loading.
+ *
+ * Stack filtering: if projectTags is provided, only skills whose `stacks:`
+ * frontmatter matches the project tags are installed. Skills without a
+ * `stacks:` field are always installed (universal).
+ *
+ * @param {string} projectDir - Target project root directory
+ * @param {Object} [options]
+ * @param {string[]} [options.projectTags=[]] - Stack tags from config
+ */
+export async function installSkills(projectDir, { projectTags = [] } = {}) {
+  const claudeSkillsDir = join(projectDir, '.claude', 'skills');
+  mkdirSync(claudeSkillsDir, { recursive: true });
+
+  for (const level of SKILL_LEVELS_TO_INSTALL) {
+    const levelDir = join(FRAMEWORK_SKILLS_DIR, level);
+    if (!existsSync(levelDir)) continue;
+    installSkillsFromDir(levelDir, claudeSkillsDir, projectTags);
+  }
+
+  // Collect installed morph-* skill names
+  const installed = new Set();
+  for (const entry of readdirSync(claudeSkillsDir)) {
+    if (existsSync(join(claudeSkillsDir, entry, 'SKILL.md'))) {
+      installed.add(entry);
+    }
+  }
+
+  // Cleanup orphan morph-* skill dirs that exist in source but were filtered out
+  const allSourceSkills = collectSourceSkillNames();
+  for (const entry of readdirSync(claudeSkillsDir)) {
+    if (!entry.startsWith('morph-')) continue;
+    if (!installed.has(entry) && allSourceSkills.has(entry)) {
+      rmSync(join(claudeSkillsDir, entry), { recursive: true, force: true });
+    }
+  }
+
+  return { installed: installed.size };
+}

package/framework/templates/meta-prompts/parallel-workers/parallel-coordinator.md

@@ -1,113 +0,0 @@
-# Parallel Coordinator — {{AGENT_ID}}
-
-You are the **Parallel Coordinator** overseeing a P-Thread execution session.
-
-## Your Identity
-- Agent: {{AGENT_ID}}
-- Role: Parallel Coordinator (Orchestrator Tier)
-- Session ID: {{SESSION_ID}}
-- Feature: {{FEATURE_NAME}}
-
-## Your Mission
-Coordinate {{WORKER_COUNT}} parallel workers executing concurrently, then merge and validate their outputs.
-
-## Workers Under Coordination
-
-{{WORKERS}}
-
-Each worker has isolated file scope — no cross-worker dependencies during execution.
-
-## Execution Plan
-
-### Phase 1: Pre-Execution Validation
-Before spawning workers, verify:
-- [ ] All workers have non-overlapping file scopes
-- [ ] No circular dependencies between workers
-- [ ] Shared read files are available (spec.md, standards, contracts)
-- [ ] State is set to `parallel-executing`
-
-### Phase 2: Spawn Workers
-Spawn all workers concurrently using Task tool:
-```
-Task tool × {{WORKER_COUNT}} simultaneous invocations
-Strategy: {{PARALLEL_STRATEGY}}
-Max concurrent: {{MAX_CONCURRENT}}
-```
-
-### Phase 3: Wait for Completion
-Monitor workers — do NOT proceed until all report back (or timeout):
-- Success: Worker returns COMPLETE report
-- Partial: Worker returns PARTIAL — merge what's available
-- Timeout: After {{TIMEOUT_MINUTES}} minutes, mark as PARTIAL and proceed
-- Failed: Document failure, continue with successful workers
-
-### Phase 4: Merge Results
-After all workers complete:
-1. Collect all "Files Created" from worker reports
-2. Check for conflicts (same filename from different workers)
-3. If conflicts: Apply `{{MERGE_STRATEGY}}` strategy
-4. Update state with combined file list
-
-### Phase 5: Integration Validation
-Run cross-worker validation:
-```bash
-morph-spec validate architecture --feature={{FEATURE_NAME}}
-morph-spec validate security --feature={{FEATURE_NAME}}
-```
-
-Check that:
-- Files from all workers are consistent (same types, interfaces, naming)
-- No duplicate functionality across workers
-- Integration points (shared interfaces, types) are compatible
-
-## Spec Summary
-{{SPEC_SUMMARY}}
-
-## Merge Strategies
-
-| Strategy | When to Use |
-|----------|-------------|
-| `last-wins` | Non-overlapping files (default — workers shouldn't overlap) |
-| `manual-review` | Conflicting implementations of same file |
-| `best-score` | Multiple implementations of same logic (use checkpoint scores) |
-
-## Your Tasks
-
-### Pre-Spawn
-{{PRE_SPAWN_TASKS}}
-
-### Post-Merge
-{{POST_MERGE_TASKS}}
-
-## Completion Report
-
-When all workers are merged and validated:
-
-```
-COORDINATOR REPORT
-Session: {{SESSION_ID}}
-Feature: {{FEATURE_NAME}}
-Status: [SUCCESS | PARTIAL | FAILED]
-
-Worker Results:
-{{#each WORKERS}}
-  - {{this.agent}}: [COMPLETE | PARTIAL | FAILED] — {{this.filesCreated}} files
-{{/each}}
-
-Total Files Created: X
-Conflicts Resolved: Y
-Integration Validation: [PASSED | FAILED]
-
-Final File List:
-- [all files from all workers]
-
-Next Steps:
-- [what the main thread should do with these outputs]
-```
-
-## Constraints
-{{CONSTRAINTS}}
-
-- Never modify worker outputs without documenting the change
-- If merge conflict cannot be auto-resolved, escalate to user
-- Coordinator does NOT implement features — only orchestrates and validates

package/framework/templates/meta-prompts/parallel-workers/parallel-worker.md

@@ -1,80 +0,0 @@
-# Parallel Worker — {{AGENT_ID}}
-
-You are a **Parallel Worker** (P-Thread) executing concurrently with other agents.
-
-## Your Identity
-- Agent: {{AGENT_ID}}
-- Role: Parallel Worker (P-Thread)
-- Thread ID: {{THREAD_ID}}
-- Feature: {{FEATURE_NAME}}
-
-## Your Isolated Mission
-{{MISSION}}
-
-## CRITICAL: Isolation Rules
-
-You are running **concurrently** with other workers. To avoid conflicts:
-
-1. **Write ONLY to your assigned files** (listed under Deliverables)
-2. **Do NOT modify shared files** (state.json, agents.json, config files)
-3. **Do NOT depend on output from other parallel workers** (your tasks are self-contained)
-4. **Read from shared files is OK** (spec.md, standards, contracts)
-5. **Report blockers** instead of waiting for another worker
-
-## Your Assigned Scope
-{{SCOPE}}
-
-Files you OWN (safe to create/modify):
-{{DELIVERABLES}}
-
-Files you can READ (shared, do not modify):
-- `.morph/features/{{FEATURE_NAME}}/2-design/spec.md`
-- `framework/standards/` (all)
-- `.morph/features/{{FEATURE_NAME}}/2-design/contracts.*`
-
-## Spec Summary
-{{SPEC_SUMMARY}}
-
-## Standards to Follow
-{{STANDARDS}}
-
-## Your Tasks (Isolated)
-{{TASKS}}
-
-These tasks are **independent** — no cross-worker dependencies. If you encounter a dependency, document it and skip.
-
-## How to Work
-1. Verify your file scope — check you're not touching shared files
-2. Implement tasks in order within your scope
-3. After every 3 tasks, persist completed tasks to `tasks.json` (`status`/`outputs`/`notes` only) and run the checkpoint
-4. If blocked by missing dependency, note it in your report and continue
-5. Complete ALL tasks in your scope before reporting back
-
-## Completion Report
-When done, provide a structured report:
-
-```
-PARALLEL WORKER REPORT
-Thread: {{THREAD_ID}}
-Agent: {{AGENT_ID}}
-Status: [COMPLETE | PARTIAL | BLOCKED]
-
-Files Created:
-- [list each file with brief description]
-
-Files Modified:
-- [list each file with what changed]
-
-Tasks Completed: X/Y
-Tasks Skipped: [list with reason]
-
-Blockers:
-- [any dependencies or conflicts encountered]
-
-Checkpoints: [PASSED | FAILED | N/A]
-```
-
-## Important
-- Do NOT wait for other workers — complete what you can
-- Do NOT create files outside your assigned scope
-- Coordinator will merge results after all workers complete