@clawdbuilder/jig-bedrock 0.1.1 → 0.2.0

package/README.md

@@ -24,24 +24,33 @@ calling AWS.
 
 ## Minimum settings
 
-With Jig, add a `bedrock` section to `jig.json` (or use the environment):
+With Jig, add a `bedrock` section to `jig.json` (or use the environment). Nothing is required: with no settings, the
+provider lists AWS-defined cross-region Claude profiles in `regions`.
 
 ```json
-{ "bedrock": { "team": "my-team" } }
+{ "bedrock": { "regions": ["us-east-1"] } }
 ```
 
 A plain Pi install has no `jig.json`: put the same keys in `~/.pi/agent/bedrock.json` (or in a `bedrock` object in that
 file). With Jig, that file is read first and Jig's `bedrock` section is merged over it. A project's `jig.json` may set the
 catalog keys, but `ssoLoginCommand`, `usageDir` and `browser` are read only from the user's file or the environment.
 
-`team` is the value of the AWS tag on your inference profiles. The package discovers active profiles with that value.
+Three modes, chosen by the settings:
+
+1. **System-defined (default).** No tag settings: lists AWS-defined cross-region Claude inference profiles with
+   `ListInferenceProfiles --type-equals SYSTEM_DEFINED`.
+2. **Tag filter.** `tagKey` and `tagValue` filter application profiles by any tag. `team` is a shorthand for
+   `tagValue` with `tagKey` defaulting to `Team`. `activeTagKey`/`activeTagValue` are optional; when `team` is set and
+   `activeTagKey` is not, `Active=true` is still required, so existing settings behave exactly as before.
+3. **Explicit list.** `profiles` names ARNs or profile ids; each is read with `GetInferenceProfile` and no tag search runs.
 
 | Setting                           | Default                                         | Meaning                                                                                            |
 | --------------------------------- | ----------------------------------------------- | -------------------------------------------------------------------------------------------------- |
-| `team`                            | required                                        | The exact AWS tag value on your application inference profiles                                     |
-| `tagKey`                          | `Team`                                          | The AWS tag that names your team on the inference profiles                                         |
-| `tagValue`                        | the value of `team`                             | The tag value to discover; `team` is kept for compatibility                                        |
-| `activeTagKey` / `activeTagValue` | `Active` / `true`                               | The tag that marks a profile as usable                                                             |
+| `team`                            | none                                            | Shorthand for `tagValue`; existing settings keep the `Active=true` filter                          |
+| `tagKey`                          | `Team` when tagged                              | The tag key for mode 2                                                                             |
+| `tagValue`                        | the value of `team`                             | The tag value for mode 2                                                                           |
+| `activeTagKey` / `activeTagValue` | none                                            | Optional tag that marks a profile usable; `team` alone still defaults to `Active`/`true`           |
+| `profiles`                        | none                                            | Mode 3: explicit inference-profile ARNs or ids                                                     |
 | `profile`                         | `my-bedrock-profile`                            | The AWS profile for discovery, requests and sign-in                                                |
 | `regions`                         | `["us-east-1"]`                                 | Where to look for profiles                                                                         |
 | `usageDir`                        | `~/.local/share/usage-tool`                     | Optional directory holding an executable `usage` that prints the usage JSON; omit if you have none |
@@ -62,13 +71,14 @@ when Pi starts an SSO check, or when you run a command.
 
 ### Discovery
 
-Discovery runs the AWS CLI with the configured `profile` and `regions`:
+Discovery runs the AWS CLI with the configured `profile` and `regions`. It always starts with
+`aws sts get-caller-identity`. Then:
 
-- `aws sts get-caller-identity` learns the 12-digit account.
-- `aws resourcegroupstaggingapi get-resources --resource-type-filters bedrock:application-inference-profile` asks for the
-  profiles in each region. `--tag-filters` keeps the profile's `Team` tag (or `tagKey`) and its `Active=true` tag (or
-  `activeTagKey`/`activeTagValue`).
-- `aws bedrock get-inference-profile --inference-profile-identifier <arn>` reads each profile's name, status and model.
+- **System:** `aws bedrock list-inference-profiles --type-equals SYSTEM_DEFINED`, paginated per region; only Claude
+  profiles are kept, then `GetInferenceProfile` reads each one.
+- **Tag:** `aws resourcegroupstaggingapi get-resources --resource-type-filters
+  bedrock:application-inference-profile`, filtered by `tagKey`/`tagValue` and, only when configured, the active tag.
+- **Explicit:** `GetInferenceProfile` for each `profiles` entry; no tag call and no system listing.
 
 Only `ACTIVE` profiles are listed. Their foundation model is read from the profile's model ARN; the provider does not call
 `GetFoundationModel`. A successful catalog is cached for **24 hours** in `~/.cache/jig-bedrock/catalog.json`, with private
@@ -84,8 +94,9 @@ There are two routes to the same Claude models:
   configured profile.
 - **Converse.** Pi's Bedrock provider uses the AWS SDK's `ConverseStream` operation at the bedrock-runtime endpoint.
 
-A profile is put on Messages only when `api` is `messages` (the default) and its foundation model is an Anthropic model.
-Every other model uses Converse. `api: "converse"` puts every model on Converse. Both routes stream. On Messages the tools array stays
+A profile is put on Messages only when `api` is `messages` (the default), it is an **application** inference profile, and
+its foundation model is an Anthropic model. System-defined profile ids use Converse, because they are not application
+inference-profile ARNs. Every other model uses Converse. `api: "converse"` puts every model on Converse. Both routes stream. On Messages the tools array stays
 stable, so the prompt cache survives a tool change; on Converse a changed tool list rewrites it. The footer and usage
 figures are the same.
 
@@ -93,6 +104,19 @@ A child agent (a Pi session with `PI_SUBAGENT_ID`, or the older `PI_SUBAGENT_CHI
 usage program and its events, and the sign-in at start. The parent does those; the child still sends requests and reads
 the parent's cached catalog.
 
+## IAM
+
+| Mode     | Discovery permissions                                          | Invoke                                                                                                   |
+| -------- | -------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| System   | `bedrock:ListInferenceProfiles`, `bedrock:GetInferenceProfile` | `bedrock:InvokeModel*` on the profile and on each foundation model it routes to, in every routing region |
+| Tag      | `tag:GetResources`, `bedrock:GetInferenceProfile`              | same                                                                                                     |
+| Explicit | `bedrock:GetInferenceProfile`                                  | same                                                                                                     |
+
+Add `sts:GetCallerIdentity` for the account check. For an AWS-defined cross-region profile the policy must allow the
+profile **and** the foundation model in every region it routes to; AWS's [inference-profile permissions][ip-iam] say the
+same. Application profiles additionally need the profile's own ARN. [ip-iam]:
+https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-prereq.html
+
 ## Credentials
 
 Requests use the AWS SDK's default credential chain, loaded from Pi's install (`pi-host.ts` loads
@@ -154,7 +178,16 @@ mode bits), and the no-browser fallback is the WSL-only `bin/windows-browser` sh
 | `/bedrock-doctor`         | Probe Node, AWS CLI, bash, jq and the optional usage program; it does not call AWS |
 
 The footer and `/bedrock-usage` read an executable named `usage` in `usageDir`; it is called with `--daily`,
-`--weekly` or `--monthly` and `--output json`, and prints the spend as JSON.
+`--weekly` or `--monthly` and `--output json`, and prints the spend as JSON. It receives `AWS_PROFILE` and
+`BEDROCK_REGIONS` in its environment.
+
+If your usage CLI's own command is `usage-cli`, put this two-line wrapper at
+`~/.local/share/usage-tool/usage` and make it executable:
+
+```sh
+#!/bin/sh
+exec usage-cli usage "$@"
+```
 
 ## Tests
 
@@ -171,3 +204,11 @@ Real-AWS tests are manual and need the user's approval; unit tests use recorded
 ## Licence
 
 MIT.
+
+## Not verified against real AWS
+
+- The exact Messages behaviour for a system-defined profile id (this package sends those through Converse).
+- The response shapes of `ListInferenceProfiles` pagination and system-profile model ARNs, which the tests fake from
+  AWS documentation.
+- IAM policy evaluation for cross-region profile plus foundation-model permissions in every routing region.
+- Pricing and model metadata for system-defined profiles come from Pi's registry; no live `GetFoundationModel` call is made.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clawdbuilder/jig-bedrock",
-    "version": "0.1.1",
+    "version": "0.2.0",
     "description": "Claude on AWS Bedrock for Pi: inference-profile discovery, the Messages route with cache-friendly tools, Converse fallback, SSO repair and a budget footer.",
     "type": "module",
     "license": "MIT",

package/src/aws-discovery.ts

@@ -3,7 +3,7 @@ import { rmSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { atomicCache } from "./cache.ts";
-import { type Catalog, type Profile, readCatalog, validArn } from "./catalog.ts";
+import { type Catalog, filterHash, type Profile, readCatalog, validArn } from "./catalog.ts";
 import type { ResolvedConfig } from "./config.ts";
 
 // biome-ignore lint/suspicious/noExplicitAny: parsed JSON from the AWS CLI or usage program, checked field by field where it is used
@@ -65,6 +65,22 @@ export function discoveryHelp(status: Status): string {
             return "Check AWS access and the configuration in README.md, then /bedrock-refresh.";
     }
 }
+const PROFILE_ERROR =
+    /profile scope|model scope|model ID|ambiguous model|models|profile name|profile mismatch|profile tags/;
+
+function profileError(error: unknown): boolean {
+    return PROFILE_ERROR.test(String(error));
+}
+
+function entryMessage(error: unknown): string {
+    const text = String(error);
+    if (/profile scope/.test(text)) return text.replace(/^Error:\s*/, "");
+    if (/model scope/.test(text)) return "model scope";
+    if (category(error) === "permission_denied") return "denied";
+    if (category(error) === "configuration") return "not found";
+    return category(error);
+}
+
 export function createAwsDiscovery(
     config: ResolvedConfig,
     runner: Runner = runFile,
@@ -73,7 +89,13 @@ export function createAwsDiscovery(
 ): CatalogSource {
     let flight: Promise<Status> | undefined,
         invalidAccount = false;
-    const load = () => (invalidAccount ? undefined : readCatalog(file, config, now()));
+    const mode =
+        config.mode ??
+        (config.profiles?.length ? "explicit" : config.team || config.tagValue || config.tagKey ? "tag" : "system");
+    const activeKey = config.activeTagKey ?? (config.team !== undefined ? "Active" : undefined);
+    const activeValue = config.activeTagValue ?? "true";
+    const scope = { ...config, mode, team: config.team };
+    const load = () => (invalidAccount ? undefined : readCatalog(file, scope, now()));
     const perform = async (force = false): Promise<Status> => {
         let remaining = 8 * 1_048_576,
             pages = 0,
@@ -92,20 +114,21 @@ export function createAwsDiscovery(
             return JSON.parse(output);
         };
         try {
-            // A catalog younger than the TTL needs no AWS call at all, not even to learn who the caller is; /bedrock-refresh forces one.
             if (!force && !invalidAccount) {
-                const cached = readCatalog(file, config, now());
+                const cached = readCatalog(file, scope, now());
                 if (cached && now() / 1000 - cached.fetched_at < 86_400) return "ok";
             }
             const account = (await aws(["sts", "get-caller-identity"])).Account;
             if (typeof account !== "string" || !/^\d{12}$/.test(account)) throw new Error("identity");
-            const old = readCatalog(file, config, now());
+            const old = readCatalog(file, scope, now());
             if (old && old.account_id !== account) {
                 invalidAccount = true;
                 rmSync(file, { force: true });
             } else invalidAccount = false;
             const profiles: Profile[] = [],
-                seen = new Set<string>();
+                seen = new Set<string>(),
+                explicitErrors: { profile: string; message: string }[] = [],
+                warnings: string[] = [];
             const info = (arn: string, region: string) =>
                 aws(["bedrock", "get-inference-profile", "--inference-profile-identifier", arn, "--region", region]);
             const foundation = async (value: Json, depth = 0): Promise<string> => {
@@ -123,95 +146,184 @@ export function createAwsDiscovery(
                         // biome-ignore lint/suspicious/noControlCharactersInRegex: reject control characters in an AWS model id
                         if (!id || id.length > 256 || /[\x00-\x1f]/.test(id)) throw new Error("model ID");
                         ids.add(id);
-                    } else if (
-                        resource.startsWith("inference-profile/") &&
-                        depth < 2 &&
-                        (!match[3] || match[3] === account)
-                    )
+                    } else if (resource.startsWith("inference-profile/") && depth < 2) {
+                        if (match[3] && match[3] !== account && match[3] !== "aws") throw new Error("model scope");
                         ids.add(await foundation(await info(row.modelArn, match[2]), depth + 1));
-                    else throw new Error("model scope");
+                    } else throw new Error("model scope");
                 }
                 if (ids.size !== 1) throw new Error("ambiguous model");
                 return [...ids][0] as string;
             };
-            for (const region of config.regions) {
-                let token = "";
-                const tokens = new Set<string>();
-                for (let page = 0; page < 32; page++) {
-                    if (++pages > 64) throw new Error("pagination");
-                    const result = await aws([
-                        "resourcegroupstaggingapi",
-                        "get-resources",
-                        "--region",
-                        region,
-                        "--resource-type-filters",
-                        "bedrock:application-inference-profile",
-                        "--tag-filters",
-                        JSON.stringify([
-                            { Key: config.tagKey ?? "Team", Values: [config.tagValue ?? config.team] },
-                            { Key: config.activeTagKey ?? "Active", Values: [config.activeTagValue ?? "true"] },
-                        ]),
-                        "--no-paginate",
-                        ...(token ? ["--pagination-token", token] : []),
-                    ]);
-                    if (!Array.isArray(result.ResourceTagMappingList) || result.ResourceTagMappingList.length > 256)
-                        throw new Error("resources");
-                    for (const row of result.ResourceTagMappingList) {
-                        const arn = row.ResourceARN;
-                        if (
-                            typeof arn !== "string" ||
-                            !validArn(arn, region, account) ||
-                            seen.has(arn) ||
-                            seen.size >= 256
-                        )
-                            throw new Error("profile scope");
-                        if (
-                            !Array.isArray(row.Tags) ||
-                            ![
+            const nameOf = (value: Json): string => {
+                const name = value.inferenceProfileName;
+                // biome-ignore lint/suspicious/noControlCharactersInRegex: reject control characters in an AWS profile name
+                if (typeof name !== "string" || !name || name.length > 256 || /[\x00-\x1f\x7f]/.test(name))
+                    throw new Error("profile name");
+                return name;
+            };
+            const add = async (candidate: string, region: string, kind: "application" | "system") => {
+                if (!validArn(candidate, region, account, kind) || seen.has(candidate) || seen.size >= 256)
+                    throw new Error("profile scope");
+                const value = await info(candidate, region);
+                if (value.inferenceProfileArn !== undefined && value.inferenceProfileArn !== candidate)
+                    throw new Error("profile mismatch");
+                if (value.status !== "ACTIVE") return;
+                seen.add(candidate);
+                const foundationModelId = await foundation(value);
+                if (kind === "system" && !foundationModelId.startsWith("anthropic.claude")) return;
+                profiles.push({
+                    arn: candidate,
+                    profile_name: nameOf(value),
+                    foundation_model_id: foundationModelId,
+                    region,
+                    kind,
+                });
+            };
+            if (mode === "explicit") {
+                for (const entry of config.profiles ?? []) {
+                    const match = entry.match(
+                        /^arn:(aws|aws-cn|aws-us-gov):bedrock:([^:]+):([^:]*):(application-inference-profile|inference-profile)\/(.+)$/,
+                    );
+                    const kind = (match?.[4] === "inference-profile" ? "system" : "application") as
+                        | "application"
+                        | "system";
+                    const region = match?.[2] ?? config.regions[0];
+                    if (!region) throw new Error("profile scope");
+                    try {
+                        if (match && !config.regions.includes(region))
+                            throw new Error(
+                                `profile scope: ${entry} is in ${region}; add ${region} to bedrock.regions`,
+                            );
+                        if (match) await add(entry, region, kind);
+                        else {
+                            const found = await info(entry, region);
+                            const foundArn = found.inferenceProfileArn;
+                            if (typeof foundArn !== "string") throw new Error("profile ARN");
+                            await add(foundArn, region, found.type === "SYSTEM_DEFINED" ? "system" : "application");
+                        }
+                    } catch (error) {
+                        if (!profileError(error) && !/AccessDenied/i.test(String(error))) throw error;
+                        explicitErrors.push({ profile: entry, message: entryMessage(error) });
+                    }
+                }
+            } else if (mode === "tag") {
+                for (const region of config.regions) {
+                    let token = "";
+                    const tokens = new Set<string>();
+                    for (let page = 0; page < 32; page++) {
+                        if (++pages > 64) throw new Error("pagination");
+                        const result = await aws([
+                            "resourcegroupstaggingapi",
+                            "get-resources",
+                            "--region",
+                            region,
+                            "--resource-type-filters",
+                            "bedrock:application-inference-profile",
+                            "--tag-filters",
+                            JSON.stringify([
+                                { Key: config.tagKey ?? "Team", Values: [config.tagValue ?? config.team] },
+                                ...(activeKey === undefined ? [] : [{ Key: activeKey, Values: [activeValue] }]),
+                            ]),
+                            "--no-paginate",
+                            ...(token ? ["--pagination-token", token] : []),
+                        ]);
+                        if (!Array.isArray(result.ResourceTagMappingList) || result.ResourceTagMappingList.length > 256)
+                            throw new Error("resources");
+                        for (const row of result.ResourceTagMappingList) {
+                            const arn = row.ResourceARN;
+                            if (
+                                typeof arn !== "string" ||
+                                !validArn(arn, region, account) ||
+                                seen.has(arn) ||
+                                seen.size >= 256
+                            )
+                                throw new Error("profile scope");
+                            const wanted = [
                                 [config.tagKey ?? "Team", config.tagValue ?? config.team],
-                                [config.activeTagKey ?? "Active", config.activeTagValue ?? "true"],
-                            ].every(
-                                ([key, value]) =>
-                                    row.Tags.filter((tag: Json) => tag?.Key === key).length === 1 &&
-                                    row.Tags.some((tag: Json) => tag?.Key === key && tag.Value === value),
+                                ...(activeKey === undefined ? [] : [[activeKey, activeValue]]),
+                            ] as Array<[string, string | undefined]>;
+                            if (
+                                !Array.isArray(row.Tags) ||
+                                !wanted.every(
+                                    ([key, value]) =>
+                                        row.Tags.filter((tag: Json) => tag?.Key === key).length === 1 &&
+                                        row.Tags.some((tag: Json) => tag?.Key === key && tag.Value === value),
+                                )
                             )
-                        )
-                            throw new Error("profile tags");
-                        seen.add(arn);
-                        const value = await info(arn, region);
-                        if (value.inferenceProfileArn !== undefined && value.inferenceProfileArn !== arn)
-                            throw new Error("profile mismatch");
-                        if (value.status !== "ACTIVE") continue;
-                        const name = value.inferenceProfileName;
-                        // biome-ignore lint/suspicious/noControlCharactersInRegex: reject control characters in an AWS profile name
-                        if (typeof name !== "string" || !name || name.length > 256 || /[\x00-\x1f\x7f]/.test(name))
-                            throw new Error("profile name");
-                        profiles.push({
-                            arn,
-                            profile_name: name,
-                            foundation_model_id: await foundation(value),
+                                throw new Error("profile tags");
+                            await add(arn, region, "application");
+                        }
+                        token = result.PaginationToken ?? "";
+                        if (!token) break;
+                        if (typeof token !== "string" || token.length > 2048 || tokens.has(token) || page === 31)
+                            throw new Error("pagination");
+                        tokens.add(token);
+                    }
+                }
+            } else {
+                for (const region of config.regions) {
+                    let token = "";
+                    const tokens = new Set<string>();
+                    for (let page = 0; page < 32; page++) {
+                        if (++pages > 64) throw new Error("pagination");
+                        const result = await aws([
+                            "bedrock",
+                            "list-inference-profiles",
+                            "--type-equals",
+                            "SYSTEM_DEFINED",
+                            "--region",
                             region,
-                        });
+                            ...(token ? ["--next-token", token] : []),
+                        ]);
+                        const rows = result.inferenceProfileSummaries;
+                        if (!Array.isArray(rows) || rows.length > 256) throw new Error("profiles");
+                        for (const row of rows) {
+                            const arn = row?.inferenceProfileArn;
+                            if (typeof arn !== "string") throw new Error("profile scope");
+                            if (!/anthropic\.claude/i.test(`${arn} ${row.inferenceProfileName ?? ""}`)) continue;
+                            try {
+                                await add(arn, region, "system");
+                            } catch (error) {
+                                if (!profileError(error)) throw error;
+                                explicitErrors.push({ profile: arn, message: entryMessage(error) });
+                            }
+                        }
+                        token = result.nextToken ?? "";
+                        if (!token) break;
+                        if (typeof token !== "string" || token.length > 2048 || tokens.has(token) || page === 31)
+                            throw new Error("pagination");
+                        tokens.add(token);
                     }
-                    token = result.PaginationToken ?? "";
-                    if (!token) break;
-                    if (typeof token !== "string" || token.length > 2048 || tokens.has(token) || page === 31)
-                        throw new Error("pagination");
-                    tokens.add(token);
                 }
             }
             profiles.sort((a, b) => (a.arn < b.arn ? -1 : a.arn > b.arn ? 1 : 0));
-            atomicCache(file, {
+            const failed =
+                (mode === "explicit" || mode === "system") && profiles.length === 0 && explicitErrors.length > 0;
+            if (mode === "tag" && profiles.length === 0) {
+                const active = activeKey === undefined ? "" : ` and ${activeKey}=${activeValue}`;
+                warnings.push(
+                    `No application inference profiles matched ${config.tagKey ?? "Team"}=${config.tagValue}${active} in ${config.regions.join(", ")}. Check bedrock.tagKey/tagValue.`,
+                );
+            }
+            if (mode === "system" && profiles.length === 0)
+                warnings.push(`No AWS-defined Claude inference profiles in ${config.regions.join(", ")}.`);
+            if (failed) return "unavailable";
+            const catalog: Catalog = {
                 schema: 1,
+                mode,
                 team: config.team,
                 aws_profile: config.profile,
                 account_id: account,
                 regions: config.regions,
                 fetched_at: Math.floor(now() / 1000),
+                filter_hash: filterHash(scope),
+                ...(warnings.length > 0 ? { warnings } : {}),
                 profiles,
-            });
+                ...(explicitErrors.length > 0 ? { errors: explicitErrors } : {}),
+            };
+            atomicCache(file, catalog);
             invalidAccount = false;
-            return "ok";
+            return failed ? "unavailable" : "ok";
         } catch (e) {
             return category(e);
         }

package/src/catalog.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, readSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -54,15 +55,26 @@ const MESSAGES_COMPAT = {
     supportsMidConvoSystemMessages: true,
     supportsMidConvoToolChanges: true,
 } as const;
-export type Profile = { arn: string; profile_name: string; foundation_model_id: string; region: string };
+export type Profile = {
+    arn: string;
+    profile_name: string;
+    foundation_model_id: string;
+    region: string;
+    kind?: "application" | "system";
+};
 export type Catalog = {
     schema: 1;
-    team: string;
+    mode?: "explicit" | "tag" | "system";
+    team?: string;
     aws_profile: string;
     account_id: string;
     regions: string[];
     fetched_at: number;
+    filter_hash?: string;
+    warnings?: string[];
     profiles: Profile[];
+    /** Explicit-list entries that could not be read; they do not stop the others. */
+    errors?: { profile: string; message: string }[];
 };
 const slug = (s: string) =>
     s
@@ -92,27 +104,68 @@ export function boundedRegular(file: string, max: number, privateMode = false):
         closeSync(fd);
     }
 }
-export function validArn(arn: string, region: string, account: string): boolean {
+export function validArn(
+    arn: string,
+    region: string,
+    account: string,
+    kind: "application" | "system" | "any" = "application",
+): boolean {
     const p = arn.split(":");
+    const app = (p[5] ?? "").startsWith("application-inference-profile/");
+    const system = (p[5] ?? "").startsWith("inference-profile/");
     return (
         p.length === 6 &&
         p[0] === "arn" &&
         ["aws", "aws-cn", "aws-us-gov"].includes(p[1] ?? "") &&
         p[2] === "bedrock" &&
         p[3] === region &&
-        p[4] === account &&
-        /^application-inference-profile\/[A-Za-z0-9-]{1,128}$/.test(p[5] ?? "")
+        (system ? p[4] === "" || p[4] === "aws" || p[4] === account : p[4] === account) &&
+        (kind === "any" ? app || system : kind === "application" ? app : system) &&
+        /^(?:application-inference-profile|inference-profile)\/[A-Za-z0-9.-]{1,256}$/.test(p[5] ?? "")
     );
 }
+/** The discovery filter, hashed into the catalog so a changed tag or list is never reused. */
+export function filterHash(expected: {
+    mode?: "explicit" | "tag" | "system";
+    tagKey?: string;
+    tagValue?: string;
+    activeTagKey?: string;
+    activeTagValue?: string;
+    profiles?: string[];
+}): string {
+    return createHash("sha256")
+        .update(
+            JSON.stringify([
+                expected.mode ?? null,
+                expected.tagKey ?? null,
+                expected.tagValue ?? null,
+                expected.activeTagKey ?? null,
+                expected.activeTagValue ?? null,
+                expected.profiles ?? null,
+            ]),
+        )
+        .digest("hex");
+}
+
 export function readCatalog(
     file: string,
-    expected: { team: string; profile: string; regions: string[] },
+    expected: {
+        mode?: "explicit" | "tag" | "system";
+        team?: string;
+        tagKey?: string;
+        tagValue?: string;
+        activeTagKey?: string;
+        activeTagValue?: string;
+        profiles?: string[];
+        profile: string;
+        regions: string[];
+    },
     now = Date.now(),
 ): Catalog | undefined {
     expected = { ...expected, regions: [...expected.regions].sort() };
     const directory = dirname(file);
     if (
-        !label(expected.team, 256) ||
+        (expected.team !== undefined && !label(expected.team, 256)) ||
         !label(expected.profile, 128) ||
         !expected.regions.length ||
         new Set(expected.regions).size !== expected.regions.length
@@ -127,6 +180,9 @@ export function readCatalog(
         if (
             c.schema !== 1 ||
             c.team !== expected.team ||
+            (c.mode === undefined
+                ? expected.mode !== "tag" || c.filter_hash !== undefined
+                : c.mode !== expected.mode || c.filter_hash !== filterHash(expected)) ||
             c.aws_profile !== expected.profile ||
             typeof c.account_id !== "string" ||
             !/^\d{12}$/.test(c.account_id) ||
@@ -151,7 +207,7 @@ export function readCatalog(
                 !label(p.profile_name, 256) ||
                 !label(p.foundation_model_id, 256) ||
                 typeof p.arn !== "string" ||
-                !validArn(p.arn, p.region, c.account_id) ||
+                !validArn(p.arn, p.region, c.account_id, p.kind ?? "application") ||
                 seen.has(p.arn)
             )
                 return;
@@ -198,6 +254,42 @@ function thinkingLevelMap(
     return { thinkingLevelMap: { ...(base ?? {}), off: null } };
 }
 
+/** System profiles first, by the geography of their id: the region's prefix, then global, then the rest. */
+function orderedSystem(rows: Profile[], catalog: Catalog | undefined): Profile[] {
+    const firstRegion = catalog?.regions?.[0] ?? "us-east-1";
+    const first = /^us-gov-/.test(firstRegion)
+        ? "us-gov"
+        : /^ap-northeast-(?:1|3)$/.test(firstRegion)
+          ? "jp"
+          : /^ap-southeast-(?:2|4)$/.test(firstRegion)
+            ? "au"
+            : /^ap-/.test(firstRegion)
+              ? "apac"
+              : (firstRegion.split("-")[0] ?? "us");
+    const geography = (p: Profile) => {
+        const id = p.arn.slice(p.arn.lastIndexOf("/") + 1);
+        const prefix = id.split(".")[0] ?? "";
+        return prefix;
+    };
+    const order = catalog?.regions ?? [firstRegion];
+    const rank = (p: Profile): number => {
+        const prefix = geography(p);
+        if (p.kind !== "system") return 999;
+        if (prefix === first) return 0;
+        if (prefix === "global") return 1;
+        return 2 + Math.max(0, order.indexOf(p.region));
+    };
+    return rows
+        .filter((p) => p.kind === "system")
+        .sort((a, b) => rank(a) - rank(b) || (a.arn < b.arn ? -1 : a.arn > b.arn ? 1 : 0));
+}
+
+function orderedApplication(rows: Profile[]): Profile[] {
+    const system = rows.filter((p) => p.kind === "system");
+    const apps = rows.filter((p) => p.kind !== "system");
+    return [...system, ...apps];
+}
+
 export function discoveredProfiles(
     catalog: Catalog | undefined,
     usageDir: string,
@@ -228,10 +320,12 @@ export function discoveredProfiles(
         const key = slug(registryName(r.name));
         grouped.set(key, [...(grouped.get(key) || []), p]);
     }
-    for (const [key, rows] of grouped)
-        for (const p of rows) {
+    for (const [key, rows] of grouped) {
+        const system = orderedSystem(rows, catalog);
+        const preferred = system[0] ?? (rows.length === 1 ? rows[0] : undefined);
+        for (const p of orderedApplication(rows)) {
             const r = registryEntry(p.foundation_model_id);
-            const id = rows.length === 1 ? key : `${key}--${p.region}--${p.arn.slice(p.arn.lastIndexOf("/") + 1)}`;
+            const id = p === preferred ? key : `${key}--${p.region}--${p.arn.slice(p.arn.lastIndexOf("/") + 1)}`;
             const pricing = rates.get(key);
             const fallback =
                 r.cost &&
@@ -250,13 +344,13 @@ export function discoveredProfiles(
             }
             const promptCache = promptCacheFor(p.foundation_model_id);
             // Only Claude profiles go on the Anthropic route; gpt, nova and the rest keep their own route.
-            const messages = api === "messages" && isAnthropicModel(p.foundation_model_id);
+            const messages = api === "messages" && p.kind !== "system" && isAnthropicModel(p.foundation_model_id);
             available.push({
                 id,
                 arn: p.arn,
                 foundationModelId: p.foundation_model_id,
                 aliases: [],
-                name: registryName(r.name) + (rows.length === 1 ? "" : ` (${p.region}, ${p.profile_name})`),
+                name: registryName(r.name) + (p === preferred ? "" : ` (${p.region}, ${p.profile_name})`),
                 api: messages ? "anthropic-messages" : "bedrock-converse-stream",
                 baseUrl: messages
                     ? `https://bedrock-runtime.${p.region}.amazonaws.com/anthropic`
@@ -280,6 +374,7 @@ export function discoveredProfiles(
                 ...(thinkingLevelMap(r.thinkingLevelMap, p.foundation_model_id) ?? {}),
             });
         }
+    }
     return { available, unavailable };
 }
 export function updateModels(

package/src/commands.ts

@@ -276,7 +276,7 @@ export function registerStatisticsCommands(
         },
     });
     pi.registerCommand("bedrock-profiles", {
-        description: "Show approved team Bedrock models, regions and pricing sources from the current catalog",
+        description: "Show your approved Bedrock models, regions and pricing sources from the current catalog",
         handler: async (args, ctx) => {
             if (args.trim()) {
                 ctx.ui.notify("Usage: /bedrock-profiles", "warning");
@@ -284,16 +284,20 @@ export function registerStatisticsCommands(
             }
             await showReport(
                 ctx,
-                "Bedrock · Team profiles",
+                "Bedrock · Your profiles",
                 async () => {
                     const catalog = sources.catalog.load(),
                         models = sources.models();
                     return [
-                        `Team: ${clean(config.team)} · AWS profile: ${clean(config.profile)} · regions: ${config.regions.join(", ")}`,
+                        `${config.mode === "system" ? "Mode: system-defined" : config.mode === "explicit" ? "Mode: explicit list" : `Tag: ${clean(config.tagKey ?? "Team")}=${clean(config.tagValue)}`} · AWS profile: ${clean(config.profile)} · regions: ${config.regions.join(", ")}`,
                         catalog
                             ? `Catalog observed ${new Date(catalog.fetched_at * 1000).toISOString()}${Date.now() / 1000 - catalog.fetched_at > 86_400 ? " (stale; /bedrock-refresh)" : ""}. ${catalog.profiles.length} active profiles / ${models.length} usable models.`
                             : "No approved catalog. Run /aws-login, then /bedrock-refresh.",
                         "Catalog tags filter presentation; AWS IAM authorizes model access.",
+                        ...(catalog?.warnings ?? []).map((line) => `Note: ${line}`),
+                        ...(catalog?.errors ?? []).map(
+                            (error) => `Could not read ${clean(error.profile)}: ${clean(error.message)}.`,
+                        ),
                         ...models.map(
                             (m) =>
                                 `${clean(m.name)} · ${m.arn.split(":")[3]} · ${m.rateSource} / million tokens: input $${m.cost.input}, output $${m.cost.output}, cache read $${m.cost.cacheRead}, ${writeRates(m)}`,

package/src/config.ts

@@ -19,11 +19,15 @@ import type { Check } from "./check.ts";
 import { isObject, knownKeys } from "./check.ts";
 
 export interface ResolvedConfig {
-    team: string;
+    team?: string;
     tagKey?: string;
     tagValue?: string;
     activeTagKey?: string;
     activeTagValue?: string;
+    /** Explicit inference-profile ARNs or ids; when nonempty, no tag or system search runs. */
+    profiles?: string[];
+    /** Derived: explicit, tag or system. */
+    mode?: "explicit" | "tag" | "system";
     profile: string;
     regions: string[];
     usageDir: string;
@@ -52,6 +56,7 @@ export const FIELDS = [
     "tagValue",
     "activeTagKey",
     "activeTagValue",
+    "profiles",
     "profile",
     "regions",
     "usageDir",
@@ -63,9 +68,6 @@ export const FIELDS = [
 ] as const;
 
 export const DEFAULTS = {
-    tagKey: "Team",
-    activeTagKey: "Active",
-    activeTagValue: "true",
     profile: "my-bedrock-profile",
     regions: ["us-east-1"],
     usageDir: "~/.local/share/usage-tool",
@@ -86,6 +88,7 @@ export function problemsOf(c: Record<string, unknown>): string[] {
         tagValue,
         activeTagKey,
         activeTagValue,
+        profiles,
         profile,
         regions,
         usageDir,
@@ -95,7 +98,10 @@ export function problemsOf(c: Record<string, unknown>): string[] {
         browser,
         api,
     } = c;
-    if (typeof team !== "string" || team.trim() === "" || team.length > 256 || control.test(team)) {
+    if (
+        team !== undefined &&
+        (typeof team !== "string" || team.trim() === "" || team.length > 256 || control.test(team))
+    ) {
         problems.push("bedrock.team must be your exact AWS tag value (1-256 characters, no control characters)");
     }
     for (const [name, value] of [
@@ -109,6 +115,24 @@ export function problemsOf(c: Record<string, unknown>): string[] {
             (typeof value !== "string" || value.trim() === "" || value.length > 256 || control.test(value))
         )
             problems.push(`bedrock.${name} must be a tag name or value of 1-256 characters`);
+    if (
+        profiles !== undefined &&
+        (!Array.isArray(profiles) ||
+            profiles.length === 0 ||
+            profiles.length > 256 ||
+            profiles.some(
+                (value) =>
+                    typeof value !== "string" ||
+                    value.trim() === "" ||
+                    value.length > 2048 ||
+                    value.startsWith("-") ||
+                    !/^[A-Za-z0-9._:/-]+$/.test(value) ||
+                    control.test(value),
+            ) ||
+            new Set(profiles).size !== profiles.length)
+    ) {
+        problems.push("bedrock.profiles must be a nonempty list of up to 256 unique inference-profile ARNs or ids");
+    }
     if (typeof profile !== "string" || !profilePattern.test(profile)) {
         problems.push(
             "bedrock.profile must be an AWS profile name: 1-128 letters, digits, underscores, dots or hyphens, starting with a letter or digit",
@@ -200,15 +224,20 @@ export function loadConfig(
     if (env.JIG_BEDROCK_REGIONS !== undefined)
         c.regions = env.JIG_BEDROCK_REGIONS.split(",").map((region) => region.trim());
     const [problem] = problemsOf(c);
-    if (problem !== undefined) {
-        return {
-            error:
-                c.team === undefined
-                    ? "Set bedrock.team in the bedrock settings to your exact AWS tag value."
-                    : `${problem}.`,
-        };
+    if (problem !== undefined) return { error: `${problem}.` };
+    const team = typeof c.team === "string" && c.team !== "" ? c.team : undefined;
+    const tagValue = typeof c.tagValue === "string" && c.tagValue !== "" ? c.tagValue : team;
+    const explicit = Array.isArray(c.profiles) && c.profiles.length > 0;
+    c.team = team;
+    c.tagValue = tagValue;
+    c.mode = explicit ? "explicit" : tagValue !== undefined || c.tagKey !== undefined ? "tag" : "system";
+    // Legacy team settings keep Active=true unless the user sets an active tag key.
+    if (c.mode === "tag" && c.activeTagKey === undefined && team !== undefined)
+        c.activeTagValue = c.activeTagValue ?? "true";
+    if (c.mode !== "tag") {
+        delete c.tagKey;
+        delete c.activeTagKey;
+        delete c.activeTagValue;
     }
-    (c.regions as string[]).sort();
-    c.tagValue = typeof c.tagValue === "string" && c.tagValue !== "" ? c.tagValue : c.team;
     return { config: c as unknown as ResolvedConfig };
 }

package/src/provider.ts

@@ -1,4 +1,4 @@
-// The Bedrock model provider: the team's application inference profiles as Pi models, AWS SSO recovery, a monthly spend figure and
+// The Bedrock model provider: your inference profiles as Pi models, AWS SSO recovery, a monthly spend figure and
 // the commands around them. Its settings are the `bedrock` section when Jig is present, or the extension's own settings (see config.ts); it also
 // publishes the optional display events in events.ts.
 //
@@ -150,10 +150,7 @@ export function createJigBedrock(
         }
         if (!config) {
             const file = path.join(agentFolder(options.env), "bedrock.json");
-            const where =
-                options.api === undefined
-                    ? `Add "team" to ${file}, then /reload.`
-                    : `Set it in bedrock in jig.json or in ${file}, then /reload.`;
+            const where = `Fix bedrock in jig.json or in ${file}, then /reload.`;
             pi.on("session_start", (_event, ctx) =>
                 ctx.ui.notify(`Bedrock provider disabled: ${resolved.error} ${where}`, "warning"),
             );
@@ -258,11 +255,17 @@ export function createJigBedrock(
                 }
             }
             const change = updateModels(models, updated);
-            if (ctx && (change.added || change.removed)) {
-                ctx.ui.notify(
-                    `Bedrock catalog updated: ${change.added} added, ${change.removed} removed. Choose /model if your selection was removed.`,
-                    "info",
-                );
+            const current = catalog.load();
+            const problems = current?.errors ?? [];
+            const warnings = current?.warnings ?? [];
+            if (ctx && (change.added || change.removed || problems.length > 0 || warnings.length > 0)) {
+                const detail = [
+                    `Bedrock catalog updated: ${change.added} added, ${change.removed} removed.`,
+                    ...warnings,
+                    ...problems.map((problem) => `${problem.profile}: ${problem.message}.`),
+                    "Choose /model if your selection was removed.",
+                ].join(" ");
+                ctx.ui.notify(detail, problems.length > 0 || warnings.length > 0 ? "warning" : "info");
             }
             if (change.changed && native) {
                 await registerTeamBedrock(
@@ -290,7 +293,7 @@ export function createJigBedrock(
             });
         }
         pi.registerCommand("bedrock-refresh", {
-            description: "Refresh team Bedrock models",
+            description: "Refresh your Bedrock models",
             handler: async (_args, context) => {
                 const status = await refresh();
                 context.ui.notify(

package/src/sso-check.ts

@@ -100,12 +100,18 @@ export async function checkSso(
 ): Promise<SsoState> {
     // The fast path: a cached token that stays valid needs no network check and no SDK.
     if (cachedTokenFresh(profile, deps)) return "ok";
-    const limit = AbortSignal.timeout(deps.timeoutMs);
+    // `AbortSignal.timeout` uses an unreferenced timer. With a stalled SDK and nothing else in the event loop, the process
+    // would exit before the check could return an error. A referenced timer keeps the check alive for its own timeout.
+    const controller = new AbortController();
+    const limit = controller.signal;
+    const timer = setTimeout(() => controller.abort(), deps.timeoutMs);
     try {
         // The SDK's answer is dropped: only whether it resolved matters.
         await until(deps.credentialProvider()({ profile })(), signal ? AbortSignal.any([signal, limit]) : limit);
         return "ok";
     } catch (error) {
         return classify(error);
+    } finally {
+        clearTimeout(timer);
     }
 }

package/src/statistics.ts

@@ -250,24 +250,20 @@ export function createStatistics(
             previous = load(period);
         if (!options.force && previous && !previous.stale) return previous;
         try {
-            const output = await runner(
-                usageExecutable(config),
-                ["usage", `--${period}`, "--output", "json", "--aws-profile", config.profile],
-                {
-                    timeout: 120_000,
-                    maxBuffer: 2_097_152,
-                    signal: options.signal,
-                    env: {
-                        ...process.env,
-                        BEDROCK_REGIONS: config.regions.join(","),
-                        AWS_PROFILE: config.profile,
-                        AWS_CLI_AUTO_PROMPT: "off",
-                        AWS_PAGER: "",
-                        NO_COLOR: "1",
-                        PAT_SKIP_UPDATE_CHECK: "1",
-                    },
+            const output = await runner(usageExecutable(config), [`--${period}`, "--output", "json"], {
+                timeout: 120_000,
+                maxBuffer: 2_097_152,
+                signal: options.signal,
+                env: {
+                    ...process.env,
+                    BEDROCK_REGIONS: config.regions.join(","),
+                    AWS_PROFILE: config.profile,
+                    AWS_CLI_AUTO_PROMPT: "off",
+                    AWS_PAGER: "",
+                    NO_COLOR: "1",
+                    PAT_SKIP_UPDATE_CHECK: "1",
                 },
-            );
+            });
             if (options.signal?.aborted) throw new UsageError("cancelled");
             const observedAt = now();
             // Legacy reports have no explicit range, so a UTC rollover cannot be safely relabelled.

package/src/usage.ts

@@ -113,8 +113,9 @@ export const runUsage: UsageRunner = (program, args, options) =>
         );
         child.on("close", (code) => finish(code === 0 ? undefined : new UsageError(classify(stderr))));
         options.signal?.addEventListener("abort", abort, { once: true });
+        // A referenced timer keeps a stalled program's timeout alive when nothing else holds the event loop. It is
+        // cleared in finish(), so a program that answers does not delay exit.
         timer = setTimeout(() => finish(new UsageError("timeout")), options.timeout);
-        timer.unref();
         if (options.signal?.aborted) abort();
     });
 export const usageExecutable = (config: ResolvedConfig): string =>