@sayknow-cli/coding-agent 0.3.16 → 0.4.0

package/src/web/search/providers/openai-compatible.ts

@@ -5,16 +5,68 @@ import { SearchProvider } from "./base";
 import { extractTextSources } from "./text-citations";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
+type JsonObject = Record<string, unknown>;
+
+function isJsonObject(value: unknown): value is JsonObject {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function malformedResponse(detail: string): never {
+	throw new SearchProviderError(
+		"openai-compatible",
+		`OpenAI-compatible web search returned malformed response body (${detail})`,
+		502,
+	);
+}
+
+function optionalArray(value: unknown, detail: string): unknown[] {
+	if (value === undefined) return [];
+	if (!Array.isArray(value)) malformedResponse(detail);
+	return value;
+}
+
+function normalizeResponseBody(value: unknown): JsonObject {
+	if (!isJsonObject(value)) malformedResponse("expected a JSON object");
+
+	const output = optionalArray(value.output, "output must be an array");
+	const choices = optionalArray(value.choices, "choices must be an array");
+
+	for (const item of output) {
+		if (!isJsonObject(item)) continue;
+		for (const content of optionalArray(item.content, "output content must be an array")) {
+			if (isJsonObject(content)) optionalArray(content.annotations, "output annotations must be an array");
+		}
+	}
+	for (const choice of choices) {
+		if (!isJsonObject(choice) || !isJsonObject(choice.message)) continue;
+		optionalArray(choice.message.annotations, "choice annotations must be an array");
+	}
+
+	return { ...value, output, choices };
+}
+
+function parseResponseBody(text: string): JsonObject {
+	let value: unknown;
+	try {
+		value = text ? JSON.parse(text) : {};
+	} catch {
+		throw new SearchProviderError("openai-compatible", "OpenAI-compatible web search returned invalid JSON", 502);
+	}
+	return normalizeResponseBody(value);
+}
+
 /**
  * Whether the response carries independent proof that a web search ran. Used to
  * gate inline-citation recovery so a stray prose URL in a non-search answer is
  * never promoted to a citation.
  */
-function webSearchPerformed(json: any): boolean {
-	if (Array.isArray(json?.output) && json.output.some((item: any) => item?.type === "web_search_call")) {
+function webSearchPerformed(json: JsonObject): boolean {
+	if (Array.isArray(json.output) && json.output.some(item => isJsonObject(item) && item.type === "web_search_call")) {
 		return true;
 	}
-	const numRequests = json?.tool_usage?.web_search?.num_requests;
+	const toolUsage = isJsonObject(json.tool_usage) ? json.tool_usage : undefined;
+	const webSearch = toolUsage && isJsonObject(toolUsage.web_search) ? toolUsage.web_search : undefined;
+	const numRequests = webSearch?.num_requests;
 	return typeof numRequests === "number" && numRequests > 0;
 }
 
@@ -23,16 +75,18 @@ function endpoint(baseUrl: string, api: string): string {
 	return api === "openai-completions" ? `${base}/chat/completions` : `${base}/responses`;
 }
 
-function textFromResponse(json: any): string | undefined {
+function textFromResponse(json: JsonObject): string | undefined {
 	if (typeof json.output_text === "string") return json.output_text;
 	const chunks: string[] = [];
-	for (const item of json.output ?? []) {
-		for (const content of item.content ?? []) {
-			if (typeof content.text === "string") chunks.push(content.text);
+	for (const item of optionalArray(json.output, "output must be an array")) {
+		if (!isJsonObject(item)) continue;
+		for (const content of optionalArray(item.content, "output content must be an array")) {
+			if (isJsonObject(content) && typeof content.text === "string") chunks.push(content.text);
 		}
 	}
-	const chat = json.choices?.[0]?.message?.content;
-	if (typeof chat === "string") chunks.push(chat);
+	const firstChoice = optionalArray(json.choices, "choices must be an array")[0];
+	const message = isJsonObject(firstChoice) && isJsonObject(firstChoice.message) ? firstChoice.message : undefined;
+	if (typeof message?.content === "string") chunks.push(message.content);
 	return chunks.join("\n") || undefined;
 }
 
@@ -55,24 +109,23 @@ function pushCitation(out: SearchCitation[], rawUrl: unknown, rawTitle: unknown,
 function collectCitationAnnotations(annotations: unknown, out: SearchCitation[]): void {
 	if (!Array.isArray(annotations)) return;
 	for (const annotation of annotations) {
-		if (!annotation || typeof annotation !== "object") continue;
-		const ann = annotation as Record<string, any>;
-		if (ann.type !== "url_citation") continue;
-		const cite =
-			ann.url_citation && typeof ann.url_citation === "object" ? (ann.url_citation as Record<string, any>) : ann;
-		pushCitation(out, cite.url ?? cite.uri, cite.title, cite.text ?? cite.quote ?? ann.text);
+		if (!isJsonObject(annotation) || annotation.type !== "url_citation") continue;
+		const cite = isJsonObject(annotation.url_citation) ? annotation.url_citation : annotation;
+		pushCitation(out, cite.url ?? cite.uri, cite.title, cite.text ?? cite.quote ?? annotation.text);
 	}
 }
 
-function parseCitations(json: any): SearchCitation[] {
+function parseCitations(json: JsonObject): SearchCitation[] {
 	const citations: SearchCitation[] = [];
-	for (const item of json?.output ?? []) {
-		for (const content of item?.content ?? []) {
-			collectCitationAnnotations(content?.annotations, citations);
+	for (const item of optionalArray(json.output, "output must be an array")) {
+		if (!isJsonObject(item)) continue;
+		for (const content of optionalArray(item.content, "output content must be an array")) {
+			if (isJsonObject(content)) collectCitationAnnotations(content.annotations, citations);
 		}
 	}
-	for (const choice of json?.choices ?? []) {
-		collectCitationAnnotations(choice?.message?.annotations, citations);
+	for (const choice of optionalArray(json.choices, "choices must be an array")) {
+		const message = isJsonObject(choice) && isJsonObject(choice.message) ? choice.message : undefined;
+		if (message) collectCitationAnnotations(message.annotations, citations);
 	}
 	const seen = new Set<string>();
 	return citations.filter(c => {
@@ -156,7 +209,7 @@ export class OpenAICompatibleSearchProvider extends SearchProvider {
 				response.status,
 			);
 		}
-		const json = text ? JSON.parse(text) : {};
+		const json = parseResponseBody(text);
 		const citations = parseCitations(json);
 		const answer = textFromResponse(json);
 		const limit = params.limit ?? params.numSearchResults ?? 10;
@@ -178,7 +231,7 @@ export class OpenAICompatibleSearchProvider extends SearchProvider {
 			sources,
 			citations: citations.length > 0 ? citations : undefined,
 			model,
-			requestId: json.id,
+			requestId: typeof json.id === "string" ? json.id : undefined,
 			authMode: "api-key",
 		};
 	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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