@gajae-code/coding-agent 0.10.2 → 0.11.1

package/dist/types/sdk/client/discovery.d.ts

@@ -0,0 +1,27 @@
+import { type BrokerDiscovery } from "../broker/discovery";
+export interface SdkSessionEndpoint {
+    sessionId: string;
+    url: string;
+    token: string;
+    path: string;
+}
+export interface SdkDiscoveryWarning {
+    code: "discovery_error";
+    path: string;
+    message: string;
+}
+export interface SdkSessionEndpointList {
+    endpoints: SdkSessionEndpoint[];
+    warnings: SdkDiscoveryWarning[];
+}
+export declare class SdkDiscoveryError extends Error {
+    readonly path: string;
+    readonly code = "discovery_error";
+    constructor(path: string, message: string);
+}
+/** Lists endpoint files and returns individual malformed or unreadable records as warnings. */
+export declare function listSdkSessionEndpoints(repo: string): Promise<SdkSessionEndpointList>;
+/** Resolves one per-session SDK endpoint discovery file. */
+export declare function readSdkSessionEndpoint(repo: string, sessionId: string): Promise<SdkSessionEndpoint | null>;
+/** Reads the agent-global broker discovery record. */
+export declare function readSdkBrokerDiscovery(agentDir: string): Promise<BrokerDiscovery | null>;

package/dist/types/sdk/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+export * from "./discovery";

package/dist/types/sdk/host/control/dispatch.d.ts

@@ -0,0 +1,34 @@
+import { type Operation } from "../../protocol/operation-registry";
+import type { ControlSurface, ControlValue } from "./operations";
+export interface ControlRequest {
+    id: string;
+    operation: string;
+    input: unknown;
+    expectedRevision?: string;
+    idempotencyKey?: string;
+    confirm?: boolean;
+}
+export type ControlErrorCode = string;
+export interface ControlError {
+    code: ControlErrorCode;
+    message: string;
+    currentRevision?: string;
+    details?: ControlValue;
+}
+export interface ControlResponse {
+    id: string;
+    ok: boolean;
+    result?: ControlValue;
+    error?: ControlError;
+}
+/** An error whose code is intentionally safe to expose on the control protocol. */
+export declare class TypedControlError extends Error {
+    readonly code: ControlErrorCode;
+    constructor(code: ControlErrorCode, message: string);
+}
+/** Busy is reserved for explicitly typed transient unavailability. */
+export declare class BusyError extends TypedControlError {
+    constructor(message?: string);
+}
+/** Dispatches a registry-defined per-session control operation. */
+export declare function dispatchControl(surface: ControlSurface, registryRow: Operation | undefined, request: ControlRequest): Promise<ControlResponse>;

package/dist/types/sdk/host/control/index.d.ts

@@ -0,0 +1,2 @@
+export { BusyError, type ControlError, type ControlErrorCode, type ControlRequest, type ControlResponse, dispatchControl, TypedControlError, } from "./dispatch";
+export type { ControlInput, ControlSurface, ControlValue } from "./operations";

package/dist/types/sdk/host/control/operations.d.ts

@@ -0,0 +1,65 @@
+export type ControlValue = unknown;
+export type ControlInput = Record<string, unknown>;
+/**
+ * Narrow host contract used by control dispatch. Implementations adapt an
+ * AgentSession and its controllers without exposing those concrete types here.
+ */
+export interface ControlSurface {
+    prompt(text: string, images?: ControlValue): Promise<ControlValue> | ControlValue;
+    steer(text: string): Promise<ControlValue> | ControlValue;
+    followUp(text: string): Promise<ControlValue> | ControlValue;
+    abort(): Promise<ControlValue> | ControlValue;
+    abortAndPrompt(text: string): Promise<ControlValue> | ControlValue;
+    answerAsk(id: string, answer: ControlValue): Promise<ControlValue> | ControlValue;
+    answerGate(id: string, response: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
+    approvePlan(id: string, choice: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
+    invokeSkill(name: string, args: ControlValue): Promise<ControlValue> | ControlValue;
+    setPlanMode(on: boolean): Promise<ControlValue> | ControlValue;
+    operateGoal(op: string, objective?: string): Promise<ControlValue> | ControlValue;
+    replaceTodo(items: ControlValue): Promise<ControlValue> | ControlValue;
+    setModel(id: string, thinkingLevel?: ControlValue): Promise<ControlValue> | ControlValue;
+    cycleModel(): Promise<ControlValue> | ControlValue;
+    setThinking(level: ControlValue): Promise<ControlValue> | ControlValue;
+    cycleThinking(): Promise<ControlValue> | ControlValue;
+    setPermissionMode(mode: ControlValue): Promise<ControlValue> | ControlValue;
+    setQueueMode(kind: string, mode: ControlValue): Promise<ControlValue> | ControlValue;
+    runCompaction(): Promise<ControlValue> | ControlValue;
+    setAutoCompaction(on: boolean): Promise<ControlValue> | ControlValue;
+    setAutoRetry(on: boolean): Promise<ControlValue> | ControlValue;
+    abortRetry(): Promise<ControlValue> | ControlValue;
+    executeBash(cmd: string): Promise<ControlValue> | ControlValue;
+    abortBash(): Promise<ControlValue> | ControlValue;
+    newSession(): Promise<ControlValue> | ControlValue;
+    forkSession(): Promise<ControlValue> | ControlValue;
+    resumeSession(id: string): Promise<ControlValue> | ControlValue;
+    closeSession(): Promise<ControlValue> | ControlValue;
+    switchSession(id: string): Promise<ControlValue> | ControlValue;
+    branchSession(entryId: string): Promise<ControlValue> | ControlValue;
+    renameSession(name: string): Promise<ControlValue> | ControlValue;
+    handoffSession(target: ControlValue): Promise<ControlValue> | ControlValue;
+    exportHtml(): Promise<ControlValue> | ControlValue;
+    patchConfig(patch: ControlValue): Promise<ControlValue> | ControlValue;
+    reloadRuntime(components: ControlValue): Promise<ControlValue> | ControlValue;
+    login(provider: string): Promise<ControlValue> | ControlValue;
+    registerHostTools(defs: ControlValue): Promise<ControlValue> | ControlValue;
+    registerHostUri(defs: ControlValue): Promise<ControlValue> | ControlValue;
+    setServiceTier(tier: ControlValue): Promise<ControlValue> | ControlValue;
+    setActiveTools(names: ControlValue): Promise<ControlValue> | ControlValue;
+    removeQueueMessage(id: string): Promise<ControlValue> | ControlValue;
+    moveQueueMessage(id: string, position: {
+        before?: string;
+        after?: string;
+    }): Promise<ControlValue> | ControlValue;
+    updateQueueMessage(id: string, patch: ControlValue): Promise<ControlValue> | ControlValue;
+    setExtensionEnabled(id: string, on: boolean): Promise<ControlValue> | ControlValue;
+    clearContext(confirm: boolean): Promise<ControlValue> | ControlValue;
+    deleteSession(id: string, confirm: boolean): Promise<ControlValue> | ControlValue;
+    moveCwd(path: string): Promise<ControlValue> | ControlValue;
+    retryLast(): Promise<ControlValue> | ControlValue;
+    retryNow(): Promise<ControlValue> | ControlValue;
+    backgroundBash(): Promise<ControlValue> | ControlValue;
+    /** Returns the current revision for a registry revision resource. */
+    /** Installed per-session registry rows. Dispatch rejects other rows before invoking a surface method. */
+    installedOperations?: ReadonlySet<string>;
+    revisionProvider?(resource: string): Promise<string | undefined> | string | undefined;
+}

package/dist/types/sdk/host/events.d.ts

@@ -0,0 +1,35 @@
+import type { SdkFrame } from "./types";
+export interface EventFrame extends SdkFrame {
+    type: "event";
+    generation: number;
+    seq: number;
+}
+export type EventReplayGap = {
+    kind: "generation_reset";
+    fromGeneration: number;
+    toGeneration: number;
+    resyncQueries: string[];
+} | {
+    kind: "sequence_gap";
+    fromSeq: number;
+    toSeq: number;
+    resyncQueries: string[];
+};
+export interface EventReplay {
+    events: EventFrame[];
+    gap?: EventReplayGap;
+}
+export declare class SessionEventStream {
+    #private;
+    constructor(options?: {
+        generation?: number;
+        ringSize?: number;
+        resyncQueryIds?: string[];
+    });
+    get generation(): number;
+    get sequence(): number;
+    restart(): number;
+    emit(frame: SdkFrame): EventFrame;
+    /** Replays retained current-generation events and reports any required resynchronization. */
+    replay(lastSeq: number, generation?: number): EventReplay;
+}

package/dist/types/sdk/host/host.d.ts

@@ -0,0 +1,35 @@
+import { type EventFrame, SessionEventStream } from "./events";
+import { ReverseLeaseRuntime } from "./reverse-leases";
+import type { BrokerIndexWriter, HostEndpointAdapters, SdkFrame } from "./types";
+export type SdkRequestObserver = (kind: "control" | "query", connectionId: string, frame: SdkFrame) => void;
+export interface SessionSdkHostOptions extends HostEndpointAdapters {
+    control?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
+    query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
+    /** Best-effort diagnostic observation of accepted control/query frames. */
+    onRequest?: SdkRequestObserver;
+    /** Runs only after a successful control response has been sent to the client. */
+    afterControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame) => void | Promise<void>;
+    installProviderDefinitions?: (capability: string, definitions: unknown) => void;
+    onProviderDefinitionsRemoved?: (capability: string) => void;
+    onReverseCancel?: (requestId: string, reason: "provider_disconnected" | "lease_released") => void;
+}
+/** SDK hosting is independent of notification configuration. Only root sessions host an endpoint. */
+export declare function shouldHostSdk(_settings: unknown, isTopLevel: boolean, env?: NodeJS.ProcessEnv): boolean;
+/** Adapter-based session host; bus wiring owns NotificationServer creation and transport framing. */
+export declare class SessionSdkHost {
+    #private;
+    readonly events: SessionEventStream;
+    readonly reverse: ReverseLeaseRuntime;
+    constructor(options: SessionSdkHostOptions);
+    get started(): boolean;
+    get generation(): number;
+    /** Current installed definitions for a live provider capability. */
+    getProviderDefinitions(capability: string): unknown | undefined;
+    /** Release reverse leases after the transport reports a WebSocket disconnect. */
+    handleDisconnect(connectionId: string): void;
+    /** Adds an event to the resumable event ring. Transport delivery is owned by bus wiring. */
+    emitEvent(frame: SdkFrame): EventFrame;
+    start(): Promise<"started" | "already">;
+    stop(): Promise<"stopped" | "already">;
+    registerWithBroker(writer: BrokerIndexWriter): Promise<void>;
+}

package/dist/types/sdk/host/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./events";
+export * from "./host";
+export * from "./reverse-leases";
+export * from "./types";

package/dist/types/sdk/host/query/cursor.d.ts

@@ -0,0 +1,62 @@
+import { type RevisionStore } from "./revision-store.js";
+export declare const CURSOR_TTL_MS: number;
+export declare const MAX_CURSORS_PER_CONNECTION = 32;
+export declare const MAX_CURSORS_PER_SESSION = 128;
+export interface CursorEnvelope {
+    cursorVersion: 1;
+    protocolMajor: 3;
+    sessionId: string;
+    resource: string;
+    revision: string;
+    highWatermark?: unknown;
+    position: unknown;
+    direction: string;
+    pageShape: unknown;
+}
+export interface CursorSelector {
+    queryId: string;
+    entryId?: string;
+    field?: string;
+    fileId?: string;
+    hunkId?: string;
+    resourceKind?: string;
+    resourceId?: string;
+    itemId?: string;
+}
+export interface CursorPosition {
+    offset?: number;
+    byteOffset?: number;
+    selector?: CursorSelector;
+}
+export declare function cursorSelector(position: unknown): CursorSelector | undefined;
+export declare function assertCursorSelector(cursor: CursorSelector | undefined, requested: Partial<CursorSelector>): CursorSelector;
+export interface CursorQueryContext {
+    sessionId: string;
+    resource?: string;
+    resourceId?: string;
+    direction: string;
+    pageShape: unknown;
+}
+export declare class CursorError extends Error {
+    readonly code: "cursor_expired" | "invalid_cursor" | "invalid_input" | "resource_gone" | "snapshot_capacity_exceeded";
+    readonly restartQuery: boolean;
+    constructor(code: "cursor_expired" | "invalid_cursor" | "invalid_input" | "resource_gone" | "snapshot_capacity_exceeded", restartQuery?: boolean, message?: string);
+}
+export declare function canonicalCursorJson(envelope: CursorEnvelope): string;
+export declare function cursorMac(envelope: CursorEnvelope, sessionToken: string | Uint8Array): string;
+export declare function signCursor(envelope: CursorEnvelope, sessionToken: string | Uint8Array): string;
+export declare function verifyCursor(cursor: string, sessionToken: string | Uint8Array): CursorEnvelope | undefined;
+/** Tracks cursor budgets and binds snapshot pins to authenticated cursor strings. */
+export declare class CursorRegistry {
+    #private;
+    private readonly sessionToken;
+    private readonly revisions;
+    private readonly now;
+    constructor(sessionToken: string | Uint8Array, revisions: RevisionStore, now?: () => number);
+    grant(connectionId: string, envelope: CursorEnvelope, resourceKind: string, resourceId: string): Promise<string>;
+    consume(cursor: string, connectionId: string, expected: CursorQueryContext): CursorEnvelope;
+    release(cursor: string): void;
+    close(): void;
+    sweep(): void;
+    get size(): number;
+}

package/dist/types/sdk/host/query/handlers.d.ts

@@ -0,0 +1,70 @@
+import { type CursorRegistry } from "./cursor.js";
+import type { RevisionStore } from "./revision-store.js";
+export declare const TARGET_PAGE_BYTES: number;
+export declare const RESPONSE_CEILING_BYTES: number;
+export interface SessionSurface {
+    getTranscriptEntries(): unknown[] | Promise<unknown[]>;
+    getContextSnapshot(): unknown | Promise<unknown>;
+    getGoalState(): unknown | Promise<unknown>;
+    getTodoState(): unknown | Promise<unknown>;
+    getDiff(): unknown | Promise<unknown>;
+    getUsage(): unknown | Promise<unknown>;
+    getModels(): unknown | Promise<unknown>;
+    getSkillState(): unknown | Promise<unknown>;
+    /** Q12 rows preserve workflow gate fields and include stable durable gate metadata. */
+    getGates(): unknown | Promise<unknown>;
+    getConfigItems(): unknown | Promise<unknown>;
+    getSessionMetadata(): unknown | Promise<unknown>;
+    getStats(): unknown | Promise<unknown>;
+    getBranchCandidates(): unknown | Promise<unknown>;
+    getLastAssistant(): unknown | Promise<unknown>;
+    getCapabilities(): unknown | Promise<unknown>;
+    getAuthProviders(): unknown | Promise<unknown>;
+    getTools(): unknown | Promise<unknown>;
+    getQueueMessages(): unknown | Promise<unknown>;
+    getExtensions(): unknown | Promise<unknown>;
+    getArtifactRange?(id: string, offset: number, length: number): {
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined | Promise<{
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined>;
+    getJobs(): unknown | Promise<unknown>;
+    /** Query rows backed by the session's installed binding map. */
+    installedQueries?: ReadonlySet<string>;
+}
+export interface QueryRequest {
+    id?: string;
+    query: string;
+    input?: Record<string, unknown>;
+    cursor?: string;
+    connectionId: string;
+}
+export interface QueryPage {
+    items: unknown[];
+    complete: boolean;
+    continuationCursor?: string;
+    revision: string;
+    preview?: boolean;
+}
+export interface QueryResponse {
+    id?: string;
+    ok: boolean;
+    page?: QueryPage;
+    result?: unknown;
+    error?: {
+        code: string;
+        message: string;
+        restartQuery?: boolean;
+    };
+}
+export declare class QueryHandlers {
+    #private;
+    private readonly surface;
+    private readonly sessionId;
+    private readonly revisions;
+    private readonly cursors;
+    constructor(surface: SessionSurface, sessionId: string, revisions: RevisionStore, cursors: CursorRegistry);
+    dispatch(request: QueryRequest): Promise<QueryResponse>;
+}

package/dist/types/sdk/host/query/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./cursor.js";
+export * from "./handlers.js";
+export * from "./revision-store.js";

package/dist/types/sdk/host/query/revision-store.d.ts

@@ -0,0 +1,60 @@
+export declare const MAX_REVISIONS_PER_RESOURCE = 8;
+export declare const MAX_PINNED_REVISIONS = 128;
+export declare const MAX_MEMORY_BYTES: number;
+export declare const SNAPSHOT_TTL_MS: number;
+export declare class RevisionStoreError extends Error {
+    readonly code: "resource_gone" | "snapshot_capacity_exceeded";
+    constructor(code: "resource_gone" | "snapshot_capacity_exceeded", message?: string);
+}
+/** Per-session MVCC snapshots. Payloads hold canonical JSON UTF-8. */
+export declare class RevisionStore {
+    #private;
+    readonly sessionId: string;
+    private readonly now;
+    constructor(sessionId: string, now?: () => number, options?: {
+        storageDir?: string;
+        onReadRange?: (start: number, end: number) => void;
+    });
+    createRevision(resourceKind: string, resourceId: string, payload: unknown): Promise<string>;
+    readRevision(resourceKind: string, resourceId: string, id: string): Promise<unknown>;
+    revisionByteLength(resourceKind: string, resourceId: string, id: string): Promise<number | undefined>;
+    readPage(resourceKind: string, resourceId: string, id: string, offset: number, targetBytes: number): Promise<{
+        items: unknown[];
+        complete: boolean;
+    } | undefined>;
+    /** Returns canonical root JSON in a UTF-8-safe bounded range without parsing it. */
+    readRootRange(resourceKind: string, resourceId: string, id: string, offset: number, length: number): Promise<{
+        body: string;
+        complete: boolean;
+        offset: number;
+    } | undefined>;
+    readStringRange(resourceKind: string, resourceId: string, id: string, field: string, offset: number, length: number): Promise<{
+        body: string;
+        complete: boolean;
+        offset: number;
+    } | undefined>;
+    readIndexedStringRange(resourceKind: string, resourceId: string, id: string, itemId: string, field: string, offset: number, length: number): Promise<{
+        body: string;
+        complete: boolean;
+        offset: number;
+    } | undefined>;
+    describeIndexedItem(resourceKind: string, resourceId: string, id: string, offset: number): Promise<{
+        itemId?: string;
+        fields: string[];
+    } | undefined>;
+    readTranscriptBodyRange(resourceId: string, id: string, entryId: string, offset: number, length: number): Promise<{
+        body: string;
+        complete: boolean;
+        offset: number;
+    } | undefined>;
+    pin(cursorId: string, resourceKind: string, resourceId: string, id: string): Promise<void>;
+    unpin(cursorId: string): void;
+    sweep(): void;
+    close(): Promise<void>;
+    get pinnedCount(): number;
+    get memoryBytes(): number;
+    /** Test-only accounting for the bounded serializer's staging buffer. */
+    get peakBufferedBytes(): number;
+    /** Test-only accounting for a spilled reader's raw chunk and decoded-text buffers. */
+    get peakReadBufferedBytes(): number;
+}

package/dist/types/sdk/host/reverse-leases.d.ts

@@ -0,0 +1,45 @@
+import type { SdkFrame } from "./types";
+export declare const REVERSE_HEARTBEAT_MS = 5000;
+export declare const REVERSE_LEASE_TTL_MS = 15000;
+export declare const REVERSE_RECLAIM_GRACE_MS = 15000;
+export declare const MAX_REVERSE_OUTSTANDING = 64;
+export declare const MAX_REVERSE_PAYLOAD_BYTES: number;
+export declare class ReverseLeaseError extends Error {
+    readonly code: "lease_unavailable" | "lease_expired" | "provider_lease_conflict" | "provider_required" | "not_lease_owner" | "payload_too_large" | "too_many_outstanding" | "unknown_request" | "idempotency_conflict";
+    constructor(code: "lease_unavailable" | "lease_expired" | "provider_lease_conflict" | "provider_required" | "not_lease_owner" | "payload_too_large" | "too_many_outstanding" | "unknown_request" | "idempotency_conflict", message?: "idempotency_conflict" | "lease_expired" | "lease_unavailable" | "not_lease_owner" | "payload_too_large" | "provider_lease_conflict" | "provider_required" | "too_many_outstanding" | "unknown_request");
+}
+export interface ProviderLease {
+    leaseId: string;
+    connectionId: string;
+    capability: string;
+    definitions: unknown;
+    expiresAt: number;
+    graceUntil?: number;
+    active: boolean;
+}
+export interface ReverseLeaseOptions {
+    now?: () => number;
+    leaseTtlMs?: number;
+    sendFrame: (connectionId: string, frame: SdkFrame) => void | Promise<void>;
+    installDefinitions?: (capability: string, definitions: unknown) => void;
+    onCancel?: (requestId: string, reason: "provider_disconnected" | "lease_released") => void;
+    onDefinitionsRemoved?: (capability: string) => void;
+}
+/** Session-local directed reverse RPC lease registry. */
+export declare class ReverseLeaseRuntime {
+    #private;
+    constructor(options: ReverseLeaseOptions);
+    registerProvider(connectionId: string, capability: string, definitions: unknown, expectedLeaseId?: string, idempotencyKey?: string): ProviderLease;
+    heartbeat(connectionId: string, leaseId: string): ProviderLease;
+    release(connectionId: string, leaseId: string, handoffTo?: string): ProviderLease;
+    disconnect(connectionId: string): void;
+    request(capability: string, method: string, payload: unknown): Promise<unknown>;
+    respond(connectionId: string, id: string, leaseId: string, result: unknown, error?: {
+        code: string;
+        message: string;
+    }): void;
+    getLease(capability: string): ProviderLease | undefined;
+    /** Installed definitions are observable only while their provider lease is live. */
+    getInstalledDefinitions(capability: string): unknown | undefined;
+    dispose(): void;
+}

package/dist/types/sdk/host/types.d.ts

@@ -0,0 +1,32 @@
+export type SdkFrame = Record<string, unknown>;
+/** Narrow common surface shared by control and query adapters. */
+export interface SessionSurface {
+    sessionId: string;
+}
+export interface SessionOperationSurface extends SessionSurface {
+    /** Query rows backed by this session's installed binding map. */
+    installedQueries?: ReadonlySet<string>;
+}
+/** Operations the neutral control dispatcher may require from a session. */
+export interface ControlSurface extends SessionSurface {
+    [key: string]: unknown;
+}
+export interface HostEndpointAdapters {
+    sessionId: string;
+    stateRoot: string;
+    token: string;
+    sendFrame: (connectionId: string, frame: SdkFrame) => void | Promise<void>;
+    onFrame: (handler: (connectionId: string, frame: SdkFrame) => void) => undefined | (() => void);
+}
+export interface BrokerIndexWriter {
+    register(input: {
+        sessionId: string;
+        stateRoot: string;
+        endpointGeneration: number;
+    }): void | Promise<void>;
+    unregister?(input: {
+        sessionId: string;
+        stateRoot: string;
+        endpointGeneration: number;
+    }): void | Promise<void>;
+}

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

@@ -0,0 +1,6 @@
+export * as bus from "./bus";
+export * from "./client";
+export * as host from "./host";
+export * as mcp from "./mcp";
+export type { Q10CurrentThinkingLevel, Q10Model, Q10SettableThinkingLevel, Q10ThinkingCapabilities, Q10ThinkingEffort, Q10ThinkingMode, } from "./models";
+export * from "./session";

package/dist/types/sdk/lifecycle-session.d.ts

@@ -0,0 +1,14 @@
+import type { AgentSession } from "../session/agent-session";
+import { type CreateAgentSessionOptions } from "./session";
+import { SdkStartupCapability, type SdkStartupFailure, SdkStartupRollbackTracker } from "./startup-capability";
+export type CreateLifecycleAgentSessionResult = {
+    session: AgentSession;
+    capability: SdkStartupCapability;
+    rollback: SdkStartupRollbackTracker;
+} | {
+    capability: SdkStartupCapability;
+    rollback: SdkStartupRollbackTracker;
+    failure: SdkStartupFailure;
+};
+/** Internal lifecycle-only session construction with an owner-bound SDK startup result. */
+export declare function createLifecycleAgentSession(options?: CreateAgentSessionOptions): Promise<CreateLifecycleAgentSessionResult>;

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

@@ -0,0 +1 @@
+export * from "./server";

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

@@ -0,0 +1,37 @@
+import { SdkClient } from "../client/client";
+type Arguments = Record<string, unknown>;
+type JsonRpcRequest = {
+    jsonrpc: "2.0";
+    id?: string | number | null;
+    method: string;
+    params?: unknown;
+};
+type JsonRpcResponse = {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+};
+export interface SdkMcpServerOptions {
+    repo?: string;
+    agentDir?: string;
+    connect?: (url: string, token: string) => Promise<SdkClient>;
+}
+export declare const SDK_MCP_TOOL_NAMES: readonly ["gjc_session_control", "gjc_session_query", "gjc_session_global", "gjc_session_list"];
+/** Creates the model-facing MCP adapter using only SDK discovery records and v3 WebSockets. */
+export declare function createSdkMcpServer(options?: SdkMcpServerOptions): {
+    callTool: (name: string, args?: Arguments) => Promise<unknown>;
+    handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+    handle: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+    tools: Record<string, unknown>[];
+};
+/**
+ * Runs the SDK MCP server over stdio (newline-delimited JSON-RPC), the shipped
+ * `gjc mcp-serve sdk` entrypoint. Pure SDK client: session control/query flows
+ * through discovery records and v3 WebSockets only.
+ */
+export declare function runSdkMcpStdio(options?: SdkMcpServerOptions): Promise<void>;
+export {};

package/dist/types/sdk/models.d.ts

@@ -0,0 +1,44 @@
+import { ThinkingLevel } from "@gajae-code/agent-core";
+import { type Api, type Effort, type Model, type ThinkingControlMode } from "@gajae-code/ai";
+export type Q10ThinkingEffort = Effort;
+export type Q10SettableThinkingLevel = typeof ThinkingLevel.Off | Q10ThinkingEffort;
+export type Q10CurrentThinkingLevel = Q10SettableThinkingLevel | typeof ThinkingLevel.Inherit;
+export type Q10ThinkingMode = ThinkingControlMode;
+export interface Q10ThinkingCapabilities {
+    validLevels: readonly Q10SettableThinkingLevel[];
+    minLevel?: Q10ThinkingEffort;
+    maxLevel?: Q10ThinkingEffort;
+    mode?: Q10ThinkingMode;
+    defaultLevel?: Q10ThinkingEffort;
+    /** Fresh raw explicit descriptor copy; source order retained. */
+    levels?: readonly Q10ThinkingEffort[];
+}
+export interface Q10Model {
+    provider: string;
+    id: string;
+    name: string;
+    contextWindow: number;
+    maxTokens: number;
+    reasoning: boolean;
+    thinking: Q10ThinkingCapabilities;
+    current: boolean;
+    currentThinkingLevel?: Q10CurrentThinkingLevel;
+}
+export type Q10ThinkingMetadataReason = "missing_thinking" | "unknown_min_level" | "unknown_max_level" | "inverted_range" | "unknown_mode" | "empty_levels" | "unknown_level" | "level_out_of_range" | "lower_bound_mismatch" | "upper_bound_mismatch" | "supported_membership_mismatch" | "empty_supported_levels" | "unknown_default_level" | "default_not_supported";
+/** An intentionally safe error for malformed model thinking metadata. */
+export declare class Q10ThinkingMetadataError extends Error {
+    readonly reason: Q10ThinkingMetadataReason;
+    readonly code = "internal";
+    constructor(provider: string, id: string, reason: Q10ThinkingMetadataReason);
+}
+export interface Q10ModelProjectionInput {
+    models: readonly Model<Api>[];
+    currentModel?: Model<Api>;
+    currentThinkingLevel?: Q10CurrentThinkingLevel;
+    resolveSupportedEfforts?: (model: Model<Api>) => readonly Effort[];
+}
+/**
+ * Projects model registry entries into the Q10 public DTO without exposing
+ * transport, credentials, pricing, or other registry internals.
+ */
+export declare function projectQ10Models(input: Q10ModelProjectionInput): Q10Model[];

package/dist/types/sdk/protocol/adapter-validation.d.ts

@@ -0,0 +1,14 @@
+type Input = Record<string, unknown>;
+type SecretInputError = {
+    code: "secret_field_forbidden";
+    message: string;
+};
+/** Rejects secret-bearing config patches from model-facing adapter inputs. */
+export declare function validateAdapterSecretFields(operation: string, input: Input): SecretInputError | undefined;
+export type AdapterValidationError = {
+    code: "invalid_reload_component" | "invalid_input";
+    message: string;
+};
+/** Validates controls that adapters must reject before forwarding them to a host. */
+export declare function validateAdapterControl(operation: string, input: Input): AdapterValidationError | undefined;
+export {};

package/dist/types/sdk/protocol/operation-registry.d.ts

@@ -0,0 +1,24 @@
+export declare const ADAPTERS: readonly ["telegram", "discord", "slack", "mcp", "acp", "daemonCli"];
+export type Adapter = (typeof ADAPTERS)[number];
+export type AdapterDisposition = "native_alias" | "generic_safe" | "machine_only" | "provider_only" | "prohibited";
+export type OperationKind = "control" | "global" | "query" | "reverse";
+export type Idempotency = "idempotent" | "ordered" | "fast_lane";
+export type QueryContinuityClass = "stable_prefix" | "retained_revision" | "scalar_snapshot" | "content_addressed";
+export interface Operation {
+    id: string;
+    sdkId: string;
+    kind: OperationKind;
+    description: string;
+    idempotency: Idempotency;
+    errorCodes: string[];
+    revisionResource?: string;
+    continuityClass?: QueryContinuityClass;
+    adapterDispositions: Record<Adapter, AdapterDisposition>;
+    testIds: string[];
+}
+export declare function findOperation(kind: OperationKind, sdkId: string): Operation | undefined;
+export declare function adapterDispositionError(adapter: Adapter, kind: OperationKind, sdkId: string, modelFacing?: boolean): {
+    code: string;
+    message: string;
+} | undefined;
+export declare const OPERATIONS: readonly Operation[];