@phnx-labs/agents-cli 1.22.68 → 1.22.70

package/dist/lib/smart-launch.js

@@ -90,15 +90,29 @@ export function formatEmptyAutoPoolError() {
         'mark one with `agents devices role <name> worker`, or widen the pool with `agents config set auto.pool all`.');
 }
 export function formatNoHealthyDeviceError(pool, signals, agent) {
+    let timedOutCount = 0;
     const excluded = pool.map((key) => {
         const signal = signals.get(key);
-        const reason = signal?.reachable !== true
-            ? 'unreachable'
-            : signal.headroom === 'loaded'
+        let reason;
+        if (signal?.reachable === true) {
+            reason = signal.headroom === 'loaded'
                 ? 'overloaded'
                 : signal.installed !== true || signal.signedIn !== true
                     ? 'no ready harness account'
                     : 'ineligible';
+        }
+        else if (signal?.timedOut) {
+            // A slow link is not an offline box. Saying "unreachable" here sent
+            // operators hunting a fleet outage that did not exist (PHNX-3682).
+            timedOutCount++;
+            reason = 'probe timed out';
+        }
+        else if (signal === undefined) {
+            reason = 'no probe signal';
+        }
+        else {
+            reason = 'unreachable';
+        }
         return `${key} (${reason})`;
     }).join(', ');
     const target = agent ? `can run ${agent}` : "for 'run auto'";
@@ -108,7 +122,16 @@ export function formatNoHealthyDeviceError(pool, signals, agent) {
     // in this error's own candidate set, not just the ones with a doc.
     const marked = describeAutoPool({ roster: pool });
     const poolNote = marked ? ` [pool: ${marked}]` : '';
-    return `agents: no healthy device ${target}${poolNote} — excluded: ${excluded}; earliest window resets unknown`;
+    // Only talk about usage windows when a device was actually turned away for
+    // one. A pool that timed out needs a link/latency hint, not a reset time.
+    const scope = timedOutCount === pool.length
+        ? `every probe (${pool.length}) exceeded`
+        : `${timedOutCount} of ${pool.length} probes exceeded`;
+    const hint = timedOutCount > 0
+        ? `; ${scope} the probe budget — those devices are likely up but slow to answer`
+            + ' (relayed Tailscale paths). Retry, or check `tailscale status` for a direct path.'
+        : '; earliest window resets unknown';
+    return `agents: no healthy device ${target}${poolNote} — excluded: ${excluded}${hint}`;
 }
 /**
  * Pick the least-loaded healthy device that can run `agent` when the harness is

package/dist/lib/staleness/detectors/permissions.js

@@ -202,25 +202,6 @@ function buildDroidDetector() {
         },
     };
 }
-function buildKiroDetector() {
-    return {
-        kind: 'permissions',
-        agent: 'kiro',
-        list({ versionHome }) {
-            const permissionsPath = path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
-            if (!fs.existsSync(permissionsPath))
-                return [];
-            try {
-                const config = yaml.parse(fs.readFileSync(permissionsPath, 'utf-8'));
-                if (config && Array.isArray(config.rules) && config.rules.length > 0) {
-                    return discoverPermissionGroups().map(g => g.name);
-                }
-            }
-            catch { /* parse fail */ }
-            return [];
-        },
-    };
-}
 function buildOpenClawDetector() {
     return {
         kind: 'permissions',
@@ -296,7 +277,6 @@ const handlers = {
     kimi: buildKimiDetector,
     cursor: buildCursorDetector,
     droid: buildDroidDetector,
-    kiro: buildKiroDetector,
     openclaw: buildOpenClawDetector,
     copilot: buildCopilotDetector,
     hermes: buildHermesDetector,

package/dist/lib/staleness/writers/commands.js

@@ -13,7 +13,7 @@
  *
  *  - native command file — `{agentDir}/<commandsSubdir>/<name>.md` (or .toml
  *    when the agent's format is toml). Standard path for Claude, Codex
- *    < 0.117.0, Cursor, OpenCode, Copilot, Amp, Kiro, Roo, Antigravity.
+ *    < 0.117.0, Cursor, OpenCode, Copilot, Amp, Roo, Antigravity.
  *
  * Source resolution is `resolveCommandSource` (user → system → extras —
  * project layer intentionally excluded).

package/dist/lib/staleness/writers/hooks.js

@@ -90,9 +90,9 @@ function buildHooksWriter(agent) {
             // so subrule-bundled guards (absolute paths outside the central hooks/
             // copy set) get registered into ~/.grok/hooks/hooks.json via
             // registerHooksForGrok — file copy alone only sees top-level available.hooks
-            // names (RUSH-1353). Copilot/Kiro/Goose load managed *.json under their
+            // names (RUSH-1353). Copilot/Goose load managed *.json under their
             // hooks dirs the same way.
-            if (agent === 'claude' || agent === 'codex' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'kiro' || agent === 'goose' || agent === 'cursor' || agent === 'grok' || agent === 'hermes' || agent === 'muse') {
+            if (agent === 'claude' || agent === 'codex' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'goose' || agent === 'cursor' || agent === 'grok' || agent === 'hermes' || agent === 'muse') {
                 registerHooksToSettings(agent, versionHome);
             }
             return { synced, paths };

package/dist/lib/storage/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `lib/storage` — the surface-agnostic core the managed-storage surfaces share:
+ *
+ *   - {@link selection}  the ONE managed-vs-BYO selection policy.
+ *   - {@link visibility} the ONE visibility model + product default (`me`).
+ *
+ * Consume the SELECTION + VISIBILITY POLICY from here; keep each surface's typed,
+ * `kind`-tagged backend adapter (endpoint, namespace, covers) in that surface's
+ * own module. `agents artifacts share` (`lib/share/`) and `agents traces`
+ * (`lib/traces/`) are the two current adapters; the `sessions` sync adapter is
+ * the next consumer.
+ */
+export { type StorageBackendKind, type StorageSelectionOpts, selectStorageBackendKind, isManagedSelection, } from './selection.js';
+export { type ShareVisibility, type VisibilityFlags, PUBLISH_VISIBILITY_LEVELS, EDITABLE_VISIBILITY_LEVELS, MANAGED_DEFAULT_VISIBILITY, BYO_DEFAULT_VISIBILITY, defaultVisibilityForBackend, explicitVisibility, resolveVisibility, publishVisibility, } from './visibility.js';

package/dist/lib/storage/index.js

@@ -0,0 +1,14 @@
+/**
+ * `lib/storage` — the surface-agnostic core the managed-storage surfaces share:
+ *
+ *   - {@link selection}  the ONE managed-vs-BYO selection policy.
+ *   - {@link visibility} the ONE visibility model + product default (`me`).
+ *
+ * Consume the SELECTION + VISIBILITY POLICY from here; keep each surface's typed,
+ * `kind`-tagged backend adapter (endpoint, namespace, covers) in that surface's
+ * own module. `agents artifacts share` (`lib/share/`) and `agents traces`
+ * (`lib/traces/`) are the two current adapters; the `sessions` sync adapter is
+ * the next consumer.
+ */
+export { selectStorageBackendKind, isManagedSelection, } from './selection.js';
+export { PUBLISH_VISIBILITY_LEVELS, EDITABLE_VISIBILITY_LEVELS, MANAGED_DEFAULT_VISIBILITY, BYO_DEFAULT_VISIBILITY, defaultVisibilityForBackend, explicitVisibility, resolveVisibility, publishVisibility, } from './visibility.js';

package/dist/lib/storage/selection.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The ONE managed-vs-BYO storage-backend selection policy.
+ *
+ * Every surface that persists to Phoenix-managed storage (`agents artifacts
+ * share` today, `agents sessions` sync next) makes the SAME choice: run on OUR
+ * managed infrastructure when the caller is signed in to Phoenix, and only fall
+ * back to a bring-your-own bucket when the caller explicitly asked for it. This
+ * module owns that decision so it is not re-derived — and re-drifted — per
+ * surface.
+ *
+ * What lives here is ONLY the identity + selection policy. It deliberately does
+ * NOT know a surface's endpoint, namespace shape, public-read semantics, or OG
+ * covers — those differ (share uses an email-handle namespace with public reads
+ * and covers; a traces/sessions adapter uses the userId and differs again). Each
+ * surface keeps its own DISCRIMINATED, typed adapter that reads this decision and
+ * returns its own `kind`-tagged backend. See `lib/share/backend.ts` and
+ * `lib/traces/backend.ts` for the two adapters.
+ */
+import { type PhoenixSession } from '../identity/client.js';
+/** The two legitimate principals any managed-capable surface can resolve to. */
+export type StorageBackendKind = 'managed' | 'byo';
+export interface StorageSelectionOpts {
+    /**
+     * True when the SURFACE detected an explicit bring-your-own override — a
+     * `--byo` flag, a caller-supplied static write token, a `…_BACKEND=byo` env,
+     * or a full BYO endpoint config. Detecting WHICH signals count is the
+     * surface's job (they differ per surface); this policy only honors the boolean.
+     */
+    byoOverride?: boolean;
+    /**
+     * DI seam for the Phoenix session. `undefined` reads the real persisted
+     * session (`readSession()`); `null` means "explicitly signed out".
+     */
+    session?: PhoenixSession | null;
+}
+/**
+ * Pick the storage principal. Managed when signed in (`readSession() != null`)
+ * AND the surface reported no explicit BYO override; otherwise BYO.
+ *
+ * This is not a fallback chain — it is a single decision. A surface that cannot
+ * authenticate EITHER principal (signed out AND no BYO config) still reads `byo`
+ * here and fails loud in its own adapter, where the actionable "run auth login
+ * or set up your bucket" message belongs.
+ */
+export declare function selectStorageBackendKind(opts?: StorageSelectionOpts): StorageBackendKind;
+/** True when the shared policy resolves to the managed principal. Thin sugar
+ * over {@link selectStorageBackendKind} for the common boolean check. */
+export declare function isManagedSelection(opts?: StorageSelectionOpts): boolean;

package/dist/lib/storage/selection.js

@@ -0,0 +1,39 @@
+/**
+ * The ONE managed-vs-BYO storage-backend selection policy.
+ *
+ * Every surface that persists to Phoenix-managed storage (`agents artifacts
+ * share` today, `agents sessions` sync next) makes the SAME choice: run on OUR
+ * managed infrastructure when the caller is signed in to Phoenix, and only fall
+ * back to a bring-your-own bucket when the caller explicitly asked for it. This
+ * module owns that decision so it is not re-derived — and re-drifted — per
+ * surface.
+ *
+ * What lives here is ONLY the identity + selection policy. It deliberately does
+ * NOT know a surface's endpoint, namespace shape, public-read semantics, or OG
+ * covers — those differ (share uses an email-handle namespace with public reads
+ * and covers; a traces/sessions adapter uses the userId and differs again). Each
+ * surface keeps its own DISCRIMINATED, typed adapter that reads this decision and
+ * returns its own `kind`-tagged backend. See `lib/share/backend.ts` and
+ * `lib/traces/backend.ts` for the two adapters.
+ */
+import { readSession } from '../identity/client.js';
+/**
+ * Pick the storage principal. Managed when signed in (`readSession() != null`)
+ * AND the surface reported no explicit BYO override; otherwise BYO.
+ *
+ * This is not a fallback chain — it is a single decision. A surface that cannot
+ * authenticate EITHER principal (signed out AND no BYO config) still reads `byo`
+ * here and fails loud in its own adapter, where the actionable "run auth login
+ * or set up your bucket" message belongs.
+ */
+export function selectStorageBackendKind(opts = {}) {
+    if (opts.byoOverride === true)
+        return 'byo';
+    const session = opts.session === undefined ? readSession() : opts.session;
+    return session != null ? 'managed' : 'byo';
+}
+/** True when the shared policy resolves to the managed principal. Thin sugar
+ * over {@link selectStorageBackendKind} for the common boolean check. */
+export function isManagedSelection(opts = {}) {
+    return selectStorageBackendKind(opts) === 'managed';
+}

package/dist/lib/storage/visibility.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The ONE visibility model, identical on every surface that publishes to managed
+ * storage. Three levels the operator ever chooses between:
+ *
+ *   - PRIVATE  = `me`      — owner-only, Phoenix-gated. THE DEFAULT for a new
+ *                            managed share (see {@link MANAGED_DEFAULT_VISIBILITY}).
+ *   - TEAM     = `org`     — everyone at the sharer's signed-in email DOMAIN,
+ *                            Phoenix-gated. Automatic from the domain — there is
+ *                            no organization to create and no member to add.
+ *   - PUBLIC   = `public`  — explicit opt-in; listed in the gallery, gets an OG
+ *                            card.
+ *
+ * Two capability-URL levels remain for the power path (unguessable link, not a
+ * login gate): `unlisted` (obscurity — noindex, gallery-hidden, still
+ * world-readable) and `private`-token-gated (`--protected`: a `?k=` key the
+ * Worker checks, 404 without it). `me`/`org` require a Phoenix session; the
+ * Worker refuses them for a bare WRITE_TOKEN (BYO) publish, which is why the BYO
+ * default stays `public`.
+ *
+ * The names match the Worker's own metadata vocabulary (`lib/share/worker-template.ts`),
+ * so this module is the single client-side source of truth for the level set and
+ * the DEFAULT, reusable by any surface.
+ */
+/** Every visibility level the Worker understands. `me`/`org` are the
+ * Phoenix-gated (login-required) levels; `public`/`unlisted`/`private` are the
+ * link-reachable levels. */
+export type ShareVisibility = 'public' | 'unlisted' | 'private' | 'me' | 'org';
+/** The levels a publish (`share <file> --visibility`) may select. */
+export declare const PUBLISH_VISIBILITY_LEVELS: readonly ShareVisibility[];
+/** The levels an ALREADY-published page may be re-scoped to in place
+ * (`share visibility <target> <level>`). Excludes `private`: re-scoping to
+ * token-gated needs a fresh viewer token, which only the publish path mints. */
+export declare const EDITABLE_VISIBILITY_LEVELS: readonly ShareVisibility[];
+/**
+ * The product default for a MANAGED (signed-in) share: PRIVATE = owner-only,
+ * Phoenix-gated. A publish with no visibility flag lands here.
+ */
+export declare const MANAGED_DEFAULT_VISIBILITY: ShareVisibility;
+/**
+ * The default for a BYO (bring-your-own bucket) publish. `me`/`org` are refused
+ * server-side for a WRITE_TOKEN publish — there is no Phoenix owner to gate on —
+ * so a BYO share with no flag stays `public`, matching the pre-managed behavior.
+ */
+export declare const BYO_DEFAULT_VISIBILITY: ShareVisibility;
+import type { StorageBackendKind } from './selection.js';
+/** The no-flags default for a given storage backend: `me` on managed,
+ * `public` on BYO. */
+export declare function defaultVisibilityForBackend(kind: StorageBackendKind): ShareVisibility;
+export interface VisibilityFlags {
+    /** An explicit `--visibility <level>`. */
+    visibility?: ShareVisibility;
+    /** `--unlisted` / `--private` (obscurity, not read-auth). */
+    unlisted?: boolean;
+    /** `--protected` — token-gated read auth (maps to `private`). */
+    protected?: boolean;
+}
+/**
+ * The visibility the caller EXPLICITLY asked for, or `undefined` when they
+ * passed no visibility signal at all. `--protected` wins over `--unlisted`
+ * (stronger control), which wins over an explicit `--visibility`.
+ *
+ * The distinction between "explicit" and "no preference" is what lets a caller
+ * apply the product default only when nothing was asked — a caller that passes
+ * `--visibility public` gets `public`, never the `me` default.
+ */
+export declare function explicitVisibility(opts?: VisibilityFlags): ShareVisibility | undefined;
+/**
+ * Resolve visibility from the caller's flags, falling back to `fallback` when no
+ * explicit signal was given. The library fallback stays `public` so a caller
+ * that hasn't opted into the managed private default (e.g. an existing lib
+ * consumer) is never silently flipped; the surface applies the product default
+ * itself via {@link defaultVisibilityForBackend}.
+ */
+export declare function resolveVisibility(opts?: VisibilityFlags, fallback?: ShareVisibility): ShareVisibility;
+/**
+ * The visibility a PUBLISH should stamp: the caller's explicit flag if any, else
+ * the product default for the resolved backend (`me` on managed, `public` on
+ * BYO). This is the one call a publishing surface makes — `agents artifacts
+ * share` today, `agents sessions` sync next — so "private by default when signed
+ * in" is decided in exactly one place.
+ */
+export declare function publishVisibility(opts: VisibilityFlags, kind: StorageBackendKind): ShareVisibility;

package/dist/lib/storage/visibility.js

@@ -0,0 +1,99 @@
+/**
+ * The ONE visibility model, identical on every surface that publishes to managed
+ * storage. Three levels the operator ever chooses between:
+ *
+ *   - PRIVATE  = `me`      — owner-only, Phoenix-gated. THE DEFAULT for a new
+ *                            managed share (see {@link MANAGED_DEFAULT_VISIBILITY}).
+ *   - TEAM     = `org`     — everyone at the sharer's signed-in email DOMAIN,
+ *                            Phoenix-gated. Automatic from the domain — there is
+ *                            no organization to create and no member to add.
+ *   - PUBLIC   = `public`  — explicit opt-in; listed in the gallery, gets an OG
+ *                            card.
+ *
+ * Two capability-URL levels remain for the power path (unguessable link, not a
+ * login gate): `unlisted` (obscurity — noindex, gallery-hidden, still
+ * world-readable) and `private`-token-gated (`--protected`: a `?k=` key the
+ * Worker checks, 404 without it). `me`/`org` require a Phoenix session; the
+ * Worker refuses them for a bare WRITE_TOKEN (BYO) publish, which is why the BYO
+ * default stays `public`.
+ *
+ * The names match the Worker's own metadata vocabulary (`lib/share/worker-template.ts`),
+ * so this module is the single client-side source of truth for the level set and
+ * the DEFAULT, reusable by any surface.
+ */
+/** The levels a publish (`share <file> --visibility`) may select. */
+export const PUBLISH_VISIBILITY_LEVELS = [
+    'public',
+    'unlisted',
+    'private',
+    'me',
+    'org',
+];
+/** The levels an ALREADY-published page may be re-scoped to in place
+ * (`share visibility <target> <level>`). Excludes `private`: re-scoping to
+ * token-gated needs a fresh viewer token, which only the publish path mints. */
+export const EDITABLE_VISIBILITY_LEVELS = [
+    'public',
+    'unlisted',
+    'me',
+    'org',
+];
+/**
+ * The product default for a MANAGED (signed-in) share: PRIVATE = owner-only,
+ * Phoenix-gated. A publish with no visibility flag lands here.
+ */
+export const MANAGED_DEFAULT_VISIBILITY = 'me';
+/**
+ * The default for a BYO (bring-your-own bucket) publish. `me`/`org` are refused
+ * server-side for a WRITE_TOKEN publish — there is no Phoenix owner to gate on —
+ * so a BYO share with no flag stays `public`, matching the pre-managed behavior.
+ */
+export const BYO_DEFAULT_VISIBILITY = 'public';
+/** The no-flags default for a given storage backend: `me` on managed,
+ * `public` on BYO. */
+export function defaultVisibilityForBackend(kind) {
+    return kind === 'managed' ? MANAGED_DEFAULT_VISIBILITY : BYO_DEFAULT_VISIBILITY;
+}
+/**
+ * The visibility the caller EXPLICITLY asked for, or `undefined` when they
+ * passed no visibility signal at all. `--protected` wins over `--unlisted`
+ * (stronger control), which wins over an explicit `--visibility`.
+ *
+ * The distinction between "explicit" and "no preference" is what lets a caller
+ * apply the product default only when nothing was asked — a caller that passes
+ * `--visibility public` gets `public`, never the `me` default.
+ */
+export function explicitVisibility(opts = {}) {
+    if (opts.protected === true)
+        return 'private';
+    if (opts.unlisted === true)
+        return 'unlisted';
+    if (opts.visibility === 'public' ||
+        opts.visibility === 'unlisted' ||
+        opts.visibility === 'private' ||
+        opts.visibility === 'me' ||
+        opts.visibility === 'org') {
+        return opts.visibility;
+    }
+    return undefined;
+}
+/**
+ * Resolve visibility from the caller's flags, falling back to `fallback` when no
+ * explicit signal was given. The library fallback stays `public` so a caller
+ * that hasn't opted into the managed private default (e.g. an existing lib
+ * consumer) is never silently flipped; the surface applies the product default
+ * itself via {@link defaultVisibilityForBackend}.
+ */
+export function resolveVisibility(opts = {}, fallback = 'public') {
+    return explicitVisibility(opts) ?? fallback;
+}
+/**
+ * The visibility a PUBLISH should stamp: the caller's explicit flag if any, else
+ * the product default for the resolved backend (`me` on managed, `public` on
+ * BYO). This is the one call a publishing surface makes — `agents artifacts
+ * share` today, `agents sessions` sync next — so "private by default when signed
+ * in" is decided in exactly one place.
+ */
+export function publishVisibility(opts, kind) {
+    return explicitVisibility(opts) ?? defaultVisibilityForBackend(kind);
+}

package/dist/lib/subagents-registry.js

@@ -15,7 +15,7 @@
  *
  *   - `flatFile`  one `<name><ext>` file, body from a `transform` fn.
  *                 (claude, grok, pi, droid, codex, opencode, copilot,
- *                  cursor, kiro, goose, kimi)
+ *                  cursor, goose, kimi)
  *   - `dirFile`   a `<name>/` directory holding one generated `<file>`.
  *                 (antigravity: `<name>/agent.md`)
  *   - `dirCopy`   copy the whole source directory to `<name>/`, applying
@@ -35,7 +35,7 @@ import * as TOML from 'smol-toml';
 import * as yaml from 'yaml';
 import { safeJoin } from './paths.js';
 import { filesContentMatch, normalizeResourceContent } from './resource-content-diff.js';
-import { parseSubagentFrontmatter, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, transformSubagentForCursor, transformSubagentForDroid, transformSubagentForGoose, transformSubagentForKiro, transformSubagentForOpenCode, transformSubagentForAntigravity, } from './subagents.js';
+import { parseSubagentFrontmatter, transformSubagentForClaude, transformSubagentForCodex, transformSubagentForCopilot, transformSubagentForCursor, transformSubagentForDroid, transformSubagentForGoose, transformSubagentForOpenCode, transformSubagentForAntigravity, } from './subagents.js';
 /** Read a file's UTF-8 content, or null when it is missing/unreadable. */
 function readFileSafe(filePath) {
     try {
@@ -54,7 +54,6 @@ function metaFrontmatterSkip(filePath) {
 function metaFrontmatterFallback(filePath, name) {
     return parseSubagentFrontmatter(filePath) ?? { name, description: '' };
 }
-/** Kiro custom-agent JSON: read name/description/model; skip on parse error. */
 function metaJson(filePath, name) {
     try {
         const cfg = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
@@ -283,9 +282,6 @@ export const SUBAGENT_TARGETS = {
     // Tier 1 -- flat markdown, Claude-compatible flatten.
     claude: flatFile({ subdir: ['.claude', 'agents'], ext: '.md', transform: transformSubagentForClaude }),
     grok: flatFile({ subdir: ['.grok', 'agents'], ext: '.md', transform: transformSubagentForClaude }),
-    // Oh My Pi discovers Claude-shaped agent markdown from ~/.omp/agent/agents/
-    // (`omp agents unpack` writes there); frontmatter name/description + body.
-    pi: flatFile({ subdir: ['.omp', 'agent', 'agents'], ext: '.md', transform: transformSubagentForClaude, readMeta: metaFrontmatterFallback }),
     droid: flatFile({ subdir: ['.factory', 'droids'], ext: '.md', transform: transformSubagentForDroid }),
     // Bespoke frontmatter/format, still one flat file.
     codex: flatFile({
@@ -312,12 +308,6 @@ export const SUBAGENT_TARGETS = {
         transform: transformSubagentForCursor,
         readMeta: metaFrontmatterFallback,
     }),
-    kiro: flatFile({
-        subdir: ['.kiro', 'agents'],
-        ext: '.json',
-        transform: transformSubagentForKiro,
-        readMeta: metaJson,
-    }),
     goose: flatFile({
         subdir: ['.config', 'goose', 'agents'],
         ext: '.yaml',

package/dist/lib/subagents.d.ts

@@ -106,16 +106,6 @@ export declare function transformSubagentForOpenCode(subagentDir: string): strin
  * https://developers.openai.com/codex/subagents (custom agents section)
  */
 export declare function transformSubagentForCodex(subagentDir: string): string;
-/**
- * Transform a subagent into a Kiro CLI custom-agent JSON file.
- *
- * Kiro custom agents live in `~/.kiro/agents/<name>.json` (or `.kiro/agents/`
- * workspace-local) and declare name, description, prompt, tools, and optional
- * model. We flatten the AGENT.md frontmatter + body plus any sibling .md files
- * as sections into a single `prompt`, and expose the standard built-in tool
- * set so the subagent can actually run.
- */
-export declare function transformSubagentForKiro(subagentDir: string): string;
 /**
  * Transform a subagent into a Goose recipe YAML file.
  *

package/dist/lib/subagents.js

@@ -403,43 +403,6 @@ function flattenSubagentInstructions(subagentDir) {
     }
     return instructions;
 }
-/**
- * Transform a subagent into a Kiro CLI custom-agent JSON file.
- *
- * Kiro custom agents live in `~/.kiro/agents/<name>.json` (or `.kiro/agents/`
- * workspace-local) and declare name, description, prompt, tools, and optional
- * model. We flatten the AGENT.md frontmatter + body plus any sibling .md files
- * as sections into a single `prompt`, and expose the standard built-in tool
- * set so the subagent can actually run.
- */
-export function transformSubagentForKiro(subagentDir) {
-    const agentMd = path.join(subagentDir, 'AGENT.md');
-    const frontmatter = parseSubagentFrontmatter(agentMd);
-    const body = getSubagentBody(agentMd);
-    if (!frontmatter) {
-        throw new Error(`Invalid AGENT.md in ${subagentDir}`);
-    }
-    const files = fs.readdirSync(subagentDir)
-        .filter(f => f.endsWith('.md') && f !== 'AGENT.md')
-        .sort();
-    let prompt = body;
-    for (const file of files) {
-        const content = fs.readFileSync(path.join(subagentDir, file), 'utf-8').trim();
-        const sectionName = file.replace('.md', '');
-        const title = sectionName.charAt(0).toUpperCase() + sectionName.slice(1).toLowerCase();
-        prompt += `\n\n## ${title}\n\n${content}`;
-    }
-    const config = {
-        name: frontmatter.name,
-        description: frontmatter.description,
-        prompt,
-        tools: ['read', 'write', 'shell', 'web_search', 'web_fetch'],
-    };
-    if (frontmatter.model) {
-        config.model = frontmatter.model;
-    }
-    return JSON.stringify(config, null, 2);
-}
 /**
  * Transform a subagent into a Goose recipe YAML file.
  *

package/dist/lib/teams/agents.js

@@ -2361,7 +2361,9 @@ export class AgentManager {
                     ? `at its agents.max-concurrent cap (${e.detail} running)`
                     : e.reason === 'not-installed'
                         ? `does not have ${this.placementAgentLabel(agent)} installed`
-                        : e.reason;
+                        : e.reason === 'probe-timed-out'
+                            ? 'did not answer the probe in time (likely up but on a slow/relayed link)'
+                            : e.reason;
                 console.error(chalk.dim(`[placement] '${e.device}' excluded from auto-pick — ${why}`));
             }
         }

package/dist/lib/teams/placement-probe.js

@@ -137,6 +137,7 @@ export async function probePoolSignals(pool, agent, opts = {}) {
             continue; // fully unknown device — leave it out of the map
         signals.set(name, {
             reachable: s?.reachable,
+            timedOut: s?.timedOut,
             headroom: s ? headroom(s) : undefined,
             loadPercent: s?.loadPercent,
             memPercent: s?.memPercent,

package/dist/lib/teams/scheduler.d.ts

@@ -10,6 +10,13 @@ import type { Headroom } from '../devices/health.js';
 export interface DevicePlacementSignal {
     /** SSH probe answered. `false` → excluded (unreachable). undefined → unknown. */
     reachable?: boolean;
+    /**
+     * The probe was killed for exceeding its budget rather than failing to
+     * connect. Ranking treats it exactly like `reachable:false` — an
+     * unresponsive box is still not placeable — but the operator-facing
+     * exclusion reason says "probe timed out", not "unreachable" (PHNX-3682).
+     */
+    timedOut?: boolean;
     /** Headroom bucket from load+memory. `'loaded'` → excluded (overloaded). */
     headroom?: Headroom;
     /** Normalized CPU load percent (finer rank tiebreak within a headroom tier). */
@@ -60,7 +67,7 @@ export interface PlacementOptions {
     preferred?: ReadonlySet<string>;
 }
 /** Why a device was excluded from the viable set, for the fail-loud message. */
-export type ExclusionReason = 'unreachable' | 'overloaded' | 'capped' | 'not-installed';
+export type ExclusionReason = 'unreachable' | 'probe-timed-out' | 'overloaded' | 'capped' | 'not-installed';
 /** A pool device dropped from the auto-pick, with the reason + live detail. */
 export interface ExcludedDevice {
     device: string;

package/dist/lib/teams/scheduler.js

@@ -199,7 +199,10 @@ export function classifyExclusions(devices, roster, opts) {
     for (const d of devices) {
         const s = signals?.get(d);
         if (s?.reachable === false) {
-            excluded.push({ device: d, reason: 'unreachable' });
+            // A probe killed for exceeding its budget is a slow link, not a box that
+            // is down. Same exclusion either way — an unresponsive device is still not
+            // placeable — but the operator sees which one it was (PHNX-3682).
+            excluded.push({ device: d, reason: s.timedOut ? 'probe-timed-out' : 'unreachable' });
             continue;
         }
         if (s?.installed === false) {

package/dist/lib/traces/backend.js

@@ -10,6 +10,7 @@
  * `agents artifacts setup`.
  */
 import { readSession } from '../identity/client.js';
+import { selectStorageBackendKind } from '../storage/selection.js';
 export const DEFAULT_TRACES_DOMAIN = 'traces.agents-cli.sh';
 /**
  * Resolve the backend for the current machine. Throws when not signed in.
@@ -21,11 +22,21 @@ export const DEFAULT_TRACES_DOMAIN = 'traces.agents-cli.sh';
 export function resolveTracesBackend() {
     const envBase = (process.env['AGENTS_TRACES_BASE_URL'] ?? '').replace(/\/+$/, '').trim();
     const envToken = (process.env['AGENTS_TRACES_WRITE_TOKEN'] ?? '').trim();
-    if (envBase && envToken) {
-        return { baseUrl: envBase, token: envToken, userId: 'byo' };
+    // The traces surface's only BYO signal is the full BASE_URL + WRITE_TOKEN env
+    // pair; the managed-vs-BYO decision itself is the shared selection policy.
+    const byoOverride = Boolean(envBase && envToken);
+    if (selectStorageBackendKind({ byoOverride }) === 'byo') {
+        if (byoOverride) {
+            return { baseUrl: envBase, token: envToken, userId: 'byo' };
+        }
+        // Not signed in and no BYO env pair — the managed principal is the only one
+        // this surface exposes, so fail loud with the login hint.
+        throw new Error("Not signed in. Run 'agents auth login' to sync traces to your Phoenix account.");
     }
     const session = readSession();
     if (!session) {
+        // selectStorageBackendKind read the same session and returned 'managed', so a
+        // null here means it was cleared between the two reads — treat as signed out.
         throw new Error("Not signed in. Run 'agents auth login' to sync traces to your Phoenix account.");
     }
     if (!session.access_token) {

package/dist/lib/types.d.ts

@@ -8,7 +8,7 @@
 import type { CloudProviderId } from './cloud/types.js';
 import type { FeedBroadcastConfig } from './feed-broadcast.js';
 /** Unique identifier for a current or legacy AI coding agent. */
-export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'pi' | 'muse' | 'warp';
+export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes' | 'muse' | 'warp';
 /** How `agents run <agent>` chooses an installed version when none is pinned. */
 export type RunStrategy = 'pinned' | 'available' | 'balanced';
 export type RunEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto';