@sayknow-cli/coding-agent 0.3.6 → 0.3.8

package/README.md

@@ -11,6 +11,82 @@ Package-specific references:
 - [DEVELOPMENT](./DEVELOPMENT.md)
 - [RenderMermaid guide](../../docs/render-mermaid.md)
 
+## External lifecycle notifications
+
+SKC already exposes public lifecycle events through the extension/hook event contract. External notification integrations for Discord, Hermes, clawhip, or similar channels should be opt-in and subscribe to these events instead of scraping transcripts or logs:
+
+- `turn_end` — a model/tool turn finished. The public payload is `{ type: "turn_end", turnIndex, message, toolResults }`.
+- `agent_end` — the agent loop for a submitted prompt reached a terminal boundary. The public payload is `{ type: "agent_end", messages }`.
+
+For simple local side effects that do not need a full extension, set the user-level `completion.notifyCommand`. SKC runs it on completed agent turns with `SKC_NOTIFICATION_*` environment variables (`SKC_NOTIFICATION_TITLE`, `SKC_NOTIFICATION_BODY`, `SKC_NOTIFICATION_JSON`, etc.); project settings cannot activate this command hook.
+
+```sh
+skc config set completion.notifyCommand 'cmux notify --title "$SKC_NOTIFICATION_TITLE" --body "$SKC_NOTIFICATION_BODY"'
+```
+
+When SKC runs inside a cmux terminal (`CMUX_WORKSPACE_ID` is set), SKC best-effort renames that cmux workspace to the current SKC session name (with a `SKC: ` prefix) — but only when the workspace still has its default title, so a name you pinned (or one set by a peer session sharing the workspace) is never overwritten. Opt out with `SKC_NO_CMUX_RENAME=1`.
+
+Windows Terminal may keep BEL (`[Console]::Write([char]7)`) silent depending on profile and system sound settings even when `notifications.terminalBell` is enabled. For an audible Windows completion beep, configure a user-level PowerShell command hook instead:
+
+```powershell
+skc config set completion.notifyCommand 'powershell.exe -NoProfile -Command "[Console]::Beep(880, 300)"'
+```
+
+`cmux notify` returning successfully means SKC handed the completion event to cmux. cmux may still suppress the native desktop banner when the app/window is focused, the emitting workspace is active, or the notification panel is open. In those cases, check cmux's notification panel or unread workspace state instead of treating the missing banner as a SKC delivery failure.
+
+Recommended external mapping:
+
+| Notification | Public event | Status guidance |
+|---|---|---|
+| Turn finished | `turn_end` | Use the handler's own sanitized status such as `"finished"`. |
+| Agent stopped/finished | `agent_end` | Treat as terminal for the prompt. |
+| Waiting/blocked/failed | `agent_end` plus a caller-supplied safe summary | Current lifecycle events do not expose a separate structured waiting/blocked reason; inspect only public-safe, integration-owned state. |
+
+Forward only a minimal, caller-sanitized payload. Do not include raw prompts, assistant transcripts, hidden prompts, tool outputs, raw logs, host paths, private config, webhook URLs, channel IDs, tokens, or secrets. A safe notification payload should be built by the extension/hook itself, for example:
+
+```ts
+import type { ExtensionAPI } from "@sayknow-cli/coding-agent";
+
+type PublicLifecycleNotification = {
+	type: "turn_end" | "agent_end";
+	status: "finished" | "stopped" | "failed" | "blocked" | "waiting";
+	turnIndex?: number;
+	timestamp: string;
+	summary: string;
+};
+
+export default function lifecycleNotifier(pi: ExtensionAPI) {
+	const enabled = process.env.SKC_LIFECYCLE_NOTIFY === "1";
+	if (!enabled) return;
+
+	const send = async (payload: PublicLifecycleNotification) => {
+		// POST to Discord/Hermes/clawhip here. Keep target URLs and channel IDs in
+		// private config or environment variables; never include them in payloads.
+	};
+
+	pi.on("turn_end", event =>
+		send({
+			type: "turn_end",
+			status: "finished",
+			turnIndex: event.turnIndex,
+			timestamp: new Date().toISOString(),
+			summary: "SKC turn finished",
+		}),
+	);
+
+	pi.on("agent_end", () =>
+		send({
+			type: "agent_end",
+			status: "stopped",
+			timestamp: new Date().toISOString(),
+			summary: "SKC prompt reached a terminal lifecycle boundary",
+		}),
+	);
+}
+```
+
+This is the supported repo-native lifecycle notification path. It is not Claude Code hook compatibility, and it remains disabled unless the user configures an extension/hook handler and private delivery target.
+
 ## Memory backends
 
 The agent supports three mutually-exclusive memory backends, selected via the `memory.backend` setting (Settings → Memory tab, or `~/.skc/config.yml`):

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

@@ -0,0 +1,31 @@
+/**
+ * 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

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

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

@@ -0,0 +1,328 @@
+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

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

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,24 @@
+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

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

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

@@ -0,0 +1,17 @@
+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;