@yagni-app/code-staging 0.3.0-staging.1093.1 → 0.3.0-staging.1098.1

package/dist/cli.js

@@ -21,8 +21,10 @@ import { PI_CONFIG_NAME } from "./branding.js";
 import { claudeCompatArgs } from "./claudeCompat.js";
 import { agentDir, credentialsDir, piPackageDir } from "./credentials.js";
 import { DISTRIBUTION } from "./distribution.js";
+import { connectCommand } from "./connectClaudeCode.js";
 import { login } from "./login.js";
 import { logout } from "./logout.js";
+import { tokenCommand } from "./token.js";
 import { buildLaunch } from "./launch.js";
 import { runDoctor } from "./doctor.js";
 import { installProcessCrashHandlers } from "./crashReport.js";
@@ -286,6 +288,10 @@ export const HELP_TEXT = [
     "  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 connect claude-code  Route Claude Code through the YAGNI model proxy",
+    "                           (--project scopes to this repo; --off disconnects).",
+    "  yagni connect codex      Route Codex CLI through the YAGNI model proxy.",
+    "  yagni token              Output the active environment's API token (for helpers).",
     "  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.",
@@ -415,6 +421,12 @@ export async function main(argv) {
     if (command === "doctor") {
         return runDoctor();
     }
+    if (command === "connect") {
+        return connectCommand(rest);
+    }
+    if (command === "token") {
+        return tokenCommand();
+    }
     if (command === "upgrade") {
         return upgradeCommand(rest, { current: cliVersion() });
     }

package/dist/connectClaudeCode.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `yagni connect claude-code` — point Claude Code at the YAGNI model proxy.
+ *
+ * Writes the three settings Claude Code needs into `~/.claude/settings.json`
+ * (or `.claude/settings.local.json` with `--project`):
+ *
+ *   env.ANTHROPIC_BASE_URL      the active environment's base URL (Claude Code
+ *                               appends /v1/messages — the proxy's Anthropic-
+ *                               dialect route)
+ *   env.ANTHROPIC_CUSTOM_HEADERS  `x-yagni-caller: claude-code`, the
+ *                               attribution label the usage report rolls up on
+ *   apiKeyHelper                `yagni token` — the credential comes from the
+ *                               profile at call time, so nothing secret is
+ *                               ever baked into a settings file and a rotated
+ *                               token is picked up automatically
+ *
+ * Everything else in the file is preserved verbatim. `--off` removes exactly
+ * the managed keys (the helper only when it is ours). The planner is pure and
+ * the writer is atomic (temp + rename, symlink-refusing) — the same guard
+ * rails as the launcher's settings seeding, except a corrupt file is an ERROR
+ * here rather than a silent back-off: the user asked for a config change, so
+ * failing quietly would be lying.
+ */
+import { type Profile } from "./profiles.js";
+export declare const CALLER_HEADER_LINE = "x-yagni-caller: claude-code";
+export interface ConnectPlanInput {
+    /** The active environment's base URL (no trailing slash). */
+    baseUrl: string;
+    /** The apiKeyHelper command, e.g. `yagni token`. */
+    helperCommand: string;
+}
+export interface ConnectPlan {
+    settings: Record<string, unknown>;
+    /** Human-readable `key: old → new` lines for the summary. */
+    changes: string[];
+    /** Keys that belonged to something else and were replaced — surfaced loudly. */
+    replaced: string[];
+}
+type Settings = Record<string, unknown>;
+/**
+ * Merge our caller header into an existing ANTHROPIC_CUSTOM_HEADERS value:
+ * foreign header lines are preserved, a stale x-yagni-caller line is replaced,
+ * ours lands last. Newline-separated per the Claude Code contract.
+ */
+export declare function mergeCustomHeaders(existing: unknown): string;
+/** Pure: the settings object after connecting, plus what changed. */
+export declare function planConnect(existing: Settings, input: ConnectPlanInput): ConnectPlan;
+export interface DisconnectPlan {
+    settings: Settings;
+    removed: string[];
+    /** A foreign apiKeyHelper we refused to touch, if any. */
+    keptForeignHelper?: string;
+}
+/** Pure: the settings object after `--off` — managed keys out, all else kept. */
+export declare function planDisconnect(existing: Settings, helperCommand: string): DisconnectPlan;
+export declare function settingsPathFor(scope: "user" | "project", cwd: string, home?: string): string;
+/** Read + parse a settings file. Missing → {}. Corrupt/symlink/non-object → throws. */
+export declare function readSettings(path: string): Settings;
+/** Atomic write (temp + rename), preserving an existing file's permissions. */
+export declare function writeSettings(path: string, settings: Settings): void;
+export interface ConnectArgs {
+    target?: string;
+    project: boolean;
+    off: boolean;
+}
+export declare function parseConnectArgs(args: string[]): ConnectArgs;
+export interface ConnectDeps {
+    readProfile?: () => Promise<Profile>;
+    cwd?: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+}
+export declare function connectCommand(args: string[], deps?: ConnectDeps): Promise<number>;
+export {};
+//# sourceMappingURL=connectClaudeCode.d.ts.map

package/dist/connectClaudeCode.js

@@ -0,0 +1,228 @@
+/**
+ * `yagni connect claude-code` — point Claude Code at the YAGNI model proxy.
+ *
+ * Writes the three settings Claude Code needs into `~/.claude/settings.json`
+ * (or `.claude/settings.local.json` with `--project`):
+ *
+ *   env.ANTHROPIC_BASE_URL      the active environment's base URL (Claude Code
+ *                               appends /v1/messages — the proxy's Anthropic-
+ *                               dialect route)
+ *   env.ANTHROPIC_CUSTOM_HEADERS  `x-yagni-caller: claude-code`, the
+ *                               attribution label the usage report rolls up on
+ *   apiKeyHelper                `yagni token` — the credential comes from the
+ *                               profile at call time, so nothing secret is
+ *                               ever baked into a settings file and a rotated
+ *                               token is picked up automatically
+ *
+ * Everything else in the file is preserved verbatim. `--off` removes exactly
+ * the managed keys (the helper only when it is ours). The planner is pure and
+ * the writer is atomic (temp + rename, symlink-refusing) — the same guard
+ * rails as the launcher's settings seeding, except a corrupt file is an ERROR
+ * here rather than a silent back-off: the user asked for a config change, so
+ * failing quietly would be lying.
+ */
+import { existsSync, lstatSync, readFileSync, renameSync, rmSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { DISTRIBUTION } from "./distribution.js";
+import { credentialsFromProfile, readActiveProfile } from "./profiles.js";
+export const CALLER_HEADER_LINE = "x-yagni-caller: claude-code";
+function envOf(settings) {
+    const env = settings.env;
+    return env && typeof env === "object" && !Array.isArray(env) ? { ...env } : {};
+}
+/**
+ * Merge our caller header into an existing ANTHROPIC_CUSTOM_HEADERS value:
+ * foreign header lines are preserved, a stale x-yagni-caller line is replaced,
+ * ours lands last. Newline-separated per the Claude Code contract.
+ */
+export function mergeCustomHeaders(existing) {
+    const lines = typeof existing === "string" && existing.length > 0 ? existing.split("\n") : [];
+    const kept = lines.filter((l) => l.trim() !== "" && !/^x-yagni-caller\s*:/i.test(l));
+    return [...kept, CALLER_HEADER_LINE].join("\n");
+}
+/** Pure: the settings object after connecting, plus what changed. */
+export function planConnect(existing, input) {
+    const env = envOf(existing);
+    const changes = [];
+    const replaced = [];
+    const note = (key, prior, next) => {
+        if (prior === next)
+            return;
+        changes.push(prior === undefined ? `${key} = ${next}` : `${key}: ${String(prior)} → ${next}`);
+        if (prior !== undefined)
+            replaced.push(key);
+    };
+    note("env.ANTHROPIC_BASE_URL", env.ANTHROPIC_BASE_URL, input.baseUrl);
+    env.ANTHROPIC_BASE_URL = input.baseUrl;
+    const headers = mergeCustomHeaders(env.ANTHROPIC_CUSTOM_HEADERS);
+    if (env.ANTHROPIC_CUSTOM_HEADERS !== headers) {
+        changes.push(`env.ANTHROPIC_CUSTOM_HEADERS = ${headers.replaceAll("\n", " | ")}`);
+    }
+    env.ANTHROPIC_CUSTOM_HEADERS = headers;
+    note("apiKeyHelper", existing.apiKeyHelper, input.helperCommand);
+    return {
+        settings: { ...existing, env, apiKeyHelper: input.helperCommand },
+        changes,
+        replaced,
+    };
+}
+/** Pure: the settings object after `--off` — managed keys out, all else kept. */
+export function planDisconnect(existing, helperCommand) {
+    const env = envOf(existing);
+    const removed = [];
+    const out = { ...existing };
+    if (env.ANTHROPIC_BASE_URL !== undefined) {
+        removed.push("env.ANTHROPIC_BASE_URL");
+        delete env.ANTHROPIC_BASE_URL;
+    }
+    if (typeof env.ANTHROPIC_CUSTOM_HEADERS === "string") {
+        const kept = env.ANTHROPIC_CUSTOM_HEADERS
+            .split("\n")
+            .filter((l) => l.trim() !== "" && !/^x-yagni-caller\s*:/i.test(l));
+        if (kept.length !== env.ANTHROPIC_CUSTOM_HEADERS.split("\n").filter((l) => l.trim() !== "").length) {
+            removed.push("env.ANTHROPIC_CUSTOM_HEADERS (x-yagni-caller line)");
+        }
+        if (kept.length === 0)
+            delete env.ANTHROPIC_CUSTOM_HEADERS;
+        else
+            env.ANTHROPIC_CUSTOM_HEADERS = kept.join("\n");
+    }
+    let keptForeignHelper;
+    if (typeof out.apiKeyHelper === "string") {
+        // Only remove a helper that is ours — `yagni token` under any install path
+        // (npx wrapper, absolute bin). Someone else's gateway helper stays.
+        if (new RegExp(`(^|[/\\s])${helperCommand.split(" ")[0]}\\s+token\\s*$`).test(out.apiKeyHelper)) {
+            removed.push("apiKeyHelper");
+            delete out.apiKeyHelper;
+        }
+        else {
+            keptForeignHelper = out.apiKeyHelper;
+        }
+    }
+    if (Object.keys(env).length === 0 && out.env !== undefined)
+        delete out.env;
+    else
+        out.env = env;
+    return { settings: out, removed, ...(keptForeignHelper ? { keptForeignHelper } : {}) };
+}
+// ---------------------------------------------------------------------------
+// File I/O
+// ---------------------------------------------------------------------------
+export function settingsPathFor(scope, cwd, home = homedir()) {
+    return scope === "project"
+        ? join(cwd, ".claude", "settings.local.json")
+        : join(home, ".claude", "settings.json");
+}
+/** Read + parse a settings file. Missing → {}. Corrupt/symlink/non-object → throws. */
+export function readSettings(path) {
+    if (!existsSync(path))
+        return {};
+    if (lstatSync(path).isSymbolicLink()) {
+        throw new Error(`${path} is a symlink; refusing to rewrite it. Point yagni at the real file.`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new Error(`${path} is not valid JSON. Fix or remove it, then re-run.`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${path} does not hold a JSON object. Fix or remove it, then re-run.`);
+    }
+    return parsed;
+}
+/** Atomic write (temp + rename), preserving an existing file's permissions. */
+export function writeSettings(path, settings) {
+    const existingMode = existsSync(path) ? lstatSync(path).mode & 0o777 : undefined;
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = join(dirname(path), `.${DISTRIBUTION.commandName}-connect-${process.pid}.tmp`);
+    try {
+        writeFileSync(tmp, `${JSON.stringify(settings, null, 2)}\n`);
+        renameSync(tmp, path);
+    }
+    finally {
+        rmSync(tmp, { force: true });
+    }
+    if (existingMode !== undefined)
+        chmodSync(path, existingMode);
+}
+export function parseConnectArgs(args) {
+    let target;
+    let project = false;
+    let off = false;
+    for (const a of args) {
+        if (a === "--project")
+            project = true;
+        else if (a === "--off")
+            off = true;
+        else if (!a.startsWith("-") && target === undefined)
+            target = a;
+    }
+    return { target, project, off };
+}
+export async function connectCommand(args, deps = {}) {
+    const stdout = deps.stdout ?? ((t) => process.stdout.write(t));
+    const stderr = deps.stderr ?? ((t) => process.stderr.write(t));
+    const { target, project, off } = parseConnectArgs(args);
+    if (target === "codex") {
+        if (project) {
+            stderr("`connect codex` has no --project scope: Codex reads one user-level config.toml.\n");
+            return 1;
+        }
+        const { connectCodexCommand } = await import("./connectCodex.js");
+        return connectCodexCommand({ off }, deps);
+    }
+    if (target !== "claude-code") {
+        stderr(target
+            ? `Unknown connect target "${target}". Supported: claude-code, codex.\n`
+            : `Usage: ${DISTRIBUTION.commandName} connect <claude-code|codex> [--project] [--off]\n`);
+        return 1;
+    }
+    const profile = await (deps.readProfile ?? readActiveProfile)();
+    const helperCommand = `${DISTRIBUTION.commandName} token`;
+    const path = settingsPathFor(project ? "project" : "user", deps.cwd ?? process.cwd(), deps.home);
+    let existing;
+    try {
+        existing = readSettings(path);
+    }
+    catch (err) {
+        stderr(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    if (off) {
+        const plan = planDisconnect(existing, DISTRIBUTION.commandName);
+        writeSettings(path, plan.settings);
+        stdout(plan.removed.length > 0
+            ? `✓ Claude Code disconnected from YAGNI.\n  ${path}\n  Removed: ${plan.removed.join(", ")}\n`
+            : `Nothing to disconnect in ${path}.\n`);
+        if (plan.keptForeignHelper) {
+            stdout(`  Kept apiKeyHelper (${plan.keptForeignHelper}) since it is not YAGNI's.\n`);
+        }
+        return 0;
+    }
+    const creds = credentialsFromProfile(profile);
+    if (!creds?.token) {
+        stderr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`${DISTRIBUTION.commandName} login\` first.\n`);
+        return 1;
+    }
+    const plan = planConnect(existing, { baseUrl: profile.baseUrl, helperCommand });
+    writeSettings(path, plan.settings);
+    stdout(`✓ Claude Code connected to YAGNI (${profile.name} → ${profile.baseUrl}).\n`);
+    stdout(`  ${path}\n`);
+    for (const change of plan.changes)
+        stdout(`    ${change}\n`);
+    for (const key of plan.replaced) {
+        stdout(`  Replaced an existing ${key}. \`connect claude-code --off\` removes YAGNI's value but cannot restore the old one.\n`);
+    }
+    const shellEnv = deps.env ?? process.env;
+    for (const key of ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"]) {
+        if (shellEnv[key]) {
+            stdout(`  ⚠ ${key} is set in your shell and OUTRANKS the settings written here. Unset it or Claude Code will keep using it.\n`);
+        }
+    }
+    stdout(`  Restart Claude Code to pick this up. Model picks map to YAGNI tiers (fable→peak, opus→advanced, sonnet→standard, haiku→efficient).\n`);
+    return 0;
+}
+//# sourceMappingURL=connectClaudeCode.js.map

package/dist/connectCodex.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `yagni connect codex` — point Codex CLI at the YAGNI model proxy.
+ *
+ * Writes into `~/.codex/config.toml` (respecting CODEX_HOME):
+ *
+ *   model_provider = "yagni"               the active provider
+ *   model = "advanced"                     a YAGNI tier — Codex sends it
+ *                                          verbatim and the proxy's catalog
+ *                                          enforcement validates it
+ *   [model_providers.yagni]                base_url → `<base>/v1` (Codex
+ *                                          appends /responses — the proxy's
+ *                                          Responses-dialect route),
+ *                                          wire_api "responses" (the only
+ *                                          wire current Codex speaks),
+ *                                          x-yagni-caller: codex attribution,
+ *                                          and auth.command = `yagni token` —
+ *                                          Codex's command-backed bearer
+ *                                          token, so no secret is ever baked
+ *                                          into the config and rotation rides
+ *                                          the same refresh client as
+ *                                          everything else.
+ *
+ * TOML cannot be comment-preservingly round-tripped by a parser, so when the
+ * existing config carries comments we save a one-time `config.toml.yagni-backup`
+ * next to it before rewriting and say so — never silently eat a user's notes.
+ * Everything else follows the claude-code connector's contract: managed keys
+ * only, atomic write, symlink refusal, corrupt file is a loud error, `--off`
+ * removes exactly what we own.
+ */
+import { type Profile } from "./profiles.js";
+export declare const CODEX_PROVIDER_ID = "yagni";
+export declare const CODEX_DEFAULT_TIER = "advanced";
+type TomlTable = Record<string, unknown>;
+export declare function codexConfigPath(home?: string, env?: NodeJS.ProcessEnv): string;
+export interface CodexConnectPlan {
+    config: TomlTable;
+    changes: string[];
+    replaced: string[];
+}
+/** Pure: the config after connecting, plus what changed. */
+export declare function planConnectCodex(existing: TomlTable, input: {
+    baseUrl: string;
+    commandName: string;
+}): CodexConnectPlan;
+export interface CodexDisconnectPlan {
+    config: TomlTable;
+    removed: string[];
+}
+/** Pure: the config after `--off` — our provider and its selection out. */
+export declare function planDisconnectCodex(existing: TomlTable): CodexDisconnectPlan;
+export interface CodexConfigFile {
+    config: TomlTable;
+    /** The raw text, kept so a comment-carrying file can be backed up. */
+    raw: string | null;
+}
+/** Read + parse the Codex config. Missing → {}. Corrupt/symlink → throws. */
+export declare function readCodexConfig(path: string): CodexConfigFile;
+/**
+ * Atomic write; when the original text carried comments (which a parse →
+ * stringify round-trip cannot preserve), a `config.toml.yagni-backup` copy of
+ * the original is written first. Returns the backup path when one was made.
+ */
+export declare function writeCodexConfig(path: string, config: TomlTable, originalRaw: string | null): string | null;
+export interface ConnectCodexDeps {
+    readProfile?: () => Promise<Profile>;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    stdout?: (text: string) => void;
+    stderr?: (text: string) => void;
+}
+export declare function connectCodexCommand(opts: {
+    off: boolean;
+}, deps?: ConnectCodexDeps): Promise<number>;
+export {};
+//# sourceMappingURL=connectCodex.d.ts.map

package/dist/connectCodex.js

@@ -0,0 +1,201 @@
+/**
+ * `yagni connect codex` — point Codex CLI at the YAGNI model proxy.
+ *
+ * Writes into `~/.codex/config.toml` (respecting CODEX_HOME):
+ *
+ *   model_provider = "yagni"               the active provider
+ *   model = "advanced"                     a YAGNI tier — Codex sends it
+ *                                          verbatim and the proxy's catalog
+ *                                          enforcement validates it
+ *   [model_providers.yagni]                base_url → `<base>/v1` (Codex
+ *                                          appends /responses — the proxy's
+ *                                          Responses-dialect route),
+ *                                          wire_api "responses" (the only
+ *                                          wire current Codex speaks),
+ *                                          x-yagni-caller: codex attribution,
+ *                                          and auth.command = `yagni token` —
+ *                                          Codex's command-backed bearer
+ *                                          token, so no secret is ever baked
+ *                                          into the config and rotation rides
+ *                                          the same refresh client as
+ *                                          everything else.
+ *
+ * TOML cannot be comment-preservingly round-tripped by a parser, so when the
+ * existing config carries comments we save a one-time `config.toml.yagni-backup`
+ * next to it before rewriting and say so — never silently eat a user's notes.
+ * Everything else follows the claude-code connector's contract: managed keys
+ * only, atomic write, symlink refusal, corrupt file is a loud error, `--off`
+ * removes exactly what we own.
+ */
+import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { DISTRIBUTION } from "./distribution.js";
+import { credentialsFromProfile, readActiveProfile } from "./profiles.js";
+export const CODEX_PROVIDER_ID = "yagni";
+export const CODEX_DEFAULT_TIER = "advanced";
+export function codexConfigPath(home = homedir(), env = process.env) {
+    const codexHome = env.CODEX_HOME?.trim() ? env.CODEX_HOME.trim() : join(home, ".codex");
+    return join(codexHome, "config.toml");
+}
+function providersOf(config) {
+    const providers = config.model_providers;
+    return providers && typeof providers === "object" && !Array.isArray(providers)
+        ? { ...providers }
+        : {};
+}
+/** Pure: the config after connecting, plus what changed. */
+export function planConnectCodex(existing, input) {
+    const changes = [];
+    const replaced = [];
+    const note = (key, prior, next) => {
+        if (prior === next)
+            return;
+        changes.push(prior === undefined ? `${key} = ${next}` : `${key}: ${String(prior)} → ${next}`);
+        if (prior !== undefined)
+            replaced.push(key);
+    };
+    note("model_provider", existing.model_provider, CODEX_PROVIDER_ID);
+    note("model", existing.model, CODEX_DEFAULT_TIER);
+    const providers = providersOf(existing);
+    if (providers[CODEX_PROVIDER_ID] === undefined) {
+        changes.push(`model_providers.${CODEX_PROVIDER_ID} = (provider block)`);
+    }
+    providers[CODEX_PROVIDER_ID] = {
+        name: "YAGNI",
+        base_url: `${input.baseUrl}/v1`,
+        wire_api: "responses",
+        http_headers: { "x-yagni-caller": "codex" },
+        auth: { command: input.commandName, args: ["token"] },
+    };
+    return {
+        config: {
+            ...existing,
+            model_provider: CODEX_PROVIDER_ID,
+            model: CODEX_DEFAULT_TIER,
+            model_providers: providers,
+        },
+        changes,
+        replaced,
+    };
+}
+/** Pure: the config after `--off` — our provider and its selection out. */
+export function planDisconnectCodex(existing) {
+    const removed = [];
+    const out = { ...existing };
+    const providers = providersOf(existing);
+    if (providers[CODEX_PROVIDER_ID] !== undefined) {
+        removed.push(`model_providers.${CODEX_PROVIDER_ID}`);
+        delete providers[CODEX_PROVIDER_ID];
+    }
+    if (Object.keys(providers).length === 0)
+        delete out.model_providers;
+    else
+        out.model_providers = providers;
+    // The model selection is only ours when it points at our provider — a
+    // foreign model_provider (and its paired model) is left untouched.
+    if (out.model_provider === CODEX_PROVIDER_ID) {
+        removed.push("model_provider");
+        delete out.model_provider;
+        if (typeof out.model === "string") {
+            removed.push("model");
+            delete out.model;
+        }
+    }
+    return { config: out, removed };
+}
+/** Read + parse the Codex config. Missing → {}. Corrupt/symlink → throws. */
+export function readCodexConfig(path) {
+    if (!existsSync(path))
+        return { config: {}, raw: null };
+    if (lstatSync(path).isSymbolicLink()) {
+        throw new Error(`${path} is a symlink; refusing to rewrite it. Point yagni at the real file.`);
+    }
+    const raw = readFileSync(path, "utf8");
+    let parsed;
+    try {
+        parsed = parseToml(raw);
+    }
+    catch {
+        throw new Error(`${path} is not valid TOML. Fix or remove it, then re-run.`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${path} does not hold a TOML table. Fix or remove it, then re-run.`);
+    }
+    return { config: parsed, raw };
+}
+const COMMENT_RE = /^\s*#|\s#/m;
+/**
+ * Atomic write; when the original text carried comments (which a parse →
+ * stringify round-trip cannot preserve), a `config.toml.yagni-backup` copy of
+ * the original is written first. Returns the backup path when one was made.
+ */
+export function writeCodexConfig(path, config, originalRaw) {
+    mkdirSync(dirname(path), { recursive: true });
+    let backupPath = null;
+    if (originalRaw !== null && COMMENT_RE.test(originalRaw)) {
+        backupPath = `${path}.yagni-backup`;
+        writeFileSync(backupPath, originalRaw);
+    }
+    const existingMode = existsSync(path) ? lstatSync(path).mode & 0o777 : undefined;
+    const tmp = join(dirname(path), `.${DISTRIBUTION.commandName}-connect-codex-${process.pid}.tmp`);
+    try {
+        writeFileSync(tmp, `${stringifyToml(config)}\n`, existingMode !== undefined ? { mode: existingMode } : {});
+        renameSync(tmp, path);
+    }
+    finally {
+        rmSync(tmp, { force: true });
+    }
+    return backupPath;
+}
+export async function connectCodexCommand(opts, deps = {}) {
+    const stdout = deps.stdout ?? ((t) => process.stdout.write(t));
+    const stderr = deps.stderr ?? ((t) => process.stderr.write(t));
+    const env = deps.env ?? process.env;
+    const path = codexConfigPath(deps.home, env);
+    const profile = await (deps.readProfile ?? readActiveProfile)();
+    let file;
+    try {
+        file = readCodexConfig(path);
+    }
+    catch (err) {
+        stderr(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    if (opts.off) {
+        const plan = planDisconnectCodex(file.config);
+        if (plan.removed.length === 0) {
+            stdout(`Nothing to disconnect in ${path}.\n`);
+            return 0;
+        }
+        const backup = writeCodexConfig(path, plan.config, file.raw);
+        stdout(`✓ Codex disconnected from YAGNI.\n  ${path}\n  Removed: ${plan.removed.join(", ")}\n`);
+        if (backup)
+            stdout(`  Comments in the original were preserved at ${backup}.\n`);
+        return 0;
+    }
+    const creds = credentialsFromProfile(profile);
+    if (!creds?.token) {
+        stderr(`Not logged in to environment "${profile.name}" (${profile.baseUrl}). Run \`${DISTRIBUTION.commandName} login\` first.\n`);
+        return 1;
+    }
+    const plan = planConnectCodex(file.config, {
+        baseUrl: profile.baseUrl,
+        commandName: DISTRIBUTION.commandName,
+    });
+    const backup = writeCodexConfig(path, plan.config, file.raw);
+    stdout(`✓ Codex connected to YAGNI (${profile.name} → ${profile.baseUrl}).\n`);
+    stdout(`  ${path}\n`);
+    for (const change of plan.changes)
+        stdout(`    ${change}\n`);
+    for (const key of plan.replaced) {
+        stdout(`  Replaced an existing ${key}. \`connect codex --off\` removes YAGNI's value but cannot restore the old one.\n`);
+    }
+    if (backup) {
+        stdout(`  Your config had comments, which a rewrite cannot keep. The original is at ${backup}.\n`);
+    }
+    stdout(`  Restart Codex to pick this up. It runs \`${DISTRIBUTION.commandName} token\` for credentials and serves the "${CODEX_DEFAULT_TIER}" tier; edit \`model\` to any YAGNI tier to change that.\n`);
+    return 0;
+}
+//# sourceMappingURL=connectCodex.js.map

package/dist/extension/askYagniTool.d.ts

@@ -1,11 +1,20 @@
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { type FlywheelState } from "./flywheel.js";
 import { type RepoDocSnippet } from "./repoDocs.js";
 /** A single source citation returned by the YAGNI `ask` endpoint. */
 export interface Citation {
     title: string;
     url: string;
 }
+/**
+ * How hard the answer may be leaned on (mirror of `@yagni/shared`'s
+ * AskStanding — mirrored locally by this extension's no-workspace-imports
+ * convention, see costHud.ts).
+ */
+export type AskStanding = "confirmed" | "asserted" | "inferred" | "no_position";
+/** One line the TUI shows above the answer, per standing. */
+export declare const STANDING_LINES: Record<AskStanding, string>;
 /** Options for {@link makeAskYagniTool}. */
 export interface MakeAskYagniToolOptions {
     baseUrl: string;
@@ -19,6 +28,19 @@ export interface MakeAskYagniToolOptions {
      * checkout's own era, since the docs are read from the tree being edited.
      */
     collectDocs?: (cwd: string, query: string) => RepoDocSnippet[];
+    /**
+     * Shared flywheel session state (Run 7): caps how many no-position
+     * recordSuggestions reach the model per session and attributes the
+     * follow-up record_decision for dedupe. Absent → suggestions always
+     * surface, nothing is attributed (tests, older wiring).
+     */
+    flywheel?: FlywheelState;
+    /**
+     * The session repo (`owner/name`), for the backend's soft-scoped decision
+     * read (workspace-level decisions plus this repo's own — never another
+     * repo's conventions). Absent keeps the workspace-wide read.
+     */
+    getRepo?: () => string | undefined;
 }
 declare const parameters: Type.TObject<{
     question: Type.TString;
@@ -34,6 +56,7 @@ declare const parameters: Type.TObject<{
  */
 export declare function makeAskYagniTool(opts: MakeAskYagniToolOptions): ToolDefinition<typeof parameters, {
     citations: Citation[];
+    standing?: AskStanding;
 }>;
 export {};
 //# sourceMappingURL=askYagniTool.d.ts.map