@popoverai/dotrequirements 0.25.0 → 0.26.1

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.d.ts

@@ -7,8 +7,10 @@
  * - CTS-CLI-3: Pipeline refuses to spec a codebase that exceeds the working context budget
  * - CTS-PACK-1: Pack stage produces compressed and uncompressed views of the codebase
  * - CTS-PACK-2: Engineer can extend the ignore list per project
+ * - CTS-PACK-4: Pack surfaces when a newer CLI version is available
  * - CTS-OBSERVE-1: CLI emits structured progress as the pipeline runs
  */
+import { checkForNewerVersion } from "../../codebase-to-spec/version-check.js";
 export interface PackOptions {
     scope?: string;
     /**
@@ -28,6 +30,8 @@ export interface PackOptions {
     progress?: import("../../codebase-to-spec/progress.js").ProgressEmitter;
     /** Override the project root, mainly for tests. */
     projectRoot?: string;
+    /** Override the registry version check, mainly for tests. */
+    checkVersion?: typeof checkForNewerVersion;
 }
 export declare function packCommand(rawOptions?: PackOptions): Promise<void>;
 //# sourceMappingURL=pack.d.ts.map

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

@@ -7,19 +7,25 @@
  * - CTS-CLI-3: Pipeline refuses to spec a codebase that exceeds the working context budget
  * - CTS-PACK-1: Pack stage produces compressed and uncompressed views of the codebase
  * - CTS-PACK-2: Engineer can extend the ignore list per project
+ * - CTS-PACK-4: Pack surfaces when a newer CLI version is available
  * - CTS-OBSERVE-1: CLI emits structured progress as the pipeline runs
  */
 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";
+import { checkForNewerVersion } from "../../codebase-to-spec/version-check.js";
 import { findProjectRoot } from "../../utils/project-settings.js";
 export async function packCommand(rawOptions = {}) {
     const progress = rawOptions.progress ?? new StdoutProgress();
     const projectRoot = rawOptions.projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
     const budgetTokens = rawOptions.budgetTokens ?? DEFAULT_BUDGET_TOKENS;
+    // Fail-soft staleness check (CTS-PACK-4), started now so the registry
+    // round-trip overlaps the pack work and adds no wall-clock on the happy
+    // path. Resolves to undefined on any failure or timeout.
+    const versionCheck = (rawOptions.checkVersion ?? checkForNewerVersion)();
     if (rawOptions.fresh) {
         progress.emit({
             stage: "pack",
@@ -29,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;
@@ -54,6 +67,17 @@ export async function packCommand(rawOptions = {}) {
         message: `Packed ${packResult.fileCount} files → ${paths.overview} (compressed), ${paths.source} (uncompressed)`,
         data: { fileCount: packResult.fileCount },
     });
+    // Surface a stale install (CTS-PACK-4). Informational only: outputs and
+    // exit code are unaffected, and a failed check emits nothing.
+    const versionInfo = await versionCheck.catch(() => undefined);
+    if (versionInfo?.stale) {
+        progress.emit({
+            stage: "pack",
+            step: "stale-version",
+            message: `A newer dotrequirements CLI is available: ${versionInfo.latest} (running ${versionInfo.current}). Re-run skill-install to refresh.`,
+            data: { current: versionInfo.current, latest: versionInfo.latest },
+        });
+    }
     // Budget check (CTS-CLI-3)
     const measured = countTokensInFileExact(paths.overview);
     const budget = checkBudget(measured, budgetTokens);

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/init.js

@@ -353,8 +353,13 @@ async function inviteFlow(cwd, token) {
         console.log(`✓ Joined team "${inviteInfo.teamName}"`);
     }
     catch (err) {
+        // Production redacts ConvexError messages to "Server Error" but keeps
+        // error.data — check both, or this graceful path only works in dev
+        const data = err.data;
+        const dataMessage = typeof data?.message === "string" ? data.message : "";
         const errorMessage = err instanceof Error ? err.message : String(err);
-        if (errorMessage.includes("already a member")) {
+        if (dataMessage.includes("already a member") ||
+            errorMessage.includes("already a member")) {
             console.log(`Already a member of "${inviteInfo.teamName}"`);
         }
         else {

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

@@ -0,0 +1,79 @@
+/**
+ * Pure decision logic for `dotrequirements link`'s non-interactive mode
+ * (LINK-10/11/12). No I/O: the link command gathers state (teams, projects)
+ * and these functions decide what to do — use a project, create one, rename,
+ * or stop with a decision-needed result that carries everything an AI
+ * assistant needs to ask the user and retry with a deviation flag.
+ */
+export interface TeamOption {
+    teamId: string;
+    name: string;
+    tier: string;
+    tierName: string;
+    projectCount: number;
+    projectLimit: number;
+}
+export interface ProjectOption {
+    projectId: string;
+    projectName: string;
+    projectSlug: string | null;
+    isDefault: boolean;
+    hasUserContent: boolean;
+}
+export interface LinkFlags {
+    yes?: boolean;
+    team?: string;
+    connect?: string;
+    create?: boolean;
+    name?: string;
+    json?: boolean;
+}
+/**
+ * LINK-12.3: any deviation flag implies non-interactive mode.
+ */
+export declare function isNonInteractive(flags: LinkFlags): boolean;
+export declare function hasCapacity(team: TeamOption): boolean;
+/** A choice the user must make, with everything needed to ask and retry. */
+export interface DecisionNeeded {
+    kind: "decision";
+    decision: "team" | "project" | "capacity";
+    message: string;
+    options: Array<{
+        label: string;
+        /** Exact flag to pass on retry (LINK-11.4), when retryable via link */
+        retryFlag?: string;
+    }>;
+}
+export interface NoMatch {
+    kind: "no-match";
+    flag: "team" | "connect";
+    provided: string;
+    alternatives: string[];
+}
+export type TeamResolution = {
+    kind: "use";
+    team: TeamOption;
+} | DecisionNeeded | NoMatch;
+/**
+ * LINK-10.1, LINK-11.0, LINK-12.0, LINK-12.4
+ */
+export declare function resolveTeam(teams: TeamOption[], flags: LinkFlags): TeamResolution;
+export type ProjectResolution = {
+    kind: "connect";
+    project: ProjectOption;
+    rename: boolean;
+} | {
+    kind: "create";
+} | DecisionNeeded | NoMatch;
+/**
+ * LINK-10.2/10.3 (default-project rule), LINK-11.1/11.2 (decision menus),
+ * LINK-12.1/12.2/12.4 (deviation flags).
+ */
+export declare function resolveProject(projects: ProjectOption[], team: TeamOption, flags: LinkFlags): ProjectResolution;
+/**
+ * Prompt-free project naming for non-interactive mode (LINK-9.0): explicit
+ * flag, then package metadata, then directory name, then a fixed fallback —
+ * never a prompt.
+ */
+export declare function resolveProjectName(flags: LinkFlags, packageName: string | undefined, directoryName: string | undefined): string;
+//# sourceMappingURL=link-resolution.d.ts.map

package/dist/commands/link-resolution.js

@@ -0,0 +1,141 @@
+/**
+ * Pure decision logic for `dotrequirements link`'s non-interactive mode
+ * (LINK-10/11/12). No I/O: the link command gathers state (teams, projects)
+ * and these functions decide what to do — use a project, create one, rename,
+ * or stop with a decision-needed result that carries everything an AI
+ * assistant needs to ask the user and retry with a deviation flag.
+ */
+/**
+ * LINK-12.3: any deviation flag implies non-interactive mode.
+ */
+export function isNonInteractive(flags) {
+    return Boolean(flags.yes || flags.team || flags.connect || flags.create);
+}
+export function hasCapacity(team) {
+    return team.projectLimit === -1 || team.projectCount < team.projectLimit;
+}
+/**
+ * LINK-10.1, LINK-11.0, LINK-12.0, LINK-12.4
+ */
+export function resolveTeam(teams, flags) {
+    if (flags.team) {
+        const wanted = flags.team.toLowerCase();
+        const match = teams.find((t) => t.teamId === flags.team || t.name.toLowerCase() === wanted);
+        if (match)
+            return { kind: "use", team: match };
+        return {
+            kind: "no-match",
+            flag: "team",
+            provided: flags.team,
+            alternatives: teams.map((t) => `${t.name} (${t.teamId})`),
+        };
+    }
+    if (teams.length === 1) {
+        return { kind: "use", team: teams[0] };
+    }
+    return {
+        kind: "decision",
+        decision: "team",
+        message: "You belong to multiple teams — which should this project join?",
+        options: teams.map((t) => ({
+            label: `${t.name} (${t.tierName}, ${formatCapacity(t)})`,
+            retryFlag: `--team ${t.teamId}`,
+        })),
+    };
+}
+/**
+ * LINK-10.2/10.3 (default-project rule), LINK-11.1/11.2 (decision menus),
+ * LINK-12.1/12.2/12.4 (deviation flags).
+ */
+export function resolveProject(projects, team, flags) {
+    if (flags.connect) {
+        const match = projects.find((p) => p.projectSlug === flags.connect);
+        if (match)
+            return { kind: "connect", project: match, rename: false };
+        return {
+            kind: "no-match",
+            flag: "connect",
+            provided: flags.connect,
+            alternatives: projects
+                .filter((p) => p.projectSlug)
+                .map((p) => `${p.projectName} (${p.projectSlug})`),
+        };
+    }
+    if (flags.create) {
+        if (hasCapacity(team))
+            return { kind: "create" };
+        return atCapacityDecision(projects, team);
+    }
+    if (projects.length === 0) {
+        // A decision with a single possible answer is not a decision: create.
+        if (hasCapacity(team))
+            return { kind: "create" };
+        return atCapacityDecision(projects, team);
+    }
+    if (projects.length === 1 && projects[0].isDefault) {
+        // LINK-10.2: rename the untouched default project to match this repo;
+        // LINK-10.3: if the user has put content in it, connect without renaming
+        return {
+            kind: "connect",
+            project: projects[0],
+            rename: !projects[0].hasUserContent,
+        };
+    }
+    // LINK-11.1: existing projects the user chose to create — their call
+    return {
+        kind: "decision",
+        decision: "project",
+        message: "This team already has projects — connect to one, or create a new one?",
+        options: [
+            ...projects.map((p) => ({
+                label: `${p.projectName}${p.hasUserContent ? "" : " (empty)"}`,
+                retryFlag: p.projectSlug ? `--connect ${p.projectSlug}` : undefined,
+            })),
+            ...(hasCapacity(team)
+                ? [{ label: "Create a new project", retryFlag: "--create" }]
+                : []),
+        ],
+    };
+}
+/**
+ * LINK-11.2: creating is required (or requested) but the team is at its
+ * project limit. None of the remedies is a plain link retry flag.
+ */
+function atCapacityDecision(projects, team) {
+    return {
+        kind: "decision",
+        decision: "capacity",
+        message: `Team "${team.name}" is at its ${team.tierName} project limit (${formatCapacity(team)}).`,
+        options: [
+            ...projects
+                .filter((p) => p.projectSlug)
+                .map((p) => ({
+                label: `Connect to existing project ${p.projectName}`,
+                retryFlag: `--connect ${p.projectSlug}`,
+            })),
+            { label: "Delete a project you no longer need (in the web app)" },
+            { label: "Upgrade the team for more projects" },
+        ],
+    };
+}
+function formatCapacity(team) {
+    return team.projectLimit === -1
+        ? `${team.projectCount}/unlimited projects`
+        : `${team.projectCount}/${team.projectLimit} projects`;
+}
+/**
+ * Prompt-free project naming for non-interactive mode (LINK-9.0): explicit
+ * flag, then package metadata, then directory name, then a fixed fallback —
+ * never a prompt.
+ */
+export function resolveProjectName(flags, packageName, directoryName) {
+    if (flags.name)
+        return flags.name;
+    if (packageName)
+        return packageName;
+    if (directoryName && directoryName !== "/" && directoryName !== ".") {
+        return directoryName;
+    }
+    return "my-project";
+}
+//# sourceMappingURL=link-resolution.js.map

package/dist/commands/link.d.ts

@@ -1,14 +1,24 @@
+import { type LinkFlags } from "./link-resolution.js";
+export interface LinkCommandOptions extends LinkFlags {
+}
 /**
- * Link command - connect or reconnect local project to cloud.
+ * Link command - connect or reconnect local project to cloud, creating the
+ * cloud project when needed. Link owns the "upgrade local to cloud"
+ * transition.
  *
  * Requirements:
  * - LINK-1: Requires existing .requirements/ folder
  * - LINK-2: Offers refresh when credentials exist
  * - LINK-3: Uses inline OAuth (no persistent tokens)
- * - LINK-4, LINK-5: Team and project selection
+ * - LINK-4, LINK-5: Team and project selection (including the create option)
  * - LINK-6: Saves credentials to project-settings.json
- * - LINK-7: Optionally pulls requirements
+ * - LINK-7: Optionally pulls requirements (interactive only)
  * - LINK-8: Handles network errors gracefully
+ * - LINK-9: Creates the cloud project when chosen
+ * - LINK-10/11/12: Non-interactive mode for AI-driven setup
+ * - LINK-13: Non-interactive success includes share artifacts (team-invite
+ *   URL + read-only pull command) so one "yes" puts the spec in front of
+ *   the team
  */
-export declare function linkCommand(): Promise<void>;
+export declare function linkCommand(options?: LinkCommandOptions): Promise<void>;
 //# sourceMappingURL=link.d.ts.map