@gajae-code/coding-agent 0.10.2 → 0.11.1

package/dist/types/sdk/broker/session-index.d.ts

@@ -0,0 +1,57 @@
+import { SDK_STATE_VERSION } from "./state-version";
+export type SessionIndexEventType = "host_registered" | "host_heartbeat" | "host_unregistered" | "lifecycle_started" | "lifecycle_terminal" | "session_closed" | "record_reconciled";
+export interface SessionIndexEvent {
+    version: typeof SDK_STATE_VERSION;
+    indexSeq: number;
+    type: SessionIndexEventType;
+    sessionId: string;
+    locator: {
+        repo: string;
+        stateRoot: string;
+    };
+    endpointGeneration: number;
+    pid: number;
+    endpointMtimeMs?: number;
+    lifecycleRequestId?: string;
+    terminalUncertain?: boolean;
+    ts: number;
+    checksum: string;
+}
+export interface IndexedSession {
+    sessionId: string;
+    locator: {
+        repo: string;
+        stateRoot: string;
+    };
+    endpointGeneration: number;
+    pid: number;
+    endpointMtimeMs?: number;
+    live: boolean;
+    indexSeq: number;
+    lifecycleRequestId?: string;
+    terminalUncertain?: boolean;
+}
+export interface SessionList {
+    indexSeq: number;
+    sessions: IndexedSession[];
+    warnings: string[];
+}
+export declare const sessionIndexChecksum: (event: Omit<SessionIndexEvent, "checksum">) => string;
+export declare class SessionIndex {
+    #private;
+    constructor(agentDir: string);
+    open(): Promise<this>;
+    replay(): Promise<void>;
+    refresh(): Promise<void>;
+    get indexSeq(): number;
+    append(input: Omit<SessionIndexEvent, "version" | "indexSeq" | "checksum" | "ts"> & Partial<Pick<SessionIndexEvent, "ts">>): Promise<SessionIndexEvent>;
+    snapshot(): Promise<void>;
+    assertSupportedStateVersions(): Promise<void>;
+    listSessions(): SessionList;
+    hostUnregisteredAfter(registration: Pick<IndexedSession, "sessionId" | "endpointGeneration" | "pid" | "indexSeq" | "lifecycleRequestId">): {
+        indexSeq: number;
+        lifecycleRequestId?: string;
+    } | undefined;
+    findHostRegistration(sessionId: string, endpointGeneration: number, pid: number, lifecycleRequestId?: string): IndexedSession | undefined;
+    hasHostRegistrationForLifecycle(sessionId: string, pid: number, lifecycleRequestId: string): boolean;
+}

package/dist/types/sdk/broker/state-version.d.ts

@@ -0,0 +1,8 @@
+export declare const SDK_STATE_VERSION = 1;
+export declare class UnsupportedStateVersionError extends Error {
+    readonly file: string;
+    readonly version: number;
+    readonly code = "unsupported_state_version";
+    constructor(file: string, version: number);
+}
+export declare function assertSupportedStateVersion(file: string, value: unknown): void;

package/dist/types/sdk/broker/transport.d.ts

@@ -0,0 +1,9 @@
+import type { Broker } from "./broker";
+/** Loopback-only WebSocket transport for the agent-global SDK broker. */
+export declare class BrokerTransport {
+    #private;
+    constructor(broker: Broker, token: string, port?: number);
+    get port(): number;
+    start(): Promise<number>;
+    stop(): Promise<void>;
+}

package/dist/types/sdk/bus/chat-command-policy.d.ts

@@ -0,0 +1,49 @@
+import { type Adapter, type OperationKind } from "../protocol/operation-registry";
+export type ChatTransport = Extract<Adapter, "telegram" | "discord" | "slack">;
+export type ChatOperationDisposition = "allowed" | "unsupported_on_chat";
+export interface ChatCommandError {
+    code: "unsupported_on_chat" | "secret_input_forbidden";
+    message: string;
+}
+export type ChatCommandDecision = {
+    ok: true;
+} | {
+    ok: false;
+    error: ChatCommandError;
+};
+export interface ChatOperationRequest {
+    kind: OperationKind;
+    operation: string;
+    input?: unknown;
+}
+/**
+ * Chat authorization follows each transport's canonical registry disposition.
+ * Explicit policy prohibitions remain as defense in depth for shell execution,
+ * callback-provider registration, and endpoint credentials.
+ */
+export declare const CHAT_OPERATION_POLICY: Readonly<Record<ChatTransport, Readonly<Record<string, ChatOperationDisposition>>>>;
+/** Reject unsafe or unknown commands before their SDK request can be sent. */
+export declare function authorizeChatOperation(transport: ChatTransport, request: ChatOperationRequest): ChatCommandDecision;
+/** Execute only an authorized command, ensuring rejected payloads produce no SDK send. */
+export declare function sendAuthorizedChatOperation<T>(transport: ChatTransport, request: ChatOperationRequest, send: () => Promise<T>): Promise<{
+    ok: true;
+    result: T;
+} | {
+    ok: false;
+    error: ChatCommandError;
+}>;
+export type ChatCommandOutcome = {
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+/**
+ * The chat transport is an untrusted presentation surface, not a general SDK
+ * result renderer. Never serialize SDK result bodies or provider error text.
+ */
+export declare function projectChatCommandOutcome(request: Pick<ChatOperationRequest, "kind" | "operation">, outcome: ChatCommandOutcome): Record<string, unknown>;

package/dist/types/sdk/bus/chat-daemon-cli.d.ts

@@ -0,0 +1,21 @@
+import { type ChatDaemonKind } from "./chat-daemon-control";
+import { type ChatDaemonRuntimeConfig } from "./chat-daemon-runtime";
+export interface ChatDaemonRuntimeHandle {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    transportHealthy?(): boolean;
+}
+export interface RunChatDaemonInternalDeps {
+    processPid?: number;
+    pidAlive?: (pid: number) => boolean;
+    createRuntime?: (input: {
+        kind: ChatDaemonKind;
+        agentDir: string;
+        config: ChatDaemonConfig;
+    }) => Promise<ChatDaemonRuntimeHandle> | ChatDaemonRuntimeHandle;
+    setInterval?: typeof setInterval;
+    clearInterval?: typeof clearInterval;
+}
+export type ChatDaemonConfig = ChatDaemonRuntimeConfig;
+/** Hidden worker entrypoint. It owns only lock/state/control lifecycle; transport creation remains injectable. */
+export declare function runChatDaemonInternal(kind: ChatDaemonKind, argv: string[], deps?: RunChatDaemonInternalDeps): Promise<void>;

package/dist/types/sdk/bus/chat-daemon-control.d.ts

@@ -0,0 +1,111 @@
+import type { Settings } from "../../config/settings";
+import type { BuiltInDaemonController, DaemonOperationOptions, DaemonOperationResult, DaemonRuntimeInfo, DaemonStatus } from "../../daemon/control-types";
+export type ChatDaemonKind = "discord" | "slack";
+export type ChatDaemonAction = "stop" | "reload";
+export interface ChatDaemonState {
+    version: 1;
+    kind: ChatDaemonKind;
+    pid: number;
+    ownerId: string;
+    identity: string;
+    incarnation: string;
+    startedAt: number;
+    heartbeatAt: number;
+    transportHealthy: boolean;
+    stoppedAt?: number;
+}
+export interface ChatDaemonControlRequest {
+    version: 1;
+    requestId: string;
+    action: ChatDaemonAction;
+    ownerId: string;
+    pid: number;
+    createdAt: number;
+    incarnation: string;
+}
+export interface ChatDaemonControlDeps {
+    pidAlive?: (pid: number) => boolean;
+    sendSignal?: (pid: number, signal: NodeJS.Signals) => void;
+    spawn?: (command: string, args: string[], opts: {
+        detached: boolean;
+        stdio: "ignore";
+    }) => {
+        unref?: () => void;
+    };
+    execPath?: string;
+    ownerPid?: number;
+    randomId?: () => string;
+    pidIncarnation?: (pid: number) => string | undefined;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare function chatDaemonPaths(agentDir: string, kind: ChatDaemonKind): {
+    dir: string;
+    lock: string;
+    state: string;
+    control: string;
+};
+export declare function readChatDaemonState(agentDir: string, kind: ChatDaemonKind): Promise<ChatDaemonState | undefined>;
+export declare function readChatDaemonControlRequest(agentDir: string, kind: ChatDaemonKind): Promise<ChatDaemonControlRequest | undefined>;
+export declare function writeChatDaemonControlRequest(agentDir: string, kind: ChatDaemonKind, request: ChatDaemonControlRequest): Promise<void>;
+export declare function clearChatDaemonControlRequest(agentDir: string, kind: ChatDaemonKind, requestId?: string): Promise<void>;
+export declare function buildChatDaemonSpawnArgs(input: {
+    kind: ChatDaemonKind;
+    ownerId: string;
+    agentDir: string;
+    execPath?: string;
+}): {
+    command: string;
+    args: string[];
+    runtime: DaemonRuntimeInfo;
+};
+export declare class ChatDaemonController implements BuiltInDaemonController {
+    private readonly settings;
+    private readonly deps;
+    readonly kind: ChatDaemonKind;
+    constructor(settings: Settings, kind: ChatDaemonKind, deps?: ChatDaemonControlDeps);
+    private identity;
+    private alive;
+    status(): Promise<DaemonStatus>;
+    stop(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
+    reload(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
+    ensure(): Promise<EnsureChatDaemonResult>;
+    private operate;
+    private incarnation;
+    private isLiveState;
+    private stopForReplacement;
+    private ownsCapturedState;
+    private signalIfOwner;
+    private ownerChanged;
+    private result;
+    private waitForDeath;
+    private sleep;
+    private spawn;
+}
+export type EnsureChatDaemonResult = "disabled" | "owner_spawned" | "attached";
+export declare function ensureDiscordDaemon(settings: Settings, deps?: ChatDaemonControlDeps): Promise<EnsureChatDaemonResult>;
+export declare function ensureSlackDaemon(settings: Settings, deps?: ChatDaemonControlDeps): Promise<EnsureChatDaemonResult>;
+export declare function acquireChatDaemonOwnership(input: {
+    agentDir: string;
+    kind: ChatDaemonKind;
+    ownerId: string;
+    pid?: number;
+    identity: string;
+    incarnation?: string;
+    pidAlive?: (pid: number) => boolean;
+    pidIncarnation?: (pid: number) => string | undefined;
+}): Promise<boolean>;
+export declare function renewChatDaemonHeartbeat(input: {
+    agentDir: string;
+    kind: ChatDaemonKind;
+    ownerId: string;
+    pid?: number;
+    incarnation?: string;
+    transportHealthy: boolean;
+}): Promise<boolean>;
+export declare function releaseChatDaemonOwnership(input: {
+    agentDir: string;
+    kind: ChatDaemonKind;
+    ownerId: string;
+    pid?: number;
+    incarnation?: string;
+}): Promise<void>;

package/dist/types/sdk/bus/chat-daemon-runtime.d.ts

@@ -0,0 +1,77 @@
+import { SessionIndex } from "../broker/session-index";
+import { type SdkSessionEndpoint } from "../client/discovery";
+import type { ChatDaemonKind } from "./chat-daemon-control";
+import type { DiscordProvider } from "./discord-provider";
+import { type SlackProviderClient } from "./slack-provider";
+export interface ChatDaemonRuntimeConfig {
+    identity: string;
+    notifications: {
+        discord?: {
+            botToken: string;
+            applicationId: string;
+            guildId: string;
+            parentChannelId: string;
+        };
+        slack?: {
+            botToken: string;
+            appToken: string;
+            workspaceId: string;
+            channelId: string;
+            authorizedUserId?: string;
+        };
+    };
+    presentation?: {
+        redact: boolean;
+        verbosity: "lean" | "verbose";
+    };
+}
+export interface ChatDaemonSdkClient {
+    onFrame(handler: (frame: Record<string, unknown>) => void): () => void;
+    request(frame: Record<string, unknown>): Promise<Record<string, unknown>>;
+    close(): Promise<void>;
+    send(frame: Record<string, unknown>): void;
+}
+export type ChatDeliveryPhase = "pre_send" | "ambiguous";
+/** An authorized SDK command could not be conclusively delivered. */
+export declare class ChatDeliveryError extends Error {
+    readonly phase: ChatDeliveryPhase;
+    constructor(phase: ChatDeliveryPhase);
+}
+export interface ChatDaemonRuntimeDeps {
+    createDiscordProvider?: (config: NonNullable<ChatDaemonRuntimeConfig["notifications"]["discord"]>) => DiscordProvider;
+    createSlackProvider?: (config: NonNullable<ChatDaemonRuntimeConfig["notifications"]["slack"]>) => SlackProviderClient;
+    createClient?: (endpoint: SdkSessionEndpoint) => Promise<ChatDaemonSdkClient>;
+    createIndex?: (agentDir: string) => SessionIndex;
+    createBrokerClient?: (endpoint: {
+        url: string;
+        token: string;
+    }) => Promise<ChatDaemonSdkClient>;
+    onReconciled?: () => void;
+    setInterval?: typeof setInterval;
+    clearInterval?: typeof clearInterval;
+}
+/**
+ * Worker-owned session discovery and event fanout. It connects only through the
+ * public SDK transport and retains endpoint tokens solely in live client objects.
+ */
+export declare class ChatDaemonRuntime {
+    #private;
+    private readonly input;
+    private readonly deps;
+    constructor(input: {
+        kind: ChatDaemonKind;
+        agentDir: string;
+        config: ChatDaemonRuntimeConfig;
+    }, deps?: ChatDaemonRuntimeDeps);
+    start(): Promise<void>;
+    transportHealthy(): boolean;
+    stop(): Promise<void>;
+    private reconcile;
+    private attach;
+    private resolveEndpoint;
+    private schedule;
+    private enqueueFrame;
+    private handleFrame;
+    private close;
+    private resume;
+}

package/dist/types/sdk/bus/chat-effect-journal.d.ts

@@ -0,0 +1,84 @@
+import { type ConversationRecord, type ConversationStoreFs } from "./conversation-store";
+export declare const CHAT_EFFECT_JOURNAL_VERSION = 1;
+export declare const MAX_TERMINAL_CHAT_EFFECTS = 128;
+export declare function chatEffectJournalPath(agentDir: string, transport: "discord" | "slack"): string;
+export type ChatEffectState = "pending" | "leased" | "accepted" | "uncertain" | "terminal";
+/** Provider receipts are identifiers/status only. Never put request or response bodies here. */
+export interface ChatEffectReceipt {
+    provider?: string;
+    messageId?: string;
+    channelId?: string;
+    threadId?: string;
+    timestamp?: string;
+    status?: string;
+}
+/**
+ * A protected, generation-bound provider-visible effect. Payload is deliberately
+ * owned by this journal; conversation mappings may retain only `effectId`.
+ */
+export interface ChatEffect<TPayload = unknown> extends ConversationRecord {
+    id: string;
+    kind: string;
+    transport: "discord" | "slack";
+    sessionId?: string;
+    endpointGeneration: number;
+    payload: TPayload;
+    state: ChatEffectState;
+    owner?: string;
+    leaseExpiresAt?: number;
+    epoch: number;
+    createdAt: number;
+    updatedAt: number;
+    receipt?: ChatEffectReceipt;
+}
+export interface EnqueueChatEffect<TPayload> {
+    id: string;
+    kind: string;
+    transport: "discord" | "slack";
+    sessionId?: string;
+    endpointGeneration: number;
+    payload: TPayload;
+    receipt?: ChatEffectReceipt;
+}
+export interface ChatEffectLease {
+    owner: string;
+    epoch: number;
+}
+/**
+ * One journal per transport. It uses the same 0600, fsynced atomic persistence
+ * and cross-process exclusive locking as mappings, but stores payloads in a
+ * separate protected file (`effects.json`). Terminal history is compacted only
+ * after terminal state is durably recorded; nonterminal effects are never evicted.
+ */
+export declare class ChatEffectJournal {
+    #private;
+    constructor(input: {
+        agentDir: string;
+        transport: "discord" | "slack";
+        fs?: ConversationStoreFs;
+        now?: () => number;
+        pid?: number;
+        pidAlive?: (pid: number) => boolean;
+        pidIncarnation?: (pid: number) => string | undefined;
+        sleep?: (ms: number) => Promise<void>;
+        lockTimeoutMs?: number;
+    });
+    get filePath(): string;
+    read<TPayload = unknown>(id: string): Promise<ChatEffect<TPayload> | undefined>;
+    list(): Promise<ChatEffect[]>;
+    replayable(transport: "discord" | "slack", endpointGeneration: number): Promise<ChatEffect[]>;
+    enqueue<TPayload>(input: EnqueueChatEffect<TPayload>): Promise<ChatEffect<TPayload>>;
+    /**
+     * Inserts an effect directly into a live lease. Recovery can never observe a
+     * newly persisted effect as claimable before its owner has authority to act.
+     * Existing effects are left untouched and report no acquired lease.
+     */
+    enqueueAndClaim<TPayload>(input: EnqueueChatEffect<TPayload>, owner: string, leaseMs: number): Promise<ChatEffect<TPayload> | undefined>;
+    claim<TPayload = unknown>(id: string, owner: string, leaseMs: number): Promise<ChatEffect<TPayload> | undefined>;
+    renew<TPayload = unknown>(id: string, lease: ChatEffectLease, leaseMs: number): Promise<ChatEffect<TPayload> | undefined>;
+    /** Persists provider progress without releasing the owner/epoch fence. */
+    recordReceipt<TPayload = unknown>(id: string, lease: ChatEffectLease, receipt: ChatEffectReceipt): Promise<ChatEffect<TPayload> | undefined>;
+    record<TPayload = unknown>(id: string, lease: ChatEffectLease, state: Exclude<ChatEffectState, "pending" | "leased">, receipt?: ChatEffectReceipt): Promise<ChatEffect<TPayload> | undefined>;
+    /** Irreversibly rejects an effect whose mapping never accepted its authority. */
+    terminalize(id: string, receipt: ChatEffectReceipt, lease?: ChatEffectLease): Promise<ChatEffect | undefined>;
+}

package/dist/types/{notifications → sdk/bus}/config-commands.d.ts

@@ -18,11 +18,12 @@ export interface ConfigCommandChange {
     verbosity?: "lean" | "verbose";
     redact?: boolean;
 }
-export type TelegramControlCommandName = "reasoning" | "usage" | "context" | "compact";
+export type TelegramControlCommandName = "reasoning" | "usage" | "context" | "compact" | "model";
 export type TelegramControlCommand = {
     name: "reasoning";
-    action: "cycle" | "status" | "set";
+    action: "cycle" | "status" | "set" | "show" | "hide";
     level?: string;
+    global?: boolean;
 } | {
     name: "usage";
 } | {
@@ -30,6 +31,10 @@ export type TelegramControlCommand = {
 } | {
     name: "compact";
     instructions?: string;
+} | {
+    name: "model";
+    action: "list" | "set";
+    selector?: string;
 };
 export type TelegramControlCommandParseResult = {
     kind: "none";