mirror of https://github.com/Donchitos/Claude-Code-Game-Studios.git synced 2026-10-16 01:37:05 +00:00

Files

T

DonchitosandClaude Opus 5 d05699707f Release 1.1.0 — one config file, and a process weight you choose

`project.yaml` at the repo root is now the single source of truth for a
project's configuration, replacing `production/stage.txt`,
`production/review-mode.txt` and `.claude/docs/technical-preferences.md` (all
three still read as a fallback; nothing is force-deleted).

**`modes.rigor` — one question instead of six.** `minimal`, `standard` or
`full` fronts six knobs: `modes.workflow`, `docs.density`, `qa.level`,
`modes.story_granularity`, `modes.review_mode` and `team.size`. It defaults to
`minimal`, which is a change from 1.0's behaviour: the heavier tier was
measured costing several times more to reach working code without producing a
better result, and returning nothing when a fresh developer inherited the
project. Pin `modes.rigor: standard` to keep 1.0's process level.

Also in this release:

- `/settings` to view or change any setting, and `project.local.yaml` for
  per-developer preferences that should not be committed.
- `system_overrides` to hold one system to a higher standard than the rest of
  the project, and `testing.strict` to set per test type whether missing
  evidence blocks a story or warns.
- A story that changes anything the player sees is not closed until the game
  has been launched, observed, and a screenshot retained in
  `production/qa/evidence/`. A parse check is not a run. This holds at every
  rigor level, including `minimal`, where automated tests are waived but the
  look is not.
- The code root is engine-specific and enforced as such: Godot `src/`, Unity
  `Assets/`, Unreal `Source/<Module>/`. Two of the three will not build a
  project laid out any other way.
- Migration tooling for existing projects: `.claude/scripts/migrate-v1-config.sh`
  converts a 1.0 layout, non-destructively by default, with a report to review
  before `--finalize` deletes anything.
- Ask-before-write holds regardless of personal automation settings.

Upgrading from 1.0 or earlier: see UPGRADING.md. Full list of changes:
CHANGELOG.md.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016xvzG3i7pWQg4LjyDwWMXd

2026-09-23 12:25:11 +10:00

3.1 KiB

Raw Blame History

Code Root Resolution

Shared procedure for any skill that reads, scans, counts or writes game source files. Referenced from the point of use in each such skill. Those skills keep the one load-bearing imperative inline — an unresolved code root means the check did not run — and cite this file for the resolution order.

.claude/docs/directory-structure.md is the authority for which directory holds code. This file is the procedure for applying it.

The roots

`engine.name`	Code root	Why it cannot be `src/`
Godot	`src/`	No constraint; Godot loads from `res://` anywhere under the project root
Unity	`Assets/`	Unity compiles only `Assets/` and `Packages/`
Unreal	`Source/<Module>/`	UnrealBuildTool discovers modules under `Source/`; content lives in `Content/`

src/ is the Godot row of that table, not a universal path.

Resolution order

engine.name from project.local.yaml, then project.yaml.
The legacy mirror: an Engine: line in .claude/docs/technical-preferences.md. A value of [TO BE CONFIGURED] does not count.
Derivation from the tree, but only when it is unambiguous. Exactly one of src/, Assets/ or Source/ present means that is the root. Two or more present means the project is genuinely undecidable — do not guess.
Otherwise: unresolved.

The hooks already implement exactly this as resolve_code_root() in .claude/hooks/yaml-helper.sh. Skills must match its semantics so that a hook and a skill never disagree about where the code lives.

Unresolved does not default to `src/`

This is the rule the whole file exists for, and it is obligation 2 of .claude/rules/skill-authoring.md: an absent value may not default to the permissive one.

For a read or scan: report NOT ASSESSED — code root unresolved and say which check did not run. Never report zero hits.

A scan anchored to a root the project does not use matches nothing, and nothing is indistinguishable from a clean result. A localization check finds no hardcoded strings; a security scan finds no secrets; a content audit counts no implemented content; a stage detector counts no source files and calls a finished project greenfield. Every one of those reads as a pass. This has been found repeatedly across skills and hooks, which is why the resolution lives in one place now.

For a write: do not write. Report the unresolved root and stop.

Writing game code to the wrong root is worse than a false pass, because it produces a project that cannot build: on Unity, source placed outside Assets/ is never compiled and never appears in the editor, so the work is silently inert. Resolving the engine in order to pick a specialist agent is not the same as resolving the code root — a skill can do the first correctly and still write to the wrong directory.

Applying it

Where a skill says src/, read it as the code root and substitute the table above. Where a skill greps, glob the resolved root. Where a skill writes, write under the resolved root and use the engine's own conventions beneath it (Assets/Scripts/<System>/ on Unity, Source/<Module>/<System>/ on Unreal).

3.1 KiB Raw Blame History