@popoverai/dotrequirements 0.26.0 → 0.26.2

package/dist/codebase-to-spec/validate.js

@@ -87,8 +87,9 @@ function describeValidationError(err) {
         const parts = [err.message];
         let cursor = err.cause;
         while (cursor instanceof Error) {
-            // Don't repeat the same message twice if the wrapper just rethrew.
-            if (cursor.message && cursor.message !== parts[parts.length - 1]) {
+            // Don't repeat the same message twice if the wrapper just rethrew
+            // (or already embedded the inner message in its own).
+            if (cursor.message && !parts[parts.length - 1].includes(cursor.message)) {
                 parts.push(cursor.message);
             }
             cursor = cursor.cause;

package/dist/commands/acceptance-test.js

@@ -127,8 +127,10 @@ export async function acceptanceTestCommand(requirementKey, url, options) {
         else {
             displayResults(requirementTree, results);
         }
-        // 11. Exit with appropriate code
-        const failedCount = results.filter((r) => r.status !== "passed").length;
+        // 11. Exit with appropriate code — computed over the requirement tree so
+        // a requirement with a missing result counts as not passing, agreeing
+        // with the displayed counts (ACCEPTANCE-1.0/.1/.2)
+        const failedCount = requirementTree.filter((_, i) => results[i]?.status !== "passed").length;
         if (failedCount > 0) {
             process.exit(1);
         }

package/dist/commands/ai-setup.js

@@ -1,10 +1,11 @@
-import { execSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import prompts from "prompts";
 import { brand } from "../utils/brand.js";
 import { appendOrUpdateSection, buildNoGitRepoMessage, findDotrequirementsSection, findGitRoot, getContextFileName, } from "../utils/context-file.js";
+import { findProjectRoot, readProjectSettings, } from "../utils/project-settings.js";
 import { loadTemplate } from "../utils/templates.js";
 /**
  * Load the context file section template
@@ -12,6 +13,56 @@ import { loadTemplate } from "../utils/templates.js";
 function loadContextFileSection() {
     return loadTemplate("context-file-section.md");
 }
+/**
+ * Read an assistant's existing MCP config file (AISETUP-2).
+ * Returns {} when the file is absent or empty. Returns null when the file
+ * exists but is unusable — unreadable (AISETUP-2.2), invalid JSON
+ * (AISETUP-2.1), or a non-object root (AISETUP-2.3). In every null case the
+ * path has already been shown to the user and the caller must stop without
+ * writing; rewriting would destroy every other configured server.
+ */
+function readExistingMcpConfig(configPath) {
+    const stopWithoutWriting = (reason) => {
+        console.error(`❌ ${reason}`);
+        console.log("   Nothing was changed. Fix (or remove) the file, then re-run ai-setup:");
+        console.log(`   ${configPath}\n`);
+        return null;
+    };
+    if (!existsSync(configPath)) {
+        return {};
+    }
+    let existingContent;
+    try {
+        existingContent = readFileSync(configPath, "utf-8");
+    }
+    catch {
+        return stopWithoutWriting("Existing config file could not be read.");
+    }
+    if (!existingContent.trim()) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(existingContent);
+    }
+    catch {
+        return stopWithoutWriting("Existing config file contains invalid JSON.");
+    }
+    // AISETUP-2.3: a non-object root (e.g. a top-level array) would swallow the
+    // mcpServers assignment and serialize back without it — success would be
+    // reported while nothing was configured
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return stopWithoutWriting("Existing config file is not a JSON object.");
+    }
+    // AISETUP-2.3: same trap one level down — an array-valued mcpServers takes
+    // the server entry as an expando property that JSON.stringify drops
+    const mcpServers = parsed.mcpServers;
+    if (mcpServers != null &&
+        (typeof mcpServers !== "object" || Array.isArray(mcpServers))) {
+        return stopWithoutWriting('Existing config file has an "mcpServers" field that is not a JSON object.');
+    }
+    return parsed;
+}
 /**
  * Install workflow guidance to the appropriate context file for a platform.
  * With `yes` (the non-interactive --assistant path, AISETUP-1.0), both
@@ -166,10 +217,18 @@ async function dispatchSetup(client, yes = false) {
 }
 async function setupClaudeCode(yes = false) {
     console.log("\n📦 Configuring MCP for Claude Code...\n");
-    const command = `claude mcp add-json dotrequirements '{"type":"stdio","command":"npx","args":["-y","@popoverai/dotrequirements","mcp"]}'`;
+    // Register via an args array so no shell quoting is involved: cmd.exe does
+    // not honor single quotes, so a shell-quoted JSON string breaks on Windows.
+    const mcpServerJson = JSON.stringify({
+        type: "stdio",
+        command: "npx",
+        args: ["-y", "@popoverai/dotrequirements", "mcp"],
+    });
+    // Shell-safe on every platform (no quoting needed anywhere)
+    const manualCommand = "claude mcp add dotrequirements -- npx -y @popoverai/dotrequirements mcp";
     let mcpConfigured = false;
     try {
-        execSync(command, { stdio: "pipe" });
+        execFileSync("claude", ["mcp", "add-json", "dotrequirements", mcpServerJson], { stdio: "pipe" });
         console.log("✅ MCP configured successfully for Claude Code!");
         mcpConfigured = true;
     }
@@ -185,7 +244,7 @@ async function setupClaudeCode(yes = false) {
         else {
             console.error("❌ Failed to configure MCP automatically.");
             console.log("\nYou can manually run:");
-            console.log(`  ${command}`);
+            console.log(`  ${manualCommand}`);
             if (stderr) {
                 console.log(`\nError: ${stderr}`);
             }
@@ -224,24 +283,17 @@ async function setupClaudeDesktop() {
             REQUIREMENTS_DIR: process.cwd(),
         },
     };
+    // AISETUP-2.1–2.3: bail out before touching anything if the config is unusable
+    const config = readExistingMcpConfig(configPath);
+    if (config === null) {
+        return;
+    }
     try {
         if (!existsSync(configDir)) {
             console.log("Creating Claude Desktop config directory...");
             mkdirSync(configDir, { recursive: true });
         }
-        let config = {};
-        if (existsSync(configPath)) {
-            try {
-                const existingContent = readFileSync(configPath, "utf-8");
-                if (existingContent.trim()) {
-                    config = JSON.parse(existingContent);
-                }
-            }
-            catch {
-                console.log("⚠️  Existing config file is invalid, creating fresh config...");
-                config = {};
-            }
-        }
+        // AISETUP-2.0: other configured servers survive; only ours is (re)set
         if (!config.mcpServers) {
             config.mcpServers = {};
         }
@@ -271,30 +323,26 @@ async function setupClaudeDesktop() {
 }
 async function setupCursor(yes = false) {
     console.log("\n📦 Configuring MCP for Cursor (project-specific)...\n");
-    const configPath = join(process.cwd(), ".cursor", "mcp.json");
-    const configDir = join(process.cwd(), ".cursor");
+    // Cursor loads .cursor/mcp.json from the project (git) root — match the
+    // context-file placement, falling back to cwd outside a repository
+    const projectDir = (await findGitRoot()) ?? process.cwd();
+    const configDir = join(projectDir, ".cursor");
+    const configPath = join(configDir, "mcp.json");
     const mcpServerConfig = {
         command: "npx",
         args: ["-y", "@popoverai/dotrequirements", "mcp"],
     };
+    // AISETUP-2.1–2.3: bail out before touching anything if the config is unusable
+    const config = readExistingMcpConfig(configPath);
+    if (config === null) {
+        return;
+    }
     try {
         if (!existsSync(configDir)) {
             console.log("Creating Cursor config directory...");
             mkdirSync(configDir, { recursive: true });
         }
-        let config = {};
-        if (existsSync(configPath)) {
-            try {
-                const existingContent = readFileSync(configPath, "utf-8");
-                if (existingContent.trim()) {
-                    config = JSON.parse(existingContent);
-                }
-            }
-            catch {
-                console.log("⚠️  Existing config file is invalid, creating fresh config...");
-                config = {};
-            }
-        }
+        // AISETUP-2.0: other configured servers survive; only ours is (re)set
         if (!config.mcpServers) {
             config.mcpServers = {};
         }
@@ -324,45 +372,33 @@ async function setupAntigravity(yes = false) {
     console.log("\n📦 Configuring MCP for Google Antigravity...\n");
     const configPath = join(homedir(), ".gemini", "antigravity", "mcp_config.json");
     const configDir = join(homedir(), ".gemini", "antigravity");
-    // Check if we're in a dotrequirements project directory
-    const envLocalPath = join(process.cwd(), ".env.local");
+    // AISETUP-3.0: detect the project the way the CLI defines projects —
+    // .requirements/project-settings.json at the project root
     let projectId = null;
     let projectPath = null;
-    if (existsSync(envLocalPath)) {
+    const projectRoot = findProjectRoot();
+    if (projectRoot) {
         try {
-            const envContent = readFileSync(envLocalPath, "utf-8");
-            const lines = envContent.split("\n");
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (trimmed.startsWith("DOTREQUIREMENTS_PROJECT_ID=")) {
-                    projectId = trimmed.split("=")[1]?.trim().replace(/['"]/g, "");
-                    projectPath = process.cwd();
-                    break;
-                }
+            const settings = readProjectSettings(projectRoot);
+            if (settings) {
+                projectId = settings.projectId;
+                projectPath = projectRoot;
             }
         }
         catch {
-            // .env.local exists but couldn't read it - continue with global setup
+            // Settings file unreadable/invalid — continue with global setup
         }
     }
+    // AISETUP-2.1–2.3: bail out before touching anything if the config is unusable
+    const config = readExistingMcpConfig(configPath);
+    if (config === null) {
+        return;
+    }
     try {
         if (!existsSync(configDir)) {
             console.log("Creating Antigravity config directory...");
             mkdirSync(configDir, { recursive: true });
         }
-        let config = {};
-        if (existsSync(configPath)) {
-            try {
-                const existingContent = readFileSync(configPath, "utf-8");
-                if (existingContent.trim()) {
-                    config = JSON.parse(existingContent);
-                }
-            }
-            catch {
-                console.log("⚠️  Existing config file is invalid, creating fresh config...");
-                config = {};
-            }
-        }
         if (!config.mcpServers) {
             config.mcpServers = {};
         }
@@ -385,7 +421,9 @@ async function setupAntigravity(yes = false) {
             console.log(`   Path: ${projectPath}\n`);
         }
         else {
-            console.log(`ℹ️  Not in a ${brand} project directory (no .env.local with DOTREQUIREMENTS_PROJECT_ID found)`);
+            // AISETUP-3.1: outside any initialized project — skip the per-project
+            // step and say so
+            console.log("ℹ️  No project found (no .requirements/project-settings.json in this directory or its parents)");
             console.log("   Setting up global MCP server only.\n");
         }
         writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");

package/dist/commands/codebase-to-spec/dispatch-editor.js

@@ -12,10 +12,10 @@
  * - CTSO-CONV-3: orchestrator dispatches an editor when revisions are needed
  */
 import { existsSync, readFileSync } from "node:fs";
+import { sanitizeAreaName } from "../../codebase-to-spec/area-name.js";
 import { cachePaths } from "../../codebase-to-spec/cache.js";
 import { EDITOR_DISPATCH_ID_PREFIX } from "../../codebase-to-spec/dispatch.js";
 import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
-import { sanitizeAreaName } from "../../codebase-to-spec/fan-out.js";
 import { parseConversationalOutline, } from "../../codebase-to-spec/schemas.js";
 import { findProjectRoot } from "../../utils/project-settings.js";
 export async function dispatchEditorCommand(areaPrefix) {

package/dist/commands/codebase-to-spec/dispatch-spec.js

@@ -10,10 +10,10 @@
  * the orchestrator should approve the outline before fan-out.
  */
 import { existsSync, readFileSync } from "node:fs";
+import { sanitizeAreaName } from "../../codebase-to-spec/area-name.js";
 import { cachePaths } from "../../codebase-to-spec/cache.js";
 import { SPECIFIER_DISPATCH_ID_PREFIX } from "../../codebase-to-spec/dispatch.js";
 import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
-import { sanitizeAreaName } from "../../codebase-to-spec/fan-out.js";
 import { parseConversationalOutline, } from "../../codebase-to-spec/schemas.js";
 import { findProjectRoot } from "../../utils/project-settings.js";
 export async function dispatchSpecCommand() {

package/dist/commands/codebase-to-spec/index.js

@@ -5,30 +5,23 @@
  * be invoked granularly (e.g., `dotrequirements cts pack`) per CTS-CLI-2.
  */
 import { installCtsAbortHandlers } from "../../codebase-to-spec/progress.js";
-import { composeCommand } from "./compose.js";
 import { composeOrchestratorCommand } from "./compose-orchestrator.js";
 import { dispatchContextCommand } from "./dispatch-context.js";
 import { dispatchEditorCommand } from "./dispatch-editor.js";
 import { dispatchPlannerCommand } from "./dispatch-planner.js";
 import { dispatchSpecCommand } from "./dispatch-spec.js";
-import { editLoopCommand } from "./edit-loop.js";
-import { fanOutCommand } from "./fan-out.js";
 import { packCommand } from "./pack.js";
-import { planLoopCommand } from "./plan-loop.js";
-import { presentCommand } from "./present.js";
 import { presentOrchestratorCommand } from "./present-orchestrator.js";
-import { runCommand } from "./run.js";
 import { skillInstallCommand } from "./skill-install.js";
-import { specifyAreaCommand } from "./specify-area.js";
 import { styleCheckCommand } from "./style-check.js";
 import { validateCommand } from "./validate.js";
 /**
  * Marker used to hide a command from `--help` output without removing it.
- * Used for dark-ship: the conversational orchestrator's plumbing commands and
- * the skill-install entry point ship in the npm package but aren't surfaced
- * in help listings or documentation. They remain fully invocable (the
- * orchestrator skill calls them by name) — they just don't pollute the
- * user-facing CLI surface until we flip the default path in Phase 6.
+ * The conversational orchestrator's plumbing commands (the `dispatch-*` payload
+ * builders and the `-orchestrator` compose/present variants) and the
+ * skill-install entry point ship in the npm package but aren't surfaced in help
+ * listings — they're invoked by name by the orchestrator skill and workflow,
+ * not by users, so they stay out of the user-facing CLI surface.
  */
 const HIDDEN = { hidden: true };
 export function registerCodebaseToSpec(program) {
@@ -37,9 +30,8 @@ export function registerCodebaseToSpec(program) {
         .alias("cts")
         .description("Generate dotrequirements behavioral specifications from a codebase");
     // Install SIGTERM/SIGINT handlers for every cts subcommand so an interrupted
-    // pipeline emits a structured `pipeline/aborted` line before exiting
-    // (CTS-OBSERVE-1.5). preAction fires after argv parsing and before the
-    // subcommand action runs.
+    // stage emits a structured `pipeline/aborted` line before exiting. preAction
+    // fires after argv parsing and before the subcommand action runs.
     cts.hook("preAction", () => {
         installCtsAbortHandlers();
     });
@@ -52,31 +44,6 @@ export function registerCodebaseToSpec(program) {
         .option("--budget <tokens>", "Override the working-context budget (in tokens)", (v) => parseInt(v, 10))
         .option("--ignore-requirements", "Exclude `.requirements/**` from the pack (use when testing cts against a codebase whose existing requirements should not influence the output)")
         .action((opts) => packCommand({ ...opts, budgetTokens: opts.budget }));
-    cts
-        .command("plan-loop")
-        .description("Run the planner + outline review loop on the cached pack")
-        .option("--max-turns <n>", "Hard cap on review turns", (v) => parseInt(v, 10))
-        .option("--model <name>", "Override the model used by the planner and reviewer")
-        .action((opts) => planLoopCommand({
-        maxTurns: opts.maxTurns,
-        model: opts.model,
-    }));
-    cts
-        .command("specify-area <name>")
-        .description("Run the specifier for one named area from the cached outline")
-        .option("--model <name>", "Override the model used by the specifier")
-        .action((name, opts) => specifyAreaCommand(name, {
-        model: opts.model,
-    }));
-    cts
-        .command("fan-out")
-        .description("Run all specifiers in parallel for areas in the cached outline")
-        .option("-c, --concurrency <n>", "Max concurrent specifiers", (v) => parseInt(v, 10))
-        .option("--model <name>", "Override the model used by specifiers")
-        .action((opts) => fanOutCommand({
-        concurrency: opts.concurrency,
-        model: opts.model,
-    }));
     cts
         .command("validate <partial-path>")
         .description("Validate the schema/syntax of a partial-spec file (deterministic, offline)")
@@ -86,69 +53,6 @@ export function registerCodebaseToSpec(program) {
         .description("Run a local style-check on a partial-spec file (severity-categorized feedback)")
         .option("--model <name>", "Override the model used for the check")
         .action((partialPath, opts) => styleCheckCommand(partialPath, { model: opts.model }));
-    cts
-        .command("compose")
-        .description("Assemble per-area partials into a single composed spec")
-        .action(() => composeCommand());
-    cts
-        .command("edit-loop")
-        .description("Run the spec reviewer + editor loop on the composed spec")
-        .option("--max-turns <n>", "Hard cap on edit-loop turns", (v) => parseInt(v, 10))
-        .option("--model <name>", "Override the model used by the reviewer and editor")
-        .action((opts) => editLoopCommand({
-        maxTurns: opts.maxTurns,
-        model: opts.model,
-    }));
-    cts
-        .command("present")
-        .description("Write the final spec to .requirements/ and emit a pipeline summary")
-        .option("--interactive", "Force interactive mode (override TTY detection)")
-        .option("--non-interactive", "Force non-interactive mode (override TTY detection)")
-        .option("--overwrite", "Replace existing .requirements/ files without prompting")
-        .option("--skip-existing", "Leave existing .requirements/ files untouched")
-        .option("--ignore-requirements", "Write output to `.requirements/cts/` instead of `.requirements/` (use together with `cts pack --ignore-requirements` when isolating cts from an existing requirements directory)")
-        .action((opts) => {
-        const forceMode = opts.interactive
-            ? "interactive"
-            : opts.nonInteractive
-                ? "non-interactive"
-                : undefined;
-        return presentCommand({
-            forceMode,
-            overwrite: opts.overwrite,
-            skipExisting: opts.skipExisting,
-            ignoreRequirements: opts.ignoreRequirements,
-        });
-    });
-    cts
-        .command("run")
-        .description("Run the full pipeline (pack → plan → specify → compose → edit → present)")
-        .option("-s, --scope <path>", "Limit to files under this path (subdir of project root)")
-        .option("--fresh", "Clear the cache before running")
-        .option("--budget <tokens>", "Override the working-context budget (in tokens)", (v) => parseInt(v, 10))
-        .option("--max-turns <n>", "Hard cap on outline review turns", (v) => parseInt(v, 10))
-        .option("--model <name>", "Override the model used by agent calls")
-        .option("--interactive", "Force interactive mode for the present stage")
-        .option("--non-interactive", "Force non-interactive mode for the present stage")
-        .option("--overwrite", "Replace existing .requirements/ files without prompting")
-        .option("--skip-existing", "Leave existing .requirements/ files untouched")
-        .option("--ignore-requirements", "Exclude `.requirements/**` from the pack and write output to `.requirements/cts/` instead of `.requirements/` (use when testing cts against a codebase whose existing requirements should not influence the output)")
-        .action((opts) => {
-        const forceMode = opts.interactive
-            ? "interactive"
-            : opts.nonInteractive
-                ? "non-interactive"
-                : undefined;
-        return runCommand({
-            ...opts,
-            budgetTokens: opts.budget,
-            maxTurns: opts.maxTurns,
-            forceMode,
-            overwrite: opts.overwrite,
-            skipExisting: opts.skipExisting,
-            ignoreRequirements: opts.ignoreRequirements,
-        });
-    });
     cts
         .command("dispatch-context <dispatch-id>", HIDDEN)
         .description("Return the composed prompt for a worker dispatch as JSON on stdout (run by cts-worker subagents to fetch their dispatch prompt)")

package/dist/commands/codebase-to-spec/pack.js

@@ -12,7 +12,7 @@
  */
 import { resolve } from "node:path";
 import { checkBudget, countTokensInFileExact, DEFAULT_BUDGET_TOKENS, formatBudgetExceededMessage, } from "../../codebase-to-spec/budget.js";
-import { clearCache, ensureCacheDir } from "../../codebase-to-spec/cache.js";
+import { clearCache, ensureCacheDir, writeRunConfig, } from "../../codebase-to-spec/cache.js";
 import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
 import { runPack } from "../../codebase-to-spec/pack.js";
 import { StdoutProgress } from "../../codebase-to-spec/progress.js";
@@ -35,6 +35,13 @@ export async function packCommand(rawOptions = {}) {
         clearCache(projectRoot);
     }
     const paths = ensureCacheDir(projectRoot);
+    // Record the isolation decision once, here, so later stages (present) honor
+    // it without the caller — or the orchestrating agent — having to carry it
+    // across the run. Written on every pack so a re-pack without the flag clears
+    // a stale isolated marker. See CTS-PRESENT-5.2.
+    writeRunConfig(projectRoot, {
+        isolated: rawOptions.ignoreRequirements === true,
+    });
     const scope = rawOptions.scope
         ? resolve(projectRoot, rawOptions.scope)
         : undefined;

package/dist/commands/codebase-to-spec/present-orchestrator.d.ts

@@ -8,13 +8,15 @@
  * rather than specFinal.
  *
  * Requirements covered:
- * - CTS-PRESENT-1..4 (reuses the legacy present logic)
+ * - CTS-PRESENT-1..3 (shared present logic in present.ts)
  * - CTSO-INTEG-1: orchestrator uses existing deterministic stages unchanged
  */
 export interface PresentOrchestratorOptions {
     forceMode?: "interactive" | "non-interactive";
     overwrite?: boolean;
     skipExisting?: boolean;
+    /** Override the project root, mainly for tests. */
+    projectRoot?: string;
 }
 export declare function presentOrchestratorCommand(options?: PresentOrchestratorOptions): Promise<void>;
 //# sourceMappingURL=present-orchestrator.d.ts.map

package/dist/commands/codebase-to-spec/present-orchestrator.js

@@ -8,11 +8,11 @@
  * rather than specFinal.
  *
  * Requirements covered:
- * - CTS-PRESENT-1..4 (reuses the legacy present logic)
+ * - CTS-PRESENT-1..3 (shared present logic in present.ts)
  * - CTSO-INTEG-1: orchestrator uses existing deterministic stages unchanged
  */
 import { existsSync, readFileSync } from "node:fs";
-import { cachePaths } from "../../codebase-to-spec/cache.js";
+import { cachePaths, readRunConfig } from "../../codebase-to-spec/cache.js";
 import { ExitCode } from "../../codebase-to-spec/exit-codes.js";
 import { detectMode } from "../../codebase-to-spec/interactive.js";
 import { runPresent, } from "../../codebase-to-spec/present.js";
@@ -31,7 +31,7 @@ function resolvePolicy(isInteractive, options) {
     return "fail-fast";
 }
 export async function presentOrchestratorCommand(options = {}) {
-    const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+    const projectRoot = options.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
     const paths = cachePaths(projectRoot);
     if (!existsSync(paths.outline)) {
         process.stderr.write(`No outline.yaml found at ${paths.outline}. Run the orchestrator's planner first.\n`);
@@ -60,11 +60,17 @@ export async function presentOrchestratorCommand(options = {}) {
         return;
     }
     const legacyOutline = conversationalOutlineToLegacy(outline);
+    // Honor the isolation decision recorded at pack time (CTS-PRESENT-5.2). When
+    // the run is isolated, write under `.requirements/cts/` so the existing
+    // requirements directory is never overwritten — the choice rides the cache,
+    // not the agent's memory, so it holds even across a resumed or compacted run.
+    const { isolated } = readRunConfig(projectRoot);
     const result = await runPresent({
         outline: legacyOutline,
         finalSpecPath: paths.composedSpec,
         projectRoot,
         overwritePolicy: policy,
+        outputSubdir: isolated ? "cts" : undefined,
     });
     if (!result.allWritten) {
         if (result.conflictPath) {
@@ -76,6 +82,7 @@ export async function presentOrchestratorCommand(options = {}) {
     for (const action of result.actions) {
         process.stdout.write(`  ${action.action}: ${action.path}\n`);
     }
-    process.stdout.write(`Wrote ${result.actions.filter((a) => a.action === "created" || a.action === "overwrote").length} file(s) to .requirements/\n`);
+    const outputDirLabel = isolated ? ".requirements/cts/" : ".requirements/";
+    process.stdout.write(`Wrote ${result.actions.filter((a) => a.action === "created" || a.action === "overwrote").length} file(s) to ${outputDirLabel}\n`);
 }
 //# sourceMappingURL=present-orchestrator.js.map

package/dist/commands/get.js

@@ -1,10 +1,14 @@
 import { glob } from "glob";
-import { formatRequirementTree, getRequirementTree, loadAllRequirements, } from "../requirements/index.js";
+import { formatRequirementTree, loadAllRequirements, } from "../requirements/index.js";
 import { findFilesWithRequirement, findTestCodeForRequirement, } from "../requirements/testCodeExtractor.js";
 export async function getCommand(id) {
     const workspaceRoot = process.cwd();
     const { flattened } = await loadAllRequirements(workspaceRoot);
-    const tree = getRequirementTree(flattened, id);
+    // Match the node itself plus all of its descendants by id prefix (mirrors
+    // the #46 MCP get fix). The shared getRequirementTree only matches on
+    // rootId/id equality, which drops grandchildren (e.g. REQ-123.0.0) when a
+    // child id (REQ-123.0) is requested.
+    const tree = flattened.filter((r) => r.id === id || r.id.startsWith(`${id}.`));
     // CLI-FIND-GET-1.2: missing ID → error + non-zero exit
     if (tree.length === 0) {
         throw new Error(`Requirement "${id}" not found`);

package/dist/commands/init.js

@@ -147,11 +147,10 @@ async function authenticatedFlow(cwd, options) {
     }
     if (projectChoice === "create") {
         await createNewProjectFlow(cwd, client, selectedTeam, options);
+        return true;
     }
-    else {
-        await connectExistingProjectFlow(cwd, client, selectedTeam);
-    }
-    return true;
+    // INIT-12: a cancelled project selection means init did not complete
+    return await connectExistingProjectFlow(cwd, client, selectedTeam);
 }
 /**
  * INIT-18: Prompt user to select a team after OAuth
@@ -268,13 +267,15 @@ async function createNewProjectFlow(cwd, client, team, options) {
 }
 /**
  * INIT-6, INIT-16: Connect to an existing project
+ * Returns true if connected successfully, false if the user cancelled
+ * (INIT-12: cancellation must not read as a successful init)
  */
 async function connectExistingProjectFlow(cwd, client, team) {
     // INIT-6.0, INIT-16.0: Select project from team
     const selectedProject = await selectProject(client, team.teamId);
     if (!selectedProject) {
         console.log("Initialization cancelled.");
-        return;
+        return false;
     }
     // AUTHZ-3: Prompt for secret expiry (paid tier only, if creating new secret)
     const expiryDays = await promptExpiryDays(team.tier);
@@ -306,6 +307,7 @@ async function connectExistingProjectFlow(cwd, client, team) {
     console.log("\nNext steps:");
     console.log("  1. Review the requirements in .requirements/");
     console.log("  2. Add the test harness to your test setup (see README)");
+    return true;
 }
 /**
  * MEMBERSHIP-18: Invite flow - join a team using an invite token

package/dist/commands/link-resolution.d.ts

@@ -29,7 +29,9 @@ export interface LinkFlags {
     json?: boolean;
 }
 /**
- * LINK-12.3: any deviation flag implies non-interactive mode.
+ * LINK-12.3: any deviation flag implies non-interactive mode. The JSON
+ * output flag does too — machine-readable output only exists on the
+ * non-interactive path, so `link --json` alone must not run interactively.
  */
 export declare function isNonInteractive(flags: LinkFlags): boolean;
 export declare function hasCapacity(team: TeamOption): boolean;

package/dist/commands/link-resolution.js

@@ -6,10 +6,12 @@
  * assistant needs to ask the user and retry with a deviation flag.
  */
 /**
- * LINK-12.3: any deviation flag implies non-interactive mode.
+ * LINK-12.3: any deviation flag implies non-interactive mode. The JSON
+ * output flag does too — machine-readable output only exists on the
+ * non-interactive path, so `link --json` alone must not run interactively.
  */
 export function isNonInteractive(flags) {
-    return Boolean(flags.yes || flags.team || flags.connect || flags.create);
+    return Boolean(flags.yes || flags.team || flags.connect || flags.create || flags.json);
 }
 export function hasCapacity(team) {
     return team.projectLimit === -1 || team.projectCount < team.projectLimit;