@phnx-labs/agents-cli 1.22.41 → 1.22.43

package/dist/lib/menubar/install-menubar.js

@@ -24,7 +24,7 @@ import { getRuntimeStateDir, getHelpersDir } from '../state.js';
 import { getCliVersion, resolveAgentsBin, resolveInstalledLayout } from '../version.js';
 import { copyAppBundle, withInstallLock } from '../app-bundle-install.js';
 import { compareVersions } from '../agent-spec/primitives.js';
-import { namespacedServiceLabel, serviceManifestHomeEnv } from '../service-manifest.js';
+import { namespacedServiceLabel, serviceManifestHomeEnv, serviceManagerRegistrationAllowed } from '../service-manifest.js';
 const APP_BUNDLE_NAME = 'MenubarHelper.app';
 const INSTALL_DIR_NAME = 'agents-cli';
 const SERVICE_LABEL_BASE = 'com.phnx-labs.agents-menubar';
@@ -333,6 +333,11 @@ ${envXml}
  * is the only sequence that reliably re-attaches the status item.
  */
 export function restartMenubarLaunchAgent(uid, plist, exec = execFileSync) {
+    const reg = serviceManagerRegistrationAllowed();
+    if (!reg.allowed) {
+        process.stderr.write(`[agents] ${reg.reason}\n`);
+        return;
+    }
     const serviceTarget = `gui/${uid}/${serviceLabel()}`;
     const opts = { stdio: ['ignore', 'ignore', 'ignore'] };
     try {
@@ -467,15 +472,21 @@ export function disableMenubarService() {
     if (!onDarwin())
         return;
     const plist = servicePlistPath();
-    const uid = process.getuid?.() ?? 0;
-    try {
-        execFileSync('launchctl', ['bootout', `gui/${uid}/${serviceLabel()}`], { stdio: ['ignore', 'ignore', 'ignore'] });
-    }
-    catch {
+    const reg = serviceManagerRegistrationAllowed();
+    if (reg.allowed) {
+        const uid = process.getuid?.() ?? 0;
         try {
-            execFileSync('launchctl', ['unload', '-w', plist], { stdio: ['ignore', 'ignore', 'ignore'] });
+            execFileSync('launchctl', ['bootout', `gui/${uid}/${serviceLabel()}`], { stdio: ['ignore', 'ignore', 'ignore'] });
+        }
+        catch {
+            try {
+                execFileSync('launchctl', ['unload', '-w', plist], { stdio: ['ignore', 'ignore', 'ignore'] });
+            }
+            catch { /* not loaded */ }
         }
-        catch { /* not loaded */ }
+    }
+    else {
+        process.stderr.write(`[agents] ${reg.reason}\n`);
     }
     try {
         fs.unlinkSync(plist);

package/dist/lib/monitors/config.d.ts

@@ -68,8 +68,8 @@ export type MonitorActionType = 'run' | 'routine' | 'notify' | 'webhook-out';
  */
 export interface ActionConfig {
     type: MonitorActionType;
-    /** run: which agent to spawn. */
-    agent?: AgentId;
+    /** run: which agent to spawn — a native harness id or a custom harness name (agents harness list). */
+    agent?: AgentId | (string & {});
     /** run: the prompt; `{event}` is replaced with the fired event summary. */
     prompt?: string;
     /** run: execution mode (shared with routines). */

package/dist/lib/monitors/config.js

@@ -17,6 +17,7 @@ import { safeJoin, isSafeSegmentName } from '../paths.js';
 import { atomicWriteFileSync } from '../fs-atomic.js';
 import { machineId, normalizeHost } from '../machine-id.js';
 import { ALL_AGENT_IDS } from '../agents.js';
+import { isCustomHarnessName } from '../profiles.js';
 /** Default values applied to every monitor config when fields are omitted. */
 const MONITOR_DEFAULTS = {
     enabled: true,
@@ -215,8 +216,8 @@ export function validateMonitor(config) {
             errors.push(`action has conflicting fields (${populatedAct.join(', ')}); specify exactly one action`);
         }
         if (action.type === 'run') {
-            if (action.agent && !ALL_AGENT_IDS.includes(action.agent)) {
-                errors.push(`action.agent must be one of: ${ALL_AGENT_IDS.join(', ')}`);
+            if (action.agent && !ALL_AGENT_IDS.includes(action.agent) && !isCustomHarnessName(action.agent)) {
+                errors.push(`action.agent must be one of: ${ALL_AGENT_IDS.join(', ')}, or a custom harness (agents harness list)`);
             }
             if (!action.prompt || typeof action.prompt !== 'string') {
                 errors.push("action.type 'run' requires action.prompt");

package/dist/lib/monitors/dispatch.d.ts

@@ -3,7 +3,7 @@
  *
  * On a fire, the monitor feeds the event to an action. Every `run`/`routine`
  * action goes through the *same* detached spawn cron and webhook fires use
- * (executeJobDetached, lib/runner.ts) — a monitor never duplicates spawn logic,
+ * (executeJobDetached, lib/daemon/runner.ts) — a monitor never duplicates spawn logic,
  * it synthesizes a JobConfig and hands it to the one dispatch seam. `notify`
  * routes the owner through the one channel seam (sendToOwner → lookupTransport,
  * lib/notify.ts) — recipient from notify.owner, no hardcoded chat id, and an

package/dist/lib/monitors/dispatch.js

@@ -3,14 +3,14 @@
  *
  * On a fire, the monitor feeds the event to an action. Every `run`/`routine`
  * action goes through the *same* detached spawn cron and webhook fires use
- * (executeJobDetached, lib/runner.ts) — a monitor never duplicates spawn logic,
+ * (executeJobDetached, lib/daemon/runner.ts) — a monitor never duplicates spawn logic,
  * it synthesizes a JobConfig and hands it to the one dispatch seam. `notify`
  * routes the owner through the one channel seam (sendToOwner → lookupTransport,
  * lib/notify.ts) — recipient from notify.owner, no hardcoded chat id, and an
  * unresolvable channel comes back as `ok: false` instead of exiting the daemon;
  * `webhook-out` POSTs the event.
  */
-import { executeJobDetached } from '../runner.js';
+import { executeJobDetached } from '../daemon/runner.js';
 import { readJob } from '../scheduling/routines.js';
 import { sendToOwner } from '../notify.js';
 /** Replace `{event}` in a prompt with the fired event summary. */

package/dist/lib/monitors/state.d.ts

@@ -110,7 +110,7 @@ export interface FireRecord extends MonitorEvent {
      * snapshot: `executeJobDetached` writes `status: 'running'` before spawning
      * and returns immediately — the real outcome (`completed`/`failed`/`timeout`)
      * lands later, asynchronously, in `executeJobDetachedClaimed`'s own
-     * `settle()` on child exit/error (lib/runner.ts). So a fire recorded
+     * `settle()` on child exit/error (lib/daemon/runner.ts). So a fire recorded
      * `runStatusAtFire: 'running'` had its `ok` frozen before the run actually
      * finished — that is the signal a future reconciliation pass (a daemon tick
      * that revisits `running`-at-fire records and patches `ok` for real) would

package/dist/lib/origin-machine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resolve which machine a session transcript originated on.
+ *
+ * Cross-machine sync mirrors a remote transcript to
+ * `backups/<agent>/<machine>/<subdir>/…`. Every other transcript is a live-home
+ * file on this box, so the origin is the local machine id.
+ *
+ * Kept in a leaf module (no session/db imports) so both discovery and the
+ * sessions DB upsert path can stamp `machine` without circular deps.
+ */
+/** Local machine id, cached for the process lifetime. */
+export declare function localMachineId(): string;
+/**
+ * The machine a discovered session originated on.
+ * When the path sits under the agent's backups root, the first segment below it
+ * is the origin machine id; otherwise it's the local machine.
+ */
+export declare function machineForSessionFile(filePath: string, agent: string): string;

package/dist/lib/origin-machine.js

@@ -0,0 +1,34 @@
+/**
+ * Resolve which machine a session transcript originated on.
+ *
+ * Cross-machine sync mirrors a remote transcript to
+ * `backups/<agent>/<machine>/<subdir>/…`. Every other transcript is a live-home
+ * file on this box, so the origin is the local machine id.
+ *
+ * Kept in a leaf module (no session/db imports) so both discovery and the
+ * sessions DB upsert path can stamp `machine` without circular deps.
+ */
+import * as path from 'path';
+import { getHistoryDir } from './state.js';
+import { machineId } from './machine-id.js';
+let _localMachineId;
+/** Local machine id, cached for the process lifetime. */
+export function localMachineId() {
+    return (_localMachineId ??= machineId());
+}
+/**
+ * The machine a discovered session originated on.
+ * When the path sits under the agent's backups root, the first segment below it
+ * is the origin machine id; otherwise it's the local machine.
+ */
+export function machineForSessionFile(filePath, agent) {
+    if (!filePath)
+        return localMachineId();
+    const base = path.join(getHistoryDir(), 'backups', agent) + path.sep;
+    if (filePath.startsWith(base)) {
+        const seg = filePath.slice(base.length).split(path.sep)[0];
+        if (seg)
+            return seg;
+    }
+    return localMachineId();
+}

package/dist/lib/perf/db.js

@@ -8,7 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import Database from '../sqlite.js';
 import { getPerfDbPath, getPerfDir } from '../state.js';
-import { localMachineId } from '../session/origin-machine.js';
+import { localMachineId } from '../origin-machine.js';
 import { resolveProjectKey } from '../project-key.js';
 import { percentile } from '../percentile.js';
 import { resolveSpoolPath, shortSessionId, _resetPerfSpoolForTest } from './spool.js';

package/dist/lib/perf/spool.js

@@ -9,7 +9,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { getPerfSpoolPath } from '../state.js';
-import { localMachineId } from '../session/origin-machine.js';
+import { localMachineId } from '../origin-machine.js';
 let _spoolOverride = null;
 let _disabled = false;
 /** Test seam — pair with db._resetPerfDbForTest. */

package/dist/lib/plugins/plugins.js

@@ -16,7 +16,7 @@ import { execFileSync } from 'child_process';
 import { getPluginsDir, getTrashPluginsDir, getExtraPluginsDir, getProjectPluginsDir, getSystemPluginsDir } from '../state.js';
 import { IS_WINDOWS, isWindowsAbsolutePath, homeDir } from '../platform/index.js';
 import { assertSafeGitTransport, resolveSnapshotSha } from '../git.js';
-import { listInstalledVersions, getVersionHomePath } from '../installations/versions.js';
+import { listInstalledVersions, getVersionHomePath } from '../installations/store.js';
 import { AGENTS, agentConfigDirName } from '../agents.js';
 import { capableAgents, isCapable } from '../capabilities.js';
 import { shouldInstallCommandAsSkill, installCommandSkillToVersion } from '../command-skills.js';

package/dist/lib/plugins/skills.js

@@ -14,7 +14,7 @@ import { normalizeAliases } from '../resource-aliases.js';
 import { AGENTS, ensureSkillsDir, agentConfigDirName } from '../agents.js';
 import { capableAgents, isCapable } from '../capabilities.js';
 import { getUserSkillsDir, getSkillsDir as getSystemSkillsDir, getProjectAgentsDir, getEnabledExtraRepos, getTrashSkillsDir } from '../state.js';
-import { getEffectiveHome, getVersionHomePath, listInstalledVersions } from '../installations/versions.js';
+import { getEffectiveHome, getVersionHomePath, listInstalledVersions } from '../installations/store.js';
 import { listCommandSkillsInVersion } from '../command-skills.js';
 import { emit } from '../feed/events.js';
 const HOME = os.homedir();

package/dist/lib/prix-account.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Client for the Rush account layer (`api.prix.dev`) — backs `agents auth` and
+ * `agents org`. `agents org` maps to `/api/v1/spaces`, not `/api/v1/orgs`: spaces
+ * already carry the free-tier caps (1 owned space, 3 members) and can exist
+ * standalone with no parent organization, matching a "just want a team" CLI flow
+ * better than the heavier enterprise-tenancy `orgs` routes (domain, SSO). See
+ * `.agents/artifacts/2026-08-20/agi-cli-client-integration-spec.md` §4.2 in the
+ * agi-cli-web repo for the full reasoning and the live-confirmed route/shape audit.
+ *
+ * Token custody: `agents auth login` writes its own session file
+ * (`getPrixSessionFile()`), separate from `~/.rush/user.yaml`, so `agents auth
+ * logout` never signs the user out of `rush` (the two CLIs share a backend
+ * account, not a credential store). Reads fall back to `~/.rush/user.yaml`
+ * (the pattern `readRushToken` in `lib/secrets/drivers/rush.ts` already uses)
+ * so a user who is only signed in via `rush login` still gets a working
+ * `agents auth whoami` / `agents org` with zero extra login step.
+ */
+export declare const PRIX_API_BASE = "https://api.prix.dev";
+/** The session `agents auth login` owns. */
+export interface PrixSession {
+    access_token: string;
+    refresh_token?: string;
+    /** Unix ms. */
+    expires_at?: number;
+    email?: string;
+    userId?: string;
+}
+export declare function getPrixSessionFile(): string;
+export declare function readPrixSession(): PrixSession | null;
+export declare function writePrixSession(session: PrixSession): void;
+export declare function clearPrixSession(): boolean;
+/** Where the caller's Bearer token came from — surfaced by `whoami` so the user knows which login is live. */
+export type PrixTokenSource = 'agents' | 'rush';
+export declare function resolvePrixToken(): {
+    token: string;
+    source: PrixTokenSource;
+} | null;
+export declare class PrixApiError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export interface WhoAmI {
+    userId: string;
+    email: string;
+    valid: true;
+}
+/** `GET /api/v1/auth/me` — live-confirmed shape: `{email, userId, valid}`. */
+export declare function fetchWhoAmI(token?: string): Promise<WhoAmI>;
+export interface DeviceAuthorization {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete: string;
+    expires_in: number;
+    interval: number;
+}
+/** `POST /api/v1/auth/device/authorization` — public, no token. */
+export declare function startDeviceAuthorization(): Promise<DeviceAuthorization>;
+export type DeviceTokenPoll = {
+    status: 'authorized';
+    access_token: string;
+    refresh_token?: string;
+    expires_in?: number;
+    user: {
+        email: string;
+        id: string;
+    };
+} | {
+    status: 'pending';
+} | {
+    status: 'slow_down';
+} | {
+    status: 'expired';
+} | {
+    status: 'denied';
+};
+/** `POST /api/v1/auth/device/token` — one poll attempt. Callers own the interval loop. */
+export declare function pollDeviceToken(deviceCode: string): Promise<DeviceTokenPoll>;
+export interface SpaceSummary {
+    id: string;
+    slug: string;
+    name: string;
+    organization_id: string | null;
+    owner_user_id: string;
+    invite_code?: string;
+    user_role: 'owner' | 'admin' | 'member';
+    created_at: string;
+}
+export interface SpaceMember {
+    user_id: string;
+    email: string;
+    name?: string;
+    avatar_url?: string;
+    role: 'owner' | 'admin' | 'member';
+    joined_at: string;
+}
+/** `GET /api/v1/spaces` — live-confirmed: array of `SpaceSummary`. */
+export declare function listSpaces(): Promise<SpaceSummary[]>;
+/** `POST /api/v1/spaces` — 403 if the caller already owns a space (free tier: 1). */
+export declare function createSpace(input: {
+    name: string;
+    slug: string;
+    description?: string;
+}): Promise<SpaceSummary>;
+/** `GET /api/v1/spaces/:id` — requires membership. */
+export declare function getSpace(spaceId: string): Promise<SpaceSummary>;
+/** `GET /api/v1/spaces/:id/members`. */
+export declare function listSpaceMembers(spaceId: string): Promise<SpaceMember[]>;
+export type CreateSpaceInviteResult = {
+    invited: true;
+    email: string;
+    role: string;
+    member_added: true;
+} | {
+    invited: true;
+    email: string;
+    role: string;
+    invite_code: string;
+    member_added?: false;
+};
+/** `POST /api/v1/spaces/:id/invites` — sends a real email for the pending-invite path. */
+export declare function createSpaceInvite(spaceId: string, email: string, role?: 'admin' | 'member'): Promise<CreateSpaceInviteResult>;
+export interface SpaceInvite {
+    id: string;
+    space_id: string;
+    email: string;
+    role: 'admin' | 'member';
+    invite_code: string;
+    created_at: string;
+}
+/** `GET /api/v1/spaces/:id/invites`. */
+export declare function listSpaceInvites(spaceId: string): Promise<SpaceInvite[]>;
+/** `DELETE /api/v1/spaces/:id/invites/:inviteId`. */
+export declare function revokeSpaceInvite(spaceId: string, inviteId: string): Promise<{
+    revoked: true;
+}>;
+/** `PATCH /api/v1/spaces/:id/members/:userId` — owner-only for admin changes. Route takes userId, not email. */
+export declare function updateSpaceMemberRole(spaceId: string, userId: string, role: 'admin' | 'member'): Promise<{
+    user_id: string;
+    role: string;
+    updated: true;
+}>;
+/** `DELETE /api/v1/spaces/:id/members/:userId` — owner, admin, or the member themself (leave). */
+export declare function removeSpaceMember(spaceId: string, userId: string): Promise<void>;
+/** `DELETE /api/v1/spaces/:id` — soft delete, 30-day restore window. */
+export declare function deleteSpace(spaceId: string): Promise<void>;
+/** `agents-cli-space-name` -> `agi-cli-space-name`; lowercase, hyphenated, matches the backend's `^[a-z0-9-]+$` slug rule. */
+export declare function slugify(name: string): string;
+/**
+ * Resolve the `--space` a command should act on: an explicit id/slug match
+ * against the caller's own space list, or — with nothing passed — the
+ * caller's sole space (free tier caps ownership at one, so this is almost
+ * always unambiguous). Pure over an already-fetched list so it's cheaply
+ * unit-testable with a fixture.
+ */
+export declare function resolveSpaceFromList(spaces: SpaceSummary[], explicit?: string): SpaceSummary;
+/** Resolve a member's email to their `user_id` from an already-fetched member list. */
+export declare function resolveMemberFromList(members: SpaceMember[], email: string): SpaceMember;

package/dist/lib/prix-account.js

@@ -0,0 +1,214 @@
+/**
+ * Client for the Rush account layer (`api.prix.dev`) — backs `agents auth` and
+ * `agents org`. `agents org` maps to `/api/v1/spaces`, not `/api/v1/orgs`: spaces
+ * already carry the free-tier caps (1 owned space, 3 members) and can exist
+ * standalone with no parent organization, matching a "just want a team" CLI flow
+ * better than the heavier enterprise-tenancy `orgs` routes (domain, SSO). See
+ * `.agents/artifacts/2026-08-20/agi-cli-client-integration-spec.md` §4.2 in the
+ * agi-cli-web repo for the full reasoning and the live-confirmed route/shape audit.
+ *
+ * Token custody: `agents auth login` writes its own session file
+ * (`getPrixSessionFile()`), separate from `~/.rush/user.yaml`, so `agents auth
+ * logout` never signs the user out of `rush` (the two CLIs share a backend
+ * account, not a credential store). Reads fall back to `~/.rush/user.yaml`
+ * (the pattern `readRushToken` in `lib/secrets/drivers/rush.ts` already uses)
+ * so a user who is only signed in via `rush login` still gets a working
+ * `agents auth whoami` / `agents org` with zero extra login step.
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { getRuntimeStateDir } from './state.js';
+export const PRIX_API_BASE = 'https://api.prix.dev';
+const RUSH_USER_YAML = path.join(os.homedir(), '.rush', 'user.yaml');
+/** Computed per-call (not cached at module load) so `AGENTS_STATE_DIR` overrides in tests take effect. */
+function prixSessionFile() {
+    return path.join(getRuntimeStateDir(), 'prix-account.json');
+}
+/** Read the token `rush login` wrote, with no expiry check — the same shape `readRushToken` reads. */
+function readRushSessionToken() {
+    if (!fs.existsSync(RUSH_USER_YAML))
+        return null;
+    try {
+        const data = yaml.parse(fs.readFileSync(RUSH_USER_YAML, 'utf-8'));
+        return data?.session?.access_token ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getPrixSessionFile() {
+    return prixSessionFile();
+}
+export function readPrixSession() {
+    const file = prixSessionFile();
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        if (!parsed || typeof parsed.access_token !== 'string')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function writePrixSession(session) {
+    const file = prixSessionFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(session, null, 2), { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+export function clearPrixSession() {
+    const file = prixSessionFile();
+    if (!fs.existsSync(file))
+        return false;
+    fs.rmSync(file);
+    return true;
+}
+export function resolvePrixToken() {
+    const own = readPrixSession();
+    if (own?.access_token)
+        return { token: own.access_token, source: 'agents' };
+    const rushToken = readRushSessionToken();
+    if (rushToken)
+        return { token: rushToken, source: 'rush' };
+    return null;
+}
+export class PrixApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'PrixApiError';
+    }
+}
+async function prixRequest(method, endpoint, opts = {}) {
+    const auth = opts.auth !== false;
+    let token = opts.token;
+    if (auth && !token) {
+        const resolved = resolvePrixToken();
+        if (!resolved)
+            throw new Error("Not signed in. Run 'agents auth login' first.");
+        token = resolved.token;
+    }
+    const headers = { 'Content-Type': 'application/json' };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const res = await fetch(`${PRIX_API_BASE}${endpoint}`, {
+        method,
+        headers,
+        body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
+    });
+    const text = await res.text();
+    const data = text ? JSON.parse(text) : undefined;
+    if (!res.ok) {
+        const message = (data && typeof data === 'object' && 'error' in data) ? String(data.error) : `${res.status} ${res.statusText}`;
+        throw new PrixApiError(res.status, message);
+    }
+    return data;
+}
+/** `GET /api/v1/auth/me` — live-confirmed shape: `{email, userId, valid}`. */
+export async function fetchWhoAmI(token) {
+    return prixRequest('GET', '/api/v1/auth/me', { token });
+}
+/** `POST /api/v1/auth/device/authorization` — public, no token. */
+export async function startDeviceAuthorization() {
+    return prixRequest('POST', '/api/v1/auth/device/authorization', { auth: false, body: {} });
+}
+/** `POST /api/v1/auth/device/token` — one poll attempt. Callers own the interval loop. */
+export async function pollDeviceToken(deviceCode) {
+    try {
+        const data = await prixRequest('POST', '/api/v1/auth/device/token', { auth: false, body: { grant_type: 'urn:ietf:params:oauth:grant-type:device_code', device_code: deviceCode } });
+        return { status: 'authorized', ...data };
+    }
+    catch (err) {
+        if (err instanceof PrixApiError) {
+            if (err.message.includes('authorization_pending'))
+                return { status: 'pending' };
+            if (err.message.includes('slow_down'))
+                return { status: 'slow_down' };
+            if (err.message.includes('expired_token'))
+                return { status: 'expired' };
+            if (err.message.includes('access_denied'))
+                return { status: 'denied' };
+        }
+        throw err;
+    }
+}
+/** `GET /api/v1/spaces` — live-confirmed: array of `SpaceSummary`. */
+export async function listSpaces() {
+    return prixRequest('GET', '/api/v1/spaces');
+}
+/** `POST /api/v1/spaces` — 403 if the caller already owns a space (free tier: 1). */
+export async function createSpace(input) {
+    return prixRequest('POST', '/api/v1/spaces', { body: input });
+}
+/** `GET /api/v1/spaces/:id` — requires membership. */
+export async function getSpace(spaceId) {
+    return prixRequest('GET', `/api/v1/spaces/${encodeURIComponent(spaceId)}`);
+}
+/** `GET /api/v1/spaces/:id/members`. */
+export async function listSpaceMembers(spaceId) {
+    return prixRequest('GET', `/api/v1/spaces/${encodeURIComponent(spaceId)}/members`);
+}
+/** `POST /api/v1/spaces/:id/invites` — sends a real email for the pending-invite path. */
+export async function createSpaceInvite(spaceId, email, role = 'member') {
+    return prixRequest('POST', `/api/v1/spaces/${encodeURIComponent(spaceId)}/invites`, { body: { email, role } });
+}
+/** `GET /api/v1/spaces/:id/invites`. */
+export async function listSpaceInvites(spaceId) {
+    return prixRequest('GET', `/api/v1/spaces/${encodeURIComponent(spaceId)}/invites`);
+}
+/** `DELETE /api/v1/spaces/:id/invites/:inviteId`. */
+export async function revokeSpaceInvite(spaceId, inviteId) {
+    return prixRequest('DELETE', `/api/v1/spaces/${encodeURIComponent(spaceId)}/invites/${encodeURIComponent(inviteId)}`);
+}
+/** `PATCH /api/v1/spaces/:id/members/:userId` — owner-only for admin changes. Route takes userId, not email. */
+export async function updateSpaceMemberRole(spaceId, userId, role) {
+    return prixRequest('PATCH', `/api/v1/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(userId)}`, { body: { role } });
+}
+/** `DELETE /api/v1/spaces/:id/members/:userId` — owner, admin, or the member themself (leave). */
+export async function removeSpaceMember(spaceId, userId) {
+    await prixRequest('DELETE', `/api/v1/spaces/${encodeURIComponent(spaceId)}/members/${encodeURIComponent(userId)}`);
+}
+/** `DELETE /api/v1/spaces/:id` — soft delete, 30-day restore window. */
+export async function deleteSpace(spaceId) {
+    await prixRequest('DELETE', `/api/v1/spaces/${encodeURIComponent(spaceId)}`);
+}
+/** `agents-cli-space-name` -> `agi-cli-space-name`; lowercase, hyphenated, matches the backend's `^[a-z0-9-]+$` slug rule. */
+export function slugify(name) {
+    const slug = name.toLowerCase().trim().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+    return slug || 'space';
+}
+/**
+ * Resolve the `--space` a command should act on: an explicit id/slug match
+ * against the caller's own space list, or — with nothing passed — the
+ * caller's sole space (free tier caps ownership at one, so this is almost
+ * always unambiguous). Pure over an already-fetched list so it's cheaply
+ * unit-testable with a fixture.
+ */
+export function resolveSpaceFromList(spaces, explicit) {
+    if (explicit) {
+        const match = spaces.find(s => s.id === explicit || s.slug === explicit);
+        if (!match)
+            throw new Error(`No space matching '${explicit}'. Run 'agents org list' to see your spaces.`);
+        return match;
+    }
+    if (spaces.length === 0)
+        throw new Error("You have no spaces. Create one with 'agents org create <name>'.");
+    if (spaces.length > 1) {
+        throw new Error(`You belong to ${spaces.length} spaces — pass --space <id-or-slug>: ${spaces.map(s => s.slug).join(', ')}`);
+    }
+    return spaces[0];
+}
+/** Resolve a member's email to their `user_id` from an already-fetched member list. */
+export function resolveMemberFromList(members, email) {
+    const match = members.find(m => m.email.toLowerCase() === email.toLowerCase());
+    if (!match)
+        throw new Error(`'${email}' is not a member of this space. Run 'agents org members' to see who is.`);
+    return match;
+}

package/dist/lib/profiles.d.ts

@@ -96,6 +96,13 @@ export declare function getProfilePath(name: string): string;
 export declare function validateProfileName(name: string): void;
 /** Check whether a profile YAML file exists on disk. */
 export declare function profileExists(name: string): boolean;
+/**
+ * True when `name` is a custom harness (a profile that is not shadowing a
+ * native agent id) — the predicate routines/monitors use to accept an
+ * `agent:` value that `agents run` will resolve as a profile. A native id
+ * always reads as native, matching exec's resolution order.
+ */
+export declare function isCustomHarnessName(name: string): boolean;
 /** Read and parse a profile from disk. Throws if not found or malformed. */
 export declare function readProfile(name: string): Profile;
 /** Write a profile to disk atomically (write-to-tmp then rename). */

package/dist/lib/profiles.js

@@ -9,6 +9,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as crypto from 'node:crypto';
 import * as yaml from 'yaml';
+import { ALL_AGENT_IDS } from './agents.js';
 import { getUserAgentsDir } from './state.js';
 import { deleteKeychainToken, getKeychainToken, hasKeychainToken, keychainItemName } from './secrets/profiles.js';
 import { getPreset } from './profiles-presets.js';
@@ -39,6 +40,17 @@ export function validateProfileName(name) {
 export function profileExists(name) {
     return fs.existsSync(profilePath(name));
 }
+/**
+ * True when `name` is a custom harness (a profile that is not shadowing a
+ * native agent id) — the predicate routines/monitors use to accept an
+ * `agent:` value that `agents run` will resolve as a profile. A native id
+ * always reads as native, matching exec's resolution order.
+ */
+export function isCustomHarnessName(name) {
+    if (!PROFILE_NAME_PATTERN.test(name))
+        return false;
+    return !ALL_AGENT_IDS.includes(name) && profileExists(name);
+}
 /** Read and parse a profile from disk. Throws if not found or malformed. */
 export function readProfile(name) {
     validateProfileName(name);
@@ -77,7 +89,11 @@ function migrateLegacyProfileAuth(profile, file) {
     }
     const migratedAccount = findAccount(accountName);
     const oldItem = profile.auth.keychainItem;
-    profile.account = migratedAccount.id;
+    // Reference by NAME, not id: profiles sync fleet-wide with `agents repo push`
+    // while account ids are minted per-device, so an id ref breaks on every other
+    // machine ("Unknown account '<uuid>'"). Names are the portable handle — the
+    // registry resolves both, and `accounts rename` already rewrites name refs.
+    profile.account = migratedAccount.name;
     profile.provider = provider;
     delete profile.auth;
     delete profile.authOptional;
@@ -477,6 +493,15 @@ export function renameProfile(oldName, newName) {
 export function resolveProfileEnv(profile) {
     const env = { ...profile.env };
     if (profile.account) {
+        if (!findAccount(profile.account)) {
+            // The commonest cause: the profile synced here via `agents repo push/pull`
+            // but its account ref was minted on another device (legacy id refs), so
+            // the bare "Unknown account" from the registry gives the user nothing to
+            // act on. Name the harness and the repair.
+            throw new Error(`Harness '${profile.name}' references account '${profile.account}', which does not exist on this device. ` +
+                `Accounts are per-machine; pick one from 'agents accounts list' and repoint with ` +
+                `'agents harness edit ${profile.name} --account <name>', or add it with 'agents accounts add'.`);
+        }
         const account = resolveCredentialAccount(profile.account, profile.host.agent, profile.provider);
         Object.assign(env, account.env);
     }