claude-use 6.2.2 → 7.1.0

package/dist/types/headroom/supervisor.d.ts

@@ -50,6 +50,8 @@ export interface SupervisorPorts {
     };
     /** The installed `headroom --version` output, or undefined when the binary is not on PATH. */
     readonly headroomVersion: () => string | undefined;
+    /** The commit the installed headroom was built from, as the install itself records it (`direct_url.json`), or undefined when it was not installed from a git source. */
+    readonly installedCommit: () => string | undefined;
     readonly log: (line: string) => void;
 }
 /** First retry delay after a failed start. Half a second keeps a transient blip invisible to the next launch. */

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * The library surface of claude-use: the pure, port-injected parts other tools can call in-process instead of shelling out to the CLI. Four groups, none of which imports interactive prompting or argument parsing:
+ * The library surface of agent-shim: the pure, port-injected parts other tools can call in-process instead of shelling out to the CLI. Four groups, none of which imports interactive prompting or argument parsing:
  *
  * - identity and configuration-profile resolution and farm sync (`resolveDecisions`, `resyncFarm`, `buildEntryFacts`, ...), pure over facts and ports passed in;
  * - routing: the front door's Remote-Control-preserving, capability-authenticated CONNECT surface and its certificate authority, the front-door supervisor and ensure lifecycle, and the headroom supervisor and ensure lifecycle, each pure over its injected ports;

package/dist/types/launcher/farm.d.ts

@@ -4,8 +4,8 @@ import { type ResolvedState } from "../resolve/pipeline";
 import type { CascadeInput } from "../resolve/walk";
 import type { Diagnostic, EntryFacts } from "../resolve/types";
 import type { FarmFs } from "./ports";
-/** The manifest file each farm carries at its own root, recording what that resync built. Named distinctly from anything Claude Code itself writes into a config directory. */
-export declare const FARM_MANIFEST_FILENAME = ".claude-use-farm.json";
+/** The manifest file each farm carries at its own root, recording what that resync built. Named distinctly from anything Claude Code itself writes into a config directory. A farm built under the former name carries `LEGACY_FARM_MANIFEST_FILENAME` instead, which is read as a fallback and never carried into the next farm, whose resync writes this name. */
+export declare const FARM_MANIFEST_FILENAME = ".agent-shim-farm.json";
 /** Reads and validates the manifest at a farm root, or undefined when it is missing, unparseable, or does not validate. */
 export declare function readFarmManifest(fs: FarmFs, farmRoot: string): FarmManifest | undefined;
 /** Everything `buildEntryFacts` needs. Everything except the tree itself is injected, so the fact manifest is reproducible from a fake filesystem, a fake clock, and a fake branch. */
@@ -60,7 +60,7 @@ export interface CarryOverResult {
  *
  * One category is not ambiguous, though: `runtime`'s own definition (see `config/categories.default.json`'s category table in the README) is specifically "live per-process or per-machine artifacts" — daemon locks, an MCP auth-needed cache, an update-check result — that make no sense being preserved across a swap at all, let alone fought over. When `classification` is given, a colliding name whose category resolves to `runtime` is discarded from the superseded copy and left exactly as the new farm already has it, with no data ever moved: `keep-new` is not a judgement call for this category, it is what the category already means. This needs only the name's *static* classification, never the resolved shared/not-shared decision for the current directory — a `runtime` entry is disposable whether or not this identity currently chooses to share it, so no cascade resolution is needed to make the call.
  *
- * Exported so `launcher/farmResolve.ts` can reuse this exact collision detection (and the same `runtime` auto-resolution) for `claude-use identity resolve-conflicts`'s interactive pass, rather than a second implementation that could drift from this one.
+ * Exported so `launcher/farmResolve.ts` can reuse this exact collision detection (and the same `runtime` auto-resolution) for `agent-shim identity resolve-conflicts`'s interactive pass, rather than a second implementation that could drift from this one.
  */
 export declare function carryOver(params: CarryOverParams): CarryOverResult;
 /** What recovery found and did. */
@@ -101,10 +101,10 @@ export declare function recoverFarm(params: RecoverFarmParams): RecoveryResult;
 /** Inputs to `resyncFarm`. */
 export interface ResyncFarmParams {
     readonly fs: FarmFs;
-    /** `~/.claude-use/identities` — the farm root's parent, and where the lock, scratch trees, and superseded farms all live. */
+    /** `~/.agent-shim/identities` — the farm root's parent, and where the lock, scratch trees, and superseded farms all live. */
     readonly identitiesDir: string;
     readonly identity: string;
-    /** The configuration profile this launch resolved to, recorded in the manifest for `claude-use check`. */
+    /** The configuration profile this launch resolved to, recorded in the manifest for `agent-shim check`. */
     readonly configProfile?: string;
     /** The canonical `~/.claude` every farm symlink points back into. */
     readonly claudeHome: string;

package/dist/types/launcher/guard.d.ts

@@ -18,7 +18,7 @@ export interface InjectedCredential {
  *
  * An empty string counts as unset, not set — confirmed load-bearing: one of Joe's real wrapper scripts (`o`, running Claude Code against OpenRouter) does `export ANTHROPIC_API_KEY=""` specifically to *clear* it so `ANTHROPIC_AUTH_TOKEN` takes effect instead, and this must never trip the guard.
  *
- * `injected`, when given, is the credential this launch exports for its own identity. Its variable holding exactly that value is not ambient: it is what a claude-use launch of the same identity left in the environment of the session this one starts from (a `claude @work` run inside a `claude @work` session). The same variable holding any other value still counts.
+ * `injected`, when given, is the credential this launch exports for its own identity. Its variable holding exactly that value is not ambient: it is what a agent-shim launch of the same identity left in the environment of the session this one starts from (a `claude @work` run inside a `claude @work` session). The same variable holding any other value still counts.
  */
 export declare function detectAmbientCredential(env: Readonly<Record<string, string | undefined>>, injected?: InjectedCredential): AmbientCredentialDetection | undefined;
 /**
@@ -30,7 +30,7 @@ export interface EvaluateAmbientCredentialGuardParams {
     readonly env: Readonly<Record<string, string | undefined>>;
     /** The active identity's own `allowAmbientCredential` setting from its `identity.json`, or false when no identity is known. */
     readonly allowAmbientCredential: boolean;
-    /** True when `CLAUDE_USE_ALLOW_AMBIENT_CREDENTIAL=1` is set for this one invocation. */
+    /** True when `AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL=1` is set for this one invocation. */
     readonly allowAmbientCredentialOverride: boolean;
     /** The active identity's name, for the message's persistent-opt-in command. Undefined when no identity is known. */
     readonly identityName?: string;
@@ -50,7 +50,7 @@ export type AmbientCredentialGuardResult = {
     readonly message: string;
 };
 /**
- * Evaluates the ambient-credential guard: refuses unless no guarded variable is set, or the active identity opted in (`allowAmbientCredential: true`), or this one invocation opted in (`CLAUDE_USE_ALLOW_AMBIENT_CREDENTIAL=1`), or a provider takes over the child's credential (see `providerSelected`).
+ * Evaluates the ambient-credential guard: refuses unless no guarded variable is set, or the active identity opted in (`allowAmbientCredential: true`), or this one invocation opted in (`AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL=1`), or a provider takes over the child's credential (see `providerSelected`).
  *
  * This guard is about credential isolation, not identity/config-dir selection — it must still run even when the `CLAUDE_CONFIG_DIR`-already-set escape hatch applies (callers pass `allowAmbientCredential: false` and no `identityName` in that case, since there is no active identity to consult).
  */

package/dist/types/launcher/lock.d.ts

@@ -16,7 +16,7 @@ export declare class IdentityLockBusyError extends CliError {
 /** Everything `acquireIdentityLock` needs, all of it injected so a test never sleeps for real, never reads a real pid table, and never writes outside its own fake filesystem. */
 export interface AcquireIdentityLockParams {
     readonly identity: string;
-    /** The directory the lock file lives in — `~/.claude-use/identities`, alongside (never inside) the farm the lock protects, so a farm swap can rename the farm root out from under itself without disturbing the lock. */
+    /** The directory the lock file lives in — `~/.agent-shim/identities`, alongside (never inside) the farm the lock protects, so a farm swap can rename the farm root out from under itself without disturbing the lock. */
     readonly dir: string;
     readonly fs: FarmFs;
     readonly nowMs: () => number;

package/dist/types/launcher/ports.d.ts

@@ -19,7 +19,7 @@ export interface FarmStat {
     readonly sizeBytes: number;
 }
 /**
- * Every filesystem operation the farm resync performs, injected so the whole of `src/launcher/farm.ts` — symlink creation, materialisation, adoption copies, and the atomic swap itself — runs against an in-memory fake in tests and never against a real `~/.claude` or `~/.claude-use`.
+ * Every filesystem operation the farm resync performs, injected so the whole of `src/launcher/farm.ts` — symlink creation, materialisation, adoption copies, and the atomic swap itself — runs against an in-memory fake in tests and never against a real `~/.claude` or `~/.agent-shim`.
  *
  * `lstat` never follows symlinks: a `~/.claude` that contains a directory symlink escaping the tree (a skills directory linked out to a separate dotfiles repository, say) must be recorded as one symlink entry rather than recursed into, both to keep the fact manifest finite and because the farm links such an entry at `<claudeHome>/<rel>` and lets the OS resolve the remaining hops.
  */
@@ -82,7 +82,7 @@ export interface RunPort {
 /**
  * The running process itself: its environment, its logical argv, and the ability to terminate with an exit code.
  *
- * `argv` is the *logical* CLI arguments only — whatever the user typed after `claude`/`claude-use`, already stripped of the Node executable path and the script path (`process.argv.slice(2)` in the real implementation). `exit` mirrors `process.exit`'s own `never` return type: a real process never returns from it, and a test fake enforces the same shape by throwing a marker so control flow unwinds the same way in both cases.
+ * `argv` is the *logical* CLI arguments only — whatever the user typed after `claude`/`agent-shim`, already stripped of the Node executable path and the script path (`process.argv.slice(2)` in the real implementation). `exit` mirrors `process.exit`'s own `never` return type: a real process never returns from it, and a test fake enforces the same shape by throwing a marker so control flow unwinds the same way in both cases.
  */
 export interface ProcPort {
     readonly env: Readonly<Record<string, string | undefined>>;
@@ -125,7 +125,7 @@ export interface FrontDoorUp {
     readonly port: number;
     /** The loopback port the CONNECT surface listens on: what an OAuth launch points HTTPS_PROXY at. */
     readonly connectPort: number;
-    /** The CA bundle every routed child points NODE_EXTRA_CA_CERTS at: claude-use's CA (which signs both the provider listener's leaf and the CONNECT surface's), plus whatever the parent environment already trusted that way. */
+    /** The CA bundle every routed child points NODE_EXTRA_CA_CERTS at: agent-shim's CA (which signs both the provider listener's leaf and the CONNECT surface's), plus whatever the parent environment already trusted that way. */
     readonly trustBundlePath: string;
     /** Why the trust bundle dropped something the parent environment named, when it did; the launcher logs it. */
     readonly trustWarning?: string;

package/dist/types/legacy.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Everything agent-shim still honours from its former name, `claude-use`, so an installation, a committed project config or an exported environment written for the old name keeps working. Nothing here is consulted when the current name's equivalent is present: a current name always wins, and the legacy form is only a fallback that `agent-shim doctor` reports so it can be retired.
+ */
+/** Prefix of every environment variable agent-shim reads. */
+export declare const ENV_PREFIX = "AGENT_SHIM_";
+/** The former prefix, still accepted wherever `ENV_PREFIX` is. */
+export declare const LEGACY_ENV_PREFIX = "CLAUDE_USE_";
+/** The state root directory name under the home directory. */
+export declare const HOME_DIRNAME = ".agent-shim";
+/**
+ * The former state root directory name. It is adopted in place rather than moved: macOS Claude Code keys each identity's Keychain login on the exact `CLAUDE_CONFIG_DIR` string (`<root>/identities/<name>`), so relocating the root would sign every identity out.
+ */
+export declare const LEGACY_HOME_DIRNAME = ".claude-use";
+/** Former committed and per-clone portable config file names. */
+export declare const LEGACY_PORTABLE_CONFIG_FILENAME = ".claude-use.json";
+export declare const LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME = ".claude-use.local.json";
+/** The former farm manifest file name, read when a farm built by an older release has no current one. */
+export declare const LEGACY_FARM_MANIFEST_FILENAME = ".claude-use-farm.json";
+/** The former executable name, still installed beside the current one and still dispatched to the same program. */
+export declare const LEGACY_COMMAND_NAME = "claude-use";
+/**
+ * Copies every `CLAUDE_USE_*` variable in `env` to its `AGENT_SHIM_*` name unless that name is already set, mutating `env`. Returns the legacy names that supplied a value, in sorted order. An empty current value counts as set, so exporting `AGENT_SHIM_X=` still overrides a stale `CLAUDE_USE_X`.
+ */
+export declare function aliasLegacyEnv(env: NodeJS.ProcessEnv): string[];

package/dist/types/paths.d.ts

@@ -1,10 +1,10 @@
 /**
- * The resolved set of paths claude-use reads and writes under its own root.
+ * The resolved set of paths agent-shim reads and writes under its own root.
  *
- * `root` is always CLAUDE_USE_HOME when that environment variable is set (used by every test in this project, and by any real installation that wants to relocate its state), falling back to `~/.claude-use` only when the variable is unset. Every other field is derived from `root` so there is exactly one place a path can go wrong.
+ * `root` is always AGENT_SHIM_HOME when that environment variable is set (used by every test in this project, and by any real installation that wants to relocate its state), falling back to `~/.agent-shim` (or the former `~/.claude-use`, see `resolveAgentShimHome`) only when the variable is unset. Every other field is derived from `root` so there is exactly one place a path can go wrong.
  */
 export interface LayoutPaths {
-    /** The resolved root directory — CLAUDE_USE_HOME, or ~/.claude-use when unset. */
+    /** The resolved root directory, see `resolveAgentShimHome`. */
     readonly root: string;
     /** Directory holding one subdirectory per identity (symlink farm + local credentials/daemon state). */
     readonly identitiesDir: string;
@@ -14,13 +14,13 @@ export interface LayoutPaths {
     readonly providersDir: string;
     /** Path to the directory-rules.json file describing directory-scoped identity/profile pins. */
     readonly directoryRulesFile: string;
-    /** Path to the persisted active-identity file (the identity `claude-use identity use` selected). */
+    /** Path to the persisted active-identity file (the identity `agent-shim identity use` selected). */
     readonly activeIdentityFile: string;
     /** Path to the global config.json (user-global override layer, and default profile/walk-limit settings). */
     readonly globalConfigFile: string;
     /** Path to the categories.local.json overlay recording answers to "unclassified entry" prompts. */
     readonly categoriesLocalFile: string;
-    /** Path to the claude-shim.json marker recording where `claude-use shim enable` last placed a `claude`-named copy of this executable, and how. */
+    /** Path to the claude-shim.json marker recording where `agent-shim shim enable` last placed a `claude`-named copy of this executable, and how. */
     readonly claudeShimFile: string;
     /** Directory holding the headroom daemon's coordination state: state.json, the start lock, and the session registry. */
     readonly headroomDir: string;
@@ -62,16 +62,18 @@ export interface LayoutPaths {
     readonly usagePicksFile: string;
 }
 /**
- * Resolves the current CLAUDE_USE_HOME root: the environment variable when set to a non-empty string, otherwise `~/.claude-use`. An empty string counts as unset, consistent with how this project treats empty-string environment variables elsewhere (see the ambient-credential guard).
+ * Resolves the state root: `AGENT_SHIM_HOME` when set to a non-empty string (an empty string counts as unset, consistent with how this project treats empty-string environment variables elsewhere, see the ambient-credential guard), otherwise `~/.agent-shim`, or the former `~/.claude-use` when only that exists.
+ *
+ * The former root is used where it stands, never moved: macOS Claude Code names each identity's Keychain entry after a hash of its exact `CLAUDE_CONFIG_DIR`, so any relocation would sign every identity out. A fresh installation, or one that already has `~/.agent-shim`, uses the current name.
  */
-export declare function resolveClaudeUseHome(): string;
+export declare function resolveAgentShimHome(env?: NodeJS.ProcessEnv, home?: string, isDirectory?: (candidate: string) => boolean): string;
 /**
- * Resolves the canonical `~/.claude` directory every farm symlink points back into: `CLAUDE_USE_CLAUDE_HOME` when set to a non-empty string, otherwise `~/.claude`.
+ * Resolves the canonical `~/.claude` directory every farm symlink points back into: `AGENT_SHIM_CLAUDE_HOME` when set to a non-empty string, otherwise `~/.claude`.
  *
- * The override exists for the same reason `CLAUDE_USE_HOME` does. Exercising a real resync end to end means building and swapping real directories, and doing that against a real, in-use `~/.claude` to find out whether the code is correct is not an acceptable way to find out. Pointing both variables at throwaway directories makes a full end-to-end run safe.
+ * The override exists for the same reason `AGENT_SHIM_HOME` does. Exercising a real resync end to end means building and swapping real directories, and doing that against a real, in-use `~/.claude` to find out whether the code is correct is not an acceptable way to find out. Pointing both variables at throwaway directories makes a full end-to-end run safe.
  */
 export declare function resolveClaudeHome(): string;
 /** Builds the full LayoutPaths structure from a given root directory. */
 export declare function buildLayoutPaths(root: string): LayoutPaths;
-/** Resolves CLAUDE_USE_HOME and builds the full LayoutPaths structure in one call. */
+/** Resolves AGENT_SHIM_HOME and builds the full LayoutPaths structure in one call. */
 export declare function resolveLayoutPaths(): LayoutPaths;

package/dist/types/resolve/conditions.d.ts

@@ -28,7 +28,7 @@ export declare function matchBranch(pattern: string, branch: string | undefined,
 /**
  * Evaluates a `when` object. Every present field must hold — conditions AND together within one object.
  *
- * An absent condition is vacuously true, so `when: {}` passes; `claude-use check` warns about that rather than erroring, since an empty object is more likely a half-finished edit than an intentional statement.
+ * An absent condition is vacuously true, so `when: {}` passes; `agent-shim check` warns about that rather than erroring, since an empty object is more likely a half-finished edit than an intentional statement.
  *
  * `newerThan`, `olderThan`, and `maxSizeBytes` read the subtree-aggregated facts (`latestMtimeMs`, `totalSizeBytes`), never the entry's own inode stat: a directory's own mtime does not change when a file three levels beneath it is rewritten, and its own size is a ~4KB inode figure that says nothing about what it contains.
  */

package/dist/types/resolve/match.d.ts

@@ -46,7 +46,7 @@ export declare function patternCouldReachUnder(canonicalPattern: string, dir: st
  *
  * The order, exactly:
  *
- * 1. **Different layers — the later layer wins, period.** This rank sits deliberately *above* exactness. Ranking exactness first would let an untrusted committed `.claude-use.json`'s exact key beat your own later, personal glob override, breaking the design's stated trust property that a directory-scoped local rule can only ever tighten what a committed file opened, never the reverse. Nothing in the design asserts that an earlier exact key beats a later glob, so nothing is lost by closing that hole.
+ * 1. **Different layers — the later layer wins, period.** This rank sits deliberately *above* exactness. Ranking exactness first would let an untrusted committed `.agent-shim.json`'s exact key beat your own later, personal glob override, breaking the design's stated trust property that a directory-scoped local rule can only ever tighten what a committed file opened, never the reverse. Nothing in the design asserts that an earlier exact key beats a later glob, so nothing is lost by closing that hole.
  * 2. Same layer: an exact literal beats a glob.
  * 3. Same layer: the longer literal prefix wins.
  * 4. Same layer: more path segments wins, which separates a one-wildcard pattern from a two-wildcard one at the same depth.

package/dist/types/resolve/reconcile.d.ts

@@ -35,7 +35,7 @@ export type ReconcileAction =
     readonly kind: "adopt-conflict";
     readonly rel: string;
 }
-/** Nothing to do, with the reason recorded so `claude-use check` can explain a no-op. */
+/** Nothing to do, with the reason recorded so `agent-shim check` can explain a no-op. */
  | {
     readonly kind: "skip";
     readonly rel: string;

package/dist/types/resolve/types.d.ts

@@ -7,7 +7,7 @@ type LayerKind = "global-config" | "config-profile" | "directory-rule" | "portab
 export interface Layer {
     readonly id: LayerId;
     readonly kind: LayerKind;
-    /** Human-readable origin (a file path, or a profile name) used by `claude-use check` to explain a decision. */
+    /** Human-readable origin (a file path, or a profile name) used by `agent-shim check` to explain a decision. */
     readonly source: string;
     readonly categories?: CategoryMap;
     readonly entries?: Entries;
@@ -72,7 +72,7 @@ export interface CompiledRule {
     /** Matches the pattern itself and everything beneath it, so a rule on `skills` covers `skills/commit/SKILL.md`. */
     readonly matches: (relPath: string) => boolean;
 }
-/** How a decision was reached, for `claude-use check`'s "which layer decided this" output. */
+/** How a decision was reached, for `agent-shim check`'s "which layer decided this" output. */
 type DecisionVia = 
 /** The unconditional pre-cascade floor: the path's real classification is `secret`. */
 "secret-floor"
@@ -100,7 +100,7 @@ export interface EliminatedRule {
     readonly rule: CompiledRule;
     readonly failed: readonly string[];
 }
-/** Every diagnostic the resolver can raise. Codes are stable strings so `claude-use check` and tests can assert on them. */
+/** Every diagnostic the resolver can raise. Codes are stable strings so `agent-shim check` and tests can assert on them. */
 type DiagnosticCode = 
 /** A profile's `extends` graph contains a cycle. */
 "EXTENDS_CYCLE"

package/dist/types/resolve/walk.d.ts

@@ -23,19 +23,19 @@ export declare function walkDirectoryAncestors(cwd: string, options: WalkOptions
 /** The up-to-three configuration sources that can apply at one directory level. */
 export interface DirectoryLevelSources {
     readonly dir: string;
-    /** The committed, team-shared `.claude-use.json` at this level. */
+    /** The committed, team-shared `.agent-shim.json` at this level. */
     readonly portable?: {
         readonly config: PortableConfig;
         readonly entryOrder?: readonly string[];
         readonly filepath: string;
     };
-    /** Every rule in this user's own `~/.claude-use/directory-rules.json` whose path is exactly this level, in file order. */
+    /** Every rule in this user's own `~/.agent-shim/directory-rules.json` whose path is exactly this level, in file order. */
     readonly rules?: readonly {
         readonly rule: DirectoryRule;
         readonly entryOrder?: readonly string[];
         readonly filepath: string;
     }[];
-    /** The gitignored `.claude-use.local.json` at this level. */
+    /** The gitignored `.agent-shim.local.json` at this level. */
     readonly portableLocal?: {
         readonly config: PortableConfig;
         readonly entryOrder?: readonly string[];
@@ -45,7 +45,7 @@ export interface DirectoryLevelSources {
 /** Everything needed to assemble the full ordered layer sequence, all of it already loaded by the caller. */
 export interface CascadeInput {
     readonly home: string;
-    /** The user-global `~/.claude-use/config.json`, the least-specific layer above the shipped defaults. */
+    /** The user-global `~/.agent-shim/config.json`, the least-specific layer above the shipped defaults. */
     readonly globalConfig?: {
         readonly config: GlobalConfig;
         readonly entryOrder?: readonly string[];
@@ -70,7 +70,7 @@ export interface AssembledCascade {
     readonly diagnostics: readonly Diagnostic[];
     /** The deepest directory-level `identity` pin encountered, which the launcher uses as a safety net beneath an explicit `@name`. */
     readonly identityPin?: string;
-    /** The deepest directory-level `configProfile` selection encountered, which is what `claude-use configure` treats as the active profile for a path. */
+    /** The deepest directory-level `configProfile` selection encountered, which is what `agent-shim configure` treats as the active profile for a path. */
     readonly directoryConfigProfile?: string;
 }
 /**
@@ -78,7 +78,7 @@ export interface AssembledCascade {
  *
  * Order is: the user-global config, then the base configuration profile's own `extends` chain, then every directory level shallowest-to-deepest, then one-off command-line overrides.
  *
- * Within one directory level, up to three sources fold most-personal-last: the committed `.claude-use.json` (team-shared), then this user's own `directory-rules.json` entries for that exact path, then `.claude-use.local.json` (this clone, this user, never committed). That three-source fold happens once per level, and the whole shallowest-to-deepest walk is one continuous sequence through those folded levels — a deeper level's three-source result composes on top of a shallower level's, never gathered per-source across the whole tree first.
+ * Within one directory level, up to three sources fold most-personal-last: the committed `.agent-shim.json` (team-shared), then this user's own `directory-rules.json` entries for that exact path, then `.agent-shim.local.json` (this clone, this user, never committed). That three-source fold happens once per level, and the whole shallowest-to-deepest walk is one continuous sequence through those folded levels — a deeper level's three-source result composes on top of a shallower level's, never gathered per-source across the whole tree first.
  *
  * A level source that names a `configProfile` composes that profile's whole chain in *before* its own inline overrides, so the source reads as "everything that profile says, plus what is additionally true this far down the tree" rather than swapping the base profile out wholesale.
  */

package/dist/types/usage/read.d.ts

@@ -22,7 +22,7 @@ export declare function listLogSegments(fs: Pick<FarmFs, "readdir">, logDir: str
 export interface UsageLogRead {
     /** Every valid record at or after the cut-off, oldest first. */
     readonly records: readonly UsageRecord[];
-    /** Complete lines that did not parse as a record of this schema version: a corrupted line, or one a newer claude-use wrote. Reported, never silently dropped. */
+    /** Complete lines that did not parse as a record of this schema version: a corrupted line, or one a newer agent-shim wrote. Reported, never silently dropped. */
     readonly invalidLines: number;
 }
 /**

package/dist/types/usage/schema.d.ts

@@ -234,7 +234,7 @@ export declare const AccountMetadataSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type AccountMetadata = z.infer<typeof AccountMetadataSchema>;
 /**
- * The latest state for one identity, rewritten atomically after each recorded response: the snapshot file other tools read (`~/.claude-use/usage/snapshots/<identity>.json`) without shelling out to `claude-use`.
+ * The latest state for one identity, rewritten atomically after each recorded response: the snapshot file other tools read (`~/.agent-shim/usage/snapshots/<identity>.json`) without shelling out to `agent-shim`.
  */
 export declare const UsageSnapshotSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
@@ -312,7 +312,7 @@ export declare const UsageSnapshotSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type UsageSnapshot = z.infer<typeof UsageSnapshotSchema>;
 /**
- * Whether a response header is one the store keeps: the quota and rate-limit families the upstreams claude-use routes to send (Anthropic's `anthropic-ratelimit-*`, the IETF draft's `ratelimit*`, the common `x-ratelimit-*`, the Codex backend's `x-codex-*` quota headers, which the Codex route forwards) and `retry-after`. Every one of these carries a number, a time or a status word; none carries a credential or content.
+ * Whether a response header is one the store keeps: the quota and rate-limit families the upstreams agent-shim routes to send (Anthropic's `anthropic-ratelimit-*`, the IETF draft's `ratelimit*`, the common `x-ratelimit-*`, the Codex backend's `x-codex-*` quota headers, which the Codex route forwards) and `retry-after`. Every one of these carries a number, a time or a status word; none carries a credential or content.
  */
 export declare function isRateLimitHeader(name: string): boolean;
 export {};

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "claude-use",
-  "version": "6.2.2",
+  "version": "7.1.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": "Apache-2.0",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ExaDev/claude-use.git"
+    "url": "git+https://github.com/ExaDev/agent-shim.git"
   },
-  "homepage": "https://github.com/ExaDev/claude-use#readme",
-  "bugs": "https://github.com/ExaDev/claude-use/issues",
+  "homepage": "https://github.com/ExaDev/agent-shim#readme",
+  "bugs": "https://github.com/ExaDev/agent-shim/issues",
   "keywords": [
     "claude-code",
     "claude",
@@ -21,6 +21,7 @@
     "node": "^22.18 || >=24"
   },
   "bin": {
+    "agent-shim": "dist/cli.cjs",
     "claude-use": "dist/cli.cjs"
   },
   "files": [