@phnx-labs/agents-cli 1.20.76 → 1.20.78

package/dist/commands/exec.js

@@ -20,8 +20,9 @@ import { sshResolve } from '../lib/hosts/ssh-config.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { randomUUID } from 'crypto';
 import { spawnSync } from 'child_process';
+import { randomUUID } from 'crypto';
+import { isSessionTrackedAgent } from '../lib/session/types.js';
 /** Distinguish a terminal account-picker marker from an explicit @version pin. */
 export function parseRunAccountPickerRequest(agentSpec) {
     const requested = agentSpec.endsWith('@');
@@ -382,8 +383,8 @@ export function registerRunCommand(program) {
         .option('--budget <tokens>', 'Loop token hard-cap: stop once cumulative tokens reach this (stoppedBy: budget), enforced outside the agent. Loop only.')
         .option('--until <signal>', 'Loop stop condition. `signal` reads <runDir>/loop-signal.json {continue,reason} each iteration; absent or continue:false stops (fail-closed). Loop only.')
         .option('--interval <dur>', 'Loop delay between iterations ("0" back-to-back, "30m" paces). Loop only.')
-        .option('--host <name>', 'Offload this run onto another machine over SSH instead of running locally — a device, a registered agent host, or user@host. See `agents devices` / `agents hosts`.')
-        .option('--device <name>', 'Alias of --host: offload this run onto a registered device (from `agents devices`).')
+        .option('--host <name>', 'Offload this run onto another machine over SSH — a device name, registered host, or user@host. Pass "auto" to pick from 14d usage affinity (most-used online device has highest probability). See `agents devices`.')
+        .option('--device <name>', 'Alias of --host. Pass "auto" for affinity-based device pick (same as --host auto).')
         .option('--remote-cwd <dir>', "Explicit host working directory for --host runs, used VERBATIM (overrides --cwd; usually --cwd suffices — it re-roots a local-home path onto the remote home). Pass a single-quoted '$HOME/…' or a valid remote absolute path; a local ~ expands here and won't exist there (/Users/you vs /home/you).")
         .option('--no-follow', 'With --host, dispatch detached and return immediately (track via `agents hosts ps/logs`).')
         .option('--any', 'With --host <cap> (a capability tag), pick any matching host instead of erroring when several match.')
@@ -398,6 +399,8 @@ export function registerRunCommand(program) {
     // `--on` and `--computer` are hidden aliases of `--host` — same behavior.
     runCmd.addOption(new Option('--on <name>', 'Alias of --host.').hideHelp());
     runCmd.addOption(new Option('--computer <name>', 'Alias of --host.').hideHelp());
+    // Deprecated one-release alias: `agents run … --smart` → treat as `--device auto`.
+    runCmd.addOption(new Option('--smart', 'Deprecated: use --device auto (affinity host pick).').hideHelp());
     // Internal: the `--host` dispatch forwards this so the REMOTE run prints its
     // resolved session id as a one-line stdout sentinel (hosts/session-marker.ts),
     // letting the launcher relate the remote-created session back to itself for
@@ -494,11 +497,14 @@ export function registerRunCommand(program) {
         // their existing meaning in every dispatch path below.
         const accountPicker = parseRunAccountPickerRequest(agentSpec);
         const accountPickerRequested = accountPicker.requested;
-        const normalizedAgentSpec = accountPicker.normalizedAgentSpec;
+        let normalizedAgentSpec = accountPicker.normalizedAgentSpec;
         if (!accountPicker.valid) {
             console.error(chalk.red(`Invalid account picker target: ${agentSpec}. Use agents run <agent>@.`));
             process.exit(1);
         }
+        // Account-picker conflict check runs BEFORE device=auto may set balanced,
+        // so an implicit balanced preference never surfaces as a fake
+        // "cannot be combined with --balanced" when the user only typed trailing @.
         if (accountPickerRequested) {
             const conflicts = runAccountPickerConflicts(options);
             if (conflicts.length > 0) {
@@ -507,6 +513,27 @@ export function registerRunCommand(program) {
                 process.exit(1);
             }
         }
+        // --device auto / --host auto (and deprecated --smart): affinity-pick host.
+        // Harness is always the agent the user typed — never auto-picked.
+        // Affinity failure degrades to local (does not kill the run).
+        {
+            const { applyDeviceAutoToOptions } = await import('../lib/smart-launch.js');
+            const result = applyDeviceAutoToOptions(options, {
+                accountPickerRequested,
+            });
+            if (!options.quiet && result.deprecationSmart) {
+                process.stderr.write(chalk.yellow('[agents] --smart is deprecated; use --device auto\n'));
+            }
+            if (!options.quiet && result.skipped) {
+                process.stderr.write(chalk.yellow(`[agents] device=auto skipped: ${result.skipped} (running local)\n`));
+            }
+            if (!options.quiet && result.banner) {
+                const { hostLabel, deviceHint, acctNote } = result.banner;
+                process.stderr.write(chalk.gray(`[agents] device=auto → ${hostLabel}` +
+                    (deviceHint ? ` (affinity ${deviceHint})` : '') +
+                    ` · ${acctNote}\n`));
+            }
+        }
         // --lease: invent a disposable cloud box for this run (via crabbox), run
         // the agent there, then tear it down. --box: reuse a named warm crabbox
         // box, run the same bootstrap there, and leave the box running.
@@ -877,7 +904,7 @@ export function registerRunCommand(program) {
                 process.exit(1);
             }
             const hostName = hostGiven[0];
-            const { resolveHostRunTarget, dispatchPromptToHost, HostResolutionError } = await import('../lib/hosts/run-target.js');
+            const { resolveHostRunTarget, resolveHostSessionId, dispatchPromptToHost, HostResolutionError } = await import('../lib/hosts/run-target.js');
             const { runInteractiveOnHost } = await import('../lib/hosts/dispatch.js');
             const { registerInteractiveHostSession } = await import('../lib/hosts/session-index.js');
             const { RUN_OPTION_REJECT_MESSAGES } = await import('../lib/hosts/remote-cmd.js');
@@ -1035,10 +1062,21 @@ export function registerRunCommand(program) {
                         process.exit(1);
                     }
                     // Mirror the local path (lib/exec.ts): only Claude accepts a forced
-                    // `--session-id`. Generating it here lets us register the run in the
-                    // local index and makes it resumable by id. On resume the remote
-                    // session keeps its existing id — don't mint a new one.
-                    const hostSessionId = runAgent === 'claude' && !resumeId ? randomUUID() : undefined;
+                    // `--session-id`. Adopt the caller's id when present; otherwise mint
+                    // one here. Registering that same id keeps the local index aligned
+                    // with the remote agent. On resume, don't mint a new one.
+                    const hostSessionId = resolveHostSessionId(runAgent, resumeId, options.sessionId);
+                    // For every OTHER agent the remote coins its own id, which we can't
+                    // know up front. Forward a launch id we control as AGENT_LAUNCH_ID:
+                    // the remote `agents run` adopts it (exec.ts resolveLaunchId) and its
+                    // SessionStart hook records the real id under that exact key, so after
+                    // the stream we resolve the id by one ssh read of the remote hook
+                    // record — the same launch-id join used locally (RUSH-2034). Not
+                    // needed for Claude (id forced) or resume (id already known).
+                    const correlationLaunchId = !hostSessionId && !resumeId && isSessionTrackedAgent(runAgent) ? randomUUID() : undefined;
+                    const hostEnv = correlationLaunchId
+                        ? [...options.env, `AGENT_LAUNCH_ID=${correlationLaunchId}`]
+                        : options.env;
                     if (hostSessionId) {
                         registerInteractiveHostSession({
                             cwd: process.cwd(),
@@ -1058,7 +1096,7 @@ export function registerRunCommand(program) {
                         mode: options.mode,
                         model: options.model,
                         effort: options.effort,
-                        env: options.env,
+                        env: hostEnv,
                         addDir: hostAddDirs,
                         json: options.json,
                         verbose: options.verbose,
@@ -1074,14 +1112,41 @@ export function registerRunCommand(program) {
                         forceInteractive: options.interactive,
                         copyCreds: hostCopyCreds,
                     });
+                    // Resolve a non-Claude agent's REAL remote session id now the run has
+                    // booted (its hook has fired on the peer): one ssh read of the remote
+                    // hook record, keyed by the launch id we forwarded. Register it so the
+                    // run shows in `agents sessions` and can be reconnected/focused —
+                    // closing the non-Claude gap RUSH-2033 left. Best-effort: an
+                    // unreachable host or a not-yet-landed record leaves the run un-mapped
+                    // rather than mis-mapped.
+                    let resolvedRemoteId;
+                    if (correlationLaunchId) {
+                        const { resolveRemoteSessionId } = await import('../lib/hosts/remote-session-id.js');
+                        const { sshTargetFor } = await import('../lib/hosts/types.js');
+                        try {
+                            resolvedRemoteId = resolveRemoteSessionId(sshTargetFor(host), correlationLaunchId);
+                        }
+                        catch {
+                            /* ssh read is best-effort — keep the run un-mapped, never guess */
+                        }
+                        if (resolvedRemoteId) {
+                            registerInteractiveHostSession({
+                                cwd: process.cwd(),
+                                host: host.name,
+                                agent: runAgent,
+                                sessionId: resolvedRemoteId,
+                                name: options.name,
+                            });
+                        }
+                    }
                     // A network drop kills the local ssh client (exit 255) but the remote
                     // agent survives in its detached tmux session. With a known session id
-                    // (Claude, or a resumed run) and a tmux-hosted run, re-attach the live
-                    // pane automatically instead of exiting — the user never has to notice
-                    // the drop and `agents sessions focus` by hand. `raw` runs aren't tmux
-                    // wrapped, so there is nothing to reconnect to. Non-Claude id capture is
-                    // tracked in RUSH-2007.
-                    const reconnectId = hostSessionId ?? resumeId;
+                    // (Claude's forced id, a resumed run, or a non-Claude id we just
+                    // resolved from the remote hook record) and a tmux-hosted run,
+                    // re-attach the live pane automatically instead of exiting — the user
+                    // never has to notice the drop and `agents sessions focus` by hand.
+                    // `raw` runs aren't tmux wrapped, so there is nothing to reconnect to.
+                    const reconnectId = hostSessionId ?? resolvedRemoteId ?? resumeId;
                     if (reconnectId && !isRaw) {
                         const { reconnectInteractiveSession, SSH_CONN_FAILURE } = await import('../lib/hosts/reconnect.js');
                         if (exitCode === SSH_CONN_FAILURE) {
@@ -1127,6 +1192,7 @@ export function registerRunCommand(program) {
                     remoteCwd: hostCwd,
                     name: options.name,
                     resume: resumeId,
+                    sessionId: options.sessionId,
                     follow: options.follow !== false,
                     passthroughArgs,
                     copyCreds: hostCopyCreds,
@@ -1883,11 +1949,13 @@ export function registerRunCommand(program) {
                 else {
                     const { bundle, env: bundleEnv } = readAndResolveBundleEnv(bundleName, {
                         caller: `agent ${agent}`,
+                        agent,
                         keys: secretsKeysSubset,
                         allowExpired: options.allowExpired,
-                        // A headless/background run (routine, teammate, detached) must not
-                        // pop a Touch ID sheet nobody can answer — resolve broker-only and
-                        // fail fast with an actionable error. Interactive runs still prompt.
+                        // The harness identity scopes any cached grant. It no longer lets the
+                        // requesting agent wait for interactive approval — an agent launch
+                        // resolves broker-only and fails fast naming
+                        // `agents secrets unlock <bundle>` (bundles.ts:interactiveUnlock).
                         agentOnly: isHeadlessSecretsContext(),
                     });
                     const entries = describeBundle(bundle);

package/dist/commands/repo.js

@@ -856,6 +856,10 @@ export function registerRepoCommands(program) {
             }
             else {
                 spinner.fail(`${formatRepoTarget(t.alias, t.dir)}: ${result.error}`);
+                // A failed repo must fail the command. Without this, `agents fleet run
+                // "agents repo pull user"` reported 11 ok across a fleet that pulled
+                // nothing — the silence that hid RUSH-2056. Matches commands/sync.ts.
+                process.exitCode = 1;
             }
         }
         // RUSH-1980: a pull rewrites the routine YAML on disk, but the daemon's
@@ -911,6 +915,10 @@ export function registerRepoCommands(program) {
             }
             else {
                 spinner.fail(`${formatRepoTarget(t.alias, t.dir)}: ${result.error}`);
+                // A failed repo must fail the command. Without this, `agents fleet run
+                // "agents repo push user"` reported ok across a fleet that pushed
+                // nothing — the silence that hid RUSH-2056. Matches commands/sync.ts.
+                process.exitCode = 1;
             }
         }
     });

package/dist/commands/routines.js

@@ -12,7 +12,8 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { isDaemonRunning, signalDaemonReload, startDaemon, stopDaemon, readDaemonLog, getDaemonStatus, } from '../lib/daemon.js';
 import { humanizeCron, humanizeNextRun, formatRepoLink, REPO_DISPLAY_MAX } from '../lib/routines-format.js';
-import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, getLatestRun, getRunDir, getJobPath, parseAtTime, jobRunsOnThisDevice, checkJobDeviceEligibility, normalizeTriggerEvent, } from '../lib/routines.js';
+import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, getLatestRun, getRunDir, getJobPath, parseAtTime, jobRunsOnThisDevice, checkJobDeviceEligibility, normalizeTriggerEvent, parseHostStrategy, resolveHostStrategy, placementRequiresFiringPin, HOST_STRATEGIES, } from '../lib/routines.js';
+import { discoverProjectRoutinesAt, enableProjectRoutines, disableProjectRoutines, syncProjectRoutines, syncAllProjectRoutines, listEnabledProjectRoots, resolveProjectRoot, displayProjectPath, listProjectRoutineFiles, } from '../lib/routines-project.js';
 import { fireWebhookJobs, matchJobsToWebhook } from '../lib/triggers/webhook.js';
 import { getRoutinesDir } from '../lib/state.js';
 import { IS_WINDOWS } from '../lib/platform/index.js';
@@ -131,6 +132,24 @@ function ensureSchedulerRunning(opts = {}) {
 function writeJson(payload) {
     process.stdout.write(JSON.stringify(payload) + '\n');
 }
+function printSyncResult(sync) {
+    console.log(chalk.bold(displayProjectPath(sync.projectRoot)));
+    if (sync.synced.length === 0 && sync.skipped.length === 0 && sync.removed.length === 0 && sync.errors.length === 0) {
+        console.log(chalk.gray('  (no project routines)'));
+    }
+    if (sync.synced.length > 0) {
+        console.log(chalk.green(`  synced: ${sync.synced.join(', ')}`));
+    }
+    if (sync.removed.length > 0) {
+        console.log(chalk.gray(`  removed: ${sync.removed.join(', ')}`));
+    }
+    for (const s of sync.skipped) {
+        console.log(chalk.yellow(`  skipped ${s.name}: ${s.reason}`));
+    }
+    for (const e of sync.errors) {
+        console.log(chalk.red(`  error ${e.name}: ${e.error}`));
+    }
+}
 function runMetaJson(run) {
     return {
         jobId: run.jobName,
@@ -233,6 +252,14 @@ export function registerRoutinesCommands(program) {
       # Create from YAML (for complex routines with multiple settings)
       agents routines add weekly-report.yml
 
+      # Place the job body on a fleet device / cloud / named host (not --host)
+      agents routines add drain --schedule "0 3 * * *" --agent claude --placement fleet --prompt "Drain queue"
+      agents routines add review --schedule "0 9 * * 1" --agent claude --placement cloud --prompt "Review open PRs"
+
+      # Opt a project's .agents/routines/*.yml into daemon firing (never auto)
+      agents routines enable-project --yes
+      agents routines sync
+
       # List all routines and their next run times
       agents routines list
 
@@ -270,8 +297,10 @@ export function registerRoutinesCommands(program) {
         - Detached/daemon fires use the pre-flight pick only (next tick re-selects).
         - Diagnostic lines log which account was picked, which were skipped, and
           each failover hop: look for "[agents] routine <name>:" in the run log.
-        - Headless Claude auth: store CLAUDE_CODE_OAUTH_TOKEN in the 'claude'
-          secrets bundle so the daemon can inject it into routine spawns.
+        - Claude auth: a routine authenticates through the pinned account's own
+          on-disk login (the same one 'agents run claude' uses on this device).
+          The daemon injects no token; if that account's login has expired the
+          run is skipped up front with a re-login hint.
     `,
     });
     routinesCmd
@@ -323,6 +352,10 @@ export function registerRoutinesCommands(program) {
                     timezone: job.timezone ?? null,
                     devices: job.devices ?? [],
                     host: job.host ?? null,
+                    hostStrategy: resolveHostStrategy(job),
+                    source: job.source ?? null,
+                    sourceRepo: job.source?.repo ?? job.repo ?? null,
+                    sourceBranch: job.source?.branch ?? null,
                     runsHere: jobRunsOnThisDevice(job),
                     enabled: job.enabled,
                     overdue: overdueSet.has(job.name),
@@ -368,7 +401,12 @@ export function registerRoutinesCommands(program) {
             }
             const latestRun = getLatestRun(job.name);
             const lastStatus = latestRun?.status || '-';
-            const repoInfo = formatRepoLink(job.repo);
+            // Prefer project-source repo (with optional @branch) over bare job.repo.
+            const sourceRepo = job.source?.repo ?? job.repo;
+            const sourceLabel = sourceRepo
+                ? (job.source?.branch ? `${sourceRepo}@${job.source.branch}` : sourceRepo)
+                : null;
+            const repoInfo = formatRepoLink(sourceLabel ?? job.repo);
             const repoCell = link(repoInfo.display, repoInfo.href);
             // Pad based on the display string, not the raw cell (which may include escape codes).
             const repoPadding = Math.max(0, REPO_W - repoInfo.display.length);
@@ -376,8 +414,16 @@ export function registerRoutinesCommands(program) {
             // chalk adds escape codes; pad the raw word and let chalk wrap it.
             const enabledWord = job.enabled ? 'yes' : 'no';
             const enabledPad = Math.max(0, ENABLED_W - enabledWord.length);
-            // Placement (`→host`) rides in the Devices cell: eligibility →execution.
-            const deviceFull = [job.devices?.join(',') ?? '', job.host ? `→${job.host}` : '']
+            // Placement rides in the Devices cell: eligibility →execution strategy.
+            const strategy = resolveHostStrategy(job);
+            const placementTag = strategy === 'local'
+                ? (job.host ? `→${job.host}` : '')
+                : strategy === 'host'
+                    ? `→${job.host ?? '?'}`
+                    : strategy === 'fleet'
+                        ? '→fleet'
+                        : '→cloud';
+            const deviceFull = [job.devices?.join(',') ?? '', placementTag]
                 .filter(Boolean)
                 .join(' ');
             const deviceWord = deviceFull.length === 0
@@ -423,7 +469,8 @@ export function registerRoutinesCommands(program) {
         .option('-t, --timeout <timeout>', 'Kill the agent if it runs longer than this (e.g., 10m, 2h, 3d, 1w; max 1w)', '10m')
         .option('--timezone <tz>', 'Interpret schedule in this timezone (e.g., America/Los_Angeles)')
         .option('--devices <names>', 'Fleet allowlist (comma-separated): only listed devices schedule and fire this routine. Omit for unrestricted.')
-        .option('--run-on <name>', 'Execute the job body on this machine over SSH (a registered host, device, capability tag, or user@host). Placement, not eligibility — see --devices. Auto-pins devices to THIS machine unless --devices is given.')
+        .option('--run-on <name>', 'Execute the job body on this machine over SSH (a registered host, device, capability tag, or user@host). Sets hostStrategy=host. Placement, not eligibility — see --devices. Auto-pins devices to THIS machine unless --devices is given.')
+        .option('--placement <strategy>', `Where the job body runs: ${HOST_STRATEGIES.join('|')} (default: local, or host when --run-on is set). Not the same as --host (which manages routines on a remote machine).`)
         .option('--run-cwd <dir>', 'Working directory on the --run-on host (--remote-cwd is taken by the remote-management passthrough)')
         .option('--at <time>', 'One-shot mode: run once at this time (e.g., "14:30" or "2026-02-24 09:00"), then disable')
         .option('--on <source:event>', 'Webhook trigger instead of/in addition to a schedule: github:pull_request or linear:Issue')
@@ -490,12 +537,29 @@ export function registerRoutinesCommands(program) {
             if (options.devices !== undefined) {
                 devices = await parseAndValidateDevices(options.devices);
             }
-            // --run-on without a --devices pin would fire on EVERY daemon in the
-            // fleet, each dispatching to the same host — duplicate runs. Pin to
-            // this machine unless the user chose an explicit eligibility set.
-            if (options.runOn && !devices) {
+            let hostStrategy;
+            try {
+                hostStrategy = parseHostStrategy(options.placement) ?? undefined;
+            }
+            catch (err) {
+                console.error(chalk.red(err.message));
+                process.exit(1);
+            }
+            // --run-on implies host strategy when the user didn't pick one.
+            if (options.runOn && !hostStrategy)
+                hostStrategy = 'host';
+            if (hostStrategy === 'host' && !options.runOn) {
+                console.error(chalk.red('--placement host requires --run-on <name>'));
+                process.exit(1);
+            }
+            // Off-box placement without a --devices pin would fire on EVERY daemon
+            // in the fleet, each dispatching once — duplicate runs (RUSH-1980).
+            // Pin to this machine unless the user chose an explicit eligibility set.
+            const strategyForPin = hostStrategy
+                ?? (options.runOn ? 'host' : 'local');
+            if (placementRequiresFiringPin(strategyForPin) && !devices) {
                 devices = [machineId()];
-                console.error(chalk.gray(`--run-on set with no --devices: pinned firing to this machine (${devices[0]}).`));
+                console.error(chalk.gray(`--placement ${strategyForPin} with no --devices: pinned firing to this machine (${devices[0]}).`));
             }
             const config = {
                 name: nameOrPath,
@@ -512,6 +576,7 @@ export function registerRoutinesCommands(program) {
                 timezone: options.timezone,
                 ...(devices ? { devices } : {}),
                 ...(options.runOn ? { host: options.runOn } : {}),
+                ...(hostStrategy ? { hostStrategy } : {}),
                 ...(options.runCwd ? { remoteCwd: options.runCwd } : {}),
                 ...(runOnce ? { runOnce: true } : {}),
                 ...(options.endAt ? { endAt: options.endAt } : {}),
@@ -586,11 +651,12 @@ export function registerRoutinesCommands(program) {
                 enabled: true,
                 ...parsed,
             };
-            // Same duplicate-fire guard as the --run-on flag: a host-placed routine
+            // Same duplicate-fire guard as --placement/--run-on: off-box placement
             // with no eligibility pin would fire from every daemon in the fleet.
-            if (config.host && (!config.devices || config.devices.length === 0)) {
+            const fileStrategy = resolveHostStrategy(config);
+            if (placementRequiresFiringPin(fileStrategy) && (!config.devices || config.devices.length === 0)) {
                 config.devices = [machineId()];
-                console.error(chalk.gray(`host: set with no devices pin: pinned firing to this machine (${config.devices[0]}).`));
+                console.error(chalk.gray(`${fileStrategy} placement with no devices pin: pinned firing to this machine (${config.devices[0]}).`));
             }
             writeJob(config);
             if (options.json) {
@@ -1120,6 +1186,12 @@ export function registerRoutinesCommands(program) {
             process.exit(1);
         }
         if (options.clear) {
+            const strategy = resolveHostStrategy(job);
+            if (placementRequiresFiringPin(strategy)) {
+                console.error(chalk.red(`Cannot clear devices for hostStrategy: ${strategy} — without a pin every fleet daemon would dispatch once.`));
+                console.error(chalk.gray(`Keep a single-machine pin (e.g. --set ${machineId()}) or switch to --placement local.`));
+                process.exit(1);
+            }
             job.devices = undefined;
             writeJob(job);
             console.log(chalk.green(`Devices cleared for '${name}' — runs on all devices`));
@@ -1130,6 +1202,12 @@ export function registerRoutinesCommands(program) {
         if (hasSet) {
             const devices = await parseAndValidateDevices(options.set);
             job.devices = devices;
+            // Re-validate so host/fleet/cloud can't be left with an empty set via --set ""
+            const errs = validateJob(job);
+            if (errs.length > 0) {
+                console.error(chalk.red(errs.join('\n')));
+                process.exit(1);
+            }
             writeJob(job);
             console.log(chalk.green(`Devices for '${name}' set to: ${devices.join(', ')}`));
             if (isDaemonRunning())
@@ -1158,6 +1236,11 @@ export function registerRoutinesCommands(program) {
                 })),
             });
             if (selected.length === 0) {
+                const strategy = resolveHostStrategy(job);
+                if (placementRequiresFiringPin(strategy)) {
+                    console.error(chalk.red(`Cannot clear devices for hostStrategy: ${strategy} — without a pin every fleet daemon would dispatch once.`));
+                    return;
+                }
                 job.devices = undefined;
                 writeJob(job);
                 console.log(chalk.green(`Devices cleared for '${name}' — runs on all devices`));
@@ -1250,6 +1333,183 @@ export function registerRoutinesCommands(program) {
             console.log(chalk.gray('\n  Start the scheduler to begin firing routines: agents routines start'));
         }
     });
+    routinesCmd
+        .command('enable-project [path]')
+        .description('Opt a project\'s .agents/routines/*.yml into daemon firing. Requires explicit approval — project routines never auto-fire from a cloned repo. Materialises copies into ~/.agents/routines/ with source provenance.')
+        .option('--yes', 'Skip the interactive confirmation prompt')
+        .option('--json', 'Emit machine-readable JSON')
+        .action(async (projectPath, options) => {
+        const root = projectPath
+            ? path.resolve(projectPath)
+            : resolveProjectRoot(process.cwd());
+        if (!root) {
+            console.error(chalk.red('No project .agents/ directory found from the current directory.'));
+            console.error(chalk.gray('Run from inside a project, or pass the project path: agents routines enable-project /path/to/repo'));
+            process.exit(1);
+        }
+        const files = listProjectRoutineFiles(root);
+        if (files.length === 0) {
+            console.error(chalk.red(`No routines found under ${path.join(root, '.agents', 'routines')}`));
+            process.exit(1);
+        }
+        if (!options.yes) {
+            if (!isInteractiveTerminal()) {
+                console.error(chalk.red('Refusing to enable project routines non-interactively without --yes.'));
+                console.error(chalk.gray(`Found ${files.length} routine(s) in ${displayProjectPath(root)}. Re-run with --yes to confirm.`));
+                process.exit(1);
+            }
+            try {
+                const { confirm } = await import('@inquirer/prompts');
+                const ok = await confirm({
+                    message: `Enable daemon firing for ${files.length} project routine(s) in ${displayProjectPath(root)}?`,
+                    default: false,
+                });
+                if (!ok) {
+                    console.log(chalk.gray('Cancelled'));
+                    return;
+                }
+            }
+            catch (err) {
+                if (isPromptCancelled(err)) {
+                    console.log(chalk.gray('Cancelled'));
+                    return;
+                }
+                throw err;
+            }
+        }
+        const newly = enableProjectRoutines(root);
+        const sync = syncProjectRoutines(root);
+        if (isDaemonRunning())
+            signalDaemonReload();
+        if (options.json) {
+            writeJson({
+                ok: true,
+                projectRoot: root,
+                newlyEnabled: newly,
+                synced: sync.synced,
+                skipped: sync.skipped,
+                removed: sync.removed,
+                errors: sync.errors,
+            });
+            return;
+        }
+        console.log(chalk.green(newly
+            ? `Enabled project routines for ${displayProjectPath(root)}`
+            : `Project routines already enabled for ${displayProjectPath(root)}`));
+        if (sync.synced.length > 0) {
+            console.log(chalk.gray(`  Synced: ${sync.synced.join(', ')}`));
+        }
+        for (const s of sync.skipped) {
+            console.log(chalk.yellow(`  Skipped ${s.name}: ${s.reason}`));
+        }
+        for (const e of sync.errors) {
+            console.log(chalk.red(`  Error ${e.name}: ${e.error}`));
+        }
+        console.log(chalk.gray('Daemon will fire these after reload. Re-sync later with: agents routines sync'));
+    });
+    routinesCmd
+        .command('disable-project [path]')
+        .description('Remove a project from the project-routines allowlist. Use --remove-synced to also delete the user-layer copies.')
+        .option('--remove-synced', 'Delete user-layer routines that were materialised from this project')
+        .option('--json', 'Emit machine-readable JSON')
+        .action(async (projectPath, options) => {
+        const root = projectPath
+            ? path.resolve(projectPath)
+            : resolveProjectRoot(process.cwd());
+        if (!root) {
+            console.error(chalk.red('No project .agents/ directory found from the current directory.'));
+            process.exit(1);
+        }
+        const result = disableProjectRoutines(root, { removeSynced: options.removeSynced });
+        if (isDaemonRunning())
+            signalDaemonReload();
+        if (options.json) {
+            writeJson({ ok: true, projectRoot: root, ...result });
+            return;
+        }
+        if (!result.removed) {
+            console.log(chalk.gray(`Project ${displayProjectPath(root)} was not on the allowlist`));
+        }
+        else {
+            console.log(chalk.green(`Disabled project routines for ${displayProjectPath(root)}`));
+        }
+        if (result.deletedJobs.length > 0) {
+            console.log(chalk.gray(`  Removed user-layer copies: ${result.deletedJobs.join(', ')}`));
+        }
+    });
+    routinesCmd
+        .command('sync [path]')
+        .description('Refresh user-layer copies of opted-in project routines from their .agents/routines/*.yml sources. With no path, syncs every enabled project. Also runs automatically on daemon reload (SIGHUP).')
+        .option('--json', 'Emit machine-readable JSON')
+        .action(async (projectPath, options) => {
+        if (projectPath) {
+            const root = path.resolve(projectPath);
+            const isEnabled = listEnabledProjectRoots().some((p) => p === root);
+            if (!isEnabled) {
+                console.error(chalk.red(`Project ${displayProjectPath(root)} is not enabled. Run: agents routines enable-project ${root}`));
+                process.exit(1);
+            }
+            const sync = syncProjectRoutines(root);
+            if (isDaemonRunning())
+                signalDaemonReload();
+            if (options.json) {
+                writeJson({ ok: true, ...sync });
+                return;
+            }
+            printSyncResult(sync);
+            return;
+        }
+        const all = syncAllProjectRoutines();
+        if (isDaemonRunning())
+            signalDaemonReload();
+        if (options.json) {
+            writeJson({ ok: true, ...all });
+            return;
+        }
+        if (all.projects.length === 0 && all.missing.length === 0) {
+            console.log(chalk.gray('No project roots on the routines allowlist.'));
+            console.log(chalk.gray('  Enable one with: agents routines enable-project'));
+            return;
+        }
+        for (const p of all.projects)
+            printSyncResult(p);
+        for (const m of all.missing) {
+            console.log(chalk.yellow(`Missing project root (still on allowlist): ${displayProjectPath(m)}`));
+        }
+    });
+    routinesCmd
+        .command('projects')
+        .description('List project roots opted into daemon-fired project routines')
+        .option('--json', 'Emit machine-readable JSON')
+        .action((options) => {
+        const roots = listEnabledProjectRoots();
+        if (options.json) {
+            writeJson(roots.map((r) => ({
+                path: r,
+                display: displayProjectPath(r),
+                routines: listProjectRoutineFiles(r).map((f) => f.name),
+            })));
+            return;
+        }
+        if (roots.length === 0) {
+            console.log(chalk.gray('No projects enabled. Use: agents routines enable-project'));
+            // Offer a discovery hint for the current project.
+            const discovered = discoverProjectRoutinesAt(process.cwd());
+            if (discovered) {
+                console.log(chalk.gray(`  Found ${discovered.files.length} routine(s) in ${displayProjectPath(discovered.projectRoot)} — enable with: agents routines enable-project`));
+            }
+            return;
+        }
+        console.log(chalk.bold('Enabled project routines\n'));
+        for (const r of roots) {
+            const files = listProjectRoutineFiles(r);
+            console.log(`  ${chalk.cyan(displayProjectPath(r))}  ${chalk.gray(`(${files.length} routine${files.length === 1 ? '' : 's'})`)}`);
+            for (const f of files) {
+                console.log(chalk.gray(`    - ${f.name}`));
+            }
+        }
+        console.log();
+    });
     routinesCmd
         .command('scheduler-logs')
         .description('Read scheduler log output (for debugging why a routine did not fire). Use --follow to stream.')