@phnx-labs/agents-cli 1.22.13 → 1.22.15

package/dist/commands/watchdog.js

@@ -10,26 +10,26 @@
  *   agents watchdog --nudge            one tick, actually injects (explicit opt-in)
  *   agents watchdog --watch            manual poll loop (dry unless --nudge)
  *   agents watchdog --json             machine-readable tick output (for the menu-bar)
- *   agents watchdog enable|disable     turn the always-on watchdog routine on/off
+ *   agents watchdog on|off             turn the always-on watchdog routine on/off
  *   agents watchdog policy <id> <p>    per-session policy: off | keep | handsoff
  *
  * The always-on watchdog is a daemon-fired ROUTINE, not a private sentinel + a
- * hand-rolled loop: `enable` creates/enables a `watchdog` command routine
- * (`agents watchdog --nudge` every couple of minutes) and reloads the daemon;
- * `disable` pauses it. See ../lib/watchdog/routine.ts.
+ * hand-rolled loop. Its immutable definition comes from the system DotAgents
+ * repo; on/off only changes this device's routine membership.
  */
 import chalk from 'chalk';
 import * as path from 'path';
 import { setHelpSections } from '../lib/help.js';
 import { parseDuration } from '../lib/hooks/cache.js';
 import { getRuntimeStateDir } from '../lib/state.js';
-import { setJobEnabled } from '../lib/routines.js';
+import { readJob, setJobEnabled } from '../lib/routines.js';
 import { getActiveSessions } from '../lib/session/active.js';
 import { mailboxIdForActiveSession } from '../lib/mailbox-target.js';
 import { gcMailbox } from '../lib/mailbox-gc.js';
-import { ensureWatchdogRoutine, isWatchdogRoutineEnabled, watchdogRoutineExists, WATCHDOG_ROUTINE_NAME, WATCHDOG_ROUTINE_SCHEDULE, } from '../lib/watchdog/routine.js';
+import { devicesWithRoutineEnabled, routineEnabledOnThisDevice } from '../lib/routine-activation.js';
 import { runWatchdogTick, writePolicySentinel, DEFAULT_THRESHOLDS, } from '../lib/watchdog/runner.js';
 import { isWatchdogRotateEnabled, listRotateStates, setWatchdogRotateEnabled } from '../lib/watchdog/rotate.js';
+const WATCHDOG_ROUTINE_NAME = 'watchdog';
 /** Default state dir the runner and these subcommands share. */
 function stateDir() {
     return path.join(getRuntimeStateDir(), 'watchdog');
@@ -120,7 +120,7 @@ export function registerWatchdogCommand(program) {
         .command('watchdog')
         .description('Auto-nudge stalled agent terminals: detect stalls, resolve the exact split, inject "Continue." — no menu-bar needed.')
         .option('--nudge', 'Actually inject (default is a dry run that only reports what it would do)')
-        .option('--watch', 'Manual poll loop: run a tick every --interval (dry unless --nudge; the always-on path is `watchdog enable`)')
+        .option('--watch', 'Manual poll loop: run a tick every --interval (dry unless --nudge; the always-on path is `watchdog on`)')
         .option('--interval <dur>', 'Poll interval in --watch mode (e.g. 30s, 1m)', '30s')
         .option('--stall <dur>', 'Idle time before a session counts as stalled', humanMs(DEFAULT_THRESHOLDS.stallMs))
         .option('--cooldown <dur>', 'Minimum time between nudges to the same session', humanMs(DEFAULT_THRESHOLDS.cooldownMs))
@@ -166,7 +166,7 @@ export function registerWatchdogCommand(program) {
         const intervalMs = durationMsOr(opts.interval, 30_000);
         if (!computeWillInject() && !opts.json) {
             console.log(chalk.yellow(`watchdog --watch is DETECT-ONLY. Pass --nudge to inject, ` +
-                `or run 'agents watchdog enable' for the always-on daemon routine.`));
+                `or run 'agents watchdog on' for the always-on daemon routine.`));
         }
         // eslint-disable-next-line no-constant-condition
         while (true) {
@@ -197,7 +197,7 @@ export function registerWatchdogCommand(program) {
       agents watchdog --json
 
       # Turn on the ALWAYS-ON watchdog (a daemon-fired routine)
-      agents watchdog enable
+      agents watchdog on
 
       # Show the routine, rotate config, and any in-flight in-place rotates
       agents watchdog status
@@ -242,36 +242,45 @@ export function registerWatchdogCommand(program) {
       'watchdog.rotate: off' to ~/.agents/agents.yaml; nudging stays on).
       State machine: ~/.agents/.cache/state/watchdog/rotate/<sessionId>.json.
 
-      Always-on: 'agents watchdog enable' creates + enables a 'watchdog' command
-      routine ('${WATCHDOG_ROUTINE_SCHEDULE}' -> agents watchdog --nudge) and reloads the
-      daemon; 'disable' pauses it. Inspect it with 'agents routines list'. Defaults
+      Always-on: 'agents watchdog on' enables the system-defined 'watchdog' routine
+      on this device and reloads the daemon; 'off' disables it here. Inspect it with
+      'agents routines list'. Defaults
       OFF. Per-session policy: off (ignore), keep (default), handsoff (detect + flag).
 
       State (tray-readable): ${path.join('~/.agents/.cache/state/watchdog', '{nudges,flags,last-tick}.json')}
     `,
     });
     // --- always-on enable/disable/status (backed by the daemon routine) --------
-    cmd.command('enable')
-        .description('Turn ON the always-on watchdog: create/enable the `watchdog` routine and (re)load the daemon.')
-        .action(async () => {
-        ensureWatchdogRoutine(true);
+    const turnOn = async () => {
+        const routine = readJob(WATCHDOG_ROUTINE_NAME);
+        if (!routine)
+            throw new Error("Built-in routine 'watchdog' is missing. Run: agents repo pull system");
+        setJobEnabled(WATCHDOG_ROUTINE_NAME, true);
         await reloadDaemonForRoutine(true);
-        console.log(chalk.green(`watchdog: ENABLED — routine '${WATCHDOG_ROUTINE_NAME}' fires ${WATCHDOG_ROUTINE_SCHEDULE} (agents watchdog --nudge)`));
-    });
-    cmd.command('disable')
-        .description('Turn OFF the always-on watchdog (pause the `watchdog` routine).')
-        .action(async () => {
-        if (!watchdogRoutineExists()) {
-            console.log(chalk.dim('watchdog: already off (no routine)'));
-            return;
-        }
+        console.log(chalk.green(`watchdog: ON on this device (${routine.schedule ?? 'event-triggered'})`));
+    };
+    const turnOff = async () => {
+        if (!readJob(WATCHDOG_ROUTINE_NAME))
+            throw new Error("Built-in routine 'watchdog' is missing. Run: agents repo pull system");
         setJobEnabled(WATCHDOG_ROUTINE_NAME, false);
         await reloadDaemonForRoutine(false);
-        console.log(chalk.yellow('watchdog: DISABLED (routine paused)'));
+        console.log(chalk.yellow('watchdog: OFF on this device'));
+    };
+    cmd.command('on')
+        .description('Enable the built-in watchdog routine on this device.')
+        .action(async () => {
+        await turnOn();
+    });
+    cmd.command('off')
+        .description('Disable the built-in watchdog routine on this device.')
+        .action(async () => {
+        await turnOff();
     });
+    cmd.command('enable', { hidden: true }).action(turnOn);
+    cmd.command('disable', { hidden: true }).action(turnOff);
     cmd.command('rotate <state>')
         .description('Turn in-place rotate of rate-limited sessions on|off (watchdog.rotate in agents.yaml). ' +
-        'Rotate-only: nudging stays on — unlike `watchdog disable`, which pauses the whole watchdog.')
+        'Rotate-only: nudging stays on — unlike `watchdog off`, which disables the whole watchdog on this device.')
         .action((state) => {
         const s = state.toLowerCase();
         if (s !== 'on' && s !== 'off') {
@@ -292,13 +301,15 @@ export function registerWatchdogCommand(program) {
         // parent, not this subcommand. optsWithGlobals() merges both levels, so we
         // read it correctly regardless of which command commander bound it to.
         const json = command.optsWithGlobals().json === true;
-        const on = isWatchdogRoutineEnabled();
+        const on = routineEnabledOnThisDevice(WATCHDOG_ROUTINE_NAME) === true;
+        const enabledDevices = devicesWithRoutineEnabled(WATCHDOG_ROUTINE_NAME);
         const rotate = isWatchdogRotateEnabled() ? 'on' : 'off';
         const rotates = listRotateStates(stateDir());
         const inflight = rotates.filter((r) => r.phase !== 'done' && r.phase !== 'failed');
         if (json) {
             console.log(JSON.stringify({
                 enabled: on,
+                enabledDevices,
                 routine: WATCHDOG_ROUTINE_NAME,
                 stateDir: stateDir(),
                 rotate,
@@ -314,6 +325,7 @@ export function registerWatchdogCommand(program) {
             return;
         }
         console.log(`always-on watchdog: ${on ? chalk.green('ON') : chalk.dim('off')} (routine '${WATCHDOG_ROUTINE_NAME}')`);
+        console.log(`enabled devices: ${enabledDevices.length > 0 ? enabledDevices.join(', ') : chalk.dim('none')}`);
         console.log(`rotate: ${rotate === 'on' ? chalk.green('on') : chalk.yellow('off')} (watchdog.rotate in agents.yaml) · ${inflight.length} in-flight`);
         for (const r of inflight) {
             console.log(`  ${chalk.magenta(r.phase.padEnd(12))} ${chalk.bold(r.sessionId.slice(0, 8))} → ${r.newSessionId.slice(0, 8)}${r.error ? chalk.red(`  ${r.error}`) : ''}`);

package/dist/lib/auto-dispatch.d.ts

@@ -8,12 +8,13 @@
  *
  * 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.
  */
-/** The subset of a managed project this module needs (mirror of the shared JSON). */
+/** The subset of a project definition this module needs. */
 export interface AutoDispatchProject {
     id: string;
     name: string;
@@ -44,13 +45,10 @@ export interface PlannedDispatch {
     delegateName: string;
 }
 /**
- * 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 declare function factoryProjectsPath(): string;
-/** Read the project registry rows this module cares about. */
 export declare function readAutoDispatchProjects(): AutoDispatchProject[];
 /** A project is eligible only when it has explicitly opted in with a positive cap. */
 export declare function isEligible(p: AutoDispatchProject): boolean;

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 };
     }