@sayknow-cli/coding-agent 0.4.2 → 0.4.3

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, idempotencyKey?: 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,37 @@
+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;
+    /** Best-effort capabilities mirrored from the native transport for out-of-band consumers. */
+    connectionCapabilities?: (connectionId: string) => ReadonlySet<string>;
+}
+/** 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?: "lease_unavailable" | "lease_expired" | "provider_lease_conflict" | "provider_required" | "not_lease_owner" | "payload_too_large" | "too_many_outstanding" | "unknown_request" | "idempotency_conflict");
+}
+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,7 @@
+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";
+export * from "./session-directory";

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 ["skc_session_control", "skc_session_query", "skc_session_global", "skc_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
+ * `skc 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 "@sayknow-cli/agent-core";
+import { type Api, type Effort, type Model, type ThinkingControlMode } from "@sayknow-cli/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[];

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

@@ -0,0 +1,56 @@
+import type { ResumeSessionIdentity } from "../session/session-manager";
+/** Version of the supported readonly managed-session directory API. */
+/** Broker-owned policy for managed-session migration decisions after scope validation. */
+export type DirectoryMigrationPolicy = "copy-retain" | "disabled";
+export declare const SESSION_DIRECTORY_API_VERSION: 1;
+/** A collision-resistant v2 managed-session scope for one canonical workspace identity. */
+export interface ManagedSessionScope {
+    readonly apiVersion: 1;
+    readonly layoutVersion: 2;
+    readonly identityVersion: 1;
+    readonly agentDir: string;
+    readonly sessionsRoot: string;
+    readonly canonicalCwd: string;
+    readonly legacyLexicalCwd: string;
+    readonly directoryName: string;
+    readonly directoryPath: string;
+}
+export type ResolveManagedSessionScopeResult = {
+    kind: "resolved";
+    scope: ManagedSessionScope;
+} | {
+    kind: "error";
+    code: "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid";
+    message: string;
+};
+export interface LogicalSessionCandidate {
+    readonly sessionId: string;
+    readonly path: string;
+    readonly cwd: string;
+    readonly provenance: "v2" | "legacy";
+    readonly identity: Readonly<ResumeSessionIdentity>;
+    readonly migrationState: "native_v2" | "legacy_unmigrated" | "migrated_v2";
+}
+export type ListManagedSessionCandidatesResult = {
+    kind: "complete";
+    scope: ManagedSessionScope;
+    owned: readonly LogicalSessionCandidate[];
+    foreignCount: number;
+    invalid: readonly {
+        code: string;
+    }[];
+} | {
+    kind: "error";
+    code: "scan_failed" | "unsafe_root" | "invalid_candidate";
+    message: string;
+};
+/** Resolve a v2 scope without creating, migrating, or deleting session data. */
+export declare function resolveManagedSessionScope(input: {
+    cwd: string;
+    agentDir?: string;
+    sessionsRoot?: string;
+}): Promise<ResolveManagedSessionScopeResult>;
+/** List readonly v2 and validated legacy candidates for an already resolved scope. */
+export declare function listManagedSessionCandidates(input: {
+    scope: ManagedSessionScope;
+}): Promise<ListManagedSessionCandidatesResult>;