@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/CHANGELOG.md

@@ -2,6 +2,60 @@
 
 ## [Unreleased]
 
+## [15.1.3] - 2026-05-17
+### Breaking Changes
+
+- Renamed the embedded-documentation internal URL scheme from `pi://` to `omp://`. `OmpProtocolHandler` replaces `PiProtocolHandler`; update any external references accordingly.
+- Removed the `StringEnum` re-export from `@oh-my-pi/pi-coding-agent`. Custom tools and extensions should use `z.enum([...])` directly via the injected `pi.zod`.
+- Replaced the `eval` tool's LARK-grammar `input` string with a structured `cells` array. Each cell is `{ language: "py" | "js", code, title?, timeout?, reset? }`. Removed the implicit/sniffed language path, the `*** Cell` / `*** End` / `*** Abort` markers, and the per-cell `t:<duration>` unit suffixes — `timeout` is now seconds (1-600).
+
+### Added
+
+- Added `providers.<name>.transport: "pi-native"` to `models.yml`. When set, every model under that provider routes its streaming dispatch through the auth-gateway's `POST /v1/pi/stream` endpoint instead of the per-provider SDK. The provider's `baseUrl` must point at a compatible `omp auth-gateway` and `apiKey` must carry the gateway bearer. The slot's `models.json` still resolves locally for pricing/capabilities/thinking config; only the wire dispatch is redirected. Use case: containerized omp installs (robomp slots, swarm extension) where the slot must stay credential-free and a sidecar gateway holds the real provider tokens. Also surfaced as `transport` on `ProviderConfigInput` for extension-registered providers.
+- Added optional backend push for the auto-QA grievance database (`dev.autoqaPush.enabled`, `dev.autoqaPush.endpoint`, `dev.autoqaPush.token`; env overrides `PI_AUTO_QA_PUSH`, `PI_AUTO_QA_PUSH_URL`, `PI_AUTO_QA_PUSH_TOKEN`). When enabled, every `report_tool_issue` call schedules a background flush that `POST`s pending rows to the configured endpoint and deletes them on HTTP 2xx. Each push carries a stable per-install UUID (`installId`) generated on first use and persisted at `~/.omp/install-id` via `getInstallId()` (new export from `@oh-my-pi/pi-utils`), so the receiver can dedup retries across host renames and `autoqa.db` wipes. Single-flight, 5s request timeout, 30s in-memory cooldown after failure, and a row-id watermark so rows inserted during an in-flight push survive and ship next time. Tool execution remains non-blocking and never throws.
+- `ModelRegistry` now promotes `models.yml` `providers.<name>.apiKey` entries to `AuthStorage`'s new config-override tier (above OAuth, below `--api-key`). Pinning a bearer in `models.yml` was previously a no-op when the broker had an OAuth credential for the same provider — the OAuth access token won and got sent unmodified to whatever `baseUrl` you redirected to, which an auth-gateway in front of that endpoint rightly rejected with 401. The override is now honored, and is cleared/repopulated atomically on `models.yml` reload (`#reloadStaticModels` calls `clearConfigApiKeys` before re-parsing). Use case: route `anthropic` / `openai-codex` to `http://llm-gateway.internal:4000` with the gateway's own bearer.
+- Added `omp auth-broker` subcommand for running and consuming a hosted credential vault.
+- `serve [--bind=host:port]` — boots a local broker against the SQLite store at `$AGENT_DB_PATH`.
+- `token [--regenerate]` — prints (and rotates) the bearer token stored at `~/.omp/auth-broker.token`.
+- `login <provider> [--via=user@host] [--dry-run]` — drives the OAuth flow locally or via SSH `-L` tunnel into a remote broker (callback ports pinned per provider).
+- `logout <provider>` — disables every credential for the given provider in the local SQLite store.
+- `import <file|dir> [--provider=<id>] [--include-disabled] [--dry-run]` — imports CLIProxyAPI-style JSON credential dumps (`~/.cliproxy/auth/*.json`). When `OMP_AUTH_BROKER_URL` is configured, credentials are uploaded to the remote broker via `POST /v1/credential`; otherwise they go into the local SQLite store. JSON `type` is mapped to omp providers (`claude` → `anthropic`, `codex` → `openai-codex`, `gemini[-cli]` → `google-gemini-cli`, `antigravity` → `google-antigravity`); `--provider` overrides the mapping for unrecognized types.
+- `status` — pings the configured remote broker (`OMP_AUTH_BROKER_URL`).
+- Added remote credential vault support to `discoverAuthStorage`. Configure via env (`OMP_AUTH_BROKER_URL` / `OMP_AUTH_BROKER_TOKEN`) or by setting `auth.broker.url` and `auth.broker.token` in `~/.omp/agent/config.yml` (hidden from the settings UI; supports `!command` resolution). Falls back to `~/.omp/auth-broker.token` when no token is provided inline. Otherwise behavior is unchanged.
+- Added `omp auth-broker migrate --from-local [--include-env] [--include-oauth] [--dry-run]` — uploads local SQLite credentials (and optionally env-var API keys) to the configured broker. Skips anything already on the broker via identity-key matching. OAuth is skipped by default (handled via `cliproxy` import). Idempotent on re-runs.
+- Added `omp auth-gateway` subcommand for running a forward-proxy that hides access tokens from less-trusted clients:
+- `serve [--bind=…]` — boots the gateway against the configured broker. Listens on `127.0.0.1:4000` by default.
+- `token [--regenerate]` — manages the gateway bearer token at `~/.omp/auth-gateway.token` (separate from the broker bearer).
+- `status` — verifies gateway config and authenticated broker readiness.
+- One wire surface: `POST /v1/chat/completions` (OpenAI chat-completions), `POST /v1/messages` (Anthropic messages), `POST /v1/responses` (OpenAI Responses), `GET /v1/usage` (aggregated, 5-min per-credential cache), `GET /v1/models` (catalog). Model id in the request body selects which omp provider/model services it; the gateway translates wire format ↔ omp canonical `Context` and dispatches through `pi-ai` `streamSimple()`. Container deployments (robomp, etc.) get inference auth without ever holding access tokens or the broker bearer.
+
+### Changed
+
+- Changed TTSR `interruptMode` semantics so a non-interrupting decision on a tool-source match now folds the rule reminder into that specific tool's `toolResult` content instead of queuing a loop-wide deferred follow-up turn. Text/thinking matches keep the previous deferred-injection behavior.
+
+### Fixed
+
+- Fixed streaming API requests to recover from provider auth errors by invalidating stale credentials and retrying with a fresh key
+- Fixed `auth-broker` migration, `auth-gateway` startup, and `discoverAuthStorage` to fail fast with a clear error when the broker snapshot endpoint returns a non-200 response
+- Fixed `omp auth-broker migrate` to skip local placeholder `<authenticated>` API credentials (not real keys) when exporting to a remote broker
+- Fixed `auth-gateway` token initialization to avoid clobbering an existing token when multiple processes initialize it concurrently
+- Fixed `omp auth-gateway` request handling to reject unsupported OpenAI/Anthropic protocol controls with 400 instead of accepting and ignoring them, propagate upstream error/abort terminal states as failures, preserve Responses reasoning and completed text items, accept string/system Responses messages, and keep Anthropic tool-result ordering valid.
+- Fixed gateway usage reporting to include cached-token totals for OpenAI Chat/Responses and to serve the last good cached report during transient upstream usage fetch failures.
+- Fixed auth-gateway request cancellation for requests that are already aborted before dispatch.
+- Fixed `/login` and `/logout` provider selector overflowing tall provider lists off-screen on small terminals. The selector now scrolls a 10-item window centered on the highlighted entry, shows a `(n/total)` indicator when windowed, and accepts PageUp/PageDown for faster navigation.
+
+## [15.1.2] - 2026-05-15
+### Fixed
+
+- Fixed SSH host additions/removals made inside a running session not refreshing the live `ssh` tool. `/ssh add` and `/ssh remove` now update the model-visible host list immediately, while `/reload-plugins` and `/move` refresh SSH discovery for external or project-scope config changes without restart.
+- Fixed loose object output schemas in `YieldTool` so non-strict schemas (for example `additionalProperties: true`) are preserved and accepted instead of being forced into strict mode
+- Fixed unconstrained output schema modes (`outputSchema: true` or absent/non-strict schemas) to run in loose mode for successful results
+- Fixed bash tool calls with `pty: true` hanging indefinitely on Windows by falling back to the non-PTY executor instead of entering the ConPTY-backed interactive path. ([#1103](https://github.com/can1357/oh-my-pi/issues/1103))
+
+### Changed
+
+- Updated MCP and theme schema metadata to reference JSON Schema draft-2020-12
+
 ## [15.1.0] - 2026-05-15
 ### Breaking Changes
 

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,87 @@
+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. "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;
+}
+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>;
+}
+/**
+ * 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;
+}
+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);
+    register(type: "bash" | "task", label: string, run: (ctx: {
+        jobId: string;
+        signal: AbortSignal;
+        reportProgress: (text: string, details?: Record<string, unknown>) => Promise<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(): AsyncJobDeliveryState;
+    hasPendingDeliveries(): 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;
+    waitForAll(): Promise<void>;
+    drainDeliveries(options?: {
+        timeoutMs?: number;
+    }): 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;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,154 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ExtensionAPI, ExtensionContext } from "../extensibility/extensions";
+import type { SessionEntry } from "../session/session-manager";
+import type { TruncationResult } from "../session/streaming-output";
+export type MetricDirection = "lower" | "higher";
+export type ExperimentStatus = "keep" | "discard" | "crash" | "checks_failed";
+export type ASIValue = string | number | boolean | null | ASIValue[] | {
+    [key: string]: ASIValue;
+};
+export interface ASIData {
+    [key: string]: ASIValue;
+}
+export interface NumericMetricMap {
+    [key: string]: number;
+}
+export interface MetricDef {
+    name: string;
+    unit: string;
+}
+export interface ExperimentResult {
+    runNumber: number | null;
+    commit: string;
+    metric: number;
+    metrics: NumericMetricMap;
+    status: ExperimentStatus;
+    description: string;
+    timestamp: number;
+    segment: number;
+    confidence: number | null;
+    asi?: ASIData;
+    modifiedPaths: string[];
+    scopeDeviations: string[];
+    justification: string | null;
+    flagged: boolean;
+    flaggedReason: string | null;
+}
+export interface ExperimentState {
+    results: ExperimentResult[];
+    bestMetric: number | null;
+    bestDirection: MetricDirection;
+    metricName: string;
+    metricUnit: string;
+    secondaryMetrics: MetricDef[];
+    name: string | null;
+    goal: string | null;
+    currentSegment: number;
+    maxExperiments: number | null;
+    confidence: number | null;
+    scopePaths: string[];
+    offLimits: string[];
+    constraints: string[];
+    notes: string;
+    branch: string | null;
+    baselineCommit: string | null;
+    sessionId: number | null;
+}
+export interface RunExperimentProgressDetails {
+    phase: "running";
+    elapsed: string;
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+    runDirectory?: string;
+}
+export interface RunDetails {
+    runNumber: number;
+    runDirectory: string;
+    benchmarkLogPath: string;
+    command: string;
+    exitCode: number | null;
+    durationSeconds: number;
+    passed: boolean;
+    crashed: boolean;
+    timedOut: boolean;
+    tailOutput: string;
+    parsedMetrics: NumericMetricMap | null;
+    parsedPrimary: number | null;
+    parsedAsi: ASIData | null;
+    metricName: string;
+    metricUnit: string;
+    preRunDirtyPaths: string[];
+    abandonedPriorRun: number | null;
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+}
+export interface LogDetails {
+    experiment: ExperimentResult;
+    state: ExperimentState;
+    wallClockSeconds: number | null;
+    scopeDeviations: string[];
+    justification: string | null;
+    flaggedRuns: Array<{
+        runId: number;
+        reason: string;
+    }>;
+}
+export interface PendingRunSummary {
+    command: string;
+    durationSeconds: number | null;
+    parsedAsi: ASIData | null;
+    parsedMetrics: NumericMetricMap | null;
+    parsedPrimary: number | null;
+    passed: boolean;
+    preRunDirtyPaths: string[];
+    runDirectory: string;
+    runNumber: number;
+    exitCode: number | null;
+    timedOut: boolean;
+}
+export interface RunningExperiment {
+    startedAt: number;
+    command: string;
+    runDirectory: string;
+    runNumber: number;
+}
+export interface AutoresearchRuntime {
+    autoresearchMode: boolean;
+    autoResumeArmed: boolean;
+    dashboardExpanded: boolean;
+    lastAutoResumePendingRunNumber: number | null;
+    lastRunDuration: number | null;
+    lastRunAsi: ASIData | null;
+    lastRunArtifactDir: string | null;
+    lastRunNumber: number | null;
+    lastRunSummary: PendingRunSummary | null;
+    runningExperiment: RunningExperiment | null;
+    state: ExperimentState;
+    goal: string | null;
+}
+export interface AutoresearchControlEntryData {
+    mode: "on" | "off" | "clear";
+    goal?: string;
+}
+export interface ReconstructedControlState {
+    autoresearchMode: boolean;
+    goal: string | null;
+    lastMode: AutoresearchControlEntryData["mode"] | null;
+}
+export interface RuntimeStore {
+    clear(sessionKey: string): void;
+    ensure(sessionKey: string): AutoresearchRuntime;
+}
+export interface DashboardController {
+    clear(ctx: ExtensionContext): void;
+    requestRender(): void;
+    showOverlay(ctx: ExtensionContext, runtime: AutoresearchRuntime): Promise<void>;
+    updateWidget(ctx: ExtensionContext, runtime: AutoresearchRuntime): void;
+}
+export interface AutoresearchToolFactoryOptions {
+    dashboard: DashboardController;
+    getRuntime(ctx: ExtensionContext): AutoresearchRuntime;
+    pi: ExtensionAPI;
+}
+export type AutoresearchToolResult<TDetails> = AgentToolResult<TDetails>;
+export type SessionEntries = SessionEntry[];

package/dist/types/capability/context-file.d.ts

@@ -0,0 +1,17 @@
+import type { SourceMeta } from "./types";
+/**
+ * A context file that provides persistent instructions to the agent.
+ */
+export interface ContextFile {
+    /** Absolute path to the file */
+    path: string;
+    /** File content */
+    content: string;
+    /** Which level this came from */
+    level: "user" | "project";
+    /** Distance from cwd (0 = in cwd, 1 = parent, etc.) for project files */
+    depth?: number;
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const contextFileCapability: import("./types").Capability<ContextFile>;

package/dist/types/capability/extension-module.d.ts

@@ -0,0 +1,15 @@
+import type { SourceMeta } from "./types";
+/**
+ * A loaded extension module.
+ */
+export interface ExtensionModule {
+    /** Extension module name (derived from path) */
+    name: string;
+    /** Absolute path to extension entrypoint */
+    path: string;
+    /** Source level */
+    level: "user" | "project";
+    /** Source metadata */
+    _source: SourceMeta;
+}
+export declare const extensionModuleCapability: import("./types").Capability<ExtensionModule>;