@phnx-labs/agents-cli 1.20.61 → 1.20.63

package/dist/lib/git.js

@@ -366,23 +366,67 @@ export async function checkGitHubRepoExists(owner, repo) {
     }
 }
 /**
- * Commit and push changes in a repo.
+ * Commit (if dirty) and push a repo.
+ *
+ * Clean tree + local ahead of origin still pushes — "nothing to commit" is not
+ * "nothing to push". Reports "already up to date" only when `ahead === 0` and
+ * there is nothing to commit.
  */
 export async function commitAndPush(repoPath, message) {
     try {
         const git = simpleGit(repoPath);
-        // Check for changes
-        const status = await git.status();
-        if (status.files.length === 0) {
-            return { success: true }; // Nothing to commit
+        let status = await git.status();
+        const branch = status.current || 'main';
+        let committed = false;
+        if (status.files.length > 0) {
+            await git.add('-A');
+            await git.commit(message);
+            committed = true;
+            status = await git.status();
+        }
+        const ahead = status.ahead ?? 0;
+        if (!committed && ahead === 0) {
+            return {
+                success: true,
+                detail: 'already up to date',
+                branch,
+                committed: false,
+                pushed: false,
+            };
+        }
+        // Capture remote tip before push for a real ref range in the detail string.
+        let before = '';
+        try {
+            before = (await git.raw(['rev-parse', '--short=8', `origin/${branch}`])).trim();
+        }
+        catch {
+            /* origin/<branch> may not exist yet (first push) */
         }
-        // Stage all changes
-        await git.add('-A');
-        // Commit
-        await git.commit(message);
-        // Push
-        await git.push('origin', 'main');
-        return { success: true };
+        await git.push('origin', branch);
+        let after = '';
+        try {
+            after = (await git.raw(['rev-parse', '--short=8', 'HEAD'])).trim();
+        }
+        catch {
+            after = 'unknown';
+        }
+        const range = before && after && before !== after
+            ? `${before}..${after}`
+            : after || undefined;
+        const detail = committed
+            ? range
+                ? `committed and pushed ${range}`
+                : 'committed and pushed'
+            : range
+                ? `pushed ${range}`
+                : 'pushed';
+        return {
+            success: true,
+            detail,
+            branch,
+            committed,
+            pushed: true,
+        };
     }
     catch (err) {
         return { success: false, error: err.message };
@@ -630,6 +674,10 @@ export function displayHomePath(dir) {
 /**
  * Pull changes in an existing repo.
  * Refuses to pull if the working tree is dirty -- user must commit or discard changes first.
+ *
+ * Uses `git pull --rebase` (same strategy as {@link syncRepoGit}) so a diverged
+ * branch reconciles instead of failing with "Need to specify how to reconcile
+ * divergent branches".
  */
 export async function pullRepo(dir) {
     try {
@@ -642,13 +690,15 @@ export async function pullRepo(dir) {
                 error: `Working tree has uncommitted changes. Commit or discard them before pulling.\n\n  cd ${displayHomePath(dir)} && git status`,
             };
         }
-        await git.fetch();
-        await git.pull();
+        const branch = status.current || 'main';
+        await git.fetch('origin');
+        await git.pull('origin', branch, { '--rebase': 'true' });
         installGithooksSymlinks(dir);
         const log = await git.log({ maxCount: 1 });
         return {
             success: true,
             commit: log.latest?.hash.slice(0, 8) || 'unknown',
+            branch,
         };
     }
     catch (err) {

package/dist/lib/goose-commands.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Goose slash-command install/remove/list/compare.
+ *
+ * Goose has no native slash-command file format — a slash command is a recipe
+ * YAML file registered in `~/.config/goose/config.yaml` under a `slash_commands`
+ * array: `[{ command: "<name>", recipe_path: "<abs path to recipe.yaml>" }]`.
+ * (See goose-docs.ai context-engineering/slash-commands.)
+ *
+ * agents-cli writes each command's recipe to `<versionHome>/.config/goose/commands/
+ * <name>.yaml` — a dir distinct from the workflow recipes dir
+ * (`.config/goose/recipes/`) so the workflow detector never treats a command
+ * recipe as a workflow — and registers/unregisters the `slash_commands` entry in
+ * `config.yaml` via a read-modify-write that preserves every other key
+ * (`mcp_servers`, `extensions`, …). Under agents-cli version isolation HOME is the
+ * version home, so both files live under it and the absolute `recipe_path`
+ * resolves correctly at goose runtime.
+ */
+/** Directory holding Goose slash-command recipe YAML files in a version home. */
+export declare function gooseCommandsDir(versionHome: string): string;
+/** Path to the Goose config.yaml (holds the `slash_commands` registry) in a version home. */
+export declare function gooseCommandConfigPath(versionHome: string): string;
+/**
+ * Install a command into a Goose version home: write its recipe YAML and register
+ * the `slash_commands` entry in config.yaml.
+ */
+export declare function installGooseCommandToVersion(versionHome: string, commandName: string, sourcePath: string): {
+    success: boolean;
+    error?: string;
+};
+/** List Goose command names (recipe files) installed in a version home. */
+export declare function listGooseCommandsInVersion(versionHome: string): string[];
+/** Whether an installed Goose command recipe matches the central Markdown source. */
+export declare function gooseCommandMatches(versionHome: string, commandName: string, sourcePath: string): boolean;
+/**
+ * Remove a Goose command from a version home: soft-delete the recipe to `trashDir`
+ * (when provided) and unregister its `slash_commands` entry.
+ */
+export declare function removeGooseCommandFromVersion(versionHome: string, commandName: string, trashDir?: string): {
+    success: boolean;
+    error?: string;
+};

package/dist/lib/goose-commands.js

@@ -0,0 +1,176 @@
+/**
+ * Goose slash-command install/remove/list/compare.
+ *
+ * Goose has no native slash-command file format — a slash command is a recipe
+ * YAML file registered in `~/.config/goose/config.yaml` under a `slash_commands`
+ * array: `[{ command: "<name>", recipe_path: "<abs path to recipe.yaml>" }]`.
+ * (See goose-docs.ai context-engineering/slash-commands.)
+ *
+ * agents-cli writes each command's recipe to `<versionHome>/.config/goose/commands/
+ * <name>.yaml` — a dir distinct from the workflow recipes dir
+ * (`.config/goose/recipes/`) so the workflow detector never treats a command
+ * recipe as a workflow — and registers/unregisters the `slash_commands` entry in
+ * `config.yaml` via a read-modify-write that preserves every other key
+ * (`mcp_servers`, `extensions`, …). Under agents-cli version isolation HOME is the
+ * version home, so both files live under it and the absolute `recipe_path`
+ * resolves correctly at goose runtime.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { safeJoin } from './paths.js';
+import { markdownToGooseRecipe } from './convert.js';
+/** Directory holding Goose slash-command recipe YAML files in a version home. */
+export function gooseCommandsDir(versionHome) {
+    return path.join(versionHome, '.config', 'goose', 'commands');
+}
+/** Path to the Goose config.yaml (holds the `slash_commands` registry) in a version home. */
+export function gooseCommandConfigPath(versionHome) {
+    return path.join(versionHome, '.config', 'goose', 'config.yaml');
+}
+/**
+ * Read the goose config.yaml as a mutable object. Throws — rather than returning
+ * `{}` — when a NON-EMPTY file fails to parse or isn't a mapping, so the caller
+ * (which rewrites the whole file) never silently clobbers a real user config
+ * (`mcp_servers`, `GOOSE_MODEL`, `extensions`, …). A missing or genuinely empty
+ * file returns `{}`.
+ */
+function readGooseConfig(configPath) {
+    if (!fs.existsSync(configPath))
+        return {};
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    if (raw.trim() === '')
+        return {};
+    let parsed;
+    try {
+        parsed = yaml.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Refusing to rewrite goose config at ${configPath}: existing file is not valid YAML ` +
+            `(${err.message}). Fix or remove it, then re-sync.`);
+    }
+    if (parsed === null || parsed === undefined)
+        return {}; // comments/whitespace only
+    if (typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Refusing to rewrite goose config at ${configPath}: expected a YAML mapping but found ` +
+            `${Array.isArray(parsed) ? 'a list' : typeof parsed}.`);
+    }
+    return parsed;
+}
+function readSlashCommands(config) {
+    const raw = config.slash_commands;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((e) => !!e && typeof e === 'object' && typeof e.command === 'string');
+}
+/**
+ * Register (or update) a `slash_commands` entry for `commandName` pointing at
+ * `recipePath`, preserving every other config key and other entries. Idempotent.
+ */
+function registerSlashCommand(configPath, commandName, recipePath) {
+    const config = readGooseConfig(configPath);
+    const entries = readSlashCommands(config);
+    const existing = entries.find((e) => e.command === commandName);
+    if (existing && existing.recipe_path === recipePath)
+        return; // already current — no rewrite
+    const next = entries.filter((e) => e.command !== commandName);
+    next.push({ command: commandName, recipe_path: recipePath });
+    next.sort((a, b) => a.command.localeCompare(b.command));
+    config.slash_commands = next;
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+}
+/** Remove the `slash_commands` entry for `commandName`, preserving all other config. */
+function unregisterSlashCommand(configPath, commandName) {
+    if (!fs.existsSync(configPath))
+        return;
+    const config = readGooseConfig(configPath);
+    const entries = readSlashCommands(config);
+    if (!entries.some((e) => e.command === commandName))
+        return; // nothing to do
+    const next = entries.filter((e) => e.command !== commandName);
+    if (next.length > 0) {
+        config.slash_commands = next;
+    }
+    else {
+        delete config.slash_commands;
+    }
+    fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+}
+/** Serialize a Goose command recipe from a central Markdown command file. */
+function buildGooseCommandRecipe(commandName, sourcePath) {
+    const markdown = fs.readFileSync(sourcePath, 'utf-8');
+    return yaml.stringify(markdownToGooseRecipe(commandName, markdown));
+}
+/**
+ * Install a command into a Goose version home: write its recipe YAML and register
+ * the `slash_commands` entry in config.yaml.
+ */
+export function installGooseCommandToVersion(versionHome, commandName, sourcePath) {
+    try {
+        const dir = gooseCommandsDir(versionHome);
+        fs.mkdirSync(dir, { recursive: true });
+        const recipePath = safeJoin(dir, `${commandName}.yaml`);
+        fs.writeFileSync(recipePath, buildGooseCommandRecipe(commandName, sourcePath), 'utf-8');
+        registerSlashCommand(gooseCommandConfigPath(versionHome), commandName, recipePath);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+/** List Goose command names (recipe files) installed in a version home. */
+export function listGooseCommandsInVersion(versionHome) {
+    const dir = gooseCommandsDir(versionHome);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir)
+        .filter((f) => f.endsWith('.yaml'))
+        .map((f) => f.slice(0, -'.yaml'.length))
+        .sort();
+}
+/** Whether an installed Goose command recipe matches the central Markdown source. */
+export function gooseCommandMatches(versionHome, commandName, sourcePath) {
+    const recipePath = safeJoin(gooseCommandsDir(versionHome), `${commandName}.yaml`);
+    if (!fs.existsSync(recipePath) || !fs.existsSync(sourcePath))
+        return false;
+    try {
+        // The slash_commands entry must also be registered for the command to be live.
+        // (An unparseable config.yaml surfaces here as "not a match" → a re-sync, which
+        // fails loudly rather than clobbering, instead of a crash during a read-only diff.)
+        const registered = readSlashCommands(readGooseConfig(gooseCommandConfigPath(versionHome)))
+            .some((e) => e.command === commandName);
+        if (!registered)
+            return false;
+        const installed = fs.readFileSync(recipePath, 'utf-8').trim();
+        const expected = buildGooseCommandRecipe(commandName, sourcePath).trim();
+        return installed === expected;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove a Goose command from a version home: soft-delete the recipe to `trashDir`
+ * (when provided) and unregister its `slash_commands` entry.
+ */
+export function removeGooseCommandFromVersion(versionHome, commandName, trashDir) {
+    try {
+        const recipePath = safeJoin(gooseCommandsDir(versionHome), `${commandName}.yaml`);
+        if (fs.existsSync(recipePath)) {
+            if (trashDir) {
+                const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+                fs.mkdirSync(trashDir, { recursive: true, mode: 0o700 });
+                fs.renameSync(recipePath, path.join(trashDir, `${commandName}.yaml.${stamp}`));
+            }
+            else {
+                fs.unlinkSync(recipePath);
+            }
+        }
+        unregisterSlashCommand(gooseCommandConfigPath(versionHome), commandName);
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}

package/dist/lib/hooks.js

@@ -1006,6 +1006,9 @@ export function registerHooksToSettings(agentId, versionHome, hookManifest, agen
     if (agentId === 'cursor') {
         return registerHooksForCursor(versionHome, manifest, resolveScript, managedPrefixes);
     }
+    if (agentId === 'hermes') {
+        return registerHooksForHermes(versionHome, manifest, resolveScript, managedPrefixes);
+    }
     return { registered: [], errors: [] };
 }
 /**
@@ -2186,3 +2189,134 @@ function registerHooksForCursor(versionHome, manifest, resolveScript, managedPre
     }
     return { registered, errors };
 }
+/**
+ * Canonical → Hermes (Nous Research) snake_case lifecycle events.
+ *
+ * Hermes ≥ 0.11.0 runs configurable hooks declared under `hooks:` in
+ * ~/.hermes/config.yaml. Only events with a documented Hermes equivalent are
+ * mapped; unmapped canonical events (the manifest may declare events for other
+ * agents) are skipped silently. UserPromptSubmit maps to `pre_llm_call` (the
+ * closest pre-turn phase) and Stop to `on_session_finalize`.
+ */
+const HERMES_EVENT_MAP = {
+    SessionStart: 'on_session_start',
+    SessionEnd: 'on_session_end',
+    PreToolUse: 'pre_tool_call',
+    PostToolUse: 'post_tool_call',
+    SubagentStop: 'subagent_stop',
+    UserPromptSubmit: 'pre_llm_call',
+    Stop: 'on_session_finalize',
+};
+/** Hermes caps hook timeouts at 300s (default 60s). */
+const HERMES_TIMEOUT_CAP = 300;
+const HERMES_TIMEOUT_DEFAULT = 60;
+/**
+ * Register hooks for Hermes Agent (Nous Research ≥ 0.11.0).
+ *
+ * Read-modify-writes the shared `~/.hermes/config.yaml` (under the version
+ * home): it merges a `hooks:` block of the form
+ *   hooks: { <event>: [ { command, timeout, matcher? } ] }
+ * into the YAML doc WITHOUT touching sibling keys (`mcp_servers` in
+ * particular — a naive overwrite would wipe the user's MCP servers). No
+ * `version` wrapper: Hermes' config is a flat YAML map.
+ *
+ * GC: rewrite managed entries by command path under managedPrefixes; preserve
+ * user-authored entries whose command is outside managed roots. Keyed by
+ * event|command|matcher so a matcher or event change drops the stale entry.
+ */
+function registerHooksForHermes(versionHome, manifest, resolveScript, managedPrefixes) {
+    const registered = [];
+    const errors = [];
+    const configDir = path.join(versionHome, '.hermes');
+    const configPath = path.join(configDir, 'config.yaml');
+    // Read-modify-write: preserve the full existing YAML doc (mcp_servers, etc.).
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            const parsed = yaml.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                config = parsed;
+            }
+        }
+        catch {
+            errors.push('Failed to parse existing config.yaml');
+            return { registered, errors };
+        }
+    }
+    const existingHooks = config.hooks && typeof config.hooks === 'object' && !Array.isArray(config.hooks)
+        ? config.hooks
+        : {};
+    // Desired managed entries keyed by event|command|matcher so a matcher or
+    // event change drops the stale entry instead of retaining it by command alone.
+    const desiredManaged = new Set();
+    for (const [hookName, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const resolved = resolveHookCommand(hookName, hookDef, resolveScript);
+        if (!resolved)
+            continue;
+        for (const event of hookDef.events) {
+            const hermesEvent = HERMES_EVENT_MAP[event];
+            if (!hermesEvent)
+                continue;
+            desiredManaged.add(`${hermesEvent}|${resolved}|${hookDef.matcher ?? ''}`);
+        }
+    }
+    // GC managed entries that are no longer in the manifest; preserve user entries.
+    const hooks = {};
+    for (const [event, entries] of Object.entries(existingHooks)) {
+        if (!Array.isArray(entries))
+            continue;
+        hooks[event] = entries.filter((e) => {
+            if (typeof e?.command !== 'string')
+                return true;
+            if (!isManagedHookCommand(e.command, managedPrefixes))
+                return true;
+            return desiredManaged.has(`${event}|${e.command}|${e.matcher ?? ''}`);
+        });
+        if (hooks[event].length === 0)
+            delete hooks[event];
+    }
+    for (const [name, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const commandPath = resolveHookCommand(name, hookDef, resolveScript);
+        if (!commandPath) {
+            errors.push(`${name}: script not found in user or system hooks dir`);
+            continue;
+        }
+        const timeout = Math.min(HERMES_TIMEOUT_CAP, hookDef.timeout ?? HERMES_TIMEOUT_DEFAULT);
+        for (const event of hookDef.events) {
+            const hermesEvent = HERMES_EVENT_MAP[event];
+            if (!hermesEvent)
+                continue;
+            if (!hooks[hermesEvent])
+                hooks[hermesEvent] = [];
+            const entry = { command: commandPath, timeout };
+            if (hookDef.matcher)
+                entry.matcher = hookDef.matcher;
+            const existingIdx = hooks[hermesEvent].findIndex((h) => h.command === entry.command && (h.matcher ?? '') === (entry.matcher ?? ''));
+            if (existingIdx >= 0) {
+                hooks[hermesEvent][existingIdx] = entry;
+            }
+            else {
+                hooks[hermesEvent].push(entry);
+            }
+            registered.push(`${name} -> ${hermesEvent}`);
+        }
+    }
+    if (Object.keys(hooks).length > 0) {
+        config.hooks = hooks;
+    }
+    else {
+        delete config.hooks;
+    }
+    try {
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+    }
+    catch (err) {
+        errors.push(`Failed to write config.yaml: ${err.message}`);
+    }
+    return { registered, errors };
+}

package/dist/lib/hosts/credentials.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Credential provisioning for `agents run --host --copy-creds`.
+ *
+ * Reuses the lease flow's runtime detection + credential-script builder so a
+ * persistent host can boot logged-in the same way an ephemeral leased box does.
+ * Unlike `--lease`, a host is persistent, so copying tokens is strictly opt-in
+ * per run and we shred the files after the run to bound the credential window.
+ */
+import type { AgentId } from '../types.js';
+import { type DetectedRuntime } from '../crabbox/runtimes.js';
+export interface HostCredentials {
+    runtimes: AgentId[];
+    detected: DetectedRuntime[];
+    claudeCredentialsJson?: string | null;
+}
+/**
+ * Build the setup (write credential files) and teardown (shred them) scripts for
+ * a host run. Returns shell snippets meant to be run on the remote host.
+ */
+export declare function buildHostCredentialScript(opts: HostCredentials): {
+    setup: string;
+    teardown: string;
+};
+/**
+ * Wrap a remote command so credentials are written before it runs and shredded
+ * after it exits, regardless of success or failure.
+ */
+export declare function wrapHostCommandWithCredentials(innerCommand: string, opts: HostCredentials): string;

package/dist/lib/hosts/credentials.js

@@ -0,0 +1,48 @@
+/**
+ * Credential provisioning for `agents run --host --copy-creds`.
+ *
+ * Reuses the lease flow's runtime detection + credential-script builder so a
+ * persistent host can boot logged-in the same way an ephemeral leased box does.
+ * Unlike `--lease`, a host is persistent, so copying tokens is strictly opt-in
+ * per run and we shred the files after the run to bound the credential window.
+ */
+import { buildCredentialScript, CLAUDE_TOKEN_REMOTE } from '../crabbox/runtimes.js';
+function getShredPaths(runtimes) {
+    const pathsById = {
+        claude: ['.claude.json', CLAUDE_TOKEN_REMOTE],
+        codex: ['.codex/auth.json'],
+        gemini: ['.gemini/google_accounts.json'],
+        grok: ['.grok/auth.json'],
+    };
+    return runtimes.flatMap((id) => pathsById[id] ?? []);
+}
+/**
+ * Build the setup (write credential files) and teardown (shred them) scripts for
+ * a host run. Returns shell snippets meant to be run on the remote host.
+ */
+export function buildHostCredentialScript(opts) {
+    const setup = buildCredentialScript(opts.runtimes, opts.detected, {
+        claudeCredentialsJson: opts.claudeCredentialsJson,
+    });
+    const teardown = getShredPaths(opts.runtimes)
+        .map((p) => `rm -f "$HOME/${p}" 2>/dev/null || true`)
+        .join('\n');
+    return { setup, teardown };
+}
+/**
+ * Wrap a remote command so credentials are written before it runs and shredded
+ * after it exits, regardless of success or failure.
+ */
+export function wrapHostCommandWithCredentials(innerCommand, opts) {
+    const { setup, teardown } = buildHostCredentialScript(opts);
+    return [
+        'set -uo pipefail',
+        setup,
+        innerCommand,
+        'rc=$?',
+        teardown,
+        'exit $rc',
+    ]
+        .filter((l) => l.length > 0)
+        .join('\n');
+}

package/dist/lib/hosts/dispatch.d.ts

@@ -10,6 +10,7 @@
  */
 import type { Host } from './types.js';
 import { type HostTask } from './tasks.js';
+import { type HostCredentials } from './credentials.js';
 /**
  * Build a `cd <dir> && ` prefix that resolves on the REMOTE host.
  *
@@ -36,6 +37,26 @@ export interface DispatchResult {
 }
 /** Terminate a detached dispatch that its caller could not persist locally. */
 export declare function terminateDispatchedTask(task: HostTask): void;
+/**
+ * Build the remote shell used by {@link stopDispatchedTask}. Exported for
+ * unit tests — the keep-log / no-clobber contract lives in this script.
+ *
+ * Protocol (printed to stdout for the local caller):
+ * - `SIGNALED`  — process group was live; SIGTERM/KILL applied; wrote 143
+ * - `ALREADY` + code — group gone; adopted existing `.exit` (never overwrite)
+ * - `GONE` — group gone and no `.exit`; write 143 as the local stop outcome
+ * Exit 1 if the group is still alive after TERM/KILL (can't stop it).
+ */
+export declare function buildStopRemoteCommand(pid: number, remoteExit: string): string;
+/**
+ * Stop a running host task from the origin machine (`agents hosts stop <id>`).
+ *
+ * Unlike {@link terminateDispatchedTask} (rollback cleanup after a failed
+ * persist), this keeps the remote log so `agents hosts logs <id>` still works,
+ * writes a terminal `.exit` marker only when we actually stopped a live group
+ * (or no code existed), and never clobbers a real completed-run exit code.
+ */
+export declare function stopDispatchedTask(task: HostTask): HostTask;
 export interface DispatchOptions {
     agent: string;
     prompt: string;
@@ -76,6 +97,8 @@ export interface DispatchOptions {
     /** Stream progress and block until completion (default true). */
     follow?: boolean;
     timeoutMs?: number;
+    /** Copy runtime credentials to the host before the run and shred them after. */
+    copyCreds?: HostCredentials;
 }
 /**
  * Build the remote `agents run …` argv for a host dispatch. Pure so the
@@ -116,6 +139,8 @@ export interface InteractiveDispatchOptions {
     raw?: boolean;
     /** Forward `--interactive` to the remote so a prompt-bearing run still starts the TUI. */
     forceInteractive?: boolean;
+    /** Copy runtime credentials to the host before the run and shred them after. */
+    copyCreds?: HostCredentials;
 }
 /**
  * Build the remote `agents run …` argv for an INTERACTIVE host dispatch. The