@phnx-labs/agents-cli 1.22.14 → 1.22.15

package/dist/lib/auto-dispatch.js

@@ -8,53 +8,31 @@
  *
  * The dispatch goes through the same provider layer as `agents cloud run`, so Rush
  * (Prix) is just one provider among rush/codex/factory — NOT a hidden requirement.
- * A project may pin its provider via `provider` in ~/.agents/factory/projects.json.
+ * A project pins its provider via `dispatch.provider` in its
+ * ~/.agents/projects/<name>.yaml definition.
  *
- * OPT-IN: a project auto-dispatches ONLY when `autoDispatch: true` AND `maxAgents > 0`.
- * Nothing global is on by default.
+ * OPT-IN: a project auto-dispatches ONLY when `dispatch.enabled: true` AND
+ * `dispatch.maxAgents > 0` AND it has a `linear.projectId`. Nothing is on by default.
  */
-import * as fs from 'fs';
-import * as path from 'path';
-import { homedir } from 'os';
+import { listProjectDefs } from './projects.js';
 /**
- * Path to the shared factory project registry (written by the factory UI).
- * `AGENTS_FACTORY_PROJECTS_PATH` overrides it, mirroring `AGENTS_PROJECTS_DIR`
- * (`state.ts`) — that seam is what lets `projects import --from-factory` be
- * tested end-to-end against a real fixture file instead of a mock.
+ * Read auto-dispatch candidates from canonical project YAML definitions
+ * (~/.agents/projects/<name>.yaml). Only projects with `dispatch.enabled: true`
+ * are returned; the caller's `isEligible` gate then checks the cap and Linear id.
  */
-export function factoryProjectsPath() {
-    return process.env.AGENTS_FACTORY_PROJECTS_PATH ?? path.join(homedir(), '.agents', 'factory', 'projects.json');
-}
-/** Read the project registry rows this module cares about. */
 export function readAutoDispatchProjects() {
-    let raw;
-    try {
-        raw = JSON.parse(fs.readFileSync(factoryProjectsPath(), 'utf-8'));
-    }
-    catch {
-        return [];
-    }
-    if (!Array.isArray(raw))
-        return [];
-    const out = [];
-    for (const r of raw) {
-        if (!r || typeof r !== 'object')
-            continue;
-        const o = r;
-        if (typeof o.id !== 'string' || typeof o.name !== 'string')
-            continue;
-        out.push({
-            id: o.id,
-            name: o.name,
-            linearProjectId: typeof o.linearProjectId === 'string' ? o.linearProjectId : undefined,
-            repoSlug: typeof o.repoSlug === 'string' ? o.repoSlug : undefined,
-            autoDispatch: o.autoDispatch === true,
-            maxAgents: typeof o.maxAgents === 'number' ? o.maxAgents : undefined,
-            provider: typeof o.provider === 'string' ? o.provider : undefined,
-            host: typeof o.host === 'string' ? o.host : undefined,
-        });
-    }
-    return out;
+    return listProjectDefs()
+        .filter((d) => d.dispatch?.enabled === true)
+        .map((d) => ({
+        id: d.name,
+        name: d.name,
+        linearProjectId: d.linear?.projectId,
+        repoSlug: d.repo ?? d.repos?.[0]?.slug,
+        autoDispatch: d.dispatch?.enabled ?? false,
+        maxAgents: d.dispatch?.maxAgents,
+        provider: d.dispatch?.provider,
+        host: d.dispatch?.host,
+    }));
 }
 /** A project is eligible only when it has explicitly opted in with a positive cap. */
 export function isEligible(p) {

package/dist/lib/migrate.d.ts

@@ -132,7 +132,7 @@ export declare function migrateRoutineDeviceToDevices(routinesDir?: string): voi
  * Both seams are injectable so the migration is unit-testable without touching the
  * real routines dir (and without racing the routine module's own tests).
  */
-export declare function migrateWatchdogSentinelToRoutine(sentinelPath?: string, ensure?: (enabled: boolean) => void): void;
+export declare function migrateWatchdogSentinelToRoutine(sentinelPath?: string, enable?: (name: string, enabled: boolean) => void): void;
 /**
  * Rename cli/ → clis/ in each of the given `.agents/` directories.
  *

package/dist/lib/migrate.js

@@ -13,7 +13,7 @@ import { atomicWriteFileSync } from './fs-atomic.js';
 import { machineId } from './machine-id.js';
 import { AGENTS, agentConfigDirName, findInPath } from './agents.js';
 import { createLink } from './platform/index.js';
-import { ensureWatchdogRoutine } from './watchdog/routine.js';
+import { migrateLegacyRoutineActivation, setJobEnabled } from './routines.js';
 const HOME = process.env.HOME ?? os.homedir();
 const USER_DIR = path.join(HOME, '.agents');
 /** Canonical system-repo location (post-fold). */
@@ -1997,11 +1997,11 @@ export function migrateRoutineDeviceToDevices(routinesDir) {
  * Both seams are injectable so the migration is unit-testable without touching the
  * real routines dir (and without racing the routine module's own tests).
  */
-export function migrateWatchdogSentinelToRoutine(sentinelPath = path.join(CACHE_DIR, 'state', 'watchdog', 'enabled'), ensure = ensureWatchdogRoutine) {
+export function migrateWatchdogSentinelToRoutine(sentinelPath = path.join(CACHE_DIR, 'state', 'watchdog', 'enabled'), enable = setJobEnabled) {
     if (!fs.existsSync(sentinelPath))
         return;
     try {
-        ensure(true);
+        enable('watchdog', true);
     }
     catch (err) {
         console.error(`watchdog sentinel migration: could not create the routine (${err.message}); leaving the sentinel for a later retry`);
@@ -2096,6 +2096,7 @@ export async function runMigration() {
     migrateExtrasExtrasToAgentsExtras();
     // Rewrite routine YAML files: singular `device:` -> plural `devices: []`.
     migrateRoutineDeviceToDevices();
+    migrateLegacyRoutineActivation();
     // Fold the legacy watchdog enable sentinel into the watchdog routine so a user
     // who opted in under the old build stays opted in after upgrading. After the
     // routine rewrites above so the routines dir is in its canonical shape.

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

@@ -1,32 +1,16 @@
 /**
  * Pure builders behind `agents projects import`.
  *
- * Two sources feed the one `ProjectDef` schema: **Linear** (the preferred one —
- * a project someone deliberately created on the board) and the **Factory
- * registry** (`~/.agents/factory/projects.json`, an auto-detection that guesses
- * from checkouts on disk). Both funnel through `writeProjectDef`.
- *
- * The Factory registry stamps each row with a `confidence` — and importing every
- * row regardless is what buried the real projects under a dozen guesses
- * (`agents-cleaned-stale2`, a repo cloned from someone else's org, …). So the
- * import is gated on that field, `high` by default.
+ * Currently supports one source: **Linear** (projects someone deliberately
+ * created on the board). Results funnel through `writeProjectDef`.
  *
  * Everything here is a pure function of its arguments — no fs, no shell, no
- * process env. The command layer reads the registry / shells out to `linear` and
- * hands the rows in; that's what makes these testable against plain fixtures
- * with no mocking. The one exception is `toHomeRelative`, a string rewrite
- * against `$HOME`.
+ * process env. The command layer shells out to `linear` and hands the rows in;
+ * that's what makes these testable against plain fixtures with no mocking.
+ * The one exception is `toHomeRelative`, a string rewrite against `$HOME`.
  */
 import { type ProjectDef } from './projects.js';
 import { type LinearProjectLite } from './linear-projects.js';
-/** Factory's per-row detection confidence, weakest first. */
-export type ImportConfidence = 'low' | 'medium' | 'high';
-/**
- * The floor an import runs at. `any` is what `--all` means — it takes rows that
- * state no confidence at all, which rank below even `low`; without it "import
- * every row regardless of confidence" would quietly drop the unranked ones.
- */
-export type ImportFloor = ImportConfidence | 'any';
 /** A row the import declined to write, with the reason to print. */
 export interface ImportSkip {
     name: string;
@@ -39,42 +23,19 @@ export interface ImportPlan {
 }
 /** The validated shape of the `import` flags. */
 export interface ImportOptions {
-    source: 'factory' | 'linear';
-    /** Factory only: the lowest confidence that still imports. */
-    minConfidence: ImportFloor;
+    source: 'linear';
     force: boolean;
 }
 /** The raw commander flags, before validation. */
 export interface RawImportFlags {
-    fromFactory?: boolean;
     fromLinear?: boolean;
-    minConfidence?: string;
-    all?: boolean;
     force?: boolean;
 }
 /**
  * Validate the flag combination, throwing a user-facing message on the first
- * problem. Every rejection is loud: an unrecognized `--min-confidence` is an
- * error, never a silent fall back to the default floor.
+ * problem.
  */
 export declare function validateImportOpts(flags: RawImportFlags): ImportOptions;
-/**
- * Plan the Factory import: same field mapping as before (`path`→`root`,
- * `repoSlug`→`repo`, `linearProjectId`→`linear.projectId`), now gated on the
- * row's `confidence`. A row with no confidence field is a guess with no stated
- * strength, so it ranks below every floor and only `--all` takes it.
- *
- * `resolveRemote` reads the checkout's actual `origin` and OVERRIDES the row's
- * `repoSlug`. Factory derives that slug from the checkout path's last two
- * segments (`apps/factory/src/core/projectIndex.ts:19-26`), which is only right
- * when the directory tree happens to mirror the GitHub org. It commonly does
- * not: a checkout at `~/src/github.com/<you>/agents-cli` whose remote is
- * `phnx-labs/agents-cli` imported as `<you>/agents-cli` — a real, different
- * repo — so the card's merged-PR and release lines silently reported a
- * stranger's repository instead of failing. The remote is the only authority on
- * which repo a checkout is; the path is a guess about it.
- */
-export declare function buildFactoryImportCandidates(rows: unknown[], existing: Map<string, ProjectDef>, opts: Pick<ImportOptions, 'minConfidence' | 'force'>, resolveRemote?: (root: string) => string | undefined): ImportPlan;
 /**
  * Turn a Linear project name into a definition slug: lowercase, every run of
  * unusable characters collapsed to one `-`, trimmed of leading/trailing

package/dist/lib/project-import.js

@@ -1,123 +1,24 @@
 /**
  * Pure builders behind `agents projects import`.
  *
- * Two sources feed the one `ProjectDef` schema: **Linear** (the preferred one —
- * a project someone deliberately created on the board) and the **Factory
- * registry** (`~/.agents/factory/projects.json`, an auto-detection that guesses
- * from checkouts on disk). Both funnel through `writeProjectDef`.
- *
- * The Factory registry stamps each row with a `confidence` — and importing every
- * row regardless is what buried the real projects under a dozen guesses
- * (`agents-cleaned-stale2`, a repo cloned from someone else's org, …). So the
- * import is gated on that field, `high` by default.
+ * Currently supports one source: **Linear** (projects someone deliberately
+ * created on the board). Results funnel through `writeProjectDef`.
  *
  * Everything here is a pure function of its arguments — no fs, no shell, no
- * process env. The command layer reads the registry / shells out to `linear` and
- * hands the rows in; that's what makes these testable against plain fixtures
- * with no mocking. The one exception is `toHomeRelative`, a string rewrite
- * against `$HOME`.
+ * process env. The command layer shells out to `linear` and hands the rows in;
+ * that's what makes these testable against plain fixtures with no mocking.
+ * The one exception is `toHomeRelative`, a string rewrite against `$HOME`.
  */
-import { toHomeRelative } from './project-root.js';
 import { isSafeProjectName } from './projects.js';
 import { matchLocalCheckoutExact } from './linear-projects.js';
-const CONFIDENCE_RANK = { any: 0, low: 1, medium: 2, high: 3 };
-/** Rank a raw `confidence` value; anything absent or unrecognized ranks 0 (below every floor). */
-function confidenceRank(raw) {
-    return typeof raw === 'string' ? (CONFIDENCE_RANK[raw] ?? 0) : 0;
-}
 /**
  * Validate the flag combination, throwing a user-facing message on the first
- * problem. Every rejection is loud: an unrecognized `--min-confidence` is an
- * error, never a silent fall back to the default floor.
+ * problem.
  */
 export function validateImportOpts(flags) {
-    const sources = [flags.fromFactory && 'factory', flags.fromLinear && 'linear'].filter(Boolean);
-    if (sources.length === 0)
-        throw new Error('Pick an import source: --from-linear or --from-factory.');
-    if (sources.length > 1)
-        throw new Error('--from-linear and --from-factory are mutually exclusive — pick one.');
-    const source = sources[0];
-    if (source === 'linear' && (flags.all || flags.minConfidence !== undefined)) {
-        throw new Error('--all and --min-confidence apply to --from-factory only (Linear rows carry no confidence).');
-    }
-    if (flags.all && flags.minConfidence !== undefined) {
-        throw new Error('--all and --min-confidence are mutually exclusive (--all means --min-confidence low).');
-    }
-    let minConfidence = 'high';
-    if (flags.all)
-        minConfidence = 'any';
-    else if (flags.minConfidence !== undefined) {
-        const v = flags.minConfidence.trim().toLowerCase();
-        if (v !== 'low' && v !== 'medium' && v !== 'high') {
-            throw new Error(`Invalid --min-confidence "${flags.minConfidence}" (expected low, medium, or high).`);
-        }
-        minConfidence = v;
-    }
-    return { source, minConfidence, force: flags.force === true };
-}
-/**
- * Plan the Factory import: same field mapping as before (`path`→`root`,
- * `repoSlug`→`repo`, `linearProjectId`→`linear.projectId`), now gated on the
- * row's `confidence`. A row with no confidence field is a guess with no stated
- * strength, so it ranks below every floor and only `--all` takes it.
- *
- * `resolveRemote` reads the checkout's actual `origin` and OVERRIDES the row's
- * `repoSlug`. Factory derives that slug from the checkout path's last two
- * segments (`apps/factory/src/core/projectIndex.ts:19-26`), which is only right
- * when the directory tree happens to mirror the GitHub org. It commonly does
- * not: a checkout at `~/src/github.com/<you>/agents-cli` whose remote is
- * `phnx-labs/agents-cli` imported as `<you>/agents-cli` — a real, different
- * repo — so the card's merged-PR and release lines silently reported a
- * stranger's repository instead of failing. The remote is the only authority on
- * which repo a checkout is; the path is a guess about it.
- */
-export function buildFactoryImportCandidates(rows, existing, opts, resolveRemote = () => undefined) {
-    const floor = CONFIDENCE_RANK[opts.minConfidence];
-    const defs = [];
-    const skipped = [];
-    // The registry keys rows by `owner/repo` but names them by basename, so two
-    // repos with the same basename in different orgs (grinich/inflow, me/inflow)
-    // arrive as two rows called `inflow`. Without this the second silently
-    // overwrote the first on disk and the run still reported both as imported.
-    const seen = new Set();
-    for (const raw of rows) {
-        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
-            continue;
-        const o = raw;
-        const name = typeof o.name === 'string' ? o.name : undefined;
-        if (!name || !isSafeProjectName(name)) {
-            skipped.push({ name: name || '(unnamed)', reason: 'not a usable project name' });
-            continue;
-        }
-        const rank = confidenceRank(o.confidence);
-        if (rank < floor) {
-            const stated = typeof o.confidence === 'string' && o.confidence ? `confidence "${o.confidence}"` : 'no confidence field';
-            skipped.push({ name, reason: `${stated} is below the "${opts.minConfidence}" floor` });
-            continue;
-        }
-        if (seen.has(name)) {
-            skipped.push({ name, reason: 'another row in this registry already claimed the name' });
-            continue;
-        }
-        if (existing.has(name) && !opts.force) {
-            skipped.push({ name, reason: 'already defined — pass --force to overwrite' });
-            continue;
-        }
-        seen.add(name);
-        const def = { name };
-        if (typeof o.path === 'string')
-            def.root = toHomeRelative(o.path);
-        // The checkout's own remote wins over the registry's path-derived guess;
-        // the guess is the fallback for a path with no git remote to ask.
-        const fromRemote = typeof o.path === 'string' ? resolveRemote(o.path) : undefined;
-        const repo = fromRemote ?? (typeof o.repoSlug === 'string' ? o.repoSlug : undefined);
-        if (repo)
-            def.repo = repo;
-        if (typeof o.linearProjectId === 'string')
-            def.linear = { projectId: o.linearProjectId };
-        defs.push(def);
-    }
-    return { defs, skipped };
+    if (!flags.fromLinear)
+        throw new Error('Pick an import source: --from-linear.');
+    return { source: 'linear', force: flags.force === true };
 }
 /**
  * Turn a Linear project name into a definition slug: lowercase, every run of

package/dist/lib/projects.d.ts

@@ -94,9 +94,25 @@ export interface ProjectDef {
     linear?: {
         projectId?: string;
         url?: string;
+        name?: string;
     };
     /** Free-form doc links surfaced in `projects show`. */
     docs?: string[];
+    /**
+     * Auto-dispatch settings. When `enabled` is true and `maxAgents > 0` and the
+     * project has a `linear.projectId`, the daemon polls Linear for delegated-Todo
+     * tickets and dispatches them up to the concurrency cap.
+     */
+    dispatch?: {
+        /** Opt-in: enable auto-dispatch for this project (default: off). */
+        enabled?: boolean;
+        /** Per-project concurrency cap for auto-dispatched agents. */
+        maxAgents?: number;
+        /** Optional provider pin: 'rush' | 'codex' | 'factory' | 'host' | … */
+        provider?: string;
+        /** For provider='host': which machine to dispatch onto (name/device/cap tag). */
+        host?: string;
+    };
 }
 /** A project name safe to use as a filename: no separators, `..`, or leading dot. */
 export declare function isSafeProjectName(name: string): boolean;
@@ -124,6 +140,7 @@ export declare function listProjectDefs(): ProjectDef[];
 /**
  * Persist a project definition, normalizing `root`/`defaultPath` to home-relative
  * so it stays portable across machines. Creates the projects dir on first write.
+ * Writes via temp+rename so readers never see a partial file.
  */
 export declare function writeProjectDef(def: ProjectDef): string;
 /** Delete a project definition. Returns true if a file was removed. Never touches the repo. */

package/dist/lib/projects.js

@@ -34,6 +34,7 @@ import { getProjectsDir } from './state.js';
 import { safeJoin } from './paths.js';
 import { toHomeRelative, expandLocalHome } from './project-root.js';
 import { resolveProjectKey } from './project-key.js';
+import { atomicWriteFileSync } from './fs-atomic.js';
 /** A project name safe to use as a filename: no separators, `..`, or leading dot. */
 export function isSafeProjectName(name) {
     return (typeof name === 'string' &&
@@ -155,9 +156,23 @@ export function validateProjectDef(raw, sourceName) {
             def.linear.projectId = l.projectId;
         if (typeof l.url === 'string')
             def.linear.url = l.url;
+        if (typeof l.name === 'string')
+            def.linear.name = l.name;
     }
     if (Array.isArray(o.docs))
         def.docs = o.docs.filter((d) => typeof d === 'string');
+    if (o.dispatch && typeof o.dispatch === 'object' && !Array.isArray(o.dispatch)) {
+        const d = o.dispatch;
+        def.dispatch = {};
+        if (d.enabled === true || d.enabled === false)
+            def.dispatch.enabled = d.enabled;
+        if (typeof d.maxAgents === 'number' && Number.isFinite(d.maxAgents))
+            def.dispatch.maxAgents = d.maxAgents;
+        if (typeof d.provider === 'string')
+            def.dispatch.provider = d.provider;
+        if (typeof d.host === 'string')
+            def.dispatch.host = d.host;
+    }
     return def;
 }
 /**
@@ -210,6 +225,7 @@ export function listProjectDefs() {
 /**
  * Persist a project definition, normalizing `root`/`defaultPath` to home-relative
  * so it stays portable across machines. Creates the projects dir on first write.
+ * Writes via temp+rename so readers never see a partial file.
  */
 export function writeProjectDef(def) {
     const validated = validateProjectDef(def, def.name);
@@ -230,7 +246,7 @@ export function writeProjectDef(def) {
     const clean = Object.fromEntries(Object.entries(normalized).filter(([, v]) => v !== undefined));
     const target = projectDefPath(def.name);
     fs.mkdirSync(getProjectsDir(), { recursive: true });
-    fs.writeFileSync(target, yaml.stringify(clean), 'utf8');
+    atomicWriteFileSync(target, yaml.stringify(clean), 'utf8');
     return target;
 }
 /** Delete a project definition. Returns true if a file was removed. Never touches the repo. */

package/dist/lib/registry.d.ts

@@ -85,7 +85,7 @@ export declare function search(query: string, options?: {
 }): Promise<RegistrySearchResult[]>;
 /** Parse a package identifier into its type (mcp, skill, git) and name. */
 export declare function parsePackageIdentifier(identifier: string): {
-    type: RegistryType | 'git' | 'unknown';
+    type: RegistryType | 'git' | 'plugin' | 'unknown';
     name: string;
 };
 /** Resolve a package identifier to an installable package with source metadata. */

package/dist/lib/registry.js

@@ -387,6 +387,11 @@ export function parsePackageIdentifier(identifier) {
     if (identifier.startsWith('skill:')) {
         return { type: 'skill', name: identifier.slice(6) };
     }
+    // plugin:name@source | plugin:/path | plugin:gh:user/repo — Phase 5 packaging
+    // umbrella. Spec after the prefix is the same grammar as `agents plugins install`.
+    if (identifier.startsWith('plugin:')) {
+        return { type: 'plugin', name: identifier.slice('plugin:'.length) };
+    }
     // gh:user/repo -> git source
     if (identifier.startsWith('gh:')) {
         return { type: 'git', name: identifier };
@@ -412,6 +417,12 @@ export function parsePackageIdentifier(identifier) {
 /** Resolve a package identifier to an installable package with source metadata. */
 export async function resolvePackage(identifier) {
     const parsed = parsePackageIdentifier(identifier);
+    if (parsed.type === 'plugin') {
+        const spec = parsed.name.trim();
+        if (!spec)
+            return null;
+        return { type: 'plugin', source: spec, pluginSpec: spec };
+    }
     if (parsed.type === 'git') {
         return { type: 'git', source: parsed.name };
     }

package/dist/lib/routine-activation.d.ts

@@ -0,0 +1,14 @@
+export declare function normalizeRoutineNames(names: Iterable<string>): string[];
+/** null means this device has not materialized activation state yet. */
+export declare function enabledRoutineNames(): string[] | null;
+export declare function routineEnabledOnThisDevice(name: string): boolean | null;
+export declare function replaceEnabledRoutines(names: Iterable<string>): string[];
+/**
+ * Add or remove one routine on this machine. `legacyEnabledNames` seeds the
+ * manifest the first time an upgraded host changes activation, preserving every
+ * other routine that was effectively enabled under the old definition fields.
+ */
+export declare function setRoutineEnabledOnThisDevice(name: string, enabled: boolean, legacyEnabledNames?: Iterable<string>): string[];
+/** Read-only fleet view from synced device documents. Never writes a peer file. */
+export declare function devicesWithRoutineEnabled(name: string): string[];
+export declare function currentRoutineDevice(): string;

package/dist/lib/routine-activation.js

@@ -0,0 +1,78 @@
+/** Device-scoped routine activation.
+ *
+ * Definitions say what a routine does. This module owns the independent answer
+ * to whether THIS device runs it: membership in the top-level `routines:` list
+ * of `~/.agents/devices/<machine>/agents.yaml`.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { machineId } from './machine-id.js';
+import { getUserAgentsDir, readMeta, updateMeta } from './state.js';
+export function normalizeRoutineNames(names) {
+    return [...new Set([...names].map((name) => name.trim()).filter(Boolean))].sort();
+}
+/** null means this device has not materialized activation state yet. */
+export function enabledRoutineNames() {
+    const names = readMeta().deviceRoutines;
+    return Array.isArray(names) ? normalizeRoutineNames(names) : null;
+}
+export function routineEnabledOnThisDevice(name) {
+    const names = enabledRoutineNames();
+    return names === null ? null : names.includes(name);
+}
+export function replaceEnabledRoutines(names) {
+    const normalized = normalizeRoutineNames(names);
+    updateMeta((meta) => ({ ...meta, deviceRoutines: normalized }));
+    return normalized;
+}
+/**
+ * Add or remove one routine on this machine. `legacyEnabledNames` seeds the
+ * manifest the first time an upgraded host changes activation, preserving every
+ * other routine that was effectively enabled under the old definition fields.
+ */
+export function setRoutineEnabledOnThisDevice(name, enabled, legacyEnabledNames = []) {
+    const current = enabledRoutineNames() ?? normalizeRoutineNames(legacyEnabledNames);
+    const next = new Set(current);
+    if (enabled)
+        next.add(name);
+    else
+        next.delete(name);
+    return replaceEnabledRoutines(next);
+}
+/** Read-only fleet view from synced device documents. Never writes a peer file. */
+export function devicesWithRoutineEnabled(name) {
+    const devicesDir = path.join(getUserAgentsDir(), 'devices');
+    if (!fs.existsSync(devicesDir))
+        return [];
+    const devices = [];
+    for (const entry of fs.readdirSync(devicesDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const file = path.join(devicesDir, entry.name, 'agents.yaml');
+        if (!fs.existsSync(file))
+            continue;
+        let parsed;
+        try {
+            parsed = yaml.parse(fs.readFileSync(file, 'utf-8'));
+        }
+        catch (err) {
+            throw new Error(`Device config corrupted at ${file}: ${err.message}`);
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error(`Device config corrupted at ${file}: expected a YAML map.`);
+        }
+        const routines = parsed.routines;
+        if (routines === undefined)
+            continue;
+        if (!Array.isArray(routines) || routines.some((routine) => typeof routine !== 'string')) {
+            throw new Error(`Device config corrupted at ${file}: routines must be a string list.`);
+        }
+        if (routines.includes(name))
+            devices.push(entry.name);
+    }
+    return devices.sort();
+}
+export function currentRoutineDevice() {
+    return machineId();
+}

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

@@ -67,7 +67,7 @@ export interface SyncProjectResult {
  * - Overwrites user copies that already carry matching `source.projectPath`
  * - Never clobbers a hand-authored user routine (no source / different source)
  * - Removes user copies from this project whose YAML disappeared
- * - Auto-pins `devices` for host/fleet/cloud placement when unset
+ * - Activates materialized routines on this device without mutating definitions
  */
 export declare function syncProjectRoutines(projectRoot: string): SyncProjectResult;
 export interface SyncAllResult {

package/dist/lib/routines-project.js

@@ -14,9 +14,8 @@ import * as path from 'path';
 import * as yaml from 'yaml';
 import { execFileSync } from 'child_process';
 import { getProjectAgentsDir, getProjectRoutinesDir, readMeta, updateMeta, ensureAgentsDir, } from './state.js';
-import { readJob, writeJob, deleteJob, listJobs, validateJob, resolveHostStrategy, placementRequiresFiringPin, } from './routines.js';
+import { readJob, writeJob, setJobEnabled, deleteJob, listJobs, validateJob, } from './routines.js';
 import { parseOwnerRepoFromRemote } from './registry.js';
-import { machineId } from './machine-id.js';
 import { isSafeSegmentName } from './paths.js';
 /** Expand `~/…` and resolve to an absolute path. */
 export function expandProjectPath(p) {
@@ -221,7 +220,7 @@ function readProjectJobFile(filePath) {
  * - Overwrites user copies that already carry matching `source.projectPath`
  * - Never clobbers a hand-authored user routine (no source / different source)
  * - Removes user copies from this project whose YAML disappeared
- * - Auto-pins `devices` for host/fleet/cloud placement when unset
+ * - Activates materialized routines on this device without mutating definitions
  */
 export function syncProjectRoutines(projectRoot) {
     ensureAgentsDir();
@@ -276,12 +275,6 @@ export function syncProjectRoutines(projectRoot) {
             if (existing.createdAt)
                 job.createdAt = existing.createdAt;
         }
-        // Placement that leaves the firing machine must pin devices to avoid
-        // every fleet daemon dispatching once.
-        const strategy = resolveHostStrategy(job);
-        if (placementRequiresFiringPin(strategy) && (!job.devices || job.devices.length === 0)) {
-            job.devices = [machineId()];
-        }
         // Surface repo for list/display when project has a GitHub origin.
         if (git.repo && !job.repo)
             job.repo = git.repo;
@@ -294,6 +287,7 @@ export function syncProjectRoutines(projectRoot) {
         }
         try {
             writeJob(job);
+            setJobEnabled(job.name, job.enabled);
             result.synced.push(file.name);
         }
         catch (err) {

package/dist/lib/routines.d.ts

@@ -294,7 +294,7 @@ export declare function finalizeRunMeta(meta: RunMeta, status: RunMeta['status']
  * `yosemite-s0` all agree. Every fire path (cron scheduler, webhook,
  * catchup/overdue, manual run) gates on this.
  */
-export declare function jobRunsOnThisDevice(config: Pick<JobConfig, 'devices'>): boolean;
+export declare function jobRunsOnThisDevice(config: Pick<JobConfig, 'name' | 'devices'>): boolean;
 /**
  * The ONE device that owns a routine — the single daemon allowed to fire it.
  *
@@ -423,6 +423,8 @@ export declare function serializeJob(output: Record<string, unknown>, existingTe
 export declare function deleteJob(name: string): boolean;
 /** Enable or disable a job by name. */
 export declare function setJobEnabled(name: string, enabled: boolean): void;
+/** Materialize legacy definition state into this device's activation manifest. */
+export declare function migrateLegacyRoutineActivation(): boolean;
 /** Validate a partial job config, returning a list of human-readable errors. */
 export declare function validateJob(config: Partial<JobConfig>): string[];
 /** Validate a job trigger block, returning a list of human-readable errors. */