@warpgogol/forge 1.1.0 → 2.1.0

package/AGENTS.md

@@ -7,7 +7,7 @@ Portable governance skills and command modules extracted from the engine (RFC-03
 - `src/` — portable, no kernel imports. Contains skill schema, registry, validators, onboarding handlers, config module, canonical types, and utilities.
 - `os/` — ForgeModule registrations. RFC-0556: `os/compass/` and `os/werkstatt/` are fully autonomous — all command handlers are inlined in `os/*/handlers/` and no longer dynamically import `@warpgogol/*` packages. Other `os/` modules may still use dynamic imports where kernel integration is needed.
 - `bin/` — CLI entrypoint (`forge` command) for autonomous usage without `@warpgogol/werkstatt`.
-- `skills/` — forge-managed skill definitions (38 fo skills + 5 shared + 3 meta = 46 skills). Project-declared skill packs (RFC-0539) live outside forge and are discovered via `discoverPackSkills` from `forge.yaml` `skillPacks` config.
+- `skills/` — forge-managed skill definitions (35 fo skills + 5 shared + 3 meta = 43 skills). Project-declared skill packs (RFC-0539) live outside forge and are discovered via `discoverPackSkills` from `forge.yaml` `skillPacks` config.
 
 ## RFC-0855 program control-plane boundary
 
@@ -70,6 +70,7 @@ Skills live in `skills/` and are synced to `.agents/skills/` by `create`. Each s
 - **When editing a skill in `packages/forge/skills/`**, the synced copy in `.agents/skills/<name>/SKILL.md` MUST also be committed in the same session — `create` is not run automatically after manual edits. Stale `.agents/skills/` copies cause `doctor` to report drift.
 - **Canonical sync path is flat**: `.agents/skills/<name>/SKILL.md` (e.g. `.agents/skills/fo-idea-implement/SKILL.md`). Both `create` (`init.ts`) and `upgrade` (`upgrade.ts`) sync to this flat path. A nested `.agents/skills/fo/<name>/SKILL.md` path is NOT created or maintained by forge — it is a stale artifact if present and should be removed.
 - **`FORGE_SKILLS[].path` is relative to the forge package root** and already includes the `skills/` prefix — resolve via `path.join(forgeRoot, skill.path)` (see `init.ts`). Never join a `skillsRoot` with `skill.path`: that produces a doubled `skills/skills/` prefix and silently finds nothing.
+- **When renumbering steps in SKILL.md files** (inserting or removing a numbered step), grep for hard-coded step numbers across all `.md` files in the repo. Cross-references to `fo-idea-implement` step numbers exist in `PREFERENCES.md`, `fo-doc-audit/SKILL.md`, and `fo-session-retro/SKILL.md` — these break silently when steps shift. Always update all cross-references in the same commit.
 
 The `concerns` field uses a four-level taxonomy (RFC-0523): `read-only` (no file modifications), `document-only` (modifies `.md` files only), `content-mutation` (modifies content `.md`/`.yaml` but not executable code), `code-mutation` (modifies `.ts`/`.astro` code). `skill.validate` enforces this via SKILL-12.
 
@@ -105,21 +106,9 @@ skillPacks:
 - **MUST** use `hasGeneratedMarker()` from `utils/index.ts` for detecting generated file markers — never use raw `content.includes("GENERATED")` which is fragile and breaks if the marker format changes.
 - **Compass shared flags:** New flags for compass commands MUST be added to the shared `compassScanFlags` object in `os/compass/compass.module.ts`, not to individual command definitions. The `compassScanFlags` object is spread into all compass commands that use `flags: { ...compassScanFlags }`, ensuring the flag is available consistently across the command family. Per-command flags that are unique to one command may be defined inline.
 - **CLI flags must be wired to behavior.** Every flag declared in a command registration MUST affect the command's output or behavior — not just be read and stored. A flag that is read but never used is dead code and a contract violation. When adding a flag, implement its behavioral effect in the same commit. Verify by searching for the flag variable name in the handler function body.
-- **Profile-driven workspace detection is domain-neutral.** `workspaceTypes` from a stack profile must replace hardcoded workspace detection for ALL domains, not just software. Do NOT gate `checkNestedAgentsMd` or `discoverWorkspaces` by `isSoftwareDomain` — that silently skips the check for non-software domains (video, creative, etc.). When `workspaceTypes` is present, it fully replaces hardcoded detection; when absent, hardcoded detection is the fallback for all domains.
+- **Profile-driven workspace detection is domain-neutral.** `workspaceTypes` from a stack profile must replace hardcoded workspace detection for ALL domains, not just software. Do NOT gate `checkNestedAgentsMd` or `discoverWorkspaces` by `isSoftwareDomain` — that silently skips the check for non-software domains (game, creative, etc.). When `workspaceTypes` is present, it fully replaces hardcoded detection; when absent, hardcoded detection is the fallback for all domains.
 - **`command-registered` probes MUST fall back to command manifest.** The `command-registered` probe in `os/rfc/acceptance.ts` uses `commandRegistry?.listCommands()`, which only sees workspace-scoped commands (forge modules). App-scoped commands from `werkstatt-site/checks` are invisible to the workspace-level registry. Always include a `loadManifestCommandNames(workspaceRoot)` fallback, matching the pattern already used in `os/rfc/handlers/lifecycle.ts`. Without this, `rfc.acceptance.run` and `rfc.verification.emit` will falsely report app-scoped commands as "not registered".
 
-## Editframe template rules
-
-- **TimelineRoot MUST NOT be used inside Workbench.** `TimelineRoot` renders a `<div style="display: contents">` wrapper that breaks `EFWorkbenchElement.#initialize()` — it searches for `TemporalElement` among direct children of `ef-canvas`, but the div wrapper makes `ef-timegroup` a grandchild instead of a direct child. The correct structure is `Workbench > Configuration > Timegroup`. `TimelineRoot` is only valid outside `Workbench` (e.g. standalone render compositions without preview).
-- **Text content MUST be passed as children, not via `text` prop.** `ef-text` reads text from child text nodes via `#captureRawText()`, not from the `text` attribute. Use `<Text style={{ color: "white" }}>Hello</Text>`, not `<Text text="Hello" color="white" />`.
-- **Text styling MUST use the `style` prop or CSS classes, not HTML attributes.** `ef-text` does not read `x`, `y`, `fontSize`, `color`, `textAlign` as attributes. Pass them via `style={{ fontSize: "48px", color: "white" }}` or Tailwind classes.
-- **Timegroup inside Workbench MUST have explicit dimensions.** Without `style={{ width, height }}`, `Timegroup` renders as a 0×0 inline element. Set dimensions matching the composition resolution (e.g. `1920px` × `1080px`).
-- **main.tsx MUST set `height: 100%` on `html`, `body`, and `#root`** and override `ef-workbench { display: grid }` after importing `@editframe/elements/styles.css`. The document-level `ef-workbench { display: block }` rule overrides the shadow DOM `:host { display: grid }`, breaking the grid layout and making the preview invisible.
-- **In `contain` mode, parent duration = max child duration.** If a child `Text` has `duration="5s"` but the parent `Timegroup` has `duration="10s"`, the composition will be 5s, not 10s. Always match child durations to the parent when using `contain` mode, or the composition will be silently shorter than expected.
-- **`--ef-progress` CSS variable (0→1) is available on temporal elements** for driving animations. Use it in `style` props: `opacity: "min(1, var(--ef-progress, 0) * 5)"` fades in over the first 20% of the timeline. `transform: "scale(min(1, 0.8 + var(--ef-progress, 0) * 0.2))"` scales from 0.8 to 1.0. The variable is set by the temporal clock and updates during playback and scrubbing.
-- **`PlaybackController.play()` after `ended` does NOT seek to 0** — this is a race condition in `@editframe/elements`. To make replay work, patch `play()` in a `useEffect` via a `ref` on the `Workbench` element: query `ef-configuration`, access `.playback`, and wrap `play()` to call `play({ from: 0 })` when `currentTime >= duration`. Also listen for the `playback-attached` event for late-bound controllers.
-- **`@editframe/react` TypeScript types do not expose `ref` or accept all CSS string values.** Use `as any` casts (`const EFWorkbench = Workbench as any`, etc.) to bypass type errors without changing runtime behavior. This is required for `ref` on `Workbench` and for CSS function values like `min()` and `var()` in `style` props.
-
 ## RFC frontmatter: commands.changed (RFC-CMD-03)
 
 The `commands.changed` field in RFC frontmatter must only list **registered CLI commands** (e.g. `compass.audit.baseline`, `mission.materialize`), not internal functions or handlers (e.g. `acquireLock`, `releaseLock`). `rfc.validate` enforces this via RFC-CMD-03: every entry in `commands.changed` must match a live command in the registry. Internal functions that are not registered as CLI commands must not appear in `commands.changed` — use `packagesImpacted` to indicate which packages were modified.
@@ -163,15 +152,15 @@ Stack profiles are YAML documents under `profiles/` describing a supported stack
 - **MUST NOT** scaffold into a non-empty directory — no `--force` flag.
 - **MUST NOT** add stack profiles for stacks forge cannot scaffold end-to-end.
 - **MUST** reference all template files in `profiles/<profile>-templates/` from the profile YAML (`workspaceTypes[].agentsMdTemplate` or `firstWorkspace.files`) or document them in the `agentsMdTemplate` file. Unreferenced template files are orphan artifacts that operators cannot discover.
-- Shipped profiles: `astro-typescript-turborepo`, `phaser-turborepo`, `forge-shell` (minimal — default for `create`), `editframe` (video domain — first non-software profile, RFC-0641, React template RFC-0694).
+- Shipped profiles: `astro-typescript-turborepo`, `phaser-turborepo`, `godot-csharp`, `forge-shell` (minimal — default for `create`).
 - **MUST** include a `.github/workflows/ci.yml` template in every stack profile's `workspace.files` list. The CI template MUST include `concurrency` (cancel superseded PR runs), `permissions: contents: read` at workflow level, `timeout-minutes` per job, `env: TZ: UTC` per job, `actions/checkout@v5`, and `actions/setup-node@v5` with Node 24. New projects inherit reliable CI from the scaffold — operators should not need to hand-write CI from scratch.
 
 ### Domain fields (RFC-0638)
 
 The `forge/stack-profile@1` schema includes six optional domain-neutral fields that allow a profile to declare its domain model. All fields are optional — existing profiles without them parse and function identically.
 
-- **`domain`** — string identifying the project domain (e.g. `software`, `video`, `book`, `music`, `game`, `illustration`). Used for profile detection and doctor output.
-- **`terminology`** — map of universal concept keys to domain-specific terms (e.g. `artifact: "composition"`). Open vocabulary; universal keys have built-in defaults exported as `TERMINOLOGY_DEFAULTS`. Missing keys fall back to the default term.
+- **`domain`** — string identifying the project domain (e.g. `software`, `game`, `book`, `music`, `illustration`). Used for profile detection and doctor output.
+- **`terminology`** — map of universal concept keys to domain-specific terms (e.g. `artifact: "game"`). Open vocabulary; universal keys have built-in defaults exported as `TERMINOLOGY_DEFAULTS`. Missing keys fall back to the default term.
 - **`artifacts`** — array of artifact definitions (id, extensions, produce/validate commands, determinism properties). Used by `doctor` for domain-specific health checks in follow-up RFCs.
 - **`workspaceTypes`** — array of workspace type definitions (id, detection markers, associated skills, AGENTS.md template). Used by `forge.agents.generate` for per-domain workspace detection in follow-up RFCs.
 - **`invariants`** — array of domain-specific invariant definitions (id matching `^[A-Z]+-\d+$`, rule text, severity). Schema only — enforcement is deferred to follow-up RFCs.
@@ -364,8 +353,8 @@ When publishing `@warpgogol/forge`, npm resolves the auth token from `.npmrc` fi
 - **Golden fixture for `agents-generate`** — when adding or modifying sections in `agents-generate.ts`, the golden fixture `src/tests/fixtures/agents-generate-business-before.txt` MUST be updated to match the new generated output. The test `agents-generate-domain.test.ts` compares generated content against this fixture with `expect(content).toBe(goldenFixture)` — a mismatch fails the test.
 - **SKILL-17 brand pattern must be case-sensitive** — the brand regex in `skill-validate.ts` uses a `@`-lookbehind to allow `@warpgogol/<pkg>` npm-scope references in skill instruction lines. Making the regex case-insensitive (`/gi`) defeats the lookbehind and false-flags every `@warpgogol` import as a brand violation. Keep the regex case-sensitive (`/g` only) so the `@`-scope allowance works correctly.
 - **`vi.resetModules()` before `vi.doMock()` for Node builtins** — when mocking Node built-in modules (e.g. `node:child_process`) in vitest, `vi.resetModules()` MUST be called BEFORE `vi.doMock()`. Without `resetModules()` first, the module cache retains the original module and the mock is not applied on re-import via dynamic `import()`. After the test, call `vi.doUnmock()` and `vi.resetModules()` to restore. Discovered during `upgrade.test.ts` `--update-npm` mock testing.
-- **Mock `execSync` for scaffold tests** — `runScaffoldProject` calls `execSync` to run `pnpm add` install commands, which fail in test environments without network access. Mock `node:child_process` with `vi.mock("node:child_process", async (importActual) => { const actual = await importActual(); return { ...actual, execSync: vi.fn(() => Buffer.from("mocked")) }; })` and use dynamic `await import("../onboarding/scaffold-project.ts")` after the mock. Use `vi.importActual` to preserve `execFile` (used by `promisify(execFile)` in forge/os/compass). See `src/tests/editframe-e2e.test.ts` for the reference pattern.
-- **`runDoctor` profile resolution in tests** — `runDoctor` calls `resolveForgeRoot(workspaceRoot)` which searches for `packages/forge/` relative to the workspace root. In temp-directory tests, the forge package is not found, so profile-dependent checks (prerequisites, invariants) are silently skipped. Either pass `forgeRoot` in the `ForgeRuntimeContext` (preferred), or create a minimal `packages/forge/profiles/<id>.yaml` inside the temp directory. See `src/tests/editframe-e2e.test.ts` "doctor checks prerequisites" test for the local-profile pattern.
+- **Mock `execSync` for scaffold tests** — `runScaffoldProject` calls `execSync` to run `pnpm add` install commands, which fail in test environments without network access. Mock `node:child_process` with `vi.mock("node:child_process", async (importActual) => { const actual = await importActual(); return { ...actual, execSync: vi.fn(() => Buffer.from("mocked")) }; })` and use dynamic `await import("../onboarding/scaffold-project.ts")` after the mock. Use `vi.importActual` to preserve `execFile` (used by `promisify(execFile)` in forge/os/compass).
+- **`runDoctor` profile resolution in tests** — `runDoctor` calls `resolveForgeRoot(workspaceRoot)` which searches for `packages/forge/` relative to the workspace root. In temp-directory tests, the forge package is not found, so profile-dependent checks (prerequisites, invariants) are silently skipped. Either pass `forgeRoot` in the `ForgeRuntimeContext` (preferred), or create a minimal `packages/forge/profiles/<id>.yaml` inside the temp directory.
 
 ## RFC frontmatter: versionBump for prose-only policy RFCs
 

package/README.md

@@ -12,13 +12,49 @@ Forge supports four kinds of projects. You pick one when you start — everythin
 | --- | --- | --- |
 | **Website** | A public website or web app — pages, blog, portfolio, landing page, online store | Photography studio site, restaurant website, SaaS landing page |
 | **Browser game** | An interactive game that runs in a web browser — 2D, arcade, puzzle, adventure | Catch falling stars, tile-matching puzzle, platformer |
-| **Video** | A programmatic video composition — animated logo, intro, product showcase, motion design | Brand intro video, product demo, social media ad clip |
 | **Governance / library** | A code library or governance-only project — no website, no game, no video, just structure and documentation | npm package, internal toolkit, documentation hub |
+| **Godot game** | A desktop or mobile game built with Godot 4.x and C# — 2D, 3D, platformer, RPG | Top-down adventure, 3D platformer, puzzle game |
 
 Each project type gets its own scaffold: the right folder structure, the right dependencies, the right tools. You don't need to know what any of those are — Forge sets them up for you.
 
 ---
 
+## Forge and the Werkstatt engine
+
+Forge is the **governance layer** — skills, RFC/ADR workflows, naming conventions, spec vendoring, and the CLI. It is framework-agnostic and has zero runtime dependencies (only `yaml` + `zod`).
+
+For full project lifecycle management — missions, releases, deployment, certification, quality checks, content codegen — Forge connects to the **Werkstatt engine** and **stack-specific plugins**. These are separate npm packages installed alongside Forge when you need runtime capabilities beyond governance.
+
+| Package | Purpose | Required for |
+| --- | --- | --- |
+| `@warpgogol/werkstatt` | Runtime engine — missions, releases, Leitstand deployment, certification, Bordbuch, artifact store | All project types with lifecycle management |
+| `@warpgogol/werkstatt-shared` | Shared infrastructure — checks, integration, ontology, passport | Installed automatically with the engine |
+| `@warpgogol/werkstatt-site` | Astro site plugin — build pipeline, content checks, codegen, deploy adapters | Website projects (`astro-typescript-turborepo`) |
+| `@warpgogol/werkstatt-game` | Phaser game plugin — game validators, Vite build, deploy adapters | Browser game projects (`phaser-turborepo`) |
+| `@warpgogol/werkstatt-godot` | Godot plugin — scene validators, dotnet build, itch.io deploy, Godot skills | Godot game projects (`godot-csharp`) |
+
+### When you need these packages
+
+- **Governance-only projects** (RFCs, ADRs, skills, documentation hubs) — Forge alone is sufficient.
+- **Websites, games, Godot projects** — install `@warpgogol/werkstatt` (the engine) plus the matching stack plugin. The `forge-bootstrap` skill configures bindings automatically; the packages themselves must be installed as devDependencies.
+
+### Installing engine packages
+
+```sh
+# Website project
+pnpm add -D @warpgogol/werkstatt @warpgogol/werkstatt-site
+
+# Browser game project
+pnpm add -D @warpgogol/werkstatt @warpgogol/werkstatt-game
+
+# Godot game project
+pnpm add -D @warpgogol/werkstatt @warpgogol/werkstatt-godot
+```
+
+> **Note for agents:** When scaffolding a new project with `forge create`, always install the engine and matching stack plugin after the scaffold completes. The `forge.yaml` bindings reference commands from these packages (e.g. `pnpm exec werkstatt run rfc.validate`), and they will fail if the packages are not installed.
+
+---
+
 ## Complete installation guide (from zero)
 
 If you've never programmed before, this section takes you from a completely empty computer to a working Forge setup. Follow the steps for your operating system.
@@ -154,43 +190,27 @@ Forge works through conversation with an AI agent. You need an IDE that supports
 
 You can also use **Cursor** ([cursor.com](https://cursor.com)) or any IDE that supports AI agent skills.
 
-### Optional — Install FFmpeg (only for video projects)
+### Optional — Install Godot and .NET (only for Godot game projects)
+
+If you're planning to create **Godot game** projects (the `godot-csharp` profile), you need two additional tools:
 
-If you're planning to create **video** projects (the `editframe` profile), you need **FFmpeg** — a free tool for processing video and audio.
+- **Godot 4.x** (with .NET support) — the game engine. Download it from [godotengine.org/download](https://godotengine.org/download). Make sure to choose the ".NET" version (not the standard version).
+- **.NET SDK 8+** — the C# runtime and build tools. Download it from [dotnet.microsoft.com/download](https://dotnet.microsoft.com/download).
 
-**Ubuntu:**
+Verify both are installed:
 
 ```sh
-sudo apt-get install -y ffmpeg
-ffmpeg -version
+godot --version
+dotnet --version
 ```
 
-**Windows:**
-
-1. Go to [ffmpeg.org/download.html](https://ffmpeg.org/download.html) in your browser.
-2. Download a Windows build (look for "Windows builds" — the gyan.dev or BtbN builds are good choices).
-3. Extract the downloaded `.zip` file to a folder, e.g. `C:\ffmpeg`.
-4. Add FFmpeg to your system PATH:
-   - Open the Start menu, search for "Environment Variables", and click "Edit the system environment variables".
-   - Click **Environment Variables**.
-   - Under "System variables" (or "User variables"), find **Path**, select it, and click **Edit**.
-   - Click **New** and type `C:\ffmpeg\bin` (or wherever you extracted FFmpeg, in the `bin` subfolder).
-   - Click **OK** on all three windows.
-5. Close and reopen PowerShell, then verify:
-
-   ```sh
-   ffmpeg -version
-   ```
-
-You should see version information, not an error.
-
 ### Troubleshooting
 
 - **"command not found" after installing Node.js** — Close and reopen your terminal (Ubuntu) or PowerShell (Windows). The system needs to reload the list of available commands.
 - **"EACCES permission denied" on Ubuntu when installing Forge globally** — Run `sudo pnpm add -g @warpgogol/forge` instead.
 - **"corepack: command not found"** — Your Node.js version is too old. Install Node.js 24+ using the steps above.
 - **Windsurf can't find `forge`** — Close and reopen Windsurf after installing Forge. IDEs need to restart to pick up new global commands.
-- **AI agent doesn't know about Forge** — You opened an empty folder, but the AI agent has no Forge context. Run `forge create --name my-project --profile editframe` (or the appropriate profile) in a terminal first, then open the created folder in your IDE. The `forge create` command populates the folder with skills, configuration, and `AGENTS.md` — without it, the AI agent can't discover Forge.
+- **AI agent doesn't know about Forge** — You opened an empty folder, but the AI agent has no Forge context. Run `forge create --in-place --profile astro-typescript-turborepo` (or the appropriate profile) in a terminal first, then open the folder in your IDE. The `forge create` command populates the current folder with skills, configuration, and `AGENTS.md` — without it, the AI agent can't discover Forge.
 
 ---
 
@@ -202,29 +222,27 @@ You need to run one command in the terminal to create your project. After that,
 
 #### Start a new project from scratch
 
-1. **Create a Forge project.** Open a terminal (PowerShell on Windows, Terminal on Ubuntu) and run:
+1. **Create a project folder and scaffold Forge in-place.** Open a terminal (PowerShell on Windows, Terminal on Ubuntu) and run:
 
    ```sh
-   forge create --name my-brand-video --profile editframe
+   mkdir my-site
+   cd my-site
+   forge create --in-place --profile astro-typescript-turborepo
    ```
 
-   Replace `my-brand-video` with your project name (lowercase letters and hyphens). This creates a new folder with everything Forge needs — skills, configuration, and project structure. For other project types, use a different `--profile`:
+   The project name is derived from the folder name (`my-site` in this example). You can override it with `--name`. This populates the current folder with everything Forge needs — skills, configuration, and project structure. For other project types, use a different `--profile`:
 
-   | What you want to build                    | Profile flag                           |
-   | ----------------------------------------- | -------------------------------------- |
-   | Video (brand video, intro, motion design) | `--profile editframe`                  |
-   | Website (landing page, blog, portfolio)   | `--profile astro-typescript-turborepo` |
-   | Browser game (2D, arcade, puzzle)         | `--profile phaser-turborepo`           |
-   | Library or governance-only project        | `--profile forge-shell`                |
+   | What you want to build                  | Profile flag                           |
+   | --------------------------------------- | -------------------------------------- |
+   | Website (landing page, blog, portfolio) | `--profile astro-typescript-turborepo` |
+   | Browser game (2D, arcade, puzzle)       | `--profile phaser-turborepo`           |
+   | Godot game (desktop, mobile, 2D/3D)     | `--profile godot-csharp`               |
+   | Library or governance-only project      | `--profile forge-shell`                |
 
-2. **Open the project folder in your AI IDE.** Open the folder that was created in step 1 in Windsurf or your preferred IDE.
+2. **Open the project folder in your AI IDE.** Open the folder from step 1 in Windsurf or your preferred IDE.
 
 3. **Tell the AI agent what you want to build.** Just type it in the chat, in your own words. For example:
 
-   > I want to create a brand video for my coffee shop. It should have an animated logo, a short intro, and a product showcase.
-
-   Or:
-
    > I want to build a website for my photography studio.
 
    Or:
@@ -236,35 +254,37 @@ You need to run one command in the terminal to create your project. After that,
    > I want to create a TypeScript library for calculating astrology charts.
 
    That's it. The AI agent will do everything else:
-   - Set up the project structure based on what you described (video, website, game, library, etc.)
+   - Set up the project structure based on what you described (website, game, library, etc.)
    - Configure language preferences and project settings
-   - Start a live preview so you can see your work (for websites, games, and videos)
+   - Start a live preview so you can see your work (for websites and games)
    - Tell you the URL to open in your browser
 
-4. **Watch the preview.** For websites, games, and videos, the AI agent will give you a localhost link. Click it — your project is already running. As you describe changes, the agent updates the project and the preview refreshes automatically.
+4. **Watch the preview.** For websites and games, the AI agent will give you a localhost link. Click it — your project is already running. As you describe changes, the agent updates the project and the preview refreshes automatically.
 
    For governance and library projects, there's no visual preview — the agent will set up the project structure and tell you when it's ready.
 
-5. **Create together.** From here on, you just talk. Want a different color? Want to add a scene? Want to change the music? Want to add a new function to your library? Just say it. The agent handles all the technical work.
+5. **Create together.** From here on, you just talk. Want a different color? Want to add a scene? Want to add a new function to your library? Just say it. The agent handles all the technical work.
 
 #### Bring an existing project into Forge
 
 If you already have a project somewhere else and want to move it into Forge:
 
-1. **Create a Forge project.** Open a terminal and run:
+1. **Create a Forge project.** Open a terminal, create a folder, and run:
 
    ```sh
-   forge create --name my-project
+   mkdir my-project
+   cd my-project
+   forge create --in-place --profile forge-shell
    ```
 
-   Then open the created folder in your AI IDE.
+   Then open the folder in your AI IDE.
 
 2. **Tell the AI agent:**
 
    > I want to bring my existing project into Forge. It's located at /path/to/my/project.
 
    The agent will:
-   - Detect what kind of project it is (website, video, game, library, etc.)
+   - Detect what kind of project it is (website, game, library, etc.)
    - Move all your files into the new Forge project — including hidden files like `.env`
    - Optionally bring your git history
    - Verify everything builds correctly
@@ -278,24 +298,33 @@ Just tell the AI agent. It can check the project's health, fix issues, and expla
 
 ### For developers — CLI commands
 
-#### Create a new project
+#### Create a new project (in-place)
 
 ```sh
-# Create a new project (scaffold + init + skills + AGENTS.md in one command)
-forge create --name my-project
+# Create a project folder, then scaffold Forge in-place
+mkdir my-project
+cd my-project
+forge create --in-place --profile forge-shell
 
 # With a specific stack profile
-forge create --name my-site --profile astro-typescript-turborepo
-forge create --name my-game --profile phaser-turborepo
-forge create --name my-video --profile editframe
-forge create --name my-library --profile forge-shell
+mkdir my-site && cd my-site
+forge create --in-place --profile astro-typescript-turborepo
 
+mkdir my-game && cd my-game
+forge create --in-place --profile phaser-turborepo
+
+mkdir my-godot-game && cd my-godot-game
+forge create --in-place --profile godot-csharp
+
+# Override the project name (derived from folder name by default)
+forge create --in-place --profile forge-shell --name my-custom-name
 ```
 
 If Forge is not installed globally, use `pnpm dlx` instead:
 
 ```sh
-pnpm dlx @warpgogol/forge create --name my-project
+mkdir my-project && cd my-project
+pnpm dlx @warpgogol/forge create --in-place --profile forge-shell
 ```
 
 #### Bring an existing project into Forge
@@ -303,15 +332,16 @@ pnpm dlx @warpgogol/forge create --name my-project
 There is no CLI command for transplant — it is an interactive, AI-guided process:
 
 ```sh
-# 1. Create a new empty Forge project
-forge create --name my-project
+# 1. Create a new empty Forge project (in-place)
+mkdir my-project && cd my-project
+forge create --in-place --profile forge-shell
 
 # 2. Open the project in Windsurf (tested with forge) or your preferred IDE
 
 # 3. Run the /forge-bootstrap skill and choose "transplant" mode
 #    The skill will:
 #    - Ask for the path to your existing codebase
-#    - Detect the stack automatically (Astro, Phaser, Editframe, etc.)
+#    - Detect the stack automatically (Astro, Phaser, Godot, etc.)
 #    - Migrate all files (including .env and git-ignored files)
 #    - Optionally transfer git history
 #    - Verify the build
@@ -339,16 +369,14 @@ A stack profile defines the project scaffold: directory structure, dependencies,
 | `forge-shell` | Governance / library | Minimal Forge shell (default) | — | Governance-only projects, libraries, non-web projects |
 | `astro-typescript-turborepo` | Website | Astro + TypeScript + pnpm + Turborepo | `sites/my-site` | Websites, web apps, content-driven sites |
 | `phaser-turborepo` | Browser game | Phaser + TypeScript + pnpm + Turborepo | `games/my-game` | Browser games, interactive experiences |
-| `editframe` | Video | Editframe React + Vite + TailwindCSS | `compositions/my-first-video` | Video compositions, brand videos, motion design |
-
-The `editframe` profile also supports an **HTML template** (instead of React) for users who prefer web components over JSX. Choose between the two during project setup.
+| `godot-csharp` | Godot game | Godot 4.x + C# + pnpm + Turborepo | `games/my-game` | Desktop/mobile games, Godot-based interactive projects |
 
 ```sh
 # List available profiles (after install)
 forge profile.validate
 ```
 
-When you bring an existing project through the `/forge-bootstrap` transplant mode, Forge detects the matching profile automatically by checking for marker files (`astro.config.*`, `phaser.config.*`, `editframe.config.*`, etc.).
+When you bring an existing project through the `/forge-bootstrap` transplant mode, Forge detects the matching profile automatically by checking for marker files (`astro.config.*`, `phaser.config.*`, `project.godot`, etc.).
 
 ## Upgrade flow
 
@@ -369,7 +397,7 @@ forge doctor
 
 ## What forge gives you
 
-- **44 skills** (fo-pipeline, grilling, preferences, skill authoring, Editframe video composition) — deployed to `.agents/skills/` by `forge create`
+- **44 skills** (fo-pipeline, grilling, preferences, skill authoring) — deployed to `.agents/skills/` by `forge create`
 - **RFC workflow** — create, validate, list, graph, archive, acceptance probes, decision logs, DNA trace
 - **ADR workflow** — lightweight architectural decision records
 - **Spec vendoring** — vendor external spec packages as immutable snapshots with integrity manifests
@@ -382,7 +410,7 @@ forge doctor
 
 The typical forge project lifecycle:
 
-1. **Create** — `forge create` bootstraps a new project with forge.yaml, skills, and docs directories
+1. **Create** — `forge create --in-place --profile <profile>` scaffolds a new project in the current directory with forge.yaml, skills, and docs directories
 2. **IDE** — open the project in Windsurf (tested with forge) or your preferred IDE
 3. **Bootstrap** — run `/forge-bootstrap` to configure the project interactively. The skill supports two modes:
    - **Greenfield** — start a new project from scratch: pick a stack, fill in bindings, init git