@sayknow-cli/coding-agent 0.3.11 → 0.3.13

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;

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

@@ -1,142 +0,0 @@
-import type { ASIData, ExperimentStatus, MetricDirection, NumericMetricMap } from "./types";
-export interface SessionRow {
-    id: number;
-    name: string;
-    goal: string | null;
-    primaryMetric: string;
-    metricUnit: string;
-    direction: MetricDirection;
-    preferredCommand: string | null;
-    branch: string | null;
-    baselineCommit: string | null;
-    currentSegment: number;
-    maxIterations: number | null;
-    scopePaths: string[];
-    offLimits: string[];
-    constraints: string[];
-    secondaryMetrics: string[];
-    notes: string;
-    createdAt: number;
-    closedAt: number | null;
-}
-export interface RunRow {
-    id: number;
-    sessionId: number;
-    segment: number;
-    command: string;
-    startedAt: number;
-    completedAt: number | null;
-    durationMs: number | null;
-    exitCode: number | null;
-    timedOut: boolean;
-    parsedPrimary: number | null;
-    parsedMetrics: NumericMetricMap | null;
-    parsedAsi: ASIData | null;
-    preRunDirtyPaths: string[];
-    logPath: string;
-    status: ExperimentStatus | null;
-    description: string | null;
-    metric: number | null;
-    metrics: NumericMetricMap | null;
-    asi: ASIData | null;
-    commitHash: string | null;
-    confidence: number | null;
-    modifiedPaths: string[] | null;
-    scopeDeviations: string[] | null;
-    justification: string | null;
-    flagged: boolean;
-    flaggedReason: string | null;
-    loggedAt: number | null;
-    abandonedAt: number | null;
-}
-export interface OpenSessionParams {
-    name: string;
-    goal: string | null;
-    primaryMetric: string;
-    metricUnit: string;
-    direction: MetricDirection;
-    preferredCommand: string | null;
-    branch: string | null;
-    baselineCommit: string | null;
-    maxIterations: number | null;
-    scopePaths: string[];
-    offLimits: string[];
-    constraints: string[];
-    secondaryMetrics: string[];
-}
-export interface UpdateSessionParams {
-    goal?: string | null;
-    preferredCommand?: string | null;
-    maxIterations?: number | null;
-    scopePaths?: string[];
-    offLimits?: string[];
-    constraints?: string[];
-    secondaryMetrics?: string[];
-    primaryMetric?: string;
-    metricUnit?: string;
-    direction?: MetricDirection;
-    branch?: string | null;
-    baselineCommit?: string | null;
-    notes?: string;
-}
-export interface InsertRunParams {
-    sessionId: number;
-    segment: number;
-    command: string;
-    logPath: string;
-    preRunDirtyPaths: string[];
-    startedAt: number;
-}
-export interface MarkRunCompletedParams {
-    runId: number;
-    completedAt: number;
-    durationMs: number;
-    exitCode: number | null;
-    timedOut: boolean;
-    parsedPrimary: number | null;
-    parsedMetrics: NumericMetricMap | null;
-    parsedAsi: ASIData | null;
-}
-export interface MarkRunLoggedParams {
-    runId: number;
-    status: ExperimentStatus;
-    description: string;
-    metric: number;
-    metrics: NumericMetricMap;
-    asi: ASIData | null;
-    commitHash: string | null;
-    confidence: number | null;
-    modifiedPaths: string[];
-    scopeDeviations: string[];
-    justification: string | null;
-    loggedAt: number;
-}
-export declare class AutoresearchStorage {
-    #private;
-    constructor(dbPath: string, projectDir: string);
-    get dbPath(): string;
-    get projectDir(): string;
-    close(): void;
-    getActiveSession(): SessionRow | null;
-    getActiveSessionForBranch(branch: string | null): SessionRow | null;
-    getSessionById(sessionId: number): SessionRow | null;
-    openSession(params: OpenSessionParams): SessionRow;
-    updateSession(sessionId: number, updates: UpdateSessionParams): SessionRow;
-    bumpSegment(sessionId: number): SessionRow;
-    closeSession(sessionId: number): void;
-    insertRun(params: InsertRunParams): RunRow;
-    updateRunLogPath(runId: number, logPath: string): RunRow;
-    updateRunConfidence(runId: number, confidence: number | null): RunRow;
-    markRunCompleted(params: MarkRunCompletedParams): RunRow;
-    markRunLogged(params: MarkRunLoggedParams): RunRow;
-    flagRun(runId: number, reason: string): RunRow;
-    abandonPendingRuns(sessionId: number): number;
-    getPendingRun(sessionId: number): RunRow | null;
-    getRunById(runId: number): RunRow | null;
-    getRunByIdRequired(runId: number): RunRow;
-    listRuns(sessionId: number): RunRow[];
-    listLoggedRuns(sessionId: number): RunRow[];
-}
-export declare function openAutoresearchStorage(cwd: string): Promise<AutoresearchStorage>;
-export declare function openAutoresearchStorageIfExists(cwd: string): Promise<AutoresearchStorage | null>;
-export declare function closeAllAutoresearchStorages(): void;

package/dist/types/autoresearch/tools/init-experiment.d.ts

@@ -1,31 +0,0 @@
-import * as z from "zod/v4";
-import type { ToolDefinition } from "../../extensibility/extensions";
-import type { AutoresearchToolFactoryOptions, ExperimentState } from "../types";
-export declare const HARNESS_FILENAME = "autoresearch.sh";
-export declare const DEFAULT_HARNESS_COMMAND = "bash autoresearch.sh";
-declare const initExperimentSchema: z.ZodObject<{
-    name: z.ZodString;
-    goal: z.ZodOptional<z.ZodString>;
-    primary_metric: z.ZodString;
-    metric_unit: z.ZodOptional<z.ZodString>;
-    direction: z.ZodOptional<z.ZodEnum<{
-        higher: "higher";
-        lower: "lower";
-    }>>;
-    secondary_metrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    scope_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    off_limits: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    max_iterations: z.ZodOptional<z.ZodNumber>;
-    new_segment: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-interface InitExperimentDetails {
-    state: ExperimentState;
-    createdSession: boolean;
-    bumpedSegment: boolean;
-    abandonedRuns: number;
-    harnessCommitted: boolean;
-    baselineCommit: string | null;
-}
-export declare function createInitExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof initExperimentSchema, InitExperimentDetails>;
-export {};

package/dist/types/autoresearch/tools/log-experiment.d.ts

@@ -1,23 +0,0 @@
-import * as z from "zod/v4";
-import type { ToolDefinition } from "../../extensibility/extensions";
-import type { AutoresearchToolFactoryOptions, LogDetails } from "../types";
-declare const logExperimentSchema: z.ZodObject<{
-    metric: z.ZodNumber;
-    status: z.ZodEnum<{
-        checks_failed: "checks_failed";
-        crash: "crash";
-        discard: "discard";
-        keep: "keep";
-    }>;
-    description: z.ZodString;
-    metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    asi: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    commit: z.ZodOptional<z.ZodString>;
-    justification: z.ZodOptional<z.ZodString>;
-    flag_runs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        run_id: z.ZodNumber;
-        reason: z.ZodString;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export declare function createLogExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof logExperimentSchema, LogDetails>;
-export {};

package/dist/types/autoresearch/tools/run-experiment.d.ts

@@ -1,8 +0,0 @@
-import * as z from "zod/v4";
-import type { ToolDefinition } from "../../extensibility/extensions";
-import type { AutoresearchToolFactoryOptions, RunDetails, RunExperimentProgressDetails } from "../types";
-declare const runExperimentSchema: z.ZodObject<{
-    timeout_seconds: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare function createRunExperimentTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof runExperimentSchema, RunDetails | RunExperimentProgressDetails>;
-export {};

package/dist/types/autoresearch/tools/update-notes.d.ts

@@ -1,12 +0,0 @@
-import * as z from "zod/v4";
-import type { ToolDefinition } from "../../extensibility/extensions";
-import type { AutoresearchToolFactoryOptions } from "../types";
-declare const updateNotesSchema: z.ZodObject<{
-    body: z.ZodString;
-    append_idea: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-interface UpdateNotesDetails {
-    notes: string;
-}
-export declare function createUpdateNotesTool(options: AutoresearchToolFactoryOptions): ToolDefinition<typeof updateNotesSchema, UpdateNotesDetails>;
-export {};