@prometheus-ai/agent 0.5.0

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

@@ -0,0 +1,94 @@
+import * as natives from "@prometheus-ai/natives";
+declare const IsoBackendKind: typeof natives.IsoBackendKind;
+type IsoBackendKind = natives.IsoBackendKind;
+/** Baseline state for a single git repository. */
+export interface RepoBaseline {
+    repoRoot: string;
+    headCommit: string;
+    staged: string;
+    unstaged: string;
+    untracked: string[];
+    untrackedPatch: string;
+}
+/** Baseline state for the project, including any nested git repos. */
+export interface WorktreeBaseline {
+    root: RepoBaseline;
+    /** Nested git repos (path relative to root.repoRoot). */
+    nested: Array<{
+        relativePath: string;
+        baseline: RepoBaseline;
+    }>;
+}
+export declare function getRepoRoot(cwd: string): Promise<string>;
+export declare function getGitNoIndexNullPath(): string;
+export declare function captureBaseline(repoRoot: string): Promise<WorktreeBaseline>;
+export interface NestedRepoPatch {
+    relativePath: string;
+    patch: string;
+}
+export interface DeltaPatchResult {
+    rootPatch: string;
+    nestedPatches: NestedRepoPatch[];
+}
+export declare function captureDeltaPatch(isolationDir: string, baseline: WorktreeBaseline): Promise<DeltaPatchResult>;
+/**
+ * Apply nested repo patches directly to their working directories after parent merge.
+ * @param commitMessage Optional async function to generate a commit message from the combined diff.
+ *                      If omitted or returns null, falls back to a generic message.
+ */
+export declare function applyNestedPatches(repoRoot: string, patches: NestedRepoPatch[], commitMessage?: (diff: string) => Promise<string | null>): Promise<void>;
+/**
+ * User-facing isolation mode names exposed by the `task.isolation.mode`
+ * setting. Mapped to a backend-kind hint via {@link parseIsolationMode};
+ * the PAL's `iso_resolve` then falls back through the kind order
+ * whenever the hint isn't available on the current host.
+ */
+export type TaskIsolationMode = "none" | "auto" | "apfs" | "btrfs" | "zfs" | "reflink" | "overlayfs" | "projfs" | "block-clone" | "rcopy" | "worktree" | "fuse-overlay" | "fuse-projfs";
+/**
+ * Translate a {@link TaskIsolationMode} string to an [`IsoBackendKind`]
+ * the PAL can act on. `"none"` returns `null` (caller skips isolation
+ * entirely); `"auto"` returns `undefined` (no hint — let the resolver
+ * pick). Anything else returns the matching kind.
+ */
+export declare function parseIsolationMode(mode: TaskIsolationMode): IsoBackendKind | undefined;
+export interface IsolationHandle {
+    /** Merged view materialised by the backend; pass this to the task. */
+    mergedDir: string;
+    /** Backend the PAL actually used. */
+    backend: IsoBackendKind;
+    /** True when the resolver downgraded from `preferred` to `backend`. */
+    fellBack: boolean;
+    /** Optional reason associated with `fellBack`. */
+    fallbackReason: string | null;
+}
+export declare function ensureIsolation(baseCwd: string, id: string, preferred?: IsoBackendKind): Promise<IsolationHandle>;
+/** Tear down a handle returned by {@link ensureIsolation}. */
+export declare function cleanupIsolation(handle: IsolationHandle): Promise<void>;
+export interface CommitToBranchResult {
+    branchName?: string;
+    nestedPatches: NestedRepoPatch[];
+}
+/**
+ * Commit task-only changes to a new branch.
+ * Only root repo changes go on the branch. Nested repo patches are returned
+ * separately since the parent git can't track files inside gitlinks.
+ */
+export declare function commitToBranch(isolationDir: string, baseline: WorktreeBaseline, taskId: string, description: string | undefined, commitMessage?: (diff: string) => Promise<string | null>): Promise<CommitToBranchResult | null>;
+export interface MergeBranchResult {
+    merged: string[];
+    failed: string[];
+    conflict?: string;
+}
+/**
+ * Cherry-pick task branch commits sequentially onto HEAD.
+ * Each branch has a single commit that gets replayed cleanly.
+ * Stops on first conflict and reports which branches succeeded.
+ */
+export declare function mergeTaskBranches(repoRoot: string, branches: Array<{
+    branchName: string;
+    taskId: string;
+    description?: string;
+}>): Promise<MergeBranchResult>;
+/** Clean up temporary task branches. */
+export declare function cleanupTaskBranches(repoRoot: string, branches: string[]): Promise<void>;
+export {};

package/dist/types/telemetry-export.d.ts

@@ -0,0 +1,43 @@
+/**
+ * OTLP trace export bootstrap.
+ *
+ * prometheus's agent core (`@prometheus-ai/agent-core`) emits OpenTelemetry GenAI
+ * spans through the global `@opentelemetry/api` tracer, but only when a
+ * TracerProvider is registered in the process — otherwise the API returns a
+ * no-op tracer and the spans are silently dropped. The shipped CLI never
+ * registered one, so headless / embedded hosts (e.g. an ACP harness that
+ * spawns `prometheus` as a child process) had no way to collect prometheus's internal traces.
+ *
+ * This module registers a NodeTracerProvider with an OTLP/proto exporter when
+ * the standard `OTEL_EXPORTER_OTLP_ENDPOINT` (or `..._TRACES_ENDPOINT`) env var
+ * is set, following the zero-code OTEL env contract: the exporter reads its
+ * endpoint, headers, and timeout from `OTEL_EXPORTER_OTLP_*` itself. The
+ * consuming process configures the destination entirely through env; prometheus stays
+ * provider-agnostic and ships no vendor coupling. Only the `http/protobuf`
+ * transport is supported — an `OTEL_EXPORTER_OTLP*_PROTOCOL` of `grpc` or
+ * `http/json` declines rather than misrouting spans.
+ *
+ * The OTLP/proto exporter on the 2.x line is used deliberately: the 1.x line
+ * deadlocks under Bun — its `req.on('close')` handler fires a spurious failure
+ * after the success path. `exporter-trace-otlp-proto@0.218` paired with
+ * `sdk-trace-base@2.7` exports cleanly on Bun.
+ */
+/**
+ * Whether {@link initTelemetryExport} registered a real provider. The CLI uses
+ * this to decide whether to switch on the agent loop's telemetry config — there
+ * is no point emitting spans into a no-op tracer.
+ */
+export declare function isTelemetryExportEnabled(): boolean;
+/**
+ * Register the global TracerProvider + OTLP exporter when an OTLP endpoint is
+ * configured via env. Idempotent, and a no-op when no endpoint is set (or when
+ * the OTEL kill-switches are engaged), so it is safe to call unconditionally at
+ * startup.
+ */
+export declare function initTelemetryExport(): void;
+/**
+ * Flush any buffered spans to the exporter. No-op when export is disabled.
+ * Hosts embedding the agent can call this at natural boundaries (e.g. the end
+ * of a turn) so traces surface promptly rather than on the batch interval.
+ */
+export declare function flushTelemetryExport(): Promise<void>;

package/dist/types/thinking.d.ts

@@ -0,0 +1,68 @@
+import { type ResolvedThinkingLevel, ThinkingLevel } from "@prometheus-ai/agent-core";
+import { Effort, type Model } from "@prometheus-ai/ai";
+/**
+ * Metadata used to render thinking selector values in the coding-agent UI.
+ */
+export interface ThinkingLevelMetadata {
+    value: ThinkingLevel;
+    label: string;
+    description: string;
+}
+/**
+ * Parses a provider-facing effort value.
+ */
+export declare function parseEffort(value: string | null | undefined): Effort | undefined;
+/**
+ * Parses an agent-local thinking selector.
+ */
+export declare function parseThinkingLevel(value: string | null | undefined): ThinkingLevel | undefined;
+/**
+ * Returns display metadata for a thinking selector.
+ */
+export declare function getThinkingLevelMetadata(level: ThinkingLevel): ThinkingLevelMetadata;
+/**
+ * Converts an agent-local selector into the effort sent to providers.
+ */
+export declare function toReasoningEffort(level: ThinkingLevel | undefined): Effort | undefined;
+/**
+ * Resolves a selector against the current model while preserving explicit "off".
+ */
+export declare function resolveThinkingLevelForModel(model: Model | undefined, level: ThinkingLevel | undefined): ResolvedThinkingLevel | undefined;
+/**
+ * Sentinel selector for the coding-agent "auto" thinking mode. Kept entirely
+ * inside the coding-agent layer: it is never an {@link Effort} or
+ * {@link ThinkingLevel}, so provider mapping/clamping keeps seeing concrete
+ * efforts. The session resolves `auto` to a concrete effort each turn.
+ */
+export declare const AUTO_THINKING: "auto";
+/** A thinking selector as configured by the user — a concrete level or `auto`. */
+export type ConfiguredThinkingLevel = ThinkingLevel | typeof AUTO_THINKING;
+/** Metadata used to render the `auto` selector value alongside concrete levels. */
+export interface ConfiguredThinkingLevelMetadata {
+    value: ConfiguredThinkingLevel;
+    label: string;
+    description: string;
+}
+/**
+ * Parses a configured thinking selector, accepting `auto` in addition to every
+ * value {@link parseThinkingLevel} accepts. {@link parseThinkingLevel} itself
+ * stays strict so model-suffix parsing (`model:high`) keeps rejecting `auto`.
+ */
+export declare function parseConfiguredThinkingLevel(value: string | null | undefined): ConfiguredThinkingLevel | undefined;
+/** Returns display metadata for a configured selector, including `auto`. */
+export declare function getConfiguredThinkingLevelMetadata(level: ConfiguredThinkingLevel): ConfiguredThinkingLevelMetadata;
+/**
+ * Resolves an auto-classified effort against the active model's supported
+ * range. Unlike {@link clampThinkingLevelForModel}, `auto` never resolves below
+ * {@link Effort.Low}: the eligible pool is the model's supported efforts at or
+ * above Low (falling back to the full supported set only when the model maxes
+ * out below Low). Within that pool the request snaps to the highest level not
+ * exceeding it, or the pool minimum when the request is below the pool.
+ */
+export declare function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort;
+/**
+ * The provisional concrete level shown while `auto` is configured but before a
+ * turn has been classified. Prefers the model's `defaultLevel`, otherwise High,
+ * clamped into the auto range. Returns `undefined` for non-reasoning models.
+ */
+export declare function resolveProvisionalAutoLevel(model: Model | undefined): Effort | undefined;

package/dist/types/tiny/compiled-runtime.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Walk a conditional `exports` target (string, array of fallbacks, or a
+ * condition object) and return the first relative path that matches a runtime
+ * condition in declaration order. Returns `null` when nothing applies (e.g.
+ * `import`-only targets).
+ */
+export declare function selectConditionalTarget(target: unknown): string | null;
+/**
+ * Split a bare specifier into its package name and optional subpath, handling
+ * scoped packages (`@scope/name/sub` → `@scope/name` + `sub`).
+ */
+export declare function splitBareSpecifier(specifier: string): {
+    packageName: string;
+    subpath: string | undefined;
+};
+/**
+ * Resolve a bare specifier against an installed `node_modules` directory,
+ * honoring `exports` (CommonJS conditions), then `main`, then `index.js`.
+ * Returns an absolute file path, or `null` when the package/entry is absent.
+ */
+export declare function resolveRuntimeModule(runtimeNodeModules: string, specifier: string): string | null;
+interface ResolverOptions {
+    /** Absolute path to the runtime cache's `node_modules`. */
+    runtimeNodeModules: string;
+    /** Bare specifier → absolute file path overrides (e.g. `sharp` → no-op stub). */
+    stubs?: Record<string, string>;
+}
+/**
+ * Patch `node:module`'s resolver (idempotently) so bare specifiers that the
+ * stock compiled-binary resolver cannot find fall back to the runtime cache.
+ * Stock resolution is tried first, so this never changes behavior for modules
+ * that already resolve (the worker's own bundled imports, node builtins).
+ */
+export declare function installRuntimeModuleResolver({ runtimeNodeModules, stubs }: ResolverOptions): void;
+export {};

package/dist/types/tiny/device.d.ts

@@ -0,0 +1,78 @@
+import type { DeviceType } from "@huggingface/transformers";
+export type TinyModelDevice = DeviceType;
+export interface TinyModelDevicePreference {
+    device: TinyModelDevice;
+    raw: string | undefined;
+}
+export declare function normalizeTinyModelDevice(value: string | undefined): TinyModelDevice | undefined;
+export declare function resolveTinyModelDevicePreference(value?: string | undefined): TinyModelDevicePreference;
+export declare function tinyModelDeviceLoadOrder(preference: TinyModelDevicePreference): readonly TinyModelDevice[];
+/** Sentinel `providers.tinyModelDevice` value meaning "use the built-in CPU default". */
+export declare const TINY_MODEL_DEVICE_DEFAULT = "default";
+/** Accepted values for the `providers.tinyModelDevice` setting (validation + UI). */
+export declare const TINY_MODEL_DEVICE_SETTING_VALUES: readonly ["default", "gpu", "cpu", "metal", "webgpu", "cuda", "dml", "coreml", "auto", "wasm", "webnn", "webnn-gpu", "webnn-cpu", "webnn-npu"];
+/** Submenu metadata for the `providers.tinyModelDevice` setting. */
+export declare const TINY_MODEL_DEVICE_SETTING_OPTIONS: readonly [{
+    readonly value: "default";
+    readonly label: "Default";
+    readonly description: "CPU-only inference";
+}, {
+    readonly value: "gpu";
+    readonly label: "GPU";
+    readonly description: "Accelerated provider (WebGPU/Metal, CUDA, or DirectML)";
+}, {
+    readonly value: "cpu";
+    readonly label: "CPU";
+    readonly description: "CPU-only inference";
+}, {
+    readonly value: "metal";
+    readonly label: "Metal";
+    readonly description: "WebGPU alias for Apple GPUs";
+}, {
+    readonly value: "webgpu";
+    readonly label: "WebGPU";
+    readonly description: "WebGPU/Metal backend";
+}, {
+    readonly value: "cuda";
+    readonly label: "CUDA";
+    readonly description: "NVIDIA CUDA (Linux x64)";
+}, {
+    readonly value: "dml";
+    readonly label: "DirectML";
+    readonly description: "DirectML backend (Windows)";
+}, {
+    readonly value: "coreml";
+    readonly label: "CoreML";
+    readonly description: "Apple CoreML (opt-in; can fail to load)";
+}, {
+    readonly value: "auto";
+    readonly label: "Auto";
+    readonly description: "Let ONNX Runtime choose a provider";
+}, {
+    readonly value: "wasm";
+    readonly label: "WASM";
+    readonly description: "WebAssembly backend";
+}, {
+    readonly value: "webnn";
+    readonly label: "WebNN";
+    readonly description: "WebNN backend";
+}, {
+    readonly value: "webnn-gpu";
+    readonly label: "WebNN GPU";
+    readonly description: "WebNN GPU device";
+}, {
+    readonly value: "webnn-cpu";
+    readonly label: "WebNN CPU";
+    readonly description: "WebNN CPU device";
+}, {
+    readonly value: "webnn-npu";
+    readonly label: "WebNN NPU";
+    readonly description: "WebNN NPU device";
+}];
+/**
+ * Map a `providers.tinyModelDevice` setting value onto a `PROMETHEUS_TINY_DEVICE` env
+ * value for the worker. Returns `undefined` for the default sentinel so the
+ * worker keeps its built-in CPU default; the worker still validates the
+ * forwarded value via {@link normalizeTinyModelDevice}.
+ */
+export declare function tinyModelDeviceSettingToEnv(value: string | undefined): string | undefined;

package/dist/types/tiny/dtype.d.ts

@@ -0,0 +1,85 @@
+import type { DataType } from "@huggingface/transformers";
+/** ONNX quantization / precision for local tiny models (transformers.js `dtype`). */
+export type TinyModelDtype = DataType;
+/**
+ * Validate and canonicalize a `PROMETHEUS_TINY_DTYPE` value. Returns `undefined` when
+ * unset/blank so callers fall back to the per-model spec dtype, and throws on an
+ * unrecognized value so a misconfiguration fails loudly instead of silently
+ * loading a different precision than requested.
+ */
+export declare function normalizeTinyModelDtype(value: string | undefined): TinyModelDtype | undefined;
+/**
+ * Resolve the `PROMETHEUS_TINY_DTYPE` override. `undefined` means "use the per-model spec
+ * dtype" (currently `q4` for every shipped model); a concrete value overrides the
+ * precision for whichever local tiny model loads.
+ */
+export declare function resolveTinyModelDtypeOverride(value?: string | undefined): TinyModelDtype | undefined;
+/** Sentinel `providers.tinyModelDtype` value meaning "use each model's shipped dtype". */
+export declare const TINY_MODEL_DTYPE_DEFAULT = "default";
+/** Accepted values for the `providers.tinyModelDtype` setting (validation + UI). */
+export declare const TINY_MODEL_DTYPE_SETTING_VALUES: readonly ["default", "q4", "q4f16", "q8", "fp16", "fp32", "int8", "uint8", "bnb4", "q2", "q2f16", "q1", "q1f16", "auto"];
+/** Submenu metadata for the `providers.tinyModelDtype` setting. */
+export declare const TINY_MODEL_DTYPE_SETTING_OPTIONS: readonly [{
+    readonly value: "default";
+    readonly label: "Default";
+    readonly description: "Each model's shipped dtype (currently q4)";
+}, {
+    readonly value: "q4";
+    readonly label: "q4";
+    readonly description: "4-bit weights; smallest and fastest";
+}, {
+    readonly value: "q4f16";
+    readonly label: "q4f16";
+    readonly description: "4-bit weights with fp16 activations";
+}, {
+    readonly value: "q8";
+    readonly label: "q8";
+    readonly description: "8-bit quantization";
+}, {
+    readonly value: "fp16";
+    readonly label: "fp16";
+    readonly description: "16-bit float; higher fidelity, larger";
+}, {
+    readonly value: "fp32";
+    readonly label: "fp32";
+    readonly description: "Full precision; largest and slowest";
+}, {
+    readonly value: "int8";
+    readonly label: "int8";
+    readonly description: "Signed 8-bit integer";
+}, {
+    readonly value: "uint8";
+    readonly label: "uint8";
+    readonly description: "Unsigned 8-bit integer";
+}, {
+    readonly value: "bnb4";
+    readonly label: "bnb4";
+    readonly description: "bitsandbytes 4-bit";
+}, {
+    readonly value: "q2";
+    readonly label: "q2";
+    readonly description: "2-bit weights";
+}, {
+    readonly value: "q2f16";
+    readonly label: "q2f16";
+    readonly description: "2-bit weights with fp16 activations";
+}, {
+    readonly value: "q1";
+    readonly label: "q1";
+    readonly description: "1-bit weights";
+}, {
+    readonly value: "q1f16";
+    readonly label: "q1f16";
+    readonly description: "1-bit weights with fp16 activations";
+}, {
+    readonly value: "auto";
+    readonly label: "Auto";
+    readonly description: "Let transformers.js choose per device";
+}];
+/**
+ * Map a `providers.tinyModelDtype` setting value onto a `PROMETHEUS_TINY_DTYPE` env value
+ * for the worker. Returns `undefined` for the default sentinel so the worker keeps
+ * each model's shipped dtype; the worker still validates the forwarded value via
+ * {@link normalizeTinyModelDtype}.
+ */
+export declare function tinyModelDtypeSettingToEnv(value: string | undefined): string | undefined;

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

@@ -0,0 +1,204 @@
+/** Default session-title model: the online prometheus/smol path (no local download / on-device inference). */
+export declare const ONLINE_TINY_TITLE_MODEL_KEY = "online";
+/** Local model the `tiny-models` CLI downloads when none is named. Not the session-title default — that is {@link ONLINE_TINY_TITLE_MODEL_KEY}. */
+export declare const DEFAULT_TINY_TITLE_LOCAL_MODEL_KEY = "lfm2-700m";
+export interface TinyTitleLocalModelSpec {
+    key: string;
+    repo: string;
+    dtype: "q4";
+    label: string;
+    description: string;
+    contextNote: string;
+}
+export declare const TINY_TITLE_LOCAL_MODELS: readonly [{
+    readonly key: "lfm2-350m";
+    readonly repo: "onnx-community/LFM2-350M-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 350M";
+    readonly description: "Recommended local model; best speed/quality balance, about 212 MB cached.";
+    readonly contextNote: "Best local default from the title-generation spike.";
+}, {
+    readonly key: "qwen3-0.6b";
+    readonly repo: "onnx-community/Qwen3-0.6B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Qwen3 0.6B";
+    readonly description: "Most robust local option; slower first load, about 500 MB cached.";
+    readonly contextNote: "Use when title quality matters more than local startup cost.";
+}, {
+    readonly key: "gemma-270m";
+    readonly repo: "onnx-community/gemma-3-270m-it-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Gemma 270M";
+    readonly description: "Smallest viable local option; lower quality, lowest cache footprint.";
+    readonly contextNote: "Use on constrained machines that still need local titles.";
+}, {
+    readonly key: "qwen2.5-0.5b";
+    readonly repo: "onnx-community/Qwen2.5-0.5B-Instruct";
+    readonly dtype: "q4";
+    readonly label: "Qwen2.5 0.5B";
+    readonly description: "Balanced local fallback; moderate quality and cache footprint.";
+    readonly contextNote: "Useful when Qwen3 is too heavy but Gemma quality is insufficient.";
+}, {
+    readonly key: "lfm2-700m";
+    readonly repo: "onnx-community/LFM2-700M-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 700M";
+    readonly description: "Highest-quality local option; larger and slower than LFM2 350M.";
+    readonly contextNote: "Use when local title quality is preferred over startup cost.";
+}];
+export declare const TINY_TITLE_MODEL_VALUES: readonly ["online", "lfm2-350m", "qwen3-0.6b", "gemma-270m", "qwen2.5-0.5b", "lfm2-700m"];
+export type TinyTitleModelKey = (typeof TINY_TITLE_MODEL_VALUES)[number];
+export type TinyTitleLocalModelKey = (typeof TINY_TITLE_LOCAL_MODELS)[number]["key"];
+export declare const TINY_TITLE_MODEL_OPTIONS: ({
+    value: "online";
+    label: string;
+    description: string;
+} | {
+    value: "gemma-270m" | "lfm2-350m" | "lfm2-700m" | "qwen2.5-0.5b" | "qwen3-0.6b";
+    label: "Gemma 270M" | "LFM2 350M" | "LFM2 700M" | "Qwen2.5 0.5B" | "Qwen3 0.6B";
+    description: "Balanced local fallback; moderate quality and cache footprint." | "Highest-quality local option; larger and slower than LFM2 350M." | "Most robust local option; slower first load, about 500 MB cached." | "Recommended local model; best speed/quality balance, about 212 MB cached." | "Smallest viable local option; lower quality, lowest cache footprint.";
+})[];
+export declare function isTinyTitleLocalModelKey(value: string): value is TinyTitleLocalModelKey;
+export declare function getTinyTitleModelSpec(key: TinyTitleLocalModelKey): (typeof TINY_TITLE_LOCAL_MODELS)[number];
+/** Default memory model: the online path (the configured smol / remote LLM; no local download). */
+export declare const ONLINE_MEMORY_MODEL_KEY = "online";
+/** Recommended local model for memory tasks when none is named. */
+export declare const DEFAULT_MEMORY_LOCAL_MODEL_KEY = "qwen3-1.7b";
+/**
+ * Local models for Mnemopi memory tasks (fact extraction + consolidation).
+ * These are larger (1B-1.7B) than the title models: structured extraction and
+ * faithful summarization need more capacity than 3-6 word titles. All q4.
+ * Ranking/recipe rationale lives in docs/local-models.md.
+ */
+export declare const TINY_MEMORY_LOCAL_MODELS: readonly [{
+    readonly key: "qwen3-1.7b";
+    readonly repo: "onnx-community/Qwen3-1.7B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Qwen3 1.7B";
+    readonly description: "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
+    readonly contextNote: "Best single-model pick for memory from the local experiment.";
+}, {
+    readonly key: "gemma-3-1b";
+    readonly repo: "onnx-community/gemma-3-1b-it-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Gemma 3 1B";
+    readonly description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction.";
+    readonly contextNote: "Use when consolidation quality and size matter most.";
+}, {
+    readonly key: "qwen2.5-1.5b";
+    readonly repo: "onnx-community/Qwen2.5-1.5B-Instruct";
+    readonly dtype: "q4";
+    readonly label: "Qwen2.5 1.5B";
+    readonly description: "Best extraction granularity (atomic facts); weaker consolidation.";
+    readonly contextNote: "Use when fine-grained, deduplicatable facts matter more than summaries.";
+}, {
+    readonly key: "lfm2-1.2b";
+    readonly repo: "onnx-community/LFM2-1.2B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 1.2B";
+    readonly description: "Fastest load; solid all-rounder, slightly noisier extraction labels.";
+    readonly contextNote: "Use when local startup cost is the priority.";
+}];
+export declare const TINY_MEMORY_MODEL_VALUES: readonly ["online", "qwen3-1.7b", "gemma-3-1b", "qwen2.5-1.5b", "lfm2-1.2b"];
+export type TinyMemoryModelKey = (typeof TINY_MEMORY_MODEL_VALUES)[number];
+export type TinyMemoryLocalModelKey = (typeof TINY_MEMORY_LOCAL_MODELS)[number]["key"];
+export declare const TINY_MEMORY_MODEL_OPTIONS: ({
+    value: "online";
+    label: string;
+    description: string;
+} | {
+    value: "gemma-3-1b" | "lfm2-1.2b" | "qwen2.5-1.5b" | "qwen3-1.7b";
+    label: "Gemma 3 1B" | "LFM2 1.2B" | "Qwen2.5 1.5B" | "Qwen3 1.7B";
+    description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction." | "Best extraction granularity (atomic facts); weaker consolidation." | "Fastest load; solid all-rounder, slightly noisier extraction labels." | "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
+})[];
+export declare function isTinyMemoryLocalModelKey(value: string): value is TinyMemoryLocalModelKey;
+export declare function getTinyMemoryModelSpec(key: TinyMemoryLocalModelKey): (typeof TINY_MEMORY_LOCAL_MODELS)[number];
+/** Any local model key (title or memory), used by the shared inference worker. */
+export type TinyLocalModelKey = TinyTitleLocalModelKey | TinyMemoryLocalModelKey;
+/** Resolve a local model spec by key across both the title and memory registries. */
+export declare function getTinyLocalModelSpec(key: string): TinyTitleLocalModelSpec | undefined;
+export declare function isTinyLocalModelKey(value: string): value is TinyLocalModelKey;
+/** Combined local model registry (title + memory) for the shared tiny-models CLI. */
+export declare const TINY_LOCAL_MODELS: readonly [{
+    readonly key: "lfm2-350m";
+    readonly repo: "onnx-community/LFM2-350M-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 350M";
+    readonly description: "Recommended local model; best speed/quality balance, about 212 MB cached.";
+    readonly contextNote: "Best local default from the title-generation spike.";
+}, {
+    readonly key: "qwen3-0.6b";
+    readonly repo: "onnx-community/Qwen3-0.6B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Qwen3 0.6B";
+    readonly description: "Most robust local option; slower first load, about 500 MB cached.";
+    readonly contextNote: "Use when title quality matters more than local startup cost.";
+}, {
+    readonly key: "gemma-270m";
+    readonly repo: "onnx-community/gemma-3-270m-it-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Gemma 270M";
+    readonly description: "Smallest viable local option; lower quality, lowest cache footprint.";
+    readonly contextNote: "Use on constrained machines that still need local titles.";
+}, {
+    readonly key: "qwen2.5-0.5b";
+    readonly repo: "onnx-community/Qwen2.5-0.5B-Instruct";
+    readonly dtype: "q4";
+    readonly label: "Qwen2.5 0.5B";
+    readonly description: "Balanced local fallback; moderate quality and cache footprint.";
+    readonly contextNote: "Useful when Qwen3 is too heavy but Gemma quality is insufficient.";
+}, {
+    readonly key: "lfm2-700m";
+    readonly repo: "onnx-community/LFM2-700M-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 700M";
+    readonly description: "Highest-quality local option; larger and slower than LFM2 350M.";
+    readonly contextNote: "Use when local title quality is preferred over startup cost.";
+}, {
+    readonly key: "qwen3-1.7b";
+    readonly repo: "onnx-community/Qwen3-1.7B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Qwen3 1.7B";
+    readonly description: "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
+    readonly contextNote: "Best single-model pick for memory from the local experiment.";
+}, {
+    readonly key: "gemma-3-1b";
+    readonly repo: "onnx-community/gemma-3-1b-it-ONNX";
+    readonly dtype: "q4";
+    readonly label: "Gemma 3 1B";
+    readonly description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction.";
+    readonly contextNote: "Use when consolidation quality and size matter most.";
+}, {
+    readonly key: "qwen2.5-1.5b";
+    readonly repo: "onnx-community/Qwen2.5-1.5B-Instruct";
+    readonly dtype: "q4";
+    readonly label: "Qwen2.5 1.5B";
+    readonly description: "Best extraction granularity (atomic facts); weaker consolidation.";
+    readonly contextNote: "Use when fine-grained, deduplicatable facts matter more than summaries.";
+}, {
+    readonly key: "lfm2-1.2b";
+    readonly repo: "onnx-community/LFM2-1.2B-ONNX";
+    readonly dtype: "q4";
+    readonly label: "LFM2 1.2B";
+    readonly description: "Fastest load; solid all-rounder, slightly noisier extraction labels.";
+    readonly contextNote: "Use when local startup cost is the priority.";
+}];
+/**
+ * Difficulty-classifier model for the `auto` thinking level. Defaults to the
+ * online smol path; the local options reuse the memory-model registry because
+ * the shared worker's `complete()` only accepts memory local keys, and the
+ * 1B+ memory models classify coding difficulty far more reliably than the
+ * sub-1B title models.
+ */
+export declare const ONLINE_AUTO_THINKING_MODEL_KEY = "online";
+export declare const AUTO_THINKING_MODEL_VALUES: readonly ["online", "qwen3-1.7b", "gemma-3-1b", "qwen2.5-1.5b", "lfm2-1.2b"];
+export type AutoThinkingModelKey = TinyMemoryModelKey;
+export declare const AUTO_THINKING_MODEL_OPTIONS: ({
+    value: "online";
+    label: string;
+    description: string;
+} | {
+    value: "gemma-3-1b" | "lfm2-1.2b" | "qwen2.5-1.5b" | "qwen3-1.7b";
+    label: "Gemma 3 1B" | "LFM2 1.2B" | "Qwen2.5 1.5B" | "Qwen3 1.7B";
+    description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction." | "Best extraction granularity (atomic facts); weaker consolidation." | "Fastest load; solid all-rounder, slightly noisier extraction labels." | "Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.";
+})[];

package/dist/types/tiny/text.d.ts

@@ -0,0 +1,36 @@
+export declare const MAX_TITLE_INPUT_CHARS = 2000;
+export declare function truncateTitleInput(message: string): string;
+/**
+ * Strip fenced code blocks from a message before titling.
+ *
+ * Small title models latch onto literal text inside code blocks — e.g. a pasted
+ * UI mockup containing "Welcome to Claude Code v2.1.158" yields that string as
+ * the title instead of the surrounding intent. Removing fenced blocks leaves the
+ * prose that actually describes the task. Inline code (single backticks) is kept
+ * — it is short, high-signal context like `/login`.
+ *
+ * Falls back to the original message when stripping leaves too little to title
+ * (a message that is essentially just a code block).
+ */
+export declare function stripCodeBlocks(message: string): string;
+/** Prepare a raw user message for titling: drop code blocks, then bound length. */
+export declare function prepareTitleInput(message: string): string;
+export declare function formatTitleUserMessage(message: string): string;
+/**
+ * True when a first user message is too low-signal to title (greeting, ack,
+ * bare number, or empty once code/punctuation/emoji are stripped).
+ *
+ * Deterministic pre-filter: the default tiny title model (~350M local) cannot
+ * reliably follow a "respond with none" instruction and tends to hallucinate a
+ * title for trivial input, so we never ask it — the caller defers titling to
+ * the next message instead.
+ */
+export declare function isLowSignalTitleInput(message: string): boolean;
+/**
+ * Sentinel a capable title model may emit when a message carries no concrete
+ * task. Treated as "no title yet" so the caller can defer titling. Backstop for
+ * the deterministic {@link isLowSignalTitleInput} filter; kept in sync with the
+ * `none` instruction in `prompts/system/title-system.md`.
+ */
+export declare const NO_TITLE_SENTINEL = "none";
+export declare function normalizeGeneratedTitle(value: string | null | undefined): string | null;