jeopi-cli 16.2.14 → 16.2.15

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

@@ -0,0 +1,14 @@
+export interface TranscribeOptions {
+    modelName?: string;
+    language?: string;
+    signal?: AbortSignal;
+}
+/**
+ * Transcribe a WAV file using the local ONNX Whisper worker.
+ *
+ * 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/subprocess/worker-client.d.ts

@@ -0,0 +1,149 @@
+import type { Subprocess } from "bun";
+/**
+ * Shared lifecycle scaffolding for the ONNX inference subprocess clients
+ * (mnemopi embeddings, speech-to-text, tiny-model titles/completions, TTS).
+ * Each runs `onnxruntime-node` inside a dedicated Bun child process so the NAPI
+ * constructor/finalizer never executes in the main agent address space — those
+ * destructors segfault Bun on shutdown (issues #1606 / #1607 / #3031).
+ *
+ * Only the genuinely identical pieces live here: the worker-handle shape, the
+ * spawn-command resolution, the parent-env snapshot, the `Bun.spawn` wiring,
+ * the inline "worker unavailable" stub, and the ping/pong smoke probe. Each
+ * client keeps its own divergent request/response correlation, streaming, and
+ * teardown semantics.
+ */
+/** Minimal inbound contract shared by every worker: a correlated `ping`. */
+export type WorkerInboundBase = {
+    type: "ping";
+    id: string;
+};
+/** Structured log line forwarded from a worker to the parent logger. */
+export type WorkerLogMessage = {
+    type: "log";
+    level: "debug" | "warn" | "error";
+    msg: string;
+    meta?: Record<string, unknown>;
+};
+/** Minimal outbound contract shared by every worker: `pong`, `error`, `log`. */
+export type WorkerOutboundBase = {
+    type: "pong";
+    id: string;
+} | {
+    type: "error";
+    id: string;
+    error: string;
+} | WorkerLogMessage;
+/**
+ * Parent-side view of a worker subprocess: send typed inbound messages,
+ * subscribe to outbound messages and worker errors, and hard-terminate.
+ */
+export interface WorkerHandle<Inbound, Outbound> {
+    send(message: Inbound): void;
+    onMessage(handler: (message: Outbound) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    terminate(): Promise<void>;
+}
+/**
+ * A {@link WorkerHandle} that can also be (un)referenced so a pending request
+ * keeps the parent event loop alive while an idle worker never blocks exit.
+ */
+export interface RefCountedWorkerHandle<Inbound, Outbound> extends WorkerHandle<Inbound, Outbound> {
+    /** Re-reference the subprocess so a pending request keeps the parent event loop alive. */
+    ref(): void;
+    /** Drop the reference once the worker is idle so it never blocks process exit. */
+    unref(): void;
+}
+/** The raw spawned subprocess plus the parent-side fan-out sets. */
+export interface SpawnedSubprocess<Outbound> {
+    proc: Subprocess<"ignore", "ignore", "ignore">;
+    inbound: Set<(message: Outbound) => void>;
+    errors: Set<(error: Error) => void>;
+    /**
+     * Flipped to `true` right before the deliberate SIGKILL so `onExit` can
+     * distinguish the expected hard-kill from a crash (SIGSEGV from a native
+     * fault, OOM SIGKILL, operator `kill -9`). Only the latter surfaces as a
+     * worker error so callers don't await forever.
+     */
+    intentionalExit: {
+        value: boolean;
+    };
+}
+export interface WorkerSpawnCommand {
+    cmd: string[];
+    cwd?: string;
+}
+/**
+ * Cold-starting a worker from a compiled binary (decompress + module graph
+ * load) is slow on contended CI runners; the probe only proves the worker
+ * spawns and ponges, so a generous bound removes flakes without weakening it.
+ */
+export declare const SMOKE_TEST_TIMEOUT_MS = 30000;
+/**
+ * Resolve the command used to relaunch the agent CLI into worker mode. In a
+ * compiled binary the entry point is the binary itself; otherwise re-enter the
+ * declared worker-host entry with a cwd-relative script path (Bun's subprocess
+ * IPC is more reliable that way under `bun test`), falling back to this
+ * package's own `src/cli.ts` when no host entry is declared (bun test, SDK
+ * embedding).
+ */
+export declare function resolveWorkerSpawnCmd(workerArg: string): WorkerSpawnCommand;
+/**
+ * Snapshot the parent environment for the child. `process.env` carries
+ * `undefined` slots that `Bun.spawn` rejects, so filter them out; an optional
+ * `overlay` (e.g. the tiny-model device/dtype vars) wins over inherited keys.
+ */
+export declare function workerEnvFromParent(overlay?: Record<string, string>): Record<string, string>;
+/**
+ * Spawn an inference worker subprocess and wire its IPC fan-out. The child
+ * inherits no stdio (native model runtimes may otherwise print progress or
+ * decoded text and corrupt the chat scrollback) and is `unref`'d outside `bun
+ * test` so an idle worker never blocks process exit. `exitLabel` prefixes the
+ * worker-error message surfaced for an unexpected (non-intentional) exit.
+ */
+export declare function createWorkerSubprocess<Outbound>(options: {
+    spawnCommand: WorkerSpawnCommand;
+    env: Record<string, string>;
+    exitLabel: string;
+}): SpawnedSubprocess<Outbound>;
+/**
+ * Wrap a {@link SpawnedSubprocess} as a {@link WorkerHandle}. The `send`
+ * strategy is injected so each client keeps its exact IPC-send behaviour (e.g.
+ * `safeSend` vs an inline guarded `proc.send`). `terminate()` SIGKILLs: the
+ * point of subprocess isolation is that the parent never runs
+ * `onnxruntime-node`'s NAPI finalizer (it crashes Bun on Windows), so the OS
+ * reclaims the model memory instead. The intentional-exit flag is flipped
+ * *before* the kill so `onExit` can tell it apart from a native crash.
+ */
+export declare function createWorkerHandle<Inbound, Outbound>(spawned: SpawnedSubprocess<Outbound>, send: (message: Inbound) => void): WorkerHandle<Inbound, Outbound>;
+/**
+ * A stand-in handle used when the worker subprocess cannot be spawned. It
+ * ponges `ping` (so the smoke probe and readiness checks still resolve) and
+ * answers every other request with the spawn error so callers fail fast
+ * instead of awaiting forever.
+ */
+export declare function createUnavailableWorker<Inbound extends {
+    type: string;
+    id: string;
+}, Outbound extends {
+    type: string;
+}>(error: unknown): WorkerHandle<Inbound, Outbound>;
+/**
+ * Spawn a worker handle, falling back to {@link createUnavailableWorker} (after
+ * a warning) when the subprocess cannot be created so the feature degrades
+ * gracefully instead of throwing into callers.
+ */
+export declare function spawnWorkerOrUnavailable<Handle>(spawn: () => Handle, unavailable: (error: unknown) => Handle, warnMessage: string): Handle;
+/** Forward a worker's structured `log` message to the matching logger level. */
+export declare function logWorkerMessage(message: WorkerLogMessage): void;
+/**
+ * Drive the ping/pong readiness probe wired into `jeopi --smoke-test`: send one
+ * `ping`, resolve on the first `pong` (ignoring `log` chatter), and reject on
+ * any other message, a worker error, or the timeout. Always tears the handle
+ * down on the way out. `label` prefixes the failure messages.
+ */
+export declare function smokeTestWorker<Inbound extends {
+    type: string;
+    id: string;
+}, Outbound extends {
+    type: string;
+}>(handle: WorkerHandle<Inbound, Outbound>, label: string, timeoutMs: number): Promise<void>;

package/dist/types/subprocess/worker-runtime.d.ts

@@ -0,0 +1,107 @@
+import type { ProgressInfo } from "@huggingface/transformers";
+/**
+ * Child-side scaffolding shared by the ONNX inference worker bodies
+ * (`stt/asr-worker`, `tiny/worker`, `tts/tts-worker`). These are the helpers
+ * that run inside the spawned subprocess: error serialization, structured log
+ * and progress reporting over the worker's typed transport, side-runtime
+ * install (sharp stubbing + module-resolver patch), once-per-process runtime
+ * memoization, and the Transformers.js runtime loader. The parent/client-side
+ * complement lives in `worker-client.ts`.
+ *
+ * Each worker keeps its own strongly-typed transport / model-key / progress
+ * event; the structural {@link WorkerLogTransport} / {@link WorkerProgressTransport}
+ * interfaces below are the minimal shapes these helpers need, and every worker's
+ * concrete transport satisfies them.
+ */
+export declare const TRANSFORMERS_PACKAGE = "@huggingface/transformers";
+export declare function errorText(error: unknown): string;
+export declare function errorMessage(error: unknown): string;
+export type WorkerLogLevel = "debug" | "warn" | "error";
+/** Minimal transport surface a worker exposes for forwarding log lines. */
+export interface WorkerLogTransport {
+    send(message: {
+        type: "log";
+        level: WorkerLogLevel;
+        msg: string;
+        meta?: Record<string, unknown>;
+    }): void;
+}
+export declare function sendLog(transport: WorkerLogTransport, level: WorkerLogLevel, msg: string, meta?: Record<string, unknown>): void;
+/**
+ * Generic worker progress event. Each worker's protocol declares an identical
+ * shape with its own `modelKey` type; this is the parameterized version the
+ * shared helpers emit, structurally assignable to each protocol's event.
+ */
+export interface WorkerProgressEvent<K> {
+    modelKey: K;
+    status: "initiate" | "download" | "progress" | "progress_total" | "done" | "ready" | "error";
+    name?: string;
+    file?: string;
+    progress?: number;
+    loaded?: number;
+    total?: number;
+    files?: Record<string, {
+        loaded: number;
+        total: number;
+    }>;
+    task?: string;
+    model?: string;
+}
+/** Minimal transport surface a worker exposes for emitting progress events. */
+export interface WorkerProgressTransport<K> {
+    send(message: {
+        type: "progress";
+        id: string;
+        event: WorkerProgressEvent<K>;
+    }): void;
+}
+export declare function sendProgress<K>(transport: WorkerProgressTransport<K>, id: string, modelKey: K, info: ProgressInfo): void;
+/**
+ * If a model is already warming/warm in `cache`, replay a `ready` progress
+ * event for this request once it resolves and return the cached promise so the
+ * caller can short-circuit; otherwise return `undefined`.
+ */
+export declare function replayCachedReady<K, M>(cache: Map<K, Promise<M>>, modelKey: K, transport: WorkerProgressTransport<K>, requestId: string, task: string, model: string): Promise<M> | undefined;
+/**
+ * Stub `sharp` (the speech/text pipelines are not image codecs, so the native
+ * image dependency is dead weight) and patch the module resolver so a side
+ * runtime's bare requires resolve against its own `node_modules`. Returns the
+ * runtime's `node_modules` directory.
+ */
+export declare function installSharpStubResolver(runtimeDir: string): Promise<string>;
+/**
+ * Lazily resolve (and memoize) the transformers version spec. In the `catalog:`
+ * case {@link resolveTransformersVersionSpec} `require`s the installed
+ * `@huggingface/transformers/package.json`, so it is only ever touched on the
+ * compiled-binary runtime-install path — loading a worker (smoke-test ping,
+ * online path) never triggers the transformers resolve/install dance.
+ */
+export declare function getTransformersVersionSpec(): string;
+/** The subset of the Transformers.js module surface {@link configureTransformers} touches. */
+interface ConfigurableTransformers {
+    env: {
+        cacheDir?: string;
+        allowLocalModels?: boolean;
+        logLevel?: unknown;
+    };
+    LogLevel: {
+        ERROR: unknown;
+    };
+}
+/**
+ * Memoize an async runtime load so it runs at most once per process, clearing
+ * the cache on failure so a later call can retry. Each worker holds one
+ * instance per runtime it loads.
+ */
+export declare class MemoizedRuntime<T> {
+    #private;
+    load(build: () => Promise<T>): Promise<T>;
+}
+/**
+ * Load the `@huggingface/transformers` runtime into `holder` (memoized): from
+ * the ambient install when running from source, or from a version-keyed side
+ * runtime (resolved lazily at `runtimeDir()`) when running as a compiled binary.
+ * The result is cast to the caller's concrete runtime type `T`.
+ */
+export declare function loadTransformersRuntime<T extends ConfigurableTransformers, K>(holder: MemoizedRuntime<T>, transport: WorkerProgressTransport<K>, requestId: string, modelKey: K, runtimeDir: () => string): Promise<T>;
+export {};

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

@@ -0,0 +1,128 @@
+/**
+ * System prompt construction and project context loading
+ */
+import type { AgentTool } from "jeopi-agent-core";
+import type { ToolExample, TSchema } from "jeopi-ai";
+import type { Personality, SkillsSettings } from "./config/settings";
+import { type Skill } from "./extensibility/skills";
+import { type ActiveRepoContext } from "./utils/active-repo-context";
+import { type WorkspaceTree } from "./workspace-tree";
+interface AlwaysApplyRule {
+    name: string;
+    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 {
+    /** Working directory to start walking up from. Default: getProjectDir() */
+    cwd?: string;
+}
+/**
+ * Load all project context files using the capability API.
+ * Returns {path, content, depth} entries for all discovered context files.
+ * Files are sorted by depth (descending) so files closer to cwd appear last/more prominent.
+ */
+export declare function loadProjectContextFiles(options?: LoadContextFilesOptions): Promise<Array<{
+    path: string;
+    content: string;
+    depth?: number;
+}>>;
+/**
+ * Load the effective system prompt customization from SYSTEM.md.
+ * Project-level SYSTEM.md overrides user-level SYSTEM.md.
+ */
+export declare function loadSystemPromptFiles(options?: LoadContextFilesOptions): Promise<string | null>;
+export declare const DEFAULT_SYSTEM_PROMPT_TOOL_NAMES: readonly ["read", "bash", "eval", "edit", "write"];
+export interface SystemPromptToolMetadata {
+    label: string;
+    description: string;
+    /** Tool name the model sees on the provider wire. Defaults to the internal tool name. */
+    wireName?: string;
+    /** Tool parameters schema (Zod or JSON Schema), fed to the verbose inventory renderer. */
+    parameters?: TSchema;
+    /** Illustrative examples rendered into the verbose inventory. */
+    examples?: readonly ToolExample[];
+}
+export declare function buildSystemPromptToolMetadata(tools: Map<string, AgentTool>, overrides?: Partial<Record<string, Partial<SystemPromptToolMetadata>>>): Map<string, SystemPromptToolMetadata>;
+export interface BuildSystemPromptOptions {
+    /** Custom system prompt (replaces default). */
+    customPrompt?: string;
+    /** Already-loaded custom system prompt text; bypasses path resolution. */
+    resolvedCustomPrompt?: string;
+    /** Tools to include in prompt. */
+    tools?: Map<string, SystemPromptToolMetadata>;
+    /** Tool names to include in prompt. */
+    toolNames?: string[];
+    /** Text to append to system prompt. */
+    appendSystemPrompt?: string;
+    /** Already-loaded append prompt text; bypasses path resolution. */
+    resolvedAppendSystemPrompt?: string;
+    /** Inline full tool descriptors in the system prompt. Default: false */
+    inlineToolDescriptors?: boolean;
+    /**
+     * Whether provider-native tool calling is active (no owned/in-band syntax).
+     * When true and `inlineToolDescriptors` is false, the inventory renders as a
+     * compact tool-name list; otherwise it renders full `# Tool:` sections. Default: true
+     */
+    nativeTools?: boolean;
+    /** Skills settings for discovery. */
+    skillsSettings?: SkillsSettings;
+    /** Working directory. Default: getProjectDir() */
+    cwd?: string;
+    /** Pre-loaded context files (skips discovery if provided). */
+    contextFiles?: Array<{
+        path: string;
+        content: string;
+        depth?: number;
+    }>;
+    /** Skills provided directly to system prompt construction. */
+    skills?: Skill[];
+    /** Pre-loaded rulebook rules (descriptions, excluding TTSR and always-apply). */
+    rules?: Array<{
+        name: string;
+        description?: string;
+        path: string;
+        globs?: string[];
+    }>;
+    /** Intent field name injected into every tool schema. If set, explains the field in the prompt. */
+    intentField?: string;
+    /** Whether MCP tool discovery is active for this prompt build. */
+    mcpDiscoveryMode?: boolean;
+    /** Discoverable MCP server summaries to advertise when discovery mode is active. */
+    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. */
+    secretsEnabled?: boolean;
+    /** Pre-loaded workspace tree (skips discovery if provided). May be a Promise to allow early kick-off. */
+    workspaceTree?: WorkspaceTree | Promise<WorkspaceTree>;
+    /** Whether the local memory://root summary is active. */
+    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;
+    /** Whether to include the workspace directory tree in the system prompt. Default: false */
+    includeWorkspaceTree?: boolean;
+    /** Whether Mermaid fenced blocks render as terminal ASCII diagrams. Default: true */
+    renderMermaid?: boolean;
+    /** Pre-resolved nested active repo context. Undefined resolves from cwd. */
+    activeRepoContext?: ActiveRepoContext | null;
+}
+/** Result of building provider-facing system prompt messages. */
+export interface BuildSystemPromptResult {
+    /** Ordered system prompt blocks. Providers should preserve entries as distinct messages/blocks. */
+    systemPrompt: string[];
+}
+/** Build the system prompt with tools, guidelines, and context */
+export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,28 @@
+import type { AgentDefinition, AgentSource } from "./types";
+export declare class AgentParsingError extends Error {
+    readonly source?: unknown;
+    constructor(error: Error, source?: unknown);
+    toString(): string;
+}
+/**
+ * Parse an agent from embedded content.
+ */
+export declare function parseAgent(filePath: string, content: string, source: AgentSource, level?: "fatal" | "warn" | "off"): AgentDefinition;
+/**
+ * Load all bundled agents from embedded content.
+ * Results are cached after first load.
+ */
+export declare function loadBundledAgents(): AgentDefinition[];
+/**
+ * Get a bundled agent by name.
+ */
+export declare function getBundledAgent(name: string): AgentDefinition | undefined;
+/**
+ * Get all bundled agents as a map keyed by name.
+ */
+export declare function getBundledAgentsMap(): Map<string, AgentDefinition>;
+/**
+ * Clear the bundled agents cache (for testing).
+ */
+export declare function clearBundledAgentsCache(): void;
+export declare const BUNDLED_AGENTS: typeof loadBundledAgents;

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

@@ -0,0 +1,35 @@
+export declare const EMBEDDED_COMMAND_TEMPLATES: ReadonlyArray<{
+    name: string;
+    content: string;
+}>;
+/** Workflow command definition */
+export interface WorkflowCommand {
+    name: string;
+    description: string;
+    instructions: string;
+    source: "bundled" | "user" | "project";
+    filePath: string;
+}
+/**
+ * Load all bundled commands from embedded content.
+ */
+export declare function loadBundledCommands(): WorkflowCommand[];
+/**
+ * Discover all available commands.
+ *
+ * Precedence (highest wins): .jeopi > .pi > .claude (project before user), then bundled
+ */
+export declare function discoverCommands(cwd: string): Promise<WorkflowCommand[]>;
+/**
+ * Get a command by name.
+ */
+export declare function getCommand(commands: WorkflowCommand[], name: string): WorkflowCommand | undefined;
+/**
+ * Expand command instructions with task input.
+ * Replaces $@ with the provided input.
+ */
+export declare function expandCommand(command: WorkflowCommand, input: string): string;
+/**
+ * Clear the bundled commands cache (for testing).
+ */
+export declare function clearBundledCommandsCache(): void;

package/dist/types/task/critic-gate.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Critic gate — the hard, code-enforced counterpart of the prompt rule
+ * "You NEVER execute a plan whose latest critic verdict is not `okay`".
+ *
+ * When a `critic` subagent completes with a schema-validated verdict, the
+ * parent session records it here. While the latest verdict is `iterate` or
+ * `reject` the runtime — not the prompt — blocks execution:
+ *
+ * - `task` refuses to spawn non-read-only agents (read-only lanes such as
+ *   `plan`, `explore`, and `critic` itself stay open so the plan can be
+ *   revised and re-gated).
+ * - Working-tree mutations through `write`/`edit`/patch are rejected; the
+ *   `local://` artifact sandbox stays writable for seeds, plans, and notes.
+ *
+ * The gate clears in exactly two ways: a subsequent critic verdict of `okay`,
+ * or the next user-authored prompt (the user regaining control is the only
+ * override — mirroring jeo-code's `approve` hard gate, scoped to a turn-chain
+ * instead of a state file).
+ *
+ * A strike counter bounds the iterate loop: after
+ * {@link CRITIC_GATE_MAX_STRIKES} consecutive non-okay verdicts without user
+ * input, even re-submitting to `critic` is refused — the agent must stop and
+ * report the surviving gaps instead of burning tokens on convergence-free
+ * re-planning.
+ */
+/** Agent name whose structured verdicts drive the gate. */
+export declare const CRITIC_AGENT_NAME = "critic";
+/** Consecutive non-okay verdicts allowed before the gate forces a stop-and-report. */
+export declare const CRITIC_GATE_MAX_STRIKES = 3;
+/** Non-okay verdicts that engage the gate. */
+export type CriticGateVerdict = "iterate" | "reject";
+/** Gate state held by the parent session while the latest verdict is not `okay`. */
+export interface CriticGateState {
+    /** Latest non-okay verdict. */
+    verdict: CriticGateVerdict;
+    /** Agent id of the critic run that produced the verdict. */
+    agentId: string;
+    /** Epoch ms when the verdict was recorded. */
+    at: number;
+    /** `required_fixes` from the critic's structured output (empty for reject without fixes). */
+    requiredFixes: string[];
+    /** Consecutive non-okay verdicts since the last okay/user prompt. */
+    strikes: number;
+}
+/** Verdict parsed from a critic subagent's validated structured output. */
+export interface ParsedCriticVerdict {
+    verdict: "okay" | CriticGateVerdict;
+    requiredFixes: string[];
+    summary?: string;
+}
+/**
+ * Parse a critic verdict from the subagent's final output payload (the
+ * JSON-serialized, schema-validated yield data). Returns undefined when the
+ * payload is not a critic-shaped verdict — the gate then stays untouched.
+ */
+export declare function parseCriticVerdict(output: string): ParsedCriticVerdict | undefined;
+/**
+ * Fold a new verdict into the gate state. `okay` clears the gate; a non-okay
+ * verdict engages it and increments the consecutive-strike counter.
+ */
+export declare function updateCriticGateState(previous: CriticGateState | undefined, parsed: ParsedCriticVerdict, agentId: string, now?: number): CriticGateState | undefined;
+/**
+ * Decide whether a spawn is allowed under the current gate state. Returns the
+ * rejection message when blocked, undefined when allowed.
+ *
+ * Read-only agents (plan revision, exploration, re-gating via critic) stay
+ * allowed — except that once the strike budget is exhausted, even a fresh
+ * critic run is refused so the loop terminates at the user instead of cycling.
+ */
+export declare function evaluateCriticGateSpawn(state: CriticGateState | undefined, agentName: string, agentIsReadOnly: boolean): string | undefined;
+/**
+ * Error text for a working-tree mutation attempted while the gate is engaged.
+ * The `local://` sandbox is exempt (seeds/plans/notes live there); callers
+ * check that before invoking this.
+ */
+export declare function criticGateWriteMessage(state: CriticGateState): string;

package/dist/types/task/critic-gate.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+import type { AgentDefinition } from "./types";
+/** Result of agent discovery */
+export interface DiscoveryResult {
+    agents: AgentDefinition[];
+    projectAgentsDir: string | null;
+}
+/**
+ * Discover agents from filesystem and merge with bundled agents.
+ *
+ * Precedence (highest wins): project .jeopi, user .jeopi, Claude plugin agents, then bundled
+ * @param cwd - Current working directory for project agent discovery
+ */
+export declare function discoverAgents(cwd: string, home?: string): Promise<DiscoveryResult>;
+/**
+ * Get an agent by name from discovered agents.
+ */
+export declare function getAgent(agents: AgentDefinition[], name: string): AgentDefinition | undefined;