@phnx-labs/agents-cli 1.20.74 → 1.20.76

package/dist/commands/feed.d.ts

@@ -1,6 +1,7 @@
 /**
- * `agents feed` -- list open blocks (decisions agents are waiting on).
+ * `agents feed` -- operator inbox + agent status posts.
  *
+ * Default (`agents feed`): list open blocks (decisions agents are waiting on).
  * Aggregates block records from the local feed store and, with --host, from
  * reachable remote hosts via SSH passthrough. Each block carries enough
  * identity for `agents message` to route a reply back to the right agent.
@@ -8,6 +9,11 @@
  * Default view groups by **outcome** (ticket / PR / worktree / Unassigned) so
  * an operator sees dozens of deliverables, not ~1,100 agents. Pass `--flat`
  * for the legacy per-agent list.
+ *
+ * `agents feed post`: agent-callable free-text progress into the activity
+ * stream (milestone `status.posted`). Session/agent/host/runtime/pid identity
+ * is auto-stamped from env + the pid registry — no domain-specific flags.
+ * Humans watch via the feed activity lane / `agents activity`.
  */
 import type { Command } from 'commander';
 import { type OpenBlock } from '../lib/feed.js';

package/dist/commands/feed.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { ensureFeedPublishHook, listAskStats, listBlocks, recordNotified } from '../lib/feed.js';
 import { ensureActivityLogHook, readRecentActivity, formatActivityLine } from '../lib/activity.js';
+import { postFeedStatus } from '../lib/feed-post.js';
 import { enrichBlocksFromSessions, groupBlocksByOutcome, isUnambiguousOutcomeAnswer, openBlocksForOutcome, stampBlockOutcomes, } from '../lib/feed-outcome.js';
 import { classifyBlock, filterBlocksForFeed, suppressionDigest, } from '../lib/ask-classifier.js';
 import { machineId, normalizeHost } from '../lib/machine-id.js';
@@ -214,9 +215,9 @@ export function sessionHintsFromActive(sessions) {
     }));
 }
 export function registerFeedCommand(program) {
-    program
+    const feed = program
         .command('feed')
-        .description('List open blocks -- decisions agents are waiting on (grouped by outcome)')
+        .description('Open blocks (needs you) + agent status posts (feed post)')
         .option('--json', 'Output as JSON (each block stamped with its outcome + ask class)')
         .option('--flat', 'List one block per agent instead of grouping by outcome')
         .option('--all', 'Include stalls/FYIs that policy would suppress (default: hide them)')
@@ -225,8 +226,50 @@ export function registerFeedCommand(program) {
         .option('--device <target...>', 'Alias for --host; repeatable')
         .option('--dispatch', 'Run stall suppression + default-on-no-answer policy and urgent notifications')
         .option('--pause <id>', 'Pause a runaway/needy local process (SIGSTOP) or cancel a cloud task')
-        .option('--kill <id>', 'Kill a runaway/needy local process (SIGTERM) or cancel a cloud task')
-        .action(async (opts) => {
+        .option('--kill <id>', 'Kill a runaway/needy local process (SIGTERM) or cancel a cloud task');
+    feed
+        .command('post')
+        .description('Post a status update to the fleet activity stream (for agents)')
+        .argument('<text...>', 'What just happened — one short human line')
+        .option('--session <id>', 'Session id escape hatch (default: auto from env / pid registry)')
+        .option('--json', 'Emit the written event as JSON')
+        .addHelpText('after', `
+Examples:
+  # Inside an agents-cli run (session identity is already in the env):
+  agents feed post "CHANGELOG pushed; watching CI and mac-mini E2E"
+  agents feed post "ready for review" --json
+
+  # Outside a run, pass the session explicitly:
+  agents feed post "manual note" --session 00998b0e-2d15-4d2f-a58b-974a886c9b47
+
+Identity (session, agent, host, runtime, pid, launchId) is stamped automatically.
+Domain facts (tickets, PRs) are not CLI flags — join them on the session at read time.
+`)
+        .action((textParts, opts, cmd) => {
+        // Parent `feed` also declares `--json` (for the list view). Commander
+        // binds the flag on the parent, so a `feed post … --json` lands on
+        // parent.opts().json — not the child. Read both.
+        const flags = {
+            session: opts?.session ?? cmd?.opts?.()?.session,
+            json: Boolean(opts?.json ?? cmd?.opts?.()?.json ?? cmd?.parent?.opts?.()?.json),
+        };
+        try {
+            const { event } = postFeedStatus({
+                text: Array.isArray(textParts) ? textParts.join(' ') : String(textParts ?? ''),
+                sessionId: flags.session,
+            });
+            if (flags.json) {
+                console.log(JSON.stringify(event, null, 2));
+                return;
+            }
+            console.log(formatActivityLine(event, { showHost: true }).trimStart());
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exitCode = 1;
+        }
+    });
+    feed.action(async (opts) => {
         if (opts.device?.length)
             opts.host = [...(opts.host ?? []), ...opts.device];
         const self = machineId();

package/dist/commands/go.d.ts

@@ -17,8 +17,15 @@ import type { Command } from 'commander';
 import { type ActiveSession } from '../lib/session/active.js';
 import type { SessionMeta } from '../lib/session/types.js';
 export declare function registerGoCommand(program: Command): void;
-/** Live jump targets (local + remote), keyed by session id. Cloud excluded (no pid). */
-export declare function gatherLiveTargets(local: boolean): Promise<{
+/**
+ * Live jump targets (local + remote), keyed by session id. Cloud is excluded by
+ * default (it has no local pid to attach), but `detach` opts in with
+ * `includeCloud` so it can resolve a cloud id and refuse it with a clear message
+ * instead of a bare "no live session".
+ */
+export declare function gatherLiveTargets(local: boolean, opts?: {
+    includeCloud?: boolean;
+}): Promise<{
     self: string;
     activeById: Map<string, ActiveSession>;
 }>;

package/dist/commands/go.js

@@ -20,6 +20,7 @@ import { promisify } from 'util';
 import { getActiveSessions, findSessionFileForKind } from '../lib/session/active.js';
 import { gatherRemoteActive } from '../lib/session/remote-active.js';
 import { discoverSessions } from '../lib/session/discover.js';
+import { deriveShortId } from '../lib/session/short-id.js';
 import { dedupeByMachineSession, mergeLocalFirst, pickSessionInteractive } from './sessions.js';
 import { focusAction } from './focus.js';
 import { machineId } from '../lib/session/sync/config.js';
@@ -39,8 +40,13 @@ export function registerGoCommand(program) {
         await focusAction(id, { local: opts.local, attachOnly: true });
     });
 }
-/** Live jump targets (local + remote), keyed by session id. Cloud excluded (no pid). */
-export async function gatherLiveTargets(local) {
+/**
+ * Live jump targets (local + remote), keyed by session id. Cloud is excluded by
+ * default (it has no local pid to attach), but `detach` opts in with
+ * `includeCloud` so it can resolve a cloud id and refuse it with a clear message
+ * instead of a bare "no live session".
+ */
+export async function gatherLiveTargets(local, opts = {}) {
     const self = machineId();
     const localActive = await getActiveSessions();
     for (const s of localActive)
@@ -55,9 +61,13 @@ export async function gatherLiveTargets(local) {
         catch { /* remote sweep is best-effort */ }
     }
     const activeById = new Map();
-    for (const s of active)
-        if (s.context !== 'cloud' && s.sessionId)
-            activeById.set(s.sessionId, s);
+    for (const s of active) {
+        if (!s.sessionId)
+            continue;
+        if (s.context === 'cloud' && !opts.includeCloud)
+            continue;
+        activeById.set(s.sessionId, s);
+    }
     return { self, activeById };
 }
 /** Interactive pick over the live sessions' rich SessionMeta; returns the chosen live session. */
@@ -99,7 +109,7 @@ function synthMeta(s, self) {
     const filePath = remote ? '' : (findSessionFileForKind(s.kind, s.cwd, s.sessionId) ?? '');
     return {
         id: s.sessionId,
-        shortId: s.sessionId.slice(0, 8),
+        shortId: deriveShortId(s.sessionId),
         agent: s.kind,
         timestamp: new Date(s.startedAtMs ?? Date.now()).toISOString(),
         filePath,

package/dist/commands/harness.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Custom harness commands (`agents harness`).
+ *
+ * A "custom harness" is a named (host CLI + model) combo — e.g. OpenCode pinned
+ * to meta/muse-spark-1.1, called `spark`. It runs like a native agent type
+ * (`agents run spark`) and syncs across devices via `agents repo push user`.
+ *
+ * Mechanism: harnesses ARE profiles (same ~/.agents/profiles/*.yml, same run
+ * resolution). This command group is the harness-flavored surface over that
+ * layer + a discovery `list` spanning custom harnesses, addable presets, and the
+ * native harness registry. The `agents profiles` tree stays unchanged.
+ */
+import type { Command } from 'commander';
+export declare function registerHarnessCommands(program: Command): void;

package/dist/commands/harness.js

@@ -0,0 +1,145 @@
+/**
+ * Custom harness commands (`agents harness`).
+ *
+ * A "custom harness" is a named (host CLI + model) combo — e.g. OpenCode pinned
+ * to meta/muse-spark-1.1, called `spark`. It runs like a native agent type
+ * (`agents run spark`) and syncs across devices via `agents repo push user`.
+ *
+ * Mechanism: harnesses ARE profiles (same ~/.agents/profiles/*.yml, same run
+ * resolution). This command group is the harness-flavored surface over that
+ * layer + a discovery `list` spanning custom harnesses, addable presets, and the
+ * native harness registry. The `agents profiles` tree stays unchanged.
+ */
+import chalk from 'chalk';
+import { addProfile } from './profiles.js';
+import { listProfiles, readProfile, deleteProfile, profileHostLabel, profileProviderLabel, profileModelLabel, profileAuthLabel, getProfilePath, } from '../lib/profiles.js';
+import { listPresets } from '../lib/profiles-presets.js';
+import { AGENTS, ALL_AGENT_IDS } from '../lib/agents.js';
+/** Short capability summary for a native harness — its supported run modes. */
+function nativeModes(id) {
+    const modes = AGENTS[id]?.capabilities?.modes ?? [];
+    return modes.length ? modes.join('/') : '-';
+}
+export function registerHarnessCommands(program) {
+    const cmd = program
+        .command('harness')
+        .alias('harnesses')
+        .description('Custom harnesses — name a (host CLI + model) combo and run it like a native agent type.')
+        .addHelpText('after', `
+A custom harness pins a host CLI (opencode, claude, codex, grok, gemini, ...) to a
+model and gives it a name. 'agents run <name>' then behaves like a native agent
+type, and 'agents repo push user' syncs it to every device.
+
+Examples:
+  # Meta Muse Spark 1.1 through OpenCode, called 'spark'
+  agents harness add spark --host opencode --model meta/muse-spark-1.1
+  agents run spark "refactor api/handlers/checkout.py"
+
+  # Per-run model override still wins
+  agents run spark --model opencode/big-pickle "quick pass"
+
+  # See custom harnesses, addable presets, and native harnesses
+  agents harness list
+
+  # Private OpenAI/Anthropic-compatible endpoint (stores a keychain key)
+  agents harness add corp --host claude --model gpt-x --base-url https://gw.corp/v1 --auth-provider corp
+
+  # Custom harnesses are just profiles — this also works via 'agents profiles'
+`);
+    cmd
+        .command('add <name>')
+        .description('Create a custom harness from a host + model (or apply a built-in preset).')
+        .option('--host <agent>', 'Host CLI to run under (opencode, claude, codex, grok, gemini, ...) — pair with --model')
+        .option('--model <id>', 'Model id to pin on the host (e.g., meta/muse-spark-1.1) — pair with --host')
+        .option('--base-url <url>', 'Custom endpoint base URL (claude/codex hosts)')
+        .option('--auth-provider <provider>', 'Attach a keychain-backed API key under this provider (for private endpoints)')
+        .option('--preset <preset>', 'Apply a built-in preset instead of --host/--model')
+        .option('--version <version>', 'Pin the host CLI version (e.g., 1.16.0)')
+        .option('--key-stdin', 'Read API key from stdin instead of prompting (for scripts/CI)')
+        .option('--force', 'Overwrite an existing harness with the same name')
+        .action(async (name, opts) => {
+        try {
+            await addProfile(name, opts, 'Harness');
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('list')
+        .alias('ls')
+        .description('List custom harnesses, addable presets, and native harnesses.')
+        .option('--json', 'Emit JSON instead of a table')
+        .action((opts) => {
+        const custom = listProfiles();
+        const presets = listPresets();
+        const native = ALL_AGENT_IDS.map((id) => ({ id, name: AGENTS[id].name, modes: nativeModes(id) }));
+        if (opts.json) {
+            console.log(JSON.stringify({
+                custom: custom.map((p) => ({
+                    name: p.name,
+                    host: p.host.agent,
+                    model: profileModelLabel(p),
+                    provider: profileProviderLabel(p),
+                })),
+                presets: presets.map((p) => ({ name: p.name, provider: p.provider, description: p.description })),
+                native,
+            }, null, 2));
+            return;
+        }
+        console.log(chalk.bold('Custom harnesses') + chalk.gray('  (yours — agents run <name>)'));
+        if (custom.length === 0) {
+            console.log(chalk.gray('  none yet — try: agents harness add spark --host opencode --model meta/muse-spark-1.1'));
+        }
+        else {
+            for (const p of custom) {
+                console.log(`  ${chalk.cyan(p.name.padEnd(16))} ${profileHostLabel(p).padEnd(14)} ${chalk.gray(profileModelLabel(p))}`);
+            }
+        }
+        console.log('');
+        console.log(chalk.bold('Presets') + chalk.gray('  (addable — agents harness add <name>)'));
+        for (const p of presets) {
+            console.log(`  ${chalk.cyan(p.name.padEnd(16))} ${p.provider.padEnd(12)} ${chalk.gray(p.description.slice(0, 70))}`);
+        }
+        console.log('');
+        console.log(chalk.bold('Native harnesses') + chalk.gray('  (built-in — agents run <id>)'));
+        for (const n of native) {
+            console.log(`  ${chalk.cyan(n.id.padEnd(16))} ${n.name.padEnd(14)} ${chalk.gray('modes: ' + n.modes)}`);
+        }
+    });
+    cmd
+        .command('view <name>')
+        .alias('show')
+        .description('Show one custom harness (host, model, provider, auth, path).')
+        .action((name) => {
+        try {
+            const p = readProfile(name);
+            console.log(chalk.bold(p.name));
+            if (p.description)
+                console.log(chalk.gray(p.description));
+            console.log('');
+            console.log(`Host:     ${profileHostLabel(p)}`);
+            console.log(`Model:    ${profileModelLabel(p)}`);
+            console.log(`Provider: ${profileProviderLabel(p)}`);
+            console.log(`Auth:     ${profileAuthLabel(p)}`);
+            console.log(chalk.gray(getProfilePath(p.name)));
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('remove <name>')
+        .alias('rm')
+        .description('Delete a custom harness (keychain token is kept).')
+        .action((name) => {
+        const existed = deleteProfile(name);
+        if (!existed) {
+            console.error(chalk.red(`Harness '${name}' not found.`));
+            process.exit(1);
+        }
+        console.log(chalk.green(`Harness '${name}' removed.`));
+    });
+}

package/dist/commands/import.js

@@ -134,7 +134,7 @@ async function runImport(agentArg, opts) {
             }
         }
     }
-    let version = opts.version;
+    let version = opts.as;
     if (!version) {
         if (!useDirectBinaryImport && globalPath) {
             try {
@@ -157,7 +157,7 @@ async function runImport(agentArg, opts) {
     }
     if (!version) {
         console.error(chalk.red(`Could not determine version for ${agentLabel(agentId)}.`));
-        console.error(chalk.gray('Pass --version <version> explicitly.'));
+        console.error(chalk.gray('Pass --as <version> explicitly.'));
         process.exit(1);
     }
     if (!isValidImportVersion(version)) {
@@ -167,7 +167,7 @@ async function runImport(agentArg, opts) {
     }
     const versionDir = getVersionDir(agentId, version);
     const fromLabel = useDirectBinaryImport ? installScriptBinary : globalPath;
-    console.log(chalk.bold(`\nImport ${agentLabel(agentId)} v${version}`));
+    console.log(chalk.bold(`\nImport ${agentLabel(agentId)} v${version}${opts.isolated ? ' (isolated copy)' : ''}`));
     console.log(`  from: ${chalk.gray(fromLabel)}`);
     console.log(`  into: ${chalk.gray(versionDir)}`);
     const configDirExists = fs.existsSync(agent.configDir);
@@ -178,6 +178,16 @@ async function runImport(agentArg, opts) {
             configAlreadyManaged = true;
             console.log(`  config: ${chalk.gray(`${agent.configDir} (already managed — will skip)`)}`);
         }
+        else if (opts.isolated) {
+            // This summary is printed BEFORE the branch that does the work, so it has to
+            // describe the mode it is actually about to run. Saying "will be moved" under
+            // --isolated announced the exact adoption the flag exists to prevent — a
+            // confirmation prompt that misdescribes the operation is worse than none.
+            console.log(`  config: ${chalk.gray(`${agent.configDir} (will be COPIED — your original stays put)`)}`);
+            if (!opts.withAuth) {
+                console.log(`          ${chalk.gray('credentials are skipped; pass --with-auth to include them')}`);
+            }
+        }
         else {
             console.log(`  config: ${chalk.gray(`${agent.configDir} (will be moved into version home)`)}`);
         }
@@ -188,7 +198,9 @@ async function runImport(agentArg, opts) {
     if (!opts.yes && isInteractiveTerminal()) {
         console.log();
         const proceed = await confirm({
-            message: `Import ${agentLabel(agentId)} v${version} into agents-cli?`,
+            message: opts.isolated
+                ? `Import ${agentLabel(agentId)} v${version} as an isolated copy?`
+                : `Import ${agentLabel(agentId)} v${version} into agents-cli?`,
             default: true,
         }).catch((err) => {
             if (isPromptCancelled(err))
@@ -205,17 +217,23 @@ async function runImport(agentArg, opts) {
     // want a stranded symlink farm. Binary registration is cheap and reversible
     // — if it fails after config, the next `agents import` call retries cleanly.
     const willImportConfig = configDirExists && !configAlreadyManaged && !opts.isolated;
-    if (opts.isolated && configDirExists) {
+    if (opts.isolated && configDirExists && configAlreadyManaged) {
+        console.log(chalk.gray(`  Skipping config copy: ${agent.configDir} is a managed symlink, not your real settings.`));
+    }
+    else if (opts.isolated && configDirExists) {
         // COPY the user's settings in; never move, never symlink. The original stays
         // exactly where it is — that is what separates this from adoption.
         const seedSpinner = ora(`Copying ${agent.configDir} into the isolated copy...`).start();
-        const seed = seedIsolatedConfigFromLocal(agentId, version, { withAuth: opts.withAuth });
+        const seed = seedIsolatedConfigFromLocal(agentId, version, { withAuth: opts.withAuth, all: opts.all });
         if (seed.error) {
             seedSpinner.fail(`Config: ${seed.error}`);
             process.exit(1);
         }
         else if (seed.seeded) {
             seedSpinner.succeed(`Settings copied (${seed.from} -> ${seed.to}); your original is untouched`);
+            if (seed.skippedRuntime.length > 0) {
+                console.log(chalk.gray(`  Runtime state NOT copied: ${seed.skippedRuntime.join(', ')} (regenerated as you use it; --all to include)`));
+            }
             if (seed.skippedAuth.length > 0) {
                 console.log(chalk.gray(`  Credentials NOT copied: ${seed.skippedAuth.join(', ')}`));
                 console.log(chalk.gray('  The copy signs in separately. Use --with-auth to copy them too.'));
@@ -288,15 +306,22 @@ export function registerImportCommand(program) {
         .command('import')
         .argument('<agent>', 'Agent id (e.g. openclaw, claude, codex)')
         .description('Import an existing unmanaged agent install into agents-cli')
-        .option('--version <version>', 'Pin a version label (otherwise read from package.json)')
+        // NOT `--version`. The program declares `.version(VERSION)` (src/index.ts), which
+        // claims `-V, --version` globally and wins over a subcommand option of the same
+        // name — so `agents import codex --version 1.2.3` printed the CLI's own version
+        // and exited without importing anything. The flag had been unreachable since it
+        // was introduced, and the "could not determine version" error even advised using
+        // it. Renamed so it actually reaches the command.
+        .option('--as <version>', 'Version label to import as (otherwise read from package.json)')
         .option('--from-path <path>', 'Path to the npm package dir (otherwise auto-detected from PATH)')
         .option('--isolated', 'Copy the install into a self-contained isolated version instead of adopting it')
         .option('--with-auth', 'With --isolated, also copy credentials into the sandbox (skipped by default)')
+        .option('--all', 'With --isolated, also copy session history, logs and caches (skipped by default)')
         .option('-y, --yes', 'Skip the confirmation prompt')
         .addHelpText('after', `
 Examples:
   $ agents import openclaw                          Auto-detect via PATH
-  $ agents import openclaw --version 2026.3.8       Pin a version label
+  $ agents import openclaw --as 2026.3.8            Pin a version label
   $ agents import openclaw --from-path /opt/homebrew/lib/node_modules/openclaw
 
   # installScript-based agents (curl/brew installers, no npm package):
@@ -305,6 +330,11 @@ Examples:
   $ agents import cursor                            Adopt ~/.local/bin/cursor-agent
   $ agents import antigravity --from-path ~/.local/bin/agy
 
+  # Copy your setup into a sandbox instead of adopting it:
+  $ agents import codex --isolated                  New isolated copy at the local version
+  $ agents import codex --isolated --as 0.146.0     Re-seed an EXISTING isolated copy
+  $ agents import codex --isolated --with-auth      ...and share credentials with it
+
 When to use:
   When an agent CLI is already installed globally and you want to bring it
   under agents-cli management without reinstalling. Creates a symlink farm

package/dist/commands/inspect.js

@@ -21,6 +21,7 @@ import { truncate, termLink } from '../lib/format.js';
 import * as yaml from 'yaml';
 import { AGENTS, getCliState, resolveAgentName } from '../lib/agents.js';
 import { supports } from '../lib/capabilities.js';
+import { resolveConfiguredModel } from '../lib/models.js';
 import { resolveSingleAgentTarget, AgentSpecError } from '../lib/agent-spec/index.js';
 import { readMeta, getUserAgentsDir, getSystemAgentsDir, getProjectAgentsDir, getEnabledExtraRepos, } from '../lib/state.js';
 import { getVersionHomePath } from '../lib/versions.js';
@@ -585,8 +586,10 @@ async function renderSummary(agent, version, versionHome, options) {
         console.log(JSON.stringify(json, null, 2));
         return;
     }
-    // Plain text
-    const head = `${chalk.bold(agent)} ${chalk.gray('@')} ${chalk.cyan(version)}${isDefault ? '  ' + chalk.green('[default]') : ''}`;
+    // Plain text — model sits right beside the version, same priority (no label).
+    const configuredModel = resolveConfiguredModel(agent, version)?.model;
+    const modelPart = configuredModel ? '  ' + chalk.yellow(configuredModel) : '';
+    const head = `${chalk.bold(agent)} ${chalk.gray('@')} ${chalk.cyan(version)}${modelPart}${isDefault ? '  ' + chalk.green('[default]') : ''}`;
     console.log('\n' + head + '\n');
     const rows = [
         ['install', versionHome],

package/dist/commands/profiles.d.ts

@@ -15,5 +15,25 @@ import { type Preset } from '../lib/profiles-presets.js';
  * without mocking @inquirer/prompts.
  */
 export declare function buildProfileFromCollection(name: string, preset: Preset, collected: Record<string, string>, version?: string): Profile;
+/** Options accepted by {@link addProfile} — shared by `agents profiles add` and `agents harness add`. */
+export interface AddProfileOptions {
+    preset?: string;
+    host?: string;
+    model?: string;
+    baseUrl?: string;
+    authProvider?: string;
+    version?: string;
+    keyStdin?: boolean;
+    force?: boolean;
+}
+/**
+ * Create a profile ("custom harness"). Two paths:
+ *  - `--host <agent> --model <id>`: one-shot custom harness from a host + model
+ *    (no preset needed). This is what makes a model like Muse Spark a named,
+ *    runnable harness.
+ *  - otherwise: apply a built-in preset (existing behavior).
+ * `label` only tunes the success wording (Profile vs Harness). Throws on error.
+ */
+export declare function addProfile(name: string, opts: AddProfileOptions, label?: 'Profile' | 'Harness'): Promise<void>;
 /** Register the `agents profiles` command tree. */
 export declare function registerProfilesCommands(program: Command): void;

package/dist/commands/profiles.js

@@ -9,13 +9,13 @@
 import chalk from 'chalk';
 import { readStdinSync } from '../lib/format.js';
 import { spawn } from 'child_process';
-import { listProfiles, readProfile, writeProfile, deleteProfile, profileExists, profileFromPreset, validateProfileName, getPresetForProfile, } from '../lib/profiles.js';
+import { listProfiles, readProfile, writeProfile, deleteProfile, profileExists, profileFromPreset, profileFromHostModel, baseUrlEnvKeyForHost, authEnvKeyForHost, validateProfileName, getPresetForProfile, } from '../lib/profiles.js';
 import { getPreset, listPresets, expandPreset } from '../lib/profiles-presets.js';
 import { hasKeychainToken, keychainItemName, setKeychainToken, deleteKeychainToken, } from '../lib/secrets/profiles.js';
 import { isInteractiveTerminal } from './utils.js';
 import { getAgentsInvocation } from '../lib/daemon.js';
 import { getActiveResourceProfileName, getResourceProfilePreset, listResourceProfileNames, setActiveResourceProfile, upsertResourceProfilePreset, validateResourceProfileName, } from '../lib/resource-profiles.js';
-import { AGENTS } from '../lib/agents.js';
+import { AGENTS, ALL_AGENT_IDS } from '../lib/agents.js';
 import { listInstalledVersions, syncResourcesToVersion } from '../lib/versions.js';
 /**
  * Pure helper: builds a Profile from collected wizard inputs. Extracted so the
@@ -31,6 +31,7 @@ export function buildProfileFromCollection(name, preset, collected, version) {
             envVar: preset.authEnvVar,
             keychainItem: keychainItemName(preset.provider),
         },
+        authOptional: preset.authOptional,
         description: preset.description,
         preset: preset.name,
         provider: preset.provider,
@@ -65,6 +66,66 @@ async function ensureProviderToken(provider, signupUrl, fromStdin) {
     setKeychainToken(item, token);
     console.log(chalk.green(`Stored in keychain: ${item}`));
 }
+/**
+ * Create a profile ("custom harness"). Two paths:
+ *  - `--host <agent> --model <id>`: one-shot custom harness from a host + model
+ *    (no preset needed). This is what makes a model like Muse Spark a named,
+ *    runnable harness.
+ *  - otherwise: apply a built-in preset (existing behavior).
+ * `label` only tunes the success wording (Profile vs Harness). Throws on error.
+ */
+export async function addProfile(name, opts, label = 'Profile') {
+    validateProfileName(name);
+    if (profileExists(name) && !opts.force) {
+        throw new Error(`${label} '${name}' already exists. Use --force to overwrite.`);
+    }
+    // One-shot host + model → custom harness, no preset required.
+    if (opts.host || opts.model) {
+        if (!opts.host || !opts.model) {
+            throw new Error('Both --host <agent> and --model <id> are required to build a harness from a host + model.');
+        }
+        if (!ALL_AGENT_IDS.includes(opts.host)) {
+            throw new Error(`Unknown host '${opts.host}'. Valid hosts: ${ALL_AGENT_IDS.join(', ')}`);
+        }
+        const host = opts.host;
+        if (opts.baseUrl && !baseUrlEnvKeyForHost(host)) {
+            console.error(chalk.yellow(`Note: --base-url has no known env var for host '${host}'; ignoring it.`));
+        }
+        let authEnvVar;
+        if (opts.authProvider) {
+            const key = authEnvKeyForHost(host);
+            if (!key) {
+                throw new Error(`--auth-provider is set but host '${host}' has no known auth env var. Use a preset or a hand-written profile YAML.`);
+            }
+            authEnvVar = key;
+            await ensureProviderToken(opts.authProvider, undefined, opts.keyStdin);
+        }
+        const profile = profileFromHostModel(name, host, opts.model, {
+            version: opts.version,
+            baseUrl: opts.baseUrl,
+            provider: opts.authProvider,
+            authEnvVar,
+        });
+        writeProfile(profile);
+        console.log(chalk.green(`${label} '${name}' added — ${host} + ${opts.model}.`));
+        console.log(chalk.gray(`Try: agents run ${name} "hello"`));
+        return;
+    }
+    // Preset path.
+    const presetName = opts.preset || name;
+    const preset = getPreset(presetName);
+    if (!preset) {
+        throw new Error(`No preset '${presetName}'.\nAvailable presets: ${listPresets().map((p) => p.name).join(', ')}\n` +
+            'Or build a custom harness: --host <agent> --model <id>.');
+    }
+    if (!preset.authOptional) {
+        await ensureProviderToken(preset.provider, preset.signupUrl, opts.keyStdin);
+    }
+    const profile = profileFromPreset(name, preset, opts.version);
+    writeProfile(profile);
+    console.log(chalk.green(`${label} '${name}' added.`));
+    console.log(chalk.gray(`Try: agents run ${name} "hello"`));
+}
 /** Format a single profile as a table row for the `profiles list` output. */
 function renderProfileRow(p) {
     const host = p.host.version ? `${p.host.agent}@${p.host.version}` : p.host.agent;
@@ -462,27 +523,13 @@ Examples:
         .option('--version <version>', 'Pin the host CLI version (e.g., 2.1.113)')
         .option('--key-stdin', 'Read API key from stdin instead of prompting (for scripts/CI)')
         .option('--force', 'Overwrite an existing profile with the same name')
+        .addHelpText('after', '\nTo build a custom harness from a host CLI + model in one shot, use `agents harness add`.\n')
         .action(async (name, opts) => {
+        // Preset-only surface here — `--host` on `profiles` is reserved for remote
+        // device routing (see lib/hosts/passthrough.ts). The host+model one-shot
+        // lives on `agents harness add`, which owns its own `--host`.
         try {
-            if (profileExists(name) && !opts.force) {
-                console.error(chalk.red(`Profile '${name}' already exists. Use --force to overwrite.`));
-                process.exit(1);
-            }
-            const presetName = opts.preset || name;
-            const preset = getPreset(presetName);
-            if (!preset) {
-                console.error(chalk.red(`No preset '${presetName}'.`));
-                console.error(chalk.gray('Available presets: ' + listPresets().map((p) => p.name).join(', ')));
-                console.error(chalk.gray('Or pass --preset <name> to pick explicitly.'));
-                process.exit(1);
-            }
-            if (!preset.authOptional) {
-                await ensureProviderToken(preset.provider, preset.signupUrl, opts.keyStdin);
-            }
-            const profile = profileFromPreset(name, preset, opts.version);
-            writeProfile(profile);
-            console.log(chalk.green(`Profile '${name}' added.`));
-            console.log(chalk.gray(`Try: agents run ${name} "hello"`));
+            await addProfile(name, { preset: opts.preset, version: opts.version, keyStdin: opts.keyStdin, force: opts.force }, 'Profile');
         }
         catch (err) {
             console.error(chalk.red(err.message));

package/dist/commands/repo.js

@@ -812,6 +812,7 @@ export function registerRepoCommands(program) {
             console.log(chalk.gray('No repos to pull.'));
             return;
         }
+        let anyPulled = false;
         for (const t of targets) {
             if (!fs.existsSync(t.dir) || !isGitRepo(t.dir)) {
                 // A plain (never-cloned) user repo — setup makes ~/.agents a bare dir and
@@ -851,11 +852,24 @@ export function registerRepoCommands(program) {
             const result = await pullRepo(t.dir);
             if (result.success) {
                 spinner.succeed(`${formatRepoTarget(t.alias, t.dir, result.branch)}: ${result.commit}`);
+                anyPulled = true;
             }
             else {
                 spinner.fail(`${formatRepoTarget(t.alias, t.dir)}: ${result.error}`);
             }
         }
+        // RUSH-1980: a pull rewrites the routine YAML on disk, but the daemon's
+        // scheduler froze its JobConfigs (device pins included) at load. Without a
+        // reload it keeps firing the pre-pull pins — a routine re-pinned to another
+        // host still fires here, double-firing across the fleet. SIGHUP the daemon
+        // so scheduler.reloadAll() re-reads the synced YAML and device pins refresh.
+        // No-op when the daemon isn't running (or on Windows, which has no SIGHUP).
+        if (anyPulled) {
+            const { isDaemonRunning, signalDaemonReload } = await import('../lib/daemon.js');
+            if (isDaemonRunning() && signalDaemonReload()) {
+                console.log(chalk.gray('Reloaded the routines daemon (device pins refreshed).'));
+            }
+        }
     });
     repoCmd
         .command('push [alias]')