jeopi-cli 16.2.13 → 16.2.14

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

@@ -1,6 +0,0 @@
-export * from "./advise-tool";
-export * from "./config";
-export * from "./emission-guard";
-export * from "./runtime";
-export * from "./transcript-recorder";
-export * from "./watchdog";

package/dist/types/advisor/runtime.d.ts

@@ -1,76 +0,0 @@
-import type { AgentMessage } from "jeopi-agent-core";
-import { type SecretObfuscator } from "../secrets/obfuscator";
-/**
- * Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core
- * `Agent`. `state.error` mirrors `Agent.state.error`: provider/stream failures
- * the loop catches internally never reject `prompt()`, so the runtime reads
- * this field after every prompt to detect a failed turn.
- */
-export interface AdvisorAgent {
-    prompt(input: string): Promise<void>;
-    abort(reason?: unknown): void;
-    reset(): void;
-    /**
-     * Drop messages appended past `count`. Called after a failed `prompt()` so a
-     * retry doesn't replay the failed user batch + synthetic assistant-error
-     * turn `Agent.#runLoop` records on its internal state.
-     */
-    rollbackTo?(count: number): void;
-    readonly state: {
-        messages: AgentMessage[];
-        error?: string;
-    };
-}
-export interface AdvisorRuntimeHost {
-    /** Live primary transcript (use `agent.state.messages`). */
-    snapshotMessages(): AgentMessage[];
-    /** Surface one advice note to the primary (enqueues into the session YieldQueue). */
-    enqueueAdvice(note: string, severity?: "nit" | "concern" | "blocker"): void;
-    /** Redact primary transcript bytes before they reach the advisor model. */
-    obfuscator?: SecretObfuscator;
-    /**
-     * Pre-prompt context maintenance for the advisor's own append-only context.
-     * Promotes the advisor model to a larger sibling when its context nears the
-     * window (mirroring the primary's promote-first policy) and resolves `true`
-     * when the advisor should re-prime — reset and replay the current
-     * primary-bounded transcript — because promotion did not free enough room.
-     * Optional: hosts that omit it get no maintenance (context only shrinks when
-     * the primary's next compaction triggers {@link AdvisorRuntime.reset}).
-     */
-    maintainContext?(incomingTokens: number): Promise<boolean>;
-    /**
-     * Called immediately before each `agent.prompt(batch)` cycle. Lets the host
-     * clear per-update advisor state — currently the one-advise-per-update gate
-     * in {@link AdvisorEmissionGuard}, which the host owns because it is the
-     * one that routes `advise()` results back to the primary.
-     */
-    beginAdvisorUpdate?(): void;
-    /** Surface a non-recovering advisor failure to the host UI without adding model-visible context. */
-    notifyFailure?(error: unknown): void;
-}
-export declare class AdvisorRuntime {
-    #private;
-    private readonly agent;
-    private readonly host;
-    private readonly retryDelayMs;
-    disposed: boolean;
-    constructor(agent: AdvisorAgent, host: AdvisorRuntimeHost, retryDelayMs?: number);
-    get backlog(): number;
-    onTurnEnd(messages?: AgentMessage[]): void;
-    waitForCatchup(maxMs: number, threshold: number, signal?: AbortSignal): Promise<void>;
-    dispose(): void;
-    /**
-     * Re-prime the advisor after a history rewrite (compaction, session
-     * switch/resume, branch). Clears the advisor's own (non-persisted) context
-     * and rewinds the cursor to 0 so the NEXT turn replays the full current —
-     * post-compaction — transcript, giving the advisor fresh context instead of
-     * leaving it blind to everything before the rewrite.
-     */
-    reset(): void;
-    /**
-     * Seed the cursor to the current transcript length when the advisor is enabled
-     * mid-session. Prevents the next turn from replaying the entire history to the
-     * advisor (which would be expensive and likely stale).
-     */
-    seedTo(count: number): void;
-}

package/dist/types/advisor/transcript-recorder.d.ts

@@ -1,63 +0,0 @@
-import type { AgentMessage } from "jeopi-agent-core";
-/**
- * Reserved transcript stem for advisor session files. Chosen so it cannot
- * collide with a task subagent's `<id>.jsonl` (task ids are reserved against
- * this exact stem in {@link AgentOutputManager}).
- */
-export declare const ADVISOR_TRANSCRIPT_STEM = "__advisor";
-export declare const ADVISOR_TRANSCRIPT_FILENAME = "__advisor.jsonl";
-/**
- * Transcript filename for an advisor: `__advisor.jsonl` for the legacy/default
- * advisor (empty slug), `__advisor.<slug>.jsonl` for a named advisor. The `.`
- * separator keeps named files out of the output manager's `-<n>` bump namespace.
- */
-export declare function advisorTranscriptFilename(slug: string): string;
-/** Whether a filename is any advisor transcript (`__advisor.jsonl` or `__advisor.<slug>.jsonl`). */
-export declare function isAdvisorTranscriptName(name: string): boolean;
-/**
- * Append-only persister for an advisor agent's transcript.
- *
- * The advisor is a passive reviewer with its own model usage, so — like a task
- * subagent — its turns are written to a JSONL inside the owning session's
- * artifacts dir (`<session>/__advisor.jsonl`, `<session>/<SubId>/__advisor.jsonl`
- * for subagent advisors). That single file gives the advisor model proper usage
- * attribution in `jeopi stats` (the stats parser scans the session dir
- * recursively) and a read-only transcript in the Agent Hub, without making the
- * advisor a registered, messageable peer.
- *
- * The target is derived from the *session file* (`getSessionFile()`), never
- * `getArtifactsDir()` — subagents adopt the parent's artifact manager, so the
- * artifacts dir points at the parent root and every subagent advisor would
- * collide. The file path is resolved synchronously when a message finalizes and
- * captured for the queued write, so a `/new`, resume, or session switch in
- * flight can never misattribute an old advisor turn into the new session's file.
- * On such a switch the previous writer is closed and the new file opened on the
- * next recorded turn. The recorder never truncates: the advisor's in-memory
- * context resets/compacts independently, but every billed turn is appended here.
- */
-export declare class AdvisorTranscriptRecorder {
-    #private;
-    private readonly resolveSessionFile;
-    private readonly resolveCwd;
-    /**
-     * @param filename Transcript filename within the session dir. Defaults to
-     *   `__advisor.jsonl`; named advisors pass `__advisor.<slug>.jsonl` via
-     *   {@link advisorTranscriptFilename}.
-     * @param after Optional barrier the queue starts behind — used on the advisor
-     *   on→off→on toggle so a fresh recorder's first `open` waits for the prior
-     *   recorder's `close` and the two never hold the same file at once.
-     */
-    constructor(resolveSessionFile: () => string | undefined, resolveCwd: () => string, filename?: string, after?: Promise<unknown>);
-    /**
-     * Persist one finalized advisor message. Assistant turns carry the usage the
-     * stats parser reads; tool results round out the Hub transcript; user deltas
-     * (the advisor's "session update" prompts) are persisted but flagged
-     * `synthetic`/agent-attributed so they never inflate user-message metrics.
-     * Non-conversational message kinds are skipped.
-     */
-    record(message: AgentMessage): void;
-    /** Flush pending writes (best-effort). */
-    flush(): Promise<void>;
-    /** Flush and close the writer, releasing the session file. */
-    close(): Promise<void>;
-}

package/dist/types/advisor/watchdog.d.ts

@@ -1,38 +0,0 @@
-import type { ActiveRepoContext } from "../utils/active-repo-context";
-export declare function formatActiveRepoWatchdogPrompt(activeRepoContext: ActiveRepoContext): string;
-/**
- * Render the project context files (AGENTS.md and the like) into a block for the
- * advisor's system prompt, mirroring how the primary agent receives them. Gives
- * the read-only reviewer the user's standing project instructions so it can hold
- * the driving agent to them instead of advising against project conventions it
- * cannot otherwise see. Returns undefined when there are no context files.
- */
-export declare function formatAdvisorContextPrompt(contextFiles: ReadonlyArray<{
-    path: string;
-    content: string;
-}>): string | undefined;
-/**
- * A readable config candidate discovered on the watchdog/advisor search path,
- * with raw (un-expanded) content and its position metadata.
- */
-export interface ConfigCandidate {
-    path: string;
-    content: string;
-    level: "user" | "project";
-    depth: number;
-}
-/**
- * Walk the watchdog/advisor config search path — the user agent dir plus every
- * directory from `cwd` up to the repo root (or home), probing both `<F>` and
- * `.omp/<F>` for each given filename — and return the readable candidates with
- * their raw content, sorted user-first then project ancestor→leaf (depth
- * descending, so the leaf directory is most specific/last). Shared by
- * {@link discoverWatchdogFiles} and `discoverAdvisorConfigs`. Content is returned
- * verbatim (no `@import` expansion); callers expand what they need.
- */
-export declare function collectConfigCandidates(cwd: string, agentDir: string | undefined, filenames: string[]): Promise<ConfigCandidate[]>;
-/**
- * Discover and load WATCHDOG.md files walking up from cwd, project .omp folder, and user agent dir.
- * Returns formatted watchdog file blocks ready to be appended to the advisor system prompt.
- */
-export declare function discoverWatchdogFiles(cwd: string, agentDir?: string): Promise<string[]>;

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

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

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

@@ -1,121 +0,0 @@
-export interface AsyncJob {
-    id: string;
-    type: "bash" | "task";
-    status: "running" | "completed" | "failed" | "cancelled";
-    startTime: number;
-    label: string;
-    abortController: AbortController;
-    promise: Promise<void>;
-    resultText?: string;
-    errorText?: string;
-    /**
-     * Registry id of the agent that registered the job (e.g. "Main",
-     * "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;
-    /**
-     * Job is registered but parked behind a caller-managed gate (e.g. a task
-     * batch semaphore). Queued jobs do not count toward the running-job limit
-     * until the caller invokes `markRunning()` from the run context.
-     */
-    queued?: boolean;
-}
-export interface AsyncJobManagerOptions {
-    onJobComplete: (jobId: string, text: string, job?: AsyncJob) => void | Promise<void>;
-    maxRunningJobs?: number;
-    retentionMs?: number;
-}
-export interface AsyncJobDeliveryState {
-    queued: number;
-    delivering: boolean;
-    nextRetryAt?: number;
-    pendingJobIds: string[];
-}
-export interface AsyncJobRegisterOptions {
-    id?: string;
-    /** Registry id of the agent that owns this job; used to scope cancelAll. */
-    ownerId?: string;
-    onProgress?: (text: string, details?: Record<string, unknown>) => void | Promise<void>;
-    /** Register the job in queued state; see {@link AsyncJob.queued}. */
-    queued?: boolean;
-}
-/**
- * Filter applied to job query/cancel APIs. With `ownerId`, results are
- * restricted to jobs registered by that agent (registry id from
- * `AgentRegistry`, e.g. "Main", "AuthLoader").
- */
-export interface AsyncJobFilter {
-    ownerId?: string;
-}
-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);
-    /** True when the running-job count has reached the configured cap. */
-    get atCapacity(): boolean;
-    register(type: "bash" | "task", label: string, run: (ctx: {
-        jobId: string;
-        signal: AbortSignal;
-        reportProgress: (text: string, details?: Record<string, unknown>) => Promise<void>;
-        /** Clear the queued flag once the job actually starts executing. */
-        markRunning: () => void;
-    }) => Promise<string>, 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;
-    getJob(id: string): AsyncJob | undefined;
-    getRunningJobs(filter?: AsyncJobFilter): AsyncJob[];
-    getRecentJobs(limit?: number, filter?: AsyncJobFilter): AsyncJob[];
-    getAllJobs(filter?: AsyncJobFilter): AsyncJob[];
-    getDeliveryState(filter?: AsyncJobFilter): AsyncJobDeliveryState;
-    hasPendingDeliveries(filter?: AsyncJobFilter): boolean;
-    watchJobs(jobIds: string[]): number;
-    unwatchJobs(jobIds: string[]): number;
-    /**
-     * Compute the next adaptive ("smart") wait (ms) for a blocking `job` poll by
-     * the given owner. Consecutive polls — those starting within
-     * POLL_ESCALATION_RESET_MS of the previous poll returning — climb
-     * POLL_WAIT_LADDER_MS so a tight wait loop backs off; a longer gap means the
-     * agent left to do real work, so the wait resets to the floor. Pair each call
-     * with `recordPollWaitEnd()` once the wait returns.
-     */
-    nextPollWaitMs(ownerId: string | undefined, now?: number): number;
-    /**
-     * Mark a blocking poll wait as finished so the idle-reset window is measured
-     * from now. Polling again before POLL_ESCALATION_RESET_MS elapses keeps
-     * climbing the ladder; waiting longer resets it to the floor.
-     */
-    recordPollWaitEnd(ownerId: string | undefined, now?: number): void;
-    acknowledgeDeliveries(jobIds: string[]): number;
-    /**
-     * Lift a foreground-wait suppression set via `acknowledgeDeliveries`. If the
-     * job already finished while suppressed (its delivery enqueue was skipped),
-     * re-enqueue the completion so the result is still delivered exactly once.
-     */
-    resumeDeliveries(jobIds: string[]): void;
-    /**
-     * 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;
-    waitForAll(): Promise<void>;
-    drainDeliveries(options?: {
-        timeoutMs?: number;
-        filter?: AsyncJobFilter;
-    }): Promise<boolean>;
-    dispose(options?: {
-        timeoutMs?: number;
-    }): Promise<boolean>;
-    isDeliverySuppressed(jobId: string): boolean;
-}

package/dist/types/auto-thinking/classifier.d.ts

@@ -1,37 +0,0 @@
-/**
- * Per-prompt difficulty classifier for the `auto` thinking level.
- *
- * Picks a coding-difficulty bucket for a user prompt and maps it to a concrete
- * {@link Effort}, clamped into the active model's supported range (never below
- * {@link Effort.Low}). Two backends, selected by `providers.autoThinkingModel`:
- *
- * - `online` (default): a smol model classifies into `low|medium|high|xhigh`.
- * - a local key: an on-device memory model classifies into the coarser
- *   `trivial|moderate|hard` scheme (3-class is more reliable than 4-way ordinal
- *   on sub-2B models), mapped to `low|high|xhigh`.
- *
- * Throws on any failure (no model, no key, unparseable output, abort/timeout);
- * the caller falls back to a concrete level and continues the turn.
- */
-import { Effort, type Model } from "jeopi-ai";
-import type { ModelRegistry } from "../config/model-registry";
-import type { Settings } from "../config/settings";
-export interface ClassifyDifficultyDeps {
-    settings: Settings;
-    registry: ModelRegistry;
-    model: Model;
-    sessionId?: string;
-    signal?: AbortSignal;
-    metadataResolver?: (provider: string) => Record<string, unknown> | undefined;
-}
-/**
- * Classify `promptText` and return a concrete effort clamped to `deps.model`,
- * or `undefined` when the model has no controllable effort surface (auto has
- * nothing to pick — the caller leaves the prior reasoning level in place).
- * @throws when the backend cannot produce a usable classification.
- */
-export declare function classifyDifficulty(promptText: string, deps: ClassifyDifficultyDeps): Promise<Effort | undefined>;
-/** Map the online 4-way level keyword to an {@link Effort}; earliest match wins. */
-export declare function parseDifficultyLevel(text: string): Effort | undefined;
-/** Map the local 3-way bucket keyword to an {@link Effort}; earliest match wins. */
-export declare function parseDifficultyBucket(text: string): Effort | undefined;

package/dist/types/autolearn/controller.d.ts

@@ -1,25 +0,0 @@
-import type { Settings } from "../config/settings";
-import type { AgentSession } from "../session/agent-session";
-/**
- * Build the standing auto-learn guidance for the system prompt from the tools
- * actually present in the active set, or null when `manage_skill` is absent.
- *
- * Driven by tool presence rather than live settings: the `learn`/`manage_skill`
- * registry is built ONCE at session start (and only for top-level sessions), so
- * keying the guidance on `autolearn.enabled` would let a mid-session enable — or
- * a subagent that filtered the tools out — inject guidance pointing at tools the
- * session never built. The `learn` addendum is included only when the `learn`
- * tool is present (it requires a memory backend).
- */
-export declare function buildAutoLearnInstructions(available: {
-    manageSkill: boolean;
-    learn: boolean;
-}): string | null;
-export interface AutoLearnControllerOptions {
-    session: AgentSession;
-    settings: Settings;
-}
-export declare class AutoLearnController {
-    #private;
-    constructor(options: AutoLearnControllerOptions);
-}

package/dist/types/autolearn/managed-skills.d.ts

@@ -1,45 +0,0 @@
-/** Provider id stamped on discovered managed skills (distinguishes them from authored). */
-export declare const MANAGED_SKILLS_PROVIDER_ID = "omp-managed";
-/** Hard cap on a managed SKILL.md body to keep generated skills bounded. */
-export declare const MAX_MANAGED_SKILL_BYTES = 64000;
-/** Resolve the isolated managed-skills directory (`~/.omp/agent/managed-skills`). */
-export declare function getManagedSkillsDir(agentDir?: string): string;
-/**
- * Validate + normalize a managed-skill name. Throws on anything outside the
- * strict allowlist so a bad name can never escape `getManagedSkillsDir()`
- * (blocks `..`, slashes, empty, and uppercase).
- */
-export declare function sanitizeSkillName(raw: string): string;
-/**
- * Whether `name` is a safe managed-skill name (the exact post-sanitize shape).
- * Used to validate names read from disk at discovery time — a managed
- * `SKILL.md` whose `frontmatter.name` was not produced by `sanitizeSkillName`
- * (e.g. hand-placed) must not render unescaped into the system prompt.
- */
-export declare function isValidManagedSkillName(name: string): boolean;
-/**
- * Neutralize a machine-generated managed-skill description so it cannot break
- * out of the system prompt's `<skills>` listing. Managed descriptions are
- * generated from prior task content and persist across sessions, so this is a
- * trust boundary: strip control/format chars, angle brackets (`<system-directive>`
- * / `</skills>`), and Markdown fence delimiters (backticks, `~~~`), then collapse
- * to a single line. Applied on BOTH write and read so existing files are safe too.
- */
-export declare function sanitizeManagedDescription(raw: string): string;
-/**
- * Serialize the minimal `name`/`description` frontmatter block via the repo's
- * YAML helper (round-trips through `parseFrontmatter`).
- */
-export declare function toSkillFrontmatter(name: string, description: string): string;
-export interface WriteManagedSkillInput {
-    action: "create" | "update";
-    name: string;
-    description: string;
-    body: string;
-}
-/** Create or update a managed `SKILL.md`. Returns the resolved file path. */
-export declare function writeManagedSkill(input: WriteManagedSkillInput): Promise<{
-    path: string;
-}>;
-/** Delete a managed skill directory. Throws when it does not exist. */
-export declare function deleteManagedSkill(name: string): Promise<void>;

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-entries";
-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;