@prometheus-ai/agent 0.5.3 → 0.5.8

package/dist/types/stt/asr-client.d.ts

@@ -0,0 +1,90 @@
+import type { Subprocess } from "bun";
+import type { SttProgressEvent, SttWorkerInbound, SttWorkerOutbound } from "./asr-protocol";
+import type { SttModelKey } from "./models";
+/**
+ * Abstraction over the speech-recognition subprocess. Modelled as a worker
+ * interface so the parent composes lifecycle, ping/pong, and request/response
+ * correlation uniformly; the runtime implementation is a Bun child process so
+ * `onnxruntime-node`'s NAPI finalizer never runs inside the main agent address
+ * space — that destructor segfaults Bun on shutdown (issue #1606).
+ */
+interface WorkerHandle {
+    send(message: SttWorkerInbound): void;
+    onMessage(handler: (message: SttWorkerOutbound) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    terminate(): Promise<void>;
+}
+export interface SttTranscribeOptions {
+    language?: string;
+    signal?: AbortSignal;
+}
+export interface SttDownloadOptions {
+    signal?: AbortSignal;
+    onProgress?: (event: SttProgressEvent) => void;
+}
+/** Live streaming session handle returned by {@link SttClient.startStream}. */
+export interface SttStreamHandle {
+    /** Feed 16 kHz mono float samples as the recorder produces them. */
+    pushAudio(audio: Float32Array): void;
+    /** Flush the trailing segment and resolve with the full joined transcript. */
+    stop(): Promise<string>;
+    /** Tear the session down without a final flush (resolves `stop()` with ""). */
+    cancel(): void;
+}
+export interface SttStreamOptions {
+    language?: string;
+    signal?: AbortSignal;
+    /** Volatile transcript of the in-progress segment, refreshed as audio arrives. */
+    onPartial?: (text: string) => void;
+    /** A finalized segment, emitted once when the endpointer commits it. */
+    onSegment?: (text: string, index: number) => void;
+}
+/**
+ * Hidden subcommand on the main CLI that boots the speech-recognition worker in
+ * the spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
+ */
+export declare const STT_WORKER_ARG = "__prometheus_stt_worker";
+interface SpawnedSubprocess {
+    proc: Subprocess<"ignore", "ignore", "ignore">;
+    inbound: Set<(message: SttWorkerOutbound) => void>;
+    errors: Set<(error: Error) => void>;
+    /**
+     * Flipped to `true` right before the parent SIGKILLs the child so `onExit`
+     * can distinguish the expected hard-kill from a crash/OOM/external signal.
+     */
+    intentionalExit: {
+        value: boolean;
+    };
+}
+/**
+ * Spawn the speech worker as a subprocess. Exported for tests and the smoke
+ * probe; production callers go through {@link spawnSttWorker}.
+ */
+export declare function createSttSubprocess(): SpawnedSubprocess;
+export declare class SttClient {
+    #private;
+    constructor(spawnWorker?: () => WorkerHandle);
+    onProgress(listener: (event: SttProgressEvent) => void): () => void;
+    /**
+     * Transcribe 16 kHz mono audio on the warm worker. Rejects with the worker
+     * error on failure and with an `AbortError` when the signal fires (the warm
+     * worker keeps the model loaded across calls — the model is never reloaded).
+     */
+    transcribe(modelKey: SttModelKey, audio: Float32Array, options?: SttTranscribeOptions): Promise<string>;
+    /**
+     * Open a live streaming session on the warm worker. Audio fed through the
+     * returned handle is segmented by the worker's endpointer: `onSegment` fires
+     * once per committed segment and `onPartial` for the volatile in-progress
+     * preview. `stop()` resolves with the full joined transcript; `cancel()` (or
+     * an aborted signal) tears the session down and resolves `stop()` with "".
+     */
+    startStream(modelKey: SttModelKey, options?: SttStreamOptions): SttStreamHandle;
+    downloadModel(modelKey: SttModelKey, options?: SttDownloadOptions): Promise<boolean>;
+    terminate(): Promise<void>;
+}
+export declare const sttClient: SttClient;
+export declare function shutdownSttClient(): Promise<void>;
+export declare function smokeTestSttWorker({ timeoutMs, }?: {
+    timeoutMs?: number;
+}): Promise<void>;
+export {};

package/dist/types/stt/asr-protocol.d.ts

@@ -0,0 +1,97 @@
+import type { SttModelKey } from "./models";
+export type SttProgressStatus = "initiate" | "download" | "progress" | "progress_total" | "done" | "ready" | "error";
+export interface SttProgressFileState {
+    loaded: number;
+    total: number;
+}
+export interface SttProgressEvent {
+    modelKey: SttModelKey;
+    status: SttProgressStatus;
+    name?: string;
+    file?: string;
+    progress?: number;
+    loaded?: number;
+    total?: number;
+    files?: Record<string, SttProgressFileState>;
+    task?: string;
+    model?: string;
+}
+export type SttWorkerInbound = {
+    type: "ping";
+    id: string;
+} | {
+    type: "transcribe";
+    id: string;
+    modelKey: SttModelKey;
+    audio: Float32Array;
+    language?: string;
+} | {
+    type: "download";
+    id: string;
+    modelKey: SttModelKey;
+} | {
+    type: "stream_start";
+    id: string;
+    modelKey: SttModelKey;
+    language?: string;
+} | {
+    type: "stream_audio";
+    id: string;
+    audio: Float32Array;
+} | {
+    type: "stream_stop";
+    id: string;
+} | {
+    type: "stream_cancel";
+    id: string;
+};
+export type SttWorkerOutbound = {
+    type: "pong";
+    id: string;
+} | {
+    type: "transcription";
+    id: string;
+    text: string;
+} | {
+    type: "downloaded";
+    id: string;
+} | {
+    type: "error";
+    id: string;
+    error: string;
+} | {
+    type: "progress";
+    id: string;
+    event: SttProgressEvent;
+} | {
+    type: "log";
+    level: "debug" | "warn" | "error";
+    msg: string;
+    meta?: Record<string, unknown>;
+} | {
+    type: "partial";
+    id: string;
+    text: string;
+} | {
+    type: "segment";
+    id: string;
+    index: number;
+    text: string;
+} | {
+    type: "stream_done";
+    id: string;
+    text: string;
+};
+/**
+ * Wire transport between the parent (`SttClient`) and the speech-recognition
+ * subprocess. The parent owns the subprocess lifecycle (graceful work, hard
+ * SIGKILL on shutdown); the protocol therefore carries no explicit close
+ * handshake — once the parent decides to terminate, it signals the OS to reap
+ * the child so `onnxruntime-node`'s NAPI finalizer never runs in any shared
+ * address space (the destructor segfaults Bun on shutdown; issue #1606). See
+ * `asr-client.ts` for the spawn/kill glue.
+ */
+export interface SttTransport {
+    send(message: SttWorkerOutbound): void;
+    onMessage(handler: (message: SttWorkerInbound) => void): () => void;
+}

package/dist/types/stt/asr-worker.d.ts

@@ -0,0 +1,2 @@
+import type { SttTransport } from "./asr-protocol";
+export declare function startSttWorker(transport: SttTransport): void;

package/dist/types/stt/downloader.d.ts

@@ -1,9 +1,47 @@
+import type { SttProgressStatus } from "./asr-protocol";
 export interface DownloadProgress {
     stage: string;
     percent?: number;
 }
 export interface EnsureOptions {
     modelName?: string;
+    signal?: AbortSignal;
     onProgress?: (progress: DownloadProgress) => void;
 }
+/**
+ * Real-progress event for a speech-model download, surfaced to UI callers.
+ * `percent` is an integer 0–100 aggregated across all model files (encoder +
+ * decoder shards), so it advances monotonically toward completion.
+ */
+export interface SttDownloadProgress {
+    status: SttProgressStatus;
+    /** Integer 0–100 aggregated across files. */
+    percent: number;
+    /** Bytes downloaded so far across all files. */
+    loaded: number;
+    /** Total bytes across all files seen so far. */
+    total: number;
+    /** The file currently downloading, when known. */
+    file?: string;
+    repo: string;
+    label: string;
+}
+/**
+ * Whether the selected model is already present in the local cache. For
+ * transformers.js Whisper tiers a complete download leaves `config.json` plus
+ * the `onnx/` weight files (a bare `config.json` from an interrupted fetch reads
+ * as not-cached); for sherpa-onnx tiers every model file (encoder/decoder/joiner
+ * + tokens) must be present (`.part` sidecars from an interrupted fetch are
+ * ignored).
+ */
+export declare function isSttModelCached(key: string): Promise<boolean>;
+/**
+ * Download (or warm from cache) the selected ONNX Whisper model via the speech
+ * worker, resolving once the model is fully present and loaded. Streams real
+ * Hub progress with an aggregated integer percent. Rejects if the worker cannot
+ * obtain the model. Safe to call non-interactively.
+ */
+export declare function downloadSttModel(key: string, onProgress?: (progress: SttDownloadProgress) => void, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
 export declare function ensureSTTDependencies(options?: EnsureOptions): Promise<void>;

package/dist/types/stt/endpointer.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Energy-based speech endpointer for live transcription.
+ *
+ * The on-device ASR models we ship are non-streaming: the sherpa-onnx Parakeet
+ * recognizer and the transformers.js Whisper pipelines both decode a complete
+ * waveform in one shot. To transcribe *while the user is still speaking*, this
+ * splits the continuous 16 kHz mono float stream into speech segments at natural
+ * pauses — each segment is decoded and committed as it finalizes, and the
+ * in-progress segment is re-decoded periodically for a volatile live preview.
+ *
+ * Segmentation is pure short-time-energy VAD with an adaptive noise floor, so it
+ * needs no extra model and is engine-agnostic (it runs the same way whether the
+ * downstream model is sherpa or transformers). It is deliberately simple and
+ * fully deterministic so it can be unit-tested with synthetic signals.
+ */
+/** Tunable thresholds for {@link StreamEndpointer}. All durations in ms. */
+export interface EndpointerConfig {
+    /** Input sample rate (the recorder always delivers 16 kHz mono). */
+    sampleRate: number;
+    /** Short-time analysis frame size. */
+    frameMs: number;
+    /** Trailing silence inside a segment that finalizes (commits) it. */
+    endSilenceMs: number;
+    /** Shortest speech run that is committed; shorter runs are discarded as noise. */
+    minSpeechMs: number;
+    /** Hard cap on segment length so long pause-free speech still commits periodically. */
+    maxSegmentMs: number;
+    /** Audio retained before onset so the first phoneme of a segment is never clipped. */
+    preRollMs: number;
+    /** Cadence of volatile partial emissions for the in-progress segment. */
+    partialIntervalMs: number;
+    /** Speech threshold is `max(minThreshold, noiseFloor * energyRatio)`. */
+    energyRatio: number;
+    /** EMA weight tracking the ambient noise floor on non-speech frames. */
+    floorAttack: number;
+    /** Absolute RMS floor so a near-silent room never trips speech detection. */
+    minThreshold: number;
+}
+export declare const DEFAULT_ENDPOINTER_CONFIG: EndpointerConfig;
+/**
+ * Emitted by {@link StreamEndpointer.push} / {@link StreamEndpointer.flush}.
+ * `partial` is the volatile in-progress segment (decode and show as preview,
+ * never commit); `segment` is a finalized run (decode and commit once).
+ */
+export type EndpointerEvent = {
+    kind: "partial";
+    audio: Float32Array;
+} | {
+    kind: "segment";
+    audio: Float32Array;
+};
+export declare class StreamEndpointer {
+    #private;
+    constructor(config?: Partial<EndpointerConfig>);
+    /** Feed newly-captured samples; returns ordered partial/segment events. */
+    push(samples: Float32Array): EndpointerEvent[];
+    /** End the stream; returns a trailing committed segment if one is pending. */
+    flush(): EndpointerEvent[];
+}

package/dist/types/stt/index.d.ts

@@ -1,3 +1,7 @@
+export * from "./asr-client";
+export * from "./asr-protocol";
 export * from "./downloader";
-export * from "./setup";
+export * from "./models";
 export * from "./stt-controller";
+export * from "./transcriber";
+export * from "./wav";

package/dist/types/stt/models.d.ts

@@ -0,0 +1,120 @@
+import type { TinyModelDtype } from "../tiny/dtype";
+/**
+ * On-device speech-to-text model registry. Each tier maps a stable settings key
+ * onto a locally-runnable ASR model and the engine that loads it:
+ *
+ * - `transformers` — a transformers.js / ONNX Whisper repo, loaded by the
+ *   `@huggingface/transformers` `automatic-speech-recognition` pipeline.
+ * - `sherpa` — a sherpa-onnx (Next-gen Kaldi) offline model, loaded by the
+ *   native `sherpa-onnx-node` addon. Used for NVIDIA Parakeet, the Open ASR
+ *   Leaderboard accuracy/speed leader.
+ *
+ * The worker resolves the spec by key and loads the model lazily (kept warm
+ * afterwards). Both engines run inside the hard-killed subprocess worker.
+ */
+/** ASR runtime that loads a given tier's model. */
+export type SttEngine = "transformers" | "sherpa";
+interface SttModelBase {
+    /** Stable key persisted in `stt.modelName` and sent over the worker protocol. */
+    key: string;
+    engine: SttEngine;
+    /** Hugging Face repo id (transformers.js ONNX repo, or sherpa-onnx model repo). */
+    repo: string;
+    /** English-only checkpoint: rejects a configured source `language`. */
+    englishOnly: boolean;
+    label: string;
+    description: string;
+    /** Approximate on-disk download size for the shipped weights (UI hint). */
+    sizeHint: string;
+}
+/** A Whisper-family tier loaded via the transformers.js ASR pipeline. */
+export interface TransformersSttModelSpec extends SttModelBase {
+    engine: "transformers";
+    /** ONNX precision used unless overridden by `PROMETHEUS_TINY_DTYPE` / `providers.tinyModelDtype`. */
+    dtype: TinyModelDtype;
+}
+/** A sherpa-onnx offline tier (e.g. NeMo Parakeet transducer) loaded natively. */
+export interface SherpaSttModelSpec extends SttModelBase {
+    engine: "sherpa";
+    /** sherpa-onnx offline model family (e.g. `nemo_transducer`). */
+    modelType: string;
+    /** Model files (relative to the repo root) fetched into the local cache. */
+    files: {
+        encoder: string;
+        decoder: string;
+        joiner: string;
+        tokens: string;
+    };
+}
+export type SttModelSpec = TransformersSttModelSpec | SherpaSttModelSpec;
+/**
+ * Speech model tiers, ordered light → SoTA. Defaults to {@link DEFAULT_STT_MODEL_KEY}.
+ * `fast`/`balanced`/`turbo` are multilingual Whisper checkpoints on transformers.js;
+ * `parakeet` is NVIDIA Parakeet TDT 0.6B v3 on sherpa-onnx — the Open ASR
+ * Leaderboard leader (lower WER and far higher throughput than Whisper).
+ */
+export declare const STT_MODELS: readonly [{
+    readonly key: "fast";
+    readonly engine: "transformers";
+    readonly repo: "onnx-community/whisper-base";
+    readonly dtype: "q8";
+    readonly englishOnly: false;
+    readonly label: "Fast (Whisper base)";
+    readonly description: "Whisper base, multilingual. Smallest + fastest; lowest accuracy. Best for low-resource machines.";
+    readonly sizeHint: "~60 MB";
+}, {
+    readonly key: "balanced";
+    readonly engine: "transformers";
+    readonly repo: "onnx-community/whisper-small";
+    readonly dtype: "q8";
+    readonly englishOnly: false;
+    readonly label: "Balanced (Whisper small)";
+    readonly description: "Whisper small, multilingual. More accurate than Fast, still light on CPU/RAM.";
+    readonly sizeHint: "~190 MB";
+}, {
+    readonly key: "turbo";
+    readonly engine: "transformers";
+    readonly repo: "onnx-community/whisper-large-v3-turbo";
+    readonly dtype: "q4";
+    readonly englishOnly: false;
+    readonly label: "Turbo (Whisper large-v3)";
+    readonly description: "Whisper large-v3-turbo, 99 languages. Widest language coverage; large download, slower.";
+    readonly sizeHint: "~600 MB";
+}, {
+    readonly key: "parakeet";
+    readonly engine: "sherpa";
+    readonly repo: "csukuangfj/sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8";
+    readonly modelType: "nemo_transducer";
+    readonly files: {
+        readonly encoder: "encoder.int8.onnx";
+        readonly decoder: "decoder.int8.onnx";
+        readonly joiner: "joiner.int8.onnx";
+        readonly tokens: "tokens.txt";
+    };
+    readonly englishOnly: false;
+    readonly label: "Parakeet TDT v3 (SoTA)";
+    readonly description: "NVIDIA Parakeet TDT 0.6B v3, 25 languages. Open ASR Leaderboard leader — best accuracy and far fastest decoding. Default.";
+    readonly sizeHint: "~680 MB";
+}];
+/**
+ * SoTA default — NVIDIA Parakeet TDT 0.6B v3 (sherpa-onnx). Tops the Open ASR
+ * Leaderboard on accuracy while decoding ~20× faster than Whisper large-v3.
+ */
+export declare const DEFAULT_STT_MODEL_KEY = "parakeet";
+export type SttModelKey = (typeof STT_MODELS)[number]["key"];
+/** A concrete entry from {@link STT_MODELS}; `key` is the literal tier union. */
+export type SttModel = (typeof STT_MODELS)[number];
+export declare const STT_MODEL_VALUES: readonly ["fast", "balanced", "turbo", "parakeet"];
+export declare const STT_MODEL_OPTIONS: {
+    value: "balanced" | "fast" | "parakeet" | "turbo";
+    label: "Balanced (Whisper small)" | "Fast (Whisper base)" | "Parakeet TDT v3 (SoTA)" | "Turbo (Whisper large-v3)";
+    description: "NVIDIA Parakeet TDT 0.6B v3, 25 languages. Open ASR Leaderboard leader — best accuracy and far fastest decoding. Default." | "Whisper base, multilingual. Smallest + fastest; lowest accuracy. Best for low-resource machines." | "Whisper large-v3-turbo, 99 languages. Widest language coverage; large download, slower." | "Whisper small, multilingual. More accurate than Fast, still light on CPU/RAM.";
+}[];
+export declare function isSttModelKey(value: string): value is SttModelKey;
+export declare function getSttModelSpec(key: string): SttModel | undefined;
+/**
+ * Resolve a (possibly stale or legacy) `stt.modelName` value onto a concrete
+ * spec, falling back to the SoTA default when the key is unknown.
+ */
+export declare function resolveSttModelSpec(key: string | undefined): SttModel;
+export {};

package/dist/types/stt/recorder.d.ts

@@ -5,9 +5,26 @@ export interface RecordingHandle {
  * Returns available recording tools in priority order.
  */
 export declare function detectRecordingTools(): string[];
+export interface ResolvedRecorder {
+    tool: "sox" | "ffmpeg" | "arecord" | "powershell";
+    bin: string;
+}
+export declare function detectRecorder(): ResolvedRecorder | null;
+/**
+ * Ensure a recorder is available, downloading the static ffmpeg binary when
+ * nothing is already present. Returns the resolved recorder.
+ */
+export declare function ensureRecorder(onProgress?: (p: {
+    stage: string;
+    percent?: number;
+}) => void, signal?: AbortSignal): Promise<ResolvedRecorder>;
 export declare function startRecording(outputPath: string): Promise<RecordingHandle>;
 /**
  * Verify a recorded audio file is usable.
  * Returns the file size in bytes, or throws.
  */
 export declare function verifyRecordingFile(filePath: string): Promise<number>;
+export interface StreamingRecordingHandle {
+    stop(): Promise<void>;
+}
+export declare function startStreamingRecording(onAudio: (samples: Float32Array) => void): Promise<StreamingRecordingHandle | null>;

package/dist/types/stt/stt-controller.d.ts

@@ -3,9 +3,15 @@ interface ToggleOptions {
     showWarning(msg: string): void;
     showStatus(msg: string): void;
     onStateChange(state: SttState): void;
+    /** Force a redraw after async edits to the composer (live segment/preview inserts). */
+    requestRender?(): void;
 }
+/** The slice of the composer editor the controller drives. */
 interface Editor {
     insertText(text: string): void;
+    setVolatileText(text: string): void;
+    clearVolatileText(): void;
+    commitVolatileText(text: string): void;
 }
 export declare class STTController {
     #private;

package/dist/types/stt/transcriber.d.ts

@@ -4,13 +4,11 @@ export interface TranscribeOptions {
     signal?: AbortSignal;
 }
 /**
- * Find a usable Python command.
- */
-export declare function resolvePython(): string | null;
-/**
- * Transcribe a WAV file using Python openai-whisper.
+ * Transcribe a WAV file using the local ONNX Whisper worker.
  *
- * Reads the WAV via Python's built-in `wave` module (no ffmpeg needed),
- * resamples to 16 kHz mono, and passes the numpy array directly to whisper.
+ * Decodes the WAV to a 16 kHz mono Float32Array in-process (no Python, no
+ * ffmpeg) and routes it to the warm speech worker, which keeps the model loaded
+ * across calls. Honors `options.signal` (abort) and applies an internal timeout
+ * with the same semantics as the previous Python path.
  */
 export declare function transcribe(audioPath: string, options?: TranscribeOptions): Promise<string>;

package/dist/types/stt/wav.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal WAV (RIFF/PCM) decoder producing the Float32Array @ 16 kHz mono that
+ * transformers.js `automatic-speech-recognition` expects. Ports the decode/
+ * mono-mix/resample logic from the retired Python `transcribe.py` (which read
+ * via the stdlib `wave` module) so STT no longer shells out to Python.
+ *
+ * Supported sample formats: PCM uint8 (8-bit), int16 (16-bit), int32 (32-bit),
+ * and IEEE float32 (format tag 3). Any number of channels is mixed down to mono.
+ */
+/** transformers.js Whisper feature extractor operates at 16 kHz. */
+export declare const TARGET_SAMPLE_RATE = 16000;
+/**
+ * Resample via linear interpolation, mirroring the Python `np.interp` over
+ * `linspace(0, n-1, targetLen)` against `arange(n)`.
+ */
+export declare function resampleLinear(input: Float32Array, fromRate: number, toRate: number): Float32Array;
+/**
+ * Decode a WAV byte buffer into a 16 kHz mono Float32Array suitable for the
+ * transformers.js Whisper pipeline.
+ */
+export declare function decodeWavToMono16k(buffer: ArrayBuffer): Float32Array;
+/**
+ * Decode interleaved little-endian signed 16-bit PCM bytes into normalized
+ * [-1, 1] mono float samples. The live recorder streams raw s16le frames from
+ * sox/ffmpeg/arecord stdout (no RIFF container), so this is the hot-path
+ * counterpart to {@link decodeWavToMono16k}. `bytes` MUST be 2-byte aligned;
+ * callers buffer any trailing odd byte across chunk boundaries.
+ */
+export declare function decodePcmS16LE(bytes: Uint8Array): Float32Array;

package/dist/types/system-prompt.d.ts

@@ -2,7 +2,7 @@
  * System prompt construction and project context loading
  */
 import type { AgentTool } from "@prometheus-ai/agent-core";
-import type { SkillsSettings } from "./config/settings";
+import type { Personality, SkillsSettings } from "./config/settings";
 import { type Skill } from "./extensibility/skills";
 import { type WorkspaceTree } from "./workspace-tree";
 interface AlwaysApplyRule {
@@ -10,6 +10,8 @@ interface AlwaysApplyRule {
     content: string;
     path: string;
 }
+/** Discover TITLE_SYSTEM.md file for automatic session-title prompt overrides */
+export declare function discoverTitleSystemPromptFile(cwd?: string): string | undefined;
 /** Resolve input as file path or literal string */
 export declare function resolvePromptInput(input: string | undefined, description: string): Promise<string | undefined>;
 export interface LoadContextFilesOptions {
@@ -76,6 +78,10 @@ export interface BuildSystemPromptOptions {
     mcpDiscoveryServerSummaries?: string[];
     /** Encourage the agent to delegate via tasks unless changes are trivial. */
     eagerTasks?: boolean;
+    /** When true, the Eager Tasks section uses the hard MUST/ONLY wording (`task.eager: always`) rather than the softer `preferred` nudge. */
+    eagerTasksAlways?: boolean;
+    /** Whether `task.batch` is enabled; gates batch-call guidance in the Eager Tasks section. */
+    taskBatch?: boolean;
     /** Rules with alwaysApply=true — their full content is injected into the prompt. */
     alwaysApplyRules?: AlwaysApplyRule[];
     /** Whether secret obfuscation is active. When true, explains the redaction format in the prompt. */
@@ -86,6 +92,8 @@ export interface BuildSystemPromptOptions {
     memoryRootEnabled?: boolean;
     /** Active model identifier (e.g. "anthropic/claude-opus-4") surfaced to the agent. */
     model?: string;
+    /** Personality preset rendered into the default system prompt. "none" omits the block. Default: "default" */
+    personality?: Personality;
 }
 /** Result of building provider-facing system prompt messages. */
 export interface BuildSystemPromptResult {

package/dist/types/task/commands.d.ts

@@ -17,7 +17,7 @@ export declare function loadBundledCommands(): WorkflowCommand[];
 /**
  * Discover all available commands.
  *
- * Precedence (highest wins): .prometheus > .claude > .codex > .gemini (project before user), then bundled
+ * Precedence (highest wins): .prometheus > .prometheus > .claude (project before user), then bundled
  */
 export declare function discoverCommands(cwd: string): Promise<WorkflowCommand[]>;
 /**

package/dist/types/task/discovery.d.ts

@@ -7,8 +7,7 @@ export interface DiscoveryResult {
 /**
  * Discover agents from filesystem and merge with bundled agents.
  *
- * Precedence (highest wins): .prometheus > .claude > .codex > .gemini (project before user), then bundled
- *
+ * Precedence (highest wins): project .prometheus, user .prometheus, Claude plugin agents, then bundled
  * @param cwd - Current working directory for project agent discovery
  */
 export declare function discoverAgents(cwd: string, home?: string): Promise<DiscoveryResult>;