@phnx-labs/agents-cli 1.20.93 → 1.21.1

package/dist/commands/message.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { spawn } from 'child_process';
 import { die } from '../lib/format.js';
+import { parseDuration } from '../lib/hooks/cache.js';
 import { getActiveSessions } from '../lib/session/active.js';
 import { getTaskById, updateTaskStatus } from '../lib/cloud/store.js';
 import { resolveProvider } from '../lib/cloud/registry.js';
@@ -53,6 +54,7 @@ async function deliverViaMailbox(mailboxId, text, block, opts) {
         text,
         from: opts.from,
         blockId: block?.blockId,
+        ttlSeconds: opts.ttlSeconds,
     });
     if (block) {
         recordMessageReceipt(block.blockId, {
@@ -116,10 +118,19 @@ export function registerMessageCommand(program) {
         .option('--from <who>', 'Label recorded as the sender of this message')
         .option('--as <operator>', 'Verified operator id answering a high-consequence block')
         .option('--surface <surface>', 'Surface that is sending this answer (feed, terminal, etc.)', 'cli')
+        .option('--ttl <dur>', 'Delivery TTL if the message is not consumed (e.g. 30m, 1h, 24h); 0 disables expiry')
         .action(async (target, text, opts) => {
         if (!target.trim()) {
             die('Target must be a session/agent id or cloud task id. Run `agents sessions --active` to list running agents.');
         }
+        let ttlSeconds;
+        if (opts.ttl !== undefined) {
+            const parsed = parseDuration(opts.ttl);
+            if (parsed == null) {
+                die(`Invalid --ttl ${JSON.stringify(opts.ttl)}: expected a duration like 30m, 1h, 24h, or 0.`);
+            }
+            ttlSeconds = parsed;
+        }
         const sessions = await getActiveSessions();
         const res = resolveMessageTarget(target, sessions, (id) => getTaskById(id) != null);
         switch (res.kind) {
@@ -152,7 +163,7 @@ export function registerMessageCommand(program) {
                     // First-answer-wins for any path that closes an open block.
                     claimBlockAnswer(block, opts);
                     if (route.kind === 'mailbox') {
-                        await deliverViaMailbox(res.id, text, block, opts);
+                        await deliverViaMailbox(res.id, text, block, { from: opts.from, ttlSeconds });
                         return;
                     }
                     if (route.kind === 'tmux' || route.kind === 'iterm' || route.kind === 'pty') {

package/dist/commands/monitors.js

@@ -57,7 +57,7 @@ function actionLabel(action) {
         case 'routine':
             return `routine ${action.routine ?? ''}`;
         case 'notify':
-            return `notify ${action.notifyChannel ?? 'telegram'}`;
+            return `notify ${action.notifyChannel ?? 'owner'}`;
         case 'webhook-out':
             return `webhook-out ${action.url ?? ''}`;
         default:
@@ -195,9 +195,11 @@ function buildAction(options) {
     if (options.routine)
         chosen.push({ type: 'routine', routine: options.routine });
     if (options.notify !== undefined) {
-        // --notify may be a bare flag (true) or carry a channel string.
-        const channel = typeof options.notify === 'string' ? options.notify : 'telegram';
-        chosen.push({ type: 'notify', notifyChannel: channel });
+        // --notify may be a bare flag (notify the owner) or carry a channel that
+        // overrides notify.owner.channel. Left unset, the send resolves the owner
+        // channel + target from notify.owner in agents.yaml (one source of truth).
+        const channel = typeof options.notify === 'string' ? options.notify : undefined;
+        chosen.push({ type: 'notify', ...(channel ? { notifyChannel: channel } : {}) });
     }
     if (options.webhookOut)
         chosen.push({ type: 'webhook-out', url: options.webhookOut });
@@ -310,7 +312,7 @@ export function registerMonitorsCommands(program) {
         .option('--effort <effort>', 'Reasoning effort for --run: low | medium | high | xhigh | max | auto')
         .option('--action-timeout <t>', 'Kill the --run action if it runs longer than this (e.g. 10m)')
         .option('--routine <name>', 'Fire an existing routine on change')
-        .option('--notify [channel]', 'Send a notification (default channel: telegram)')
+        .option('--notify [channel]', 'Notify the owner (notify.owner); [channel] overrides the owner channel')
         .option('--webhook-out <url>', 'POST the event to this URL')
         // PLACEMENT / hygiene
         .option('--device <name>', 'OWNER device — the single machine that evaluates + fires (exactly-once)')
@@ -573,7 +575,7 @@ export function registerMonitorsCommands(program) {
                 name,
                 source: { type: 'poll', command: 'echo hello', interval: '1m' },
                 condition: { mode: 'on-change' },
-                action: { type: 'notify', notifyChannel: 'telegram' },
+                action: { type: 'notify' },
             });
             fs.writeFileSync(monitorPath, template, 'utf-8');
             console.log(chalk.gray(`Created new monitor file: ${monitorPath}`));

package/dist/commands/packages.js

@@ -14,7 +14,7 @@ import { AGENTS, getAllCliStates, agentLabel, } from '../lib/agents.js';
 import { capableAgents } from '../lib/capabilities.js';
 import { DEFAULT_REGISTRIES } from '../lib/types.js';
 import { getRegistries, setRegistry, removeRegistry, search as searchRegistries, resolvePackage, validatedNpmSpec, validatedPyPISpec, buildSkillIndex, verifySkillIntegrity, parseOwnerRepoFromRemote, } from '../lib/registry.js';
-import { cloneRepo, commitAndPush, getRemoteUrl, isGitRepo } from '../lib/git.js';
+import { cloneRepo, commitAndPush, getCurrentBranch, getRemoteUrl, isGitRepo } from '../lib/git.js';
 import { discoverCommands, resolveCommandSource, installCommand, installCommandCentrally, } from '../lib/commands.js';
 import { discoverSkillsFromRepo, installSkill, installSkillCentrally, } from '../lib/skills.js';
 import { discoverHooksFromRepo, installHooks, installHooksCentrally, } from '../lib/hooks.js';
@@ -335,7 +335,7 @@ When to use:
         .description('Generate a skills-index.json for a git repo and push it, making its skills discoverable via agents search/install')
         .option('--repo <alias>', 'Publish an extra repo added via `agents repo add` (default: your ~/.agents repo)')
         .option('--name <name>', 'Registry name to suggest in the output (default: the repo name)')
-        .option('--branch <branch>', 'Branch the raw URL should reference', 'main')
+        .option('--branch <branch>', 'Branch to push the index to and reference in the raw URL (default: the repo\'s current branch)')
         .option('--dry-run', 'Write the index and print the URL without committing or pushing')
         .addHelpText('after', `
 Publish walks a repo's skills/ directory, records a sha256 of every SKILL.md,
@@ -398,20 +398,29 @@ the sha256 in the index and abort on mismatch.
         for (const s of index.skills) {
             console.log(`  ${chalk.cyan(s.name)} ${chalk.gray(`sha256:${s.sha256?.slice(0, 12)}…`)}`);
         }
+        // The branch the URL references must be the branch the index actually
+        // lands on. In a real push that's whatever commitAndPush reports back
+        // (the requested --branch, else the checked-out branch); in a dry run we
+        // resolve it the same way without pushing.
+        let urlBranch;
         if (options.dryRun) {
+            urlBranch = options.branch || (await getCurrentBranch(repoDir));
             console.log(chalk.gray(`\nDry run — wrote ${indexPath} but did not commit or push.`));
         }
         else {
             const pushSpinner = ora('Committing and pushing skills-index.json...').start();
-            const result = await commitAndPush(repoDir, 'chore: update skills-index.json (agents publish)');
+            const result = await commitAndPush(repoDir, 'chore: update skills-index.json (agents publish)', options.branch);
             if (!result.success) {
                 pushSpinner.fail(`Push failed: ${result.error}`);
                 console.log(chalk.gray('The index was written locally — commit and push it manually to publish.'));
                 process.exit(1);
             }
-            pushSpinner.succeed('Pushed skills-index.json');
+            // commitAndPush always reports the pushed branch on success; the `??`
+            // only satisfies the optional return type, it is not a behavior path.
+            urlBranch = result.branch ?? (await getCurrentBranch(repoDir));
+            pushSpinner.succeed(`Pushed skills-index.json to ${urlBranch}`);
         }
-        const rawUrl = `https://raw.githubusercontent.com/${repoSlug}/${options.branch}/skills-index.json`;
+        const rawUrl = `https://raw.githubusercontent.com/${repoSlug}/${urlBranch}/skills-index.json`;
         const registryName = options.name || repoSlug.split('/')[1] || 'my-skills';
         console.log(chalk.bold('\nPublished. Share these with anyone who wants your skills:\n'));
         console.log(chalk.gray('  Index URL:'));

package/dist/commands/projects.d.ts

@@ -9,6 +9,7 @@
  * lifecycle state, plan completion, open PRs, and tickets in flight.
  */
 import type { Command } from 'commander';
+import { type LinearMilestone } from '../lib/linear-project-counts.js';
 /** Recursion guard: a peer answering a probe fan-out never re-fans-out itself. */
 export declare const PROJECTS_NO_FANOUT_ENV = "AGENTS_PROJECTS_LOCAL";
 /**
@@ -19,4 +20,31 @@ export declare const PROJECTS_NO_FANOUT_ENV = "AGENTS_PROJECTS_LOCAL";
  * string when everything answered.
  */
 export declare function formatFleetSkippedNote(skipped: string[]): string;
+/** One `projects list` row, pre-render. */
+export interface ProjectListRow {
+    name: string;
+    path: string;
+    repo: string;
+}
+/**
+ * Column widths for `projects list`, sized to the rows actually being printed.
+ * Fixed padding was the bug: home-relative roots run past 50 characters, so a
+ * hardcoded 32 pushed the repo column off its gridline on every long path.
+ * Paths longer than {@link LIST_PATH_MAX} truncate rather than widen the table.
+ */
+export declare function computeProjectListWidths(rows: ProjectListRow[]): {
+    name: number;
+    path: number;
+    repo: number;
+};
+/**
+ * A milestone's target date as a person would say it — "due tomorrow",
+ * "overdue by 3 days", "due Aug 21" — never a raw `2026-08-21` or a duration in
+ * hours. Linear stores a calendar date with no timezone, so both sides are
+ * compared at LOCAL midnight; parsing `YYYY-MM-DD` with `new Date(str)` would
+ * read it as UTC and shift the answer by a day for anyone west of Greenwich.
+ */
+export declare function formatMilestoneDue(targetDate: string, nowMs: number): string | undefined;
+/** The `next` card line: what this project is due to hit, and how far along it is. */
+export declare function formatNextMilestone(ms: LinearMilestone, nowMs: number): string;
 export declare function registerProjectsCommands(program: Command): void;

package/dist/commands/projects.js

@@ -10,12 +10,14 @@
  */
 import chalk from 'chalk';
 import * as fs from 'fs';
+import * as path from 'path';
 import { execFileSync, spawnSync } from 'child_process';
 import { betaEnableHint, isBetaEnabled } from '../lib/beta.js';
 import { setHelpSections } from '../lib/help.js';
 import { getMainRepoRoot } from '../lib/git.js';
 import { parseOwnerRepoFromRemote } from '../lib/registry.js';
-import { toHomeRelative } from '../lib/project-root.js';
+import { truncate } from '../lib/format.js';
+import { expandLocalHome, getProjectRoot, toHomeRelative } from '../lib/project-root.js';
 import { machineId } from '../lib/machine-id.js';
 import { getActiveSessions } from '../lib/session/active.js';
 import { gatherRemoteActive } from '../lib/session/remote-active.js';
@@ -26,6 +28,7 @@ import { listProjectDefs, loadProjectDef, writeProjectDef, removeProjectDef, pro
 import { rollupSessionsByProject, planPct, enrichProjectSignals, formatProjectMembers, } from '../lib/project-status.js';
 import { fetchLinearProjectCounts } from '../lib/linear-project-counts.js';
 import { listLinearProjects, pickLinearProject } from '../lib/linear-projects.js';
+import { buildFactoryImportCandidates, buildLinearImportCandidates, validateImportOpts, } from '../lib/project-import.js';
 /** Recursion guard: a peer answering a probe fan-out never re-fans-out itself. */
 export const PROJECTS_NO_FANOUT_ENV = 'AGENTS_PROJECTS_LOCAL';
 /** Max peers named in the skipped note before the rest collapse to `+N`. */
@@ -63,6 +66,135 @@ function originSlug(cwd) {
         return undefined;
     }
 }
+/**
+ * Read the Factory registry off disk and plan its import. Every read failure is
+ * fatal and named — an unreadable or malformed registry must not read as "0
+ * projects to import".
+ */
+function runFactoryImport(existing, opts) {
+    const src = factoryProjectsPath();
+    let rawText;
+    try {
+        rawText = fs.readFileSync(src, 'utf8');
+    }
+    catch {
+        console.error(chalk.red(`No Factory registry at ${src}`));
+        process.exit(1);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawText);
+    }
+    catch {
+        console.error(chalk.red(`Factory registry at ${src} is not valid JSON`));
+        process.exit(1);
+    }
+    const rows = Array.isArray(parsed)
+        ? parsed
+        : Array.isArray(parsed?.projects)
+            ? parsed.projects
+            : [];
+    return buildFactoryImportCandidates(rows, existing, opts);
+}
+/**
+ * List the workspace's Linear projects and plan their import, binding each to a
+ * local checkout under the configured projects root when the names match
+ * exactly. A missing / logged-out `linear` CLI is loud (this is an explicit user
+ * command), and nothing is written before the whole plan is built.
+ */
+function runLinearImport(existing, opts) {
+    let list;
+    try {
+        list = listLinearProjects();
+    }
+    catch (e) {
+        console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+        process.exit(1);
+    }
+    // No projects root configured (or unreadable) → no local matching; every def
+    // still imports, carrying its Linear link and nothing it can't prove.
+    const rootAbs = getProjectRoot() ? expandLocalHome(getProjectRoot()) : undefined;
+    let localDirs = [];
+    if (rootAbs) {
+        try {
+            localDirs = fs
+                .readdirSync(rootAbs, { withFileTypes: true })
+                .filter((d) => d.isDirectory() && !d.name.startsWith('.'))
+                .map((d) => d.name);
+        }
+        catch {
+            localDirs = [];
+        }
+    }
+    return buildLinearImportCandidates(list, existing, {
+        localDirs,
+        resolveRoot: (dir) => (rootAbs ? toHomeRelative(path.join(rootAbs, dir)) : undefined),
+        resolveOrigin: (dir) => (rootAbs ? originSlug(path.join(rootAbs, dir)) : undefined),
+    }, opts);
+}
+/** Longest path a `list` row shows before it truncates. */
+const LIST_PATH_MAX = 48;
+/**
+ * Column widths for `projects list`, sized to the rows actually being printed.
+ * Fixed padding was the bug: home-relative roots run past 50 characters, so a
+ * hardcoded 32 pushed the repo column off its gridline on every long path.
+ * Paths longer than {@link LIST_PATH_MAX} truncate rather than widen the table.
+ */
+export function computeProjectListWidths(rows) {
+    const widest = (pick, cap) => Math.min(cap, rows.reduce((w, r) => Math.max(w, pick(r).length), 0));
+    return {
+        name: widest((r) => r.name, 64),
+        path: widest((r) => r.path, LIST_PATH_MAX),
+        repo: widest((r) => r.repo, 64),
+    };
+}
+/**
+ * A milestone's target date as a person would say it — "due tomorrow",
+ * "overdue by 3 days", "due Aug 21" — never a raw `2026-08-21` or a duration in
+ * hours. Linear stores a calendar date with no timezone, so both sides are
+ * compared at LOCAL midnight; parsing `YYYY-MM-DD` with `new Date(str)` would
+ * read it as UTC and shift the answer by a day for anyone west of Greenwich.
+ */
+export function formatMilestoneDue(targetDate, nowMs) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(targetDate.trim());
+    if (!m)
+        return undefined;
+    const due = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+    if (Number.isNaN(due.getTime()))
+        return undefined;
+    const now = new Date(nowMs);
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const days = Math.round((due.getTime() - today.getTime()) / 86_400_000);
+    if (days === 0)
+        return 'due today';
+    if (days === 1)
+        return 'due tomorrow';
+    if (days === -1)
+        return 'overdue by a day';
+    if (days < 0)
+        return `overdue by ${-days} days`;
+    if (days <= 14)
+        return `due in ${days} days`;
+    const sameYear = due.getFullYear() === today.getFullYear();
+    const label = due.toLocaleDateString('en-US', {
+        month: 'short',
+        day: 'numeric',
+        ...(sameYear ? {} : { year: 'numeric' }),
+    });
+    return `due ${label}`;
+}
+/** The `next` card line: what this project is due to hit, and how far along it is. */
+export function formatNextMilestone(ms, nowMs) {
+    const parts = [chalk.bold(ms.name)];
+    // A milestone with nothing filed under it yet has no progress to report —
+    // `0/0` is noise, not information.
+    if (ms.total > 0)
+        parts.push(`${ms.done}/${ms.total}`);
+    const due = ms.targetDate ? formatMilestoneDue(ms.targetDate, nowMs) : undefined;
+    if (due)
+        parts.push(due.startsWith('overdue') ? chalk.yellow(due) : chalk.dim(due));
+    return parts.join(chalk.dim('  ·  '));
+}
 function statusBar(r) {
     const parts = [];
     const push = (n, label, color) => {
@@ -80,7 +212,7 @@ function statusBar(r) {
         parts.push(chalk.gray(`+${r.agents - shown} other`));
     return parts.join(' · ') || chalk.gray('no live agents');
 }
-function renderCard(def, r, remote, fleet, linear) {
+function renderCard(def, r, remote, fleet, linear, nowMs = Date.now()) {
     const agents = r?.agents ?? 0;
     const pct = r ? planPct(r.plan) : undefined;
     const planStr = pct === undefined ? '' : `  ·  ${chalk.cyan(`${pct}% plan`)}`;
@@ -104,6 +236,9 @@ function renderCard(def, r, remote, fleet, linear) {
     if (linear) {
         console.log(`  ${chalk.dim('linear')}   ${linear.done}/${linear.total}${linear.truncated ? '+' : ''} done · ${linear.inProgress} in progress`);
     }
+    if (linear?.nextMilestone) {
+        console.log(`  ${chalk.dim('next')}     ${formatNextMilestone(linear.nextMilestone, nowMs)}`);
+    }
     if (r && r.tickets.length) {
         console.log(`  ${chalk.dim('tickets')}  ${r.tickets.slice(0, 8).join(' · ')}${r.tickets.length > 8 ? ' …' : ''}`);
     }
@@ -138,6 +273,7 @@ export function registerProjectsCommands(program) {
         .description('Named multi-repo projects with a progress rollup.');
     setHelpSections(projects, {
         examples: `
+      agents projects import --from-linear  # the projects you actually track
       agents projects add rush --repo phnx-labs/rush --path apps/web
       agents projects list
       agents projects status              # progress card for every project
@@ -149,6 +285,11 @@ export function registerProjectsCommands(program) {
         notes: `
       Definitions are hand-editable YAML in ~/.agents/projects/ and sync across
       machines with 'agents push/pull'. Enable with: agents beta enable projects.
+
+      'import --from-factory' reads Factory's auto-detected registry, which
+      guesses from checkouts on disk — it imports only 'high' confidence rows by
+      default. Widen with --min-confidence medium or --all, and drop a bad guess
+      with 'agents projects rm <name>'.
     `,
     });
     projects.hook('preAction', (_thisCommand, actionCommand) => {
@@ -180,10 +321,16 @@ export function registerProjectsCommands(program) {
             return;
         }
         const roll = rollupSessionsByProject(defs, await getActiveSessions());
-        for (const d of defs) {
+        const rows = defs.map((d) => ({
+            name: d.name,
+            path: truncate(d.root ?? d.defaultPath ?? '', LIST_PATH_MAX),
+            repo: d.repo ?? d.repos?.[0]?.slug ?? '',
+        }));
+        const w = computeProjectListWidths(rows);
+        for (const [i, d] of defs.entries()) {
             const agents = roll.get(d.name)?.agents ?? 0;
-            const repo = d.repo ?? d.repos?.[0]?.slug ?? '';
-            console.log(`  ${chalk.bold(d.name.padEnd(16))} ${chalk.dim((d.root ?? d.defaultPath ?? '').padEnd(32))} ${chalk.cyan(repo.padEnd(24))} ${agents} agents`);
+            const row = rows[i];
+            console.log(`  ${chalk.bold(row.name.padEnd(w.name))} ${chalk.dim(row.path.padEnd(w.path))} ${chalk.cyan(row.repo.padEnd(w.repo))} ${agents} agents`);
         }
     });
     // ---- add ----
@@ -384,7 +531,7 @@ export function registerProjectsCommands(program) {
             return;
         }
         for (const d of defs) {
-            renderCard(d, roll.get(d.name), remote.get(d.name), opts.fleet ? fleetFor(d) : undefined, linear.get(d.name));
+            renderCard(d, roll.get(d.name), remote.get(d.name), opts.fleet ? fleetFor(d) : undefined, linear.get(d.name), nowMs);
         }
         if (fleetSkipped.length > 0)
             process.stdout.write(formatFleetSkippedNote(fleetSkipped));
@@ -402,54 +549,33 @@ export function registerProjectsCommands(program) {
     // ---- import ----
     projects
         .command('import')
-        .description('Absorb the Factory project registry (~/.agents/factory/projects.json) into YAML definitions.')
-        .requiredOption('--from-factory', 'Import from the Factory projects.json registry')
+        .description('Import project definitions from Linear (preferred) or the Factory auto-detection registry.')
+        .option('--from-linear', 'Import the workspace\'s Linear projects (via the `linear` CLI)')
+        .option('--from-factory', 'Import the Factory registry (~/.agents/factory/projects.json)')
+        .option('--min-confidence <level>', '--from-factory only: lowest detection confidence to import — low|medium|high (default: high)')
+        .option('--all', '--from-factory only: import every row regardless of confidence')
         .option('--force', 'Overwrite existing definitions')
-        .action((opts) => {
-        const src = factoryProjectsPath();
-        let rawText;
-        try {
-            rawText = fs.readFileSync(src, 'utf8');
-        }
-        catch {
-            console.error(chalk.red(`No Factory registry at ${src}`));
-            process.exit(1);
-        }
-        let rows;
+        .action((raw) => {
+        let opts;
         try {
-            rows = JSON.parse(rawText);
+            opts = validateImportOpts(raw);
         }
-        catch {
-            console.error(chalk.red(`Factory registry at ${src} is not valid JSON`));
+        catch (e) {
+            console.error(chalk.red(e instanceof Error ? e.message : String(e)));
             process.exit(1);
         }
-        const list = Array.isArray(rows) ? rows : Array.isArray(rows.projects) ? rows.projects : [];
-        let created = 0;
-        let skipped = 0;
-        for (const raw of list) {
-            if (!raw || typeof raw !== 'object')
-                continue;
-            const o = raw;
-            const name = typeof o.name === 'string' ? o.name : undefined;
-            if (!name || !isSafeProjectName(name)) {
-                skipped++;
-                continue;
-            }
-            if (loadProjectDef(name) && !opts.force) {
-                skipped++;
-                continue;
-            }
-            const def = { name };
-            if (typeof o.path === 'string')
-                def.root = toHomeRelative(o.path);
-            if (typeof o.repoSlug === 'string')
-                def.repo = o.repoSlug;
-            if (typeof o.linearProjectId === 'string')
-                def.linear = { projectId: o.linearProjectId };
+        const existing = new Map(listProjectDefs().map((d) => [d.name, d]));
+        const result = opts.source === 'linear' ? runLinearImport(existing, opts) : runFactoryImport(existing, opts);
+        for (const def of result.defs)
             writeProjectDef(def);
-            created++;
+        const n = result.defs.length;
+        const s = result.skipped.length;
+        console.log(chalk.green(`Imported ${n} project${n === 1 ? '' : 's'}${s ? chalk.gray(` (${s} skipped)`) : ''}`));
+        for (const skip of result.skipped)
+            console.log(chalk.gray(`  skip ${skip.name}: ${skip.reason}`));
+        if (opts.source === 'factory' && s > 0 && opts.minConfidence === 'high') {
+            console.log(chalk.gray('  (widen with --min-confidence medium or --all)'));
         }
-        console.log(chalk.green(`Imported ${created} project${created === 1 ? '' : 's'}${skipped ? chalk.gray(` (${skipped} skipped)`) : ''}`));
     });
     // ---- link ----
     projects

package/dist/commands/routines.js

@@ -11,6 +11,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { isDaemonRunning, signalDaemonReload, startDaemon, stopDaemon, readDaemonLog, getDaemonStatus, } from '../lib/daemon.js';
+import { assertSchedulerEnabled } from '../lib/device-config.js';
 import { resolveAgentName, isAgentHardDeprecated, hardDeprecationError } from '../lib/agents.js';
 import { humanizeCron, humanizeNextRun, formatRepoLink, REPO_DISPLAY_MAX } from '../lib/routines-format.js';
 import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, getLatestRun, getRunDir, getJobPath, parseAtTime, hasCompletedOneShotRun, isOneShotLikeSchedule, isOneShotRoutine, isPastOneShotRoutine, jobRunsOnThisDevice, checkJobDeviceEligibility, normalizeTriggerEvent, parseHostStrategy, resolveHostStrategy, placementRequiresFiringPin, HOST_STRATEGIES, } from '../lib/routines.js';
@@ -295,9 +296,21 @@ function parseRoutineTrigger(options) {
 /**
  * Start or reload the background scheduler so newly-added jobs fire on time.
  * `quiet` suppresses human status lines for JSON callers.
+ *
+ * When this device has `scheduler.enabled=false` the auto-start is skipped with
+ * the stated reason (the add itself already succeeded — the job is config and
+ * stays valid fleet-wide); the refusal message names the setting and the fix.
  */
 function ensureSchedulerRunning(opts = {}) {
     const log = opts.stderr ? console.error : console.log;
+    try {
+        assertSchedulerEnabled();
+    }
+    catch (err) {
+        // Loud stated skip, on stderr so --json stdout stays clean.
+        console.error(chalk.yellow(err.message));
+        return;
+    }
     if (isDaemonRunning()) {
         signalDaemonReload();
         if (!opts.quiet)
@@ -1480,9 +1493,22 @@ export function registerRoutinesCommands(program) {
         .command('start')
         .description('Start the background scheduler. Usually unnecessary — it auto-starts when you add your first routine.')
         .action(() => {
+        try {
+            // A manual start on a scheduler-disabled device refuses with the same
+            // message the auto-start surfaces give.
+            assertSchedulerEnabled();
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
         const result = startDaemon();
         if (result.method === 'already-running') {
-            console.log(chalk.yellow(`Scheduler already running (PID: ${result.pid})`));
+            // Signal a reload even here: if the daemon booted while this device had
+            // scheduler.enabled=false, the reload re-evaluates the gate and boots
+            // the scheduler — a manual start heals a scheduler-less daemon.
+            signalDaemonReload();
+            console.log(chalk.yellow(`Scheduler already running (PID: ${result.pid}) — reloaded`));
         }
         else if (result.pid) {
             console.log(chalk.green(`Scheduler started (PID: ${result.pid})`));

package/dist/commands/rules.js

@@ -512,6 +512,12 @@ Examples:
         .addHelpText('after', `
 Targets are <agent>@<version>. Use 'default' for the alias of the global default version.
 
+This re-syncs the version home immediately, AND the choice sticks: every later
+'agents run' for this agent+version re-applies the active preset before launch
+(skip-fast when nothing changed), so a preset set here never goes stale even if
+something changes it again without running 'switch' — you don't need to re-run
+'switch' or 'sync' by hand before the next launch.
+
 Examples:
   # Persist the cautious preset for claude 2.1.111
   agents rules switch claude@2.1.111 --preset cautious

package/dist/commands/sessions.d.ts

@@ -315,6 +315,13 @@ export declare function isBareBrowserListing(options: SessionsOptions, query: st
  * `runSessionBrowser` picker cannot represent.
  */
 export declare function hasNoBrowserDisqualifyingFlags(options: SessionsOptions, query: string | undefined): boolean;
+/** Resolve a session by id/query globally and print its compact preview (no pager).
+ * Backs `--preview` — the fast path for the "peek before resume" hot loop. */
+export declare function renderSessionPreview(query: string, scope: {
+    agent?: string;
+    project?: string;
+    local?: boolean;
+}): Promise<void>;
 /**
  * The one-line live status banner shown above a session preview: the glyph, the
  * status word, and — when the session needs a human or has LOST one — a plain
@@ -351,6 +358,16 @@ export declare function teamBadge(session: SessionMeta): {
  * when `showTicket` — otherwise a listing with no refs would waste a column of
  * dashes and needlessly truncate the topic. Worktree stays a trailing badge. */
 export declare function flatSessionRow(session: SessionMeta, live?: ActiveSession, showTicket?: boolean, cols?: PickerColumns, favorite?: boolean): string;
+/**
+ * Live-session index for enriching the default listing, or undefined when
+ * enrichment is off (`--no-live`) or irrelevant (`--json`, which serializes
+ * SessionMeta). Full detection (incl. the headless `ps` scan) is deliberate:
+ * bare-CLI and tmux agents are the common case here, and skipping them would
+ * leave the glyph almost never showing. The listing is a one-shot user action,
+ * not a hot loop, so the `ps`/`lsof` cost is acceptable; `--no-live` is the
+ * escape hatch. Never throws — a probe failure just yields a plain listing.
+ */
+export declare function maybeLiveIndex(options: SessionsOptions): Promise<Map<string, ActiveSession> | undefined>;
 /**
  * Group key for the overview: resolve the cwd through the same canonical
  * resolver the `agents activity` timeline groups by — a defined project's name