@phnx-labs/agents-cli 1.22.39 → 1.22.41

package/dist/commands/projects.js

@@ -21,10 +21,11 @@ import { getActiveSessions } from '../lib/session/active.js';
 import { gatherRemoteActive } from '../lib/session/remote-active.js';
 import { gatherRemoteAgentsJson } from '../lib/remote-agents-json.js';
 import { formatFleetSummary, formatFleetWorkspaces, parseRemoteProbe, probeProjectWorkspaces, workspaceTargetsForDef, workspaceWarnings, } from '../lib/project-probe.js';
-import { listProjectDefs, loadProjectDef, writeProjectDef, removeProjectDef, projectDefPath, isSafeProjectName, validateProjectDef, projectNameForCwd, } from '../lib/projects.js';
+import { listProjectDefs, loadProjectDef, writeProjectDef, removeProjectDef, projectDefPath, isSafeProjectName, validateProjectDef, projectNameForCwd, projectRepoTargetsForDef, } from '../lib/projects.js';
+import { buildPullEnvelope, decodePullTargets, fingerprintTargets, pullLocalArgs, parseProjectPullEnvelope, printProjectPullSummary, projectPullComplete, pullProjectTargets, } from '../lib/project-pull.js';
 import { rollupSessionsByProject, withDefaultMachine, isDeadStatus, formatDeadSummary, liveDeadSplit, enrichProjectSignals, formatProjectMembersByHost, formatProjectWarnings, } from '../lib/project-status.js';
 import { fetchLinearProjectCounts } from '../lib/linear-project-counts.js';
-import { listLinearProjects, pickLinearProject } from '../lib/linear-projects.js';
+import { listLinearProjects, nextLinearLink, pickLinearProject } from '../lib/linear-projects.js';
 import { checkRepoSlug } from '../lib/project-doctor.js';
 import { formatFocusAreas, readFocusAreas } from '../lib/project-focus.js';
 import { formatVerdict, scheduleVerdict } from '../lib/project-schedule.js';
@@ -61,6 +62,23 @@ export function formatFleetSkippedNote(skipped) {
     const noun = skipped.length === 1 ? 'device' : 'devices';
     return chalk.gray(`  · ${skipped.length} ${noun} didn't answer (unreachable, older agents-cli, or timed out): ${list}\n`);
 }
+/**
+ * One compact trailing note for peers that DID answer a fan-out but whose
+ * payload failed verification — a wrong machine id, a fingerprint that doesn't
+ * match the targets we sent, or a malformed row. Deliberately separate from
+ * {@link formatFleetSkippedNote}: silence means a peer never ran, while this
+ * means it ran and we cannot trust what it reports, which is the worse state.
+ * Empty string when every answer verified.
+ */
+export function formatFleetUnverifiedNote(unverified) {
+    if (unverified.length === 0)
+        return '';
+    const named = unverified.slice(0, SKIPPED_NAME_LIMIT);
+    const rest = unverified.length - named.length;
+    const list = rest > 0 ? `${named.join(', ')} +${rest}` : named.join(', ');
+    const noun = unverified.length === 1 ? 'device' : 'devices';
+    return chalk.red(`  · ${unverified.length} ${noun} answered with a result that could not be verified: ${list}\n`);
+}
 /** `path:purpose` → a context anchor. Purpose may contain colons. */
 function parseContextFlag(raw) {
     const i = raw.indexOf(':');
@@ -616,8 +634,13 @@ export function registerProjectsCommands(program) {
         for (const ig of def.integrations ?? []) {
             console.log(`  ${chalk.dim(ig.kind.padEnd(8))} ${ig.url}${ig.label ? chalk.dim(`  (${ig.label})`) : ''}`);
         }
-        if (def.linear?.url || def.linear?.projectId)
-            console.log(`  ${chalk.dim('linear')}   ${def.linear.url ?? def.linear.projectId}`);
+        if (def.linear?.url || def.linear?.projectId || def.linear?.name) {
+            // Lead with the board's own name — the id/url answers "which project",
+            // but the name is what a reader (or an agent) calls the work.
+            const ref = def.linear.url ?? def.linear.projectId;
+            const label = def.linear.name ? chalk.cyan(def.linear.name) : '';
+            console.log(`  ${chalk.dim('linear')}   ${[label, ref && chalk.dim(ref)].filter(Boolean).join('  ')}`);
+        }
         for (const d of def.docs ?? [])
             console.log(`  ${chalk.dim('doc')}      ${d}`);
         console.log(chalk.gray(`  ${projectDefPath(name)}`));
@@ -789,6 +812,112 @@ export function registerProjectsCommands(program) {
         // and this command has no remote code path either way.
         console.log(JSON.stringify(probeProjectWorkspaces(paths ?? []), null, 2));
     });
+    // ---- pull-local (hidden; the peer half of `pull`) ----
+    projects
+        .command('pull-local', { hidden: true })
+        .description('Fast-forward workspace repos (default-branch only) and print JSON. Answers for this machine only.')
+        .requiredOption('--targets <json>', 'JSON array of {path, expectedSlug} targets, from the orchestrating `pull`')
+        .option('--json', 'Machine-readable output (the only output format)')
+        .action(async (opts) => {
+        // Never fans out — this is the peer half of the fleet fan-out.
+        //
+        // Targets arrive as {path, expectedSlug} PAIRS, not bare paths: the slug
+        // is what lets this machine refuse to fast-forward a directory hosting a
+        // different repo, and it is hashed into the fingerprint the caller
+        // verifies. Decoding failures exit non-zero so the caller records this
+        // peer as skipped instead of reading a missing answer as "nothing to do".
+        let targets;
+        try {
+            targets = decodePullTargets(opts.targets);
+        }
+        catch (err) {
+            console.error(chalk.red(`Invalid --targets: ${err.message}`));
+            process.exit(1);
+        }
+        const results = await pullProjectTargets(targets);
+        const envelope = buildPullEnvelope(results, targets);
+        console.log(JSON.stringify(envelope, null, 2));
+    });
+    // ---- pull ----
+    const pullCmd = projects
+        .command('pull <name>')
+        .description('Fast-forward every fleet checkout of a named project to its remote default branch.')
+        .option('--device <name...>', 'Scope fleet pull to one or more devices (repeatable)')
+        .option('--devices <names>', 'Scope fleet pull to a comma-separated list of devices')
+        .option('--json', 'Machine-readable output')
+        .action(async (name, rawOpts) => {
+        const def = loadProjectDef(name);
+        if (!def) {
+            console.error(chalk.red(`No project named "${name}". Create it: agents projects add ${name}`));
+            process.exit(1);
+        }
+        const targets = projectRepoTargetsForDef(def);
+        if (targets.length === 0) {
+            console.error(chalk.yellow(`Project "${name}" has no configured repositories.`));
+            process.exit(0);
+        }
+        const deviceFilter = resolveDeviceFilter(rawOpts.device, rawOpts.devices);
+        // Pull locally first.
+        const self = machineId();
+        const localResults = await pullProjectTargets(targets, self);
+        // Fan out to fleet peers. Send the full {path, expectedSlug} targets —
+        // bare paths would disable slug verification on every peer AND make the
+        // peer's fingerprint (which hashes the slug) unmatchable, so its whole
+        // answer would be discarded. Compute the fingerprint once so every peer
+        // envelope can be verified against the exact target set we sent.
+        const expectedFingerprint = fingerprintTargets(targets);
+        const remoteRes = await gatherRemoteAgentsJson({
+            args: pullLocalArgs(targets),
+            noFanoutEnv: PROJECTS_NO_FANOUT_ENV,
+            hosts: deviceFilter,
+            parse: (stdout, machine) => parseProjectPullEnvelope(stdout, machine, { expectedFingerprint }),
+            quiet: true,
+            timeoutMs: 120_000,
+        });
+        const allResults = [...localResults, ...remoteRes.items];
+        if (rawOpts.json) {
+            // Mirror `status --json`: peers that didn't answer, or answered
+            // unverifiably, go to stderr so a machine caller can still tell them
+            // apart from a device with nothing to report (the JSON array itself
+            // stays a clean result list).
+            if (remoteRes.skipped.length > 0)
+                process.stderr.write(formatFleetSkippedNote(remoteRes.skipped));
+            if (remoteRes.parseFailed.length > 0)
+                process.stderr.write(formatFleetUnverifiedNote(remoteRes.parseFailed));
+            console.log(JSON.stringify(allResults, null, 2));
+        }
+        else {
+            printProjectPullSummary(name, allResults, remoteRes.skipped, remoteRes.parseFailed);
+        }
+        // A peer whose answer could not be verified already ran a real pull whose
+        // outcome we cannot see — that is a failed pull, not a quiet success.
+        if (!projectPullComplete(allResults) || remoteRes.parseFailed.length > 0) {
+            process.exit(1);
+        }
+    });
+    setHelpSections(pullCmd, {
+        examples: `
+      agents projects pull rush                        # pull every checkout in the project
+      agents projects pull rush --device yosemite-s0  # scope to one device
+      agents projects pull rush --devices s0,s1       # scope to multiple devices
+      agents projects pull rush --json                # machine-readable results
+    `,
+        notes: `
+      Only checkouts on their remote's default branch are fast-forwarded. Dirty
+      trees, local commits ahead of upstream, or a wrong branch are blocked and
+      reported — never overwritten.
+
+      Each checkout is verified against the project's declared repo slug before
+      anything is fast-forwarded — on every device, not just this one. A path
+      hosting a different repo is blocked.
+
+      Checkouts absent on a device are skipped (never cloned). Blocked or failed
+      checkouts drive a non-zero exit; missing paths do not. A device that
+      answers with a result that cannot be verified is reported as unverified
+      and also drives a non-zero exit; a device that never answers is reported
+      as unavailable and does not.
+    `,
+    });
     // ---- import ----
     projects
         .command('import')
@@ -914,7 +1043,7 @@ export function registerProjectsCommands(program) {
     // ---- link ----
     projects
         .command('link <name>')
-        .description('Attach an external tracker to a project definition (writes linear.projectId into the YAML).')
+        .description('Attach an external tracker to a project definition (writes linear.projectId + name into the YAML; re-run to pick up a Linear rename).')
         .option('--linear [query]', 'Bind a Linear project by exact name or id; no value auto-suggests from the def name + repo')
         .action((name, opts) => {
         const def = loadProjectDef(name);
@@ -976,9 +1105,12 @@ export function registerProjectsCommands(program) {
         if (def.linear?.projectId && def.linear.projectId !== p.id) {
             console.log(chalk.gray(`  replacing previous Linear link (${def.linear.projectId})`));
         }
-        def.linear = { ...def.linear, projectId: p.id };
-        if (p.url)
-            def.linear.url = p.url;
+        if (def.linear?.name && def.linear.name !== p.name) {
+            console.log(chalk.gray(`  renaming "${def.linear.name}" → "${p.name}" (Linear is authoritative)`));
+        }
+        // Assigned, not spread over `def.linear`: a spread would resurrect a url
+        // that nextLinearLink deliberately dropped. The block has no other fields.
+        def.linear = nextLinearLink(def.linear, p);
         writeProjectDef(def);
         console.log(chalk.green(`${def.name} → Linear project "${p.name}" (${p.id})${p.url ? ` ${p.url}` : ''}`));
     });

package/dist/commands/prune.js

@@ -23,18 +23,19 @@
  */
 import * as fs from 'fs';
 import chalk from 'chalk';
+import { formatBytes } from '../lib/format.js';
 import { confirm } from '@inquirer/prompts';
 import { diffVersionCommands, iterCommandsCapableVersions, removeCommandFromVersion, } from '../lib/commands.js';
-import { diffVersionSkills, iterSkillsCapableVersions, removeSkillFromVersion, } from '../lib/skills.js';
+import { diffVersionSkills, iterSkillsCapableVersions, removeSkillFromVersion, } from '../lib/plugins/skills.js';
 import { listUnmanagedHooksInVersionHome, iterHooksCapableVersions, removeHookFromVersion, } from '../lib/hooks.js';
-import { diffVersionPlugins, iterPluginsCapableVersions, removePluginSkillFromVersion, } from '../lib/plugins.js';
+import { diffVersionPlugins, iterPluginsCapableVersions, removePluginSkillFromVersion, } from '../lib/plugins/plugins.js';
 import { diffVersionSubagents, iterSubagentsCapableVersions, removeSubagentFromVersion, } from '../lib/subagents.js';
-import { getGlobalDefault } from '../lib/versions.js';
+import { getGlobalDefault } from '../lib/installations/versions.js';
 import { resolveAgentName, formatAgentError } from '../lib/agents.js';
 import { pruneDuplicates } from './view.js';
 import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { getTrashDir } from '../lib/state.js';
-import { previewRunsPrune, pruneRuns, countAllRuns } from '../lib/routines.js';
+import { previewRunsPrune, pruneRuns, countAllRuns } from '../lib/scheduling/routines.js';
 const RESOURCE_TYPES = ['commands', 'skills', 'hooks', 'plugins', 'subagents'];
 const STATE_TYPES = ['trash', 'sessions', 'runs'];
 const ALL_TYPES = [...RESOURCE_TYPES, 'versions', ...STATE_TYPES];
@@ -128,15 +129,6 @@ function parseTarget(arg) {
     console.log(chalk.gray(formatAgentError(arg)));
     process.exit(1);
 }
-function formatBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    if (bytes < 1024 * 1024 * 1024)
-        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
 async function runTrashPrune(options) {
     const trashDir = getTrashDir();
     if (!fs.existsSync(trashDir)) {

package/dist/commands/refresh-rules.js

@@ -7,7 +7,7 @@
  */
 import chalk from 'chalk';
 import { AGENTS, resolveAgentName } from '../lib/agents.js';
-import { isVersionInstalled } from '../lib/versions.js';
+import { isVersionInstalled } from '../lib/installations/versions.js';
 import { ensureRulesFresh, supportsRulesImports } from '../lib/rules/compile.js';
 /**
  * Hidden command invoked by shims for agents that don't natively resolve

package/dist/commands/repo.d.ts

@@ -99,12 +99,10 @@ export declare function wrapPhrases(parts: string[], width: number): string[];
 export interface RepoStatusOptions {
     verbose?: boolean;
     json?: boolean;
-    /** Fan out across every reachable fleet device (`--devices-all`/`--hosts-all`). */
+    /** Fan out across every reachable fleet device (`--devices-all`). */
     devicesAll?: boolean;
-    hostsAll?: boolean;
-    /** `all`, or a comma-separated device list (`--devices`/`--hosts`). */
+    /** `all`, or a comma-separated device list (`--devices`). */
     devices?: string;
-    hosts?: string;
 }
 /**
  * Per-device repo status — the unit of the `--devices-all` fleet fan-out. One
@@ -146,9 +144,9 @@ type DeviceIntent = {
 };
 /**
  * Read the device-scope flags into an intent, or null for the default local-only
- * run. `--devices-all`/`--hosts-all` (and `--devices all`/`--hosts all`) sweep
- * every reachable peer; `--devices box1,box2` targets an explicit list. A peer
- * carrying {@link NO_REPO_FANOUT_ENV} never fans out again (recursion guard).
+ * run. `--devices-all` (and `--devices all`) sweeps every reachable peer;
+ * `--devices box1,box2` targets an explicit list. A peer carrying
+ * {@link NO_REPO_FANOUT_ENV} never fans out again (recursion guard).
  */
 export declare function resolveDeviceIntent(opts: RepoStatusOptions): DeviceIntent | null;
 /** Register the `agents repos` command tree (`repo` is a convenience alias). */

package/dist/commands/repo.js

@@ -34,8 +34,8 @@ import { DEFAULT_SYSTEM_REPO } from '../lib/types.js';
 import { ALL_AGENT_IDS, isAgentName, resolveAgentName } from '../lib/agents.js';
 import { refresh } from '../lib/refresh.js';
 import { capableAgents } from '../lib/capabilities.js';
-import { getGlobalDefault, getVersionHomePath, listInstalledVersions } from '../lib/versions.js';
-import { syncAllMarketplaces } from '../lib/plugin-marketplace.js';
+import { getGlobalDefault, getVersionHomePath, listInstalledVersions } from '../lib/installations/versions.js';
+import { syncAllMarketplaces } from '../lib/plugins/plugin-marketplace.js';
 import { gatherRemoteAgentsJson } from '../lib/remote-agents-json.js';
 import { machineId, normalizeHost } from '../lib/machine-id.js';
 /**
@@ -522,16 +522,16 @@ export function renderDeviceStatusRows(results) {
 }
 /**
  * Read the device-scope flags into an intent, or null for the default local-only
- * run. `--devices-all`/`--hosts-all` (and `--devices all`/`--hosts all`) sweep
- * every reachable peer; `--devices box1,box2` targets an explicit list. A peer
- * carrying {@link NO_REPO_FANOUT_ENV} never fans out again (recursion guard).
+ * run. `--devices-all` (and `--devices all`) sweeps every reachable peer;
+ * `--devices box1,box2` targets an explicit list. A peer carrying
+ * {@link NO_REPO_FANOUT_ENV} never fans out again (recursion guard).
  */
 export function resolveDeviceIntent(opts) {
     if (process.env[NO_REPO_FANOUT_ENV] === '1')
         return null;
-    if (opts.devicesAll || opts.hostsAll)
+    if (opts.devicesAll)
         return { all: true };
-    const val = opts.devices ?? opts.hosts;
+    const val = opts.devices;
     if (val === undefined)
         return null;
     const v = val.trim();
@@ -639,21 +639,19 @@ function formatRepoTarget(alias, dir, branch) {
 }
 /**
  * Register the fleet device-scope flags shared by `repo list` / `repo status`.
- * `--devices-all` (alias `--hosts-all`) sweeps every reachable device;
- * `--devices <who>` (alias `--hosts`) takes `all` or a comma-separated list.
- * A single `--host`/`--device` is handled upstream by maybeRunOnHost, which
- * streams that one box's `agents repo status` — these are the aggregating forms.
+ * `--devices-all` sweeps every reachable device; `--devices <who>` takes `all`
+ * or a comma-separated list. A single `--device` is handled upstream by
+ * maybeRunOnHost, which streams that one box's `agents repo status` — these are
+ * the aggregating forms.
  */
 function addDeviceStatusOptions(cmd) {
     return cmd
-        .option('--devices-all', 'Report repo sync state across ALL reachable fleet devices (alias: --hosts-all).')
-        .option('--hosts-all', 'Alias of --devices-all.')
-        .option('--devices <who>', 'Fleet devices to report on: "all", or a comma-separated device list (alias: --hosts).')
-        .option('--hosts <who>', 'Alias of --devices.');
+        .option('--devices-all', 'Report repo sync state across ALL reachable fleet devices.')
+        .option('--devices <who>', 'Fleet devices to report on: "all", or a comma-separated device list.');
 }
 /** Register the `agents repos` command tree (`repo` is a convenience alias). */
 export function registerRepoCommands(program) {
-    // addHostOption on the group so --help documents --host/--device; remote
+    // addHostOption on the group so --help documents --device; remote
     // routing is handled pre-parse by maybeRunOnHost (passthrough.ts).
     const repoCmd = addHostOption(program
         .command('repos')
@@ -968,7 +966,7 @@ export function registerRepoCommands(program) {
     });
     repoCmd
         .command('pull [alias] [url]')
-        .description('Pull updates. Aliases: "system" (~/.agents/.system/), "user" (~/.agents/), or any registered extra. No arg pulls all. Pass a git URL to git-back a not-yet-cloned user repo: "agents repo pull user <url>".')
+        .description('Pull updates and reconcile synced device decisions. Aliases: "system" (~/.agents/.system/), "user" (~/.agents/), or any registered extra. No arg pulls all. Pass a git URL to git-back a not-yet-cloned user repo: "agents repo pull user <url>".')
         .action(async (alias, url) => {
         const targets = collectRepoTargets(alias);
         if (!targets) {
@@ -980,6 +978,7 @@ export function registerRepoCommands(program) {
             return;
         }
         let anyPulled = false;
+        let userPulled = 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
@@ -1020,6 +1019,8 @@ export function registerRepoCommands(program) {
             if (result.success) {
                 spinner.succeed(`${formatRepoTarget(t.alias, t.dir, result.branch)}: ${result.commit}`);
                 anyPulled = true;
+                if (t.alias === 'user')
+                    userPulled = true;
             }
             else {
                 spinner.fail(`${formatRepoTarget(t.alias, t.dir)}: ${result.error}`);
@@ -1036,11 +1037,22 @@ export function registerRepoCommands(program) {
         // 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');
+            const { isDaemonRunning, signalDaemonReload } = await import('../lib/daemon/daemon.js');
             if (isDaemonRunning() && signalDaemonReload()) {
                 console.log(chalk.gray('Reloaded the routines daemon (device pins refreshed).'));
             }
         }
+        if (userPulled) {
+            const { reconcileDeviceDiscoveryPolicies } = await import('../lib/devices/discovery-policy.js');
+            const result = await reconcileDeviceDiscoveryPolicies();
+            const parts = [
+                result.registered.length ? `${result.registered.length} registered` : null,
+                result.ignored.length ? `${result.ignored.length} ignored` : null,
+                result.unresolved.length ? `${result.unresolved.length} approved but unavailable` : null,
+            ].filter(Boolean);
+            if (parts.length > 0)
+                console.log(chalk.gray(`Device policy: ${parts.join(' · ')}`));
+        }
     });
     repoCmd
         .command('push [alias]')
@@ -1123,6 +1135,10 @@ Examples:
             if (result.success) {
                 const pushed = result.pushed ? ' (pushed)' : '';
                 spinner.succeed(`${formatRepoTarget(t.alias, t.dir)}: ${result.commit}${pushed}`);
+                if (t.alias === 'user') {
+                    const { reconcileDeviceDiscoveryPolicies } = await import('../lib/devices/discovery-policy.js');
+                    await reconcileDeviceDiscoveryPolicies();
+                }
             }
             else {
                 spinner.fail(`${formatRepoTarget(t.alias, t.dir)}: ${result.error}`);

package/dist/commands/resource-view.js

@@ -42,6 +42,10 @@ export async function showResourceList(opts) {
             filter: (query) => filterRows(opts.rows, query),
             labelFor: (row) => formatPickerRow(row, opts),
             buildPreview: (row) => row.buildDetail(),
+            // Row numbers say where each entry sits in the list while scrolling —
+            // and read against the total when the caller prints one, as
+            // `agents inspect` does with its "commands (12)" header.
+            numbered: true,
             pageSize: 12,
             emptyMessage: `No matching ${opts.resourcePlural}.`,
             enterHint: 'view',

package/dist/commands/resume.d.ts

@@ -1,5 +1,4 @@
-import type { Command } from 'commander';
-interface ResumeOptions {
+export interface StrictResumeOptions {
     mode?: string;
     interactive?: boolean;
     headless?: boolean;
@@ -16,13 +15,18 @@ interface ResumeOptions {
  * on an older CLI (see the constant's docs). Every argv token here exists in the
  * released surface.
  */
-export declare function buildResumeRemoteArgs(sessionId: string, prompt: string | undefined, options: ResumeOptions): string[];
-/** Translate `agents resume <id>` to the canonical `agents run` surface after
+export declare function buildResumeRemoteArgs(sessionId: string, prompt: string | undefined, options: StrictResumeOptions): string[];
+/** Translate `agents sessions resume <id>` to the canonical `agents run` surface after
  * resolving the source identity. The run command remains the only executor. */
 export declare function buildResumeRunArgs(session: {
     id: string;
     agent: string;
     version?: string;
-}, prompt: string | undefined, options: ResumeOptions): string[];
-export declare function registerResumeCommand(program: Command): void;
-export {};
+}, prompt: string | undefined, options: StrictResumeOptions): string[];
+/** True when the caller asked for the strict resume path (prompt and/or flags). */
+export declare function wantsStrictResume(prompt: string | undefined, options: StrictResumeOptions): boolean;
+/**
+ * Strict single-session resume: resolve id/label across the fleet, hop to the
+ * owning device when needed, then delegate to `agents run --resume`.
+ */
+export declare function runStrictResume(sessionId: string, prompt: string | undefined, options: StrictResumeOptions): Promise<void>;