@xingjisoft/neutrino 0.6.2 → 0.7.0

package/dist/compact.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Helpers for compressing a long conversation so it fits back inside the
+ * model's context window.
+ *
+ * Everything here is pure: deciding *what* to summarise, and flattening that
+ * part into a plain transcript. The actual "ask the model to summarise" step
+ * lives in `LLMClient.summarize`, so this module stays trivially unit-testable.
+ */
+export interface CompactMessage {
+    role: string;
+    content?: string;
+    /** Tool name, when `role` is "tool". */
+    name?: string;
+}
+/** A model-only summary of a prefix of the complete, non-system transcript. */
+export interface ConversationContext {
+    /** Number of original messages covered by the summary (exclusive boundary). */
+    end: number;
+    summary: string;
+}
+/** Ignore stale/corrupt metadata rather than hiding any original messages. */
+export declare function normalizeContext(value: unknown, messageCount: number): ConversationContext | null;
+/** Derive a bounded model history while leaving the complete transcript intact. */
+export declare function modelHistory<T extends CompactMessage>(messages: T[], context: ConversationContext | null): Array<T | {
+    role: "summary";
+    content: string;
+}>;
+export interface CompactionPlan<T> {
+    /** Older messages that should be summarised away. */
+    head: T[];
+    /** Recent messages kept verbatim. */
+    tail: T[];
+}
+/** How many trailing messages are always kept verbatim when compressing. */
+export declare const COMPACT_KEEP = 4;
+/** Per-message character budget fed to the summariser, to bound its own input. */
+export declare const COMPACT_MAX_CHARS_PER_MESSAGE = 4000;
+/**
+ * Split `messages` into an older prefix to summarise and a recent suffix to
+ * keep. The kept suffix never begins with a bare tool result — that would be an
+ * orphan without the assistant tool-call that produced it — so such messages
+ * are folded into the prefix instead.
+ *
+ * Returns null when there is nothing worth compressing (the conversation is
+ * already short enough).
+ */
+export declare function planCompaction<T extends CompactMessage>(messages: T[], keep?: number): CompactionPlan<T> | null;
+/**
+ * Flatten messages into a plain transcript for the summariser, clipping each
+ * message so a single huge tool result cannot dominate the summary request.
+ */
+export declare function transcriptFor(messages: CompactMessage[], maxCharsPerMessage?: number): string;

package/dist/config.d.ts

@@ -0,0 +1,221 @@
+import { type ConversationContext } from "./compact.js";
+import type { PlanState } from "./llm/plan.js";
+import { type TaskSnapshot } from "./llm/runtime.js";
+import type { FastSnapshot } from "./fast/types.js";
+export declare const NEUTRINO_DIR: string;
+export declare const MODEL_FILE: string;
+export declare const SESSION_DIR: string;
+export declare const CONFIG_FILE: string;
+/**
+ * The browser console has two workspaces: the regular one and the isolated
+ * "Pro" workspace served at `/pro`. Everything a workspace owns — transcripts,
+ * model defaults, plan/compaction settings, reviewer model and interface
+ * language — is stored per mode; only the credentials and the approval policy
+ * below are shared, because they protect or gate the whole process.
+ */
+export declare const MODES: readonly ["standard", "pro"];
+export type Mode = (typeof MODES)[number];
+/** Conversation strategy inside the regular workspace; Pro owns its own workspace. */
+export declare const AGENT_MODES: readonly ["standard", "ptc", "fast", "fast_dag"];
+export type AgentMode = (typeof AGENT_MODES)[number];
+export declare function isAgentMode(value: unknown): value is AgentMode;
+export declare function normalizeAgentMode(value: unknown): AgentMode;
+export declare const PRO_DIR: string;
+export declare const PRO_CONFIG_FILE: string;
+export declare const PRO_SESSION_DIR: string;
+/**
+ * Settings that intentionally apply to both workspaces. The Web password, the
+ * approval policy, the console's interface/LAN access and background residency
+ * are properties of this process, not of a conversation workspace.
+ */
+export declare const SHARED_CONFIG_KEYS: readonly ["web_password_hash", "approval_mode", "auto_approve_extreme_risk", "web_lan", "background"];
+export declare function normalizeMode(value: unknown): Mode;
+export declare function configFile(mode?: Mode): string;
+export declare function sessionDir(mode?: Mode): string;
+/** Key used to remember a model's context capacity per workspace. */
+export declare function modelContextWindowKey(provider: string, modelName: string): string;
+export interface ModelInfo {
+    name: string;
+    url: string;
+    api_key: string;
+    supports_streaming: boolean;
+    /** Context capacity in tokens; omitted models use 1M. */
+    context_window?: number;
+    /**
+     * DeepSeek-style thinking mode: the endpoint rejects a request that offers
+     * tools while an assistant message in the history carries no
+     * `reasoning_content`. Defaults to true for DeepSeek endpoints; set it
+     * explicitly for a differently named endpoint (or to opt out).
+     */
+    reasoning?: boolean;
+    /**
+     * Thinking intensities this model accepts, e.g. `["low", "high", "max"]`.
+     * Names are matched case-insensitively and normalised to the canonical
+     * `INTENSITY_LEVELS` spelling. Omitted or empty means every level is allowed,
+     * which keeps hand-written catalogues backwards compatible.
+     */
+    intensity?: string[];
+}
+/**
+ * Whether assistant messages must be sent back with a `reasoning_content`
+ * field. DeepSeek's thinking mode requires one on *every* assistant message of
+ * a tools-bearing request (an empty string is accepted), and the plan message
+ * written by the planner is otherwise an assistant message without it.
+ */
+export declare function modelUsesReasoning(provider: string, model: ModelInfo): boolean;
+export declare const DEFAULT_CONTEXT_WINDOW = 1000000;
+export declare const CONTEXT_COMPRESSION_RATIO = 0.8;
+export declare const CONTEXT_WINDOW_OPTIONS: number[];
+export declare function isContextWindow(value: unknown): value is number;
+export declare function contextWindow(value: unknown): number;
+/** Reload the exact provider/model so settings also apply to active chats. */
+export declare function modelContextWindow(provider: string, model: ModelInfo, mode?: Mode): number;
+export declare function contextCompressionThreshold(provider: string, model: ModelInfo, mode?: Mode): number;
+export interface ModelSelection {
+    provider: string;
+    model: string;
+    intensity: string;
+}
+/** Resolved only on the server; credentials must never be serialized to clients. */
+export interface ResolvedModelSelection {
+    provider: string;
+    model: ModelInfo;
+    intensity: string;
+}
+export interface Provider {
+    name: string;
+    models: ModelInfo[];
+}
+export interface ModelsData {
+    providers: Provider[];
+}
+export declare const DEFAULT_MODELS: ModelsData;
+/** Languages the browser console can render its own interface in. */
+export declare const WEB_LANGUAGES: readonly ["en", "zh"];
+export type WebLanguage = (typeof WEB_LANGUAGES)[number];
+/** Unknown or missing values fall back to English rather than breaking the UI. */
+export declare function normalizeWebLanguage(value: unknown): WebLanguage;
+export declare const DEFAULT_CONFIG: Record<string, unknown>;
+export declare const INTENSITY_LEVELS: string[];
+export declare const INTENSITY_PARAMS: Record<string, {
+    temperature: number;
+    top_p: number;
+}>;
+/** Canonical spelling of a configured intensity name, or null when unknown. */
+export declare function normalizeIntensity(value: unknown): string | null;
+/**
+ * The intensities a model accepts, in the canonical Low → Ultra order.
+ *
+ * An absent or empty list keeps the historical behaviour: every level is
+ * allowed. Unknown names are ignored rather than making the model unusable, so
+ * a typo in `model.json` falls back to the remaining valid entries (or to all
+ * levels when none is valid).
+ */
+export declare function modelIntensities(model: ModelInfo | null | undefined): string[];
+/**
+ * Pick a usable intensity for a model. The preferred value wins when the model
+ * accepts it; otherwise the configured fallback, then High, then the first
+ * supported level. This is the one place stale UI state, a saved session or a
+ * hand-edited `config.json` is reconciled with the model's limits.
+ */
+export declare function intensityForModel(model: ModelInfo | null | undefined, preferred?: unknown, fallback?: unknown): string;
+/** Exact model lookup within a provider (names may repeat across providers). */
+export declare function findConfiguredModel(providerName: string, modelName: string): ModelInfo | null;
+export interface SessionMeta {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    model: string;
+    provider: string;
+    intensity: string;
+    cwd: string;
+    title: string;
+    message_count: number;
+    agent_mode?: AgentMode;
+}
+export interface ToolMessage {
+    role: "tool";
+    name: string;
+    arguments: Record<string, unknown>;
+    result: string;
+}
+export interface ChatMessage {
+    role: "user" | "assistant" | "system";
+    content: string;
+}
+export type SessionMessage = ChatMessage | ToolMessage;
+export interface TokenUsage {
+    prompt: number;
+    completion: number;
+}
+export interface SessionData {
+    fast_run?: FastSnapshot;
+    task_run?: TaskSnapshot;
+    id: string;
+    created_at: string;
+    updated_at: string;
+    model: string;
+    provider: string;
+    intensity: string;
+    cwd: string;
+    title: string;
+    messages: SessionMessage[];
+    tokens?: TokenUsage;
+    /** Model context is separate from messages, which always retain the originals. */
+    context?: ConversationContext;
+    approval_mode?: ApprovalMode;
+    agent_mode?: AgentMode;
+    /** The plan of the turn being worked on, so reopening shows the same steps. */
+    plan?: PlanState | null;
+    /** Pro preset selection; resolved fallback models are always task-local. */
+    pro_preset?: string;
+}
+export type ApprovalMode = "request" | "auto";
+export declare function normalizeApprovalMode(value: unknown): ApprovalMode;
+export declare function ensureDirs(mode?: Mode): void;
+export declare function loadModels(): ModelsData;
+export declare function saveModels(data: ModelsData): void;
+export declare function loadConfig(mode?: Mode): Record<string, unknown>;
+export declare function saveConfig(data: Record<string, unknown>, mode?: Mode): void;
+/** Look a model up by name across every configured provider. */
+export declare function findModel(name: string): {
+    provider: string;
+    model: ModelInfo;
+} | null;
+export declare function getModelsByProvider(): Record<string, ModelInfo[]>;
+/** Resolve a provider/model pair exactly, including when names repeat across providers. */
+export declare function resolveModelSelection(value: unknown, requireKey?: boolean): ResolvedModelSelection;
+export declare function saveSession(messages: SessionMessage[], modelName: string, provider: string, intensity: string, cwd?: string, sessionId?: string, tokens?: TokenUsage, context?: ConversationContext | null, approvalMode?: ApprovalMode, plan?: PlanState | null, mode?: Mode, proPreset?: string, agentMode?: AgentMode, taskRun?: TaskSnapshot, fastRun?: FastSnapshot): string;
+export declare function loadSession(sessionId: string, mode?: Mode): SessionData | null;
+export declare function deleteSession(sessionId: string, mode?: Mode): boolean;
+export declare function listSessions(mode?: Mode): SessionMeta[];
+/**
+ * Sessions that were started in `cwd` (the directory neutrino runs in).
+ * The history menu is scoped to the current project so sessions started in
+ * other directories do not clutter it.
+ */
+export declare function listSessionsForCwd(cwd?: string, mode?: Mode): SessionMeta[];
+export declare function loadLogo(): string;
+export declare function loadPrompt(): string;
+/** Mode prompts are standalone so standard planning/delegation directives cannot conflict. */
+export declare function loadAgentPrompt(mode: AgentMode): string;
+/** The planning agent's system prompt. */
+export declare function loadPlannerPrompt(): string;
+/** Template for the per-step system text; `{{index}}`, `{{plan}}`, … are filled in. */
+export declare function loadStepPrompt(): string;
+/** The system prompt a delegated sub-agent works from. */
+export declare function loadSubAgentPrompt(): string;
+/**
+ * Whether a turn is planned before it is executed. Unset means on: the plan is
+ * the default workflow, and only an explicit `false` turns it off.
+ *
+ * `NEUTRINO_PLAN=off` overrides both ways for a single run, the way the other
+ * environment variables override the saved configuration.
+ */
+export declare function planFirstEnabled(mode?: Mode): boolean;
+/**
+ * Read the CLI version straight from the package's `package.json` so the
+ * displayed version can never drift out of sync with the published package.
+ * The result is cached after the first successful read.
+ */
+export declare function loadVersion(): string;

package/dist/config.js

@@ -1,3 +1,4 @@
+import { pluginPrompt } from "./plugins/session.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -9,7 +10,7 @@ import { SUBAGENT_MAX_ROUNDS } from "./llm/subagent.js";
 import { DEFAULT_TASK_LIMITS } from "./llm/runtime.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = path.resolve(__dirname, "..");
-export const NEUTRINO_DIR = path.join(os.homedir(), ".neutrino");
+export const NEUTRINO_DIR = process.env.NEUTRINO_HOME || path.join(os.homedir(), ".neutrino");
 export const MODEL_FILE = path.join(NEUTRINO_DIR, "model.json");
 export const SESSION_DIR = path.join(NEUTRINO_DIR, "session");
 export const CONFIG_FILE = path.join(NEUTRINO_DIR, "config.json");
@@ -22,7 +23,7 @@ export const CONFIG_FILE = path.join(NEUTRINO_DIR, "config.json");
  */
 export const MODES = ["standard", "pro"];
 /** Conversation strategy inside the regular workspace; Pro owns its own workspace. */
-export const AGENT_MODES = ["standard", "ptc", "fast"];
+export const AGENT_MODES = ["standard", "ptc", "fast", "fast_dag"];
 export function isAgentMode(value) {
     return typeof value === "string" && AGENT_MODES.includes(value);
 }
@@ -151,6 +152,15 @@ export const DEFAULT_CONFIG = {
     task_max_tools: DEFAULT_TASK_LIMITS.toolCalls,
     task_max_tokens: DEFAULT_TASK_LIMITS.tokens,
     task_timeout_ms: DEFAULT_TASK_LIMITS.durationMs,
+    // Independent concurrent engine. Legacy "fast" remains a separate strategy.
+    fast_mode_enabled: true,
+    fast_model_slots: 4,
+    fast_tool_slots: 8,
+    fast_background_slots: 2,
+    fast_task_timeout_ms: DEFAULT_TASK_LIMITS.durationMs,
+    fast_max_tasks: 24,
+    fast_retries: 1,
+    fast_replans: 2,
     // Mount the browser UI alongside the terminal UI unless it is turned off
     // here or on the command line.
     web_console: true,
@@ -357,7 +367,7 @@ export function resolveModelSelection(value, requireKey = true) {
         throw new Error("this model has no API key configured");
     return { provider: provider.name, model: { ...model }, intensity };
 }
-export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens, context, approvalMode, plan, mode = "standard", proPreset, agentMode, taskRun) {
+export function saveSession(messages, modelName, provider, intensity, cwd, sessionId, tokens, context, approvalMode, plan, mode = "standard", proPreset, agentMode, taskRun, fastRun) {
     ensureDirs(mode);
     const now = new Date();
     const id = sessionId ?? `${now.toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
@@ -381,6 +391,7 @@ export function saveSession(messages, modelName, provider, intensity, cwd, sessi
         title,
         messages,
         tokens,
+        ...((fastRun ?? existing?.fast_run) ? { fast_run: fastRun ?? existing?.fast_run } : {}),
         ...((taskRun ?? existing?.task_run) ? { task_run: taskRun ?? existing?.task_run } : {}),
         approval_mode: normalizeApprovalMode(approvalMode ?? existing?.approval_mode),
         agent_mode: mode === "pro" ? "standard" : normalizeAgentMode(agentMode ?? existing?.agent_mode),
@@ -509,16 +520,17 @@ export function loadPrompt() {
 }
 /** Mode prompts are standalone so standard planning/delegation directives cannot conflict. */
 export function loadAgentPrompt(mode) {
-    if (mode === "standard")
-        return loadPrompt();
+    if (mode === "standard" || mode === "fast_dag")
+        return pluginPrompt(loadPrompt(), "main");
     const file = mode === "fast" ? "fast.txt" : "ptc.txt";
-    return readAsset(path.join(PKG_ROOT, "assets", file)) ?? loadPrompt();
+    return pluginPrompt(readAsset(path.join(PKG_ROOT, "assets", file)) ?? loadPrompt(), "main");
 }
 /** The planning agent's system prompt. */
 export function loadPlannerPrompt() {
-    return (readAsset(path.join(PKG_ROOT, "assets", "planner.txt"), path.join(PKG_ROOT, "planner.txt")) ??
+    const prompt = (readAsset(path.join(PKG_ROOT, "assets", "planner.txt"), path.join(PKG_ROOT, "planner.txt")) ??
         "Split the user's request into ordered, independent steps a coding agent can execute one at a " +
             "time. Answer with JSON only: {\"goal\": \"...\", \"steps\": [{\"title\": \"...\"}]}.");
+    return pluginPrompt(prompt, "planner");
 }
 /** Template for the per-step system text; `{{index}}`, `{{plan}}`, … are filled in. */
 export function loadStepPrompt() {

package/dist/cwd.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Helpers for deciding whether a stored session belongs to the directory the
+ * agent is currently running in.
+ *
+ * Every agent records the working directory in its own flavour — `C:\a\b`,
+ * `C:/a/b`, a trailing slash, a differently cased drive letter, or a WSL style
+ * `/mnt/c/a/b` — so the comparison has to be forgiving about the spelling and
+ * strict about the actual location.
+ */
+/** Reduce a directory path to a canonical form that can be compared for equality. */
+export declare function normalizeCwd(dir: string): string;
+/** True when both paths point at the same directory. Empty paths never match. */
+export declare function sameCwd(a: string, b: string): boolean;
+/**
+ * Claude Code names each project directory after the working directory with
+ * every non-alphanumeric character replaced by a dash. That lets us attribute
+ * transcripts that do not carry an explicit `cwd` field.
+ */
+export declare function claudeProjectKey(dir: string): string;

package/dist/fast/artifacts.d.ts

@@ -0,0 +1,26 @@
+import type { FastArtifact, FastOutput, FastSnapshot } from "./types.js";
+import type { DiagnosticRecorder } from "../llm/diagnostics.js";
+/** Every turn has its own store; immutable versions remain available after invalidation. */
+export declare class ArtifactStore {
+    private directory?;
+    private diagnostics?;
+    private history;
+    private stable;
+    private persistenceStarted;
+    private discarded;
+    cacheHits: number;
+    constructor(directory?: string | undefined, diagnostics?: DiagnosticRecorder | undefined);
+    context(key: string, content: string): string;
+    readContext(key: string): {
+        version: string;
+        content: string;
+    } | undefined;
+    latest(id: string): FastArtifact | undefined;
+    put(id: string, output: FastOutput, versions: Record<string, number | string>): FastArtifact;
+    verify(id: string): void;
+    invalidate(id: string): void;
+    all(): FastArtifact[];
+    checkpoint(snapshot: FastSnapshot): void;
+    private persist;
+    private ensureDirectory;
+}

package/dist/fast/artifacts.js

@@ -0,0 +1,109 @@
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { currentTask } from "../llm/runtime.js";
+/** Every turn has its own store; immutable versions remain available after invalidation. */
+export class ArtifactStore {
+    directory;
+    diagnostics;
+    history = new Map();
+    stable = new Map();
+    persistenceStarted = false;
+    discarded = false;
+    cacheHits = 0;
+    constructor(directory, diagnostics) {
+        this.directory = directory;
+        this.diagnostics = diagnostics;
+    }
+    context(key, content) {
+        const version = createHash("sha256").update(content).digest("hex");
+        const cached = this.stable.get(key);
+        if (cached?.version === version)
+            this.cacheHits++;
+        else
+            this.stable.set(key, { version, content });
+        return version;
+    }
+    readContext(key) {
+        const value = this.stable.get(key);
+        if (value)
+            this.cacheHits++;
+        return value ? { ...value } : undefined;
+    }
+    latest(id) {
+        const item = this.history.get(id)?.at(-1);
+        return item ? structuredClone(item) : undefined;
+    }
+    put(id, output, versions) {
+        const versionsSoFar = this.history.get(id) ?? [];
+        const artifact = { ...structuredClone(output), task_id: id,
+            version: versionsSoFar.length + 1, input_versions: { ...versions }, verification: "pending",
+            created_at: new Date().toISOString() };
+        versionsSoFar.push(artifact);
+        this.history.set(id, versionsSoFar);
+        this.persist(id);
+        return structuredClone(artifact);
+    }
+    verify(id) {
+        const item = this.history.get(id)?.at(-1);
+        if (!item || item.verification === "invalidated")
+            throw new Error(`Cannot verify invalid artifact: ${id}`);
+        item.verification = "verified";
+        this.persist(id);
+    }
+    invalidate(id) {
+        const item = this.history.get(id)?.at(-1);
+        if (item)
+            item.verification = "invalidated";
+        this.persist(id);
+    }
+    all() { return structuredClone([...this.history.values()].flat()); }
+    checkpoint(snapshot) {
+        if (!this.directory || !this.ensureDirectory())
+            return;
+        const target = path.join(this.directory, "run.json"), temp = `${target}.${randomUUID()}.tmp`;
+        const span = this.diagnostics?.span("persistence", { artifact_kind: "run" }, currentTask());
+        try {
+            const serialized = JSON.stringify(snapshot);
+            if (span)
+                this.diagnostics?.emit("persistence_encoded", { span_id: span.id, artifact_kind: "run", payload_bytes: Buffer.byteLength(serialized) });
+            fs.writeFileSync(temp, serialized, { mode: 0o600 });
+            fs.renameSync(temp, target);
+        }
+        finally {
+            if (fs.existsSync(temp))
+                fs.unlinkSync(temp);
+            span?.end();
+        }
+    }
+    persist(taskId) {
+        if (!this.directory || !this.ensureDirectory())
+            return;
+        const target = path.join(this.directory, "artifacts.json");
+        const temp = `${target}.${randomUUID()}.tmp`;
+        const span = this.diagnostics?.span("persistence", { artifact_kind: "artifacts", task_id: taskId }, currentTask());
+        try {
+            const serialized = JSON.stringify({ contexts: Object.fromEntries(this.stable), artifacts: this.all() });
+            if (span)
+                this.diagnostics?.emit("persistence_encoded", { span_id: span.id, artifact_kind: "artifacts", payload_bytes: Buffer.byteLength(serialized) });
+            fs.writeFileSync(temp, serialized, { mode: 0o600 });
+            fs.renameSync(temp, target);
+        }
+        finally {
+            if (fs.existsSync(temp))
+                fs.unlinkSync(temp);
+            span?.end();
+        }
+    }
+    ensureDirectory() {
+        if (!this.directory || this.discarded)
+            return false;
+        if (this.persistenceStarted && !fs.existsSync(this.directory)) {
+            this.discarded = true;
+            return false;
+        }
+        fs.mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+        this.persistenceStarted = true;
+        return true;
+    }
+}

package/dist/fast/engine.d.ts

@@ -0,0 +1,78 @@
+import { LLMClient, type UsageInfo } from "../llm/client.js";
+import { type TaskRuntime } from "../llm/runtime.js";
+import { type ApprovalDecision } from "../llm/approval.js";
+import { ArtifactStore } from "./artifacts.js";
+import { ResourcePool } from "./pool.js";
+import { DynamicScheduler } from "./scheduler.js";
+import { type FastSettings, type FastSnapshot } from "./types.js";
+type Messages = Parameters<LLMClient["streamTurn"]>[0];
+export declare const FAST_FINISH_REVIEW = "finish_fast_review";
+export interface FastEngineOptions {
+    runtime: TaskRuntime;
+    settings: FastSettings;
+    signal: AbortSignal;
+    cwd: string;
+    history: Messages;
+    system: string;
+    subagentSystem: string;
+    contextWindow: number;
+    maxRounds: number;
+    directory?: string;
+    /** The session's unchanged model/provider/reasoning configuration, fresh for every request. */
+    createClient(): LLMClient;
+    approve(name: string, args: Record<string, unknown>, signal: AbortSignal, wrapReviewer?: (client: LLMClient) => LLMClient): Promise<ApprovalDecision>;
+    execute(name: string, args: Record<string, unknown>, signal: AbortSignal): Promise<string>;
+    onUsage?(usage: UsageInfo): void;
+    onSnapshot?(snapshot: FastSnapshot): void;
+    onText?(text: string): void;
+    onTool?(name: string, args: Record<string, unknown>, result: string): void;
+}
+/** Separate engine; no changes to Standard's planner or agent loop. */
+export declare class FastAgentEngine {
+    private options;
+    readonly runId: `${string}-${string}-${string}-${string}-${string}`;
+    readonly models: ResourcePool;
+    readonly tools: ResourcePool;
+    readonly background: ResourcePool;
+    readonly store: ArtifactStore;
+    readonly scheduler: DynamicScheduler;
+    private phase;
+    private error?;
+    private started;
+    private integrated;
+    private integrations;
+    private integrationError?;
+    private modelBlocker?;
+    private constraints;
+    private goal;
+    private approvalPool;
+    private diagnosticPhase?;
+    private toolWaitMs;
+    private replans;
+    private planningErrors;
+    private reviewLog;
+    private metrics;
+    constructor(options: FastEngineOptions);
+    snapshot(): FastSnapshot;
+    run(): Promise<{
+        report: string;
+        status: "completed" | "partial" | "failed" | "cancelled";
+        snapshot: FastSnapshot;
+    }>;
+    /** JSONL lines are admitted during streaming, before the planner request completes. */
+    private plan;
+    private worker;
+    private review;
+    private approve;
+    private taskTools;
+    private historyForPrompt;
+    private evidenceView;
+    private dependencyEvidence;
+    private evidenceContext;
+    private execute;
+    private delegate;
+    private client;
+    private bindClient;
+    private publish;
+}
+export {};