@yagni-app/code 0.1.0

package/LICENSE.md

@@ -0,0 +1,55 @@
+# YAGNI Code License
+
+Copyright (c) 2026 YAGNI, Inc. (https://yagni.app). All rights reserved.
+
+This software is a proprietary client for the YAGNI service. It is licensed to
+you, not sold. Installing it from a public package registry does not make it
+open source and grants no rights beyond this license.
+
+## License grant
+
+Subject to this license and the YAGNI Terms of Service, YAGNI, Inc. ("YAGNI")
+grants you a limited, revocable, non-exclusive, non-transferable license to
+install and run this software, in unmodified form, solely to access and use
+the YAGNI service under an active YAGNI account or workspace.
+
+## Restrictions
+
+You may not:
+
+- copy, modify, adapt, or create derivative works of the software;
+- distribute, sublicense, rent, lease, sell, or otherwise transfer the
+  software or access to it;
+- reverse engineer, decompile, or disassemble the software, except to the
+  extent applicable law does not allow that restriction;
+- remove or alter any copyright, trademark, or other proprietary notices; or
+- use the software to build a product or service that competes with the YAGNI
+  service.
+
+## Ownership
+
+The software and all intellectual property rights in it remain the exclusive
+property of YAGNI and its licensors. Third-party packages installed alongside
+this one are licensed under their own terms.
+
+## Termination
+
+This license ends automatically if you breach it or when your access to the
+YAGNI service ends. When it ends, you must stop using the software and
+uninstall it.
+
+## Disclaimer of warranty
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT.
+
+## Limitation of liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, YAGNI WILL NOT BE LIABLE FOR ANY
+INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR EXEMPLARY DAMAGES ARISING
+FROM OR RELATED TO THE SOFTWARE, AND YAGNI'S TOTAL LIABILITY WILL NOT EXCEED
+THE AMOUNTS YOU PAID FOR THE YAGNI SERVICE IN THE TWELVE MONTHS BEFORE THE
+CLAIM AROSE.
+
+Questions about this license: jack@yagni.app.

package/README.md

@@ -0,0 +1,161 @@
+# YAGNI Code
+
+A terminal coding agent that already knows your company.
+
+YAGNI Code is a coding agent for your terminal, like Claude Code or Codex — but
+it is wired into the YAGNI app, your team's shared source of truth for how your
+company and codebase actually work. One YAGNI login routes everything:
+
+- the **model** runs on YAGNI-routed open-weight inference (you bring no API
+  keys), and
+- the agent **boots already grounded** in your company — conventions,
+  decisions, ownership, priorities, the "why" — and can consult it mid-task with
+  a built-in `ask_yagni` tool.
+
+**The bet:** a cheaper open-weight model that is *grounded in your context*
+beats a stronger model that is *guessing* on your own codebase. Because YAGNI
+Code and the YAGNI app are connected, you intervene less and the agent does more
+correct, autonomous work than a coding agent that starts blank.
+
+## Install
+
+```bash
+npm install -g @yagni-app/code
+```
+
+The command it installs is `yagni`:
+
+```bash
+yagni login     # device-code auth against your YAGNI workspace
+yagni doctor    # green/red readiness checklist
+yagni           # launch the agent in the current repo
+```
+
+Your workspace must have YAGNI Code enabled (the `yagni_code.enabled` feature
+flag) — ask your workspace admin. Maintainers: the alpha checklist is
+`docs/yagni-code-alpha.md`; publish-day steps live in
+`docs/yagni-code-publishing.md`.
+
+## Develop
+
+Working in this monorepo, install from the repo instead of the registry. Build
+the extension first — the CLI loads `pi-extension-yagni` at runtime, so an
+unbuilt extension fails on launch — then build and link the CLI:
+
+```bash
+pnpm --filter pi-extension-yagni build
+pnpm --filter @yagni-app/code build
+npm i -g ./packages/yagni-code-cli      # or `pnpm --filter @yagni-app/code link --global`
+```
+
+Both packages are plain `tsc` builds that emit to `dist/`. The global
+`yagni` command is a symlink into this repo's `dist/`, so after the initial
+`npm i -g` you **never reinstall** — a rebuild is enough, and the next launch
+picks it up.
+
+Iterate with watch mode (one terminal each — run the commands bare, an inline
+`#` comment is passed through as a filename by zsh and breaks `tsc`):
+
+```bash
+pnpm --filter pi-extension-yagni dev
+pnpm --filter @yagni-app/code dev
+```
+
+Notes:
+
+- **Order matters when changing both.** The CLI bundles the extension, so build
+  (or have a watcher running) `pi-extension-yagni` before `@yagni-app/code`.
+- **`yagni` is long-lived.** A rebuild only takes effect the next time you
+  launch it — restart the CLI to pick up new code.
+- **Frontend/backend changes** (e.g. the `/v1` dev proxy) are served by
+  `pnpm dev` — Vite restarts on `vite.config.ts` changes and the backend runs
+  under `tsx` watch, so no manual rebuild there.
+- **Tests:** `pnpm --filter @yagni-app/code test` (`node:test` via `tsx`).
+
+## Use
+
+```bash
+yagni login          # device-code flow: open the URL, enter the code, approve
+yagni doctor         # green/red readiness checklist (engine, token, backend, perms)
+cd ~/code/my-repo
+yagni                # launch the agent in this repo (interactive)
+yagni -p "explain the deploy pipeline; ask_yagni if unsure"   # one-shot / print mode
+yagni logout         # revoke the token and clear it locally
+```
+
+The agent runs on three opaque model tiers routed by YAGNI: `advanced` (the strongest,
+for judgment), `standard` (for execution) and `efficient` (cheapest).
+Interactive sessions default to `advanced`; pass `--model standard` or `--model
+efficient` to switch a run. The `/go` pipeline routes its own steps automatically —
+judgment steps (plan, review) on `advanced`, execution steps (map, implement, fix) on
+`standard`.
+
+`login` opens a device-code flow: it prints a short code and a URL. Open the URL
+in a browser where you are signed in to YAGNI, enter the code, and approve. The
+token is stored in the active environment's profile (`~/.yagni-code/profiles/<name>.json`,
+mode `0600`). Re-run `login` any time to refresh it. See **Environments** below to
+point the CLI at a non-prod backend.
+
+Any arguments after `yagni` are passed straight through to the agent, so
+flags like `--model` and `--print/-p` work.
+
+### What "knows your company" means in practice
+
+- On startup, YAGNI Code loads a brief of your workspace (vision, goals,
+  conventions) and works from it immediately — no prompting required.
+- When a choice depends on something organization- or codebase-specific, the
+  agent calls **`ask_yagni`** and gets a cited answer from the YAGNI app instead
+  of guessing.
+
+## Environments (profiles)
+
+YAGNI Code keeps a **sticky active environment**. Each environment ("profile") binds a
+base URL to its own stored token, so you can point the CLI at prod, a local backend, or
+a staging host and switch between them without re-authenticating each time.
+
+```bash
+yagni use local                          # switch to the local dev backend (preset)
+yagni login                              # authorize the active environment
+yagni                                    # runs against `local` from now on (sticky)
+
+yagni use staging --base-url https://staging.example.com   # define a custom env
+yagni login
+yagni profiles                           # list environments; the active one is *-marked
+yagni use prod                           # switch back (sticky); prod is the default
+```
+
+- `prod` (→ `https://yagni.app`) is the default environment and a built-in preset.
+- `local` (→ `http://localhost:3456`, the `pnpm dev` backend) is the other preset.
+- Any other name needs `--base-url <url>` the first time you `use` it.
+- Each environment gets its own isolated pi state under `~/.yagni-code/agent/<name>`,
+  so prod sessions never bleed into staging.
+- `login` / `logout` always act on the **active** environment. `logout` clears its token
+  but keeps the binding, so a later `login` re-authorizes the same environment.
+
+## Configuration
+
+| Variable         | Default                  | Purpose                                            |
+| ---------------- | ------------------------ | -------------------------------------------------- |
+| `YAGNI_BASE_URL` | active environment's URL | Override the base URL for a **single run** (escape hatch). Prefer `yagni use` for anything sticky. |
+
+Credentials live in `~/.yagni-code/profiles/<name>.json` (mode `0600`); the active
+environment is recorded in `~/.yagni-code/config.json`. A pre-profiles
+`~/.yagni-code/credentials.json` is migrated automatically on first run.
+
+## Troubleshooting
+
+- **`Not logged in to environment "<name>" … Run \`yagni login\` first.`** — no
+  valid token for the active environment; run `yagni login` (or `yagni use`
+  a different one). Run `yagni doctor` for a full green/red readiness check.
+- **`Could not start login … Is YAGNI Code enabled for your workspace?`** —
+  YAGNI Code is not enabled for your workspace. Ask an admin to enable it.
+- **The login code expired** — approval wasn't completed in time; run
+  `yagni login` again.
+- **Talking to staging** — `yagni use staging --base-url https://<staging-host>`,
+  then `yagni login`.
+
+---
+
+Maintainers: YAGNI Code is built on the open-source `pi` coding agent, configured
+entirely through a first-party extension (no fork). The engineering details live
+in [`ARCHITECTURE.md`](./ARCHITECTURE.md).

package/dist/branding.d.ts

@@ -0,0 +1,25 @@
+/**
+ * YAGNI Code launcher branding.
+ *
+ * pi derives its entire app identity — terminal title, `process.title`, and the
+ * name of the env var it reads for its config dir — from `piConfig.name` in the
+ * package.json it loads from `PI_PACKAGE_DIR` (pi config.ts: `APP_NAME`,
+ * `APP_TITLE`, `ENV_AGENT_DIR`). We rebrand "pi"/"π" out of the chrome by
+ * pointing pi at a shadow package whose `piConfig.name` is set to this value.
+ *
+ * Because the SAME name drives `ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}` +
+ * "_CODING_AGENT_DIR"`, this module is the single source of truth: the shadow
+ * package.json and the launcher's hermetic-dir env wiring must agree on the
+ * name, or pi reads a different env var than the launcher sets and silently
+ * falls back to `~/.pi/agent` — breaking the hermetic boundary that keeps the
+ * user's local provider keys from bypassing the YAGNI proxy.
+ */
+/** The app name pi will compute as `APP_NAME` (shown in the terminal title/tab). */
+export declare const PI_CONFIG_NAME = "YAGNI";
+/**
+ * The env var name pi reads for its config dir, derived exactly as pi does
+ * (`${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`). For the default name this is
+ * `"YAGNI_CODING_AGENT_DIR"`.
+ */
+export declare function agentDirEnvVar(name?: string): string;
+//# sourceMappingURL=branding.d.ts.map

package/dist/branding.js

@@ -0,0 +1,27 @@
+/**
+ * YAGNI Code launcher branding.
+ *
+ * pi derives its entire app identity — terminal title, `process.title`, and the
+ * name of the env var it reads for its config dir — from `piConfig.name` in the
+ * package.json it loads from `PI_PACKAGE_DIR` (pi config.ts: `APP_NAME`,
+ * `APP_TITLE`, `ENV_AGENT_DIR`). We rebrand "pi"/"π" out of the chrome by
+ * pointing pi at a shadow package whose `piConfig.name` is set to this value.
+ *
+ * Because the SAME name drives `ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}` +
+ * "_CODING_AGENT_DIR"`, this module is the single source of truth: the shadow
+ * package.json and the launcher's hermetic-dir env wiring must agree on the
+ * name, or pi reads a different env var than the launcher sets and silently
+ * falls back to `~/.pi/agent` — breaking the hermetic boundary that keeps the
+ * user's local provider keys from bypassing the YAGNI proxy.
+ */
+/** The app name pi will compute as `APP_NAME` (shown in the terminal title/tab). */
+export const PI_CONFIG_NAME = "YAGNI";
+/**
+ * The env var name pi reads for its config dir, derived exactly as pi does
+ * (`${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`). For the default name this is
+ * `"YAGNI_CODING_AGENT_DIR"`.
+ */
+export function agentDirEnvVar(name = PI_CONFIG_NAME) {
+    return `${name.toUpperCase()}_CODING_AGENT_DIR`;
+}
+//# sourceMappingURL=branding.js.map

package/dist/cli.d.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+/**
+ * yagni — the thin launcher (package `yagni-code`, command `yagni`).
+ *
+ *   yagni login        device-code auth, stores a scoped token
+ *   yagni logout       revoke + delete the local token
+ *   yagni doctor       green/red readiness checklist
+ *   yagni [pi args…]   launch pi configured with the yagni provider +
+ *                      the ask_yagni tool (default command)
+ *
+ * The launcher holds NO model or business logic — it is credential plumbing
+ * plus a configured pi spawn. Everything that makes this "YAGNI Code" lives in
+ * pi-extension-yagni and the YAGNI backend.
+ */
+export declare const HELP_TEXT: string;
+/** Parse `use <name> [--base-url <url>]` argv into its parts. */
+export declare function parseUseArgs(args: string[]): {
+    name?: string;
+    baseUrl?: string;
+};
+/** `yagni use <name> [--base-url <url>]` — switch the sticky environment. */
+export declare function useCommand(args: string[]): Promise<number>;
+/** `yagni profiles` — list saved environments, marking the active one. */
+export declare function profilesCommand(): Promise<number>;
+/**
+ * Whether to show YAGNI Code's own help instead of launching the agent.
+ *
+ * `--help`/`-h` are intercepted ANYWHERE in argv (not just position 0) so the
+ * underlying agent's branded help never leaks (e.g. `yagni <flag> --help`).
+ */
+export declare function wantsHelp(argv: string[]): boolean;
+/**
+ * Whether to print YAGNI Code's own version instead of launching the agent.
+ *
+ * `--version` AND `-v` are intercepted ANYWHERE in argv for the same reason as
+ * `--help`: pi parses both as its version flag, so letting either through
+ * leaks the agent's branded version line (or a login error before it).
+ */
+export declare function wantsVersion(argv: string[]): boolean;
+/**
+ * The CLI's own version, read from this package's package.json. Resolved
+ * relative to the module (src/ and dist/ both sit one level below the package
+ * root), so it is correct under tsx in tests and in the published tarball.
+ */
+export declare function cliVersion(): string;
+export declare function main(argv: string[]): Promise<number>;
+/**
+ * Whether this module is the process entrypoint (vs. imported by a test).
+ *
+ * Symlink-safe: when `yagni-code` is installed globally, the shell runs it
+ * through a symlink in the bin dir, so `process.argv[1]` is that symlink path.
+ * Node resolves symlinks for `import.meta.url`, so a raw `argv[1] === metaPath`
+ * compare is ALWAYS false for a symlinked install and `main()` never runs (the
+ * "nothing happens" bug). We realpath both sides so the symlinked bin and a
+ * direct `node dist/cli.js` invocation both count as the entrypoint, while a
+ * test import (argv[1] points at the test runner) does not.
+ */
+export declare function isEntrypoint(argv1: string | undefined, moduleUrl: string): boolean;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+/**
+ * yagni — the thin launcher (package `yagni-code`, command `yagni`).
+ *
+ *   yagni login        device-code auth, stores a scoped token
+ *   yagni logout       revoke + delete the local token
+ *   yagni doctor       green/red readiness checklist
+ *   yagni [pi args…]   launch pi configured with the yagni provider +
+ *                      the ask_yagni tool (default command)
+ *
+ * The launcher holds NO model or business logic — it is credential plumbing
+ * plus a configured pi spawn. Everything that makes this "YAGNI Code" lives in
+ * pi-extension-yagni and the YAGNI backend.
+ */
+import { spawn } from "node:child_process";
+import { mkdirSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PI_CONFIG_NAME } from "./branding.js";
+import { agentDir, piPackageDir } from "./credentials.js";
+import { login } from "./login.js";
+import { logout } from "./logout.js";
+import { buildLaunch } from "./launch.js";
+import { runDoctor } from "./doctor.js";
+import { maybeRefreshAtLaunch } from "./refresh.js";
+import { ensureShadowPiPackage } from "./piPackage.js";
+import { resolveExtensionPath, resolvePiCliPath, resolvePiPackageDir } from "./paths.js";
+import { credentialsFromProfile, getActiveProfileName, listProfiles, migrateLegacyCredentials, persistProfileTokenRotation, profilePath, readActiveProfile, useProfile, } from "./profiles.js";
+// Present as "yagni" in process listings, not "node".
+process.title = "yagni";
+async function runDefault(passthroughArgs) {
+    // Load the active environment's credentials (base URL respects a per-run
+    // YAGNI_BASE_URL override). The token must belong to this environment.
+    const profile = await readActiveProfile();
+    let creds = credentialsFromProfile(profile);
+    if (!creds?.token) {
+        process.stderr.write(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`yagni login\` first.\n`);
+        return 1;
+    }
+    // Refresh-at-launch: if the token is inside the 7-day refresh window (and not
+    // yet expired), rotate it before spawning so a long session doesn't 401
+    // mid-flight. Fail-soft: a refresh failure keeps the current token and warns.
+    // Persist ONLY the token rotation — never the (possibly YAGNI_BASE_URL-
+    // overridden) base URL, so a single-run override can't become sticky.
+    const refresh = await maybeRefreshAtLaunch(creds, {
+        persist: (c) => persistProfileTokenRotation(profile.name, c),
+    });
+    for (const warning of refresh.warnings) {
+        process.stderr.write(`${warning}\n`);
+    }
+    creds = refresh.creds;
+    // Hermetic config dir, scoped per environment — created up front (0700) so pi
+    // reads/writes its settings, auth, model scope, and theme here (per profile)
+    // instead of ~/.pi/agent, and prod state never bleeds into staging.
+    const piAgentDir = agentDir(profile.name);
+    mkdirSync(piAgentDir, { recursive: true, mode: 0o700 });
+    // Generate the shadow pi package so the terminal title/process name read
+    // "YAGNI Code" instead of "pi"/"π". Best-effort: if it can't be built we
+    // still launch (un-rebranded but hermetic), never blocking the agent.
+    let shadowPiDir;
+    try {
+        shadowPiDir = ensureShadowPiPackage({
+            realPiDir: resolvePiPackageDir(),
+            shadowDir: piPackageDir(),
+            name: PI_CONFIG_NAME,
+        });
+    }
+    catch {
+        shadowPiDir = undefined;
+    }
+    // buildLaunch runs the token-expiry preflight: it throws (with an actionable
+    // login prompt) on an already-expired token so we never spawn a session that
+    // immediately 401s, and returns non-fatal warnings (e.g. expiry approaching).
+    // `creds` was read fresh from the profile file above, so an out-of-band
+    // re-login in another terminal is picked up here with no stale cached token.
+    let plan;
+    try {
+        plan = buildLaunch(creds, passthroughArgs, {
+            extensionPath: resolveExtensionPath(),
+            agentDir: piAgentDir,
+            piPackageDir: shadowPiDir,
+            // Forward the active profile's file path so the extension can persist a
+            // mid-session token rotation back to the same profile the launcher read.
+            profilePath: profilePath(profile.name),
+            baseEnv: process.env,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    for (const warning of plan.warnings) {
+        process.stderr.write(`${warning}\n`);
+    }
+    const { env, argv } = plan;
+    const piCli = resolvePiCliPath();
+    return await new Promise((resolve) => {
+        const child = spawn(process.execPath, [piCli, ...argv], {
+            stdio: "inherit",
+            env,
+        });
+        child.on("exit", (code) => resolve(code ?? 0));
+        child.on("error", (err) => {
+            process.stderr.write(`Failed to start YAGNI Code: ${err.message}\n`);
+            resolve(1);
+        });
+    });
+}
+export const HELP_TEXT = [
+    "YAGNI Code — a business-context-grounded terminal coding agent.",
+    "",
+    "Usage:",
+    "  yagni login            Authorize the active environment (device-code flow).",
+    "  yagni logout           Revoke and clear the active environment's token.",
+    "  yagni doctor           Check that everything is ready (green/red checklist).",
+    "  yagni use <name>       Switch the active environment (sticky).",
+    "                         Presets: prod, local. Others need --base-url <url>.",
+    "  yagni profiles         List saved environments; the active one is marked.",
+    "  yagni version          Print the CLI version.",
+    "  yagni [args…]          Launch the agent in the current repo.",
+    "",
+    "The active environment is sticky; `use` switches it (prod is the default).",
+    "Set YAGNI_BASE_URL to override the base URL for a single run.",
+].join("\n");
+/** Parse `use <name> [--base-url <url>]` argv into its parts. */
+export function parseUseArgs(args) {
+    let name;
+    let baseUrl;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--base-url") {
+            baseUrl = args[++i];
+            continue;
+        }
+        if (a.startsWith("--base-url=")) {
+            baseUrl = a.slice("--base-url=".length);
+            continue;
+        }
+        if (!a.startsWith("-") && name === undefined)
+            name = a;
+    }
+    return { name, baseUrl };
+}
+/** `yagni use <name> [--base-url <url>]` — switch the sticky environment. */
+export async function useCommand(args) {
+    const { name, baseUrl } = parseUseArgs(args);
+    if (!name) {
+        process.stderr.write("Usage: yagni use <name> [--base-url <url>]\n");
+        return 1;
+    }
+    try {
+        const profile = await useProfile(name, { baseUrl });
+        const hint = profile.token ? "" : " — run `yagni login` to authorize it";
+        process.stdout.write(`Active environment: ${profile.name} → ${profile.baseUrl}${hint}\n`);
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+}
+/** `yagni profiles` — list saved environments, marking the active one. */
+export async function profilesCommand() {
+    const active = await getActiveProfileName();
+    const stored = await listProfiles();
+    const rows = [...stored];
+    // Surface the active environment even if it has no saved file yet.
+    if (!rows.some((p) => p.name === active))
+        rows.push(await readActiveProfile());
+    rows.sort((a, b) => a.name.localeCompare(b.name));
+    for (const p of rows) {
+        const marker = p.name === active ? "*" : " ";
+        const status = p.token ? "logged in" : "not logged in";
+        process.stdout.write(`${marker} ${p.name.padEnd(12)} ${p.baseUrl}  (${status})\n`);
+    }
+    return 0;
+}
+/**
+ * Whether to show YAGNI Code's own help instead of launching the agent.
+ *
+ * `--help`/`-h` are intercepted ANYWHERE in argv (not just position 0) so the
+ * underlying agent's branded help never leaks (e.g. `yagni <flag> --help`).
+ */
+export function wantsHelp(argv) {
+    return argv[0] === "help" || argv.includes("--help") || argv.includes("-h");
+}
+/**
+ * Whether to print YAGNI Code's own version instead of launching the agent.
+ *
+ * `--version` AND `-v` are intercepted ANYWHERE in argv for the same reason as
+ * `--help`: pi parses both as its version flag, so letting either through
+ * leaks the agent's branded version line (or a login error before it).
+ */
+export function wantsVersion(argv) {
+    return argv[0] === "version" || argv.includes("--version") || argv.includes("-v");
+}
+/**
+ * The CLI's own version, read from this package's package.json. Resolved
+ * relative to the module (src/ and dist/ both sit one level below the package
+ * root), so it is correct under tsx in tests and in the published tarball.
+ */
+export function cliVersion() {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return pkg.version ?? "0.0.0";
+}
+export async function main(argv) {
+    const [command, ...rest] = argv;
+    // Help never touches storage; everything else first adopts any pre-profiles
+    // credentials.json as a named profile (one-shot, no-op once migrated).
+    if (wantsHelp(argv)) {
+        process.stdout.write(`${HELP_TEXT}\n`);
+        return 0;
+    }
+    // Bare semver on stdout (script-friendly); like help, never touches storage.
+    if (wantsVersion(argv)) {
+        process.stdout.write(`${cliVersion()}\n`);
+        return 0;
+    }
+    await migrateLegacyCredentials();
+    // login/logout act on the active environment; use/profiles manage which one
+    // that is. Anything else is passed straight through to the agent.
+    if (command === "login") {
+        const profile = await readActiveProfile();
+        await login({ baseUrl: profile.baseUrl, profileName: profile.name });
+        return 0;
+    }
+    if (command === "logout") {
+        await logout();
+        return 0;
+    }
+    if (command === "doctor") {
+        return runDoctor();
+    }
+    if (command === "use") {
+        return useCommand(rest);
+    }
+    if (command === "profiles") {
+        return profilesCommand();
+    }
+    return runDefault(command === undefined ? [] : [command, ...rest]);
+}
+/**
+ * Whether this module is the process entrypoint (vs. imported by a test).
+ *
+ * Symlink-safe: when `yagni-code` is installed globally, the shell runs it
+ * through a symlink in the bin dir, so `process.argv[1]` is that symlink path.
+ * Node resolves symlinks for `import.meta.url`, so a raw `argv[1] === metaPath`
+ * compare is ALWAYS false for a symlinked install and `main()` never runs (the
+ * "nothing happens" bug). We realpath both sides so the symlinked bin and a
+ * direct `node dist/cli.js` invocation both count as the entrypoint, while a
+ * test import (argv[1] points at the test runner) does not.
+ */
+export function isEntrypoint(argv1, moduleUrl) {
+    if (argv1 === undefined)
+        return false;
+    const resolve = (p) => {
+        try {
+            return realpathSync(p);
+        }
+        catch {
+            return p; // path may not exist on disk; fall back to the raw value
+        }
+    };
+    return resolve(argv1) === resolve(fileURLToPath(moduleUrl));
+}
+// Only auto-run when invoked as the CLI entry, so tests can import this module
+// (e.g. to exercise wantsHelp) without spawning the agent.
+if (isEntrypoint(process.argv[1], import.meta.url)) {
+    main(process.argv.slice(2))
+        .then((code) => process.exit(code))
+        .catch((err) => {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=cli.js.map

package/dist/config.d.ts

@@ -0,0 +1,19 @@
+/** Shared CLI config: where the YAGNI backend lives + the environment presets. */
+export declare const DEFAULT_BASE_URL = "https://yagni.app";
+/**
+ * Built-in environment presets. These only SEED a profile's base URL when you
+ * `yagni use <name>` without `--base-url`; once stored, the profile's own
+ * baseUrl wins. `prod` is the default profile; `local` points at the dev backend
+ * (`pnpm dev` serves /api + /v1 on 3456). Any other environment is user-defined
+ * (pass `--base-url`).
+ */
+export declare const PRESET_BASE_URLS: Record<string, string>;
+/** The base URL a named preset resolves to, or undefined for a custom name. */
+export declare function presetBaseUrl(name: string): string | undefined;
+/**
+ * The YAGNI_BASE_URL env override (back-compat / per-run escape hatch). Profiles
+ * are the primary mechanism now; this still wins when set so a one-off run can
+ * target an ad-hoc host without flipping the active profile.
+ */
+export declare function resolveBaseUrl(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,26 @@
+/** Shared CLI config: where the YAGNI backend lives + the environment presets. */
+export const DEFAULT_BASE_URL = "https://yagni.app";
+/**
+ * Built-in environment presets. These only SEED a profile's base URL when you
+ * `yagni use <name>` without `--base-url`; once stored, the profile's own
+ * baseUrl wins. `prod` is the default profile; `local` points at the dev backend
+ * (`pnpm dev` serves /api + /v1 on 3456). Any other environment is user-defined
+ * (pass `--base-url`).
+ */
+export const PRESET_BASE_URLS = {
+    prod: DEFAULT_BASE_URL,
+    local: "http://localhost:3456",
+};
+/** The base URL a named preset resolves to, or undefined for a custom name. */
+export function presetBaseUrl(name) {
+    return PRESET_BASE_URLS[name];
+}
+/**
+ * The YAGNI_BASE_URL env override (back-compat / per-run escape hatch). Profiles
+ * are the primary mechanism now; this still wins when set so a one-off run can
+ * target an ad-hoc host without flipping the active profile.
+ */
+export function resolveBaseUrl(env = process.env) {
+    return (env.YAGNI_BASE_URL?.trim() || DEFAULT_BASE_URL).replace(/\/$/, "");
+}
+//# sourceMappingURL=config.js.map