@phnx-labs/agents-cli 1.22.16 → 1.22.17

package/dist/lib/feed-post.js

@@ -16,7 +16,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { spawnSync } from 'child_process';
-import { appendActivityEvent, } from './activity.js';
+import { appendActivityEvent, readRecentActivity, } from './activity.js';
 import { resolveProjectNameForCwd, listProjectDefs } from './projects.js';
 import { getHistoryDir } from './state.js';
 import { machineId } from './machine-id.js';
@@ -30,7 +30,7 @@ export const STATUS_TITLE_MAX_CHARS = 60;
  * Resolve who is posting. Order:
  *  1. Explicit --session flag
  *  2. Env: AGENT_SESSION_ID / AGENTS_SESSION_ID / basename(AGENTS_MAILBOX_DIR)
- *  3. Env AGENT_LAUNCH_ID → match in pid registry
+ *  3. Env AGENT_LAUNCH_ID → match in pid registry or activity index
  *  4. Walk parent PIDs from startPid (default process.ppid) through by-pid registry
  */
 export function resolvePostIdentity(input) {
@@ -55,8 +55,12 @@ export function resolvePostIdentity(input) {
             registry = walkPidRegistry(start, getParent, readEntry);
         }
     }
+    const activity = launchId && !envSession && !registry?.sessionId
+        ? readRecentActivity({ root: input.activityRoot, maxBytesPerSession: 64 * 1024 })
+            .find((event) => event.launchId === launchId)
+        : undefined;
     // Prefer env session (explicit + managed run), fill gaps from registry.
-    const sessionId = envSession ?? registry?.sessionId;
+    const sessionId = envSession ?? registry?.sessionId ?? activity?.sessionId;
     if (!sessionId || !isValidMailboxId(sessionId))
         return undefined;
     const mailboxFromEnv = mailboxIdFromEnv(env);
@@ -66,17 +70,18 @@ export function resolvePostIdentity(input) {
     return {
         sessionId,
         mailboxId,
-        host: machineIdFromEnv(env),
-        runtime: env.AGENTS_RUNTIME?.trim() || 'headless',
+        host: activity?.host ?? machineIdFromEnv(env),
+        runtime: env.AGENTS_RUNTIME?.trim() || activity?.runtime || 'headless',
         agent: env.AGENTS_AGENT_NAME?.trim()
             || registry?.agent
+            || activity?.agent
             || detectAgentKind(env),
         cwd: input.cwd
-            ?? (env.AGENTS_CWD?.trim() || registry?.cwd || process.cwd()),
-        pid: registry?.pid,
-        launchId: launchId || registry?.launchId,
-        terminalId: env.AGENT_TERMINAL_ID?.trim() || registry?.terminalId,
-        tmuxPane: env.TMUX_PANE?.trim() || registry?.tmuxPane,
+            ?? (env.AGENTS_CWD?.trim() || registry?.cwd || activity?.cwd || process.cwd()),
+        pid: registry?.pid ?? activity?.pid,
+        launchId: launchId || registry?.launchId || activity?.launchId,
+        terminalId: env.AGENT_TERMINAL_ID?.trim() || registry?.terminalId || activity?.terminalId,
+        tmuxPane: env.TMUX_PANE?.trim() || registry?.tmuxPane || activity?.tmuxPane,
     };
 }
 function firstValidId(candidates) {

package/dist/lib/hosts/remote-cmd.js

@@ -118,6 +118,14 @@ export const RUN_OPTION_FORWARDING = {
     bare: 'local-only', // skips the local setup-copy push; lease-only concern
     tailscale: 'local-only', // --tailscale/--no-tailscale gate the lease net mode; never forwarded
     copyCreds: 'local-only', // copies creds TO the host before dispatch — local concern only
+    // Cloud placement: chosen and dispatched from THIS machine via the provider
+    // registry; mutually exclusive with --host (placement conflict dies before
+    // dispatch), so these never have a remote argv to ride.
+    cloud: 'local-only',
+    provider: 'local-only',
+    repo: 'local-only',
+    branch: 'local-only',
+    cloudEnv: 'local-only',
     authCheck: 'local-only', // --no-auth-check gates the local interactive login preflight; --host runs skip that preflight entirely
     // The notification must land on the box the PERSON is at — the one that
     // dispatched — not on a headless worker with no desktop to post to. The local

package/dist/lib/humans.d.ts

@@ -12,8 +12,9 @@ export declare function readHumans(): HumansConfig | null;
  */
 export declare function writeHumans(config: HumansConfig): void;
 /**
- * Return the effective owner notification config from humans.yaml if
- * available, otherwise return null (caller falls back to agents.yaml).
+ * Return the effective owner notification destination from humans.yaml.
+ * The owner's normal-severity policy selects the channel; when no normal
+ * policy is declared, the first addressable channel is the default.
  */
 export declare function getOwnerNotifyFromHumans(): {
     channel: string;

package/dist/lib/humans.js

@@ -5,8 +5,7 @@
  * Schema version: 1
  *
  * This module is the single read/write seam for humans.yaml. All channel/
- * notify consumers should read owner config from here (with a fallback to
- * the legacy notify.owner in agents.yaml during the migration window).
+ * notify consumers should read owner config from here.
  */
 import * as fs from 'fs';
 import * as yaml from 'yaml';
@@ -47,14 +46,23 @@ export function writeHumans(config) {
     fs.writeFileSync(filePath, HUMANS_HEADER + body, { encoding: 'utf-8', mode: 0o600 });
 }
 /**
- * Return the effective owner notification config from humans.yaml if
- * available, otherwise return null (caller falls back to agents.yaml).
+ * Return the effective owner notification destination from humans.yaml.
+ * The owner's normal-severity policy selects the channel; when no normal
+ * policy is declared, the first addressable channel is the default.
  */
 export function getOwnerNotifyFromHumans() {
-    const humans = readHumans();
-    const notify = humans?.owner?.notify;
-    if (notify?.channel && notify?.to)
-        return notify;
+    const owner = readHumans()?.owner;
+    const channels = owner?.channels ?? [];
+    const preferredIds = owner?.policy?.normal ?? [];
+    const preferred = preferredIds
+        .map((id) => channels.find((entry) => entry.id === id))
+        .find((entry) => entry?.to);
+    const selected = preferred ?? channels.find((entry) => entry.to);
+    if (selected?.id && selected.to)
+        return { channel: selected.id, to: selected.to };
+    const migrated = owner?.notify;
+    if (migrated?.channel && migrated.to)
+        return migrated;
     return null;
 }
 /**

package/dist/lib/notify.d.ts

@@ -4,7 +4,7 @@
  * Every human-facing owner notification (feed urgent-block dispatch, monitor
  * `notify` action, `agents notify`) funnels through the single channel seam:
  * `lookupTransport(channel, meta).provider.send(text, opts)`. The recipient comes
- * from `notify.owner` in agents.yaml — never a hardcoded chat id — so changing the
+ * from `humans.yaml` — never a hardcoded chat id — so changing the
  * owner is honoured by every path at once. `notify.transports` picks the actual
  * provider per host (rush telegram on zion, openclaw-telegram on mac-mini).
  * Best-effort: a delivery failure is returned to the caller, never thrown, so a
@@ -19,9 +19,9 @@ import type { SendResult } from './channels/registry.js';
 export interface OwnerNotifyOptions {
     /** Config source (defaults to `readMeta()`); lets callers/tests inject it. */
     meta?: Meta;
-    /** Override the owner channel from `notify.owner.channel`. */
+    /** Override the owner channel resolved from humans.yaml. */
     channel?: string;
-    /** Override the owner target from `notify.owner.to`. */
+    /** Override the owner target resolved from humans.yaml. */
     target?: string;
     /** Resolve + build the delivery but do not actually send. */
     dryRun?: boolean;
@@ -44,7 +44,7 @@ export declare function buildOpenClawNotifyArgs(text: string, opts: {
 }): string[];
 /**
  * Deliver a message to the configured owner through the one channel seam.
- * `channel`/`target` default to `notify.owner.{channel,to}`; `notify.transports`
+ * `channel`/`target` default to the normal owner channel in humans.yaml; `notify.transports`
  * selects the provider per host. A missing owner config or a delivery failure
  * (e.g. openclaw not on PATH) returns a clean `SendResult` error — never a raw
  * ENOENT — so callers surface a consistent, best-effort failure.

package/dist/lib/notify.js

@@ -34,17 +34,14 @@ export function buildOpenClawNotifyArgs(text, opts) {
 }
 /**
  * Deliver a message to the configured owner through the one channel seam.
- * `channel`/`target` default to `notify.owner.{channel,to}`; `notify.transports`
+ * `channel`/`target` default to the normal owner channel in humans.yaml; `notify.transports`
  * selects the provider per host. A missing owner config or a delivery failure
  * (e.g. openclaw not on PATH) returns a clean `SendResult` error — never a raw
  * ENOENT — so callers surface a consistent, best-effort failure.
  */
 export async function sendToOwner(text, options = {}) {
     const meta = options.meta ?? readMeta();
-    // humans.yaml is the primary source; agents.yaml notify.owner is the fallback.
-    const humansOwner = getOwnerNotifyFromHumans();
-    const legacyOwner = meta.notify?.owner;
-    const owner = humansOwner ?? legacyOwner;
+    const owner = getOwnerNotifyFromHumans() ?? meta.notify?.owner;
     const channel = options.channel ?? owner?.channel;
     const target = options.target ?? owner?.to;
     if (!channel || !target) {
@@ -52,7 +49,7 @@ export async function sendToOwner(text, options = {}) {
             ok: false,
             channel: channel ?? 'unknown',
             id: target ?? '',
-            error: 'notify.owner.{channel,to} not set in humans.yaml or agents.yaml',
+            error: 'No addressable owner channel configured in humans.yaml or legacy notify.owner',
         };
     }
     registerBuiltinProviders();

package/dist/lib/placement.d.ts

@@ -2,7 +2,7 @@
  * Placement — one model for "where does the body run?"
  *
  * The CLI grew several doors that all mean execution target:
- *   run --host / --device / --lease / --box
+ *   run --host / --device / --lease / --box / --cloud
  *   routines --placement / --run-on / hostStrategy
  *   monitors --run-on (body) vs --device (owner — NOT placement)
  *   teams --device (teammate pin)
@@ -41,6 +41,10 @@ export interface RunPlacementFlags {
     computer?: string;
     lease?: string | boolean;
     box?: string;
+    /** --cloud: vendor cloud placement (the agent's native cloud provider). */
+    cloud?: boolean;
+    /** --provider: refines the cloud placement; not a placement on its own. */
+    provider?: string;
 }
 export declare class PlacementError extends Error {
     constructor(message: string);
@@ -68,10 +72,10 @@ export declare function placementFromRunFlags(flags: RunPlacementFlags): Placeme
  * Expand a resolved placement into the concrete run option fields the
  * existing dispatch paths already understand. Pure — does not mutate input.
  *
- * `cloud` and `fleet` are not valid for a bare `agents run` (use `cloud run`
- * / routines); they throw so callers fail loud.
+ * `fleet` is not valid for a bare `agents run` (it is a routines placement);
+ * it throws so callers fail loud.
  */
-export declare function expandPlacementToRunFlags(placement: Placement): Pick<RunPlacementFlags, 'host' | 'device' | 'lease' | 'box'>;
+export declare function expandPlacementToRunFlags(placement: Placement): Pick<RunPlacementFlags, 'host' | 'device' | 'lease' | 'box' | 'cloud' | 'provider'>;
 /** Map routines hostStrategy (+ optional host) onto the shared Placement. */
 export declare function placementFromHostStrategy(strategy: 'local' | 'host' | 'fleet' | 'cloud', host?: string): Placement;
 /** One-line human form for logs / help. */

package/dist/lib/placement.js

@@ -2,7 +2,7 @@
  * Placement — one model for "where does the body run?"
  *
  * The CLI grew several doors that all mean execution target:
- *   run --host / --device / --lease / --box
+ *   run --host / --device / --lease / --box / --cloud
  *   routines --placement / --run-on / hostStrategy
  *   monitors --run-on (body) vs --device (owner — NOT placement)
  *   teams --device (teammate pin)
@@ -93,6 +93,7 @@ export function placementFromRunFlags(flags) {
     const hostT = hostFamilyTarget(flags);
     const hasLease = flags.lease !== undefined && flags.lease !== false;
     const hasBox = !!flags.box;
+    const hasCloud = flags.cloud === true;
     const placementFlags = [];
     if (where)
         placementFlags.push('--where');
@@ -102,12 +103,16 @@ export function placementFromRunFlags(flags) {
         placementFlags.push('--lease');
     if (hasBox)
         placementFlags.push('--box');
+    if (hasCloud)
+        placementFlags.push('--cloud');
     if (placementFlags.length > 1) {
         throw new PlacementError(`Conflicting placement flags: ${placementFlags.join(' + ')}. ` +
-            `Use one door — prefer --where (device:<name> | auto | lease | local).`);
+            `Use one door — prefer --where (device:<name> | auto | lease | cloud | local).`);
     }
     if (where)
         return parseWhereSpec(where, '--where');
+    if (hasCloud)
+        return { kind: 'cloud', target: flags.provider, source: '--cloud' };
     if (hasBox)
         return { kind: 'lease', target: flags.box, source: '--box' };
     if (hasLease) {
@@ -122,8 +127,8 @@ export function placementFromRunFlags(flags) {
  * Expand a resolved placement into the concrete run option fields the
  * existing dispatch paths already understand. Pure — does not mutate input.
  *
- * `cloud` and `fleet` are not valid for a bare `agents run` (use `cloud run`
- * / routines); they throw so callers fail loud.
+ * `fleet` is not valid for a bare `agents run` (it is a routines placement);
+ * it throws so callers fail loud.
  */
 export function expandPlacementToRunFlags(placement) {
     switch (placement.kind) {
@@ -140,12 +145,13 @@ export function expandPlacementToRunFlags(placement) {
             if (placement.source === '--box')
                 return { box: placement.target };
             return placement.target ? { lease: placement.target } : { lease: true };
+        case 'cloud':
+            // Vendor cloud placement — `--where cloud[:provider]` expands to the
+            // --cloud flag (+ --provider refinement) the run action dispatches on.
+            return placement.target ? { cloud: true, provider: placement.target } : { cloud: true };
         case 'fleet':
             throw new PlacementError(`fleet placement is for routines (agents routines add … --placement fleet), not agents run. ` +
                 `Use --where device:auto for an affinity pick, or --where device:<name>.`);
-        case 'cloud':
-            throw new PlacementError(`cloud placement is agents cloud run (vendor cloud), not agents run. ` +
-                `For a disposable box use --where lease; for your fleet use --where device:<name>.`);
     }
 }
 /** Map routines hostStrategy (+ optional host) onto the shared Placement. */
@@ -180,9 +186,9 @@ export const PLACEMENT_MATRIX = `
   Affinity pick (14d usage)      --where auto            (= --device auto)
   Disposable cloud box           --where lease           (= --lease)
   Reuse warm crabbox             --box <slug>
+  Vendor cloud task              --cloud   (= --where cloud[:provider])
   Routines: body on one box      --run-on <name> / --placement host
   Routines: pick any online      --placement fleet
-  Vendor cloud task              agents cloud run …
   Monitors: who evaluates        --device <owner>   (NOT body placement)
   Monitors: where action runs    --run-on <host>
 `.trim();

package/dist/lib/settings-manifest.js

@@ -30,7 +30,13 @@ const SETTINGS_MANIFEST = {
             strategy: 'toml-merge',
             stateKeys: ['notice', 'windows_wsl_setup_acknowledged'],
         },
-        { rel: '.codex/auth.json', strategy: 'copy-if-absent', restrictMode: true },
+        // `.codex/auth.json` is deliberately NOT carried forward. Copying it seeded
+        // every new Codex version with the current default's ChatGPT token, so two
+        // installed versions always reported the same account and could never sign
+        // into separate accounts. Claude omits its credential (`.claude.json`) for
+        // the same reason — a version home holds its own login, keeping accounts
+        // per-version. A fresh Codex version installs signed-out; run `codex login`
+        // (or `agents run codex --version <v>`) inside it to authenticate.
         { rel: '.codex/instructions.md', strategy: 'copy-if-absent' },
         { rel: '.codex/hooks.json', strategy: 'copy-if-absent' },
         { rel: '.codex/prompts', strategy: 'dir-entries' },

package/dist/lib/types.d.ts

@@ -1008,6 +1008,8 @@ export interface HumanChannel {
     id: string;
     /** Provider transport (e.g. "rush", "twilio"). */
     transport: string;
+    /** Provider-specific recipient (phone number, user id, address). */
+    to?: string;
     /** If true the channel is watched for incoming messages. */
     watch?: boolean;
     /** Shell command to invoke (for call channels). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.16",
+  "version": "1.22.17",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",