project-init

  Let me analyze your project to get started.
</output>

<monorepo_detection>
  Check for monorepo indicators:
  - nx.json, turbo.json, pnpm-workspace.yaml, lerna.json, rush.json
  - package.json with "workspaces" field
  - Cargo.toml with [workspace] section
  - go.work file
  - Multiple independent package/dependency manifests
  - Common patterns: packages/*, apps/*, services/*, libs/*

  If any indicator found → workspace.structure = "monorepo"
</monorepo_detection>

<output>
  Here's what I found:

  **Tech Stack**: {detected_tech}
  **Structure**: {detected_structure}
  **Patterns**: {detected_patterns}

  Does this look accurate? [Y/n/edit]
</output>

  **Language**: {suggested_language}
  **Framework**: {suggested_framework}
  **Database**: {suggested_database}

  Accept these suggestions? [Y/n/edit]
</output>

  **[1] Autonomous** — AI executes more freely, fewer checkpoints
       (medium complexity → autopilot, high → confirm)

  **[2] Balanced** — Standard checkpoints based on complexity (Recommended)
       (low → autopilot, medium → confirm, high → validate)

  **[3] Controlled** — More human oversight, more checkpoints
       (low → confirm, medium/high → validate)

  Choose [1/2/3]:
</output>
<check if="response == 1">
  <set>workspace.autonomy_bias = autonomous</set>
</check>
<check if="response == 2">
  <set>workspace.autonomy_bias = balanced</set>
</check>
<check if="response == 3">
  <set>workspace.autonomy_bias = controlled</set>
</check>
<note>Can be changed later in .specs-fire/state.yaml</note>

<action>Find module directories by exploring:</action>
<substep>Paths from workspace config (nx.json projects, pnpm-workspace.yaml, etc.)</substep>
<substep>Common patterns: packages/*, apps/*, services/*, libs/*, modules/*</substep>
<substep>Directories with their own dependency manifest</substep>

<action>For each discovered module, analyze (AI-driven, no hardcoded mappings):</action>
<substep>Primary language (from file extensions, config files)</substep>
<substep>Build/test commands (from CI config, package scripts, Makefile)</substep>
<substep>Linter/formatter (from config files in module)</substep>
<substep>Package manager (from lock files, manifests)</substep>

<output>
  Found {{module_count}} modules:

  | Module | Language | Test Command | Linter |
  |--------|----------|--------------|--------|
  {{#each modules}}
  | {{path}} | {{language}} | {{test_cmd}} | {{linter}} |
  {{/each}}

  Create module-specific standards?
  [c] All modules — create standards for all
  [s] Select — choose which modules
  [n] None — I'll create them manually later
</output>

<check if="response == c or response == s">
  <action>For each selected module, create {module}/.specs-fire/standards/tech-stack.md</action>
  <note>Only tech-stack.md by default — other standards inherit from root</note>
</check>

<check if="workspace.structure == monorepo and modules_selected">
  <action>For each selected module:</action>
  <substep>Create {module}/.specs-fire/standards/</substep>
  <substep>Generate {module}/.specs-fire/standards/tech-stack.md with detected settings</substep>
</check>

  Structure created:
  ```
  .specs-fire/
  ├── state.yaml
  ├── intents/
  ├── runs/
  └── standards/
      ├── constitution.md        # Universal policies (always inherited)
      ├── tech-stack.md
      ├── coding-standards.md
      ├── testing-standards.md
      └── system-architecture.md
  {{#if modules_created}}

  Module standards created:
  {{#each modules_created}}
  {{path}}/.specs-fire/standards/
  └── tech-stack.md
  {{/each}}
  {{/if}}
  ```

  Ready to capture your first intent.
  What do you want to build?
</output>
<route_to>planner-agent (intent-capture)</route_to>