@phnx-labs/agents-cli 1.22.39 → 1.22.41

package/dist/lib/routines-placement.d.ts

@@ -9,7 +9,7 @@
  * fire. Cross-device double-fire is prevented by requiring a `devices` firing
  * pin for fleet/host/cloud strategies (applied at add/sync time).
  */
-import type { JobConfig } from './routines.js';
+import type { JobConfig } from './scheduling/routines.js';
 import { type DevicePlatform } from './devices/registry.js';
 export type PlacementTarget = {
     mode: 'local';
@@ -35,5 +35,15 @@ export declare function pickFleetDevice(_config?: Pick<JobConfig, 'devices'>, pl
 /**
  * Resolve where a fired job's body should execute.
  * Throws a human-readable Error when placement cannot be satisfied.
+ *
+ * `host: 'auto'` under `hostStrategy: fleet` re-picks a healthy, signed-in,
+ * unloaded device AT EACH FIRE via the same picker `agents run --device auto`
+ * uses (`resolveDeviceAuto`), instead of `pickFleetDevice`'s
+ * first-online-by-name order. The decision is deliberately not baked in at add
+ * time — fleet health at fire time is the whole point (RUSH-2719).
  */
-export declare function resolvePlacementTarget(config: JobConfig): PlacementTarget;
+export declare function resolvePlacementTarget(config: JobConfig, deps?: {
+    resolveDeviceAuto?: (agent?: string) => Promise<{
+        pickedDeviceKey: string;
+    }>;
+}): Promise<PlacementTarget>;

package/dist/lib/routines-placement.js

@@ -9,7 +9,7 @@
  * fire. Cross-device double-fire is prevented by requiring a `devices` firing
  * pin for fleet/host/cloud strategies (applied at add/sync time).
  */
-import { resolveHostStrategy } from './routines.js';
+import { resolveHostStrategy } from './scheduling/routines.js';
 import { machineId, normalizeHost } from './machine-id.js';
 import { loadDevicesSync } from './devices/registry.js';
 import { planFleetTargets } from './devices/fleet.js';
@@ -53,8 +53,14 @@ export function pickFleetDevice(_config, platform) {
 /**
  * Resolve where a fired job's body should execute.
  * Throws a human-readable Error when placement cannot be satisfied.
+ *
+ * `host: 'auto'` under `hostStrategy: fleet` re-picks a healthy, signed-in,
+ * unloaded device AT EACH FIRE via the same picker `agents run --device auto`
+ * uses (`resolveDeviceAuto`), instead of `pickFleetDevice`'s
+ * first-online-by-name order. The decision is deliberately not baked in at add
+ * time — fleet health at fire time is the whole point (RUSH-2719).
  */
-export function resolvePlacementTarget(config) {
+export async function resolvePlacementTarget(config, deps = {}) {
     const strategy = resolveHostStrategy(config);
     switch (strategy) {
         case 'local':
@@ -69,7 +75,18 @@ export function resolvePlacementTarget(config) {
             return { mode: 'host', host: config.host };
         }
         case 'fleet': {
-            const picked = pickFleetDevice(config);
+            let picked;
+            if (config.host === 'auto') {
+                const resolveAuto = deps.resolveDeviceAuto
+                    ?? (async (agent) => (await import('./smart-launch.js')).resolveDeviceAuto(agent));
+                // resolveDeviceAuto fails loud on an empty/unhealthy pool — surface its
+                // message (it names each excluded device) instead of a generic one.
+                const plan = await resolveAuto(config.agent);
+                picked = plan.pickedDeviceKey;
+            }
+            else {
+                picked = pickFleetDevice(config);
+            }
             if (!picked) {
                 throw new Error(`Routine '${config.name}' hostStrategy: fleet — no eligible online device to place the run`);
             }

package/dist/lib/routines-project.d.ts

@@ -12,7 +12,7 @@
  * `list` shows them as disabled. `syncProjectRoutines` refreshes materialised
  * copies from their source YAML (also invoked on daemon SIGHUP).
  */
-import { type JobConfig, type JobSource } from './routines.js';
+import { type JobConfig, type JobSource } from './scheduling/routines.js';
 /** Expand `~/…` and resolve to an absolute path. */
 export declare function expandProjectPath(p: string): string;
 /** Store paths home-relative when under $HOME so they travel across machines. */

package/dist/lib/routines-project.js

@@ -18,7 +18,7 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { execFileSync } from 'child_process';
 import { getProjectAgentsDir, getProjectRoutinesDir, ensureAgentsDir, } from './state.js';
-import { readJob, writeJob, deleteJob, listJobs, validateJob, } from './routines.js';
+import { readJob, writeJob, deleteJob, listJobs, validateJob, } from './scheduling/routines.js';
 import { parseOwnerRepoFromRemote } from './registry.js';
 import { listProjectDefs, projectDirsAbs } from './projects.js';
 import { isSafeSegmentName } from './paths.js';

package/dist/lib/rules/compile.d.ts

@@ -8,6 +8,7 @@
  */
 import type { AgentId } from '../types.js';
 import { type RulesLayer } from './compose.js';
+export declare const COMPILED_HEADER_PROJECT: string;
 /** Sidecar manifest recording source file hashes for staleness detection. */
 export interface CompileManifest {
     compiledAt: string;

package/dist/lib/rules/compile.js

@@ -11,7 +11,7 @@ import * as path from 'path';
 import * as os from 'os';
 import * as crypto from 'crypto';
 import { AGENTS, agentConfigDirName } from '../agents.js';
-import { getVersionsDir } from '../state.js';
+import { getVersionsDir, isReservedAgentsDir } from '../state.js';
 import { composeRules, composeRulesFromState } from './compose.js';
 // Match `@path` preceded by start-of-string or whitespace. This avoids
 // matching emails ("foo@bar.com") and the middle of words. The leading
@@ -20,7 +20,7 @@ const IMPORT_RE = /(^|\s)@(\S+)/g;
 const MAX_DEPTH = 5;
 const COMPILED_HEADER = '<!-- Auto-compiled by agents-cli from ~/.agents/rules/AGENTS.md + imports.\n' +
     '     Edit the source files under ~/.agents/rules/ — edits to this file will be overwritten on next sync. -->\n\n';
-const COMPILED_HEADER_PROJECT = '<!-- Auto-compiled by agents-cli from .agents/rules/AGENTS.md + imports.\n' +
+export const COMPILED_HEADER_PROJECT = '<!-- Auto-compiled by agents-cli from .agents/rules/AGENTS.md + imports.\n' +
     '     Edit the source files under .agents/rules/ — edits to this file will be overwritten on next sync. -->\n\n';
 function expandTilde(p) {
     if (p === '~')
@@ -230,6 +230,14 @@ export function compileRulesForProject(cwd, opts = {}) {
     };
     if (!fs.existsSync(projectRulesDir))
         return empty;
+    // The user layer's own home satisfies the rules-dir test — ~/.agents/rules
+    // exists on every configured machine — which compiled $HOME as a "project",
+    // wrote ~/AGENTS.md (+ per-agent symlinks), and injected the whole ruleset
+    // into every session twice: once as global memory, once as "project" memory
+    // (RUSH-2725). Reserved roots (user layer, system layer, or a checkout of
+    // either canonical DotAgents repo) never compile as a project.
+    if (isReservedAgentsDir(path.join(cwd, '.agents')))
+        return empty;
     let composed;
     try {
         // Tests inject `layers` to isolate from real ~/.agents-system / ~/.agents

package/dist/lib/rules/rules.js

@@ -10,7 +10,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { AGENTS, ALL_AGENT_IDS, agentConfigDirName } from '../agents.js';
 import { getResolvedRulesDir, getUserRulesDir, getProjectAgentsDir } from '../state.js';
-import { getEffectiveHome } from '../versions.js';
+import { getEffectiveHome } from '../installations/versions.js';
 /**
  * Central rules filename constant.
  * All agents map to this file in ~/.agents/rules/, renamed per-agent when synced.

package/dist/lib/run-notify.js

@@ -11,7 +11,7 @@
  * does not need a helper to have been running at dispatch time either.
  *
  * Armed once via `process.on('exit')` so it covers every way the run command
- * terminates — local spawn, `--host` dispatch, `--lease` box, the error path —
+ * terminates — local spawn, `--device` dispatch, `--lease` box, the error path —
  * rather than being sprinkled over ~50 `process.exit` call sites where the next
  * new exit path would silently miss it.
  */

package/dist/lib/runner.d.ts

@@ -13,12 +13,12 @@
  * limit is detected mid-run (foreground `executeJob` only — detached daemon
  * fires once with the pre-flight pick).
  */
-import type { JobConfig, RunMeta } from './routines.js';
+import type { JobConfig, RunMeta } from './scheduling/routines.js';
 import { readMeta } from './state.js';
 import type { AgentId } from './types.js';
 import { type FallbackEntry } from './exec.js';
 import type { LoopDeps } from './loop.js';
-import { resolveRunVersion, resolveAccountVersion, type RotateResult } from './rotate.js';
+import { resolveRunVersion, resolveAccountVersion, type RotateResult } from './accounting/rotate.js';
 /** Result of a completed job execution, including metadata and optional report. */
 export interface RunResult {
     meta: RunMeta;
@@ -27,12 +27,43 @@ export interface RunResult {
 export declare class RoutineAlreadyRunningError extends Error {
     constructor(jobName: string, runId: string);
 }
+/**
+ * Consecutive trailing `skipped`/`active_run` records — a routine that keeps
+ * being refused because a prior run "still owns" the slot. After the slot is
+ * released correctly on terminal states (see {@link activeRoutineRun}) this can
+ * only accumulate for a genuine long-overlap or a new wedge; either way it means
+ * the routine has stopped firing on schedule and should be surfaced, not left to
+ * pile up silently. `runs` is oldest→newest (listRuns sorts by run id).
+ */
+export declare function activeRunSkipStreak(runs: RunMeta[]): number;
+/**
+ * The pid to stamp on a launcher's provisional active claim, or null when the
+ * launcher is this box's routines daemon.
+ *
+ * The claim pid exists so a launcher that dies between claiming the slot and
+ * spawning the child releases the slot quickly (`isPidOurs` goes false) instead
+ * of wedging it for the full timeout. That fast recovery only helps a SHORT-LIVED
+ * foreground launcher (`agents routines run`): the daemon never dies between
+ * claim and spawn, and recording ITS pid is actively harmful — the daemon
+ * outlives every run, so `isPidOurs` never goes false and a claim finalized to a
+ * terminal state before its child spawned kept the slot and drew
+ * `reapTerminalRoutineProcesses` at the daemon's own process group on every tick
+ * (RUSH-2640, requirement: never record the daemon's own pid as a run's pid). So
+ * the daemon records no claim pid; the timeout window bounds a daemon that
+ * crashes mid-claim instead.
+ */
+export declare function launcherClaimPid(): number | null;
 /** How a routine attempt was triggered, plus the schedule slot it belongs to. */
 export interface RoutineTrigger {
     kind: NonNullable<RunMeta['triggerKind']>;
     /** UTC fire time for a schedule/catchup attempt; keys the single-fire slot claim. */
     scheduledFor?: Date | string;
 }
+/** A claimed attempt: the run id to use, plus the RunMeta fields to stamp on it. */
+interface RoutineAttempt {
+    runId: string;
+    stamp: Partial<Pick<RunMeta, 'triggerKind' | 'scheduledFor' | 'project' | 'requestedCwd' | 'resolvedCwd'>>;
+}
 /**
  * Working directory for a routine's LOCAL child, resolved from its explicit
  * `project`/`cwd` execution anchor via {@link resolveJobExecutionContext} — never
@@ -95,6 +126,41 @@ export declare function pinJobBinary(cmd: string[], agent: AgentId, version: str
  * Such commands must NOT be binary-pinned (pinning rewrites cmd[0] to the agent binary,
  * producing a broken `<binary> run …`) and must not receive a version-pinned spawn env.
  */
+/**
+ * Assert a routine's account can be dispatched to the resolved placement, BEFORE
+ * any off-box dispatch (placement is resolved before {@link resolveRoutineLaunch}),
+ * at the top of both the foreground and detached paths:
+ *
+ * - **native** account → rejected for host AND cloud: a native login is a
+ *   device-local harness credential that cannot be forwarded off-box.
+ * - **provider** account + **cloud** → rejected (fail loud): the cloud dispatch
+ *   has no secure way to inject a device-local provider bundle yet.
+ * - **provider** account + **host** → allowed: the host dispatch forwards the
+ *   account NAME (the remote resolves its own local bundle — no secret copied).
+ *
+ * `account` is injectable so the guard is unit-tested for both modes without a
+ * registry or a real dispatch.
+ */
+export declare function assertRoutineAccountLocalForPlacement(config: Pick<JobConfig, 'name' | 'account'>, mode: 'host' | 'cloud', deps?: {
+    account?: import('./account-registry.js').UnifiedAccount | null;
+    readMeta?: typeof readMeta;
+}): Promise<void>;
+export declare function dispatchPlacedJob(config: JobConfig, target: import('./routines-placement.js').PlacementTarget, attempt: RoutineAttempt, deps?: {
+    account?: import('./account-registry.js').UnifiedAccount | null;
+    host?: typeof executeJobOnHost;
+    cloud?: typeof executeJobOnCloud;
+}): Promise<RunResult | undefined>;
+/**
+ * Build the options passed to `dispatchPromptToHost` for a host routine. Split
+ * out so the execution boundary is unit-testable: it MUST forward the routine's
+ * `account` by name (the remote resolves its own local bundle; no secret copied)
+ * — dropping it silently ran the remote under the wrong identity.
+ */
+export declare function buildHostDispatchOptions(config: JobConfig, ctx: {
+    remoteCwd: string | undefined;
+    runDir: string;
+    detached: boolean;
+}): import('./hosts/run-target.js').HostPromptRun;
 export declare function dispatchesViaAgentsRun(config: Pick<JobConfig, 'workflow' | 'resume'>): boolean;
 /**
  * Merge sandbox/base env with the canonical per-version exec env
@@ -103,6 +169,17 @@ export declare function dispatchesViaAgentsRun(config: Pick<JobConfig, 'workflow
  */
 export declare function buildRoutineSpawnEnv(baseEnv: Record<string, string>, agent: AgentId, version: string | undefined, timezone?: string, overlayHome?: string): Record<string, string>;
 export declare function executeJob(config: JobConfig, deps?: LoopDeps, trigger?: RoutineTrigger): Promise<RunResult>;
+/**
+ * Dispatch a routine to the agent's native cloud provider (or the configured
+ * default). Writes a local run record with `cloudTaskId` so list/runs still
+ * work; does not wait for cloud completion on the detached path.
+ */
+declare function executeJobOnCloud(config: JobConfig, opts: {
+    detached: boolean;
+}, attempt: RoutineAttempt): Promise<RunResult>;
+declare function executeJobOnHost(config: JobConfig, opts: {
+    detached: boolean;
+}, attempt: RoutineAttempt): Promise<RunResult>;
 /**
  * Optional lifecycle callbacks for a detached routine run. The daemon passes an
  * `onFinish` that fires the branded finish/output notification (RUSH-2030) — it
@@ -141,3 +218,4 @@ export declare function inferFinalStatusFromLog(stdoutPath: string, agent: Agent
 export declare function listLiveRoutineChildren(): number[];
 /** Scan all runs marked "running" and finalize any whose process has exited. */
 export declare function monitorRunningJobs(): void;
+export {};