@shardflux/cli 0.20.0 → 0.22.0

package/dist/account-commands.js

@@ -21,6 +21,7 @@ import { CLI_VERSION, UUID, parseDuration, parsePositiveInt } from "./args.js";
 import { openUrl } from "./browser.js";
 import { defaultClientName, startDeviceAuthorization, waitForDeviceSession } from "./browser-login.js";
 import { setupGuide, setupGuideText } from "./agent-setup.js";
+import { allOrgs, allProjects, byRef, choices, findOrg, gone, keyOrganizationWarning, keyScope, resolveOrg, resolveProject, staleDefaultOrg } from "./account-scope.js";
 import { readFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { legalFields, requireTermsAcceptance, showLegalNotice } from "./legal.js";
@@ -135,100 +136,6 @@ async function withStepUp(ctx, account, call) {
         return call();
     }
 }
-// ---- organization / project resolution ------------------------------------------------------------------------
-async function allOrgs(account) {
-    const rows = [];
-    for await (const o of account.organizations.listAll())
-        rows.push(o);
-    return rows;
-}
-async function allProjects(account, organizationId) {
-    const rows = [];
-    for await (const p of account.projects.listAll(organizationId))
-        rows.push(p);
-    return rows;
-}
-const choices = (rows) => rows.map((r) => `  ${r.id}  ${r.slug}  ${r.name}`).join('\n');
-function byRef(rows, ref) {
-    const exact = rows.find((r) => r.id === ref || r.slug === ref);
-    if (exact)
-        return exact;
-    const named = rows.filter((r) => r.name.toLowerCase() === ref.toLowerCase());
-    return named.length === 1 ? named[0] : undefined;
-}
-const gone = (err) => err instanceof ShardfluxApiError && (err.status === 404 || err.status === 403);
-async function findOrg(account, ref) {
-    if (UUID.test(ref))
-        return account.organizations.get(ref);
-    const hit = byRef(await allOrgs(account), ref);
-    if (!hit)
-        throw new NotFoundError(`No organization "${ref}" among yours.`, 'list them: shard orgs list');
-    return hit;
-}
-/** `ref` (a positional), else --org, else the saved default, else the only organization. */
-async function resolveOrg(ctx, account, values, ref) {
-    const given = ref ?? str(values.org);
-    if (given !== undefined)
-        return findOrg(account, given);
-    const saved = ctx.store.profile(ctx.apiUrl).organization_id;
-    if (saved) {
-        try {
-            return await account.organizations.get(saved);
-        }
-        catch (err) {
-            if (gone(err))
-                throw new NotFoundError(`The default organization ${saved} is no longer available to you.`, 'pick another: shard orgs use <org> (list: shard orgs list)');
-            throw err;
-        }
-    }
-    const orgs = await allOrgs(account);
-    if (orgs.length === 1)
-        return orgs[0];
-    if (orgs.length === 0)
-        throw new UsageError('You have no organization yet.', 'create one with a project and an API key: shard setup (or shard orgs create <name>)');
-    throw new UsageError(`You belong to ${orgs.length} organizations; pick one with --org <id|slug>:\n${choices(orgs)}\n`, 'or save a default: shard orgs use <id|slug>');
-}
-/** `ref` (a positional), else --project, else the saved default (unless --org names another), else the only project. */
-async function resolveProject(ctx, account, values, ref) {
-    const given = ref ?? str(values.project);
-    const orgFlag = str(values.org);
-    if (given !== undefined && UUID.test(given)) {
-        const p = await account.projects.get(given);
-        if (orgFlag !== undefined) {
-            const org = await findOrg(account, orgFlag);
-            if (p.organization_id !== org.id)
-                throw new UsageError(`project ${given} is not in organization ${org.slug}`);
-        }
-        return p;
-    }
-    const profile = ctx.store.profile(ctx.apiUrl);
-    if (given === undefined && profile.project_id && orgFlag === undefined) {
-        try {
-            return await account.projects.get(profile.project_id);
-        }
-        catch (err) {
-            if (gone(err))
-                throw new NotFoundError(`The default project ${profile.project_id} is no longer available to you.`, 'pick another: shard projects use <project> (list: shard projects list)');
-            throw err;
-        }
-    }
-    const org = await resolveOrg(ctx, account, values);
-    const projects = await allProjects(account, org.id);
-    if (given !== undefined) {
-        const hit = byRef(projects, given);
-        if (!hit)
-            throw new NotFoundError(`No project "${given}" in ${org.name} (${org.slug}).`, 'list them: shard projects list');
-        return hit;
-    }
-    const saved = profile.project_id ? projects.find((p) => p.id === profile.project_id) : undefined;
-    if (saved)
-        return saved;
-    if (projects.length === 1)
-        return projects[0];
-    if (projects.length === 0)
-        throw new UsageError(`${org.name} (${org.slug}) has no project yet.`, 'create one: shard projects create <name> (or shard setup)');
-    throw new UsageError(`${org.name} has ${projects.length} projects; pick one with --project <id|slug>:\n${choices(projects)}\n`, 'or save a default: shard projects use <id|slug>');
-}
 /** Removes a saved default (and the saved key) that pointed into an organization that is gone. */
 function forgetOrganization(ctx, organizationId, projectIds) {
     ctx.store.update(ctx.apiUrl, (p) => {
@@ -593,30 +500,40 @@ async function runSetup(ctx, values, account) {
             if (!gone(err))
                 throw err;
             if (!ctx.json)
-                ctx.io.stderr.write(`note: the saved API key ${profile.api_key.key_id} belongs to a project you cannot see; creating a key for your own.\n`);
+                ctx.io.stderr.write(`note: the saved API key ${profile.api_key.key_id} belongs to organization ${keyCheck.organizationId}, which you are no longer in; making a key for one of yours.\n`);
             keyCheck = { ok: false, reason: 'another account' };
         }
     }
+    // Several organizations: which one this setup picked, and how that choice is kept and changed (0.20.2+).
+    let orgCount = 1;
     if (home) {
         org = home.org;
         project = home.project;
     }
     else {
         const orgs = await allOrgs(account);
+        orgCount = orgs.length;
         const orgRef = str(values.org);
         const savedOrg = profile.organization_id ? orgs.find((o) => o.id === profile.organization_id) : undefined;
         if (orgRef !== undefined)
             org = await findOrg(account, orgRef);
         else if (savedOrg)
             org = savedOrg;
-        else if (orgs.length === 1)
+        else if (profile.organization_id && orgs.length > 1)
+            throw staleDefaultOrg(profile.organization_id, orgs);
+        else if (orgs.length === 1) {
             org = orgs[0];
+            if (profile.organization_id && profile.organization_id !== org.id && !ctx.json)
+                ctx.io.stderr.write(`note: your saved default organization ${profile.organization_id} is no longer one of yours; using ${org.name} (${org.slug}).\n`);
+        }
         else if (orgs.length === 0) {
             org = await account.organizations.create({ name: str(values['org-name'])?.trim() || defaultOrgName(me.user) });
             created.organization = true;
         }
-        else
-            throw new UsageError(`You belong to ${orgs.length} organizations; pick one with --org <id|slug>:\n${choices(orgs)}\n`, 'or save a default first: shard orgs use <id|slug>');
+        else {
+            throw new UsageError(`You belong to ${orgs.length} organizations; pick one with --org <id|slug>:\n${choices(orgs)}\n` +
+                `The one you pick becomes this computer's default, with an API key for it (saved in ${ctx.store.file}); switch later: shard setup --org <id|slug> --new-key\n`, 'or save a default first: shard orgs use <id|slug>');
+        }
         const projects = created.organization ? [] : await allProjects(account, org.id);
         const projectRef = str(values.project);
         const savedProject = profile.project_id ? projects.find((p) => p.id === profile.project_id) : undefined;
@@ -680,6 +597,7 @@ async function runSetup(ctx, values, account) {
         codex = { ...await cloud.codex.waitConnector({ timeoutMs: ctx.wakeTimeoutMs, signal: ctx.signal }) };
     }
     const envNote = ctx.io.env.SHARDFLUX_API_KEY?.trim() ? 'note: SHARDFLUX_API_KEY is set in this environment and wins over the saved key; unset it to use the saved key.\n' : '';
+    const warnings = envNote ? [{ code: 'api_key_environment_override', message: 'SHARDFLUX_API_KEY is set in this environment and wins over the saved key.', fix: 'unset SHARDFLUX_API_KEY' }] : [];
     return {
         text: (keep ? 'Already set up; the saved API key works.\n' : 'Set up.\n') +
             kv([
@@ -688,6 +606,7 @@ async function runSetup(ctx, values, account) {
                 ['api key', `"${key.name}" ${key.key_id} (tools: ${toolsText(permissions)}) ${keep ? 'saved earlier' : 'created'}, saved in ${ctx.store.file}`],
             ]) +
             envNote +
+            (orgCount > 1 ? `${org.name} is your default organization on this computer (saved in ${ctx.store.file}, with the key); switch: shard setup --org <id|slug> --new-key\n` : '') +
             (codex ? 'Codex Cloud is ready. One account executor; no pairing. Its residency is billed as workspace usage.\n' : '') +
             nextLines(),
         data: {
@@ -699,6 +618,7 @@ async function runSetup(ctx, values, account) {
             credentials_file: ctx.store.file,
             next: NEXT_WORKSPACE,
             next_steps: NEXT_STEPS,
+            ...(warnings.length ? { warnings } : {}),
         },
     };
 }
@@ -767,7 +687,7 @@ async function browserSignIn(ctx, values, noticeShown = false) {
         else if (!noticeShown)
             showLegalNotice(ctx);
         // A resumed request was opened (or printed) by the command that started it.
-        const opened = !resumed && values.open !== false && openUrl(d.verification_uri_complete, ctx.io.env);
+        const opened = !resumed && values.open !== false && (await openUrl(d.verification_uri_complete, ctx.io.env));
         const minutes = Math.max(1, Math.round(d.expires_in / 60));
         if (!ctx.json) {
             ctx.io.stderr.write(`${resumed ? 'Continuing the sign-in started earlier' : opened ? 'Opening your browser to sign in' : 'Open this page to sign in'}: ${d.verification_uri_complete}\n` +
@@ -852,6 +772,32 @@ export function agentSetupGuide(ctx) {
     const profile = ctx.store.profile(ctx.apiUrl);
     return setupGuide({ signedIn: ctx.sessionSource() !== null, email: profile.session?.user?.email ?? null, apiKey: profile.api_key !== undefined || Boolean(ctx.io.env.SHARDFLUX_API_KEY?.trim()) });
 }
+/**
+ * After `orgs use` / `projects use` (0.20.2+): the defaults moved, but workspace, agent and usage commands use the API
+ * key, which may act in another organization. Says so; on a terminal offers to make a key for the new default (a
+ * `shard setup --new-key` for it), otherwise names that command. Nothing when the key is already there (or none).
+ */
+async function keyElsewhereOffer(ctx, account, orgId, loadOrg, setupValues) {
+    const key = await keyScope(ctx);
+    if (key === null || key.organizationId === orgId)
+        return { text: '', data: {} };
+    const org = await loadOrg();
+    const w = keyOrganizationWarning(key, await allOrgs(account), org, str(setupValues.project));
+    const { fix, message: warning } = w;
+    if (key.source === 'file' && ctx.input.interactive && !ctx.json) {
+        ctx.io.stderr.write(`${warning}\n`);
+        const answer = (await ctx.input.answer(`Make an API key for ${org.name} and save it in place of ${key.keyId}? [y/N] `))?.trim() ?? '';
+        if (/^y(es)?$/i.test(answer)) {
+            const r = await runSetup(ctx, { ...setupValues, 'new-key': true, codex: false }, account);
+            return { text: r.text, data: { setup: r.data } };
+        }
+    }
+    else if (!ctx.json)
+        ctx.io.stderr.write(`warning: ${warning}\n`);
+    if (!ctx.json)
+        ctx.io.stderr.write(`fix: ${fix}\n`);
+    return { text: '', data: { api_key: { key_id: key.keyId, source: key.source, organization_id: key.organizationId, project_id: key.projectId }, warnings: [w] } };
+}
 // ---- handlers --------------------------------------------------------------------------------------------------
 export const ACCOUNT_HANDLERS = {
     async 'auth register'(ctx, values) {
@@ -1358,13 +1304,15 @@ export const ACCOUNT_HANDLERS = {
         return 0;
     },
     async 'orgs use'(ctx, values, [ref]) {
-        const org = await resolveOrg(ctx, ctx.account(), values, ref);
+        const account = ctx.account();
+        const org = await resolveOrg(ctx, account, values, ref);
         ctx.store.update(ctx.apiUrl, (p) => {
             if (p.organization_id !== org.id)
                 delete p.project_id;
             p.organization_id = org.id;
         });
-        out(ctx, `Default organization: ${org.name} (${org.slug}, ${org.id}).\n`, { default_organization_id: org.id, organization: org });
+        const key = await keyElsewhereOffer(ctx, account, org.id, () => Promise.resolve(org), { org: org.id });
+        out(ctx, `Default organization: ${org.name} (${org.slug}, ${org.id}).\n${key.text}`, { default_organization_id: org.id, organization: org, ...key.data });
         return 0;
     },
     async 'orgs export'(ctx, values, [ref]) {
@@ -1479,12 +1427,14 @@ export const ACCOUNT_HANDLERS = {
         return 0;
     },
     async 'projects use'(ctx, values, [ref]) {
-        const p = await resolveProject(ctx, ctx.account(), values, ref);
+        const account = ctx.account();
+        const p = await resolveProject(ctx, account, values, ref);
         ctx.store.update(ctx.apiUrl, (x) => {
             x.organization_id = p.organization_id;
             x.project_id = p.id;
         });
-        out(ctx, `Default project: ${p.name} (${p.slug}, ${p.id}) of organization ${p.organization_id}.\n`, { default_project_id: p.id, default_organization_id: p.organization_id, project: p });
+        const key = await keyElsewhereOffer(ctx, account, p.organization_id, () => account.organizations.get(p.organization_id), { project: p.id });
+        out(ctx, `Default project: ${p.name} (${p.slug}, ${p.id}) of organization ${p.organization_id}.\n${key.text}`, { default_project_id: p.id, default_organization_id: p.organization_id, project: p, ...key.data });
         return 0;
     },
     async 'api-keys list'(ctx, values) {
@@ -1673,13 +1623,13 @@ export const ACCOUNT_HANDLERS = {
             if (!(err instanceof ShardfluxApiError && err.code === 'conflict' && err.details?.reason === 'subscription_exists'))
                 throw err;
             const portal = await account.billing.portal(org.id);
-            const opened = values.open === true && openUrl(portal.url, ctx.io.env);
+            const opened = values.open === true && (await openUrl(portal.url, ctx.io.env));
             out(ctx, `${org.name} already has a subscription: plan changes happen in the Stripe billing portal (it shows the new price before you confirm):\n${portal.url}\n${values.open === true ? (opened ? 'Opened it in your browser.\n' : 'Could not open a browser; open the URL yourself.\n') : ''}`, { subscription_exists: true, organization_id: org.id, plan_key: plan.plan_key, portal_url: portal.url, opened });
             return 0;
         }
         if (!checkout.url && !checkout.subscription_active)
             throw new UsageError(`checkout ${checkout.id} is ${checkout.status} and has no URL; start again: shard billing upgrade ${plan.plan_key}`);
-        const opened = values.open === true && checkout.url !== null && openUrl(checkout.url, ctx.io.env);
+        const opened = values.open === true && checkout.url !== null && (await openUrl(checkout.url, ctx.io.env));
         if (!ctx.json) {
             ctx.io.stdout.write(`Checkout for ${plan.name} (${plan.plan_key}, ${priceText(catalog, plan.plan_key)}) for ${org.name}:\n${checkout.url ?? '-'}\n` +
                 `A person pays there (Stripe Checkout${checkout.expires_at ? `; the link works until ${time(checkout.expires_at)}` : ''}). The plan is active once Stripe confirms the payment${values.wait === true ? '.' : ': shard billing status'}\n` +
@@ -1699,7 +1649,7 @@ export const ACCOUNT_HANDLERS = {
         const account = ctx.account();
         const org = await resolveOrg(ctx, account, values);
         const portal = await account.billing.portal(org.id);
-        const opened = values.open === true && openUrl(portal.url, ctx.io.env);
+        const opened = values.open === true && (await openUrl(portal.url, ctx.io.env));
         out(ctx, `Billing portal of ${org.name} (plan changes, payment methods, invoices, cancellation; the link is short-lived):\n${portal.url}\n${values.open === true ? (opened ? 'Opened it in your browser.\n' : 'Could not open a browser; open the URL yourself.\n') : ''}`, { organization_id: org.id, url: portal.url, opened });
         return 0;
     },

package/dist/account-pool.d.ts

@@ -1,16 +1,28 @@
 /**
- * `shard agents accounts` (0.18.0+); with --json every write prints the updated `{accounts, pool}` block (the menu bar
- * redraws from it), plus the account it changed.: the organization's Claude and ChatGPT/Codex accounts, with each one's usage
- * windows, reset times, status and threads (docs/progress/account-pool.md). Sign-ins run the provider's own login in a
- * workspace, as `shard agents credentials login claude` does; API keys come from standard input and are write-only.
+ * `shard agents accounts` (0.18.0+): the organization's Claude and ChatGPT/Codex accounts, with each one's usage
+ * windows, reset times and status, and which one is active. Each provider has one active account: new conversations
+ * start with its login and running conversation VMs get it. The person chooses it (`shard agents accounts use`);
+ * nothing switches on usage (switching accounts automatically because usage runs out is against the providers' terms).
+ * With --json every write prints the updated `{accounts, pool}` block (the menu bar redraws from it), plus the account
+ * it changed. Sign-ins run the provider's own login in a workspace, as `shard agents credentials login claude` does.
  */
-import type { AgentAccount, AgentAccountList } from '@shardflux/sdk';
+import type { AgentAccount, AgentAccountList, AgentAccountWindow } from '@shardflux/sdk';
 import type { Ctx, Handler } from './commands.js';
-import { CodedError } from './errors.js';
-import type { HubCloud } from './cli-proxy-hub.js';
+/**
+ * Codex names its windows primary and secondary; their length says which is the 5-hour and which the weekly one (a
+ * ChatGPT Pro Max login's primary window is its weekly one). Unknown length: the provider's name.
+ */
+export declare const windowLabel: (w: AgentAccountWindow) => string;
 /** "in 2h 10m", "in 4d 8h", "in 41m"; "now" once passed. */
 export declare function resetIn(resetsAt: string | null, now: number): string | null;
 export declare const planName: (planType: string) => string;
+/** The provider's active account; an API before 2026-10-12 sends only `preferred` (the same account). */
+export declare const isActive: (a: AgentAccount) => boolean;
+/**
+ * Whether the caller can make it the active account: the API says so (`can_activate`, 2026-10-12+); an API from before
+ * it, by the same rules as far as the list shows them (a working subscription sign-in, not active, team or yours).
+ */
+export declare const canActivate: (a: AgentAccount) => boolean;
 /** Account references: the id, `<provider>:<n>` (its place in the list, from 1), the email or the label. */
 export declare function findAccount(list: AgentAccountList, ref: string): AgentAccount;
 /** The compact list: one row per account, grouped by provider. */
@@ -22,11 +34,3 @@ export declare function codexLoginUrls(output: string): string[];
 export declare const ACCOUNT_POOL_HANDLERS: Record<string, Handler>;
 /** The `accounts` block of `shard agents targets --json` (0.18.0+): the account list for the menu bar; null when it cannot be read. */
 export declare function targetsAccounts(ctx: Ctx): Promise<AgentAccountList | null>;
-/** The conversation's thread runs on the account pool (its `account.mode`, API with the pool). */
-export declare function conversationPooled(conversation: unknown): boolean;
-/** A pooled thread has no provider login on its session, so claude.ai, Claude Desktop and the Codex app cannot reach it. */
-export declare const pooledNeedsT3: (ref: string) => CodedError;
-/** Test seam: the hub cloud the pool toggle ensures (the SDK's by default). */
-export declare const accountPoolSeams: {
-    hubCloud?: (ctx: Ctx) => HubCloud;
-};

package/dist/account-pool.js

@@ -1,17 +1,17 @@
-import { ShardfluxApiError } from '@shardflux/sdk';
-import { out, readInput, resolveWorkspace } from "./commands.js";
-import { CodedError, UsageError, describeError } from "./errors.js";
+import { out, resolveWorkspace } from "./commands.js";
+import { UsageError } from "./errors.js";
 import { claudeLoginUrls, requireClaudeTerminal, runWorkspaceLogin } from "./claude-cloud-login.js";
 import { openMachine } from "./filesystem-commands.js";
-import { t3Install } from "./t3-mode.js";
-import { ensureCliProxyHub, sdkHubCloud } from "./cli-proxy-hub.js";
-import { homeProject } from "./cli-proxy.js";
-import { progress } from "./progress.js";
 const PROVIDERS = { claude: 'Claude', codex: 'ChatGPT / Codex' };
 const WINDOW_LABELS = { five_hour: '5-hour', seven_day: 'Weekly', seven_day_opus: 'Weekly Opus', seven_day_sonnet: 'Weekly Sonnet', primary: 'Primary', secondary: 'Secondary' };
-/** Codex names its windows primary and secondary; their length says which is the 5-hour and which the weekly one. */
-const windowLabel = (w) => (w.window === 'primary' || w.window === 'secondary') && w.window_minutes === 300 ? '5-hour'
-    : (w.window === 'primary' || w.window === 'secondary') && w.window_minutes === 10080 ? 'Weekly' : WINDOW_LABELS[w.window] ?? w.window;
+/** A window's length as a title, as Claude's windows read: "Weekly", "5-hour", "2-day", "90-minute". */
+const lengthLabel = (m) => m === 10080 ? 'Weekly' : m % 1440 === 0 ? `${m / 1440}-day` : m % 60 === 0 ? `${m / 60}-hour` : `${m}-minute`;
+/**
+ * Codex names its windows primary and secondary; their length says which is the 5-hour and which the weekly one (a
+ * ChatGPT Pro Max login's primary window is its weekly one). Unknown length: the provider's name.
+ */
+export const windowLabel = (w) => (w.window === 'primary' || w.window === 'secondary') && typeof w.window_minutes === 'number' && w.window_minutes > 0
+    ? lengthLabel(w.window_minutes) : WINDOW_LABELS[w.window] ?? w.window;
 const STATUS_LABELS = { signed_in: 'Signed in', low: 'Low', limited: 'Limited', expired: 'Expired' };
 const CLAUDE_VERSION = '2.1.289';
 function provider(value, what = 'provider') {
@@ -37,7 +37,14 @@ const pct = (w) => `${Math.round(w.used_percent)}%`;
 const PLAN_NAMES = { free: 'Free', go: 'Go', plus: 'Plus', pro: 'Pro', prolite: 'Pro Lite', promax: 'Pro Max', max: 'Max' };
 export const planName = (planType) => PLAN_NAMES[planType] ?? planType.charAt(0).toUpperCase() + planType.slice(1);
 const plan = (a) => a.kind === 'api_key' ? 'API key' : a.plan_type ? planName(a.plan_type) : '';
-const threads = (n) => `${n} ${n === 1 ? 'thread' : 'threads'}`;
+const threads = (n) => `${n} ${n === 1 ? 'conversation' : 'conversations'}`;
+/** The provider's active account; an API before 2026-10-12 sends only `preferred` (the same account). */
+export const isActive = (a) => a.active ?? a.preferred;
+/**
+ * Whether the caller can make it the active account: the API says so (`can_activate`, 2026-10-12+); an API from before
+ * it, by the same rules as far as the list shows them (a working subscription sign-in, not active, team or yours).
+ */
+export const canActivate = (a) => a.can_activate ?? (a.kind === 'oauth' && !isActive(a) && a.status !== 'expired' && (a.scope === 'team' || a.mine));
 const name = (a) => a.email && a.label !== a.email ? `${a.label} (${a.email})` : a.label;
 function bar(used, width = 10) {
     const filled = Math.max(0, Math.min(width, Math.round(used / 100 * width)));
@@ -72,14 +79,22 @@ export function formatAccounts(list, now) {
         for (const a of rows) {
             const windows = a.kind === 'api_key' ? 'Pay as you go' : a.windows.filter(w => ['five_hour', 'seven_day', 'primary', 'secondary'].includes(w.window))
                 .map(w => `${windowLabel(w)} ${pct(w)}${resetIn(w.resets_at, now) ? ` (resets ${resetIn(w.resets_at, now) === 'now' ? 'now' : `in ${resetIn(w.resets_at, now)}`})` : ''}`).join(' · ') || 'No usage read yet';
-            const tags = [plan(a), a.preferred ? 'in use' : '', list.pool.pooled ? threads(a.threads) : ''].filter(Boolean).join(', ');
+            const tags = [plan(a), isActive(a) ? 'active' : ''].filter(Boolean).join(', ');
             lines.push(`  ${`${p}:${a.position + 1}`.padEnd(9)} ${name(a)}${tags ? ` (${tags})` : ''} · ${STATUS_LABELS[a.status]}${a.status === 'expired' ? ': sign in again with shard agents accounts add ' + p : ''}`);
             lines.push(`  ${''.padEnd(9)} ${windows}${asOf(a, now)}`);
         }
     }
-    if (list.pool.pooled) {
-        const open = list.accounts.reduce((n, a) => n + a.threads, 0), used = list.accounts.filter(a => a.threads > 0).length;
-        lines.push(`Pooled: ${threads(open)} on ${used} ${used === 1 ? 'account' : 'accounts'}; open threads remotely in T3 Code.`);
+    // Only what the caller can do: the accounts the API says they can make active (can_activate).
+    for (const p of ['claude', 'codex']) {
+        const rows = list.accounts.filter(a => a.provider === p);
+        if (!rows.length)
+            continue;
+        const can = rows.filter(canActivate);
+        const ref = can.length === 1 ? `${p}:${can[0].position + 1}` : `${p}:<n>`;
+        if (can.length)
+            lines.push(rows.some(isActive) ? `Switch ${PROVIDERS[p]}: shard agents accounts use ${ref}` : `No ${PROVIDERS[p]} account is active: shard agents accounts use ${ref}`);
+        else if (!rows.some(isActive))
+            lines.push(`No ${PROVIDERS[p]} account is active: an organization owner or admin makes one active.`);
     }
     return `${lines.join('\n')}\n`;
 }
@@ -89,7 +104,7 @@ export function formatUsage(list, now) {
         return formatAccounts(list, now);
     const lines = [];
     for (const a of list.accounts) {
-        lines.push(`${PROVIDERS[a.provider]} · ${name(a)}${plan(a) ? ` · ${plan(a)}` : ''} · ${STATUS_LABELS[a.status]} · ${threads(a.threads)}${a.preferred ? ' · in use' : ''}${asOf(a, now)}`);
+        lines.push(`${PROVIDERS[a.provider]} · ${name(a)}${plan(a) ? ` · ${plan(a)}` : ''} · ${STATUS_LABELS[a.status]}${isActive(a) ? ` · active · ${threads(a.threads)}` : ''}${asOf(a, now)}`);
         if (a.kind === 'api_key')
             lines.push('  Pay as you go');
         else if (!a.windows.length)
@@ -142,17 +157,17 @@ export function codexLoginUrls(output) {
 /**
  * Adds a subscription account: the provider's own sign-in runs in a fresh profile in the workspace (Claude:
  * `claude auth login --claudeai`; Codex: `codex login --device-auth`), its login files go to the API, and the profile
- * is deleted. The workspace's own logins are untouched; the API delivers the account threads use.
+ * is deleted. The workspace's own logins are untouched; the API delivers the active account's login.
  */
 async function signIn(ctx, values, app) {
     if (ctx.json || !ctx.io.stdin.isTTY || !ctx.io.stdin.setRawMode || !ctx.io.stdin.on) {
-        throw new UsageError(`Signing in to ${PROVIDERS[app]} runs in a terminal: shard agents accounts add ${app} (or --api-key-stdin for an API key).`);
+        throw new UsageError(`Signing in to ${PROVIDERS[app]} runs in a terminal: shard agents accounts add ${app}`);
     }
     if (app === 'claude')
         requireClaudeTerminal(ctx);
     const ws = await signInWorkspace(ctx, values);
     const api = ctx.cloud().agentAccounts;
-    const claim = await api.signIn(app, ws.id, { ...(typeof values.label === 'string' ? { label: values.label } : {}), ...(values.scope === 'team' || values.scope === 'personal' ? { scope: values.scope } : {}) });
+    const claim = await api.signIn(app, ws.id, typeof values.label === 'string' ? { label: values.label } : {});
     const root = `/tmp/shard-account-${claim.sign_in_id}`;
     const session = `account-sign-in-${claim.sign_in_id}`;
     const cell = ws.cell({ agentLabel: ctx.agentLabel, transitionTimeoutMs: ctx.wakeTimeoutMs });
@@ -191,16 +206,6 @@ async function signIn(ctx, values, app) {
             await api.cancelSignIn(claim.sign_in_id).catch(() => undefined);
     }
 }
-/**
- * Pooled threads are used remotely in T3 Code (desktop, web, phone): they have no provider login for claude.ai or the
- * ChatGPT app. Where new conversations open stays the person's choice (Settings, or agents targets --open-in).
- */
-function remoteHint(ctx) {
-    return t3Install(ctx.io.env)
-        ? 'Use pooled threads remotely in T3 Code: shard agents targets --open-in claude=t3,codex=t3 opens new conversations there.\n'
-        : 'Use pooled threads remotely in T3 Code (desktop, web and phone): install it from https://t3.codes.\n';
-}
-const notAvailable = () => new CodedError('pool_not_available', 'Pooling accounts is not available for this organization.', 'Your accounts keep serving threads directly; shard agents accounts shows their usage.');
 export const ACCOUNT_POOL_HANDLERS = {
     async 'agents accounts'(ctx, values) {
         const list = await ctx.cloud().agentAccounts.list({ provider: optionalProvider(values.provider) });
@@ -218,20 +223,9 @@ export const ACCOUNT_POOL_HANDLERS = {
         return 0;
     },
     async 'agents accounts add'(ctx, values, [app]) {
-        const p = provider(app);
-        if (values.scope !== undefined && values.scope !== 'personal' && values.scope !== 'team')
-            throw new UsageError('--scope is personal or team');
-        let account;
-        if (values['api-key-stdin'] === true) {
-            const key = Buffer.from(await readInput(ctx, '-', 64 * 1024, '--api-key-stdin')).toString('utf8').trim();
-            if (!key || /\s/.test(key))
-                throw new UsageError('--api-key-stdin reads one API key from standard input, e.g. pbpaste | shard agents accounts add claude --api-key-stdin');
-            ctx.addSecret(key);
-            account = await ctx.cloud().agentAccounts.addApiKey(p, key, { ...(typeof values.label === 'string' ? { label: values.label } : {}), ...(values.scope === 'team' || values.scope === 'personal' ? { scope: values.scope } : {}) });
-        }
-        else
-            account = await signIn(ctx, values, p);
-        out(ctx, `Added ${name(account)} (${PROVIDERS[account.provider]}${plan(account) ? ` ${plan(account)}` : ''}) as ${account.provider}:${account.position + 1}.\n`, ctx.json ? { ...await ctx.cloud().agentAccounts.list(), account } : account);
+        const account = await signIn(ctx, values, provider(app));
+        const ref = `${account.provider}:${account.position + 1}`;
+        out(ctx, `Added ${name(account)} (${PROVIDERS[account.provider]}${plan(account) ? ` ${plan(account)}` : ''}) as ${ref}${isActive(account) ? ', the active account' : `. Make it active: shard agents accounts use ${ref}`}.\n`, ctx.json ? { ...await ctx.cloud().agentAccounts.list(), account } : account);
         return 0;
     },
     async 'agents accounts remove'(ctx, _values, [ref]) {
@@ -241,33 +235,17 @@ export const ACCOUNT_POOL_HANDLERS = {
         out(ctx, `Removed ${name(account)} (${PROVIDERS[account.provider]}).\n`, ctx.json ? { ...await api.list(), removed: account.id, provider: account.provider } : null);
         return 0;
     },
-    async 'agents accounts move'(ctx, _values, [ref, direction]) {
-        if (direction !== 'up' && direction !== 'down')
-            throw new UsageError('move takes an account and up or down, e.g. shard agents accounts move claude:2 up');
+    async 'agents accounts use'(ctx, _values, [ref]) {
         const api = ctx.cloud().agentAccounts;
-        const account = findAccount(await api.list(), ref);
-        const list = await api.move(account.id, direction);
-        const moved = list.accounts.find(a => a.id === account.id) ?? account;
-        out(ctx, moved.position === account.position ? `${name(account)} is already ${direction === 'up' ? 'first' : 'last'}.\n` : `Moved ${name(moved)} to ${moved.provider}:${moved.position + 1}.\n`, { ...list, account: moved });
-        return 0;
-    },
-    async 'agents accounts pool'(ctx, _values, [state]) {
-        if (state !== 'on' && state !== 'off')
-            throw new UsageError('pool is on or off');
-        let pool;
-        try {
-            pool = await ctx.cloud().agentPool.set({ pooled: state === 'on' });
-        }
-        catch (error) {
-            if (error instanceof ShardfluxApiError && (error.status === 404 || error.details?.reason === 'pool_not_on_plan'))
-                throw notAvailable();
-            throw error;
-        }
-        // Pooled threads run through the account hub: it needs the router (codex-connector 5) and its hub token.
-        const hub = pool.pooled ? await ensurePoolHub(ctx) : null;
-        out(ctx, pool.pooled
-            ? `Pooled: each new thread runs on the account with the most room. Running threads keep their account.\n${hub ? `The account hub is not ready (${hub}); new threads start directly until it is. Run shard agents accounts pool on again.\n` : ''}${remoteHint(ctx)}`
-            : 'Direct: new threads use your account as before. Pooled threads keep their account until they end.\n', ctx.json ? { ...await ctx.cloud().agentAccounts.list(), pool, ...(pool.pooled ? { hub: hub ? { ready: false, error: hub } : { ready: true } } : {}) } : pool);
+        const before = await api.list();
+        const account = findAccount(before, ref);
+        const previous = before.accounts.find(a => a.provider === account.provider && isActive(a) && a.id !== account.id);
+        const list = await api.activate(account.id);
+        const active = list.accounts.find(a => a.id === account.id) ?? account;
+        const follows = account.provider === 'claude'
+            ? 'New conversations start with it; running ones continue on it, and Remote Control turns back on by itself.'
+            : `New conversations and every running conversation VM use it; Codex Cloud moves to it${previous ? ` (Cloud threads started on ${name(previous)} stay in that ChatGPT account)` : ''}.`;
+        out(ctx, previous || !isActive(account) ? `${name(active)} is the active ${PROVIDERS[account.provider]} account. ${follows}\n` : `${name(active)} is already the active ${PROVIDERS[account.provider]} account.\n`, { ...list, account: active });
         return 0;
     },
 };
@@ -284,33 +262,6 @@ export async function targetsAccounts(ctx) {
         clearTimeout(timer);
     }
 }
-/** The conversation's thread runs on the account pool (its `account.mode`, API with the pool). */
-export function conversationPooled(conversation) {
-    const account = conversation?.account;
-    return account?.mode === 'pooled';
-}
-/** A pooled thread has no provider login on its session, so claude.ai, Claude Desktop and the Codex app cannot reach it. */
-export const pooledNeedsT3 = (ref) => new CodedError('t3_not_installed', `${ref} runs on pooled accounts; open it in T3 Code.`, `Install T3 Code from https://t3.codes, open it once, then run shard agents open t3 ${ref}.`);
 // `shard accounts …` runs the same handlers (hidden aliases in args.ts).
 for (const [path, handler] of Object.entries(ACCOUNT_POOL_HANDLERS))
     ACCOUNT_POOL_HANDLERS[path.replace(/^agents /, '')] = handler;
-/**
- * The account hub in pool mode (W1): created or upgraded on codex-connector 5 with its hub token (POST
- * /v1/agent-pool/hub-token, minted for the hub workspace). Null when ready, else what stopped it.
- */
-async function ensurePoolHub(ctx) {
-    try {
-        const cloud = ctx.cloud();
-        const hub = (accountPoolSeams.hubCloud ?? ((c) => sdkHubCloud(c.cloud(), { signal: c.signal, wakeTimeoutMs: c.wakeTimeoutMs, agentLabel: c.agentLabel, homeProject: (org) => homeProject(c, org) })))(ctx);
-        const ensured = await ensureCliProxyHub(hub, { dir: ctx.store.dir, apiUrl: ctx.apiUrl, progress: (m) => progress(ctx, m),
-            pool: { hubToken: async (workspaceId) => (await cloud.request('POST', '/v1/agent-pool/hub-token', { json: { workspace_id: workspaceId } })).token } });
-        for (const value of [ensured.info.callback_url, ensured.info.management_key])
-            ctx.addSecret(value);
-        return null;
-    }
-    catch (error) {
-        return describeError(error).message;
-    }
-}
-/** Test seam: the hub cloud the pool toggle ensures (the SDK's by default). */
-export const accountPoolSeams = {};

package/dist/account-scope.d.ts

@@ -0,0 +1,65 @@
+import type { Organization, Project, ShardfluxAccount } from '@shardflux/sdk';
+import type { Values } from './args.js';
+import type { Ctx } from './commands.js';
+import { UsageError } from './errors.js';
+export declare function allOrgs(account: ShardfluxAccount): Promise<Organization[]>;
+export declare function allProjects(account: ShardfluxAccount, organizationId: string): Promise<Project[]>;
+export declare const choices: (rows: readonly {
+    id: string;
+    slug: string;
+    name: string;
+}[]) => string;
+export declare function byRef<T extends {
+    id: string;
+    slug: string;
+    name: string;
+}>(rows: readonly T[], ref: string): T | undefined;
+export declare const gone: (err: unknown) => boolean;
+export declare function findOrg(account: ShardfluxAccount, ref: string): Promise<Organization>;
+/** The fix for a saved default organization the person is no longer in. */
+export declare function staleDefaultOrg(saved: string, orgs: readonly Organization[]): UsageError;
+/** `ref` (a positional), else --org, else the saved default, else the only organization. */
+export declare function resolveOrg(ctx: Ctx, account: ShardfluxAccount, values: Values, ref?: string): Promise<Organization>;
+/** `ref` (a positional), else --project, else the saved default (unless --org names another), else the only project. */
+export declare function resolveProject(ctx: Ctx, account: ShardfluxAccount, values: Values, ref?: string): Promise<Project>;
+/** The API key in use (SHARDFLUX_API_KEY, else the saved one): where it acts. Null without a key or when it is rejected. */
+export interface KeyScope {
+    keyId: string;
+    /** Where the key comes from: SHARDFLUX_API_KEY or the credentials file. */
+    source: 'env' | 'file';
+    organizationId: string;
+    projectId: string;
+}
+export declare function keyScope(ctx: Ctx): Promise<KeyScope | null>;
+/** A default that points somewhere it should not, and the exact command that fixes it (`--json`: `warnings`). */
+export interface ScopeWarning {
+    code: 'default_organization_gone' | 'api_key_organization_gone' | 'api_key_in_other_organization' | 'api_key_environment_override';
+    message: string;
+    fix: string;
+}
+/**
+ * Plain warnings about defaults that point into an organization the signed-in person is no longer in: the saved
+ * default organization, and the API key's organization. Each names the command that fixes it.
+ */
+export declare function staleScopeWarnings(ctx: Ctx, orgs: readonly Organization[], key: KeyScope | null): ScopeWarning[];
+/** Compare membership before defaults: a departed organization is different from another one still accessible. */
+export declare function keyOrganizationWarning(key: KeyScope, orgs: readonly Organization[], target?: Organization, projectId?: string): ScopeWarning | null;
+/**
+ * The stale-default warnings for the signed-in person, or none: without a session (or with one the API no longer
+ * accepts) there is no list of their organizations to compare with, and the command itself goes on either way.
+ */
+export declare function sessionScopeWarnings(ctx: Ctx, key: KeyScope | null): Promise<ScopeWarning[]>;
+/** Warnings on stderr, one `warning:` line and its `fix:` each (text mode). */
+export declare function writeWarnings(ctx: Ctx, warnings: readonly ScopeWarning[]): void;
+/** The note for a default just saved in `org` while the API key acts in another organization (orgs use, projects use). */
+export declare function keyElsewhere(key: KeyScope, org: Organization): string;
+/**
+ * The project a T3 Connect sign-in is scoped by (0.20.2+). A sign-in is per person and organization, and a session in
+ * more than one organization must name one (the API answers 422 without `project_id`). --project, else a project of
+ * --org (the saved default or the key's project when it is in that organization, else its first), else the API key's
+ * project (T3 links the key's workspaces with the sign-in of the key's organization, and the onboarding row checks it
+ * with the key), else the saved default project. Undefined when none is known: one organization needs none.
+ */
+export declare function t3SignInProject(ctx: Ctx, values: Values): Promise<string | undefined>;
+/** The API's 422 for a session in several organizations without a project (production before train 22): what to run. */
+export declare function t3NeedsProject(err: unknown): UsageError | null;