@gajae-code/coding-agent 0.10.1 → 0.11.0

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

@@ -0,0 +1,30 @@
+import { processIncarnation } from "./process-incarnation";
+import { SDK_STATE_VERSION } from "./state-version";
+export declare const BROKER_HEARTBEAT_TTL_MS = 15000;
+export interface BrokerDiscovery {
+    version: typeof SDK_STATE_VERSION;
+    protocolVersion: 3;
+    packageGeneration: string;
+    ownerId: string;
+    pid: number;
+    incarnation: string;
+    host: "127.0.0.1";
+    port: number;
+    url: string;
+    token: string;
+    startedAt: number;
+    heartbeatAt: number;
+}
+export type RedactedBrokerDiscovery = Omit<BrokerDiscovery, "token"> & {
+    token: "[redacted]";
+};
+export type BrokerDiscoveryWrite = Omit<BrokerDiscovery, "incarnation"> & {
+    incarnation?: string;
+};
+export declare const brokerDiscoveryPath: (agentDir: string) => string;
+export declare const newBrokerToken: () => string;
+export declare const brokerProcessIncarnation: typeof processIncarnation;
+export declare function isPidAlive(pid: number): boolean;
+export declare function writeBrokerDiscovery(agentDir: string, discovery: BrokerDiscoveryWrite): Promise<void>;
+export declare function readBrokerDiscovery(agentDir: string, ttlMs?: number): Promise<BrokerDiscovery | null>;
+export declare function redactBrokerDiscovery(discovery: BrokerDiscovery): RedactedBrokerDiscovery;

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

@@ -0,0 +1,33 @@
+import { type ChildProcess } from "node:child_process";
+import { type BrokerDiscovery } from "./discovery";
+import { type SdkInternalSpawnCommand } from "./runtime";
+export interface EnsureBrokerSettings {
+    agentDir: string;
+    heartbeatTtlMs?: number;
+    /**
+     * Environment for the spawned detached broker. Defaults to `process.env`; tests
+     * that pre-start an isolated broker pass the same sanitized child env so the
+     * broker and the child that attaches to it share one owned root.
+     */
+    env?: NodeJS.ProcessEnv;
+}
+interface BrokerOwner {
+    stop(): Promise<void>;
+    canReuse(discovery: BrokerDiscovery | null): boolean;
+    markReady(discovery: BrokerDiscovery): boolean;
+}
+interface ReapTiming {
+    gracefulMs: number;
+    killVerifyMs: number;
+}
+/** Starts the detached broker entrypoint when discovery has no live owner. */
+export declare function ensureBroker(settings: EnsureBrokerSettings): Promise<BrokerDiscovery>;
+/** Test hook: returns a stop handle for the detached broker this process spawned. */
+export declare function brokerOwnerForTest(agentDir: string): BrokerOwner | undefined;
+/** Test hook: drives the detached-broker reap on a controllable child surface. */
+export declare function reapSpawnedBrokerForTest(child: ChildProcess, timing?: ReapTiming): Promise<void>;
+/** Test hook: resolves the complete broker environment without spawning. */
+export declare function brokerSpawnEnvironmentForTest(command: SdkInternalSpawnCommand, override?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** Test hook: installs an exact controllable owner to exercise replacement fencing. */
+export declare function registerBrokerOwnerForTest(agentDir: string, child: ChildProcess, timing?: ReapTiming): BrokerOwner;
+export {};

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

@@ -0,0 +1,3 @@
+export declare function brokerIdentityPath(agentDir: string): string;
+export declare function getBrokerIdentityKey(agentDir: string): Promise<string>;
+export declare function deriveIdempotencyIdentity(agentDir: string, operation: string, callerKey: string, canonicalTargetHash: string): Promise<string>;

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

@@ -0,0 +1,8 @@
+export * from "./broker";
+export * from "./discovery";
+export * from "./ensure";
+export * from "./identity";
+export * from "./lifecycle";
+export * from "./lifecycle-ledger";
+export * from "./session-index";
+export * from "./transport";

package/dist/types/sdk/broker/lifecycle-ledger.d.ts

@@ -0,0 +1,95 @@
+import type { SdkStartupFailure, SdkStartupRollbackResult } from "../startup-capability";
+import { SDK_STATE_VERSION } from "./state-version";
+export type LifecycleState = "accepted" | "effect_started" | "awaiting_ready" | "terminal_ok" | "terminal_error" | "terminal_uncertain";
+export interface LifecycleWorktreeIntent {
+    repoRoot: string;
+    worktreePath: string;
+    detached: boolean;
+    baseRef: string;
+    branchName?: string;
+}
+export interface LifecycleEffectIntent {
+    sessionId: string;
+    stateRoot: string;
+    childOwnershipEstablished?: boolean;
+    worktree?: LifecycleWorktreeIntent;
+}
+/** Durable lifecycle effects retained for exact replay; never implies rollback authority. */
+export interface LifecycleCleanupProof {
+    processExited: true;
+    endpointRemoved: true;
+    hostUnregistered: {
+        state: "unregistered";
+        indexSeq: number;
+        lifecycleRequestId?: string;
+    } | {
+        state: "not_registered";
+    };
+    rollback: {
+        endpointGeneration: number | null;
+        fenced: true;
+        runtimeRemoved: true;
+        hostStopped: true;
+        brokerRegistrationReleased: true;
+    };
+}
+export interface LifecycleStartupFailureReceipt extends SdkStartupFailure {
+    artifactDigest: string;
+    rollback: SdkStartupRollbackResult;
+    cleanupProof?: LifecycleCleanupProof;
+}
+export interface LifecycleDurableEffectsReceipt {
+    worktree?: {
+        cwdDigest: string;
+        created: boolean;
+        reused: boolean;
+        branchDigest?: string;
+    };
+    transcript?: {
+        identityDigest: string;
+        contentDigest: string;
+    };
+    startup?: LifecycleStartupFailureReceipt;
+    digest?: string;
+}
+export interface LifecycleLedgerEntry {
+    version: typeof SDK_STATE_VERSION;
+    identity: string;
+    requestHash: string;
+    state: LifecycleState;
+    intendedSessionId?: string;
+    resultSessionId?: string;
+    effectMarker?: string;
+    effectIntent?: LifecycleEffectIntent;
+    durableEffects?: LifecycleDurableEffectsReceipt;
+    startupFailure?: LifecycleStartupFailureReceipt;
+    endpointGeneration?: number;
+    responseDigest?: string;
+    response?: unknown;
+    ts: number;
+}
+export type BeginResult = {
+    kind: "new";
+    entry: LifecycleLedgerEntry;
+} | {
+    kind: "replay";
+    entry: LifecycleLedgerEntry;
+} | {
+    kind: "idempotency_conflict";
+} | {
+    kind: "terminal_uncertain";
+    entry: LifecycleLedgerEntry;
+} | {
+    kind: "in_progress";
+    entry: LifecycleLedgerEntry;
+};
+export declare class LifecycleLedger {
+    #private;
+    constructor(agentDir: string);
+    open(): Promise<this>;
+    get warnings(): readonly string[];
+    begin(identity: string, requestHash: string): Promise<BeginResult>;
+    transition(identity: string, state: LifecycleState, fields?: Omit<Partial<LifecycleLedgerEntry>, "identity" | "requestHash" | "state" | "ts">): Promise<LifecycleLedgerEntry>;
+    assertSupportedStateVersions(): Promise<void>;
+    get(identity: string): LifecycleLedgerEntry | undefined;
+}

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

@@ -0,0 +1,85 @@
+import type { SdkStartupFailure, SdkStartupRollbackResult } from "../startup-capability";
+import type { Broker, BrokerResponse } from "./broker";
+import type { LifecycleDurableEffectsReceipt, LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
+import { type ProcessIncarnationCommandRunner, type ProcessIncarnationOptions, parseDarwinProcessIncarnation, processIncarnation } from "./process-incarnation";
+import { type SdkInternalSpawnCommand } from "./runtime";
+export { type ProcessIncarnationCommandRunner, type ProcessIncarnationOptions, parseDarwinProcessIncarnation, processIncarnation, };
+export interface LifecycleDeadlines {
+    receivedAt: number;
+    requestedReadinessTimeoutMs: number;
+    semanticReadyDeadlineAt: number;
+    terminationStartDeadlineAt: number;
+    lifecycleCleanupDeadlineAt: number;
+}
+export declare function deriveLifecycleDeadlines(receivedAt: number, requestedReadinessTimeoutMs: number): LifecycleDeadlines;
+export interface LifecycleTiming {
+    now(): number;
+    sleep(ms: number): Promise<void>;
+}
+type LifecycleCommand = SdkInternalSpawnCommand | {
+    file: string;
+    args: string[];
+};
+type LifecycleCommandResolver = () => LifecycleCommand;
+export declare function setLifecycleCommandResolverForTest(broker: Broker, resolver: LifecycleCommandResolver | undefined): void;
+export declare function setLifecycleTimingForTest(broker: Broker, timing: LifecycleTiming | undefined): void;
+export declare function hasValidLifecycleDeadlines(value: LifecycleDeadlines, now?: number): boolean;
+type Input = Record<string, unknown>;
+export declare const isCanonicalSessionId: (value: string) => boolean;
+export interface SessionLifecycleWorktreeTarget {
+    enabled: true;
+    name?: string;
+}
+export interface SessionLifecycleWorktreeReceipt {
+    enabled: true;
+    cwd: string;
+    created: boolean;
+    reused: boolean;
+    branch?: string;
+}
+export interface SessionLifecycleTranscriptIdentity {
+    dev: string;
+    ino: string;
+    size: number;
+    mtimeMs: number;
+    mtimeNs: string;
+}
+export interface SessionLifecycleLaunchRequest {
+    operation: "session.create" | "session.fork" | "session.resume";
+    sessionId: string;
+    cwd: string;
+    stateRoot: string;
+    sourceSessionId?: string;
+    sourceSessionPath?: string;
+    sourceSessionIdentity?: SessionLifecycleTranscriptIdentity;
+    sourceCwd?: string;
+    sessionPath?: string;
+    sessionIdentity?: SessionLifecycleTranscriptIdentity;
+    /** Broker-issued effect marker which the child echoes only after host readiness. */
+    effectMarker?: string;
+    modelPreset?: string;
+    worktree?: SessionLifecycleWorktreeTarget;
+    receivedAt: number;
+    requestedReadinessTimeoutMs: number;
+    semanticReadyDeadlineAt: number;
+    terminationStartDeadlineAt: number;
+    lifecycleCleanupDeadlineAt: number;
+}
+export declare function readSessionLifecycleLaunchRequest(value: string | undefined, now?: number): SessionLifecycleLaunchRequest;
+export declare function setProcessIncarnationForTest(broker: Broker, value: ((pid: number) => string | undefined) | undefined): void;
+/** The child writes this only after its endpoint and semantic ready event are both live. */
+export declare function writeSessionLifecycleReady(root: string, id: string, effectMarker: string): Promise<void>;
+export interface LifecycleTranscriptEvidence {
+    digest: string;
+    identity: SessionLifecycleTranscriptIdentity;
+}
+/** The child writes bounded startup diagnostics before exiting without readiness. */
+export declare function writeSessionLifecycleFailure(root: string, id: string, effectMarker: string, failure: SdkStartupFailure, rollback: SdkStartupRollbackResult, transcript?: LifecycleTranscriptEvidence, ownerIncarnation?: string): Promise<void>;
+export interface LifecycleExecutionOutcome {
+    response: BrokerResponse;
+    durableEffects?: LifecycleDurableEffectsReceipt;
+    startupFailure?: LifecycleStartupFailureReceipt;
+    deferredArtifactCleanup?: () => Promise<void>;
+}
+/** Returns the response together with every durable lifecycle fact needed for truthful replay. */
+export declare function executeLifecycle(broker: Broker, operation: string, input: Input, identity: string): Promise<LifecycleExecutionOutcome>;

package/dist/types/sdk/broker/process-incarnation.d.ts

@@ -0,0 +1,14 @@
+type ProcessIncarnationCommandResult = {
+    exitCode: number | null;
+    stdout: string;
+} | undefined;
+export type ProcessIncarnationCommandRunner = (command: string, args: readonly string[]) => ProcessIncarnationCommandResult;
+export interface ProcessIncarnationOptions {
+    platform?: typeof process.platform;
+    runCommand?: ProcessIncarnationCommandRunner;
+}
+/** Parse the microsecond-resolution start timestamp returned by Darwin proc_pidinfo. */
+export declare function parseDarwinProcessIncarnation(info: Uint8Array): string | undefined;
+/** A PID is reusable; bind it to the strongest OS-provided process start incarnation available. */
+export declare function processIncarnation(pid: number, options?: ProcessIncarnationOptions): string | undefined;
+export {};

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

@@ -0,0 +1,33 @@
+export type SdkInternalAction = "broker-internal" | "session-host-internal";
+export type SdkInternalSpawnCommand = {
+    kind: "bun-source";
+    file: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+} | {
+    kind: "compiled";
+    file: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    cwd?: undefined;
+};
+type EmbeddedFile = Blob | {
+    name: string;
+};
+/** Test-only injectable inputs for hostile evidence and platform grammar coverage. */
+export interface SdkInternalRuntimeDescriptorTestOptions {
+    execPath?: string;
+    environment?: NodeJS.ProcessEnv;
+    embeddedFiles?: readonly EmbeddedFile[];
+    markerPath?: string;
+    brokerDirectory?: string;
+    cliPath?: string;
+    configPath?: string;
+    bunAvailable?: boolean;
+}
+/** Resolve the production descriptor from the statically imported marker and current Bun runtime evidence. */
+export declare function resolveSdkInternalSpawnCommand(action: SdkInternalAction): SdkInternalSpawnCommand;
+/** Test hook: injects runtime evidence without weakening the production marker authority. */
+export declare function resolveSdkInternalSpawnCommandForTest(action: SdkInternalAction, options: SdkInternalRuntimeDescriptorTestOptions): SdkInternalSpawnCommand;
+export {};

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;
+}