jeopi-cli 16.2.13 → 16.2.14

package/dist/types/task/repair-args.d.ts

@@ -1,53 +0,0 @@
-/**
- * Repair double-encoded JSON string arguments for the task tool.
- *
- * Models occasionally JSON-escape a string value twice when emitting a
- * `task` tool call, so an `assignment` that should read
- *
- *     # Role
- *     You are a judge … "describe this" … return —
- *
- * arrives — after the one JSON decode the provider already applied — as the
- * literal text
- *
- *     # Role\nYou are a judge … \"describe this\" … return \u2014
- *
- * i.e. every newline, quote, and unicode character is still backslash-escaped.
- * The subagent then receives that garbled prompt, and the call preview renders
- * one long blob with visible `\n` / `\"` / `\uXXXX`.
- *
- * The *whole-arguments* form of this quirk (the entire `arguments` blob is a
- * JSON string) is already auto-corrected by the validator's JSON-string
- * coercion. This module handles the *per-field* form, where the object parses
- * fine but an individual string value is double-encoded — the validator never
- * fires there because a double-encoded string is still a structurally valid
- * string.
- *
- * This is deliberately scoped to the task tool's natural-language fields
- * (`assignment`, `description`). It is NOT applied to code-bearing
- * tools (write/edit/bash/search), where a backslash or quote is load-bearing
- * and a false-positive unescape would silently corrupt a file or command.
- */
-import type { TaskParams } from "./types";
-/**
- * Return the once-unescaped string when `value` is uniformly double-encoded
- * JSON (a well-formed JSON string body that decodes to a different string);
- * otherwise return `value` unchanged.
- *
- * The `JSON.parse(\`"${value}"\`)` round-trip is the safety net: it only
- * succeeds when *every* backslash begins a valid JSON escape and no bare
- * double-quote exists — exactly the signature of double-encoding. Genuine
- * prose with a Windows path (`C:\Users`), a regex (`\d+`), an embedded quote,
- * or a real (already-decoded) newline makes the parse throw, so the value is
- * returned untouched.
- */
-export declare function repairDoubleEncodedJsonString(value: string): string;
-/**
- * Repair double-encoded prose in task-tool params (`assignment`,
- * `description`, shared `context`, and each batch task item's prose fields).
- * Returns the same reference when nothing changed so callers can cheaply skip
- * work. Defensive against partially-streamed args (missing/undefined fields,
- * partial task arrays) so it is safe on the render path as well as on
- * execution.
- */
-export declare function repairTaskParams(params: TaskParams): TaskParams;

package/dist/types/task/spawn-policy.d.ts

@@ -1,17 +0,0 @@
-/** Default agent used when a session has unrestricted spawning. */
-export declare const DEFAULT_SPAWN_AGENT = "task";
-/** Spawn policy derived from a parent agent's `spawns` frontmatter. */
-export interface ResolvedSpawnPolicy {
-    /** True when at least one subagent may be spawned. */
-    enabled: boolean;
-    /** Agent used when the caller omits the agent field. */
-    defaultAgent: string;
-    /** Explicitly allowed agents, or `null` when the policy is unrestricted. */
-    allowedAgents: readonly string[] | null;
-    /** Text used in spawn rejection messages. */
-    allowedErrorText: string;
-    /** Backtick-quoted explicit agents for prompt descriptions. */
-    allowedPromptText?: string;
-}
-/** Resolves spawn frontmatter into the default and prompt/error surfaces. */
-export declare function resolveSpawnPolicy(parentSpawns: string | boolean | null | undefined): ResolvedSpawnPolicy;

package/dist/types/task/spawn-policy.test.d.ts

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

package/dist/types/task/subprocess-tool-registry.d.ts

@@ -1,72 +0,0 @@
-/**
- * Registry for handling tool events from subprocess agents.
- *
- * Tools can register handlers to:
- * - Extract structured data from their execution results
- * - Trigger subprocess termination on completion
- * - Provide custom rendering for realtime/final display
- */
-import type { Component } from "jeopi-tui";
-import type { Theme } from "../modes/theme/theme";
-/** Event from subprocess tool execution (parsed from JSONL) */
-export interface SubprocessToolEvent {
-    toolName: string;
-    toolCallId: string;
-    args?: Record<string, unknown>;
-    result?: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: unknown;
-    };
-    isError?: boolean;
-}
-/** Handler for subprocess tool events */
-export interface SubprocessToolHandler<TData = unknown> {
-    /**
-     * Extract structured data from tool result.
-     * Extracted data is accumulated in progress.extractedToolData[toolName][].
-     */
-    extractData?: (event: SubprocessToolEvent) => TData | undefined;
-    /**
-     * Whether this tool's completion should terminate the subprocess.
-     * Return true to send SIGTERM after the tool completes.
-     */
-    shouldTerminate?: (event: SubprocessToolEvent) => boolean;
-    /**
-     * Render a single data item inline during streaming progress.
-     * Called for each tool execution end event.
-     */
-    renderInline?: (data: TData, theme: Theme) => Component;
-    /**
-     * Render accumulated data in the final result view.
-     * Called once with all accumulated data for this tool.
-     */
-    renderFinal?: (allData: TData[], theme: Theme, expanded: boolean) => Component;
-}
-/** Registry for subprocess tool handlers */
-declare class SubprocessToolRegistryImpl {
-    #private;
-    /**
-     * Register a handler for a tool's subprocess events.
-     */
-    register<T>(toolName: string, handler: SubprocessToolHandler<T>): void;
-    /**
-     * Get the handler for a tool, if registered.
-     */
-    getHandler(toolName: string): SubprocessToolHandler | undefined;
-    /**
-     * Check if a tool has a registered handler.
-     */
-    hasHandler(toolName: string): boolean;
-    /**
-     * Get all registered tool names.
-     */
-    getRegisteredTools(): string[];
-}
-/** Singleton registry instance */
-export declare const subprocessToolRegistry: SubprocessToolRegistryImpl;
-/** Type helper for extracted tool data in progress/result */
-export type ExtractedToolData = Record<string, unknown[]>;
-export {};

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

@@ -1,384 +0,0 @@
-import { type BaseType } from "arktype";
-import type { ThinkingLevel } from "jeopi-agent-core";
-import type { Usage } from "jeopi-ai";
-import type { AgentSessionEvent } from "../session/agent-session";
-import type { NestedRepoPatch } from "./worktree";
-/** Source of an agent definition */
-export type AgentSource = "bundled" | "user" | "project";
-/** Maximum output bytes per agent */
-export declare const MAX_OUTPUT_BYTES: number;
-/** Maximum output lines per agent */
-export declare const MAX_OUTPUT_LINES: number;
-/** EventBus channel for raw subagent events */
-export declare const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
-/** EventBus channel for aggregated subagent progress */
-export declare const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
-/** EventBus channel for subagent lifecycle (start/end) */
-export declare const TASK_SUBAGENT_LIFECYCLE_CHANNEL = "task:subagent:lifecycle";
-/** Payload emitted on TASK_SUBAGENT_PROGRESS_CHANNEL */
-export interface SubagentProgressPayload {
-    index: number;
-    agent: string;
-    agentSource: AgentSource;
-    task: string;
-    parentToolCallId?: string;
-    assignment?: string;
-    progress: AgentProgress;
-    sessionFile?: string;
-    /** See {@link SubagentLifecyclePayload.detached}. */
-    detached?: boolean;
-}
-/** Payload emitted on TASK_SUBAGENT_EVENT_CHANNEL */
-export interface SubagentEventPayload {
-    id: string;
-    event: AgentSessionEvent;
-}
-/** Payload emitted on TASK_SUBAGENT_LIFECYCLE_CHANNEL */
-export interface SubagentLifecyclePayload {
-    id: string;
-    agent: string;
-    agentSource: AgentSource;
-    description?: string;
-    status: "started" | "completed" | "failed" | "aborted";
-    sessionFile?: string;
-    parentToolCallId?: string;
-    index: number;
-    /**
-     * Spawn runs as a detached background job: the parent turn keeps working
-     * while this agent runs. Sync task spawns (parent blocked on the call) and
-     * eval `agent()` bridge spawns (rendered inside their eval cell) leave this
-     * unset — surfaces like the subagent HUD only list detached spawns.
-     */
-    detached?: boolean;
-}
-/** Display cap for a normalized one-line label (roster line, registry `displayName`, prompt field). */
-export declare const ROLE_LABEL_MAX = 80;
-/** Schema bound on the raw `role` input, before it is label-normalized at every use site. */
-export declare const ROLE_INPUT_MAX = 256;
-export declare const taskItemSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-    id?: string | undefined;
-    description?: string | undefined;
-    role?: string | undefined;
-    assignment: string;
-}, {}>;
-/** Single task item. Fields are optional defensively: args stream in token by token. */
-export interface TaskItem {
-    /** Stable agent id; default = generated AdjectiveNoun. */
-    id?: string;
-    /** UI label, not seen by the subagent. */
-    description?: string;
-    /** Specialist role/expertise this subagent embodies; shapes its system-prompt identity and display name. */
-    role?: string;
-    /** The work; required by the schema. */
-    assignment?: string;
-    /** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
-    isolated?: boolean;
-}
-export declare const taskSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-    agent: import("arktype/internal/attributes.ts").Default<string, "task">;
-    id?: string | undefined;
-    description?: string | undefined;
-    role?: string | undefined;
-    assignment: string;
-    isolated?: boolean | undefined;
-}, {}>;
-declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/object.ts").ObjectType<{
-    agent: import("arktype/internal/attributes.ts").Default<string, "task">;
-    id?: string | undefined;
-    description?: string | undefined;
-    role?: string | undefined;
-    assignment: string;
-    isolated?: boolean | undefined;
-}, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
-    agent: import("arktype/internal/attributes.ts").Default<string, "task">;
-    id?: string | undefined;
-    description?: string | undefined;
-    role?: string | undefined;
-    assignment: string;
-}, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
-    agent: import("arktype/internal/attributes.ts").Default<string, "task">;
-    context: string;
-    tasks: {
-        id?: string | undefined;
-        description?: string | undefined;
-        role?: string | undefined;
-        assignment: string;
-        isolated?: boolean | undefined;
-    }[];
-}, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
-    agent: import("arktype/internal/attributes.ts").Default<string, "task">;
-    context: string;
-    tasks: {
-        id?: string | undefined;
-        description?: string | undefined;
-        role?: string | undefined;
-        assignment: string;
-    }[];
-}, {}>];
-type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
-export type TaskSchema = typeof taskSchema;
-/** Active task tool parameter schema for the current isolation / batch flags */
-export type TaskToolSchemaInstance = DynamicTaskSchema | BaseType;
-export declare function getTaskSchema(options: {
-    isolationEnabled: boolean;
-    batchEnabled: boolean;
-}): DynamicTaskSchema;
-export declare function getTaskSchema(options: {
-    isolationEnabled: boolean;
-    batchEnabled: boolean;
-    defaultAgent: string;
-}): TaskToolSchemaInstance;
-/**
- * Runtime params union over both wire shapes. The model sees exactly one shape
- * (`{ agent, context, tasks[] }` when `task.batch` is on, `{ agent, ...item }`
- * otherwise); runtime stays permissive so internal callers and stale
- * transcripts using the flat form keep working under either setting.
- */
-export interface TaskParams {
-    /** Agent type to spawn; omitted values resolve from the session spawn policy. */
-    agent?: string;
-    /** Stable agent id (flat form); default = generated AdjectiveNoun. */
-    id?: string;
-    /** UI label (flat form), not seen by the subagent. */
-    description?: string;
-    /** Specialist role/expertise this subagent embodies; shapes its system-prompt identity and display name. */
-    role?: string;
-    /** The work (flat form). */
-    assignment?: string;
-    /** Batch form (`task.batch`): one subagent per item. */
-    tasks?: TaskItem[];
-    /** Batch form: shared background prepended to every assignment; required by the batch schema. */
-    context?: string;
-    /** Run in an isolated worktree (flat form; per-item in batch form). */
-    isolated?: boolean;
-}
-/**
- * One-line, length-capped label safe for a single roster line, a registry
- * `displayName`, or a system-prompt field. Collapses every run of whitespace
- * AND control/format characters — including U+0085 NEL, ESC/ANSI, and the
- * zero-width separators that `\s` misses — to a single space, then caps length.
- * So untrusted text (a spawn `role`, a peer activity gist) can neither break the
- * line, inject prompt structure, nor smuggle terminal escapes. Caps at `max`
- * characters (clamped to >= 1; default `ROLE_LABEL_MAX`), appending an ellipsis when truncated.
- */
-export declare function oneLineLabel(text: string, max?: number): string;
-/**
- * Display name for a spawned subagent: its tailored `role` (label-normalized)
- * when one is given, else the agent type's name. Empty/whitespace roles fall
- * back to the agent name.
- */
-export declare function resolveSubagentDisplayName(role: string | undefined, agentName: string): string;
-/**
- * Whether an agent at `taskDepth` may still spawn children — i.e. it currently
- * holds the `task` tool. Mirrors the task-tool availability gate;
- * `maxRecursionDepth < 0` disables the cap entirely.
- */
-export declare function canSpawnAtDepth(maxRecursionDepth: number, taskDepth: number): boolean;
-/** A code review finding reported by the reviewer agent */
-export interface ReviewFinding {
-    title: string;
-    body: string;
-    priority: number;
-    confidence: number;
-    file_path: string;
-    line_start: number;
-    line_end: number;
-}
-/** Review summary submitted by the reviewer agent */
-export interface ReviewSummary {
-    overall_correctness: "correct" | "incorrect";
-    explanation: string;
-    confidence: number;
-}
-/** Structured review data extracted from reviewer agent */
-export interface ReviewData {
-    findings: ReviewFinding[];
-    summary?: ReviewSummary;
-}
-/** Agent definition (bundled or discovered) */
-export interface AgentDefinition {
-    name: string;
-    description: string;
-    systemPrompt: string;
-    tools?: string[];
-    spawns?: string[] | "*";
-    model?: string[];
-    thinkingLevel?: ThinkingLevel;
-    output?: unknown;
-    blocking?: boolean;
-    autoloadSkills?: string[];
-    /** When `false`, the agent's `read` tool returns verbatim file content instead of structural summaries. */
-    readSummarize?: boolean;
-    source: AgentSource;
-    filePath?: string;
-}
-/** Details extracted from a subagent `yield` tool call for final-result assembly and task rendering. */
-export interface YieldItem {
-    data?: unknown;
-    status?: "success" | "aborted";
-    error?: string;
-    /** A string label is terminal; a non-empty array of labels is incremental. */
-    type?: string | string[];
-    /** Resolve this yield's payload from the latest durable assistant text instead of `data`. */
-    useLastTurn?: boolean;
-    /**
-     * Set by the in-tool yield validator when it exhausted its retry budget and
-     * accepted schema-invalid data anyway. The executor preserves that override
-     * during post-mortem validation.
-     */
-    schemaOverridden?: boolean;
-}
-/** Progress tracking for a single agent */
-export interface AgentProgress {
-    index: number;
-    id: string;
-    agent: string;
-    agentSource: AgentSource;
-    status: "pending" | "running" | "completed" | "failed" | "aborted";
-    task: string;
-    assignment?: string;
-    description?: string;
-    lastIntent?: string;
-    currentTool?: string;
-    currentToolArgs?: string;
-    currentToolStartMs?: number;
-    recentTools: Array<{
-        tool: string;
-        args: string;
-        endMs: number;
-    }>;
-    recentOutput: string[];
-    toolCount: number;
-    /** Count of assistant requests (assistant message_end events) across the run. Drives the soft request budget guard. */
-    requests: number;
-    /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
-    tokens: number;
-    /**
-     * Current per-turn context size: latest assistant message's `usage.totalTokens`.
-     * This is the number to compare against `contextWindow` — what compaction
-     * decides on, what the user typically reads as "how full is the context".
-     * Distinct from `tokens`, which is a lifetime billing-volume counter.
-     */
-    contextTokens?: number;
-    /** Model's context window in tokens, when known. Lets the UI render `<curr>/<window>` gauges. */
-    contextWindow?: number;
-    /** Cumulative billing cost in USD, accumulated incrementally from message_end events. */
-    cost: number;
-    durationMs: number;
-    modelOverride?: string | string[];
-    /** Resolved model display string in the form `<provider>/<id>`, optionally suffixed with `:<thinkingLevel>` when the level was set explicitly. Undefined when the model could not be resolved. */
-    resolvedModel?: string;
-    /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
-    extractedToolData?: Record<string, unknown[]>;
-    /**
-     * Auto-retry state when the subagent is sleeping between provider retries
-     * (e.g. 429 rate-limit with retry-after). Cleared when the retry resolves
-     * or fails. Surfacing this to the parent prevents the task tool from
-     * looking indefinitely "in progress" when a child is actually blocked on
-     * provider quota.
-     */
-    retryState?: {
-        attempt: number;
-        maxAttempts: number;
-        delayMs: number;
-        errorMessage: string;
-        startedAtMs: number;
-    };
-    /**
-     * Terminal retry failure surfaced once the subagent gave up retrying
-     * (e.g. retry-after exceeded the cap, or all attempts exhausted). Carries
-     * the final error so the parent UI can render "blocked: rate-limited"
-     * instead of waiting for a status that never arrives.
-     */
-    retryFailure?: {
-        attempt: number;
-        errorMessage: string;
-    };
-    /**
-     * Snapshot of the most recent `task` tool call's in-flight `TaskToolDetails`,
-     * captured from `tool_execution_update`. Lets the parent UI surface live
-     * nested-subagent progress while this agent is still inside its own `task`
-     * call. Cleared when the call ends — finalized data lives in
-     * `extractedToolData.task` after that.
-     */
-    inflightTaskDetails?: TaskToolDetails;
-}
-/** Result from a single agent execution */
-export interface SingleResult {
-    index: number;
-    id: string;
-    agent: string;
-    agentSource: AgentSource;
-    task: string;
-    assignment?: string;
-    description?: string;
-    lastIntent?: string;
-    exitCode: number;
-    output: string;
-    stderr: string;
-    truncated: boolean;
-    durationMs: number;
-    /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
-    tokens: number;
-    /** Count of assistant requests (assistant message_end events) across the run. */
-    requests: number;
-    /** Latest per-turn context size at task completion. See `AgentProgress.contextTokens`. */
-    contextTokens?: number;
-    /** Model's context window in tokens, when known. */
-    contextWindow?: number;
-    modelOverride?: string | string[];
-    /** Resolved model display string in the form `<provider>/<id>`, optionally suffixed with `:<thinkingLevel>` when the level was set explicitly. Omitted from tool-result JSON when undefined to keep wire payloads small. */
-    resolvedModel?: string;
-    error?: string;
-    aborted?: boolean;
-    abortReason?: string;
-    /** Aggregated usage from the subprocess, accumulated incrementally from message_end events. */
-    usage?: Usage;
-    /** Output path for the task result */
-    outputPath?: string;
-    /** Patch path for isolated worktree output */
-    patchPath?: string;
-    /** Branch name for isolated branch-mode output */
-    branchName?: string;
-    /**
-     * Baseline commit SHA the task branch was created from. Passed to
-     * `mergeTaskBranches` so cherry-pick uses the inclusive range
-     * `branchBaseSha..branchName` and preserves every agent commit's message.
-     */
-    branchBaseSha?: string;
-    /** Nested repo patches to apply after parent merge */
-    nestedPatches?: NestedRepoPatch[];
-    /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
-    extractedToolData?: Record<string, unknown[]>;
-    /**
-     * Terminal retry failure, when the subagent exited because the auto-retry
-     * loop gave up (retry-after exceeded the cap, or all attempts exhausted).
-     * Lets the parent task tool surface a "blocked: rate-limited" outcome
-     * instead of a generic failure.
-     */
-    retryFailure?: {
-        attempt: number;
-        errorMessage: string;
-    };
-    /** Output metadata for agent:// URL integration */
-    outputMeta?: {
-        lineCount: number;
-        charCount: number;
-    };
-}
-/** Tool details for TUI rendering */
-export interface TaskToolDetails {
-    projectAgentsDir: string | null;
-    results: SingleResult[];
-    totalDurationMs: number;
-    /** Aggregated usage across all subagents. */
-    usage?: Usage;
-    outputPaths?: string[];
-    progress?: AgentProgress[];
-    async?: {
-        state: "running" | "completed" | "failed";
-        jobId: string;
-        type: "task";
-    };
-}
-export {};

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

@@ -1,135 +0,0 @@
-import * as natives from "jeopi-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.
- *
- * Pre-existing dirty state in a nested repo is stashed before the patch is
- * applied and popped back (with `--index` so staged WIP stays staged) after
- * the commit, so unrelated user edits never get folded into the agent's
- * commit. A failing `git stash pop` (e.g. user edits collide with the patched
- * lines) leaves the stash entry intact, emits a `logger.warn`, and is
- * returned to the caller as a human-readable warning string — the agent
- * commit already landed, so this is a partial success the workflow needs to
- * see, not a thrown failure.
- *
- * Returns the collected stash-restore warnings (empty when every nested repo
- * was restored cleanly). Throws when the patch apply itself fails.
- *
- * @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<string[]>;
-/**
- * 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[];
-    /**
-     * SHA of the parent-repo commit the task branch was created on top of, so
-     * {@link mergeTaskBranches} can cherry-pick the range `baseSha..branchName`
-     * and preserve every agent commit's message and author.
-     */
-    baseSha?: string;
-}
-/**
- * Capture task-only changes from the isolation worktree onto a parent-repo
- * branch named `omp/task/${taskId}`. Only root-repo changes go on the branch;
- * nested-repo patches are returned separately because the parent git can't
- * track files inside gitlinks.
- *
- * If the agent committed inside isolation (HEAD moved past
- * `baseline.root.headCommit`), clean-baseline runs fetch the raw commit range
- * into the parent repo and later cherry-pick `baseSha..branchName`, preserving
- * every message and author verbatim. Dirty-baseline runs rewrite each agent
- * commit against the captured baseline WIP before committing it to the task
- * branch, so user staged/unstaged/untracked changes present at isolation
- * start are not replayed into the parent commit history.
- *
- * If the agent did not commit, the captured delta is collapsed onto a single
- * branch commit with an AI-generated (or fallback) message — the legacy
- * behaviour.
- *
- * Returns `null` when no root or nested changes exist.
- */
-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;
-    /** Set when cherry-picks landed on HEAD but restoring the stashed working tree failed. */
-    stashConflict?: string;
-}
-/**
- * Cherry-pick task branch commits sequentially onto HEAD. When `baseSha` is
- * provided the cherry-pick uses the inclusive range `baseSha..branchName`,
- * replaying every commit individually and preserving each commit's message
- * and author. When omitted, the branch is cherry-picked as a single commit
- * (legacy callers).
- *
- * Stops on the first conflict and reports which branches succeeded.
- */
-export declare function mergeTaskBranches(repoRoot: string, branches: Array<{
-    branchName: string;
-    taskId: string;
-    description?: string;
-    baseSha?: string;
-}>): Promise<MergeBranchResult>;
-/** Clean up temporary task branches. */
-export declare function cleanupTaskBranches(repoRoot: string, branches: string[]): Promise<void>;
-export {};