@oh-my-pi/pi-coding-agent 15.1.0 → 15.1.2

package/dist/types/mcp/smithery-registry.d.ts

@@ -0,0 +1,51 @@
+import type { MCPServerConfig } from "./types";
+type RegistryInputType = "string" | "number" | "boolean";
+export type SmitherySearchResult = {
+    id: string;
+    name: string;
+    title?: string;
+    description?: string;
+    score?: number;
+    useCount?: number;
+    display: {
+        displayName: string;
+        description: string;
+        useCount: number;
+        verified: boolean;
+        deployed: boolean;
+        transport: string;
+        connectionType: string;
+        createdAt?: string;
+        homepage?: string;
+        tools: Array<{
+            name: string;
+            description?: string;
+            params: string[];
+        }>;
+    };
+    sourceType: "remote" | "package";
+    config: MCPServerConfig;
+    warnings: string[];
+    requiredInputs: Array<{
+        key: string;
+        label: string;
+        type: RegistryInputType;
+        required: boolean;
+        defaultValue?: string;
+        description?: string;
+        enumValues?: string[];
+        sensitive: boolean;
+    }>;
+};
+export interface SmitherySearchOptions {
+    limit?: number;
+    apiKey?: string;
+    includeSemantic?: boolean;
+}
+export declare class SmitheryRegistryError extends Error {
+    status: number;
+    constructor(message: string, status: number);
+}
+export declare function searchSmitheryRegistry(keyword: string, options?: SmitherySearchOptions): Promise<SmitherySearchResult[]>;
+export declare function toConfigName(candidate: string): string;
+export {};

package/dist/types/mcp/tool-bridge.d.ts

@@ -0,0 +1,86 @@
+/**
+ * MCP to CustomTool bridge.
+ *
+ * Converts MCP tool definitions to CustomTool format for the agent.
+ */
+import type { AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { TSchema } from "@oh-my-pi/pi-ai";
+import type { SourceMeta } from "../capability/types";
+import type { CustomTool, CustomToolContext, CustomToolResult, RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { MCPContent, MCPServerConnection, MCPToolDefinition } from "./types";
+/** Reconnect callback: tears down stale connection, returns new one or null. */
+export type MCPReconnect = () => Promise<MCPServerConnection | null>;
+export declare function isRetriableConnectionError(error: unknown): boolean;
+/** Details included in MCP tool results for rendering */
+export interface MCPToolDetails {
+    /** Server name */
+    serverName: string;
+    /** Original MCP tool name */
+    mcpToolName: string;
+    /** Whether the call resulted in an error */
+    isError?: boolean;
+    /** Raw content from MCP response */
+    rawContent?: MCPContent[];
+    /** Provider ID (e.g., "claude", "mcp-json") */
+    provider?: string;
+    /** Provider display name (e.g., "Claude Code", "MCP Config") */
+    providerName?: string;
+}
+export declare function createMCPToolName(serverName: string, toolName: string): string;
+/**
+ * Parse an MCP tool name back to server and tool components.
+ *
+ * Note: This returns the normalized tool name (with server prefix stripped).
+ * The original MCP tool name may have had the server name as a prefix.
+ */
+export declare function parseMCPToolName(name: string): {
+    serverName: string;
+    toolName: string;
+} | null;
+/**
+ * CustomTool wrapping an MCP tool with an active connection.
+ */
+export declare class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
+    private connection;
+    private readonly tool;
+    private readonly reconnect?;
+    readonly name: string;
+    readonly label: string;
+    readonly description: string;
+    readonly parameters: TSchema;
+    /** Original MCP tool name (before normalization) */
+    readonly mcpToolName: string;
+    /** Server name */
+    readonly mcpServerName: string;
+    /** Create MCPTool instances for all tools from an MCP server connection */
+    static fromTools(connection: MCPServerConnection, tools: MCPToolDefinition[], reconnect?: MCPReconnect): MCPTool[];
+    constructor(connection: MCPServerConnection, tool: MCPToolDefinition, reconnect?: MCPReconnect | undefined);
+    renderCall(args: unknown, _options: RenderResultOptions, theme: Theme): import("@oh-my-pi/pi-tui").Component;
+    renderResult(result: CustomToolResult<MCPToolDetails>, options: RenderResultOptions, theme: Theme, args?: unknown): import("@oh-my-pi/pi-tui").Component;
+    execute(_toolCallId: string, params: unknown, _onUpdate: AgentToolUpdateCallback<MCPToolDetails> | undefined, _ctx: CustomToolContext, signal?: AbortSignal): Promise<CustomToolResult<MCPToolDetails>>;
+}
+/**
+ * CustomTool wrapping an MCP tool with deferred connection resolution.
+ */
+export declare class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
+    #private;
+    private readonly serverName;
+    private readonly tool;
+    private readonly getConnection;
+    private readonly reconnect?;
+    readonly name: string;
+    readonly label: string;
+    readonly description: string;
+    readonly parameters: TSchema;
+    /** Original MCP tool name (before normalization) */
+    readonly mcpToolName: string;
+    /** Server name */
+    readonly mcpServerName: string;
+    /** Create DeferredMCPTool instances for all tools from an MCP server */
+    static fromTools(serverName: string, tools: MCPToolDefinition[], getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect): DeferredMCPTool[];
+    constructor(serverName: string, tool: MCPToolDefinition, getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect | undefined);
+    renderCall(args: unknown, _options: RenderResultOptions, theme: Theme): import("@oh-my-pi/pi-tui").Component;
+    renderResult(result: CustomToolResult<MCPToolDetails>, options: RenderResultOptions, theme: Theme, args?: unknown): import("@oh-my-pi/pi-tui").Component;
+    execute(_toolCallId: string, params: unknown, _onUpdate: AgentToolUpdateCallback<MCPToolDetails> | undefined, _ctx: CustomToolContext, signal?: AbortSignal): Promise<CustomToolResult<MCPToolDetails>>;
+}

package/dist/types/mcp/tool-cache.d.ts

@@ -0,0 +1,8 @@
+import type { AgentStorage } from "../session/agent-storage";
+import type { MCPServerConfig, MCPToolDefinition } from "./types";
+export declare class MCPToolCache {
+    private storage;
+    constructor(storage: AgentStorage);
+    get(serverName: string, config: MCPServerConfig): Promise<MCPToolDefinition[] | null>;
+    set(serverName: string, config: MCPServerConfig, tools: MCPToolDefinition[]): Promise<void>;
+}

package/dist/types/mcp/transports/http.d.ts

@@ -0,0 +1,36 @@
+import type { MCPHttpServerConfig, MCPRequestOptions, MCPSseServerConfig, MCPTransport } from "../../mcp/types";
+/**
+ * HTTP transport for MCP servers.
+ * Uses POST for requests, supports SSE responses.
+ */
+export declare class HttpTransport implements MCPTransport {
+    #private;
+    private config;
+    onClose?: () => void;
+    onError?: (error: Error) => void;
+    onNotification?: (method: string, params: unknown) => void;
+    onRequest?: (method: string, params: unknown) => Promise<unknown>;
+    /** Called on 401/403 to attempt token refresh. Returns updated headers or null. */
+    onAuthError?: () => Promise<Record<string, string> | null>;
+    constructor(config: MCPHttpServerConfig | MCPSseServerConfig);
+    get connected(): boolean;
+    get url(): string;
+    /**
+     * Mark transport as connected.
+     * HTTP doesn't need persistent connection, but we track state.
+     */
+    connect(): Promise<void>;
+    /**
+     * Start SSE listener for server-initiated messages.
+     * Resolves once the SSE connection is established (or fails/unsupported).
+     * Message reading continues in the background.
+     */
+    startSSEListener(): Promise<void>;
+    request<T = unknown>(method: string, params?: Record<string, unknown>, options?: MCPRequestOptions): Promise<T>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Create and connect an HTTP transport.
+ */
+export declare function createHttpTransport(config: MCPHttpServerConfig | MCPSseServerConfig): Promise<HttpTransport>;

package/dist/types/mcp/transports/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * MCP transport exports.
+ */
+export * from "./http";
+export * from "./stdio";

package/dist/types/mcp/transports/stdio.d.ts

@@ -0,0 +1,32 @@
+/**
+ * MCP stdio transport.
+ *
+ * Implements JSON-RPC 2.0 over subprocess stdin/stdout.
+ * Messages are newline-delimited JSON.
+ */
+import type { MCPRequestOptions, MCPStdioServerConfig, MCPTransport } from "../../mcp/types";
+/**
+ * Stdio transport for MCP servers.
+ * Spawns a subprocess and communicates via stdin/stdout.
+ */
+export declare class StdioTransport implements MCPTransport {
+    #private;
+    private config;
+    onClose?: () => void;
+    onError?: (error: Error) => void;
+    onNotification?: (method: string, params: unknown) => void;
+    onRequest?: (method: string, params: unknown) => Promise<unknown>;
+    constructor(config: MCPStdioServerConfig);
+    get connected(): boolean;
+    /**
+     * Start the subprocess and begin reading.
+     */
+    connect(): Promise<void>;
+    request<T = unknown>(method: string, params?: Record<string, unknown>, options?: MCPRequestOptions): Promise<T>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Create and connect a stdio transport.
+ */
+export declare function createStdioTransport(config: MCPStdioServerConfig): Promise<StdioTransport>;

package/dist/types/mcp/types.d.ts

@@ -0,0 +1,333 @@
+/**
+ * MCP (Model Context Protocol) type definitions.
+ *
+ * Based on MCP specification 2025-03-26:
+ * https://modelcontextprotocol.io/specification/2025-03-26/
+ */
+import type { SourceMeta } from "../capability/types";
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+/** Authentication configuration for MCP servers */
+export interface MCPAuthConfig {
+    /** Authentication type */
+    type: "oauth" | "apikey";
+    /** Credential ID for OAuth (references agent.db) */
+    credentialId?: string;
+    /** Token endpoint URL — persisted for proactive token refresh */
+    tokenUrl?: string;
+    /** Client ID — persisted for token refresh */
+    clientId?: string;
+    /** Client secret — persisted for token refresh */
+    clientSecret?: string;
+}
+/** Base server config with shared options */
+interface MCPServerConfigBase {
+    /** Whether this server is enabled (default: true) */
+    enabled?: boolean;
+    /** Connection timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Authentication configuration (optional) */
+    auth?: MCPAuthConfig;
+    /** OAuth configuration for servers requiring explicit client credentials */
+    oauth?: {
+        clientId?: string;
+        clientSecret?: string;
+        redirectUri?: string;
+        callbackPort?: number;
+        callbackPath?: string;
+    };
+}
+/** Stdio server configuration */
+export interface MCPStdioServerConfig extends MCPServerConfigBase {
+    type?: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+}
+/** HTTP server configuration (Streamable HTTP transport) */
+export interface MCPHttpServerConfig extends MCPServerConfigBase {
+    type: "http";
+    url: string;
+    headers?: Record<string, string>;
+}
+/** SSE server configuration (deprecated, use HTTP) */
+export interface MCPSseServerConfig extends MCPServerConfigBase {
+    type: "sse";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type MCPServerConfig = MCPStdioServerConfig | MCPHttpServerConfig | MCPSseServerConfig;
+export declare const MCP_CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/can1357/oh-my-pi/main/packages/coding-agent/src/config/mcp-schema.json";
+/** Root mcp.json/.mcp.json file structure */
+export interface MCPConfigFile {
+    $schema?: string;
+    mcpServers?: Record<string, MCPServerConfig>;
+    disabledServers?: string[];
+}
+/** MCP implementation info */
+export interface MCPImplementation {
+    name: string;
+    version: string;
+}
+/** MCP client capabilities */
+export interface MCPClientCapabilities {
+    roots?: {
+        listChanged?: boolean;
+    };
+    sampling?: Record<string, never>;
+    experimental?: Record<string, unknown>;
+}
+/** MCP server capabilities */
+export interface MCPServerCapabilities {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        subscribe?: boolean;
+        listChanged?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+    logging?: Record<string, never>;
+    experimental?: Record<string, unknown>;
+}
+/** Initialize request params */
+export interface MCPInitializeParams {
+    protocolVersion: string;
+    capabilities: MCPClientCapabilities;
+    clientInfo: MCPImplementation;
+}
+/** Initialize response result */
+export interface MCPInitializeResult {
+    protocolVersion: string;
+    capabilities: MCPServerCapabilities;
+    serverInfo: MCPImplementation;
+    instructions?: string;
+}
+/** MCP tool definition */
+export interface MCPToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema: {
+        type: "object";
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [key: string]: unknown;
+    };
+}
+/** tools/list response */
+export interface MCPToolsListResult {
+    tools: MCPToolDefinition[];
+    nextCursor?: string;
+}
+/** tools/call params */
+export interface MCPToolCallParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+/** Content types in tool results */
+export interface MCPTextContent {
+    type: "text";
+    text: string;
+}
+export interface MCPImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export interface MCPResourceContent {
+    type: "resource";
+    resource: {
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+    };
+}
+export type MCPContent = MCPTextContent | MCPImageContent | MCPResourceContent;
+/** tools/call response */
+export interface MCPToolCallResult {
+    content: MCPContent[];
+    isError?: boolean;
+}
+export interface MCPRequestOptions {
+    /** Abort signal (e.g. Escape-to-interrupt) */
+    signal?: AbortSignal;
+}
+/** Transport interface - abstracts stdio/http */
+export interface MCPTransport {
+    /** Send a request and wait for response */
+    request<T = unknown>(method: string, params?: Record<string, unknown>, options?: MCPRequestOptions): Promise<T>;
+    /** Send a notification (no response expected) */
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    /** Close the transport */
+    close(): Promise<void>;
+    /** Whether the transport is connected */
+    readonly connected: boolean;
+    /** Event handlers */
+    onClose?: () => void;
+    onError?: (error: Error) => void;
+    onNotification?: (method: string, params: unknown) => void;
+    /** Handler for server-to-client requests (e.g. roots/list). Returns result or throws a JsonRpcError. */
+    onRequest?: (method: string, params: unknown) => Promise<unknown>;
+}
+/** Transport factory function */
+export type TransportFactory = (config: MCPServerConfig) => Promise<MCPTransport>;
+/** Connected MCP server state */
+export interface MCPServerConnection {
+    /** Server name from config */
+    name: string;
+    /** Original config */
+    config: MCPServerConfig;
+    /** Transport instance */
+    transport: MCPTransport;
+    /** Server info from initialize */
+    serverInfo: MCPImplementation;
+    /** Server capabilities */
+    capabilities: MCPServerCapabilities;
+    /** Cached tools (populated on demand) */
+    tools?: MCPToolDefinition[];
+    /** Source metadata (for display) */
+    _source?: SourceMeta;
+    /** Cached resources (populated on demand) */
+    resources?: MCPResource[];
+    /** Cached resource templates (populated on demand) */
+    resourceTemplates?: MCPResourceTemplate[];
+    /** Server instructions from initialize */
+    instructions?: string;
+    /** Cached prompts (populated on demand) */
+    prompts?: MCPPrompt[];
+}
+/** MCP tool with server context */
+export interface MCPToolWithServer {
+    server: MCPServerConnection;
+    tool: MCPToolDefinition;
+}
+/** Annotations for resources, templates, and content blocks */
+export interface MCPAnnotations {
+    audience?: ("user" | "assistant")[];
+    priority?: number;
+    lastModified?: string;
+}
+/** A concrete resource exposed by an MCP server */
+export interface MCPResource {
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+    annotations?: MCPAnnotations;
+}
+/** A parameterized resource template (RFC 6570 URI template) */
+export interface MCPResourceTemplate {
+    uriTemplate: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    annotations?: MCPAnnotations;
+}
+/** Result of resources/list */
+export interface MCPResourcesListResult {
+    resources: MCPResource[];
+    nextCursor?: string;
+}
+/** Result of resources/templates/list */
+export interface MCPResourceTemplatesListResult {
+    resourceTemplates: MCPResourceTemplate[];
+    nextCursor?: string;
+}
+/** A single content item from resources/read */
+export interface MCPResourceContentItem {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+}
+/** Result of resources/read */
+export interface MCPResourceReadResult {
+    contents: MCPResourceContentItem[];
+}
+/** Params for resources/read */
+export interface MCPResourceReadParams {
+    uri: string;
+}
+/** Params for resources/subscribe and resources/unsubscribe */
+export interface MCPResourceSubscribeParams {
+    uri: string;
+}
+/** An argument definition for an MCP prompt */
+export interface MCPPromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+/** A prompt definition exposed by an MCP server */
+export interface MCPPrompt {
+    name: string;
+    title?: string;
+    description?: string;
+    arguments?: MCPPromptArgument[];
+}
+/** Result of prompts/list */
+export interface MCPPromptsListResult {
+    prompts: MCPPrompt[];
+    nextCursor?: string;
+}
+/** Audio content in prompt messages */
+export interface MCPAudioContent {
+    type: "audio";
+    data: string;
+    mimeType: string;
+}
+/** Content type union for prompt messages */
+export type MCPPromptContent = MCPTextContent | MCPImageContent | MCPAudioContent | MCPResourceContent;
+/** A single message in a prompt result */
+export interface MCPPromptMessage {
+    role: "user" | "assistant";
+    content: MCPPromptContent | MCPPromptContent[];
+}
+/** Params for prompts/get */
+export interface MCPGetPromptParams {
+    name: string;
+    arguments?: Record<string, string>;
+}
+/** Result of prompts/get */
+export interface MCPGetPromptResult {
+    description?: string;
+    messages: MCPPromptMessage[];
+}
+/** MCP server notification method names */
+export declare const MCPNotificationMethods: {
+    readonly TOOLS_LIST_CHANGED: "notifications/tools/list_changed";
+    readonly RESOURCES_LIST_CHANGED: "notifications/resources/list_changed";
+    readonly RESOURCES_UPDATED: "notifications/resources/updated";
+    readonly PROMPTS_LIST_CHANGED: "notifications/prompts/list_changed";
+};
+/** Extract a JsonRpcError from a thrown value. Preserves `.code` and `.message` from Error instances or plain objects. */
+export declare function toJsonRpcError(error: unknown): JsonRpcError;
+export {};

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

@@ -0,0 +1,28 @@
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+import type { AgentSession } from "../session/agent-session";
+/**
+ * Start the background memory startup pipeline.
+ *
+ * Skips for ephemeral sessions, subagent sessions, disabled settings, or DB failures.
+ */
+export declare function startMemoryStartupTask(options: {
+    session: AgentSession;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    agentDir: string;
+    taskDepth: number;
+}): void;
+/**
+ * Build memory usage instructions for prompt injection.
+ */
+export declare function buildMemoryToolDeveloperInstructions(agentDir: string, settings: Settings): Promise<string | undefined>;
+/**
+ * Clear all persisted memory state and generated artifacts.
+ */
+export declare function clearMemoryData(agentDir: string, cwd: string): Promise<void>;
+/**
+ * Force-enqueue global consolidation maintenance work.
+ */
+export declare function enqueueMemoryConsolidation(agentDir: string, cwd: string, sourceUpdatedAt?: number): void;
+export declare function getMemoryRoot(agentDir: string, cwd: string): string;

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

@@ -0,0 +1,110 @@
+import { Database } from "bun:sqlite";
+export interface MemoryThread {
+    id: string;
+    updatedAt: number;
+    rolloutPath: string;
+    cwd: string;
+    sourceKind: string;
+}
+export interface Stage1OutputRow {
+    threadId: string;
+    sourceUpdatedAt: number;
+    rawMemory: string;
+    rolloutSummary: string;
+    rolloutSlug: string | null;
+    generatedAt: number;
+    cwd: string;
+}
+export interface Stage1Claim {
+    threadId: string;
+    ownershipToken: string;
+    inputWatermark: number;
+    sourceUpdatedAt: number;
+    rolloutPath: string;
+    cwd: string;
+}
+export interface GlobalClaim {
+    ownershipToken: string;
+    inputWatermark: number;
+}
+export declare function openMemoryDb(dbPath: string): Database;
+export declare function closeMemoryDb(db: Database): void;
+export declare function clearMemoryData(db: Database): void;
+export declare function upsertThreads(db: Database, threads: MemoryThread[]): void;
+export declare function claimStage1Jobs(db: Database, params: {
+    nowSec: number;
+    threadScanLimit: number;
+    maxRolloutsPerStartup: number;
+    maxRolloutAgeDays: number;
+    minRolloutIdleHours: number;
+    leaseSeconds: number;
+    runningConcurrencyCap: number;
+    workerId: string;
+    excludeThreadIds?: string[];
+}): Stage1Claim[];
+export declare function enqueueGlobalWatermark(db: Database, sourceUpdatedAt: number, cwd: string, params?: {
+    forceDirtyWhenNotAdvanced?: boolean;
+}): void;
+export declare function markStage1SucceededWithOutput(db: Database, params: {
+    threadId: string;
+    ownershipToken: string;
+    sourceUpdatedAt: number;
+    rawMemory: string;
+    rolloutSummary: string;
+    rolloutSlug: string | null;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function markStage1SucceededNoOutput(db: Database, params: {
+    threadId: string;
+    ownershipToken: string;
+    sourceUpdatedAt: number;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function markStage1Failed(db: Database, params: {
+    threadId: string;
+    ownershipToken: string;
+    retryDelaySeconds: number;
+    reason: string;
+    nowSec: number;
+}): boolean;
+export declare function tryClaimGlobalPhase2Job(db: Database, params: {
+    workerId: string;
+    leaseSeconds: number;
+    nowSec: number;
+    cwd: string;
+}): {
+    kind: "claimed";
+    claim: GlobalClaim;
+} | {
+    kind: "skipped_not_dirty";
+} | {
+    kind: "skipped_running";
+};
+export declare function heartbeatGlobalJob(db: Database, params: {
+    ownershipToken: string;
+    leaseSeconds: number;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function listStage1OutputsForGlobal(db: Database, limit: number, cwd: string): Stage1OutputRow[];
+export declare function markGlobalPhase2Succeeded(db: Database, params: {
+    ownershipToken: string;
+    newWatermark: number;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function markGlobalPhase2Failed(db: Database, params: {
+    ownershipToken: string;
+    retryDelaySeconds: number;
+    reason: string;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function markGlobalPhase2FailedUnowned(db: Database, params: {
+    retryDelaySeconds: number;
+    reason: string;
+    nowSec: number;
+    cwd: string;
+}): boolean;