@sayknow-cli/coding-agent 0.3.4 → 0.3.6

package/src/slash-commands/builtin-registry.ts

@@ -12,7 +12,12 @@ import {
 	SKC_MODEL_ASSIGNMENT_TARGETS,
 	type SkcModelAssignmentTargetId,
 } from "../config/model-registry";
-import { extractExplicitThinkingSelector, formatModelSelectorValue, parseModelPattern } from "../config/model-resolver";
+import {
+	extractExplicitThinkingSelector,
+	formatModelSelectorValue,
+	parseModelPattern,
+	parseModelString,
+} from "../config/model-resolver";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../discovery/helpers.js";
 import { td } from "../i18n";
 import { resolveMemoryBackend } from "../memory-backend";
@@ -170,11 +175,32 @@ function splitExplicitThinkingSelector(selector: string): { baseSelector: string
 	return thinkingLevel ? { baseSelector: trimmed.slice(0, colonIndex), thinkingLevel } : { baseSelector: trimmed };
 }
 
-function resolveModelCommandSelection(
+interface ModelCommandSelection {
+	model: Model;
+	selector: string;
+	thinkingLevel?: ThinkingLevel;
+}
+
+interface ModelCommandResolutionFailure {
+	message: string;
+}
+
+type ModelCommandResolution =
+	| { ok: true; selection: ModelCommandSelection }
+	| { ok: false; failure: ModelCommandResolutionFailure };
+
+function parseProviderQualifiedSelector(selector: string): { provider: string; modelId: string } | undefined {
+	const splitSelector = splitExplicitThinkingSelector(selector);
+	const parsed = parseModelString(splitSelector.baseSelector);
+	if (!parsed) return undefined;
+	return { provider: parsed.provider, modelId: parsed.id };
+}
+
+function resolveModelCommandSelectionFromAvailable(
 	runtime: SlashCommandRuntime,
 	selector: string,
-): { model: Model; selector: string; thinkingLevel?: ThinkingLevel } | undefined {
-	const availableModels = runtime.session.getAvailableModels?.() ?? [];
+	availableModels: Model[],
+): ModelCommandSelection | undefined {
 	const matchPreferences = { usageOrder: runtime.settings.getStorage()?.getModelUsageOrder() };
 	const resolved = parseModelPattern(selector, availableModels, matchPreferences, {
 		modelRegistry: runtime.session.modelRegistry,
@@ -199,6 +225,78 @@ function resolveModelCommandSelection(
 	};
 }
 
+function formatDiscoverableProviderFailure(
+	selector: string,
+	provider: string,
+	modelId: string,
+	runtime: SlashCommandRuntime,
+): string {
+	const state = runtime.session.modelRegistry.getProviderDiscoveryState?.(provider);
+	const discovered = state?.models ?? [];
+	const base = `Unknown model: ${selector}.`;
+	if (!modelId.trim()) {
+		return `${base} Local provider model selectors must use provider/model-id syntax with a non-empty model id.`;
+	}
+	if (!state) {
+		return `${base} Provider ${provider} is configured for discovery but has not reported models yet.`;
+	}
+	if (state.status === "unavailable") {
+		const details = state.error ? ` (${state.error})` : "";
+		return `${base} Provider ${provider} discovery is unavailable${details}. Check the local endpoint and run /model again.`;
+	}
+	if (state.status === "unauthenticated") {
+		return `${base} Provider ${provider} requires authentication before model discovery.`;
+	}
+	if (state.status === "empty") {
+		return `${base} Provider ${provider} discovery succeeded but returned no models.`;
+	}
+	if (discovered.length > 0) {
+		const preview = discovered.slice(0, 8).join(", ");
+		const suffix = discovered.length > 8 ? ", …" : "";
+		return `${base} Provider ${provider} did not report model ${modelId}. Available local models: ${preview}${suffix}.`;
+	}
+	return `${base} Provider ${provider} did not report model ${modelId}.`;
+}
+
+async function resolveModelCommandSelection(
+	runtime: SlashCommandRuntime,
+	selector: string,
+): Promise<ModelCommandResolution> {
+	let availableModels = runtime.session.getAvailableModels?.() ?? [];
+	const initialSelection = resolveModelCommandSelectionFromAvailable(runtime, selector, availableModels as Model[]);
+	if (initialSelection) {
+		return { ok: true, selection: initialSelection };
+	}
+
+	const providerRef = parseProviderQualifiedSelector(selector);
+	const discoverableProviders = runtime.session.modelRegistry?.getDiscoverableProviders?.() ?? [];
+	if (providerRef && discoverableProviders.includes(providerRef.provider)) {
+		await runtime.session.modelRegistry.refreshProvider?.(providerRef.provider, "online");
+		availableModels = runtime.session.getAvailableModels?.() ?? [];
+		const refreshedSelection = resolveModelCommandSelectionFromAvailable(
+			runtime,
+			selector,
+			availableModels as Model[],
+		);
+		if (refreshedSelection) {
+			return { ok: true, selection: refreshedSelection };
+		}
+		return {
+			ok: false,
+			failure: {
+				message: formatDiscoverableProviderFailure(selector, providerRef.provider, providerRef.modelId, runtime),
+			},
+		};
+	}
+
+	return {
+		ok: false,
+		failure: {
+			message: `Unknown model: ${selector}. Configure or login to a provider first, then list/select models with /model.`,
+		},
+	};
+}
+
 function modelSelectionUsage(runtime: SlashCommandRuntime, currentModelLine?: string): string {
 	return [
 		currentModelLine,
@@ -283,16 +381,11 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 						runtime,
 					);
 				}
-				const selection = resolveModelCommandSelection(runtime, modelId);
-				if (!selection) {
-					return usage(
-						modelSelectionUsage(
-							runtime,
-							`Unknown model: ${modelId}. Configure or login to a provider first, then list/select models with /model.`,
-						),
-						runtime,
-					);
+				const resolution = await resolveModelCommandSelection(runtime, modelId);
+				if (!resolution.ok) {
+					return usage(modelSelectionUsage(runtime, resolution.failure.message), runtime);
 				}
+				const { selection } = resolution;
 				try {
 					const persistedSelector = formatModelSelectorValue(selection.selector, selection.thinkingLevel);
 					if (parsedArgs.targetId === "default") {

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;