@arcbridge/core 0.1.6 → 0.2.1

package/dist/index.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 var ServiceSchema = z.object({
   name: z.string().min(1),
   path: z.string().default("."),
-  type: z.enum(["nextjs", "react", "fastify", "express", "hono", "dotnet"]),
+  type: z.enum(["nextjs", "react", "fastify", "express", "hono", "dotnet", "unity"]),
   tsconfig: z.string().optional(),
   csproj: z.string().optional()
 });
@@ -14,7 +14,8 @@ var ArcBridgeConfigSchema = z.object({
     "nextjs-app-router",
     "react-vite",
     "api-service",
-    "dotnet-webapi"
+    "dotnet-webapi",
+    "unity-game"
   ]).default("nextjs-app-router"),
   services: z.array(ServiceSchema).default([]),
   platforms: z.array(z.enum(["claude", "copilot", "gemini", "codex"])).default(["claude"]),
@@ -743,12 +744,44 @@ function configTemplate4(input) {
   };
 }
 
+// src/templates/config/unity-game.ts
+function configTemplate5(input) {
+  return {
+    schema_version: 1,
+    project_name: input.name,
+    project_type: input.template,
+    services: [{ name: "main", path: ".", type: "unity" }],
+    platforms: input.platforms,
+    quality_priorities: input.quality_priorities,
+    indexing: {
+      include: ["Assets/**/*.cs"],
+      exclude: ["Library", "Temp", "obj", "bin", "Logs", "UserSettings", "Packages"],
+      default_mode: "fast",
+      csharp_indexer: "auto"
+    },
+    testing: {
+      test_command: "unity -batchmode -projectPath . -runTests -testPlatform EditMode",
+      timeout_ms: 12e4
+    },
+    drift: {
+      ignore_paths: []
+    },
+    metrics: { auto_record: false },
+    sync: {
+      auto_detect_drift: true,
+      drift_severity_threshold: "warning",
+      propose_updates_on: "phase-complete"
+    }
+  };
+}
+
 // src/generators/config-generator.ts
 var configTemplates = {
   "nextjs-app-router": configTemplate,
   "react-vite": configTemplate2,
   "api-service": configTemplate3,
-  "dotnet-webapi": configTemplate4
+  "dotnet-webapi": configTemplate4,
+  "unity-game": configTemplate5
 };
 function generateConfig(targetDir, input) {
   const templateFn = configTemplates[input.template] ?? configTemplate;
@@ -777,7 +810,7 @@ function introductionTemplate(input) {
 
 ## Requirements Overview
 
-${input.name} is a ${input.template === "nextjs-app-router" ? "Next.js application using the App Router" : input.template === "dotnet-webapi" ? "ASP.NET Core Web API" : "web application"}.
+${input.name} is a ${input.template === "nextjs-app-router" ? "Next.js application using the App Router" : input.template === "dotnet-webapi" ? "ASP.NET Core Web API" : input.template === "unity-game" ? "Unity game built with a code-heavy C# architecture" : "web application"}.
 
 ### Key Features
 
@@ -814,6 +847,10 @@ function techStack(template) {
       return `- **Framework:** Express / Fastify
 - **Language:** TypeScript
 - **Runtime:** Node.js`;
+    case "unity-game":
+      return `- **Engine:** Unity
+- **Language:** C#
+- **Runtime:** Mono / IL2CPP`;
     default:
       return `- **Framework:** Next.js (App Router)
 - **Language:** TypeScript
@@ -882,6 +919,8 @@ function getEntrypoints(template, srcPrefix, appPrefix) {
       return [`${srcPrefix}main.tsx`, `${srcPrefix}App.tsx`];
     case "api-service":
       return [`${srcPrefix}index.ts`, `${srcPrefix}app.ts`, `${srcPrefix}server.ts`];
+    case "unity-game":
+      return ["Assets/Scripts/Core/GameManager.cs"];
     default:
       return [`${srcPrefix}index.ts`];
   }
@@ -891,7 +930,7 @@ function getEntrypoints(template, srcPrefix, appPrefix) {
 function buildingBlocksTemplate(input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const layout = detectProjectLayout(input.projectRoot, input.template);
-  const defaultBlocks = input.template === "dotnet-webapi" ? buildDotnetBlocks(input) : buildJsBlocks(input, layout);
+  const defaultBlocks = input.template === "dotnet-webapi" ? buildDotnetBlocks(input) : input.template === "unity-game" ? buildUnityBlocks() : buildJsBlocks(input, layout);
   function buildJsBlocks(inp, lt) {
     const src = lt.srcPrefix;
     const entries = lt.entrypoints;
@@ -1087,6 +1126,98 @@ function buildingBlocksTemplate(input) {
     });
     return blocks;
   }
+  function buildUnityBlocks() {
+    return [
+      {
+        id: "game-core",
+        name: "Game Core",
+        level: 1,
+        code_paths: ["Assets/Scripts/Core/"],
+        interfaces: [],
+        quality_scenarios: ["PERF-01", "PERF-02"],
+        adrs: [],
+        responsibility: "Game loop, GameManager, state machine, scene management",
+        service: "main"
+      },
+      {
+        id: "input-system",
+        name: "Input System",
+        level: 1,
+        code_paths: ["Assets/Scripts/Input/"],
+        interfaces: [],
+        quality_scenarios: ["PERF-06"],
+        adrs: [],
+        responsibility: "Input handling layer, action maps, platform-independent input abstraction",
+        service: "main"
+      },
+      {
+        id: "player-systems",
+        name: "Player Systems",
+        level: 1,
+        code_paths: ["Assets/Scripts/Player/"],
+        interfaces: ["input-system"],
+        quality_scenarios: [],
+        adrs: [],
+        responsibility: "Player controller, camera system, character state and animation",
+        service: "main"
+      },
+      {
+        id: "gameplay-systems",
+        name: "Gameplay Systems",
+        level: 1,
+        code_paths: ["Assets/Scripts/Gameplay/"],
+        interfaces: ["game-core"],
+        quality_scenarios: ["MAINT-02"],
+        adrs: [],
+        responsibility: "Game mechanics, combat, inventory, AI, physics interactions",
+        service: "main"
+      },
+      {
+        id: "ui-framework",
+        name: "UI Framework",
+        level: 1,
+        code_paths: ["Assets/Scripts/UI/"],
+        interfaces: [],
+        quality_scenarios: ["A11Y-01"],
+        adrs: [],
+        responsibility: "HUD, menus, dialogs, settings screens, and UI event handling",
+        service: "main"
+      },
+      {
+        id: "audio-system",
+        name: "Audio System",
+        level: 1,
+        code_paths: ["Assets/Scripts/Audio/"],
+        interfaces: [],
+        quality_scenarios: [],
+        adrs: [],
+        responsibility: "Music playback, sound effects, spatial audio, and audio mixing",
+        service: "main"
+      },
+      {
+        id: "data-layer",
+        name: "Data Layer",
+        level: 1,
+        code_paths: ["Assets/Scripts/Data/"],
+        interfaces: [],
+        quality_scenarios: [],
+        adrs: [],
+        responsibility: "ScriptableObject definitions, save/load system, game configuration, and persistent data",
+        service: "main"
+      },
+      {
+        id: "editor-tools",
+        name: "Editor Tools",
+        level: 1,
+        code_paths: ["Assets/Editor/"],
+        interfaces: [],
+        quality_scenarios: [],
+        adrs: [],
+        responsibility: "Custom inspectors, editor windows, debug overlays, and development tools",
+        service: "main"
+      }
+    ];
+  }
   return {
     frontmatter: {
       section: "building-blocks",
@@ -1121,6 +1252,15 @@ Client \u2192 Kestrel \u2192 Middleware Pipeline \u2192 Controller / Endpoint
 Client \u2192 HTTP Server \u2192 Middleware \u2192 Route Handler
                                   \u2192 Services
                                   \u2192 Database / External APIs
+\`\`\``;
+    case "unity-game":
+      return `\`\`\`
+Input System \u2192 Player Controller \u2192 Gameplay Systems
+                                 \u2192 Physics / Collision
+GameManager \u2192 State Machine \u2192 Active Game Systems
+                            \u2192 UI Framework
+                            \u2192 Audio System
+Unity Engine \u2192 Update Loop \u2192 Render Pipeline
 \`\`\``;
     default:
       return `\`\`\`
@@ -1140,7 +1280,7 @@ function runtimeViewsTemplate(input) {
 
 ## Key Runtime Scenarios
 
-### Request Flow
+### ${input.template === "unity-game" ? "Game Loop" : "Request Flow"}
 
 ${runtimeDiagram(input.template)}
 
@@ -1168,7 +1308,13 @@ ${input.template === "dotnet-webapi" ? `| Platform | Description | Notes |
 |----------|-------------|-------|
 | Azure App Service | Managed PaaS for .NET | Recommended for ASP.NET Core |
 | Docker / Kubernetes | Container-based | For self-hosted or multi-cloud |
-| AWS ECS / Fargate | Container orchestration | For AWS environments |` : `| Platform | Description | Notes |
+| AWS ECS / Fargate | Container orchestration | For AWS environments |` : input.template === "unity-game" ? `| Platform | Description | Notes |
+|----------|-------------|-------|
+| Steam | PC distribution | Recommended for indie games |
+| Apple App Store | iOS distribution | Requires Xcode build |
+| Google Play | Android distribution | For mobile games |
+| WebGL | Browser-based | For quick prototypes and web distribution |
+| Console | PlayStation, Xbox, Switch | Requires platform-specific SDKs |` : `| Platform | Description | Notes |
 |----------|-------------|-------|
 | Vercel | Recommended for Next.js | Zero-config deployment |
 | Docker | Container-based | For self-hosted environments |`}
@@ -1177,7 +1323,7 @@ ${input.template === "dotnet-webapi" ? `| Platform | Description | Notes |
 
 | Variable | Description | Required |
 |----------|-------------|----------|
-| \`${input.template === "dotnet-webapi" ? "ASPNETCORE_ENVIRONMENT" : "NODE_ENV"}\` | Runtime environment | Yes |
+| \`${input.template === "dotnet-webapi" ? "ASPNETCORE_ENVIRONMENT" : input.template === "unity-game" ? "UNITY_TARGET_PLATFORM" : "NODE_ENV"}\` | ${input.template === "unity-game" ? "Build target platform" : "Runtime environment"} | Yes |
 | *Add your environment variables here* | | |
 `
   };
@@ -1193,6 +1339,8 @@ function firstAdrTemplate(input) {
       return reactViteAdr(input, now);
     case "api-service":
       return apiServiceAdr(input, now);
+    case "unity-game":
+      return unityAdr(input, now);
     default:
       return nextjsAdr(input, now);
   }
@@ -1297,6 +1445,44 @@ Use a Node.js HTTP framework (Express, Fastify, or Hono) as the API service foun
 `
   };
 }
+function unityAdr(input, date) {
+  return {
+    filename: "001-unity-code-heavy.md",
+    frontmatter: {
+      id: "001-unity-code-heavy",
+      title: "Use Unity with Code-Heavy Architecture",
+      status: "accepted",
+      date,
+      affected_blocks: ["game-core", "player-systems"],
+      affected_files: ["Assets/Scripts/"],
+      quality_scenarios: []
+    },
+    body: `# ADR-001: Use Unity with Code-Heavy Architecture
+
+## Context
+
+${input.name} needs a game engine with cross-platform support, strong performance, and a productive development workflow. The team prefers a code-driven approach over hand-crafting scenes in the editor.
+
+## Decision
+
+Use Unity as the game engine with a code-heavy C# architecture. Favor programmatic scene composition, ScriptableObject data architecture, and assembly definitions for modular code organization.
+
+## Consequences
+
+- **Positive:** Version control friendly \u2014 most logic lives in .cs files, not serialized scenes
+- **Positive:** Testable \u2014 gameplay logic can be unit tested without the editor
+- **Positive:** Reusable systems \u2014 assembly definitions enforce module boundaries
+- **Positive:** AI-agent friendly \u2014 agents work effectively with C# scripts
+- **Negative:** More boilerplate than visual scripting or drag-and-drop workflows
+- **Negative:** Scene references require discipline (use ScriptableObjects or addressables)
+- **Negative:** Some Unity features (Animator, Timeline) still require editor interaction
+
+## Agent Limitations
+
+AI agents can review C# scripts, suggest architectural improvements, and check code quality \u2014 but they **cannot** evaluate gameplay feel, frame timing, or visual quality. Use [Unity-MCP](https://github.com/IvanMurzak/Unity-MCP) to give agents basic editor access (scene management, asset operations). For runtime quality (actual FPS, GC spikes, input latency), rely on the Unity Profiler and manual playtesting.
+`
+  };
+}
 function dotnetAdr(input, date) {
   return {
     filename: "001-aspnet-core-webapi.md",
@@ -1611,11 +1797,139 @@ var API_SCENARIOS = {
     }
   ]
 };
+var UNITY_GAME_SCENARIOS = {
+  performance: [
+    {
+      id: "PERF-01",
+      name: "Frame rate stability at 60 FPS",
+      category: "performance",
+      priority: "must",
+      scenario: "Game runs on target hardware during typical gameplay",
+      expected: "Maintains 60 FPS (or platform target) with no frame exceeding 16.7ms",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["game-core"],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-02",
+      name: "Zero per-frame GC allocations in gameplay",
+      category: "performance",
+      priority: "must",
+      scenario: "Gameplay systems run during a typical session",
+      expected: "No GC allocations per frame in hot-path gameplay code (use object pooling)",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["gameplay-systems"],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-03",
+      name: "Draw calls under budget",
+      category: "performance",
+      priority: "should",
+      scenario: "Peak visual complexity scene is rendered",
+      expected: "Draw calls stay under 200 on target hardware (use batching, atlasing, instancing)",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-04",
+      name: "Scene load time under 3s",
+      category: "performance",
+      priority: "should",
+      scenario: "Player transitions between major scenes",
+      expected: "Scene load completes within 3 seconds on minimum-spec hardware",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["game-core"],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-05",
+      name: "Memory usage under platform budget",
+      category: "performance",
+      priority: "should",
+      scenario: "Game is loaded and gameplay session is active",
+      expected: "Memory stays under 512MB on mobile, 2GB on desktop",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "semi-automatic",
+      status: "untested"
+    },
+    {
+      id: "PERF-06",
+      name: "Input-to-visual response under 100ms",
+      category: "performance",
+      priority: "should",
+      scenario: "Player presses an input during gameplay",
+      expected: "Visual feedback appears within 100ms of input",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["input-system", "player-systems"],
+      verification: "semi-automatic",
+      status: "untested"
+    }
+  ],
+  security: [
+    {
+      id: "SEC-01",
+      name: "No client-only validation for multiplayer state",
+      category: "security",
+      priority: "should",
+      scenario: "Game state changes are validated (if multiplayer)",
+      expected: "Critical game state changes are server-authoritative; client cannot cheat by modifying local state",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: [],
+      verification: "manual",
+      status: "untested"
+    }
+  ],
+  reliability: [
+    {
+      id: "REL-01",
+      name: "No unhandled exceptions crash the game",
+      category: "reliability",
+      priority: "should",
+      scenario: "An unexpected error occurs during gameplay",
+      expected: "Error is caught and logged; game recovers gracefully or shows error UI without crashing",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["game-core"],
+      verification: "automatic",
+      status: "untested"
+    }
+  ],
+  accessibility: [
+    {
+      id: "A11Y-01",
+      name: "Color-blind friendly UI",
+      category: "accessibility",
+      priority: "should",
+      scenario: "Player with color vision deficiency plays the game",
+      expected: "Critical UI elements distinguish by shape, pattern, or label \u2014 not color alone",
+      linked_code: [],
+      linked_tests: [],
+      linked_blocks: ["ui-framework"],
+      verification: "manual",
+      status: "untested"
+    }
+  ]
+};
 var TEMPLATE_SCENARIOS = {
   "nextjs-app-router": FRONTEND_SCENARIOS,
   "react-vite": FRONTEND_SCENARIOS,
   "api-service": API_SCENARIOS,
-  "dotnet-webapi": DOTNET_SCENARIOS
+  "dotnet-webapi": DOTNET_SCENARIOS,
+  "unity-game": UNITY_GAME_SCENARIOS
 };
 function mergeScenarios(template, category) {
   const shared = SHARED_SCENARIOS[category] ?? [];
@@ -1835,12 +2149,96 @@ function apiConcepts() {
 - Schema versioning approach for event contracts
 `;
 }
+function unityConcepts() {
+  return `## Scripting Architecture
+
+*Document the code organization and scripting patterns once established.*
+
+- MonoBehaviour vs plain C# class usage guidelines
+- Assembly definition (.asmdef) boundaries and dependencies
+- Component composition patterns
+- Singleton vs dependency injection approach
+
+## Asset Management
+
+*Document how assets are organized and loaded.*
+
+- Folder structure and naming conventions
+- Resource loading strategy (Resources, Addressables, AssetBundles)
+- Asset versioning and memory lifecycle
+- Prefab organization and instantiation patterns
+
+## Scene Management
+
+*Document the scene structure and loading strategy.*
+
+- Scene organization (main scenes, additive scenes, test scenes)
+- Scene loading patterns (async loading, transition effects)
+- DontDestroyOnLoad usage and persistent objects
+- Scene-to-scene data passing
+
+## Physics & Collision
+
+*Document physics setup and collision detection.*
+
+- Physics layers and collision matrix configuration
+- Rigidbody usage guidelines (kinematic vs dynamic)
+- Collision detection mode choices
+- Physics performance budget
+
+## Input Handling
+
+*Document player input processing.*
+
+- Input System package configuration and action maps
+- Input abstraction layer for platform-independent code
+- Rebinding and accessibility considerations
+- Mobile/touch input handling
+
+## Audio
+
+*Document audio implementation.*
+
+- AudioMixer group structure
+- Music vs SFX management and pooling
+- Spatial audio configuration
+- Volume control and persistence
+
+## Visual Effects & Animation
+
+*Document visual effects and animation approach.*
+
+- Particle system conventions
+- Shader usage and material management
+- Animator controller organization and state naming
+- Animation event and callback patterns
+
+## Object Pooling
+
+*Document object pooling strategy.*
+
+- Which objects are pooled (projectiles, effects, enemies)
+- Pool sizing and growth strategy
+- Return-to-pool lifecycle management
+
+## Save System
+
+*Document the save/load approach.*
+
+- Serialization format (JSON, binary, PlayerPrefs)
+- Save data structure and versioning
+- Auto-save and checkpoint strategy
+`;
+}
 function crosscuttingTemplate(input) {
   const isDotnet = input.template === "dotnet-webapi";
   const isFrontend = input.template === "nextjs-app-router" || input.template === "react-vite";
+  const isUnity = input.template === "unity-game";
   let concepts;
   if (isDotnet) {
     concepts = dotnetConcepts();
+  } else if (isUnity) {
+    concepts = unityConcepts();
   } else if (isFrontend) {
     concepts = frontendConcepts();
   } else {
@@ -2843,12 +3241,197 @@ function phaseTasksTemplate4(_input, phaseId) {
   return tasksByPhase[phaseId] ?? null;
 }
 
+// src/templates/phases/unity-game.ts
+function phasePlanTemplate5(_input) {
+  const phases = [
+    {
+      id: "phase-0-setup",
+      name: "Project Setup",
+      phase_number: 0,
+      status: "in-progress",
+      description: "Initialize Unity project structure, configure input system, core game loop, and assembly definitions",
+      gate_requirements: [
+        "Unity project opens and runs without errors",
+        "Assembly definitions (.asmdef) created for each module",
+        "Basic scene loads and game loop runs at target FPS",
+        "Development tooling configured (version control, IDE, logging)"
+      ]
+    },
+    {
+      id: "phase-1-core",
+      name: "Core Systems",
+      phase_number: 1,
+      status: "planned",
+      description: "Player controller, camera system, game state machine, data architecture with ScriptableObjects",
+      gate_requirements: [
+        "Player input responds and controls character/object",
+        "Camera system follows player correctly",
+        "Game state machine handles transitions (menu, playing, paused)",
+        "ScriptableObject data architecture established",
+        "Quality scenarios PERF-01, MAINT-01 verified"
+      ]
+    },
+    {
+      id: "phase-2-gameplay",
+      name: "Gameplay Features",
+      phase_number: 2,
+      status: "planned",
+      description: "Core game mechanics, level design, UI framework, audio integration, save/load system",
+      gate_requirements: [
+        "Core gameplay loop complete and playable",
+        "UI framework in place (HUD, menus, dialogs)",
+        "Audio system integrated (music, SFX)",
+        "Save/load system working",
+        "Performance targets met on target platforms"
+      ]
+    },
+    {
+      id: "phase-3-polish",
+      name: "Polish & Launch",
+      phase_number: 3,
+      status: "planned",
+      description: "Performance profiling, accessibility, platform-specific builds, bug fixes, and release",
+      gate_requirements: [
+        "All quality scenarios passing",
+        "Accessibility audit complete",
+        "Platform-specific builds tested and optimized",
+        "No critical or major bugs outstanding",
+        "Release build successful"
+      ]
+    }
+  ];
+  return { schema_version: 1, phases };
+}
+function phaseTasksTemplate5(_input, phaseId) {
+  const tasksByPhase = {
+    "phase-0-setup": {
+      schema_version: 1,
+      phase_id: "phase-0-setup",
+      tasks: [
+        {
+          id: "task-0.1-project-structure",
+          title: "Set up Unity project folder structure and assembly definitions",
+          status: "todo",
+          building_block: "game-core",
+          quality_scenarios: ["MAINT-01"],
+          acceptance_criteria: [
+            "Folder structure: Assets/Scripts/{Core,Input,Player,Gameplay,UI,Audio,Data}, Assets/Editor/",
+            "Assembly definition (.asmdef) for each script folder",
+            "Version control configured (.gitignore for Library/, Temp/, Logs/)"
+          ]
+        },
+        {
+          id: "task-0.2-core-loop",
+          title: "Implement core game loop and GameManager",
+          status: "todo",
+          building_block: "game-core",
+          quality_scenarios: ["PERF-01"],
+          acceptance_criteria: [
+            "GameManager handles game lifecycle (init, run, pause, quit)",
+            "Main scene loads and runs at target frame rate",
+            "Debug logging infrastructure in place"
+          ]
+        },
+        {
+          id: "task-0.3-input-system",
+          title: "Configure Unity Input System",
+          status: "todo",
+          building_block: "input-system",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "New Input System package installed and configured",
+            "Input action asset with default action maps",
+            "Input abstraction layer for platform-independent handling"
+          ]
+        },
+        {
+          id: "task-0.4-testing",
+          title: "Set up testing infrastructure",
+          status: "todo",
+          quality_scenarios: ["MAINT-02"],
+          acceptance_criteria: [
+            "EditMode test assembly created (NUnit)",
+            "PlayMode test assembly created",
+            "Basic test for GameManager lifecycle"
+          ]
+        }
+      ]
+    },
+    "phase-1-core": {
+      schema_version: 1,
+      phase_id: "phase-1-core",
+      tasks: [
+        {
+          id: "task-1.1-player-controller",
+          title: "Implement player controller and movement",
+          status: "todo",
+          building_block: "player-systems",
+          quality_scenarios: ["PERF-06"],
+          acceptance_criteria: [
+            "Player character spawns and responds to input",
+            "Movement feels responsive (< 100ms input-to-visual)",
+            "Physics/collision configured correctly"
+          ]
+        },
+        {
+          id: "task-1.2-camera-system",
+          title: "Implement camera system",
+          status: "todo",
+          building_block: "player-systems",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "Camera follows player smoothly",
+            "Camera handles transitions and edge cases",
+            "Camera settings configurable via ScriptableObject"
+          ]
+        },
+        {
+          id: "task-1.3-data-architecture",
+          title: "Set up ScriptableObject data architecture",
+          status: "todo",
+          building_block: "data-layer",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "ScriptableObject base types for game config, events, and data",
+            "Event channel pattern for decoupled communication",
+            "Game settings accessible from ScriptableObject assets"
+          ]
+        },
+        {
+          id: "task-1.4-state-machine",
+          title: "Implement game state machine",
+          status: "todo",
+          building_block: "game-core",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "State machine handles: MainMenu, Loading, Playing, Paused, GameOver",
+            "Clean transitions between states",
+            "State-specific systems enabled/disabled correctly"
+          ]
+        },
+        {
+          id: "task-1.5-document-decisions",
+          title: "Document architectural decisions as ADRs",
+          status: "todo",
+          quality_scenarios: [],
+          acceptance_criteria: [
+            "ADR for each significant architecture/pattern choice",
+            "ADRs linked to affected building blocks and code paths"
+          ]
+        }
+      ]
+    }
+  };
+  return tasksByPhase[phaseId] ?? null;
+}
+
 // src/generators/plan-generator.ts
 var planTemplates = {
   "nextjs-app-router": { plan: phasePlanTemplate, tasks: phaseTasksTemplate },
   "react-vite": { plan: phasePlanTemplate2, tasks: phaseTasksTemplate2 },
   "api-service": { plan: phasePlanTemplate3, tasks: phaseTasksTemplate3 },
-  "dotnet-webapi": { plan: phasePlanTemplate4, tasks: phaseTasksTemplate4 }
+  "dotnet-webapi": { plan: phasePlanTemplate4, tasks: phaseTasksTemplate4 },
+  "unity-game": { plan: phasePlanTemplate5, tasks: phaseTasksTemplate5 }
 };
 function generatePlan(targetDir, input) {
   const planDir = join5(targetDir, ".arcbridge", "plan");
@@ -2974,14 +3557,41 @@ You are responsible for maintaining these sections in \`.arcbridge/arc42/\`. Upd
 - All ADRs and their status
 - Building block \u2192 code mapping
 
+## Post-Init Tailoring (CRITICAL \u2014 Do This Before Writing Code)
+
+The building blocks, quality scenarios, and phase tasks generated during init are a **generic starting template**, not a project-specific plan. Before writing any code, systematically tailor the generated content to the actual project:
+
+1. **Building blocks:** Review each generated block against the project description. Delete blocks that don't apply (e.g., "API Client" for a client-only app). Add blocks for the real modules/features you'll build. **Declare interfaces between blocks** to specify dependencies \u2014 drift detection and phase gates rely on this.
+2. **Quality scenarios:** Review each scenario against the project's quality priorities. Delete irrelevant ones (e.g., "API response time" for a localStorage-only app). Add scenarios that reflect the actual requirements.
+3. **Phase tasks:** Phase 0-1 tasks are ready to use. **Phase 2+ tasks are examples \u2014 delete them** and create tasks that match the features you're actually building. Keep phases small and focused (3-6 tasks per phase). Add more phases if needed using \`arcbridge_create_phase\` \u2014 6, 8, or 10 phases is fine for larger projects.
+4. **Reindex** after making changes so drift detection picks up your tailored architecture.
+
+The goal is that by the time you start Phase 0, the building blocks describe your architecture, the quality scenarios test your requirements, and the tasks reflect your build plan.
+
+### Building Block interfaces
+
+Each building block in \`05-building-blocks.md\` should declare its dependencies on other blocks using the \`interfaces\` field. This is required for drift detection to catch undeclared cross-block dependencies at phase gates.
+
+Format \u2014 within the \`blocks:\` array, list the IDs of other blocks this block depends on:
+\`\`\`yaml
+blocks:
+  - id: canvas-engine
+    name: Canvas Engine
+    level: 1
+    responsibility: "Render and manage collaborative canvas state"
+    service: main
+    code_paths:
+      - "src/canvas/"
+    interfaces:
+      - workflow-model
+      - shared-types
+\`\`\`
+
+If your code imports across block boundaries without declaring the interface, \`arcbridge_check_drift\` will flag it and \`arcbridge_complete_phase\` will block the gate.
+
 ## Project Planning
 
-At the start of a project (after init), plan the full roadmap:
-- **ArcBridge generates 4 phases as a starting template** (Setup, Foundation, Features, Polish). These are a baseline \u2014 adapt them to your project's actual scope and complexity.
-- **For larger projects, add more phases** using \`arcbridge_create_phase\`. Split "Core Features" into multiple phases if needed (e.g., "Auth & Users", "Core Business Logic", "Integrations", "Polish").
-- **Phase 0-1 tasks are ready to use** \u2014 they cover setup and foundation for this template
-- **Phase 2+ tasks are examples** \u2014 replace them with real tasks derived from the project's requirements and specifications
-- Review the phase plan with \`arcbridge_get_phase_plan\` and replace example tasks with project-specific ones
+- Review the phase plan with \`arcbridge_get_phase_plan\`
 - Create tasks using \`arcbridge_create_task\` with the phase ID shown in the plan
 - Keep each phase reasonably scoped \u2014 3-6 tasks per phase is ideal
 - Map tasks to building blocks so drift detection tracks coverage
@@ -3492,7 +4102,7 @@ You cannot see screenshots, but you CAN reason about UI quality through code:
 }
 
 // src/generators/agent-generator.ts
-var UI_TEMPLATES = /* @__PURE__ */ new Set(["nextjs-app-router", "react-vite"]);
+var UI_TEMPLATES = /* @__PURE__ */ new Set(["nextjs-app-router", "react-vite", "unity-game"]);
 function writeAgentRole(dir, role) {
   const { system_prompt, ...frontmatter } = role;
   const content = matter2.stringify(system_prompt, frontmatter);
@@ -5957,9 +6567,23 @@ async function indexCSharpTreeSitter(db, options) {
   await ensureCSharpParser();
   const service = options.service ?? "main";
   const projectRoot = options.projectRoot;
+  const ignorePatterns = [
+    "**/bin/**",
+    "**/obj/**",
+    "**/node_modules/**",
+    "**/.git/**",
+    // Unity root-level directories (anchored to avoid matching nested folders
+    // like src/Library/ or src/Packages/ in non-Unity .NET projects)
+    "Library/**",
+    "Temp/**",
+    "Logs/**",
+    "UserSettings/**",
+    "Packages/**",
+    "ProjectSettings/**"
+  ];
   const csFiles = globbySync("**/*.cs", {
     cwd: projectRoot,
-    ignore: ["**/bin/**", "**/obj/**", "**/node_modules/**", "**/.git/**"],
+    ignore: ignorePatterns,
     absolute: false
   });
   const existingHashes = getExistingHashes(db, service);
@@ -6154,6 +6778,9 @@ function loadConfig(projectRoot) {
 
 // src/indexer/index.ts
 function detectProjectLanguage(projectRoot) {
+  if (existsSync7(join14(projectRoot, "ProjectSettings")) && existsSync7(join14(projectRoot, "Assets"))) {
+    return "csharp";
+  }
   if (existsSync7(join14(projectRoot, "tsconfig.json"))) return "typescript";
   if (existsSync7(join14(projectRoot, "package.json"))) return "typescript";
   if (findDotnetProject(projectRoot)) return "csharp";
@@ -6296,6 +6923,17 @@ var FRAMEWORK_IGNORES = {
     "Properties/",
     "Migrations/",
     "wwwroot/"
+  ],
+  "unity-game": [
+    "Library/",
+    "Temp/",
+    "Logs/",
+    "UserSettings/",
+    "Packages/",
+    "ProjectSettings/",
+    "Assets/Plugins/",
+    "obj/",
+    "bin/"
   ]
 };
 function detectDrift(db, options) {
@@ -6560,7 +7198,7 @@ function safeParseJson(value, fallback) {
 
 // src/sync/yaml-writer.ts
 import { join as join15 } from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, unlinkSync } from "fs";
 import { parse as parse2, stringify as stringify4 } from "yaml";
 function syncTaskToYaml(projectRoot, phaseId, taskId, status, completedAt) {
   const taskPath = join15(
@@ -6744,6 +7382,41 @@ function deleteTaskFromYaml(projectRoot, phaseId, taskId) {
     };
   }
 }
+function deletePhaseFromYaml(projectRoot, phaseId) {
+  try {
+    const phasesPath = join15(projectRoot, ".arcbridge", "plan", "phases.yaml");
+    if (!existsSync8(phasesPath)) {
+      return { success: false, warning: "phases.yaml not found" };
+    }
+    const raw = readFileSync8(phasesPath, "utf-8");
+    const result = PhasesFileSchema.safeParse(parse2(raw));
+    if (!result.success) {
+      return {
+        success: false,
+        warning: "Could not parse phases.yaml \u2014 phase may reappear after reindex"
+      };
+    }
+    const phasesFile = result.data;
+    const before = phasesFile.phases.length;
+    phasesFile.phases = phasesFile.phases.filter((p) => p.id !== phaseId);
+    if (phasesFile.phases.length === before) {
+      return { success: false, warning: `Phase '${phaseId}' not found in phases.yaml` };
+    }
+    writeFileSync5(phasesPath, stringify4(phasesFile), "utf-8");
+    const taskFilePath = join15(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
+    try {
+      unlinkSync(taskFilePath);
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      warning: `YAML update failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
 
 // src/sync/task-inference.ts
 function inferTaskStatuses(db, phaseId) {
@@ -7721,6 +8394,7 @@ export {
   addPhaseToYaml,
   addTaskToYaml,
   applyInferences,
+  deletePhaseFromYaml,
   deleteTaskFromYaml,
   detectDrift,
   detectProjectLanguage,