@sayknow-cli/coding-agent 0.3.12 → 0.3.13

package/src/tools/index.ts

@@ -122,16 +122,91 @@ export type {
 	DiscoverableToolSource,
 } from "../tool-discovery/tool-index";
 
+/** A typed remote action available to an ask answer source. */
+export type AskRemoteControlId = "navigation_forward";
+
+export interface AskRemoteControl {
+	id: AskRemoteControlId;
+	kind: "navigation";
+	label: "Next" | "Done";
+	enabled: boolean;
+}
+
+export interface AskAnswerRequest {
+	question: string;
+	options: string[];
+	interaction: "selector" | "custom_editor" | "clarification_editor";
+	controls: readonly AskRemoteControl[];
+}
+
+export type AskRemoteInteraction =
+	| { kind: "value"; value: string }
+	| { kind: "control"; controlId: AskRemoteControlId };
+
+export type AskSettlement =
+	| { kind: "commit" }
+	| {
+			kind: "resolve_without_commit";
+			reason:
+				| "toggle"
+				| "other_transition"
+				| "clarification_transition"
+				| "clarification_submitted"
+				| "empty_navigation"
+				| "back_navigation"
+				| "cancelled"
+				| "aborted"
+				| "timed_out"
+				| "exception"
+				| "shutdown";
+	  }
+	| {
+			kind: "invalid";
+			reason:
+				| "invalid_option"
+				| "invalid_control"
+				| "invalid_structured_answer"
+				| "empty_custom"
+				| "empty_clarification";
+	  };
+
+export type AskSelectedAckOutcome =
+	| { status: "delivered"; messageId: number }
+	| {
+			status: "failed";
+			reason:
+				| "unsupported"
+				| "no_participant"
+				| "ambiguous_participant"
+				| "route_missing"
+				| "expired"
+				| "cancelled"
+				| "telegram_rejected"
+				| "session_closed";
+	  }
+	| { status: "unknown"; reason: "transport_ambiguous" | "origin_disconnected" | "host_timeout" | "shutdown" };
+
+export type AskSettlementResult =
+	| { kind: "committed"; ack: AskSelectedAckOutcome }
+	| { kind: "resolved_without_commit" }
+	| { kind: "invalid_closed" };
+
+export interface AskRemoteReceipt {
+	source: "remote";
+	interaction: AskRemoteInteraction;
+	settle(value: AskSettlement): Promise<AskSettlementResult>;
+}
+
+export type AskAnswerSourceResult = AskRemoteReceipt | string | undefined;
+
 /**
- * Source of remote answers for interactive asks (e.g. a Telegram reply routed
- * through the notifications SDK). Lets a pending ask resolve without RPC mode.
+ * Source of remote answers. `awaitAnswer` remains the legacy wire for existing
+ * integrations; typed sources opt into `awaitAnswerRequest`. This keeps an old
+ * string-only source from accidentally acquiring acknowledgement authority.
  */
 export interface AskAnswerSource {
-	/**
-	 * Race a remote answer against the local UI for one question. Resolves with the
-	 * chosen option label or free-text answer, or `undefined` to defer to local UI.
-	 */
 	awaitAnswer(question: string, options: string[], signal?: AbortSignal): Promise<string | undefined>;
+	awaitAnswerRequest?(request: AskAnswerRequest, signal?: AbortSignal): Promise<AskAnswerSourceResult>;
 }
 
 /** Session context for tool factories */

package/src/tools/sqlite-reader.ts

@@ -150,13 +150,16 @@ function buildAsciiTable(columns: string[], rows: SqliteRow[]): string {
 	return lines.map(line => truncateToWidth(replaceTabs(line), MAX_RENDER_WIDTH)).join("\n");
 }
 
+const DECIMAL_INTEGER_PATTERN = /^[+-]?\d+$/;
+
 function parseLimit(value: string | null, fallback: number): number {
 	if (value === null || value.trim().length === 0) {
 		return fallback;
 	}
 
-	const parsed = Number.parseInt(value, 10);
-	if (!Number.isFinite(parsed) || parsed < 1) {
+	const normalizedValue = value.trim();
+	const parsed = Number(normalizedValue);
+	if (!DECIMAL_INTEGER_PATTERN.test(normalizedValue) || !Number.isFinite(parsed) || parsed < 1) {
 		throw new ToolError(`SQLite limit must be a positive integer; got '${value}'`);
 	}
 	return Math.min(parsed, MAX_QUERY_LIMIT);
@@ -167,8 +170,9 @@ function parseOffset(value: string | null): number {
 		return 0;
 	}
 
-	const parsed = Number.parseInt(value, 10);
-	if (!Number.isFinite(parsed) || parsed < 0) {
+	const normalizedValue = value.trim();
+	const parsed = Number(normalizedValue);
+	if (!DECIMAL_INTEGER_PATTERN.test(normalizedValue) || !Number.isFinite(parsed) || parsed < 0) {
 		throw new ToolError(`SQLite offset must be a non-negative integer; got '${value}'`);
 	}
 	return parsed;

package/src/tui/output-block.ts

@@ -1,9 +1,16 @@
 /**
  * Bordered output container with optional header and sections.
  */
-import { ImageProtocol, padding, TERMINAL, visibleWidth, wrapTextWithAnsi } from "@sayknow-cli/tui";
+import {
+	ImageProtocol,
+	isTerminalGraphicsFallbackActive,
+	padding,
+	TERMINAL,
+	visibleWidth,
+	wrapTextWithAnsi,
+} from "@sayknow-cli/tui";
 import type { Theme } from "../modes/theme/theme";
-import { getSixelLineMask } from "../utils/sixel";
+import { containsSixelSequence, getSixelLineMask } from "../utils/sixel";
 import type { State } from "./types";
 import type { RenderCache } from "./utils";
 import { getStateBgColor, Hasher, padToWidth, truncateToWidth } from "./utils";
@@ -81,13 +88,17 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 			);
 		}
 		const allLines = section.lines.flatMap(l => l.split("\n"));
-		const sixelLineMask = TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(allLines) : undefined;
+		const fallbackActive = isTerminalGraphicsFallbackActive();
+		const sixelLineMask =
+			fallbackActive || TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(allLines) : undefined;
 		for (let lineIndex = 0; lineIndex < allLines.length; lineIndex++) {
-			const line = allLines[lineIndex]!;
-			if (sixelLineMask?.[lineIndex]) {
-				lines.push(line);
+			const sixelLine = sixelLineMask?.[lineIndex] ?? false;
+			if (sixelLine && !fallbackActive) {
+				lines.push(allLines[lineIndex]!);
 				continue;
 			}
+			if (sixelLine && sixelLineMask?.[lineIndex - 1] && !containsSixelSequence(allLines[lineIndex]!)) continue;
+			const line = sixelLine ? "[SIXEL image hidden while IRC sidebar is visible]" : allLines[lineIndex]!;
 			const wrappedLines = wrapTextWithAnsi(line.trimEnd(), contentWidth);
 			for (const wrappedLine of wrappedLines) {
 				const innerPadding = padding(Math.max(0, contentWidth - visibleWidth(wrappedLine)));
@@ -137,6 +148,7 @@ export class CachedOutputBlock {
 		h.optional(options.headerMeta);
 		h.optional(options.state);
 		h.bool(options.applyBg ?? true);
+		h.bool(isTerminalGraphicsFallbackActive());
 		if (options.sections) {
 			for (const s of options.sections) {
 				h.optional(s.label);

package/src/utils/external-editor.ts

@@ -21,6 +21,11 @@ export interface OpenInEditorOptions {
 	trimTrailingNewline?: boolean;
 }
 
+/** Remove one platform-standard trailing line terminator from editor content. */
+export function trimEditorTrailingNewline(text: string): string {
+	return text.replace(/\r?\n$/, "");
+}
+
 /**
  * Opens `content` in the user's external editor and returns the edited text.
  * Returns `null` if the editor exits with a non-zero code.
@@ -52,7 +57,7 @@ export async function openInEditor(
 			if (options?.trimTrailingNewline === false) {
 				return text;
 			}
-			return text.replace(/\n$/, "");
+			return trimEditorTrailingNewline(text);
 		}
 		return null;
 	} finally {

package/dist/types/append-only-mode.d.ts

@@ -1,31 +0,0 @@
-/**
- * Single source of truth for append-only context-mode resolution and manager
- * construction. Both the initial session build (`sdk.ts`) and the runtime
- * model/setting-change path (`agent-session.ts`), plus the status UI, resolve
- * through here so the auto allowlist and prefix-reset diagnostics never drift.
- */
-import { AppendOnlyContextManager } from "@sayknow-cli/agent-core";
-/**
- * Providers for which append-only context auto-enables. Exact provider-string
- * match only: `anthropic` reached via a gateway/aggregator provider string
- * (e.g. `openrouter`, a custom gateway) does NOT match and stays opt-in via
- * `provider.appendOnlyContext: "on"`, because those transports can rewrite or
- * renormalize the request in ways that have not been validated for append-only
- * prefix stability.
- */
-export declare function providerSupportsAppendOnlyAuto(provider: string): boolean;
-/**
- * Resolve whether to enable append-only context mode based on the setting and provider.
- *
- * - `"on"` → always enable
- * - `"off"` → never enable
- * - `"auto"` → enable for providers with strong prompt-prefix caching that this
- *   harness has validated (see {@link providerSupportsAppendOnlyAuto})
- */
-export declare function resolveAppendOnlyMode(setting: "auto" | "on" | "off" | undefined, provider: string): boolean;
-/**
- * Construct an {@link AppendOnlyContextManager} wired to emit per-session
- * stable-prefix reset diagnostics. Use this at every creation site so the
- * telemetry is uniform.
- */
-export declare function createAppendOnlyContextManager(provider: string | undefined): AppendOnlyContextManager;

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

@@ -1,2 +0,0 @@
-export * from "./job-manager";
-export * from "./support";

package/dist/types/async/job-manager.d.ts

@@ -1,328 +0,0 @@
-import type { AgentProgress, AgentSource } from "../task/types";
-export interface AsyncJob {
-    id: string;
-    type: "bash" | "task";
-    status: "running" | "completed" | "failed" | "cancelled" | "paused";
-    startTime: number;
-    /**
-     * Wall-clock ms when the job left the `running` state (completed, failed,
-     * cancelled, or paused). Undefined while running. Frozen on the first
-     * terminal/pause transition so elapsed-time renderers stop counting once a
-     * job is no longer active instead of growing forever against `Date.now()`.
-     */
-    endTime?: number;
-    label: string;
-    abortController: AbortController;
-    promise: Promise<void>;
-    resultText?: string;
-    errorText?: string;
-    metadata?: AsyncJobMetadata;
-    /**
-     * Registry id of the agent that registered the job (e.g. "0-Main",
-     * "3-AuthLoader"). Used by scoped cancel/list APIs so a subagent's teardown
-     * does not cancel its parent's jobs. Undefined for callers that don't
-     * supply an id (e.g. legacy tests, SDK consumers without an agent context).
-     */
-    ownerId?: string;
-}
-/**
- * Elapsed wall-clock ms for a job, frozen once it stops running. While the job
- * is active (`endTime` undefined) this counts against `now`; after it stops it
- * returns the fixed `endTime - startTime` span so status renderers do not keep
- * incrementing a completed job's timer.
- */
-export declare function jobElapsedMs(job: Pick<AsyncJob, "startTime" | "endTime">, now?: number): number;
-export interface AsyncJobMetadata {
-    subagent?: {
-        id: string;
-        agent: string;
-        agentSource: AgentSource;
-        description?: string;
-        assignment?: string;
-    };
-    /** True when this bash job was started by the `monitor` tool (vs plain async bash). */
-    monitor?: boolean;
-}
-/**
- * Typed outcome a subagent task run may produce. A `paused` outcome is
- * non-terminal and non-delivering: the run suspended at a safe boundary and the
- * subagent can be resumed from its persisted sessionFile. `completed` always
- * wins a race with a late pause because the run returns it once it has actually
- * finished.
- */
-export type SubagentRunOutcome = {
-    kind: "completed";
-    text: string;
-} | {
-    kind: "paused";
-    note?: string;
-};
-/** Canonical lifecycle of a subagent across pause/resume cycles. */
-export type SubagentLifecycle = "running" | "paused" | "queued" | "completed" | "failed" | "cancelled";
-/**
- * Live, executor-owned control handle for a RUNNING subagent. Registered when a
- * subagent run starts and removed on pause/terminal so a paused subagent retains
- * no live `AgentSession` reference (leak-free).
- */
-export interface SubagentLiveHandle {
-    /** Request a cooperative safe-boundary pause (never aborts the in-flight tool). */
-    requestPause(): void;
-    /** Inject a steering message into the live session. */
-    injectMessage(content: string, deliverAs: "steer" | "followUp" | "nextTurn", opts?: {
-        fromAgentId?: string;
-    }): Promise<void>;
-}
-/**
- * Canonical, stable-id-keyed record for a subagent. Survives `AsyncJob`
- * eviction so resume stays addressable by subagent id, and is the single source
- * of truth for control-plane status and identity.
- */
-export interface SubagentRecord {
-    subagentId: string;
-    ownerId?: string;
-    /** Current live/last AsyncJob id; null while queued with no active job. */
-    currentJobId: string | null;
-    historicalJobIds: string[];
-    status: SubagentLifecycle;
-    sessionFile: string | null;
-    /** False for ephemeral sessions (no persistent artifacts dir). */
-    resumable: boolean;
-    queued?: {
-        ownerId?: string;
-        seq: number;
-        message?: string;
-        createdAt: number;
-    };
-    /** Resolved model the subagent was asked to use, e.g. "openai-codex/gpt-5.5". */
-    requestedModel?: string;
-    /** Model actually used after auth fallback (#985); equals requestedModel when no fallback. */
-    effectiveModel?: string;
-    /** True when the requested model lacked credentials and the subagent fell back to the parent model. */
-    modelFellBack?: boolean;
-}
-/** Lightweight, manager-owned resume payload. The async layer treats `data` as opaque. */
-export interface ResumeDescriptor {
-    subagentId: string;
-    ownerId?: string;
-    data: unknown;
-}
-export interface AsyncJobManagerOptions {
-    onJobComplete: (jobId: string, text: string, job?: AsyncJob) => void | Promise<void>;
-    maxRunningJobs?: number;
-    retentionMs?: number;
-}
-export interface AsyncJobDisposeDiagnostics {
-    stuckJobIds: string[];
-    deliveriesDrained: boolean;
-}
-export interface AsyncJobDeliveryState {
-    queued: number;
-    delivering: boolean;
-    nextRetryAt?: number;
-    pendingJobIds: string[];
-    deadLettered: number;
-}
-export interface AsyncJobLifecycleCleanup {
-    onCancel?: (job: AsyncJob) => void;
-    onTerminal?: (job: AsyncJob) => void;
-    onEvict?: (job: AsyncJob) => void;
-    /**
-     * Idempotent residual cleanup invoked by a post-eviction tombstone purge
-     * (e.g. a late `job cancel` after the job left the registry). Kept distinct
-     * from the at-most-once lifecycle phases so a tombstone purge never has to
-     * re-invoke a phase hook. Must be safe to call repeatedly.
-     */
-    onTombstonePurge?: (job: AsyncJob) => void;
-}
-export interface MonitorTombstone {
-    jobId: string;
-    ownerId?: string;
-    status: AsyncJob["status"];
-    expiresAt: number;
-    purge: () => unknown;
-}
-export interface AsyncJobRegisterOptions {
-    id?: string;
-    /** Registry id of the agent that owns this job; used to scope cancelAll. */
-    ownerId?: string;
-    /** Structured metadata for tool-specific control surfaces. */
-    metadata?: AsyncJobMetadata;
-    onProgress?: (text: string, details?: Record<string, unknown>) => void | Promise<void>;
-    lifecycle?: AsyncJobLifecycleCleanup;
-}
-/**
- * Filter applied to job query/cancel APIs. With `ownerId`, results are
- * restricted to jobs registered by that agent (registry id from
- * `AgentRegistry`, e.g. "0-Main", "3-AuthLoader").
- */
-export interface AsyncJobFilter {
-    ownerId?: string;
-}
-/**
- * A slice of process-stream output for a background job, as recorded by
- * `appendOutput` / read by `readOutputSince`.
- *
- * The cursor model is monotonic UTF-8 byte offsets. `nextOffset` is the offset
- * to pass to the next read to receive only fresh bytes; `startOffset` is the
- * first byte the manager still retains for this job. When the requested offset
- * is older than `startOffset`, the manager returns the retained tail and sets
- * `truncated: true`.
- */
-export interface AsyncJobOutputSlice {
-    jobId: string;
-    status: AsyncJob["status"];
-    text: string;
-    startOffset: number;
-    nextOffset: number;
-    truncated: boolean;
-}
-/** Default retention cap for per-job captured output. ~512 KiB matches the
- *  bash tail-buffer order of magnitude without dominating session memory. */
-export declare const DEFAULT_JOB_OUTPUT_RETENTION_BYTES: number;
-export declare class AsyncJobManager {
-    #private;
-    /** Process-global instance shared by internal URL protocol handlers and tools. */
-    static instance(): AsyncJobManager | undefined;
-    /** Install or clear the process-global instance. */
-    static setInstance(value: AsyncJobManager | undefined): void;
-    /** Reset the process-global instance. Test-only. */
-    static resetForTests(): void;
-    constructor(options: AsyncJobManagerOptions);
-    /**
-     * Subscribe to live-job-set change events. Returns an unsubscribe function.
-     * Listener errors are isolated so one bad subscriber cannot break others.
-     */
-    onChange(cb: () => void): () => void;
-    register(type: "bash" | "task", label: string, run: (ctx: {
-        jobId: string;
-        signal: AbortSignal;
-        reportProgress: (text: string, details?: Record<string, unknown>) => Promise<void>;
-    }) => Promise<string | SubagentRunOutcome>, options?: AsyncJobRegisterOptions): string;
-    /**
-     * Cancel a single job by id. When `filter.ownerId` is set and does not
-     * match the job's owner, the call is treated as not-found (returns false)
-     * so cross-agent cancellation is rejected at the manager level.
-     */
-    cancel(id: string, filter?: AsyncJobFilter): boolean;
-    getMonitorTombstone(jobId: string, filter?: AsyncJobFilter): MonitorTombstone | undefined;
-    purgeMonitorTombstone(jobId: string, filter?: AsyncJobFilter): {
-        found: boolean;
-        status?: AsyncJob["status"];
-    };
-    /** Register or replace the canonical record for a subagent. */
-    registerSubagentRecord(record: SubagentRecord): void;
-    /** Patch model metadata onto an existing subagent record (best-effort; no-op if unknown). */
-    updateSubagentModel(subagentId: string, model: {
-        requestedModel?: string;
-        effectiveModel?: string;
-        modelFellBack?: boolean;
-    }): void;
-    getSubagentRecord(subagentId: string, filter?: AsyncJobFilter): SubagentRecord | undefined;
-    getSubagentRecords(filter?: AsyncJobFilter): SubagentRecord[];
-    registerLiveHandle(subagentId: string, handle: SubagentLiveHandle): void;
-    getLiveHandle(subagentId: string): SubagentLiveHandle | undefined;
-    removeLiveHandle(subagentId: string): void;
-    /**
-     * Retain the latest live `AgentProgress` for a subagent (deep-cloned so later
-     * mutation of the live object cannot corrupt retained state). Read by the
-     * `subagent` await panel; cleared on terminal/cancel/purge/dispose.
-     *
-     * Ignored for ids without a canonical `SubagentRecord` (e.g. foreground/inline
-     * task runs that share the executor path) so the map only holds detached
-     * subagent progress and never accumulates untracked foreground task state.
-     */
-    recordSubagentProgress(subagentId: string, progress: AgentProgress): void;
-    getSubagentProgress(subagentId: string): AgentProgress | undefined;
-    /**
-     * True only when a live, in-session progress producer exists for this id: a
-     * canonical registered record with a live handle or an in-memory running job.
-     * False for `SubagentTool` backward-compat job synthesis and resumed-from-disk
-     * records, which have no live producer to stream from.
-     */
-    hasLiveSubagent(subagentId: string, filter?: AsyncJobFilter): boolean;
-    /** Install the TaskTool-owned resume runner. Returns the new job id, or undefined on failure. */
-    setResumeRunner(runner: (subagentId: string, message?: string, descriptor?: ResumeDescriptor) => string | undefined): void;
-    registerResumeDescriptor(descriptor: ResumeDescriptor): void;
-    getResumeDescriptor(subagentId: string, filter?: AsyncJobFilter): ResumeDescriptor | undefined;
-    /** Request a graceful safe-boundary pause of a running subagent. */
-    pauseSubagent(subagentId: string, filter?: AsyncJobFilter): {
-        ok: boolean;
-        status?: SubagentLifecycle;
-        reason?: string;
-    };
-    /** Resume a non-running subagent from its sessionFile, optionally injecting a message first. */
-    resumeSubagent(subagentId: string, filter?: AsyncJobFilter, message?: string): {
-        ok: boolean;
-        status?: SubagentLifecycle;
-        jobId?: string;
-        queued?: boolean;
-        reason?: string;
-    };
-    /** Cancel a subagent by stable id across running/paused/queued states (keeps the session file). */
-    cancelSubagent(subagentId: string, filter?: AsyncJobFilter): boolean;
-    getJob(id: string): AsyncJob | undefined;
-    getRunningJobs(filter?: AsyncJobFilter): AsyncJob[];
-    getRecentJobs(limit?: number, filter?: AsyncJobFilter): AsyncJob[];
-    getAllJobs(filter?: AsyncJobFilter): AsyncJob[];
-    /**
-     * Append a sanitized process-stream chunk for a background job. Called from
-     * the unthrottled bash-executor capture hook (`onRawChunk`) so monitor sees
-     * every chunk even when preview/progress callbacks are throttled.
-     *
-     * Offsets are in UTF-8 bytes. Storing chunk metadata avoids unsafe byte
-     * slicing across multibyte characters at read time. The retention window is
-     * a per-job rolling cap (`DEFAULT_JOB_OUTPUT_RETENTION_BYTES`); when it
-     * overflows, oldest whole chunks are evicted and `startOffset` advances —
-     * subsequent reads from a stale offset get `truncated: true`.
-     */
-    appendOutput(jobId: string, chunk: string): void;
-    /**
-     * Read fresh process-stream output for a job since `offset` (in UTF-8
-     * bytes). Returns `undefined` when the job does not exist or when an
-     * `ownerId` filter is set and the job belongs to a different owner — this
-     * mirrors the manager-level "not found" pattern used by `cancel`.
-     *
-     * - `offset < startOffset` returns the retained tail with `truncated: true`.
-     * - `offset > nextOffset` clamps to `nextOffset` and returns an empty text
-     *   slice with `truncated: false`.
-     * - Assembled text slices the leading retained chunk at a UTF-8 codepoint
-     *   boundary when needed, so multibyte characters cannot be split.
-     */
-    readOutputSince(jobId: string, offset: number, filter?: AsyncJobFilter): AsyncJobOutputSlice | undefined;
-    /**
-     * Register an owner-scoped cleanup callback. Returns an unregister function.
-     *
-     * Used by Cron* tools to clear session-scoped timers when the owning agent
-     * is torn down. Invoked by `runOwnerCleanups({ ownerId })` before
-     * `cancelAll({ ownerId })` so timers cannot register new jobs during
-     * teardown.
-     */
-    registerOwnerCleanup(ownerId: string, cleanup: () => void): () => void;
-    /**
-     * Run and clear every registered cleanup for the given filter. Idempotent
-     * and error-isolated: a throwing cleanup does not prevent siblings from
-     * running and never escalates to the caller.
-     */
-    runOwnerCleanups(filter?: AsyncJobFilter): void;
-    getDeliveryState(filter?: AsyncJobFilter): AsyncJobDeliveryState;
-    hasPendingDeliveries(filter?: AsyncJobFilter): boolean;
-    watchJobs(jobIds: string[]): number;
-    unwatchJobs(jobIds: string[]): number;
-    acknowledgeDeliveries(jobIds: string[]): number;
-    /**
-     * Cancel running jobs. With `filter.ownerId` set, cancels only jobs the
-     * matching agent registered; with no filter, cancels every running job
-     * (used by `dispose()` to nuke the manager's state).
-     */
-    cancelAll(filter?: AsyncJobFilter): void;
-    getLastDisposeDiagnostics(): AsyncJobDisposeDiagnostics;
-    waitForAll(): Promise<void>;
-    drainDeliveries(options?: {
-        timeoutMs?: number;
-        filter?: AsyncJobFilter;
-    }): Promise<boolean>;
-    dispose(options?: {
-        timeoutMs?: number;
-    }): Promise<boolean>;
-    isDeliverySuppressed(jobId: string): boolean;
-}

package/dist/types/async/support.d.ts

@@ -1,2 +0,0 @@
-import type { Settings } from "../config/settings";
-export declare function isBackgroundJobSupportEnabled(settings: Pick<Settings, "get">): boolean;

package/dist/types/autoresearch/dashboard.d.ts

@@ -1,4 +0,0 @@
-import type { Theme } from "../modes/theme/theme";
-import type { AutoresearchRuntime, DashboardController } from "./types";
-export declare function createDashboardController(): DashboardController;
-export declare function renderDashboardLines(runtime: AutoresearchRuntime, width: number, theme: Theme, maxRows: number): string[];

package/dist/types/autoresearch/git.d.ts

@@ -1,36 +0,0 @@
-import type { ExtensionAPI } from "../extensibility/extensions";
-export interface EnsureAutoresearchBranchFailure {
-    error: string;
-    ok: false;
-}
-export interface EnsureAutoresearchBranchSuccess {
-    branchName: string | null;
-    created: boolean;
-    ok: true;
-    warning?: string;
-}
-export type EnsureAutoresearchBranchResult = EnsureAutoresearchBranchFailure | EnsureAutoresearchBranchSuccess;
-export declare function getCurrentAutoresearchBranch(_api: ExtensionAPI, workDir: string): Promise<string | null>;
-/**
- * Ensure the working tree is on an `autoresearch/*` branch when possible.
- *
- * If the worktree is dirty and we're not already on an autoresearch branch, this returns
- * `{ ok: true, branchName: null, warning }` rather than failing. The caller surfaces the
- * warning and continues on the current branch — `keep` will skip auto-commits and `discard`
- * will revert only run-modified paths instead of resetting to baseline.
- */
-export declare function ensureAutoresearchBranch(api: ExtensionAPI, workDir: string, goal: string | null): Promise<EnsureAutoresearchBranchResult>;
-export declare function parseWorkDirDirtyPaths(statusOutput: string, workDirPrefix: string): string[];
-export declare function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPrefix: string): string | null;
-export declare function parseDirtyPaths(statusOutput: string): string[];
-export declare function normalizeStatusPath(rawPath: string): string;
-export interface DirtyPathEntry {
-    path: string;
-    untracked: boolean;
-}
-export declare function parseDirtyPathsWithStatus(statusOutput: string): DirtyPathEntry[];
-export declare function parseWorkDirDirtyPathsWithStatus(statusOutput: string, workDirPrefix: string): DirtyPathEntry[];
-export declare function computeRunModifiedPaths(preRunDirtyPaths: string[], currentStatusOutput: string, workDirPrefix: string): {
-    tracked: string[];
-    untracked: string[];
-};

package/dist/types/autoresearch/helpers.d.ts

@@ -1,24 +0,0 @@
-import type { ASIData, MetricDirection, NumericMetricMap } from "./types";
-export declare const METRIC_LINE_PREFIX = "METRIC";
-export declare const ASI_LINE_PREFIX = "ASI";
-export declare const EXPERIMENT_MAX_LINES = 10;
-export declare const EXPERIMENT_MAX_BYTES: number;
-export declare function parseMetricLines(output: string): Map<string, number>;
-export declare function parseAsiLines(output: string): ASIData | null;
-export declare function mergeAsi(base: ASIData | null, override: ASIData | undefined): ASIData | undefined;
-export declare function commas(value: number): string;
-export declare function fmtNum(value: number, decimals?: number): string;
-export declare function formatNum(value: number | null, unit: string): string;
-export declare function formatElapsed(milliseconds: number): string;
-export declare function killTree(pid: number, signal?: NodeJS.Signals | number): void;
-export declare function isBetter(current: number, best: number, direction: MetricDirection): boolean;
-export declare function inferMetricUnitFromName(name: string): string;
-export declare function normalizePathSpec(value: string): string;
-export declare function pathMatchesSpec(pathValue: string, specValue: string): boolean;
-export declare function dedupeStrings(values: readonly string[]): string[];
-export declare function ensureNumericMetricMap(value: NumericMetricMap | undefined): NumericMetricMap;
-export declare function sanitizeAsi(value: {
-    [key: string]: unknown;
-} | undefined): ASIData | undefined;
-export declare function tryGitStatus(cwd: string): Promise<string>;
-export declare function tryGitPrefix(cwd: string): Promise<string>;

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

@@ -1,2 +0,0 @@
-import type { ExtensionFactory } from "../extensibility/extensions";
-export declare const createAutoresearchExtension: ExtensionFactory;

package/dist/types/autoresearch/state.d.ts

@@ -1,17 +0,0 @@
-import type { SessionEntry } from "../session/session-manager";
-import type { RunRow, SessionRow } from "./storage";
-import type { AutoresearchRuntime, ExperimentResult, ExperimentState, MetricDef, MetricDirection, NumericMetricMap, ReconstructedControlState, RuntimeStore } from "./types";
-export declare function createExperimentState(): ExperimentState;
-export declare function createSessionRuntime(): AutoresearchRuntime;
-export declare function cloneExperimentState(state: ExperimentState): ExperimentState;
-export declare function currentResults(results: ExperimentResult[], segment: number): ExperimentResult[];
-export declare function findBaselineResult(results: ExperimentResult[], segment: number): ExperimentResult | null;
-export declare function findBaselineMetric(results: ExperimentResult[], segment: number): number | null;
-export declare function findBestKeptMetric(results: ExperimentResult[], segment: number, direction: MetricDirection): number | null;
-export declare function findBaselineRunNumber(results: ExperimentResult[], segment: number): number | null;
-export declare function findBaselineSecondary(results: ExperimentResult[], segment: number, knownMetrics: MetricDef[]): NumericMetricMap;
-export declare function sortedMedian(values: number[]): number;
-export declare function computeConfidence(results: ExperimentResult[], segment: number, direction: MetricDirection): number | null;
-export declare function buildExperimentState(session: SessionRow, loggedRuns: RunRow[]): ExperimentState;
-export declare function reconstructControlState(entries: SessionEntry[]): ReconstructedControlState;
-export declare function createRuntimeStore(): RuntimeStore;