agile-context-engineering 0.2.2 → 0.5.0

package/{agile-context-engineering/workflows/map-story.xml → skills/map-story/workflow.xml}

@@ -5,11 +5,12 @@
         exists (file mode), then create or update topic-scoped documents in
         `.docs/wiki/subsystems/[subsystem-name]/`.
 
-        Produces documents across five categories:
+        Produces documents across six categories:
         - systems/       — WHAT exists (domain subsystems and their current state)
         - patterns/      — HOW things work (reusable implementation patterns)
         - cross-cutting/ — concerns spanning multiple systems
         - guides/        — step-by-step recipes for common implementation tasks
+        - walkthroughs/  — deep tutorial-style flow explanations with actual code snippets
         - decisions/     — WHY significant choices were made (ADRs)
 
         Two input modes that converge into ONE execution flow:
@@ -199,6 +200,153 @@
                     </variant>
                 </substep>
 
+                <substep order="2e" name="detect-new-subsystems">
+                    Detect whether any subsystems in `subsystem_work` are NEW (not yet documented
+                    in system-structure.md). If found, offer to run full subsystem mapping via
+                    /ace:map-subsystem before proceeding with per-change documentation.
+
+                    Only runs in story mode. Naturally skipped when map-story is invoked as a
+                    background agent (e.g., from execute-story) because the required tools —
+                    Agent, AskUserQuestion — are unavailable to ace-wiki-mapper agents.
+
+                    <substep order="2e.1" name="check-system-structure">
+                        Check if `.docs/wiki/system-wide/system-structure.md` exists.
+
+                        <variant condition="file does not exist">
+                            Display:
+                            ```
+                              i  system-structure.md not found — skipping new subsystem detection.
+                                 Run /ace:map-system first to create system-wide documentation.
+                            ```
+                            Skip the rest of substep 2e.
+                        </variant>
+
+                        <variant condition="file exists">
+                            Read `.docs/wiki/system-wide/system-structure.md`.
+                            Parse the **Subsystem Index** table to extract known subsystem
+                            directory paths (the Directory column values).
+                            Store as `known_subsystems`.
+                        </variant>
+                    </substep>
+
+                    <substep order="2e.2" name="identify-new-subsystems">
+                        For each subsystem key in `subsystem_work`, determine its source
+                        directory path from the changed file paths (the common parent
+                        directory at the subsystem root level).
+
+                        Compare against `known_subsystems`. Any subsystem whose directory
+                        path is NOT in the list → add to `new_subsystems` with name and path.
+
+                        <variant condition="new_subsystems is empty">
+                            No new subsystems detected — skip the rest of substep 2e.
+                        </variant>
+                    </substep>
+
+                    <substep order="2e.3" name="ask-user-approval">
+                        Display:
+                        ```
+                          !  New subsystem(s) detected — not yet in system-structure.md:
+
+                             [For each new subsystem:]
+                             - [subsystem-name] at [path] ([N] changed files)
+                        ```
+
+                        Use AskUserQuestion:
+                        - header: "New Subsystem"
+                        - question: "This story added files in [count] subsystem(s) not yet
+                          documented in system-structure.md:\n\n[list: name at path]\n\nFull
+                          mapping creates structure.md, architecture.md, module discovery, and
+                          all knowledge docs (systems/, patterns/, cross-cutting/, guides/,
+                          decisions/). It also updates system-structure.md and
+                          system-architecture.md.\n\nShould I run full subsystem mapping?"
+                        - options:
+                          - "Yes, map new subsystem(s)" — Run /ace:map-subsystem for each
+                            new subsystem, then continue with remaining work
+                          - "No, just document the changes" — Treat them like existing
+                            subsystems (lightweight per-change docs only)
+
+                        <option value="No, just document the changes">
+                            Skip the rest of substep 2e — new subsystems stay in
+                            `subsystem_work` for normal step 3 processing.
+                        </option>
+                    </substep>
+
+                    <substep order="2e.4" name="run-map-subsystem" condition="user approved">
+                        For each subsystem in `new_subsystems`, run map-subsystem SEQUENTIALLY
+                        (each spawns many internal sub-agents — parallel would be too heavy).
+
+                        Store results in `new_subsystem_reports` list.
+
+                        <loop for-each="subsystem in new_subsystems">
+                            Display:
+                            ```
+                            ┌──────────────────────────────────────────────────┐
+                            │  ACE > Map Story > New Subsystem Mapping          │
+                            └──────────────────────────────────────────────────┘
+
+                              Mapping [subsystem.name] at [subsystem.path]...
+                              ([index] of [total] new subsystems)
+                            ```
+
+                            ```
+                            Agent(
+                                prompt="/ace:map-subsystem subsystem=\"[subsystem.path]\"
+
+                                Execute the map-subsystem workflow end-to-end.
+                                This is a NEW subsystem — no existing docs to triage
+                                (all documents will be created fresh).
+
+                                **Return format — ONLY this, nothing else:**
+                                MAP-SUBSYSTEM COMPLETE
+                                Subsystem: [subsystem.name]
+                                - Structure: created ([N] lines)
+                                - Architecture: created ([N] lines)
+                                - Modules discovered: [count]
+                                - Knowledge docs created: [count]
+                                - system-structure.md: updated
+                                - system-architecture.md: updated",
+                                subagent_type="general-purpose",
+                                description="Map new subsystem [subsystem.name]"
+                            )
+                            ```
+
+                            Parse the agent's return and add to `new_subsystem_reports`.
+
+                            Display:
+                            ```
+                              +  [subsystem.name] mapping complete — [count] docs created
+                            ```
+                        </loop>
+                    </substep>
+
+                    <substep order="2e.5" name="prune-work-map" condition="user approved">
+                        Remove all `new_subsystems` entries from `subsystem_work` to prevent
+                        duplicate documentation in step 3 (map-subsystem already created full
+                        structure, architecture, module discovery, AND all knowledge docs).
+
+                        Display:
+                        ```
+                          i  Removed [count] fully-mapped subsystem(s) from work queue.
+                             Remaining for per-change documentation: [list remaining, or "none"]
+                        ```
+
+                        <variant condition="subsystem_work is now empty AND tech_debt_items exist for new subsystems">
+                            map-subsystem does NOT handle tech debt integration. Spawn a
+                            lightweight ace-wiki-mapper agent per new subsystem that has
+                            tech_debt_items, with instructions to ONLY add ## Tech Debt
+                            sections to the docs that map-subsystem just created.
+                        </variant>
+
+                        <variant condition="subsystem_work is now empty AND no tech debt">
+                            Skip steps 3-4, jump to step 5 (tech debt index update).
+                        </variant>
+
+                        <variant condition="subsystem_work still has entries">
+                            Continue to step 3 normally with the reduced work map.
+                        </variant>
+                    </substep>
+                </substep>
+
             </mode>
 
             <!-- ── File Mode ──────────────────────────────────────────────── -->
@@ -339,11 +487,12 @@
                         <instruction order="0" name="read-templates">
                             TEMPLATES — Read ALL of these before writing ANY docs:
 
-                            - System docs:        .claude/templates/system.xml
-                            - Pattern docs:       .claude/templates/pattern.xml
-                            - Cross-cutting docs: .claude/templates/system-cross-cutting.xml
-                            - Guide docs:         .claude/templates/guide.xml
-                            - Decision docs:      .claude/templates/decizions.xml
+                            - System docs:        ${CLAUDE_SKILL_DIR}/templates/system.xml
+                            - Pattern docs:       ${CLAUDE_SKILL_DIR}/templates/pattern.xml
+                            - Cross-cutting docs: ${CLAUDE_SKILL_DIR}/templates/system-cross-cutting.xml
+                            - Guide docs:         ${CLAUDE_SKILL_DIR}/templates/guide.xml
+                            - Walkthrough docs:   ${CLAUDE_SKILL_DIR}/templates/walkthrough.xml
+                            - Decision docs:      ${CLAUDE_SKILL_DIR}/templates/decizions.xml
                         </instruction>
 
                         <instruction order="0" name="inputs">
@@ -417,6 +566,7 @@
                                     <item>patterns/*.md — every pattern document, complete</item>
                                     <item>cross-cutting/*.md — every cross-cutting document, complete</item>
                                     <item>guides/*.md — every guide document, complete</item>
+                                    <item>walkthroughs/*.md — every walkthrough document, complete</item>
                                     <item>decisions/*.md — every ADR, complete</item>
                                 </checklist>
                             </substep>
@@ -428,6 +578,7 @@
                                     <item>Which patterns are already documented? What implementations are listed?</item>
                                     <item>Which cross-cutting concerns are documented? What registrations are listed?</item>
                                     <item>Which guides exist? Are the steps still accurate?</item>
+                                    <item>Which walkthroughs exist? Are the code snippets still accurate? Which flows do they cover?</item>
                                     <item>Which decisions are recorded?</item>
                                 </checklist>
                             </substep>
@@ -437,7 +588,7 @@
 
                             If the wiki directory does not exist:
                             ```bash
-                            mkdir -p .docs/wiki/subsystems/[subsystem_name]/{systems,patterns,cross-cutting,guides,decisions}
+                            mkdir -p .docs/wiki/subsystems/[subsystem_name]/{systems,patterns,cross-cutting,guides,walkthroughs,decisions}
                             ```
                         </instruction>
 
@@ -453,6 +604,7 @@
                                     <rule pattern="Reusable structural pattern (2+ similar)" target="patterns/" />
                                     <rule pattern="Shared infrastructure (DI, events, registry)" target="cross-cutting/" />
                                     <rule pattern="Common repeatable task recipe" target="guides/" />
+                                    <rule pattern="Complex multi-class flow with framework involvement" target="walkthroughs/" />
                                     <rule pattern="Significant architectural 'why' decision" target="decisions/" />
                                 </categorization-rules>
                             </substep>
@@ -595,7 +747,26 @@
                             Include tech debt integration in your report.
                         </instruction>
 
-                        <instruction order="F" name="report">
+                        <instruction order="F" name="walkthrough-suggestions">
+                            WALKTHROUGH SUGGESTIONS
+
+                            After documenting, analyze the code you just read for potential
+                            walkthrough candidates. A flow is a walkthrough candidate when:
+                            - It spans 3+ classes across multiple layers (handler -> service -> repository -> db)
+                            - External frameworks/libraries are involved (SignalR, EF Core, gRPC, Microsoft Agent Framework etc.)
+                            - The flow is complex enough that an intern couldn't follow it from code alone
+                            - No existing walkthrough already covers this flow
+
+                            Check `.docs/wiki/subsystems/[subsystem_name]/walkthroughs/` for existing
+                            walkthroughs. Do NOT suggest flows already covered.
+
+                            For each candidate, identify:
+                            - A natural language flow description (start -> end)
+                            - Which emphasis-frameworks would be valuable (if any)
+                            - Why this flow deserves a walkthrough (1 line)
+                        </instruction>
+
+                        <instruction order="G" name="report">
                             YOUR REPORT (return this)
 
                             Return a structured report:
@@ -613,6 +784,16 @@
 
                             Issues found (if any):
                             - [description of any problems encountered]
+
+                            Walkthrough suggestions:
+                            - FLOW: [natural language flow description]
+                              SUBSYSTEM: [subsystem_name]
+                              EMPHASIS: [framework1, framework2, or "none"]
+                              REASON: [why this deserves a walkthrough]
+                            - FLOW: ...
+
+                            [If no walkthrough candidates found:]
+                            Walkthrough suggestions: none
                         </instruction>
 
                     </agent-instructions>
@@ -729,7 +910,14 @@
                     **Story**: [story name from artifacts, or "Git changes"]
                     **Affected Subsystems**: [list]
 
-                    [For each subsystem, include the agent's report:]
+                    [If new_subsystem_reports is not empty:]
+
+                    ### New Subsystems Mapped (via map-subsystem)
+                    [For each new subsystem report:]
+                    - **[subsystem.name]** at `[subsystem.path]` — [modules] modules, [docs] knowledge docs
+                      Docs: `.docs/wiki/subsystems/[subsystem.name]/`
+
+                    [For each remaining subsystem, include the agent's report:]
 
                     ### [subsystem_name]
 
@@ -748,9 +936,66 @@
                     ### Failures
                     - [subsystem]: [error]
 
+                    [If any agent reports contain walkthrough suggestions:]
+
+                    ### Walkthrough Suggestions
+
+                    [For each suggestion, numbered:]
+                    [N]. [flow description]
+                         Subsystem: [subsystem] | Emphasis: [frameworks or "none"]
+                         [reason]
+                    ```
+
+                    **If walkthrough suggestions exist:**
+                    Use AskUserQuestion:
+                    - header: "Walkthroughs"
+                    - question: "Would you like to create any of these walkthroughs?\nYou can also describe your own."
+                    - options:
+                      - "Create [numbers]" — e.g., "Create 1,3" or "Create all"
+                      - "Custom" — user describes their own walkthrough
+                      - "Skip" — no walkthroughs
+
+                    **If "Skip":** Display next steps and end.
+
+                    **If "Create [numbers]" or "Create all":**
+                    For each selected suggestion, spawn a background agent:
+
+                    ```
+                    Agent(
+                        prompt="/ace:map-walkthrough flow=\"{suggestion.flow}\" subsystem=\"{suggestion.subsystem}\" emphasis-frameworks=\"{suggestion.emphasis}\"
+
+                        Execute the map-walkthrough workflow end-to-end.",
+                        subagent_type="ace-wiki-mapper",
+                        run_in_background=true,
+                        description="Walkthrough: {short flow name}"
+                    )
+                    ```
+
+                    **If "Custom":**
+                    Ask the user for their flow description, subsystem, and optional emphasis-frameworks.
+                    Spawn a background agent for that walkthrough too.
+
+                    Wait for all walkthrough agents to complete.
+
+                    Display:
+                    ```
+                      +  [N] walkthrough(s) created.
+                         [For each: path and line count]
+                    ```
+
+                    Stage and commit walkthrough files:
+                    ```bash
+                    git add .docs/wiki/subsystems/*/walkthroughs/
+                    git commit -m "docs: add walkthroughs from map-story suggestions"
+                    ```
+
+                    **After walkthroughs (or if no suggestions):**
+
+                    ```
                     Next > `/clear` first for a fresh context window, then:
 
                            /ace:map-story — document another story
+                           /ace:map-walkthrough — create another walkthrough
                            /ace:map-subsystem [subsystem] — map or refresh an entire subsystem
                            Review files in .docs/wiki/subsystems/
                     ```
@@ -792,6 +1037,10 @@
         <criterion>Tech debt index updated with new items and recalculated counts (if provided)</criterion>
         <criterion>Security scan passed (no secrets in generated docs)</criterion>
         <criterion>Clear structured report from each agent, merged into final report</criterion>
+        <criterion>New subsystems detected by comparing subsystem_work against system-structure.md Subsystem Index (story mode only)</criterion>
+        <criterion>User approval required before running map-subsystem on new subsystems</criterion>
+        <criterion>New subsystems removed from subsystem_work after map-subsystem to prevent duplicate docs</criterion>
+        <criterion>New subsystem mapping results included in final report</criterion>
     </success_criteria>
 
 </workflow>

package/skills/map-subsystem/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: map-subsystem
+description: Map a subsystem's structure, architecture, and knowledge docs into .docs/wiki/subsystems/[name]/
+argument-hint: "subsystem='src/api' (or subsystem name) existing-docs=comma separated paths | directory"
+disable-model-invocation: true
+allowed-tools: Read, Bash, Glob, Grep, Write, Task, AskUserQuestion
+model: opus
+effort: max
+---
+
+# Map Subsystem
+
+Map a subsystem's structure, architecture, and knowledge docs into .docs/wiki/subsystems/[name]/.
+
+## When to Use
+
+- After `/ace:map-system` — drill into individual subsystems
+- Anytime to refresh an existing subsystem's wiki documents
+- When a new subsystem is added and needs to be documented
+- A subsystem has not yet been documented in `.docs/wiki/subsystems/`
+- An existing subsystem's docs are stale after a significant refactor
+- You want a deep-dive view of a specific subsystem's internals (components, flows, data)
+
+## Input
+
+### Required
+
+- **`subsystem`** — Path to the subsystem (e.g., `src/api`) or its name. If not provided, pause execution and ask the user for it. If provided but ambiguous, or not found in the codebase, ask clarifying questions.
+
+### Optional
+
+- **`existing-docs`** — Pre-existing documentation relevant to this subsystem. Accepts file paths, directory paths, or a mix of both. When a directory is provided, recursively discover all files within it (including nested subdirectories). All resolved file paths are passed through to every map-story invocation (file mode) alongside any per-module docs discovered during module-discovery. Use this when the caller already knows about documentation that should inform knowledge-doc generation.
+
+## Environment Context (preprocessed)
+
+!`node "${CLAUDE_SKILL_DIR}/script.js" init "$ARGUMENTS" 2>/dev/null`
+
+## Supporting Resources
+
+Read ALL of these before starting the workflow:
+
+- **Workflow**: Read [workflow.xml](workflow.xml) — complete orchestration process with all steps
+- **Subsystem structure template**: Read [templates/subsystem-structure.xml](templates/subsystem-structure.xml) — output format for subsystem structure
+- **Subsystem architecture template**: Read [templates/subsystem-architecture.xml](templates/subsystem-architecture.xml) — output format for subsystem architecture
+- **Module discovery template**: Read [templates/module-discovery.xml](templates/module-discovery.xml) — format for module discovery artifact
+- **System template**: Read [templates/system.xml](templates/system.xml) — format for system documents
+- **Pattern template**: Read [templates/pattern.xml](templates/pattern.xml) — format for pattern documents
+- **Cross-cutting template**: Read [templates/system-cross-cutting.xml](templates/system-cross-cutting.xml) — format for cross-cutting concern documents
+- **Guide template**: Read [templates/guide.xml](templates/guide.xml) — format for guide documents
+- **Walkthrough template**: Read [templates/walkthrough.xml](templates/walkthrough.xml) — format for walkthrough documents
+- **Decisions template**: Read [templates/decizions.xml](templates/decizions.xml) — format for decision documents
+- **Questioning guide**: Read `${CLAUDE_SKILL_DIR}/../../shared/utils/questioning.xml` — deep questioning techniques
+- **UI formatting**: Read `${CLAUDE_SKILL_DIR}/../../shared/utils/ui-formatting.md` — ACE output formatting rules
+
+## Process
+
+Use the `ace-wiki-mapper` agent for codebase analysis and document generation.
+
+The Environment Context above contains the preprocessed INIT JSON — use it directly instead of running the init script manually. The workflow's step 1 setup can skip the init bash call since that data is already available.
+
+Read all supporting resources listed above, then execute the workflow defined in [workflow.xml](workflow.xml) end-to-end. Preserve all workflow gates (validation, user questions, commits).
+
+The workflow has 13 steps:
+1-5: Setup, context loading, subsystem resolution, document triage, directory creation
+6-8: Structure + architecture agents (parallel) + collect results
+9: Update system-wide docs (system-structure.md, system-architecture.md)
+10: Module discovery (3 parallel discovery agents + 1 synthesis agent)
+11: Knowledge documentation — run map-story for EACH discovered module (sequential)
+12: Verify and commit all documents
+13: Completion report
+
+Steps 10-11 are CRITICAL — they produce the knowledge docs (systems/, patterns/, cross-cutting/, guides/, walkthroughs/, decisions/) that AI agents need for future implementations. Do NOT skip them.
+
+## Artifacts
+
+```
+.docs/wiki/subsystems/[subsystem-name]/structure.md
+.docs/wiki/subsystems/[subsystem-name]/architecture.md
+.docs/wiki/subsystems/[subsystem-name]/systems/*.md
+.docs/wiki/subsystems/[subsystem-name]/patterns/*.md
+.docs/wiki/subsystems/[subsystem-name]/cross-cutting/*.md
+.docs/wiki/subsystems/[subsystem-name]/guides/*.md
+.docs/wiki/subsystems/[subsystem-name]/walkthroughs/*.md
+.docs/wiki/subsystems/[subsystem-name]/decisions/*.md
+.ace/artifacts/subsystems/[subsystem-name]/module-discovery/module-discovery.md
+.ace/artifacts/subsystems/[subsystem-name]/module-discovery/existing-docs-inventory.md
+.docs/wiki/system-wide/system-structure.md    (subsystem entry added if new)
+.docs/wiki/system-wide/system-architecture.md (subsystem responsibility matrix updated)
+```
+
+## Example Usage
+
+```
+# Map a subsystem by path
+/ace:map-subsystem subsystem="src/api"
+
+# Map a subsystem with existing docs
+/ace:map-subsystem subsystem="src/auth" existing-docs="docs/auth-design.md,docs/auth/"
+
+# Map a subsystem by name
+/ace:map-subsystem subsystem="authentication"
+```
+
+## Next Steps
+
+After this command, `/clear` first for a fresh context window, then:
+
+- `/ace:map-subsystem subsystem="src/other"` — Map another subsystem
+- `/ace:init-coding-standards` — Define prescriptive coding standards
+- `/ace:help` — Check project initialization status and next steps
+- Review and edit files in `.docs/wiki/subsystems/` anytime

package/skills/map-subsystem/script.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * map-subsystem skill script — Entry point for ace-tools operations
+ * needed by the map-subsystem skill.
+ *
+ * Subcommands:
+ *   init [args]        Environment detection for map-subsystem workflow
+ *
+ * Usage: node script.js <subcommand> [args] [--raw]
+ */
+
+const {
+  loadConfig, pathExists, resolveModel,
+  detectBrownfieldStatus, output, error,
+} = require('../../shared/lib/ace-core');
+
+// ─── CLI Dispatch ────────────────────────────────────────────────────────────
+
+const cwd = process.cwd();
+const args = process.argv.slice(2);
+const raw = args.includes('--raw');
+const cmd = args[0];
+
+switch (cmd) {
+  case 'init':
+    cmdInit(cwd, raw, args.slice(1).filter(a => a !== '--raw'));
+    break;
+  default:
+    error(`Unknown command: ${cmd}\nAvailable: init`);
+}
+
+// ─── Init: Map Subsystem ────────────────────────────────────────────────────
+
+function cmdInit(cwd, raw) {
+  const config = loadConfig(cwd);
+  const brownfield = detectBrownfieldStatus(cwd);
+
+  const wikiDir = '.docs/wiki/subsystems';
+  const wikiDirExists = pathExists(cwd, wikiDir);
+
+  const result = {
+    // Models
+    mapper_model: resolveModel(cwd, 'ace-wiki-mapper'),
+
+    // Config
+    commit_docs: config.commit_docs,
+
+    // Brownfield detection
+    ...brownfield,
+
+    // Wiki directory state
+    wiki_dir_exists: wikiDirExists,
+
+    // Git state
+    has_git: pathExists(cwd, '.git'),
+  };
+
+  output(result, raw);
+}

package/skills/map-subsystem/script.test.js

@@ -0,0 +1,68 @@
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SCRIPT = path.join(__dirname, 'script.js');
+
+function createTestProject() {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ace-test-'));
+
+  const aceDir = path.join(tmpDir, '.ace');
+  fs.mkdirSync(aceDir, { recursive: true });
+  fs.writeFileSync(path.join(aceDir, 'config.json'), JSON.stringify({
+    version: '0.1.0',
+    projectName: 'test-project',
+    model_profile: 'quality',
+    commit_docs: true,
+    github: { enabled: false },
+  }, null, 2));
+
+  return tmpDir;
+}
+
+function runScript(subcommand, args, cwd) {
+  return execSync(`node "${SCRIPT}" ${subcommand} ${args}`, {
+    cwd,
+    encoding: 'utf-8',
+    timeout: 10000,
+  });
+}
+
+function cleanup(tmpDir) {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+}
+
+describe('map-subsystem script', () => {
+  it('errors on unknown command', () => {
+    assert.throws(() => {
+      execSync(`node "${SCRIPT}" bogus`, { encoding: 'utf-8', stdio: 'pipe' });
+    });
+  });
+
+  describe('init', () => {
+    let tmpDir;
+
+    before(() => { tmpDir = createTestProject(); });
+    after(() => { cleanup(tmpDir); });
+
+    it('init returns valid JSON', () => {
+      const result = JSON.parse(runScript('init', '', tmpDir));
+      assert.ok(typeof result === 'object');
+      assert.ok(result.mapper_model, 'should have mapper_model');
+      assert.strictEqual(typeof result.commit_docs, 'boolean');
+      assert.strictEqual(typeof result.has_git, 'boolean');
+      assert.strictEqual(typeof result.is_brownfield, 'boolean');
+      assert.strictEqual(typeof result.wiki_dir_exists, 'boolean');
+    });
+
+    it('returns brownfield detection fields', () => {
+      const result = JSON.parse(runScript('init', '', tmpDir));
+      assert.strictEqual(typeof result.is_brownfield, 'boolean');
+      assert.strictEqual(typeof result.is_greenfield, 'boolean');
+      assert.strictEqual(result.is_brownfield, !result.is_greenfield);
+    });
+  });
+});