init

---
name: init
description: "Start a new project under the factory: interview the user until the project is fully specified, have competing architects propose architectures, let the user choose, and write the locked charter (.factory/config.json, ARCHITECTURE.md, STANDARDS.md, ADR 0001). Use for /factory:init."
disable-model-invocation: true
---

# Init

Set up a new project's charter. The architecture chosen here binds every later run until an ADR changes it, so the interview leaves nothing to guess.

`PLUGIN` is the directory two levels above this file.

## 1. Preconditions

- The current directory must not already contain `.factory/config.json`. If it does, say so and stop; `/factory:build` is the next step.
- It must be a git repository. If it is not, ask whether to run `git init -b main` here.
- If the repository already has substantial code, recommend `/factory:adopt` instead, which records the architecture the code already has, and ask which the user wants.

## 2. Interview

Ask with `AskUserQuestion`, up to four questions per call, until every item below has an answer. Recommend an option where the earlier answers make one better, and say why. Never fill an item with a default the user did not choose.

1. What the project is, who uses it, and the problem it solves.
2. Project type: service, library, CLI, desktop or mobile app, web app, embedded, or data pipeline.
3. Stacks: TypeScript, Python, C/C++, Rust (more than one is allowed), and the runtime or platform for each.
4. Quality attributes, ranked: correctness, performance, developer experience, scalability, security, operability, portability.
5. Scale: expected load, data volume, and growth over the next year, with numbers.
6. Performance budgets for the main operations, with numbers.
7. Deployment target and environments.
8. Data: storage, retention, and consistency requirements.
9. External systems the project talks to.
10. Security and compliance requirements.
11. Base branch name, and whether runs land by local merge or pull request.

Restate the full brief in your own words and ask the user to confirm it or correct it.

## 3. Propose architectures

Call `Workflow` with `name: "factory:charter"` and `args`:

- `pluginRoot`: the absolute `PLUGIN` path
- `brief`: the confirmed brief as JSON, one field per interview item
- `models`: per [`../build/SKILL.md`](../build/SKILL.md) "Models"

Present the recommendation and each alternative in a table: style, summary, score, what it makes easy, what it makes hard. Ask the user to choose one, or to request changes, which you apply and present again.

## 4. Write the charter

1. `.factory/config.json` from `$PLUGIN/templates/config.json`: the project name, the stacks (`cpp` covers C and C++), the chosen proposal's checks merged with the stack packs' default checks, the base branch, and the ship mode. Validate it against `$PLUGIN/schemas/config.schema.json` by running `node "$PLUGIN/scripts/factory-state.mjs" list`, which loads and validates the config.
2. `.factory/ARCHITECTURE.md` from `$PLUGIN/templates/ARCHITECTURE.md`, every section filled from the chosen proposal, each with its enforcer.
3. `.factory/STANDARDS.md` from `$PLUGIN/templates/STANDARDS.md`, with the stack-pack choices and the one-command setup and check commands the scaffold will provide.
4. `.factory/adr/0001-adopt-the-initial-architecture.md` from `$PLUGIN/templates/adr.md`: status `Accepted`, run `none`, the brief as context, the chosen proposal as the decision, and every other proposal under alternatives with why it lost. Run `node "$PLUGIN/scripts/check.mjs" adr <file>`.
5. `.gitignore`: add `.factory/runs/` and `.claude/worktrees/` if missing.
6. `CLAUDE.md`: append `$PLUGIN/templates/claude-md-section.md`, creating the file if it does not exist.

## 5. Commit and hand off

Worktrees branch from committed history, so the charter must be committed before the first run: `git add .factory .gitignore CLAUDE.md && git commit -m "docs(factory): adopt the initial architecture"`. Tell the user you committed it.

The configured checks cannot pass until the scaffold exists, so the first run builds it. Offer to start it now:

```
/factory:build Scaffold the project per .factory/ARCHITECTURE.md: build and toolchain configuration, every enforcer the charter names, the one-command setup and check scripts from STANDARDS.md, CI that runs the configured checks, and a smoke test that proves the toolchain runs.
```