@yagni-app/code 0.1.0 → 0.2.0

package/dist/claudePlugins.js

@@ -0,0 +1,336 @@
+/**
+ * Claude Code plugin + marketplace discovery (local content only).
+ *
+ * Finds the plugin content a Claude Code user already has on disk and exposes
+ * it as asset paths the launcher can feed through the existing compat seams:
+ * skills → `--skill`, commands → `--prompt-template`, agents → the subagent
+ * discovery env var. Two sources:
+ *
+ * 1. Installed plugins: `~/.claude/plugins/installed_plugins.json` (version-2
+ *    ledger of `name@marketplace` → cache checkouts), enabled through
+ *    `enabledPlugins` in the user's `~/.claude/settings.json` (user scope) or
+ *    the repo's `.claude/settings{,.local}.json` (project scope). When a
+ *    ledger entry is gone, the marketplace checkout recorded in
+ *    `known_marketplaces.json` is tried as a fallback.
+ * 2. The repo's own `.claude-plugin/marketplace.json` (the internal-
+ *    marketplace pattern): every plugin it defines with a locally-present
+ *    relative-path source loads on the project side, unless explicitly
+ *    disabled via `enabledPlugins`.
+ *
+ * Deliberately NOT here: network installation of any kind, plugin hooks, MCP
+ * servers, LSP servers, themes, output styles. Discovery is read-only.
+ *
+ * Everything is fail-soft: malformed JSON, missing dirs, or hostile path
+ * entries degrade to "that plugin absent" — never a failed launch. Path
+ * entries from marketplace/plugin manifests are containment-checked (realpath
+ * inside the expected root) so a malicious `source` or component override
+ * cannot reach outside its repo/plugin.
+ */
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve, sep } from "node:path";
+// ── fail-soft fs/json primitives ────────────────────────────────────────────
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function readJsonObject(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function realOrNull(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve `candidate` (a relative path from untrusted JSON) against `root` and
+ * return its realpath only when it exists AND stays inside `root` after
+ * symlink resolution. Absolute candidates and any `../` escape are rejected.
+ */
+export function containedExistingPath(root, candidate) {
+    if (typeof candidate !== "string" || candidate.length === 0)
+        return null;
+    if (isAbsolute(candidate))
+        return null;
+    const realRoot = realOrNull(root);
+    if (!realRoot)
+        return null;
+    const real = realOrNull(resolve(root, candidate));
+    if (!real)
+        return null;
+    if (real !== realRoot && !real.startsWith(realRoot + sep))
+        return null;
+    return real;
+}
+/** `~/.claude/plugins/installed_plugins.json` → `name@marketplace` → entries. */
+export function readInstalledPlugins(homeDir) {
+    const out = new Map();
+    const parsed = readJsonObject(join(homeDir, ".claude", "plugins", "installed_plugins.json"));
+    const plugins = parsed?.plugins;
+    if (!plugins || typeof plugins !== "object" || Array.isArray(plugins))
+        return out;
+    for (const [key, value] of Object.entries(plugins)) {
+        if (!Array.isArray(value))
+            continue;
+        const entries = [];
+        for (const item of value) {
+            if (!item || typeof item !== "object")
+                continue;
+            const installPath = item.installPath;
+            if (typeof installPath !== "string" || installPath.length === 0)
+                continue;
+            const projectPath = item.projectPath;
+            entries.push({
+                installPath,
+                ...(typeof projectPath === "string" ? { projectPath } : {}),
+            });
+        }
+        if (entries.length > 0)
+            out.set(key, entries);
+    }
+    return out;
+}
+function collectEnabled(path, scope, into) {
+    const parsed = readJsonObject(path);
+    const enabled = parsed?.enabledPlugins;
+    if (!enabled || typeof enabled !== "object" || Array.isArray(enabled))
+        return;
+    for (const [key, value] of Object.entries(enabled)) {
+        if (value === true || value === false)
+            into.set(key, { enabled: value, scope });
+    }
+}
+/**
+ * `enabledPlugins` merged across scopes, later (more specific) winning:
+ * user `~/.claude/settings.json` < project `.claude/settings.json` <
+ * project `.claude/settings.local.json`.
+ */
+export function readEnabledPlugins(cwd, homeDir) {
+    const out = new Map();
+    collectEnabled(join(homeDir, ".claude", "settings.json"), "user", out);
+    collectEnabled(join(cwd, ".claude", "settings.json"), "project", out);
+    collectEnabled(join(cwd, ".claude", "settings.local.json"), "project", out);
+    return out;
+}
+/** `~/.claude/plugins/known_marketplaces.json` → marketplace name → checkout dir. */
+export function readKnownMarketplaces(homeDir) {
+    const out = new Map();
+    const parsed = readJsonObject(join(homeDir, ".claude", "plugins", "known_marketplaces.json"));
+    if (!parsed)
+        return out;
+    for (const [name, value] of Object.entries(parsed)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const loc = value.installLocation;
+        if (typeof loc === "string" && loc.length > 0)
+            out.set(name, loc);
+    }
+    return out;
+}
+/** Parse `<root>/.claude-plugin/marketplace.json`; null when absent/unusable. */
+export function readMarketplace(root) {
+    const parsed = readJsonObject(join(root, ".claude-plugin", "marketplace.json"));
+    if (!parsed || typeof parsed.name !== "string" || parsed.name.length === 0)
+        return null;
+    if (!Array.isArray(parsed.plugins))
+        return null;
+    const metadata = parsed.metadata && typeof parsed.metadata === "object" && !Array.isArray(parsed.metadata)
+        ? parsed.metadata
+        : {};
+    const pluginRoot = typeof metadata.pluginRoot === "string" ? metadata.pluginRoot : null;
+    const plugins = [];
+    for (const item of parsed.plugins) {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const name = item.name;
+        if (typeof name !== "string" || name.length === 0)
+            continue;
+        plugins.push({ name, source: item.source });
+    }
+    return { name: parsed.name, root, pluginRoot, plugins };
+}
+/**
+ * The local directory a marketplace entry's source points at, when it is a
+ * relative-path source that exists inside the marketplace root. Object
+ * sources (github/url/npm/...) are network installs → null here.
+ */
+export function resolveLocalPluginRoot(mp, entry) {
+    const src = entry.source;
+    if (typeof src !== "string" || src.length === 0)
+        return null;
+    if (isAbsolute(src))
+        return null;
+    // Docs: `metadata.pluginRoot` lets a bare "formatter" mean "./plugins/formatter".
+    // Try the pluginRoot-prefixed form first, then the source as written.
+    const candidates = [];
+    if (mp.pluginRoot)
+        candidates.push(`${mp.pluginRoot}/${src}`);
+    candidates.push(src);
+    for (const candidate of candidates) {
+        const contained = containedExistingPath(mp.root, candidate);
+        if (contained && isDirectory(contained))
+            return contained;
+    }
+    return null;
+}
+// ── plugin component assets ─────────────────────────────────────────────────
+function asStringArray(value) {
+    if (typeof value === "string")
+        return [value];
+    if (Array.isArray(value))
+        return value.filter((v) => typeof v === "string");
+    return [];
+}
+/**
+ * The bridgeable assets inside one plugin checkout, per Claude Code's
+ * component rules: `skills/` (manifest `skills` ADDS dirs), `commands/`
+ * (manifest REPLACES), `agents/` (manifest REPLACES; dirs only — pi's
+ * discovery reads whole dirs), root `SKILL.md` fallback. Null when the plugin
+ * has nothing we can bridge.
+ */
+export function pluginAssets(root, name) {
+    if (!isDirectory(root))
+        return null;
+    const manifest = readJsonObject(join(root, ".claude-plugin", "plugin.json")) ?? {};
+    const skillPaths = [];
+    const defaultSkills = join(root, "skills");
+    if (isDirectory(defaultSkills))
+        skillPaths.push(defaultSkills);
+    const manifestSkills = asStringArray(manifest.skills);
+    for (const rel of manifestSkills) {
+        const contained = containedExistingPath(root, rel);
+        if (contained)
+            skillPaths.push(contained);
+    }
+    if (skillPaths.length === 0 && manifestSkills.length === 0) {
+        const rootSkill = join(root, "SKILL.md");
+        if (isFile(rootSkill))
+            skillPaths.push(rootSkill);
+    }
+    const componentPaths = (manifestValue, defaultDir) => {
+        const entries = asStringArray(manifestValue);
+        if (entries.length > 0) {
+            const out = [];
+            for (const rel of entries) {
+                const contained = containedExistingPath(root, rel);
+                if (contained)
+                    out.push(contained);
+            }
+            return out;
+        }
+        const def = join(root, defaultDir);
+        return isDirectory(def) ? [def] : [];
+    };
+    const commandPaths = componentPaths(manifest.commands, "commands");
+    const agentDirs = componentPaths(manifest.agents, "agents").filter(isDirectory);
+    if (skillPaths.length === 0 && commandPaths.length === 0 && agentDirs.length === 0)
+        return null;
+    return { name, root, skillPaths, commandPaths, agentDirs };
+}
+function resolveInstalledRoot(key, installed, marketplaces, realCwd) {
+    const entries = (installed.get(key) ?? []).filter((e) => isDirectory(e.installPath));
+    const projectMatch = entries.find((e) => {
+        if (typeof e.projectPath !== "string")
+            return false;
+        const real = realOrNull(e.projectPath);
+        if (!real)
+            return false;
+        return realCwd === real || realCwd.startsWith(real + sep);
+    });
+    if (projectMatch)
+        return projectMatch.installPath;
+    if (entries[0])
+        return entries[0].installPath;
+    // Cache entry gone: try the marketplace checkout's own copy of the plugin.
+    const at = key.lastIndexOf("@");
+    if (at <= 0)
+        return null;
+    const pluginName = key.slice(0, at);
+    const marketplaceName = key.slice(at + 1);
+    const location = marketplaces.get(marketplaceName);
+    if (!location)
+        return null;
+    const mp = readMarketplace(location);
+    if (!mp)
+        return null;
+    const entry = mp.plugins.find((p) => p.name === pluginName);
+    if (!entry)
+        return null;
+    return resolveLocalPluginRoot(mp, entry);
+}
+/**
+ * All locally-present Claude Code plugin content relevant to `cwd`, split by
+ * the trust posture the launcher must apply. Never throws.
+ */
+export function discoverClaudePlugins(deps) {
+    try {
+        const installed = readInstalledPlugins(deps.homeDir);
+        const enabled = readEnabledPlugins(deps.cwd, deps.homeDir);
+        const marketplaces = readKnownMarketplaces(deps.homeDir);
+        const realCwd = realOrNull(deps.cwd) ?? resolve(deps.cwd);
+        const user = [];
+        const project = [];
+        const seen = new Set();
+        for (const [key, state] of enabled) {
+            if (!state.enabled)
+                continue;
+            const root = resolveInstalledRoot(key, installed, marketplaces, realCwd);
+            if (!root)
+                continue;
+            const at = key.lastIndexOf("@");
+            const assets = pluginAssets(root, at > 0 ? key.slice(0, at) : key);
+            if (!assets)
+                continue;
+            seen.add(key);
+            (state.scope === "user" ? user : project).push(assets);
+        }
+        // The internal-marketplace pattern: working inside the marketplace repo
+        // itself, its locally-present plugins load (trust-gated) with zero config.
+        const repoMarketplace = readMarketplace(deps.cwd);
+        if (repoMarketplace) {
+            for (const entry of repoMarketplace.plugins) {
+                const key = `${entry.name}@${repoMarketplace.name}`;
+                if (seen.has(key))
+                    continue;
+                if (enabled.get(key)?.enabled === false)
+                    continue;
+                const root = resolveLocalPluginRoot(repoMarketplace, entry) ??
+                    resolveInstalledRoot(key, installed, marketplaces, realCwd);
+                if (!root)
+                    continue;
+                const assets = pluginAssets(root, entry.name);
+                if (!assets)
+                    continue;
+                seen.add(key);
+                project.push(assets);
+            }
+        }
+        return { user, project };
+    }
+    catch {
+        return { user: [], project: [] };
+    }
+}
+//# sourceMappingURL=claudePlugins.js.map

package/dist/cli.d.ts

@@ -37,11 +37,7 @@ export declare function wantsHelp(argv: string[]): boolean;
  * 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.
- */
+/** The CLI's own version (see `currentCliVersion` — upgrade.ts owns it). */
 export declare function cliVersion(): string;
 export declare function main(argv: string[]): Promise<number>;
 /**

package/dist/cli.js

@@ -13,22 +13,40 @@
  * 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 { mkdirSync, realpathSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { PI_CONFIG_NAME } from "./branding.js";
-import { agentDir, piPackageDir } from "./credentials.js";
+import { claudeCompatArgs } from "./claudeCompat.js";
+import { agentDir, credentialsDir, piPackageDir } from "./credentials.js";
+import { DISTRIBUTION } from "./distribution.js";
 import { login } from "./login.js";
 import { logout } from "./logout.js";
 import { buildLaunch } from "./launch.js";
 import { runDoctor } from "./doctor.js";
+import { installProcessCrashHandlers } from "./crashReport.js";
+import { currentCliVersion, maybeNudgeAndRefresh, upgradeCommand } from "./upgrade.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";
+process.title = DISTRIBUTION.commandName;
+/** The one-time Claude-compat trust question, asked on the launch TTY. */
+async function confirmOnTty(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`${question} [Y/n] `);
+        return !/^n/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
 async function runDefault(passthroughArgs) {
+    // Cache-backed update nudge (never a network wait), then a background cache
+    // refresh that completes while the session runs. Both fail soft.
+    await maybeNudgeAndRefresh({ current: cliVersion() });
     // 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();
@@ -68,6 +86,21 @@ async function runDefault(passthroughArgs) {
     catch {
         shadowPiDir = undefined;
     }
+    // Zero-config Claude Code compat: wire this repo's (and the user's)
+    // .claude/skills and .claude/commands into the agent, asking the one-time
+    // per-folder trust question when needed. Fail-soft: compat can only add
+    // flags, never block a launch.
+    let compat = { argv: [], env: {} };
+    try {
+        compat = await claudeCompatArgs({
+            cwd: process.cwd(),
+            agentDir: piAgentDir,
+            confirm: confirmOnTty,
+        });
+    }
+    catch {
+        compat = { argv: [], env: {} };
+    }
     // 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).
@@ -79,9 +112,13 @@ async function runDefault(passthroughArgs) {
             extensionPath: resolveExtensionPath(),
             agentDir: piAgentDir,
             piPackageDir: shadowPiDir,
+            extraAgentArgs: compat.argv,
+            extraEnv: compat.env,
             // 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),
+            stateDir: credentialsDir(),
+            cliVersion: cliVersion(),
             baseEnv: process.env,
         });
     }
@@ -110,17 +147,37 @@ 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.",
+    "  yagni [args…]            Launch the agent in the current repo.",
+    "  yagni -c                 Continue the most recent session.",
+    "  yagni -r                 Browse and resume a previous session.",
+    '  yagni -p "prompt"        Print one response and exit (reads piped stdin too).',
+    "  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 upgrade [x.y.z]    Upgrade the CLI to the latest (or a given) version.",
+    "  yagni version            Print the CLI version.",
+    "",
+    "Common agent flags (passed straight through):",
+    "  --model <tier>           Pick the model tier (balanced by default).",
+    "  --thinking <level>       off | minimal | low | medium | high | xhigh | max",
+    "  --session <id>           Open a specific session; --fork <id> branches one.",
+    "  --mode json              Emit machine-readable events (for scripts and CI).",
+    "",
+    "In a session:",
+    "  /name                    Runs this repo's .claude/commands/<name>.md template.",
+    "  /mode plan|review|auto   Hold writes for planning, or confirm each change.",
+    "  /todos                   Show the agent's live task list.",
+    "  /cost                    Session usage and credit headroom.",
     "",
     "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.",
+    "Set YAGNI_DISABLE_UPDATE_CHECK=1 to silence the new-version notice.",
+    "Set YAGNI_DISABLE_CLAUDE_COMPAT=1 to skip loading .claude assets.",
+    "Set YAGNI_DISABLE_BRANDING=1 to pass the system prompt through unmodified.",
+    "Set YAGNI_DISABLE_CRASH_REPORTS=1 to turn off sanitized crash reports.",
 ].join("\n");
 /** Parse `use <name> [--base-url <url>]` argv into its parts. */
 export function parseUseArgs(args) {
@@ -194,15 +251,9 @@ export function wantsHelp(argv) {
 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.
- */
+/** The CLI's own version (see `currentCliVersion` — upgrade.ts owns it). */
 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";
+    return currentCliVersion();
 }
 export async function main(argv) {
     const [command, ...rest] = argv;
@@ -232,6 +283,9 @@ export async function main(argv) {
     if (command === "doctor") {
         return runDoctor();
     }
+    if (command === "upgrade") {
+        return upgradeCommand(rest, { current: cliVersion() });
+    }
     if (command === "use") {
         return useCommand(rest);
     }
@@ -267,6 +321,11 @@ export function isEntrypoint(argv1, 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)) {
+    // Crash reporting for the LAUNCHER process only (pi runs as a child and the
+    // extension covers the session side). Fire-and-forget, sanitized, bounded;
+    // YAGNI_DISABLE_CRASH_REPORTS=1 turns it off. Registered before main() so a
+    // crash anywhere in the launcher is covered.
+    installProcessCrashHandlers({ client: "cli", clientVersion: cliVersion() });
     main(process.argv.slice(2))
         .then((code) => process.exit(code))
         .catch((err) => {

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 /** Shared CLI config: where the YAGNI backend lives + the environment presets. */
-export declare const DEFAULT_BASE_URL = "https://yagni.app";
+export declare const DEFAULT_BASE_URL: string;
 /**
  * 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

package/dist/config.js

@@ -1,5 +1,6 @@
 /** Shared CLI config: where the YAGNI backend lives + the environment presets. */
-export const DEFAULT_BASE_URL = "https://yagni.app";
+import { DISTRIBUTION } from "./distribution.js";
+export const DEFAULT_BASE_URL = DISTRIBUTION.defaultBaseUrl;
 /**
  * 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
@@ -8,7 +9,8 @@ export const DEFAULT_BASE_URL = "https://yagni.app";
  * (pass `--base-url`).
  */
 export const PRESET_BASE_URLS = {
-    prod: DEFAULT_BASE_URL,
+    prod: "https://yagni.app",
+    staging: "https://yagni-staging.app",
     local: "http://localhost:3456",
 };
 /** The base URL a named preset resolves to, or undefined for a custom name. */

package/dist/crashReport.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Crash reporting for the YAGNI Code launcher (and, via deep import, the
+ * desktop driver): a sanitized, fire-and-forget POST to the customer's own
+ * YAGNI backend at /api/yagni-code/crash. Deliberately no third-party
+ * telemetry SDK — crash reports are the ONLY thing this CLI phones home, they
+ * contain no code and no prompts, and `YAGNI_DISABLE_CRASH_REPORTS=1` turns
+ * them off entirely (same switch family as YAGNI_DISABLE_UPDATE_CHECK).
+ *
+ * Everything here is fail-soft: reporting never throws, never retries, never
+ * blocks longer than the short timeout, and never changes how the process
+ * would otherwise crash.
+ *
+ * The sanitizer core (scrub patterns + env-value redaction + path collapse +
+ * caps) is duplicated in `pi-extension-yagni/src/crashReport.ts` (the
+ * extension is bundled standalone and cannot import across packages) and
+ * re-run server-side in `backend/src/yagniCode/crashReports.ts`. Keep the
+ * three in sync. Spec:
+ * docs/superpowers/specs/2026-08-08-crash-reporting-design.md
+ */
+export declare const CRASH_REPORT_DISABLE_ENV = "YAGNI_DISABLE_CRASH_REPORTS";
+export declare const CRASH_REPORT_TIMEOUT_MS = 1500;
+/** Hard ceiling the process-exit path waits for a report before exiting. */
+export declare const CRASH_REPORT_EXIT_RACE_MS = 1600;
+export declare const MAX_CRASH_MESSAGE = 512;
+export declare const MAX_CRASH_ERROR_CLASS = 128;
+export declare const MAX_CRASH_STACK = 8000;
+export declare const MAX_CRASH_STACK_FRAMES = 40;
+/** If the serialized payload would exceed this, the stack is dropped. */
+export declare const MAX_CRASH_PAYLOAD_BYTES = 16384;
+/** Same truthiness rule as updateChecksDisabled: set and not "" / "0". */
+export declare function crashReportsDisabled(env?: NodeJS.ProcessEnv): boolean;
+export interface SanitizeCrashOptions {
+    /** Environment whose values get redacted (defaults to process.env). */
+    env?: NodeJS.ProcessEnv;
+    /** Repo root; paths under it become repo-relative instead of basenames. */
+    repoRoot?: string;
+}
+/**
+ * Sanitize one piece of crash text. Order matters:
+ *   1. env-value redaction (non-path values, length >= 8) → `[ENV:NAME]`
+ *   2. secret patterns (keys, connection strings, base64 blobs)
+ *   3. home-dir collapse to `~`
+ *   4. repo-root strip (repo files stay readable as relative paths)
+ *   5. every remaining absolute/`~` path → basename (node_modules kept from
+ *      `node_modules/` on, so dependency frames stay diagnosable)
+ * Over-redacts rather than under-redacts; pure; never throws.
+ */
+export declare function sanitizeCrashText(text: string, opts?: SanitizeCrashOptions): string;
+export interface SanitizedCrash {
+    errorClass: string;
+    message: string;
+    stack?: string;
+}
+/**
+ * Reduce an arbitrary thrown value to sanitized error facts. Reads ONLY
+ * `name`, `message`, and `stack` — custom fields (response bodies, request
+ * payloads…) are never touched.
+ */
+export declare function sanitizeCrashError(err: unknown, opts?: SanitizeCrashOptions): SanitizedCrash;
+export type CrashClient = "cli" | "desktop" | "desktop-driver";
+export interface CrashReportInput {
+    client: CrashClient;
+    clientVersion: string;
+    error: unknown;
+    /** Command/phase label, e.g. "uncaught-exception" or "go:implement". */
+    context?: string;
+    baseUrl: string;
+    token: string;
+    env?: NodeJS.ProcessEnv;
+    repoRoot?: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}
+/**
+ * Pre-extracted crash facts (e.g. relayed from the desktop webview or the
+ * Rust panic hook, where no live Error object crosses the boundary). Each
+ * text field is sanitized and capped before sending.
+ */
+export interface CrashFieldsInput {
+    client: CrashClient;
+    clientVersion: string;
+    errorClass: string;
+    message: string;
+    stack?: string;
+    context?: string;
+    baseUrl: string;
+    token: string;
+    env?: NodeJS.ProcessEnv;
+    repoRoot?: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}
+/**
+ * Sanitize + POST one crash report from pre-extracted fields. Resolves on
+ * every outcome — timeout, network error, non-2xx, disabled — and never
+ * throws; there is nobody upstream who could act on a failure, and a
+ * reporting bug must never re-crash the process.
+ */
+export declare function sendCrashReport(input: CrashFieldsInput): Promise<void>;
+/**
+ * Fire one crash report from a live thrown value. Same never-throws contract
+ * as {@link sendCrashReport}, which does the sending.
+ */
+export declare function reportCrash(input: CrashReportInput): Promise<void>;
+export interface InstallCrashHandlersOptions {
+    client: CrashClient;
+    clientVersion: string;
+    /** Credentials source; defaults to the active profile. Fail-soft. */
+    resolveTarget?: () => Promise<{
+        baseUrl: string;
+        token: string;
+    } | null>;
+    env?: NodeJS.ProcessEnv;
+    repoRoot?: string;
+    fetchImpl?: typeof fetch;
+    /** Ceiling on how long the exit path waits for the report. */
+    raceMs?: number;
+    /** Test seams. */
+    exit?: (code: number) => void;
+    writeStderr?: (text: string) => void;
+    proc?: Pick<NodeJS.Process, "on">;
+}
+/**
+ * The handler behind uncaughtException/unhandledRejection: report (bounded by
+ * `raceMs`), then preserve today's crash behavior — print the error to stderr
+ * and exit 1. Exposed for tests; `installProcessCrashHandlers` registers it.
+ */
+export declare function makeProcessCrashHandler(context: "uncaught-exception" | "unhandled-rejection", opts: InstallCrashHandlersOptions): (err: unknown) => void;
+/**
+ * Install process-level crash reporting. Call once, before main() runs, from
+ * a process YAGNI owns (the launcher, the desktop driver) — never from inside
+ * pi's process, where adding these listeners would change crash semantics.
+ */
+export declare function installProcessCrashHandlers(opts: InstallCrashHandlersOptions): void;
+//# sourceMappingURL=crashReport.d.ts.map