levante 0.3.6 → 0.3.7

package/dist/mcp.js

@@ -28540,7 +28540,7 @@ class StdioServerTransport {
 // src/mcp.ts
 import { execSync } from "node:child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/agents/loadAgent.ts
 import { readFileSync, existsSync as existsSync2, readdirSync } from "node:fs";
@@ -28726,6 +28726,44 @@ function parseSections(body) {
   return sections;
 }
 
+// src/config/paths.ts
+import { join as join3 } from "node:path";
+function resolvePaths(config2, key) {
+  const root = getProjectRoot();
+  const workingDir = join3(root, config2.paths.workingDir);
+  const testsDir = join3(root, config2.paths.tests);
+  const recordingsDir = join3(root, config2.paths.recordings);
+  const transcriptsDir = join3(root, config2.paths.transcripts);
+  const tracesDir = join3(root, config2.paths.traces);
+  const qaDir = join3(root, config2.paths.qaOutput);
+  const keyDir = key ? join3(workingDir, key) : null;
+  const testDir = key ? join3(testsDir, key) : null;
+  const testFile = key ? join3(testsDir, key, `${key}.test.ts`) : null;
+  const scenarioDir = key ? join3(testsDir, key) : null;
+  const scenarioFile = key ? join3(testsDir, key, `${key}.yaml`) : null;
+  const qaFile = key ? join3(qaDir, `${key}.md`) : null;
+  const needsZephyr = config2.outputTarget === "zephyr" || config2.outputTarget === "both";
+  const zephyrJsonFile = needsZephyr && key ? join3(workingDir, key, `${key}-zephyr-test-case.json`) : null;
+  const zephyrXmlFile = needsZephyr && key ? join3(testsDir, key, `${key}-zephyr-import.xml`) : null;
+  return {
+    projectRoot: root,
+    workingDir,
+    keyDir,
+    testsDir,
+    testDir,
+    testFile,
+    scenarioDir,
+    scenarioFile,
+    recordingsDir,
+    transcriptsDir,
+    tracesDir,
+    qaDir,
+    qaFile,
+    zephyrJsonFile,
+    zephyrXmlFile
+  };
+}
+
 // src/scanner/scanner.ts
 import { readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync, writeFileSync } from "node:fs";
 import { resolve as resolve2, relative as relative2 } from "node:path";
@@ -32218,10 +32256,10 @@ class TypeScriptParser {
 
 // src/scanner/extractors/routes.ts
 import { readdirSync as readdirSync2, statSync, readFileSync as readFileSync2 } from "node:fs";
-import { join as join3, relative, basename, dirname as dirname2 } from "node:path";
+import { join as join4, relative, basename, dirname as dirname2 } from "node:path";
 function extractRoutes(scanDir) {
   const routes = [];
-  const appDirs = ["app", "src/app"].map((d) => join3(scanDir, d));
+  const appDirs = ["app", "src/app"].map((d) => join4(scanDir, d));
   for (const appDir of appDirs) {
     try {
       if (statSync(appDir).isDirectory()) {
@@ -32229,7 +32267,7 @@ function extractRoutes(scanDir) {
       }
     } catch {}
   }
-  const pagesDirs = ["pages", "src/pages"].map((d) => join3(scanDir, d));
+  const pagesDirs = ["pages", "src/pages"].map((d) => join4(scanDir, d));
   for (const pagesDir of pagesDirs) {
     try {
       if (statSync(pagesDir).isDirectory()) {
@@ -32242,7 +32280,7 @@ function extractRoutes(scanDir) {
 function extractAppRouterRoutes(dir, baseDir, routes) {
   const entries = readdirSync2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join3(dir, entry.name);
+    const fullPath = join4(dir, entry.name);
     if (entry.isDirectory()) {
       extractAppRouterRoutes(fullPath, baseDir, routes);
       continue;
@@ -32278,7 +32316,7 @@ function extractAppRouterRoutes(dir, baseDir, routes) {
 function extractPagesRouterRoutes(dir, baseDir, routes) {
   const entries = readdirSync2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join3(dir, entry.name);
+    const fullPath = join4(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "api") {
         extractPagesApiRoutes(fullPath, baseDir, routes);
@@ -32304,7 +32342,7 @@ function extractPagesRouterRoutes(dir, baseDir, routes) {
 function extractPagesApiRoutes(dir, baseDir, routes) {
   const entries = readdirSync2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join3(dir, entry.name);
+    const fullPath = join4(dir, entry.name);
     if (entry.isDirectory()) {
       extractPagesApiRoutes(fullPath, baseDir, routes);
       continue;
@@ -32332,7 +32370,7 @@ function findLayoutFile(dir, baseDir) {
   let current = dir;
   while (current.startsWith(baseDir)) {
     for (const ext of [".tsx", ".ts", ".jsx", ".js"]) {
-      const layoutPath = join3(current, `layout${ext}`);
+      const layoutPath = join4(current, `layout${ext}`);
       try {
         statSync(layoutPath);
         return layoutPath;
@@ -32793,7 +32831,7 @@ function requireEnum(obj, field, allowed, context, errors3) {
 
 // src/utils/scan.ts
 import { readdirSync as readdirSync3, existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
-import { join as join4, relative as relative3 } from "node:path";
+import { join as join5, relative as relative3 } from "node:path";
 async function scanCodebase(root) {
   const scan = {
     testFiles: [],
@@ -32812,7 +32850,7 @@ async function scanCodebase(root) {
       for (const entry of readdirSync3(dir, { withFileTypes: true })) {
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist")
           continue;
-        const full = join4(dir, entry.name);
+        const full = join5(dir, entry.name);
         if (entry.isDirectory()) {
           files.push(...walk(full, depth + 1));
         } else {
@@ -32849,7 +32887,7 @@ async function scanCodebase(root) {
     }
   }
   for (const name of ["playwright.config.ts", "vitest.config.ts", "jest.config.ts", "tsconfig.json", "package.json"]) {
-    if (existsSync4(join4(root, name)))
+    if (existsSync4(join5(root, name)))
       scan.configFiles.push(name);
   }
   return scan;
@@ -32898,38 +32936,60 @@ You have access to Levante, an AI-powered E2E test automation tool. Follow this
 
 NEVER run multiple pipeline steps at once. Each step is a separate job with its own context.
 
+## Two Modes of Execution
+
+Steps fall into two categories:
+
+### 1. Tool Steps — use \`levante_execute_step\`
+These steps do NOT require an LLM. Run them via \`levante_execute_step\`:
+- \`record\` — opens Playwright browser codegen (interactive)
+- \`test\` — runs Playwright tests
+- \`push\` — pushes QA map to remote API
+- \`scan\` — runs the filesystem/AST scan
+
+### 2. Agent Steps — YOU are the AI, do these yourself
+These steps require LLM reasoning. Do NOT call \`levante_execute_step\` for them. Instead, load the agent prompt and act on it directly:
+
+| Step | Agent to load | Input to read | Output to write |
+|------|--------------|---------------|-----------------|
+| \`transcribe\` | \`transcript-agent\` | codegen file via \`levante_read_pipeline_file(key, "codegen")\` | transcript JSON via \`levante_write_pipeline_file\` |
+| \`scenario\` | \`scenario-agent\` | codegen + optional transcript | scenario YAML via \`levante_write_pipeline_file(key, "scenario", ...)\` |
+| \`generate\` | \`playwright-generator-agent\` | scenario YAML | test file via \`levante_write_pipeline_file(key, "test", ...)\` |
+| \`refine\` | \`refactor-agent\` | test file | updated test file (overwrite via \`levante_write_pipeline_file\`) |
+| \`heal\` | \`self-healing-agent\` | test file + error output | patched test file |
+| \`qa\` | \`qa-testcase-agent\` | test file + scenario | QA markdown via \`levante_write_pipeline_file(key, "qa", ...)\` |
+| \`analyze\` | \`feature-analyzer-agent\` | AST via \`levante_scan_ast_detail\` | QA map via \`levante_build_qa_map\` |
+
+**Workflow for each agent step:**
+1. Call \`levante_read_agent("<agent-name>")\` to load the system prompt and config.
+2. Call \`levante_read_pipeline_file(key, "<type>")\` to load the input artifact.
+3. Read \`.qai/levante/context.md\` if it exists — this is project context the agent needs.
+4. Apply the agent system prompt to your own reasoning and produce the output.
+5. Call \`levante_write_pipeline_file(key, "<type>", content)\` to save the output.
+
 ## Protocol
 
-1. **Plan first.** Call \`levante_plan_workflow\` with the user's goal. This returns a structured todo list of steps.
-2. **Check prerequisites.** The plan includes a \`ready\` boolean and \`missingPrerequisites\` array. If \`ready\` is false, show the user what's missing (API keys, config, etc.) and **wait for them to fix it** before proceeding. Do NOT attempt to execute any step while prerequisites are missing.
-3. **Present the plan.** Show the user the ordered step list with descriptions. Ask for confirmation or adjustments before proceeding.
-4. **Execute one step at a time.** For each step in the approved plan:
-   a. Tell the user which step you're about to run and why.
-   b. Call \`levante_execute_step\` with the step name and parameters.
-   c. Report the result to the user (success, key output, any warnings).
-   d. If the step fails, stop and discuss with the user before continuing.
-   e. Move to the next step only after the current one succeeds.
-5. **Use subagents when available.** If your AI platform supports subagents (e.g., Claude Code Agent tool), dispatch each step as a dedicated subagent to preserve context. Each subagent should:
-   - Receive only the context it needs (step name, key, relevant file paths)
-   - Call \`levante_execute_step\` to do its work
-   - Return the result to the orchestrator
+1. **Plan first.** Call \`levante_plan_workflow\` with the user's goal to get a structured step list.
+2. **Present the plan.** Show the user the ordered steps. Ask for confirmation before proceeding.
+3. **Execute one step at a time.** For each step:
+   a. Announce which step you're running and why.
+   b. Use **Tool Steps** via \`levante_execute_step\`, or handle **Agent Steps** yourself (see above).
+   c. Report the result. If a step fails, stop and discuss before continuing.
+4. **Use subagents when available.** If your AI platform supports subagents (Claude Code Agent tool), dispatch each step as a dedicated subagent. Each subagent should receive only the context it needs.
 
 ## Step Dependencies
 
-Steps produce artifacts that feed into later steps. The pipeline handles this automatically — each step picks up where the previous one left off. Do not skip steps unless the plan says a step can be skipped.
+Steps produce artifacts consumed by later steps. Do not skip steps unless the plan says a step can be skipped.
 
 ## Interactive Steps
 
-The \`record\` step opens a browser and requires user interaction. When the plan includes \`record\`:
-- Tell the user they need to interact with the browser window
-- The step will block until they close the codegen window
-- After recording completes, proceed with the next step
+The \`record\` step opens a browser. Tell the user to interact with it — the step blocks until they close the codegen window.
 
 ## When Things Fail
 
-- If \`test\` fails and \`heal\` is in the plan, that's expected — heal will attempt to fix it
-- If \`heal\` exhausts all retries, stop and show the user the last error output
-- For any other failure, stop and ask the user how to proceed
+- If \`test\` fails and \`heal\` is in the plan, that's expected — do the \`heal\` agent step yourself.
+- If healing fails after multiple attempts, stop and show the user the last error.
+- For any other failure, stop and ask the user how to proceed.
 
 ## Available Workflows
 
@@ -32945,7 +33005,7 @@ Always use \`levante_plan_workflow\` to determine the right steps — don't gues
 
 ## Scanner Analysis (Interactive QA Map)
 
-For deep codebase analysis and QA map generation, use the interactive scanner workflow instead of the CLI pipeline:
+For deep codebase analysis and QA map generation, use the interactive scanner workflow:
 
 1. **Load the protocol.** Call \`levante_read_agent("scanner-agent")\` — this returns the full interactive protocol.
 2. **Scan.** Call \`levante_scan_ast()\` to run the AST scanner and get a compact summary.
@@ -32954,8 +33014,6 @@ For deep codebase analysis and QA map generation, use the interactive scanner wo
 5. **Build.** Construct the QA map payload and validate with \`levante_build_qa_map({ dryRun: true })\`.
 6. **Write.** Once validated and approved, call \`levante_build_qa_map({ dryRun: false })\` to save.
 7. **Read existing.** Use \`levante_read_qa_map()\` to load a previously generated QA map for incremental updates.
-
-This approach is preferred over \`scan → analyze\` CLI steps because it allows interactive refinement with the user.
 `.trim();
 var TEST_PIPELINE_STEPS = [
   {
@@ -33043,41 +33101,20 @@ var SCANNER_PIPELINE_STEPS = [
 var ALL_STEPS = [...TEST_PIPELINE_STEPS, ...SCANNER_PIPELINE_STEPS];
 var STEP_REQUIREMENTS = {
   record: { envVars: [] },
-  transcribe: { envVars: [{ name: "OPENAI_API_KEY", reason: "Whisper transcription requires OpenAI API key" }] },
-  scenario: { envVars: [
-    { name: "OPENAI_API_KEY", reason: "LLM calls require OpenAI API key", onlyIf: () => getProvider() === "openai" },
-    { name: "ANTHROPIC_API_KEY", reason: "LLM calls require Anthropic API key", onlyIf: () => getProvider() === "anthropic" }
-  ] },
-  generate: { envVars: [
-    { name: "OPENAI_API_KEY", reason: "LLM calls require OpenAI API key", onlyIf: () => getProvider() === "openai" },
-    { name: "ANTHROPIC_API_KEY", reason: "LLM calls require Anthropic API key", onlyIf: () => getProvider() === "anthropic" }
-  ] },
-  refine: { envVars: [
-    { name: "OPENAI_API_KEY", reason: "LLM calls require OpenAI API key", onlyIf: () => getProvider() === "openai" },
-    { name: "ANTHROPIC_API_KEY", reason: "LLM calls require Anthropic API key", onlyIf: () => getProvider() === "anthropic" }
-  ] },
+  transcribe: { envVars: [] },
+  scenario: { envVars: [] },
+  generate: { envVars: [] },
+  refine: { envVars: [] },
   test: { envVars: [] },
-  heal: { envVars: [
-    { name: "OPENAI_API_KEY", reason: "LLM calls require OpenAI API key", onlyIf: () => getProvider() === "openai" },
-    { name: "ANTHROPIC_API_KEY", reason: "LLM calls require Anthropic API key", onlyIf: () => getProvider() === "anthropic" }
-  ] },
-  qa: { envVars: [
-    { name: "OPENAI_API_KEY", reason: "LLM calls require OpenAI API key", onlyIf: () => getProvider() === "openai" },
-    { name: "ANTHROPIC_API_KEY", reason: "LLM calls require Anthropic API key", onlyIf: () => getProvider() === "anthropic" }
-  ] },
+  heal: { envVars: [] },
+  qa: { envVars: [] },
   scan: { envVars: [] },
-  analyze: { envVars: [
-    { name: "OPENAI_API_KEY", reason: "LLM calls require OpenAI API key", onlyIf: () => getProvider() === "openai" },
-    { name: "ANTHROPIC_API_KEY", reason: "LLM calls require Anthropic API key", onlyIf: () => getProvider() === "anthropic" }
-  ] },
+  analyze: { envVars: [] },
   push: { envVars: [
     { name: "E2E_AI_API_URL", reason: "Push requires API URL (set E2E_AI_API_URL or push.apiUrl in config)" },
     { name: "E2E_AI_API_KEY", reason: "Push requires API key (set E2E_AI_API_KEY or push.apiKey in config)" }
   ] }
 };
-function getProvider() {
-  return process.env.AI_PROVIDER ?? "openai";
-}
 function checkPrerequisites(stepNames) {
   const issueMap = new Map;
   for (const stepName of stepNames) {
@@ -33085,8 +33122,6 @@ function checkPrerequisites(stepNames) {
     if (!reqs)
       continue;
     for (const envReq of reqs.envVars) {
-      if (envReq.onlyIf && !envReq.onlyIf())
-        continue;
       if (!process.env[envReq.name]) {
         const key = `env:${envReq.name}`;
         if (issueMap.has(key)) {
@@ -33230,7 +33265,7 @@ function executeStep(stepName, options) {
     args.push(...options.extraArgs);
   }
   const pkgRoot = getPackageRoot();
-  const cliBin = join5(pkgRoot, "dist", "cli.js");
+  const cliBin = join6(pkgRoot, "dist", "cli.js");
   const command = `node ${cliBin} ${args.join(" ")}`;
   try {
     const stdout = execSync(command, {
@@ -33257,7 +33292,7 @@ ${stderr}`,
     };
   }
 }
-var server = new McpServer({ name: "levante", version: "1.5.1" }, { instructions: SERVER_INSTRUCTIONS });
+var server = new McpServer({ name: "levante", version: "1.6.0" }, { instructions: SERVER_INSTRUCTIONS });
 server.registerTool("levante_scan_codebase", {
   title: "Scan Codebase",
   description: "Scan a project directory for test files, configs, fixtures, path aliases, and sample test content. Use this during project setup or to understand test infrastructure.",
@@ -33309,13 +33344,108 @@ server.registerTool("levante_read_agent", {
     };
   }
 });
+server.registerTool("levante_read_pipeline_file", {
+  title: "Read Pipeline File",
+  description: "Read a pipeline artifact for a given issue key. Use this before an agent step to load the input. " + 'Types: "codegen" (raw Playwright codegen), "transcript" (voice transcript JSON), ' + '"scenario" (YAML test scenario), "test" (Playwright .test.ts), "qa" (QA markdown), "context" (project context.md).',
+  inputSchema: exports_external.object({
+    key: exports_external.string().optional().describe('Issue key (e.g. PROJ-101). Not required for "context" type.'),
+    type: exports_external.enum(["codegen", "transcript", "scenario", "test", "qa", "context"]).describe("Which artifact to read")
+  })
+}, async ({ key, type }) => {
+  try {
+    let filePath = null;
+    if (type === "context") {
+      filePath = join6(process.cwd(), CONFIG_DIR, "context.md");
+    } else {
+      if (!key) {
+        return {
+          content: [{ type: "text", text: "Error: key is required for this file type" }],
+          isError: true
+        };
+      }
+      const config2 = await loadConfig();
+      const paths = resolvePaths(config2, key);
+      if (type === "codegen") {
+        filePath = paths.keyDir ? join6(paths.keyDir, `${key}.codegen.ts`) : null;
+      } else if (type === "transcript") {
+        filePath = paths.keyDir ? join6(paths.keyDir, `${key}.transcript.json`) : null;
+      } else if (type === "scenario") {
+        filePath = paths.scenarioFile;
+      } else if (type === "test") {
+        filePath = paths.testFile;
+      } else if (type === "qa") {
+        filePath = paths.qaFile;
+      }
+    }
+    if (!filePath) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ found: false, path: null, reason: "Could not resolve path" }) }]
+      };
+    }
+    if (!existsSync5(filePath)) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ found: false, path: filePath }) }]
+      };
+    }
+    const fileContent = readFileSync5(filePath, "utf-8");
+    return {
+      content: [{ type: "text", text: JSON.stringify({ found: true, path: filePath, content: fileContent }) }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true
+    };
+  }
+});
+server.registerTool("levante_write_pipeline_file", {
+  title: "Write Pipeline File",
+  description: "Write a pipeline artifact after completing an agent step. " + 'Types: "transcript" (voice transcript JSON), "scenario" (YAML test scenario), ' + '"test" (Playwright .test.ts), "qa" (QA markdown).',
+  inputSchema: exports_external.object({
+    key: exports_external.string().describe("Issue key (e.g. PROJ-101)"),
+    type: exports_external.enum(["transcript", "scenario", "test", "qa"]).describe("Which artifact to write"),
+    content: exports_external.string().describe("The file content to write")
+  })
+}, async ({ key, type, content: fileContent }) => {
+  try {
+    const config2 = await loadConfig();
+    const paths = resolvePaths(config2, key);
+    const fileMap = {
+      transcript: paths.keyDir ? join6(paths.keyDir, `${key}.transcript.json`) : null,
+      scenario: paths.scenarioFile,
+      test: paths.testFile,
+      qa: paths.qaFile
+    };
+    const filePath = fileMap[type];
+    if (!filePath) {
+      return {
+        content: [{ type: "text", text: `Error: Could not resolve path for type "${type}" with key "${key}"` }],
+        isError: true
+      };
+    }
+    const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("node:fs");
+    const { dirname: dirname4 } = await import("node:path");
+    mkdirSync2(dirname4(filePath), { recursive: true });
+    writeFileSync2(filePath, fileContent, "utf-8");
+    return {
+      content: [{ type: "text", text: JSON.stringify({ written: true, path: filePath }) }]
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true
+    };
+  }
+});
 server.registerTool("levante_get_example", {
   title: "Get Example Context",
   description: `Returns the full example context markdown file that shows the expected format for ${CONFIG_DIR}/context.md.`,
   inputSchema: exports_external.object({})
 }, async () => {
   try {
-    const examplePath = join5(getPackageRoot(), "templates", "e2e-ai.context.example.md");
+    const examplePath = join6(getPackageRoot(), "templates", "e2e-ai.context.example.md");
     const content = readFileSync5(examplePath, "utf-8");
     return {
       content: [{ type: "text", text: content }]
@@ -33411,7 +33541,7 @@ server.registerTool("levante_get_workflow_guide", {
   inputSchema: exports_external.object({})
 }, async () => {
   try {
-    const guidePath = join5(getPackageRoot(), "templates", "workflow.md");
+    const guidePath = join6(getPackageRoot(), "templates", "workflow.md");
     if (!existsSync5(guidePath)) {
       return {
         content: [{ type: "text", text: "Error: workflow.md not found in templates" }],
@@ -33442,15 +33572,15 @@ server.registerTool("levante_scan_ast", {
     const cwd = process.cwd();
     const dir = scanDir ?? "src";
     const scanConfig = {
-      scanDir: join5(cwd, dir),
+      scanDir: join6(cwd, dir),
       include: include ?? ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
       exclude: exclude ?? ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.next/**", "**/*.test.*", "**/*.spec.*", "**/__tests__/**"],
-      cacheDir: join5(cwd, CONFIG_DIR, "cache")
+      cacheDir: join6(cwd, CONFIG_DIR, "cache")
     };
     const ast = await runStage1(scanConfig);
-    const astPath = join5(cwd, CONFIG_DIR, "ast-scan.json");
+    const astPath = join6(cwd, CONFIG_DIR, "ast-scan.json");
     const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("node:fs");
-    mkdirSync2(join5(cwd, CONFIG_DIR), { recursive: true });
+    mkdirSync2(join6(cwd, CONFIG_DIR), { recursive: true });
     writeFileSync2(astPath, JSON.stringify(ast, null, 2));
     const summary2 = summarizeAST(ast, astPath);
     return {
@@ -33473,7 +33603,7 @@ server.registerTool("levante_scan_ast_detail", {
   })
 }, async ({ category, filter, limit }) => {
   try {
-    const astPath = join5(process.cwd(), CONFIG_DIR, "ast-scan.json");
+    const astPath = join6(process.cwd(), CONFIG_DIR, "ast-scan.json");
     if (!existsSync5(astPath)) {
       return {
         content: [{ type: "text", text: "Error: No AST scan found. Run levante_scan_ast first." }],
@@ -33509,7 +33639,7 @@ server.registerTool("levante_build_qa_map", {
         payload.commitSha = sha;
       } catch {}
     }
-    const outputPath = output ?? join5(process.cwd(), CONFIG_DIR, "qa-map.json");
+    const outputPath = output ?? join6(process.cwd(), CONFIG_DIR, "qa-map.json");
     let written = false;
     if (validation.valid && !dryRun) {
       const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("node:fs");
@@ -33553,7 +33683,7 @@ server.registerTool("levante_read_qa_map", {
   })
 }, async ({ path }) => {
   try {
-    const mapPath = path ?? join5(process.cwd(), CONFIG_DIR, "qa-map.json");
+    const mapPath = path ?? join6(process.cwd(), CONFIG_DIR, "qa-map.json");
     if (!existsSync5(mapPath)) {
       return {
         content: [{ type: "text", text: JSON.stringify(null) }]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "levante",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "type": "module",
   "bin": {
     "levante": "./dist/cli.js",