agent-shim 7.13.1 → 7.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-shim",
-  "version": "7.13.1",
+  "version": "7.14.0",
   "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   "license": "MIT",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",
@@ -74,6 +74,8 @@
     "jiti": "^2.7.0",
     "knip": "^6.35.1",
     "lint-staged": "^17.5.0",
+    "rollup": "4.64.0",
+    "rollup-plugin-dts": "6.5.1",
     "semantic-release": "^25.0.9",
     "turbo": "^2.10.12",
     "typescript": "^6.0.3",

package/dist/types/checkReport.d.ts

@@ -1,154 +0,0 @@
-import { type CategoryClassification, type CategoryClassificationOverlay, type Identity, type Provider } from "./config/schema";
-import { type CredentialSummary } from "./credential";
-import { type AmbientCredentialGuardResult } from "./launcher/guard";
-import type { ConfigProfileDecisionSource, IdentityDecisionSource } from "./launcher/identity";
-import type { FarmFs, RunPort } from "./launcher/ports";
-import type { LayoutPaths } from "./paths";
-import type { PoolPickReport } from "./poolPickReport";
-import { type EncodingAmbiguity } from "./resolve/projects";
-import { type ResolvedState } from "./resolve/pipeline";
-import type { CascadeInput } from "./resolve/walk";
-import type { Decision, EntryFacts, FlattenedCascade } from "./resolve/types";
-/**
- * Flags every `history/projects/` entries rule in scope whose encoded form could plausibly correspond to more than one real path.
- *
- * Reuses `src/resolve/projects.ts`'s own `detectEncodingAmbiguity` rather than reimplementing the detection — this function's whole job is recovering the as-written fragments from the flattened cascade's compiled rules and handing them to that function, plus the real project directory names already present in the fact manifest so the report can say how many a pattern actually matches today.
- */
-export declare function flagAmbiguousEncodings(flattened: FlattenedCascade, facts: EntryFacts): EncodingAmbiguity[];
-/** Renders one entry's resolved decision as a single explanatory line, for `agent-shim check`'s printout. */
-export declare function formatDecision(decision: Decision): string;
-/** The result of looking up the macOS Keychain service name Claude Code is actually using for one identity's farm. */
-export interface KeychainLookupResult {
-    readonly checked: true;
-    readonly found: boolean;
-    readonly serviceName?: string;
-    readonly note: string;
-}
-/**
- * Looks up the macOS Keychain entry Claude Code is using for one identity's configuration directory, via `security find-generic-password`, run through the injected `RunPort` so no test ever shells out for real.
- *
- * This is real OS state: the exact account/service naming Claude Code uses in the Keychain is empirically observed (per this project's README), not a documented contract, so genuinely exercising this against a real Keychain is a manual/integration check on a macOS runner, never something a unit test fakes convincingly — a unit test here can only prove that this function parses `security`'s own output shape correctly, not that the shape matches what a real installation produces.
- */
-export declare function lookupKeychainService(run: RunPort, farmRoot: string): KeychainLookupResult;
-/** One file's reported settings exposure: names and counts only, never the underlying values. */
-export interface SettingsExposureReport {
-    readonly file: string;
-    readonly envKeyNames: readonly string[];
-    readonly hookEventNames: readonly string[];
-    readonly hookCommandCount: number;
-}
-/** Inputs to `inspectSettingsExposure`. */
-export interface InspectSettingsExposureParams {
-    /** Whether the `settings` category resolves shared for this launch — the advisory only has anything to report when it does. */
-    readonly settingsShared: boolean;
-    /** Raw file contents keyed by filename (`settings.json`, `settings.local.json`), undefined when the file does not exist. */
-    readonly files: Readonly<Record<string, string | undefined>>;
-}
-/**
- * Reports how many `env` keys and `hooks` commands `settings.json`/`settings.local.json` would share, by name and count only — never a value, per the README's own warning that a hook command or an `env` entry there can easily hold a real secret with nothing in Claude Code's own documentation warning against it.
- *
- * Returns nothing at all when `settingsShared` is false, and nothing for a file whose `env`/`hooks` fields are both empty or absent — the whole point of this advisory is to be silent unless there is something worth a second look.
- */
-export declare function inspectSettingsExposure(params: InspectSettingsExposureParams): SettingsExposureReport[];
-/** The provider the cascade selects for this directory, as the wiring layer loaded it: its definition, or why it could not be used (no such provider, an invalid or old-format file). */
-type CheckProviderInput = {
-    readonly name: string;
-    readonly definition: Provider;
-    readonly problem?: never;
-} | {
-    readonly name: string;
-    readonly definition?: never;
-    readonly problem: string;
-};
-/**
- * Which credential a launch here would use, by source kind and target only: a selected provider's credential block always wins; otherwise the identity's own credential block; otherwise the login stored in the identity's directory.
- */
-interface CredentialReport {
-    readonly applies: "provider" | "identity" | "stored-login";
-    readonly provider?: {
-        readonly name: string;
-        readonly credential?: CredentialSummary;
-        readonly problem?: string;
-    };
-    readonly identity?: CredentialSummary;
-}
-/** Inputs to `runCheck` — everything already loaded/injected, exactly like the resolver core and the launcher: nothing in this function touches a real filesystem, git repository, clock, or environment itself. */
-export interface RunCheckParams {
-    readonly cwd: string;
-    readonly home: string;
-    readonly claudeHome: string;
-    readonly env: Readonly<Record<string, string | undefined>>;
-    readonly branch?: string;
-    readonly branchDetached?: boolean;
-    readonly nowMs: number;
-    /** Used only to build the fact manifest by reading the canonical `~/.claude` tree — `runCheck` never mutates the farm and never spawns anything. */
-    readonly farmFs: FarmFs;
-    readonly cascade: CascadeInput;
-    readonly classification: {
-        readonly defaults: CategoryClassification;
-        readonly overlay?: CategoryClassificationOverlay;
-    };
-    readonly identityName?: string;
-    readonly identitySource: IdentityDecisionSource;
-    /** The pool the launch selected and how it ranks right now, when it named a pool instead of an identity; `identityName` is then the member it would pick. */
-    readonly poolPick?: PoolPickReport;
-    readonly configProfileName?: string;
-    readonly configProfileSource: ConfigProfileDecisionSource;
-    /** The resolved identity's own `identity.json`, when one was found. */
-    readonly identity?: Identity;
-    /** Raw `settings.json`/`settings.local.json` contents, keyed by filename, undefined when a file does not exist. */
-    readonly settingsFiles: Readonly<Record<string, string | undefined>>;
-    /** Runs `security find-generic-password` for the Keychain diagnostic. Omit to skip that diagnostic entirely (e.g. off macOS, or when no identity/farm root is known). */
-    readonly run?: RunPort;
-    /** The identity's own farm root — `security`'s lookup account. Required alongside `run` for the Keychain diagnostic to run at all. */
-    readonly farmRoot?: string;
-    /** `process.platform` in real use; the Keychain diagnostic only ever runs when this is `"darwin"`. */
-    readonly platform: string;
-    /** The provider a launch here would route through (`launch.provider` in the cascade), when one is selected. */
-    readonly provider?: CheckProviderInput;
-}
-/** Everything `agent-shim check` reports about one directory/identity, without touching the farm or spawning anything. */
-export interface CheckReport {
-    readonly identityName?: string;
-    readonly identitySource: IdentityDecisionSource;
-    readonly poolPick?: PoolPickReport;
-    readonly configProfileName?: string;
-    readonly configProfileSource: ConfigProfileDecisionSource;
-    readonly resolved: ResolvedState;
-    readonly decisionLines: readonly string[];
-    readonly projectEncodingAmbiguities: readonly EncodingAmbiguity[];
-    readonly ambientCredential: AmbientCredentialGuardResult;
-    readonly keychain?: KeychainLookupResult;
-    readonly settingsExposure: readonly SettingsExposureReport[];
-    readonly credential: CredentialReport;
-}
-/**
- * Resolves the full cascade for one directory/identity and reports everything `agent-shim check` documents: every entry's resolved state and which layer/condition decided it, any ambiguous `history/projects/` encoding in scope, and the three always-on diagnostics (ambient-credential exposure, macOS Keychain service name, settings-secrets exposure).
- *
- * Deliberately reuses the same cascade machinery a real launch uses — `resolveDecisions` and `buildEntryFacts` — rather than reimplementing any part of resolution. The one thing this function never does that a launch does is touch the farm or spawn anything: it only reads the canonical `~/.claude` tree to build the fact manifest resolution needs, and every other input (cascade, classification, settings file contents, the Keychain lookup) is handed in already loaded.
- */
-export declare function runCheck(params: RunCheckParams): CheckReport;
-/** Renders a full `CheckReport` as plain text lines, in the order `agent-shim check` prints them. */
-export declare function formatCheckReport(report: CheckReport): string[];
-/**
- * The `check --json` form of a report: every field the text form prints, as plain data (no `Map`s, no compiled matchers), so a script can read the same verdicts a person would.
- */
-export declare function checkReportToJson(report: CheckReport): Record<string, unknown>;
-/**
- * Whether a report carries anything `check --strict` fails on: a resolver diagnostic of warning or error severity, an ambiguous `history/projects/` encoding, an ambient credential a launch would refuse, or a selected provider a launch could not use. Informational diagnostics and the settings-exposure advisory (names and counts only, for a person to review) never fail it.
- */
-export declare function checkReportHasWarnings(report: CheckReport): boolean;
-/** What `collectCheckReport` needs from its caller. */
-export interface CollectCheckReportParams {
-    readonly paths: LayoutPaths;
-    /** The directory a launch would run in; resolved against the working directory by the caller. */
-    readonly cwd: string;
-    /** The identity to check, as `--identity` names it; absent means the identity a launch there would resolve. */
-    readonly identity?: string;
-    readonly env: NodeJS.ProcessEnv;
-}
-/**
- * Resolves what a launch in `params.cwd` would share or hide, and why, against this machine: the edge adapter that reads the real filesystem, clock, git and keychain, resolves the identity, configuration profile and cascade exactly as a launch does, and hands the facts to the pure `runCheck`. Never touches the farm or spawns claude.
- */
-export declare function collectCheckReport(params: CollectCheckReportParams): CheckReport;
-export {};

package/dist/types/claudeShim.d.ts

@@ -1,114 +0,0 @@
-import type { Command } from "commander";
-import { z } from "zod";
-import { type CommandDeps } from "./cli/commandDeps";
-import { CliError } from "./cliError";
-import type { LayoutPaths } from "./paths";
-export declare const ClaudeShimStateSchema: z.ZodObject<{
-    targetPath: z.ZodString;
-    method: z.ZodEnum<{
-        copy: "copy";
-        hardlink: "hardlink";
-    }>;
-    installedAtMs: z.ZodNumber;
-}, z.core.$strict>;
-export type ClaudeShimState = z.infer<typeof ClaudeShimStateSchema>;
-/** Raised by enableClaudeShim/disableClaudeShim when the target path exists but doesn't look like agent-shim's own doing (no matching claude-shim.json marker, and not a hardlink of the currently-running executable) — refuses rather than silently clobbering or deleting something an installer never created. Bypassed by --force. */
-export declare class ForeignClaudeEntryError extends CliError {
-    readonly targetPath: string;
-    readonly action: "enable" | "disable";
-    constructor(targetPath: string, action: "enable" | "disable");
-}
-/** Raised by enableClaudeShim when the running executable cannot possibly be turned into a directly-runnable `claude` command: an npm/Node install of agent-shim on Windows, which has no bundled .exe and no shebang-based dispatch the way POSIX does. Not bypassed by --force — this isn't a safety refusal, it's "this would produce a broken file." */
-export declare class UnsupportedShimSourceError extends CliError {
-    readonly contentSourcePath: string;
-    constructor(contentSourcePath: string);
-}
-/**
- * The exact filename to create: `claude.exe` when the running executable is itself a `.exe` (Windows needs the extension to recognise it as directly executable at all), `claude` for every other case.
- *
- * Deliberately not "preserve whatever extension the source has" — an npm install's own file is `cli.cjs`, and a bare `claude` (not `claude.cjs`) is what makes it invocable as the expected command on POSIX, where a shebang plus the executable bit is what matters, not the filename's extension.
- */
-export declare function claudeTargetFilename(ownExecutablePath: string): string;
-/** The same rule generalised to any command name this tool owns, so `doctor`'s PATH-resolution check can ask "what filename would a bare `agent-shim` be" without restating the Windows `.exe` condition and letting the two drift apart. */
-export declare function commandFilename(ownExecutablePath: string, commandName: string): string;
-/**
- * `cli.ts`'s own name-dispatch check: is `invokedName` (the basename of however this binary was invoked) one of the two names `shim enable` ever creates, per `claudeTargetFilename` above? `path.basename` includes the file extension, so a bare `=== "claude"` comparison never matches the Windows case, where the file must be named `claude.exe` to be directly invocable at all.
- *
- * Confirmed as a real, previously-undetected bug against an actual Scoop install: the shim-placement and hardlink-source bugs fixed in prior releases had never let a Windows `claude.exe` invocation reach this far before, so this exact mismatch never surfaced until the shim itself finally worked end-to-end — invoking the newly-created `claude.exe` fell through to agent-shim's own CLI (printing its own `--version`) instead of the launcher.
- */
-export declare function isInvokedAsClaude(invokedName: string): boolean;
-/**
- * The directories `discoverClaudeBinary`'s PATH-fallback search must exclude to avoid recursively discovering/spawning this very tool: wherever the running executable itself lives, plus wherever `shim enable` last placed a `claude`-named copy, when that's a *different* directory (i.e. `--dir` was used). Without folding the recorded shim directory in here too, `agent-shim run`/`agent-shim doctor` would only exclude their own directory, not a `--dir`-placed shim living elsewhere on PATH.
- */
-export declare function resolveOwnInstallDirs(paths: LayoutPaths, ownExecutablePath: string): string[];
-/** Where `shim enable` places `claude` absent a --dir override: alongside the running executable. */
-export declare function resolveClaudeTargetPath(ownExecutablePath: string, dir?: string): string;
-/** The two low-level fs calls the hardlink-then-copy-fallback needs, matching `src/config/store.ts`'s own `StoreFs`/`nodeStoreFs`-with-a-real-default pattern — the one seam in this file that isn't plain `node:fs`, added so the EXDEV fallback branch gets real unit coverage without a genuine cross-filesystem test rig. */
-export interface LinkFs {
-    readonly link: (existingPath: string, newPath: string) => void;
-    readonly copyFile: (src: string, dest: string) => void;
-    readonly chmod: (target: string, mode: number) => void;
-}
-/** Inputs to `enableClaudeShim`. */
-export interface EnableShimParams {
-    readonly paths: LayoutPaths;
-    /** `realOwnExecutablePath()` (see realPorts.ts) — the PATH-visible location `claude` should be placed alongside, supplied by the wiring layer. Deliberately separate from `contentSourcePath` below: for a Scoop install, this is `~/scoop/shims/agent-shim.exe` (Scoop's own proxy binary, not agent-shim's real content), and using it as the link/copy source would hardlink that proxy instead of the genuine executable. */
-    readonly ownExecutablePath: string;
-    /** `realContentSourcePath()` (see realPorts.ts) — the actual file whose content is this running process, used as the hardlink/copy source and for "is the existing target mine" inode comparisons. */
-    readonly contentSourcePath: string;
-    /** process.platform, supplied by the wiring layer — only used for the Windows/npm-source guard. */
-    readonly platform: string;
-    readonly dir?: string;
-    readonly force: boolean;
-}
-type EnableShimAction = "enabled" | "reenabled";
-export interface EnableShimResult {
-    readonly action: EnableShimAction;
-    readonly targetPath: string;
-    readonly method: "hardlink" | "copy";
-}
-/**
- * Creates a `claude`-named hardlink (falling back to a copy on a cross-device filesystem) of the currently running `agent-shim` executable, so `claude @<name>` works directly instead of needing `agent-shim run`.
- *
- * A target that already exists is only ever overwritten when it's provably agent-shim's own doing — either it shares an inode with the currently-running executable (covers a pre-existing install from before this feature existed, where no marker could possibly exist yet), or claude-shim.json records this exact target path (covers refreshing after a agent-shim upgrade, when the old target's inode no longer matches the new binary's content). Anything else is refused unless `force` is set — this could otherwise silently delete or overwrite someone's genuine, unrelated `claude` binary.
- */
-export declare function enableClaudeShim(params: EnableShimParams, linkFs?: LinkFs): EnableShimResult;
-type DisableShimAction = "disabled" | "not-enabled";
-export interface DisableShimResult {
-    readonly action: DisableShimAction;
-    readonly targetPath: string;
-}
-export interface DisableShimParams {
-    readonly paths: LayoutPaths;
-    /** `realOwnExecutablePath()` — the PATH-visible location, used to derive the default target path. */
-    readonly ownExecutablePath: string;
-    /** `realContentSourcePath()` — used for the "is the existing target mine" inode comparison; see `EnableShimParams` for why this must be separate from `ownExecutablePath`. */
-    readonly contentSourcePath: string;
-    readonly dir?: string;
-    readonly force: boolean;
-}
-/** The inverse of `enableClaudeShim`: removes the `claude` command it created, using the same "is this ours" safety check. A no-op, not an error, when nothing is enabled — including clearing a dangling marker whose target has since been deleted by other means. */
-export declare function disableClaudeShim(params: DisableShimParams): DisableShimResult;
-export type PathShadowStatus = {
-    readonly status: "ok";
-} | {
-    readonly status: "not-on-path";
-} | {
-    readonly status: "shadowed";
-    readonly by: string;
-};
-export interface FindPathShadowParams {
-    readonly pathDirs: readonly string[];
-    readonly targetDir: string;
-    readonly targetFilename: string;
-    readonly findExecutableInDir: (dir: string, name: string) => string | undefined;
-}
-/** Would something else on PATH run before the just-enabled `claude`? Reuses the exact PATH-scan semantics `discoverClaudeBinary`'s own fallback already uses (via the injected `findExecutableInDir`), rather than shelling out to `command -v` — this answers a more directly relevant question ("would this tool's own binary discovery find this file first") without spawning a process at all. */
-export declare function findPathShadow(params: FindPathShadowParams): PathShadowStatus;
-/**
- * Registers `agent-shim shim enable`/`agent-shim shim disable` onto `program`.
- *
- * `shim` is a deliberate noun-group, matching `identity`/`profile`/`rule`: it names the actual mechanism (a PATH-level executable that dispatches by invoked name, the same concept Scoop itself calls a "shim"), so `enable`/`disable` read as toggling one clearly-scoped thing rather than "installing"/"uninstalling" software, which could be misread as installing Claude Code itself.
- */
-export declare function registerShimCommand(program: Command, deps: CommandDeps): void;
-export {};

package/dist/types/cli/bool.d.ts

@@ -1,8 +0,0 @@
-/**
- * The one boolean vocabulary every agent-shim input shares, CLI flag values and environment variables alike: `true` and `1` mean true, `false` and `0` mean false, and nothing else is a boolean (no case folding, no `yes`/`no`).
- *
- * Lives in a module with no imports so both `src/cli/parsers.ts` (which raises on anything else) and `src/cliError.ts` (which must never raise while reporting another failure) can share it without an import cycle.
- * @param input - The raw text.
- * @returns The boolean it spells, or undefined when it spells none.
- */
-export declare function parseBoolWord(input: string): boolean | undefined;

package/dist/types/cli/commandDeps.d.ts

@@ -1,39 +0,0 @@
-import type { Command } from "commander";
-import type { PromptsPort } from "../configure";
-import type { LayoutPaths } from "../paths";
-/**
- * What every `agent-shim` command's registration needs from `buildProgram`: where the config tree lives, the prompt surface, whether standard input is a terminal those prompts can run on, and how to end the process.
- *
- * `isInteractive` is a function rather than a snapshot so the real wiring reads `process.stdin.isTTY` at the moment a command runs, and a test can script both answers against the same program.
- */
-export interface CommandDeps {
-    readonly paths: LayoutPaths;
-    readonly prompts: PromptsPort;
-    readonly isInteractive: () => boolean;
-    /** Ends the process with `code` immediately. Only the long-running `__headroom-supervisor` and `__codex-supervisor` need it (a signal must terminate it, and its servers would otherwise keep the event loop alive); every other command sets `process.exitCode` or throws, so its output is never truncated. */
-    readonly exit: (code: number) => never;
-}
-/** Prints `value` as indented JSON on standard output: the one `--json` output format every `list`, `show`, `check`, `doctor` and `headroom status` command shares. */
-export declare function printJson(value: unknown): void;
-/** What a mutating command did, as the one object `--json` prints in place of its text output. */
-export interface MutationReport {
-    readonly action: "created" | "updated" | "removed" | "selected";
-    /** The noun the command works on: `identity`, `profile`, `provider`, `pool` or `rule`. */
-    readonly kind: string;
-    readonly name: string;
-    /** The stored object after the change; absent for a removal and for a selection. */
-    readonly value?: unknown;
-}
-/** Reports a mutating command's outcome: the `MutationReport` as JSON under `--json`, otherwise whatever `printText` prints. */
-export declare function reportMutation(json: boolean | undefined, report: MutationReport, printText: () => void): void;
-/**
- * Appends an `Examples:` block to `command`'s help output, one `$ agent-shim ...` line per entry. Every command registers at least one, so `--help` on any of them shows a runnable invocation, not just its option list.
- */
-export declare function withExamples(command: Command, examples: readonly string[]): Command;
-/**
- * The confirmation every destructive `remove` verb shares. `--yes` skips it; otherwise a terminal gets a yes/no prompt (declining throws `PromptCancelledError`), and a non-terminal throws `MissingInputError` naming `--yes`, since deleting without either would be a silent destructive default.
- * @param deps - The prompt surface and terminal check.
- * @param yes - Whether `--yes` was passed.
- * @param description - What would be removed, phrased to follow "Remove ", e.g. `identity "work" and its directory`.
- */
-export declare function confirmRemoval(deps: CommandDeps, yes: boolean | undefined, description: string): Promise<void>;

package/dist/types/cli/envBool.d.ts

@@ -1,11 +0,0 @@
-import { UsageError } from "../cliError";
-/** Raised when a boolean environment variable holds something outside the shared vocabulary. */
-export declare class InvalidEnvBoolError extends UsageError {
-    readonly variable: string;
-    readonly value: string;
-    constructor(variable: string, value: string);
-}
-/**
- * Reads a boolean environment variable with the same vocabulary a CLI flag value uses. Unset and the empty string both mean "not given" (undefined), consistent with how every other agent-shim environment variable treats the empty string; anything outside the vocabulary throws `InvalidEnvBoolError` rather than silently reading as false.
- */
-export declare function parseEnvBool(variable: string, value: string | undefined): boolean | undefined;

package/dist/types/cli/pairs.d.ts

@@ -1,19 +0,0 @@
-/** One `<key>=<value>` pair, as parsed by `parsePair`. */
-export interface ParsedPair {
-    readonly key: string;
-    readonly value: string;
-}
-/**
- * Splits `input` on its *first* `=` into a key and a value. The value may itself contain further `=` characters (they stay part of the value); only the first `=` is treated as the separator.
- *
- * Throws when there is no `=` at all, or when the key half is empty (`=true`, or a leading `=`).
- */
-export declare function parsePair(input: string): ParsedPair;
-/** Parses `input` as a boolean in the shared vocabulary (`true`/`1`, `false`/`0`); throws on anything else. */
-export declare function parseBool(input: string): boolean;
-/**
- * Parses a comma-separated list of `<key>=<bool>` pairs into a plain object, e.g. `"history=true,knowledge=false"` becomes `{ history: true, knowledge: false }`. Used only for the list-valued environment variables; flags repeat instead.
- *
- * An empty string parses to `{}`. A key repeated within the same list is not an error: the later occurrence wins, matching how a plain object literal with a repeated key behaves.
- */
-export declare function parseBoolPairList(input: string): Record<string, boolean>;

package/dist/types/cliError.d.ts

@@ -1,27 +0,0 @@
-/** Exit status for every expected failure that is not a usage error: a missing identity, an invalid config file, a refused launch. */
-export declare const EXIT_FAILURE = 1;
-/** Exit status for a usage error: an unknown command or option, a malformed flag value, or required input missing with no terminal to prompt on. */
-export declare const EXIT_USAGE = 2;
-/**
- * Base class for every error this CLI throws to represent an expected, user-facing failure: bad input, a missing identity/profile/rule, a malformed config file. `reportFatalError` prints this class as `agent-shim: <message>` with no stack trace and exits with `exitCode`; anything that does not extend it is an unexpected bug, reported by message alone unless `AGENT_SHIM_DEBUG` asks for the stack.
- */
-export declare abstract class CliError extends Error {
-    /** The process exit status this failure maps to. `EXIT_FAILURE` unless a subclass says otherwise. */
-    readonly exitCode: number;
-}
-/** A usage error: the command line itself is wrong or incomplete. Exits `EXIT_USAGE`. */
-export declare class UsageError extends CliError {
-    readonly exitCode: number;
-    constructor(message: string);
-}
-/**
- * Raised when a command needs input it would prompt for on a terminal, but standard input is not one. Names the option (or argument) that supplies the input non-interactively, so a script's failure says exactly what to add.
- */
-export declare class MissingInputError extends UsageError {
-    readonly option: string;
-    constructor(option: string, what: string);
-}
-/** Raised when the user cancels an interactive prompt that a command cannot continue without. */
-export declare class PromptCancelledError extends CliError {
-    constructor();
-}

package/dist/types/codex/http.d.ts

@@ -1,15 +0,0 @@
-/** The HTTP statuses the codex route and its listener answer with, named so every use says what it means. */
-export declare const HTTP_STATUS: {
-    readonly ok: 200;
-    readonly badRequest: 400;
-    readonly unauthorized: 401;
-    readonly forbidden: 403;
-    readonly notFound: 404;
-    readonly methodNotAllowed: 405;
-    readonly payloadTooLarge: 413;
-    readonly tooManyRequests: 429;
-    /** Not sent to anyone: the client is gone. Recorded for a response abandoned because the client disconnected, following the convention nginx uses for the same case. */
-    readonly clientClosedRequest: 499;
-    readonly internalServerError: 500;
-    readonly badGateway: 502;
-};

package/dist/types/config/classify.d.ts

@@ -1,49 +0,0 @@
-import { type CategoryClassification, type CategoryClassificationOverlay, type CategoryName } from "./schema";
-import type { LayoutPaths } from "../paths";
-/** Which map a classification pattern came from. A `local` pattern is an answer the user gave to an "unclassified entry" prompt; a `default` pattern is shipped with the tool. */
-type ClassificationSource = "default" | "local";
-/** One compiled classification pattern: which category it assigns, where it came from, and how specific it is. */
-export interface ClassificationPattern {
-    readonly pattern: string;
-    readonly category: CategoryName;
-    readonly source: ClassificationSource;
-    /** True when the pattern contains no glob metacharacter, so it can only ever match one literal name. */
-    readonly isExact: boolean;
-    /** Position of the pattern within its own category list, used only as the final deterministic tie-break. */
-    readonly ordinal: number;
-    readonly matches: (name: string) => boolean;
-}
-/** The outcome of classifying a set of real top-level `~/.claude` entry names. */
-export interface ClassifyResult {
-    /** Every input name mapped to its category, or to null when nothing in either map recognises it. */
-    readonly classification: ReadonlyMap<string, CategoryName | null>;
-    /** The input names that nothing recognised, in input order. These are the names `agent-shim configure` prompts about. */
-    readonly unclassified: readonly string[];
-    /** For each classified name, the pattern that decided it — used by `agent-shim check` to explain a classification. */
-    readonly decidedBy: ReadonlyMap<string, ClassificationPattern>;
-}
-/** True when `pattern` contains no glob metacharacter, so it matches exactly one literal name. */
-export declare function isExactPattern(pattern: string): boolean;
-/** Compiles a shipped classification map plus an optional local overlay into one flat, ranked pattern list. */
-export declare function compileClassificationPatterns(defaults: CategoryClassification, overlay?: CategoryClassificationOverlay): ClassificationPattern[];
-/** The classification input every real call site needs: the shipped defaults plus this user's own local overlay, when one exists. */
-export interface LoadedClassification {
-    readonly defaults: CategoryClassification;
-    readonly overlay?: CategoryClassificationOverlay;
-}
-/**
- * Loads the classification input `classifyEntries` needs — the shipped `categories.default.json`, plus `categories.local.json` when the user has answered at least one "unclassified entry" prompt.
- *
- * Real-wired convenience over reading and validating the two files. Every command that classifies anything (`cli.ts`'s farm runtime, `check`, `configure`, `identity resolve-conflicts`) was independently repeating this exact pair of `readJson`/`.parse()` calls before this existed; centralising it here means the four command files stay thin call sites rather than each holding its own copy of a validation step that never varies between them.
- */
-export declare function loadClassification(paths: LayoutPaths): LoadedClassification;
-/**
- * Classifies a list of real top-level `~/.claude` entry names against the shipped category map plus an optional local overlay.
- *
- * An unrecognised name maps to `null` rather than being silently assumed safe or silently dropped: the resolver treats it as not-shared and reports it, and `agent-shim configure` prompts for an answer that is then written to the local overlay.
- */
-export declare function classifyEntries(names: readonly string[], options: {
-    defaults: CategoryClassification;
-    overlay?: CategoryClassificationOverlay;
-}): ClassifyResult;
-export {};

package/dist/types/config/load.d.ts

@@ -1,42 +0,0 @@
-import { type PublicExplorerSync } from "cosmiconfig";
-import type { z } from "zod";
-import { CliError } from "../cliError";
-/**
- * A configuration file that has been read, parsed, and validated.
- *
- * `entryOrder` and `ruleEntryOrders` capture each `entries` object's own key insertion order as an explicit ordinal array, taken from the *raw* parsed value before Zod ever sees it. This is not paranoia about JSON key ordering: `schema.parse()` returns a fresh deep clone, and relying on key order implicitly surviving that clone would make the resolver's same-layer source-order tie-break depend on an implementation detail of a third-party library. Capturing it explicitly at load time makes it data.
- */
-export interface LoadedFile<T> {
-    readonly filepath: string;
-    readonly config: T;
-    /** Key insertion order of the file's own top-level `entries` object; empty when the file has none. */
-    readonly entryOrder: readonly string[];
-    /** For a directory-rules file: the key insertion order of each rule's `entries` object, indexed the same as `rules[]`. Empty for every other file shape. */
-    readonly ruleEntryOrders: readonly (readonly string[])[];
-}
-/**
- * Builds the cosmiconfig explorer used for every read.
- *
- * Only `load(filepath)` is ever called on it — never `search()`. `search()` stops at the first config file found while walking upward, and this design needs the exact opposite: every ancestor collected, shallowest-first. `src/resolve/walk.ts` does its own directory walk and this module loads each level it visits, so cosmiconfig contributes its format flexibility (JSON, YAML, JS) without its traversal semantics.
- */
-export declare function createExplorer(moduleName?: string): PublicExplorerSync;
-/** Reads the key insertion order of `value.entries`, when `value` is an object carrying an `entries` object. */
-export declare function captureEntryOrder(value: unknown): readonly string[];
-/** Reads the per-rule key insertion order of a directory-rules file's `rules[].entries` objects. */
-export declare function captureRuleEntryOrders(value: unknown): readonly (readonly string[])[];
-/** Raised when a config file exists but fails Zod validation, so the caller can report the offending path alongside the issue list. */
-export declare class ConfigValidationError extends CliError {
-    readonly filepath: string;
-    readonly issues: readonly z.core.$ZodIssue[];
-    constructor(filepath: string, issues: readonly z.core.$ZodIssue[]);
-}
-/** Injected reader for a single config file, so tests never touch a real filesystem. Returns undefined when the file does not exist. */
-export type ConfigFileReader = (filepath: string) => unknown;
-/** A cosmiconfig-backed reader: loads and parses one file by path, returning undefined when it is missing or empty. */
-export declare function cosmiconfigReader(explorer?: Readonly<PublicExplorerSync>): ConfigFileReader;
-/**
- * Loads one config file by exact path, validates it against `schema`, and captures its entries key order.
- *
- * Returns undefined when the file does not exist or is empty. Throws ConfigValidationError when it exists but does not validate — a malformed config is never silently ignored or half-applied.
- */
-export declare function loadConfigFile<S extends z.ZodType>(filepath: string, schema: S, read?: ConfigFileReader): LoadedFile<z.infer<S>> | undefined;