@phnx-labs/agents-cli 1.22.14 → 1.22.16

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;
@@ -116,14 +132,15 @@ export declare function validateProjectDef(raw: unknown, sourceName?: string): P
  */
 export declare function loadProjectDef(name: string): ProjectDef | undefined;
 /**
- * List every defined project, sorted by name. Skips (does not throw on) a
- * malformed file so one bad definition can't break `projects list`; the loader
- * for a single named project stays strict.
+ * List every defined project, sorted by name. A missing projects directory is
+ * the empty state; malformed definitions and filesystem failures stay loud so
+ * CLI callers (including Factory) can show the actual error.
  */
 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;
 }
 /**
@@ -172,15 +187,18 @@ export function loadProjectDef(name) {
     try {
         raw = fs.readFileSync(projectDefPath(name), 'utf8');
     }
-    catch {
-        return undefined; // absent — not a defined project
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return undefined; // absent — not a defined project
+        }
+        throw error;
     }
     return validateProjectDef(yaml.parse(raw), name);
 }
 /**
- * List every defined project, sorted by name. Skips (does not throw on) a
- * malformed file so one bad definition can't break `projects list`; the loader
- * for a single named project stays strict.
+ * List every defined project, sorted by name. A missing projects directory is
+ * the empty state; malformed definitions and filesystem failures stay loud so
+ * CLI callers (including Factory) can show the actual error.
  */
 export function listProjectDefs() {
     let files;
@@ -190,26 +208,24 @@ export function listProjectDefs() {
         // loader and silently drop the project. One extension, one code path.
         files = fs.readdirSync(getProjectsDir()).filter((f) => f.endsWith('.yaml'));
     }
-    catch {
-        return [];
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
     }
     const out = [];
     for (const f of files) {
         const name = f.replace(/\.yaml$/, '');
-        try {
-            const def = loadProjectDef(name);
-            if (def)
-                out.push(def);
-        }
-        catch {
-            /* malformed — skip in the listing */
-        }
+        const def = loadProjectDef(name);
+        if (def)
+            out.push(def);
     }
     return out.sort((a, b) => a.name.localeCompare(b.name));
 }
 /**
  * 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. */
@@ -239,8 +255,10 @@ export function removeProjectDef(name) {
         fs.unlinkSync(projectDefPath(name));
         return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
     }
 }
 /**

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. */