@stratusagent/cli 0.11.2 → 0.11.3

package/dist/index.d.ts

@@ -1,629 +1,36 @@
-import { type ApprovalContext, type ApprovalPolicy, type JsonValue, type Session, type StratusEvent, type TrustLevel } from '@stratusagent/core';
-import { type CredentialProviderName, type RuntimeSelection, type RuntimeConfig, type StratusConfigFile, type StratusProviderName } from '@stratusagent/state';
-import { type ServiceRunner } from './service.ts';
 export { installService, launchdPlist, readServiceCommand, readServiceStatus, servicePlatform, serviceUnitPath, startService, stopService, systemdUnit, uninstallService, SERVICE_LABEL, type ServiceRunner, type ServiceStatus, } from './service.ts';
 export { createLogWriter, currentLogPosition, truncateRedirectLogs, formatLogRecord, parseLogLines, readRecentRecords, tailLog, type LogRecord, } from './logs.ts';
 export { createFileMemoryStore } from '@stratusagent/state';
 export type { StoredCredential, RuntimeConfig } from '@stratusagent/state';
-export interface CliStreams {
-    stdout: Pick<typeof process.stdout, 'write'>;
-    stderr: Pick<typeof process.stderr, 'write'>;
-}
-export interface CliEnvironment {
-    stdin?: string;
-    stdinStream?: NodeJS.ReadableStream;
-    approvalInput?: NodeJS.ReadableStream;
-    setupInput?: NodeJS.ReadableStream;
-    processEnv?: NodeJS.ProcessEnv;
-    cwd?: string;
-    /** Home directory override (tests). Defaults to os.homedir(). */
-    homeDir?: string;
-    fetch?: typeof fetch;
-    openExternal?: (url: string) => Promise<void> | void;
-    dashboardAutoShutdownMs?: number;
-    /** Shuts down `stratus serve` the way SIGTERM would (tests). */
-    shutdownSignal?: AbortSignal;
-    /**
-     * Starts the fresh daemon an announced restart asks for and resolves
-     * with its exit code. Injected so tests never spawn a process; the
-     * default runs this CLI's own entrypoint with the serve arguments given.
-     */
-    serveRespawn?: (argv: string[], handoff: RestartHandoff) => Promise<RespawnResult>;
-    /**
-     * The link between a supervised daemon and its supervisor (tests): what
-     * the daemon sends up — the port it bound, the dashboard sessions it
-     * hands on — and what it receives. The default is the IPC channel a
-     * supervisor opens when it spawns a daemon, and does nothing where
-     * there is none.
-     */
-    supervisorLink?: SupervisorLink;
-    /** Ends the process at once (tests). Default `process.exit`. */
-    exitProcess?: (code: number) => void;
-    /** Runs launchctl/systemctl. Injected so tests never touch the real one. */
-    serviceRunner?: ServiceRunner;
-    /** Service-manager platform override (tests) — which unit format and manager commands apply. */
-    servicePlatform?: NodeJS.Platform;
-    /** Reports whether an optional package is installed. Injected so tests do not assert on their own node_modules. */
-    packageResolver?: PackageResolver;
-    /** Installs optional packages. Injected so tests never run npm. */
-    packageInstaller?: PackageInstaller;
-    /** Looks up a package's latest published version. Injected so tests never ask npm. */
-    packageVersionFetcher?: PackageVersionFetcher;
-}
-/**
- * A dashboard session as it crosses the restart hand-off: structurally the
- * control API's `DashboardSession`, declared here rather than imported.
- * That package is an optional peer, and a type import of it is kept in
- * this package's declarations — every TypeScript consumer of the CLI would
- * then need the optional package installed just to type-check.
- */
-export interface DashboardSession {
-    id: string;
-    /** Epoch milliseconds; a handed session keeps the expiry it was minted with. */
-    expiresAt: number;
-    /** A fingerprint of the bearer token it was minted under; the replacement adopts it only under the same one. */
-    vouchedBy: string;
-}
-/** What a daemon and its supervisor say to each other. See SupervisorLink. */
-export type SupervisorMessage = {
-    type: 'stratusd.bound-api-port';
-    port: number;
-} | {
-    type: 'stratusd.sessions';
-    sessions: DashboardSession[];
-};
-/** One end of the daemon–supervisor channel. */
-export interface SupervisorLink {
-    send(message: SupervisorMessage): void;
-    receive(handler: (message: SupervisorMessage) => void): void;
-}
-/**
- * What a supervisor hands the daemon it starts: the port its predecessor
- * bound (a hint, see BOUND_API_PORT_ENV) and the dashboard sessions the
- * predecessor had live when it stopped, so `stratus restart` does not log
- * a browser out. In memory end to end; nothing here is written down.
- */
-export interface RestartHandoff {
-    boundApiPort?: number;
-    sessions: DashboardSession[];
-}
-/** How a daemon the supervisor started ended, and what it handed back before it did. */
-export interface RespawnResult {
-    code: number;
-    boundApiPort?: number;
-    sessions?: DashboardSession[];
-}
-export interface PackageInstallResult {
-    ok: boolean;
-    /** Why it failed, as a line the operator can act on. Empty on success. */
-    message: string;
-}
-/** Installs optional packages globally. */
-export type PackageInstaller = (packages: string[]) => Promise<PackageInstallResult>;
-/** The latest published version of a package, or undefined when the registry did not answer. */
-export type PackageVersionFetcher = (packageName: string) => Promise<string | undefined>;
-/** How long `stratus update` waits for npm to answer a version lookup. */
-export declare const VERSION_LOOKUP_TIMEOUT_MS = 15000;
-/**
- * Dotted-numeric comparison, enough for this package's own versions:
- * positive when `a` is newer than `b`. Anything unparseable in a segment
- * counts as zero rather than throwing — a weird registry answer must not
- * crash the update that would fix things.
- */
-export declare const compareVersions: (a: string, b: string) => number;
-/**
- * Whether spawning npm needs a shell on this platform.
- *
- * On Windows npm is `npm.cmd`, a batch file: a bare `npm` does not exist as
- * an executable there (PATHEXT is a shell's job, not spawn's), and naming
- * the `.cmd` directly has thrown EINVAL since the fix for CVE-2024-27980 —
- * both land in the caller's error handler, so a Windows setup would report
- * that it could not install and leave Slack and the dashboard missing.
- *
- * Every package name reaching the shell is a constant in this file, so
- * there is nothing user-supplied here for it to re-parse.
- */
-export declare const npmNeedsShell: (platform: NodeJS.Platform) => boolean;
-export interface CliRunOptions {
-    argv: string[];
-    streams?: CliStreams;
-    env?: CliEnvironment;
-}
-export type CliProviderName = StratusProviderName;
-export type CliApprovalMode = 'always' | 'ask' | 'never';
-export interface ParsedRunCommand {
-    command: 'run';
-    prompt: string;
-    provider?: CliProviderName;
-    model?: string;
-    baseUrl?: string;
-    configPath?: string;
-    /** Path to a soul file defining the agent to run as. */
-    soul?: string;
-    format: 'text' | 'json';
-    events: boolean;
-    approvals: CliApprovalMode;
-    maxTurns?: number;
-}
-export interface ParsedDashboardCommand {
-    command: 'dashboard';
-    port?: number;
-    /**
-     * Present only when `--host` was actually given.
-     *
-     * A defaulted string here would be indistinguishable from an explicit
-     * `--host 127.0.0.1`, and the two mean opposite things when a trusted
-     * config says `api.host: "0.0.0.0"`: absent means "let the config decide",
-     * while explicit means "bind loopback, whatever the config says". Collapsing
-     * them exposed the API on every interface to an operator who had just asked
-     * for the opposite.
-     */
-    host?: string;
-    openBrowser: boolean;
-}
-export interface ParsedSetupCommand {
-    command: 'setup';
-    configPath?: string;
-}
-export interface ParsedAgentNewCommand {
-    command: 'agent-new';
-    name?: string;
-    instructions?: string;
-    format: 'text' | 'json' | 'soul';
-}
-export interface ParsedChatCommand {
-    command: 'chat';
-    provider?: CliProviderName;
-    model?: string;
-    baseUrl?: string;
-    configPath?: string;
-    /** Path to a soul file defining the agent to chat with. */
-    soul?: string;
-    events: boolean;
-    approvals: CliApprovalMode;
-    maxTurns?: number;
-}
-export interface ParsedSkillAddCommand {
-    command: 'skill-add';
-    /** A GitHub `owner/repo`, a git URL, or a local path. */
-    source: string;
-    /** Install only these ids (repeatable --skill). */
-    skillIds?: string[];
-    /** Replace an already-installed id instead of refusing it. */
-    force?: boolean;
-    /** Enable the installed skills in this agent's soul afterwards. */
-    agentId?: string;
-    /** Tell a running daemon to reload its skills afterwards. Default true; `--no-reload` sets false. */
-    reload?: boolean;
-}
-export interface ParsedSkillValidateCommand {
-    command: 'skill-validate';
-    /** A skill directory, a directory of skills, or an installed skill's id. */
-    target: string;
-}
-export interface ParsedSkillsCommand {
-    command: 'skills';
-}
-/**
- * What a credential name may be: the two conventions in use, and nothing
- * that would be awkward in a soul's `credentials:` list — `search.apiKey`
- * and environment-style `SLACK_TOKEN`. Leading letter required, which also
- * happens to exclude `__proto__`; the store does not *rely* on that (it
- * keys prototype-free maps), because a credentials file can be written by
- * something other than this command.
- */
-export declare const CREDENTIAL_NAME_PATTERN: RegExp;
-export interface ParsedCredentialCommand {
-    command: 'credential';
-    action: 'set' | 'list' | 'remove';
-    /** The credential name — `search.apiKey` and whatever the ecosystem asks for next. */
-    name?: string;
-    /** Store or remove this agent's own entry rather than the fleet's shared one. */
-    agentId?: string;
-}
-export interface ParsedSkillReloadCommand {
-    command: 'skill-reload';
-    /** A daemon's control API URL; default: the one `~/.stratus/gateway.json` names. */
-    gateway?: string;
-    token?: string;
-}
-export interface ParsedRestartCommand {
-    command: 'restart';
-    /** For the daemon's log. */
-    reason?: string;
-    /** How long the daemon lets in-flight turns finish, in milliseconds. */
-    drainTimeoutMs?: number;
-    gateway?: string;
-    token?: string;
-}
-export interface ParsedAgentsCommand {
-    command: 'agents';
-    format: 'text' | 'json';
-    /**
-     * Ask a running gateway instead of resolving locally. The first
-     * remote-consuming command: the same listing, rendered from the control
-     * API's answer rather than from this machine's files.
-     */
-    gateway?: string;
-    /** Bearer token override, for a gateway whose token file is not local. */
-    token?: string;
-}
-export interface ParsedSchedulesCommand {
-    command: 'schedules';
-    action: 'list' | 'cancel';
-    /** cancel only: which schedule. */
-    scheduleId?: string;
-    format: 'text' | 'json';
-}
-export interface ParsedMemoryCommand {
-    command: 'memory';
-    action: 'list' | 'reassert';
-    agentId: string;
-    /** list: show only entries at this label. reassert: the label to record. */
-    trust?: TrustLevel;
-    /** reassert: the entries to re-label, by id. */
-    ids: string[];
-    /** reassert: every live entry currently reading `unknown` — the upgrade case. */
-    allUnknown: boolean;
-    format: 'text' | 'json';
-}
-export interface ParsedSessionCommand {
-    command: 'session';
-    action: 'rollover';
-    sessionId: string;
-    gateway?: string;
-    token?: string;
-}
-export interface ParsedDoctorCommand {
-    command: 'doctor';
-    format: 'text' | 'json';
-    configPath?: string;
-}
-export interface ParsedUpdateCommand {
-    command: 'update';
-    /** Report what an update would do — version, migrations, unit health — without doing any of it. */
-    check: boolean;
-}
-export interface ParsedServiceCommand {
-    command: 'service';
-    action: 'install' | 'uninstall' | 'status' | 'start' | 'stop';
-    /** install only: start automatically at login. Defaults to true. */
-    runAtLogin?: boolean;
-    /** install only: the config the managed daemon should load. */
-    configPath?: string;
-}
-export interface ParsedLogsCommand {
-    command: 'logs';
-    /** Keep streaming new records instead of exiting after the backlog. */
-    follow: boolean;
-    /** How many recent records to show before following. */
-    limit: number;
-    agentId?: string;
-    sessionId?: string;
-    format: 'text' | 'json';
-}
-export type ServeApprovalMode = 'headless' | 'remote';
-export interface ParsedServeCommand {
-    command: 'serve';
-    configPath?: string;
-    /** Overrides `approvals.mode` in the config file. */
-    approvals?: ServeApprovalMode;
-    /** Watchdog idle timeout in milliseconds. 0 disables. */
-    idleTimeoutMs?: number;
-    events: boolean;
-    /** Write the structured log to ~/.stratus/logs. Defaults to true. */
-    logToFile?: boolean;
-    /** Serve the control API. Defaults to true when the package is installed. */
-    api?: boolean;
-    /** Overrides `api.port` in the config file. */
-    apiPort?: number;
-    /** Overrides `api.host` in the config file. */
-    apiHost?: string;
-}
-export interface ParsedHelpCommand {
-    command: 'help';
-}
-export type ParsedCommand = ParsedRunCommand | ParsedChatCommand | ParsedDashboardCommand | ParsedSetupCommand | ParsedAgentNewCommand | ParsedAgentsCommand | ParsedSkillAddCommand | ParsedSkillValidateCommand | ParsedSkillsCommand | ParsedSkillReloadCommand | ParsedCredentialCommand | ParsedRestartCommand | ParsedSchedulesCommand | ParsedMemoryCommand | ParsedSessionCommand | ParsedDoctorCommand | ParsedLogsCommand | ParsedUpdateCommand | ParsedServiceCommand | ParsedServeCommand | ParsedHelpCommand;
-export declare const CLI_VERSION = "0.11.2";
-/**
- * The range every package declares in its `engines` field. Two floors, not
- * one: `node:sqlite` was unflagged in 22.13.0 on the LTS line and in 23.4.0
- * on the 23.x line, so 23.0 through 23.3 are NEWER than the 22.x floor and
- * still ship it behind `--experimental-sqlite`. A plain `>=22.13` admits
- * exactly those releases.
- */
-export declare const SUPPORTED_NODE_RANGE = ">=22.13 <23 || >=23.4";
-/**
- * Why the CLI checks a version its manifests already declare: `engines` is
- * advisory. npm and pnpm print EBADENGINE and carry on unless the user has
- * turned on engine-strict, so an install on Node 20 succeeds and the floor
- * is discovered later as an ERR_UNKNOWN_BUILTIN_MODULE for `node:sqlite`,
- * thrown from a lazy import inside whichever command first needed the
- * session store. That error names neither Node nor the version required.
- *
- * Returns the message to print, or undefined when the version is fine —
- * including when it cannot be parsed at all, since an unrecognized build
- * string is a bad reason to refuse to run.
- */
-export declare const unsupportedNodeMessage: (version: string) => string | undefined;
-/**
- * The warning listeners to install in place of Node's default one, so the
- * `node:sqlite` ExperimentalWarning stops being the first thing the CLI
- * prints.
- *
- * The session store imports `node:sqlite`, which is experimental on every
- * Node release this supports — that is exactly why
- * {@link SUPPORTED_NODE_RANGE} is written the way it is — so the warning
- * announces a dependency the project chose deliberately and a user can do
- * nothing about. It landed above `stratusd ready` on every `stratus serve`,
- * and on `stratus schedules`.
- *
- * Filtered rather than silenced wholesale (`--no-warnings` would be the
- * blunt version): every other warning still reaches stderr through the
- * listeners passed in, because a deprecation in our own dependencies is
- * ours to act on.
- */
-export declare const withoutSqliteExperimentalWarning: (listeners: readonly ((warning: Error) => void)[]) => ((warning: Error) => void);
-/**
- * Swap Node's default warning printer for the filtered one above.
- *
- * Node installs its printer as an ordinary `warning` listener, so adding one
- * alongside it would print twice rather than filter; the default has to come
- * off and be handed to the replacement.
- *
- * **Only ever Node's own printer.** Wrapping a listener somebody else
- * registered changes it in two ways that are not ours to change: `listeners()`
- * hands back the *unwrapped* function for a `once` listener, so re-registering
- * it makes it permanent — it then runs for every later warning instead of one
- * — and a caller that keeps a reference can no longer `process.off('warning',
- * theirs)`, because what is registered is this wrapper. So when anything other
- * than the default is present — a `--require` preload, an embedding host — this
- * does nothing at all and the warning stays. A host that took an interest in
- * warnings owns them.
- *
- * Called once from the binary, before anything imports the session store.
- */
-export declare const filterSqliteExperimentalWarning: (process_?: NodeJS.EventEmitter) => void;
-declare const HELP_TEXT = "Stratus Agent CLI\n\nUsage:\n  stratus setup\n  stratus chat\n  stratus chat --soul ./examples/souls/ava.md\n  stratus run --prompt \"Use the demo tool\"\n  stratus run \"Say hello\"\n  ANTHROPIC_API_KEY=... stratus run --provider anthropic \"Say hello\"\n  stratus run --soul ./examples/souls/ava.md \"Say hello\"\n  echo \"Use the echo tool\" | stratus run --stdin\n  STRATUS_PROVIDER=openai OPENAI_API_KEY=... stratus run \"Say hello\"\n  stratus run --config ./stratus.config.json --provider openai \"Say hello\"\n  stratus agents\n  stratus agents --gateway http://127.0.0.1:4123\n  stratus skill add stratuslabs/skill-code-review\n  stratus skill add ./my-skills --skill code-review --agent ava\n  stratus skill validate ./my-skill\n  stratus skills\n  stratus skill reload\n  stratus restart\n  stratus schedules\n  stratus schedules cancel <id>\n  stratus memory list ava\n  stratus memory reassert ava --trust user --all-unknown\n  stratus session rollover slack:ava:T01ABCDEF:D07GHIJKL\n  printf %s \"$BRAVE_KEY\" | stratus credential set search.apiKey\n  stratus credentials\n  stratus doctor\n  stratus update\n  stratus update --check\n  stratus service install\n  stratus service status\n  stratus logs -f\n  stratus logs --agent ava -n 200\n  stratus dashboard\n  stratus dashboard --port 4123 --host 0.0.0.0 --no-open\n\nCommands:\n  setup            Menu-driven onboarding: pick a provider, sign in (Claude\n                   subscription or API key), create your agent, connect it to\n                   Slack, and test it \u2014 settings go to ~/.stratus/config.json,\n                   sign-ins and channel tokens to ~/.stratus/credentials.json\n                   (0600). Save & finish offers to install any optional\n                   package your answers imply (the Slack channel, the control\n                   API and dashboard) before it starts the daemon\n  chat             Talk with your agent \u2014 the conversation persists across turns\n                   and remembered facts accumulate; /exit or Ctrl+C to leave\n  run              Execute one local Stratus Agent session\n  serve            Run stratusd, the always-on gateway: durable sessions, the\n                   whole roster live at once (each agent on its own provider),\n                   delegation, and a watchdog \u2014 one per home (it refuses to\n                   start over a daemon already serving ~/.stratus), and\n                   Ctrl+C / SIGTERM drains cleanly\n                   (--idle-timeout <seconds>, --approvals <headless|remote>,\n                   --no-events, --no-log-file, --config <path>); everything it\n                   says is also written to ~/.stratus/logs, which\n                   \"stratus logs\" reads. With @stratusagent/control-api\n                   installed it also serves the HTTP + WebSocket control API\n                   on 127.0.0.1:4123 (--no-api, --api-host, --api-port, or\n                   the config file's \"api\" block)\n  service          Keep stratusd running under launchd (macOS) or systemd\n                   (Linux): install, uninstall, status, start, stop.\n                   Installing starts it now and at every login\n                   (--no-login installs without the login trigger,\n                   --config <path> pins the daemon to one config file)\n  logs             Read the daemon's log from any terminal: -f to follow,\n                   -n <count> for backlog, --agent / --session to filter,\n                   --format json for the raw records\n  skill add        Install skills from a GitHub repo (owner/repo or URL) or a\n                   local path into ~/.stratus/skills \u2014 whole directories, one\n                   per skill; works with skills published for other agents\n                   (skills.sh-style repos). Installed is not enabled: a soul\n                   opts in via skills:, or pass --agent <id> to enable now.\n                   --skill <id> picks from a multi-skill repo (repeatable),\n                   --force replaces an already-installed id. A skill that\n                   does not conform to the Agent Skills spec is refused,\n                   naming what is wrong; one that installs with caveats\n                   (fields another host owns, a bundled scripts/) says so.\n                   A running daemon reloads its skills afterwards, no\n                   restart (--no-reload skips that)\n  skill validate   Check a skill directory, a directory of skills, or an\n                   installed skill id against the Agent Skills spec \u2014 the\n                   same check \"skill add\" runs, so what validates installs.\n                   Exit 1 if anything would be refused\n  skills           List installed skills and which agents enable each\n                   (also: stratus skill list)\n  skill reload     Ask the running daemon to re-read ~/.stratus/skills \u2014 for a\n                   skill edited or removed by hand. A skill that will not\n                   load refuses the whole reload and the previous set keeps\n                   serving; nothing becomes reachable to an agent whose soul\n                   does not list it\n  restart          Ask the running daemon for an announced restart \u2014 what a\n                   plugin change needs: it refuses new turns, lets in-flight\n                   ones finish for up to --drain-timeout <seconds> (default\n                   30), then comes back with sessions, schedules, and\n                   channels intact, under the service manager or not\n  credential set   Store a named credential an agent can resolve \u2014 a search\n                   backend asks for search.apiKey. The value is read from\n                   stdin, never from a flag, so it stays out of your shell\n                   history: printf %s \"$KEY\" | stratus credential set\n                   search.apiKey. --agent <id> stores one agent's own key,\n                   which outranks the shared entry for that agent. Storing\n                   grants nothing: the soul still needs credentials: [name]\n  credentials      List stored credential names and which agents have their\n                   own \u2014 names only, never values (also: credential list)\n  credential remove\n                   Forget one (--agent <id> for that agent's own entry)\n  schedules        List every schedule the fleet has set \u2014 cadence, prompt,\n                   pre-authorized destination, next firing \u2014 straight from the\n                   daemon's database (--format json). \"stratus schedules\n                   cancel <id>\" stops the next firing and revokes the\n                   destination that was approved with it\n                   (also: stratus schedule list / schedule cancel <id>)\n  memory list      Show an agent's live memory with the trust label each\n                   entry carries \u2014 user, agent, unknown (no recorded origin,\n                   or written in a conversation with someone not configured\n                   as a principal), external (recorded after reading content\n                   from outside). --trust <level> filters; --format json\n  memory reassert  Re-label entries as an operator: stratus memory reassert\n                   <agent> --trust user <id>..., or --all-unknown for every\n                   entry with no recorded origin (the upgrade case; an\n                   entry recorded unknown \u2014 a stranger's message, a shell\n                   command \u2014 is left for you to name by id). Appends\n                   a record to ~/.stratus/memory.jsonl; a running daemon\n                   sees it on its next turn. The only way a label ever\n                   rises \u2014 no tool can do this\n  session rollover Start a conversation over under the same session id,\n                   archiving its transcript so far \u2014 for a long-lived\n                   session (a Slack DM) that predates provenance tracking\n                   and would otherwise write unknown forever. Asks the\n                   running daemon (--gateway, --token)\n  agent new        Create an agent identity (generates a human-ish name + avatar theme)\n  agents           List your agents: who they are, where their souls live, what\n                   they run on, what they remember (also: stratus agent list).\n                   --gateway <url> asks a running daemon instead of resolving\n                   locally, authenticating with ~/.stratus/gateway-token\n                   (override with --token or STRATUS_GATEWAY_TOKEN)\n  doctor           Show what a run would use right now \u2014 provider, model, soul \u2014\n                   and which file or environment variable decided each, then\n                   flag anything that would surprise you (--format json)\n  update           The whole upgrade dance, in the order that cannot lose\n                   data: stop stratusd, upgrade the package from npm, run\n                   pending state migrations, rewrite the service unit with\n                   current node/entrypoint paths, restart. --check reports\n                   what it would do without doing any of it (exits 1 when\n                   something is actionable). Works offline too \u2014 an\n                   unreachable npm skips the upgrade but still migrates and\n                   repairs the unit\n  dashboard        Open the web dashboard: finds a running daemon (or starts one),\n                   mints a single-use sign-in link, and opens your browser at it.\n                   Needs @stratusagent/control-api and @stratusagent/dashboard\n  help             Show this help message\n\nAgent options:\n  --name           Agent name (omit to have one generated)\n  --instructions   The agent's persona/instructions\n  --format         Output format for agent new: text, json, or soul (a ready-to-edit soul file)\n\nOptions:\n  --prompt, -p     Prompt to send to the local agent loop\n  --stdin          Read the prompt from stdin\n  --provider       Provider to use: anthropic, openai, codex, or demo\n  --model          Model name for real providers (anthropic default: claude-opus-5, openai default: gpt-4.1-mini, codex default: gpt-5.5)\n  --base-url       Override the provider API base URL\n  --soul           Run as the agent defined by a soul file (markdown + frontmatter, see examples/souls)\n  --config         Config file path (run: load settings from it, setup: write it)\n  --format         Output format: text or json (default: text)\n  --no-events      Hide event-by-event progress lines in text mode\n  --approvals      run/chat: tool approval mode \u2014 always, ask, or never (default: always)\n                   serve: how the daemon reaches a human \u2014 headless (refuse every\n                   gated call) or remote (ask in Slack). Default headless, or\n                   the config file's \"approvals.mode\"\n  --max-turns      Maximum provider turns per run (default: 8)\n  --port           dashboard: port for a daemon it starts (default: 4123)\n  --host           dashboard: host for a daemon it starts (default: 127.0.0.1)\n  --no-open        Do not open the browser automatically\n  --gateway        agents / skill reload / restart / session rollover: a running\n                   daemon's control API (all but agents default to the daemon\n                   ~/.stratus/gateway.json names)\n  --trust          memory list: show only this label; memory reassert: the\n                   label to record (user, agent, unknown, external)\n  --all-unknown    memory reassert: every live entry with no recorded origin\n  --token          Bearer token for --gateway (default: ~/.stratus/gateway-token)\n  --no-reload      skill add: install without reloading a running daemon\n  --reason         restart: why, for the daemon's log\n  --drain-timeout  restart: seconds the daemon lets in-flight turns finish\n                   before aborting them (default: 30)\n  --no-api         serve: do not serve the control API\n  --api            serve: serve it even where the config says api.enabled: false\n  --api-host       serve: control API interface (default: 127.0.0.1)\n  --api-port       serve: control API port (default: 4123, 0 for any free port)\n  --help, -h       Show this help message\n\nConfig file:\n  The CLI looks for ./stratus.config.json first, then a path from --config / STRATUS_CONFIG,\n  then the global ~/.stratus/config.json written by `stratus setup`.\n  A \"soul\" key (or STRATUS_SOUL) points at a soul file so every run uses that agent.\n\nPlugins (tools):\n  Capability is optional: install a package, then list it under \"plugins\" in a\n  TRUSTED config (--config, STRATUS_CONFIG, or ~/.stratus/config.json), keyed by\n  package name. A plugin runs inside this process, so an auto-discovered\n  project-local stratus.config.json may not enable one.\n\n    \"plugins\": {\n      \"@stratusagent/tool-fs\": { \"enabled\": true, \"roots\": [\"~/notes\"],\n                                 \"agents\": { \"ava\": { \"roots\": [\"~/work/ava\"] } } },\n      \"@stratusagent/tool-web\": { \"enabled\": true }\n    }\n\n  Available: @stratusagent/tool-fs (fs.read/list/search/write),\n  @stratusagent/tool-shell (shell.run), @stratusagent/tool-web (web.fetch),\n  @stratusagent/tool-browser (browser.goto/read/screenshot/act).\n  Installing one grants no agent anything \u2014 each soul lists what it may call.\n\nSoul files:\n  A soul file is markdown with frontmatter (name, provider, model, tools, skills, credentials)\n  followed by the agent's persona in prose. See examples/souls/ava.md.\n  \"tools\" takes exact names or a whole toolset: tools: [fs.read, fs.search] or\n  tools: [fs.*]. Omitted means every registered tool.\n  \"skills\" is the same allowlist shape over installed skills (see stratus\n  skills), except omitted means none \u2014 a skill is enabled per agent, never\n  by being installed.\n";
-declare const stringifyValue: (value: JsonValue) => string;
-export declare const parseCommand: (argv: string[], env?: CliEnvironment) => ParsedCommand;
-export declare const formatEvent: (event: StratusEvent) => string | null;
-/**
- * The fields worth keeping per event type. Tool inputs and message text
- * are deliberately excluded: the log is a trace of what happened, not a
- * second copy of the transcript.
- *
- * The approval pair is the one place the trace carries a person's id, and
- * it earns it: `always` widens what an agent may do unattended for the rest
- * of the session, and "who decided that" is unanswerable afterwards from
- * anything else. The refusal path is warned about by `onDecision`, but an
- * *approval* produces no warning at all — without these two records a
- * granted permission leaves no trace whatsoever. Still no tool input: what
- * was asked is here, what it was asked with is not.
- */
-export declare const eventDetail: (event: StratusEvent) => Record<string, unknown> | undefined;
-/**
- * Kept with its historical CLI signature: a parsed run command is a
- * RuntimeSelection plus CLI-only fields the resolver ignores.
- *
- * Those fields are *permitted*, not required. Demanding a whole
- * `ParsedRunCommand` made the type claim the resolver cared about
- * `approvals`, `format`, and `events` — it reads none of them — so every
- * caller with a selection in hand had to invent values to get past it.
- */
-export declare const resolveRuntimeConfig: (command: RuntimeSelection & Partial<Omit<ParsedRunCommand, keyof RuntimeSelection>>, env?: CliEnvironment) => Promise<RuntimeConfig>;
-/**
- * A saved subscription sign-in silently demoted to per-token billing is the
- * one config surprise that costs money — an API key in the environment
- * outranks the stored credential, and the run otherwise looks identical.
- * Detected from the resolved config: an apiKey where the stored credential
- * is a subscription token means the environment won.
- */
-export declare const warnOnCredentialOverride: (runtime: RuntimeConfig, streams: CliStreams, env?: CliEnvironment) => Promise<void>;
-/**
- * What a local prompt asks about: the tool, where it would act when that is
- * a question at all, and the arguments.
- *
- * The origin is not in the arguments and cannot be — a `browser.act` call
- * carries a CSS selector, and `#submit` is equally "load more results" and
- * "confirm purchase". A prompt that showed only the selector would be
- * asking someone to authorize an effect whose location it withheld, which
- * is the same reason the daemon's prompt and the Slack request name it.
- */
-export declare const describeApprovalCall: (context: ApprovalContext) => string;
-export declare const createApprovalPolicy: (mode: CliApprovalMode, streams: CliStreams, env: CliEnvironment, ask?: (prompt: string) => Promise<string>) => ApprovalPolicy;
-export declare const runSingleLoop: (prompt: string, streams: CliStreams, options: {
-    events?: boolean;
-    runtime: RuntimeConfig;
-    approvals?: CliApprovalMode;
-    maxTurns?: number;
-    env?: CliEnvironment;
-    configPath?: string;
-}) => Promise<Session>;
-export declare const printSessionSummary: (session: Session, streams: CliStreams) => void;
-export declare const runChat: (command: ParsedChatCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-export declare const openExternalUrl: (url: string) => Promise<void>;
-export declare const slackAppManifest: (agentName: string) => string;
-export declare const runSetup: (command: ParsedSetupCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-export declare const runAgents: (command: ParsedAgentsCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/** One resolved setting, with the thing that decided it. */
-interface DoctorSetting {
-    value: string;
-    source: string;
-}
-export interface DoctorReport {
-    configInUse?: string;
-    /** Config files that exist but lost to `configInUse`, nearest first. */
-    configShadowed: string[];
-    provider: DoctorSetting;
-    model?: DoctorSetting;
-    soul?: DoctorSetting;
-    agent?: string;
-    /** The model a failing run retries on, when one is configured. */
-    fallback?: {
-        provider: string;
-        model: string;
-    };
-    signIns: Array<{
-        provider: CredentialProviderName;
-        status: string;
-    }>;
-    slackAgents: string[];
-    slackPackageInstalled: boolean;
-    rosterCount: number;
-    problems: string[];
-}
-/**
- * `stratus doctor` — what a run would resolve to right now, and which file
- * or variable decided each part. Every "why is it using X" question needs
- * the precedence chain, and reading it out of the source is not something
- * anyone should have to do.
- */
-export declare const collectDoctorReport: (command: ParsedDoctorCommand, warn: (message: string) => void, env?: CliEnvironment) => Promise<DoctorReport>;
-export declare const runDoctor: (command: ParsedDoctorCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/**
- * `stratus logs` — the daemon's structured log, filtered. `serve` streams
- * to its own stdout, which is gone the moment it runs under a service
- * manager; this reads the file it also writes, from any terminal.
- */
-export declare const runLogs: (command: ParsedLogsCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/**
- * `stratus service` — run the daemon under launchd or systemd, so it
- * survives logout, crashes, and reboots. `serve` itself stays a plain
- * foreground process; this only tells the platform how to keep it up.
- */
-export declare const runService: (command: ParsedServiceCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-export declare const runSkillAdd: (command: ParsedSkillAddCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/**
- * List and cancel what the fleet has scheduled — against the daemon's own
- * database, the way `stratus logs` reads the daemon's own log. WAL makes a
- * second process on the file routine; a running daemon re-reads due rows
- * every tick and the destination grant on every send, so a cancel from
- * here takes effect without asking it anything.
- */
-export declare const runSchedules: (command: ParsedSchedulesCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/**
- * `stratus credential set|list|remove`: the place a named credential goes.
- *
- * A credential nobody can add is a credential nobody has, which is why this
- * exists at all — a search backend asks for `search.apiKey` and until now
- * there was nowhere to put one. Three rules it keeps, all of them
- * deliberate:
- *
- * The value is read from **stdin, never from a flag**. A secret in argv is
- * a secret in shell history and in every `ps` on the machine.
- *
- * Nothing here ever prints a value back. `list` reports names and which
- * agents have their own, the same posture the control API's credential read
- * already keeps.
- *
- * And storing one grants no agent anything: the agent's soul still has to
- * list the name under `credentials:`, which is the per-identity gate.
- */
-export declare const runCredential: (command: ParsedCredentialCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/**
- * `stratus skill validate <target>`: the install-time check, run without
- * installing — for an author about to publish a skill, or an operator
- * asking why one was refused. A local path is a skill directory or a
- * directory of skills, discovered exactly as `skill add` would; a bare id
- * names an installed skill under `~/.stratus/skills/`. Exit 1 when
- * anything would be refused, so a publish step can gate on it.
- */
-export declare const runSkillValidate: (command: ParsedSkillValidateCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-export declare const runSkillReload: (command: ParsedSkillReloadCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/**
- * `stratus memory list|reassert` — the operator's half of provenance.
- *
- * `list` shows what an agent's store holds with the label each entry
- * carries, because an operator cannot re-assert what they cannot see.
- * `reassert` is the one way a label ever rises: it appends a re-assertion
- * record to the JSONL (never rewrites a line), so a running daemon — which
- * re-reads the file on every read — sees it at once. Operator only, on
- * purpose: no tool exposes this, because an agent re-labelling its own
- * memory as trusted is the attack writing its own permission slip.
- *
- * `--all-unknown` exists for the upgrade: every entry written before labels
- * existed reads `unknown`, and the injected slice of such a store makes
- * every session `unknown` on its first turn. Re-asserting the entries the
- * agent actually surfaces, once, is the bounded work that drains it.
- */
-export declare const runMemory: (command: ParsedMemoryCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/**
- * `stratus session rollover <id>` — start a conversation over under the
- * same id, archiving its transcript so far. The daemon does the work, on
- * the session's own chain, so a turn cannot interleave; this only asks.
- */
-export declare const runSessionRollover: (command: ParsedSessionCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-export declare const runRestart: (command: ParsedRestartCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-export declare const runSkills: (streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/**
- * The provider/model a newly created soul pins. Frontmatter pins what a run
- * from this directory would actually use: env vars outrank the active
- * config file (project-local or explicit first, global otherwise), and no
- * provider anywhere falls back to demo — the exact precedence of stratus
- * run. Demo produces no model at all: the soul keeps following the
- * machine's configuration instead of demanding credentials nothing has
- * signed in for. The active config's model was written for the provider
- * named in that config, so it only travels into the soul when they still
- * match; otherwise the selected provider's own default model stands in.
- *
- * Exported for tests: the interactive path that consumes it needs a TTY.
- */
-export declare const soulPinForNewAgent: (activeConfig: StratusConfigFile, processEnv: NodeJS.ProcessEnv) => {
-    provider: StratusProviderName;
-    model?: string;
-};
-export declare const runAgentNew: (command: ParsedAgentNewCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/**
- * `stratus dashboard` — open the web UI against a running daemon, starting
- * one in the foreground when there is none.
- *
- * The daemon is started by calling `runServe`, not by rebuilding its wiring:
- * channels, approvals, the credential preflight, and the log writer are all
- * decisions `serve` already makes, and a second copy of them here would drift
- * the first time either side gained a rule.
- */
-export declare const runDashboard: (command: ParsedDashboardCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-/** Reports whether an optional package is installed. */
-export type PackageResolver = (specifier: string) => boolean;
-/**
- * `stratus serve` — run the gateway (stratusd) in the foreground: load the
- * roster, accept dispatches, print events, and drain cleanly on SIGTERM,
- * SIGINT, or the injected shutdown signal.
- */
-/**
- * What a daemon exits with to ask for a fresh process. Only ever seen by the
- * supervisor below, which is the only thing that starts a daemon with the
- * environment marker that makes it exit this way instead of supervising.
- */
-export declare const RESTART_EXIT_CODE = 75;
-/**
- * What a daemon exits with when a restart could not drain — a turn that
- * ignored its abort, a plugin or channel that did not let go. Distinct from
- * the restart status on purpose: the supervisor answers this one by
- * exiting with it too, so the process the service manager started ends
- * and the manager restarts the whole unit — under systemd, cleaning the
- * cgroup of whatever the plugin left running. A supervisor that started
- * another daemon instead would keep that cgroup, and its leaks, alive.
- */
-export declare const UNDRAINED_RESTART_EXIT_CODE = 76;
-/**
- * The parsed serve command as arguments again — what the fresh daemon is
- * started with. From the command, not from `process.argv`: `stratus
- * dashboard` runs the daemon through `runServe` with a command it built,
- * and the process's own arguments would start a second dashboard.
- */
-export declare const serveArgv: (command: ParsedServeCommand) => string[];
-/**
- * The `bin` beside the module at `moduleUrl`, with that module's own
- * extension: `dist/index.js` respawns `dist/bin.js`, and a source checkout
- * running `src/index.ts` under type stripping respawns `src/bin.ts` — the
- * flags that made that possible travel in `process.execArgv`. Assuming
- * compiled output would hand a source checkout a file that does not exist,
- * and a daemon that never comes back.
- */
-export declare const restartEntrypoint: (moduleUrl: string) => string;
-export declare const runServe: (command: ParsedServeCommand, streams: CliStreams, env?: CliEnvironment) => Promise<number>;
-export declare const runCli: ({ argv, streams, env }: CliRunOptions) => Promise<number>;
-export { HELP_TEXT, stringifyValue };
+export { type CliStreams, type CliEnvironment, type DashboardSession, type SupervisorMessage, type SupervisorLink, type RestartHandoff, type RespawnResult, type PackageInstallResult, type PackageInstaller, type PackageVersionFetcher, type PackageResolver, } from './environment.ts';
+export { SUPPORTED_NODE_RANGE, unsupportedNodeMessage, withoutSqliteExperimentalWarning, filterSqliteExperimentalWarning, } from './preflight.ts';
+export { VERSION_LOOKUP_TIMEOUT_MS, compareVersions, npmNeedsShell, isPackageName, isInstallableSpecifier, CLI_VERSION, } from './npm.ts';
+export { stringifyValue } from './io.ts';
+export { HELP_TEXT } from './help.ts';
+export { type CliProviderName, type CliApprovalMode, type ParsedRunCommand, type ParsedDashboardCommand, type ParsedSetupCommand, type ParsedAgentNewCommand, type ParsedChatCommand, type ParsedTemplateAddCommand, type ParsedSkillAddCommand, type ParsedSkillValidateCommand, type ParsedPluginsCommand, type ParsedSkillsCommand, CREDENTIAL_NAME_PATTERN, type ParsedCredentialCommand, type ParsedSkillReloadCommand, type ParsedRestartCommand, type ParsedAgentsCommand, type ParsedSchedulesCommand, type ParsedGrantsCommand, type ParsedMemoryCommand, type ParsedSessionCommand, type ParsedDoctorCommand, type ParsedUpdateCommand, type ParsedServiceCommand, type ParsedLogsCommand, type ServeApprovalMode, type ParsedServeCommand, type ParsedHelpCommand, type ParsedCommand, parseCommand, } from './parse.ts';
+export { formatEvent, eventDetail } from './events.ts';
+export { describeApprovalCall, createApprovalPolicy } from './approvals.ts';
+export { resolveRuntimeConfig, warnOnCredentialOverride, runSingleLoop, printSessionSummary, } from './runtime.ts';
+export { menuPrefixWidth } from './prompter.ts';
+export { slackAppManifest } from './slack.ts';
+export { RESTART_EXIT_CODE, UNDRAINED_RESTART_EXIT_CODE, serveArgv, restartEntrypoint, } from './supervisor.ts';
+export { runChat } from './commands/chat.ts';
+export { runSetup } from './commands/setup.ts';
+export { runAgents } from './commands/agents.ts';
+export { type DoctorReport, collectDoctorReport, runDoctor } from './commands/doctor.ts';
+export { runLogs } from './commands/logs.ts';
+export { runService } from './commands/service.ts';
+export { runTemplateAdd } from './commands/template.ts';
+export { runSkillAdd, runSkillValidate, runSkillReload, runSkills } from './commands/skills.ts';
+export { type PluginToolReport, type PluginReport, type PluginsReport, collectPluginsReport, runPlugins, } from './commands/plugins.ts';
+export { runGrants } from './commands/grants.ts';
+export { runSchedules } from './commands/schedules.ts';
+export { runCredential } from './commands/credential.ts';
+export { runMemory } from './commands/memory.ts';
+export { runSessionRollover } from './commands/session.ts';
+export { runRestart } from './commands/restart.ts';
+export { soulPinForNewAgent, runAgentNew } from './commands/agent-new.ts';
+export { openExternalUrl, runDashboard } from './commands/dashboard.ts';
+export { runServe } from './commands/serve.ts';
+export { type CliRunOptions, runCli } from './main.ts';
 //# sourceMappingURL=index.d.ts.map