@activate-core/test-forge 0.1.1 → 0.2.0

package/README.md

@@ -40,7 +40,7 @@ testforge update     # re-check and refresh only what changed
 | Command              | What it does                                                                                                                       |
 | -------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
 | `testforge setup`    | One-time setup: runs init, map, and discover in order, with progress.                                                              |
-| `testforge generate` | Generates a test file and a seed file for each journey doc. Only changed docs are regenerated.                                     |
+| `testforge generate` | Generates a test file and a seed file for each journey doc. Only changed docs are regenerated. First asks what the tests should be based on — the AI-derived docs, or an external reference (see [Source of truth](#source-of-truth)). |
 | `testforge update`   | Detects source-code changes and refreshes the map, docs, and tests when needed. Skips everything if nothing changed (no AI calls). |
 
 ### Advanced (run a single step)
@@ -73,6 +73,49 @@ generates a seed file that provisions the test data each test needs.
 **update** hashes your source code and compares it to the last run. No
 change means no work and no AI calls; a change triggers a refresh.
 
+## Source of truth
+
+By default, testforge's docs are derived from your **code** — the AI reads
+the project and writes `testforge.md` and the journey docs. That is fast,
+but it inherits whatever the code does: if a flow is buggy or a scenario
+is mishandled, the AI faithfully documents the wrong behavior, and the
+tests then lock that wrong behavior in.
+
+So when you run `testforge generate`, it first asks what the tests should
+be based on:
+
+```
+What should the tests be based on?
+  [1] testforge.md + docs/ (what the AI derived from your code) (default)
+  [2] An external reference (a file/PDF in scope, a website, or a Notion link)
+```
+
+Choose **[2]** to give testforge an authoritative reference of the
+_expected_ behavior — a spec or requirements doc in the repo, a PDF, a
+website, or a Notion page. testforge then:
+
+1. reads the reference and compares it against the current docs,
+2. writes a full comparison to **`testforge.diff.md`** and prints a short
+   summary of the differences,
+3. asks you to confirm, and on confirmation **reconciles the docs** so the
+   reference wins (fixing wrong expectations, adding missing journeys),
+4. generates the tests from those reconciled docs.
+
+The reference becomes the source of truth — expected behavior from a human
+or client, not just what the code happens to do. Your review of
+`testforge.diff.md` stays as an audit of what changed and why.
+
+**Non-interactive use (CI, scripts):**
+
+```bash
+testforge generate --source docs              # skip the prompt, use the docs as-is
+testforge generate --reference ./spec.md      # reconcile against a reference, no prompts
+testforge generate --reference https://…      # a URL or Notion link works too
+```
+
+With no flags and no terminal attached, testforge does not block — it
+falls back to the docs and prints a note.
+
 ## Running the generated tests
 
 testforge generates the tests and seed files — you run them with your
@@ -159,7 +202,12 @@ The test runner produces its own pass/fail report.
 
 - **aiCommand** — the CLI used to call the AI. Any tool that reads a
   prompt from stdin and prints the reply works, so testforge is not tied
-  to one provider.
+  to one provider. testforge appends the right flags per phase: the
+  setup phases (init/map/discover) run with edit permission because the
+  model writes files, while the generation phases (tests/seeds) run with
+  no tools (`--allowedTools ""` for Claude) so the model just prints code
+  instead of trying to create files — which would otherwise leak "the
+  write wasn't approved…" prose into the output.
 - **testOutput** — where tests go, per area. Areas are not fixed — use
   whatever your project has (`api`, `web`, `ops`, `lambda`, ...).
 - **framework** — which test framework each area uses.

package/dist/cli/index.js

@@ -3,12 +3,15 @@
  * testforge — command-line entry point.
  *
  * Commands:
- *   testforge generate           Generate tests for changed journeys (AI).
- *   testforge generate --basic   Use the built-in basic generator only.
- *   testforge generate --force   Regenerate everything, ignoring the cache.
+ *   testforge generate                 Generate tests for changed journeys (AI).
+ *   testforge generate --basic         Use the built-in basic generator only.
+ *   testforge generate --force         Regenerate everything, ignoring the cache.
+ *   testforge generate --source docs   Skip the source-of-truth prompt, use docs.
+ *   testforge generate --reference <x> Reconcile docs against a reference first,
+ *                                      where <x> is a file path, URL, or Notion link.
  */
 import { VERSION } from '../core/index.js';
-import { runGenerate } from '../core/run-generate.js';
+import { runGenerateCommand } from '../core/generate-command.js';
 import { runDiscover } from '../core/discover.js';
 import { runMap } from '../core/map.js';
 import { runInit } from '../core/init.js';
@@ -18,6 +21,16 @@ import { runEnvTemplate } from '../core/env-template.js';
 const command = process.argv[2];
 const useBasic = process.argv.includes('--basic');
 const force = process.argv.includes('--force');
+/** Read the value that follows a `--flag <value>` option, if present. */
+function flagValue(name) {
+    const i = process.argv.indexOf(name);
+    if (i === -1)
+        return undefined;
+    const value = process.argv[i + 1];
+    if (value === undefined || value.startsWith('--'))
+        return undefined;
+    return value;
+}
 if (command === 'update') {
     runUpdate('.');
 }
@@ -53,27 +66,16 @@ else if (command === 'generate') {
     console.log(useAI
         ? 'Generating tests with AI for changed journeys...\n'
         : 'Generating tests with the basic generator...\n');
-    const results = runGenerate('docs', useAI, force);
-    if (results.length === 0) {
-        console.log('No journey files found in docs/. Add a .md file and try again.');
-    }
-    else {
-        for (const r of results) {
-            if (r.status === 'skipped') {
-                console.log(`  [skip] ${r.journeyName} (unchanged)`);
-            }
-            else {
-                const tag = r.status === 'ai' ? '[AI]' : '[basic]';
-                console.log(`  ${tag} ${r.journeyName}`);
-                console.log(`         test: ${r.testPath}`);
-                if (r.status === 'ai')
-                    console.log(`         seed: ${r.seedPath}`);
-            }
-        }
-        const generated = results.filter((r) => r.status !== 'skipped').length;
-        const skipped = results.filter((r) => r.status === 'skipped').length;
-        console.log(`\nDone. ${generated} generated, ${skipped} skipped (unchanged).`);
-    }
+    runGenerateCommand({
+        docsDir: 'docs',
+        useAI,
+        force,
+        reference: flagValue('--reference'),
+        source: flagValue('--source'),
+    }).catch((err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
 }
 else {
     console.log(`testforge v${VERSION}`);
@@ -82,6 +84,8 @@ else {
     console.log('  testforge generate           Generate tests for changed journeys');
     console.log('  testforge generate --basic   Use the basic generator only');
     console.log('  testforge generate --force   Regenerate everything');
+    console.log('  testforge generate --source docs        Skip the source-of-truth prompt');
+    console.log('  testforge generate --reference <file|url>  Reconcile docs against a reference first');
     console.log('  testforge discover          Scan source code and draft journey files');
     console.log('  testforge map               Scan project, write journey + data map');
     console.log('  testforge init              Inspect project and write config');

package/dist/core/ai-generator.js

@@ -12,10 +12,10 @@
  */
 import { execFileSync } from 'node:child_process';
 import { readFileSync, existsSync } from 'node:fs';
-import { loadConfig, splitCommand } from './config.js';
+import { loadConfig, splitCommand, withTextOnlyTools } from './config.js';
 const MAP_PATH = 'testforge.md';
 /** Build the prompt we send to the AI for one journey. */
-export function buildPrompt(journey, map) {
+export function buildPrompt(journey, map, testPath) {
     const config = loadConfig();
     const fw = config.framework?.[journey.type];
     const isApi = journey.type === 'api' || fw === 'jest' || fw === 'supertest';
@@ -42,6 +42,16 @@ export function buildPrompt(journey, map) {
         `useful). For payment/webhook journeys, test idempotency, amount/`,
         `price tampering, and signature/verification where relevant.`,
         ``,
+        `IMPORTANT — do not presume the app is vulnerable. For every security`,
+        `probe, assert the SECURE expectation (e.g. auth bypass returns 401/403,`,
+        `a tampered amount is rejected, a duplicate charge is idempotent). Only`,
+        `assert that a vulnerability exists when the journey doc EXPLICITLY`,
+        `documents it as a known/accepted behavior. If you cannot tell from the`,
+        `journey or map whether a defense exists, write the check as`,
+        `test.todo(...) or it.skip(...) with a "// TODO:" note — never assume a`,
+        `guard is missing and produce a failing test that falsely brands the`,
+        `product as vulnerable.`,
+        ``,
         isApi
             ? [
                 `Because this is an API journey, write Jest tests that call the`,
@@ -60,6 +70,17 @@ export function buildPrompt(journey, map) {
                 `they are real.`,
             ].join('\n'),
         ``,
+        ...(testPath
+            ? [
+                `This test file will be saved at EXACTLY this path:`,
+                `  ${testPath}`,
+                `Compute every require()/import path (to app source, helpers, the`,
+                `seed file, etc.) RELATIVE TO THAT EXACT location — count the`,
+                `directory depth from that path, do not assume a conventional`,
+                `depth. Getting the relative depth wrong breaks the whole file.`,
+                ``,
+            ]
+            : []),
         `This test relies on seeded test data (a separate seed file provisions`,
         `the database before tests run). Assume the seed has created the`,
         `records described in the journey's Data section, using stable test`,
@@ -96,10 +117,12 @@ export function buildPrompt(journey, map) {
  * journey. Reads the project map (testforge.md) for data-layer
  * context. Returns the test file content.
  */
-export function generateWithAI(journey) {
+export function generateWithAI(journey, testPath) {
     const map = existsSync(MAP_PATH) ? readFileSync(MAP_PATH, 'utf-8') : '';
-    const prompt = buildPrompt(journey, map);
-    const { program, args } = splitCommand(loadConfig().aiCommand);
+    const prompt = buildPrompt(journey, map, testPath);
+    // Generation is pure text — run with NO tools so the model just
+    // prints code instead of trying to write files.
+    const { program, args } = withTextOnlyTools(splitCommand(loadConfig().aiCommand));
     const output = execFileSync(program, args, {
         input: prompt,
         encoding: 'utf-8',
@@ -107,35 +130,65 @@ export function generateWithAI(journey) {
     });
     return cleanOutput(output);
 }
+/** Does this line look like the start (or body) of real code? */
+function looksLikeCode(line) {
+    const t = line.trim();
+    return (t.startsWith('//') ||
+        t.startsWith('/*') ||
+        t.startsWith('*') ||
+        t.startsWith('import ') ||
+        t.startsWith('export ') ||
+        t.startsWith('const ') ||
+        t.startsWith('let ') ||
+        t.startsWith('var ') ||
+        t.startsWith('function ') ||
+        t.startsWith('async ') ||
+        t.startsWith('require(') ||
+        t.startsWith("'use strict'") ||
+        t.startsWith('"use strict"'));
+}
 /**
  * Extract clean code from the AI's reply.
  *
  * 1. If there's a fenced code block, take its contents.
- * 2. Otherwise, drop any leading prose by starting from the first line
- *    that looks like code (a comment, import, require, or known
- *    statement keyword). This rescues cases where the AI adds a
- *    sentence before the code despite instructions.
+ * 2. Otherwise, keep only the span between the first and the last
+ *    code-ish line — this strips BOTH leading prose ("Here is the
+ *    code:") and trailing prose ("Note: I attempted to write the
+ *    file...") that the model sometimes adds despite instructions.
+ * 3. If no code can be detected at all, throw so the caller can
+ *    retry or skip — we never return junk to be written to disk.
+ *
+ * Exported so the seed generator can share the exact same cleaning
+ * logic instead of a weaker fence-only strip.
  */
-function cleanOutput(text) {
+export function cleanOutput(text) {
     // 1. Prefer a fenced code block if present.
-    const fence = text.match(/```[a-zA-Z]*\n([\s\S]*?)\n```/);
+    const fence = text.match(/```[a-zA-Z]*\n([\s\S]*?)```/);
     if (fence) {
-        return fence[1].trim();
+        const inner = fence[1].trim();
+        if (!inner) {
+            throw new Error('AI output contained an empty code fence');
+        }
+        return inner;
     }
-    // 2. No fence — find the first line that looks like real code.
+    // 2. No fence — locate the first line that looks like real code.
     const lines = text.split('\n');
-    const codeStart = lines.findIndex((line) => {
-        const t = line.trim();
-        return (t.startsWith('//') ||
-            t.startsWith('/*') ||
-            t.startsWith('import ') ||
-            t.startsWith('const ') ||
-            t.startsWith('require(') ||
-            t.startsWith("'use strict'") ||
-            t.startsWith('"use strict"'));
-    });
-    if (codeStart > 0) {
-        return lines.slice(codeStart).join('\n').trim();
+    const codeStart = lines.findIndex(looksLikeCode);
+    if (codeStart === -1) {
+        throw new Error('AI output contained no recognizable code');
+    }
+    // Trim trailing prose: walk back from the end to the last line that
+    // is code-ish or ends with a code terminator (; } ) ]). A trailing
+    // sentence ("Note: ...") ends with a word/period, so it is dropped.
+    let codeEnd = codeStart;
+    for (let i = lines.length - 1; i >= codeStart; i--) {
+        const t = lines[i].trim();
+        if (t === '')
+            continue;
+        if (looksLikeCode(t) || /[;})\]]$/.test(t)) {
+            codeEnd = i;
+            break;
+        }
     }
-    return text.trim();
+    return lines.slice(codeStart, codeEnd + 1).join('\n').trim();
 }

package/dist/core/config.js

@@ -14,7 +14,16 @@
  *
  * If no config file exists, we default to "claude -p" so users with
  * Claude installed work out of the box. Users of other tools (Gemini,
- * Codex, etc.) set aiCommand to their own CLI.
+ * Codex, etc.) set aiCommand to their own CLI — it just needs to read a
+ * prompt on stdin and print the reply to stdout.
+ *
+ * The command is a BASE. Each phase appends the flags it needs (these
+ * are tool-specific; for Claude): the setup phases (init/map/discover)
+ * add `--permission-mode acceptEdits` because the model reads/writes
+ * files, while the pure-text generation phases add `--allowedTools ""`
+ * so the model has NO tools and just prints code — it can't try (and
+ * fail) to write a file and leak "the write wasn't approved..." prose
+ * into the output. See withTextOnlyTools / withEditTools.
  */
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
@@ -44,14 +53,80 @@ export function loadConfig() {
 }
 /**
  * Split an AI command string into a program and its arguments.
- * Example: "claude -p" -> { program: "claude", args: ["-p"] }
+ *
+ * Quote-aware: single or double quotes group a token and can produce an
+ * EMPTY-string argument, which matters for invocations like
+ * `claude -p --allowedTools ""` (disable all tools). A naive
+ * whitespace split would turn "" into the literal two-char token `""`.
+ *
+ * Example: `claude -p --allowedTools ""`
+ *   -> { program: "claude", args: ["-p", "--allowedTools", ""] }
  */
 export function splitCommand(command) {
-    const parts = command.trim().split(/\s+/);
-    const program = parts[0];
-    const args = parts.slice(1);
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    let started = false; // did the current token have any chars (incl. empty quotes)?
+    for (const ch of command.trim()) {
+        if (quote) {
+            if (ch === quote) {
+                quote = null; // closing quote — token may be empty
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            started = true;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (started) {
+                tokens.push(current);
+                current = '';
+                started = false;
+            }
+            continue;
+        }
+        current += ch;
+        started = true;
+    }
+    if (started)
+        tokens.push(current);
+    const program = tokens[0] ?? '';
+    const args = tokens.slice(1);
     return { program, args };
 }
+/** Is this command Claude's CLI (so Claude-specific flags apply)? */
+function isClaude(program) {
+    const base = program.split(/[\\/]/).pop() ?? program;
+    return base === 'claude';
+}
+/**
+ * Args for a pure-text generation call (test/seed): no tools at all, so
+ * the model prints code instead of attempting file writes. Only applies
+ * the Claude flag when the base command is Claude; other CLIs get the
+ * command unchanged (configure their own text-only mode if needed).
+ */
+export function withTextOnlyTools(cmd) {
+    if (!isClaude(cmd.program))
+        return cmd;
+    return { program: cmd.program, args: [...cmd.args, '--allowedTools', ''] };
+}
+/**
+ * Args for a phase where the model must read/write files (init, map,
+ * discover). Mirrors withTextOnlyTools but grants edit permission.
+ */
+export function withEditTools(cmd) {
+    if (!isClaude(cmd.program))
+        return cmd;
+    return {
+        program: cmd.program,
+        args: [...cmd.args, '--permission-mode', 'acceptEdits'],
+    };
+}
 /**
  * Decide where a journey's test file should go, based on its type
  * and the config. Falls back to "generated-tests/<area>" when the

package/dist/core/discover.js

@@ -15,7 +15,7 @@
  * keeps this simple and works for projects of any size.
  */
 import { execFileSync } from 'node:child_process';
-import { loadConfig, splitCommand } from './config.js';
+import { loadConfig, splitCommand, withEditTools } from './config.js';
 /** Build the discovery prompt. */
 export function buildDiscoverPrompt(srcDir, docsDir) {
     return [
@@ -93,8 +93,8 @@ export function runDiscover(srcDir, docsDir) {
     // read source files and write markdown files. The flags for that
     // are tool-specific; for Claude we add acceptEdits. Other tools may
     // need different setup (see README).
-    const { program, args } = splitCommand(loadConfig().aiCommand);
-    const output = execFileSync(program, [...args, '--permission-mode', 'acceptEdits'], {
+    const { program, args } = withEditTools(splitCommand(loadConfig().aiCommand));
+    const output = execFileSync(program, args, {
         input: prompt,
         encoding: 'utf-8',
         maxBuffer: 10 * 1024 * 1024,

package/dist/core/env-template.js

@@ -11,15 +11,19 @@
  * Only names are collected, never values. The developer fills in real
  * values in their own .env.testing (which stays out of version control).
  */
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, readdirSync, } from 'node:fs';
+import { join } from 'node:path';
 import { findMarkdownFiles } from './find-files.js';
 /** Pull env var names from a chunk of text. */
 function extractEnvVars(text) {
     const vars = new Set();
-    // process.env.XXX
+    // process.env.XXX  and  process.env["XXX"] / process.env['XXX']
     for (const m of text.matchAll(/process\.env\.([A-Z0-9_]+)/gi)) {
         vars.add(m[1]);
     }
+    for (const m of text.matchAll(/process\.env\[\s*['"]([A-Z0-9_]+)['"]\s*\]/gi)) {
+        vars.add(m[1]);
+    }
     // backtick-wrapped ALL_CAPS names in "env var" lines
     for (const line of text.split('\n')) {
         if (/env var|secret|credential/i.test(line)) {
@@ -30,6 +34,69 @@ function extractEnvVars(text) {
     }
     return vars;
 }
+/** Directories we never want to scan for app env vars. */
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    'docs',
+    'generated-tests',
+    '.testforge',
+]);
+const SOURCE_EXT = /\.(c|m)?[jt]sx?$/i;
+/**
+ * Scan the project's application SOURCE (not just the docs) for
+ * process.env references. Docs describe features; they routinely miss
+ * boot-critical vars (Sentry DSN, Twilio keys, feature flags) that the
+ * app reads directly at startup. Without those in the example file, the
+ * server won't even boot for a fresh clone. We walk the source tree,
+ * skipping vendored/build/test output, with a file cap so a huge repo
+ * can't stall the run.
+ */
+function scanSourceEnvVars(srcDir, maxFiles = 4000) {
+    const vars = new Set();
+    let seen = 0;
+    const walk = (dir) => {
+        if (seen >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (seen >= maxFiles)
+                return;
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.'))
+                    continue;
+                walk(full);
+            }
+            else if (SOURCE_EXT.test(entry.name)) {
+                // Skip test files — we want app source, not existing tests.
+                if (/\.(test|spec)\./i.test(entry.name))
+                    continue;
+                seen++;
+                try {
+                    for (const v of extractEnvVars(readFileSync(full, 'utf-8'))) {
+                        vars.add(v);
+                    }
+                }
+                catch {
+                    // unreadable file — ignore
+                }
+            }
+        }
+    };
+    if (existsSync(srcDir))
+        walk(srcDir);
+    return vars;
+}
 /** Derive "area" and "journey" from a doc file name like web-payments.md */
 function areaAndJourney(file) {
     // file is a relative path like "api/payments.md" (folder = area).
@@ -41,7 +108,7 @@ function areaAndJourney(file) {
     // Fallback: flat file with no area folder.
     return { area: 'general', journey: noExt };
 }
-export function runEnvTemplate(docsDir, outPath) {
+export function runEnvTemplate(docsDir, outPath, srcDir = '.') {
     if (!existsSync(docsDir)) {
         console.log(`No docs found at "${docsDir}". Run \`testforge setup\` first.`);
         return;
@@ -76,8 +143,18 @@ export function runEnvTemplate(docsDir, outPath) {
             }
         }
     }
-    if (byArea.size === 0) {
-        console.log('No environment variables found in the docs.');
+    // Vars the app reads directly from source but that no doc/map mentioned.
+    // These are the ones that silently break `boot` when missing, so they get
+    // their own clearly-flagged section.
+    const knownFromDocs = new Set();
+    for (const areaMap of byArea.values()) {
+        for (const v of areaMap.keys())
+            knownFromDocs.add(v);
+    }
+    const sourceVars = scanSourceEnvVars(srcDir);
+    const bootVars = [...sourceVars].filter((v) => !knownFromDocs.has(v)).sort();
+    if (byArea.size === 0 && bootVars.length === 0) {
+        console.log('No environment variables found in the docs or source.');
         return;
     }
     // Build the file.
@@ -90,6 +167,15 @@ export function runEnvTemplate(docsDir, outPath) {
         '# Keep .env.testing OUT of version control.',
         '',
     ];
+    if (bootVars.length > 0) {
+        lines.push(`# ${'='.repeat(40)}`);
+        lines.push('# APP (read directly from source — REQUIRED to boot)');
+        lines.push(`# ${'='.repeat(40)}`);
+        for (const v of bootVars) {
+            lines.push(`${v}=            # used by: app source`);
+        }
+        lines.push('');
+    }
     for (const area of [...byArea.keys()].sort()) {
         lines.push(`# ${'='.repeat(40)}`);
         lines.push(`# ${area.toUpperCase()}`);

package/dist/core/generate-command.js

@@ -0,0 +1,55 @@
+/**
+ * testforge — the `generate` command (CLI orchestration).
+ *
+ * This ties together the source-of-truth barrier and the generate
+ * pipeline, and prints results for the terminal. It is async because the
+ * barrier may prompt the developer interactively (see source-of-truth.ts).
+ *
+ * Kept separate from the pure runGenerate() engine so that engine stays
+ * synchronous and easy to call from update.ts, while the human-facing
+ * command handles prompting and output.
+ */
+import { runGenerate } from './run-generate.js';
+import { resolveSourceOfTruth } from './source-of-truth.js';
+export async function runGenerateCommand(opts) {
+    // 1. Decide (and possibly reconcile) the source of truth first.
+    await resolveSourceOfTruth({
+        docsDir: opts.docsDir,
+        reference: opts.reference,
+        source: opts.source,
+    });
+    // 2. Generate from whatever the docs now say.
+    const results = runGenerate(opts.docsDir, opts.useAI, opts.force);
+    if (results.length === 0) {
+        console.log(`No journey files found in ${opts.docsDir}/. Add a .md file and try again.`);
+        return;
+    }
+    for (const r of results) {
+        if (r.status === 'skipped') {
+            console.log(`  [skip] ${r.journeyName} (unchanged)`);
+        }
+        else {
+            const tag = r.status === 'ai' ? '[AI]' : '[basic]';
+            console.log(`  ${tag} ${r.journeyName}`);
+            console.log(`         test: ${r.testPath}`);
+            if (r.status === 'ai') {
+                if (r.seedStatus === 'ok') {
+                    console.log(`         seed: ${r.seedPath}`);
+                }
+                else if (r.seedStatus === 'failed') {
+                    console.log(`         seed: (not written — generation failed)`);
+                }
+            }
+        }
+        for (const w of r.warnings ?? []) {
+            console.log(`         ! ${w}`);
+        }
+    }
+    const generated = results.filter((r) => r.status !== 'skipped').length;
+    const skipped = results.filter((r) => r.status === 'skipped').length;
+    const seedFailures = results.filter((r) => r.seedStatus === 'failed').length;
+    console.log(`\nDone. ${generated} generated, ${skipped} skipped (unchanged).`);
+    if (seedFailures > 0) {
+        console.log(`Warning: ${seedFailures} seed file(s) could not be generated — see notes above.`);
+    }
+}

package/dist/core/index.js

@@ -4,4 +4,4 @@
  * Currently exposes the package version only.
  * Model, parser, and engines will be added in upcoming steps.
  */
-export const VERSION = '0.1.0';
+export const VERSION = '0.2.0';

package/dist/core/init.js

@@ -11,7 +11,7 @@
  * infers it from what the project actually looks like.
  */
 import { execFileSync } from 'node:child_process';
-import { loadConfig, splitCommand } from './config.js';
+import { loadConfig, splitCommand, withEditTools } from './config.js';
 /** Build the prompt that asks the AI to write testforge.config.json. */
 export function buildInitPrompt() {
     return [
@@ -57,8 +57,8 @@ export function buildInitPrompt() {
 /** Run init via the configured AI command. */
 export function runInit() {
     const prompt = buildInitPrompt();
-    const { program, args } = splitCommand(loadConfig().aiCommand);
-    const output = execFileSync(program, [...args, '--permission-mode', 'acceptEdits'], {
+    const { program, args } = withEditTools(splitCommand(loadConfig().aiCommand));
+    const output = execFileSync(program, args, {
         input: prompt,
         encoding: 'utf-8',
         maxBuffer: 10 * 1024 * 1024,