@gajae-code/coding-agent 0.15.6 → 0.16.0

package/dist/types/sdk/broker/spawn-authority.d.ts

@@ -0,0 +1,201 @@
+export type SpawnClaimV2 = {
+    version: 2;
+    claimId: string;
+    lifecycleIdentity: string;
+    /** Opaque binding of the raw selector request, retained for catalog-independent replay. */
+    requestBindingMac?: string;
+    bindingMac: string;
+    state: "prepared" | "substrate_starting" | "authority_active" | "seed_prepared" | "dispatching" | "accepted" | "pre_send_rejected" | "uncertain" | "closed";
+    failure?: SpawnSubstrateFailure;
+    preSendLease?: {
+        epoch: string;
+        status: "owned" | "consumed";
+    };
+    childId?: string;
+    seed?: SeedDeliveryV2;
+    authorityRef?: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type SpawnSubstrateFailure = {
+    substrateKind: "tmux" | "psmux" | "headless";
+    code: string;
+    message: string;
+};
+export type SeedDeliveryV2 = {
+    version: 2;
+    phase: "prepared" | "dispatching" | "accepted" | "pre_send_rejected" | "uncertain";
+    clientRef: string;
+    commandId?: string;
+    turnId?: string;
+    acceptedAt?: number;
+    lastQ26Status?: "accepted" | "in_flight" | "terminal_ok" | "failed" | "unknown";
+    observedAt?: number;
+};
+/** Live-only capability check. Implementations must not retain either argument. */
+export interface MasterCapabilityVerifier {
+    verifyMasterCapability(ownerSessionId: string, rawCapability: string, attestationEpoch: string): Promise<{
+        allowed: boolean;
+    }>;
+}
+/** Structured, shell-free child launch contract owned by the Broker. */
+export interface SpawnSubstrateLaunchSpec {
+    childSessionId: string;
+    cwd: string;
+    argv: readonly string[];
+    /** Broker-inherited values are filtered to the portable launch subset. */
+    inheritedEnv?: Readonly<Record<string, string>>;
+    /** Child-specific values are part of this spec and must be shell-safe. */
+    env?: Readonly<Record<string, string>>;
+}
+/** Durable facts required to re-prove one spawned substrate without task material. */
+export type SpawnSubstrateProof = {
+    substrateKind: "tmux" | "psmux" | "headless";
+    providerIdentity: string;
+    nativeSessionId?: string;
+    pid?: number;
+    processIncarnation?: string;
+    ownerGeneration?: number;
+    stateFileProof?: Readonly<Record<string, string | number>>;
+};
+export interface SpawnSubstrateProvider {
+    launch(spec: SpawnSubstrateLaunchSpec): Promise<{
+        ok: true;
+        proof: SpawnSubstrateProof;
+    } | {
+        ok: false;
+        code: "substrate_unavailable" | "substrate_proof_failed";
+        message: string;
+    }>;
+    verify(proof: SpawnSubstrateProof): Promise<"verified" | "mismatch" | "gone">;
+    close(proof: SpawnSubstrateProof): Promise<{
+        ok: boolean;
+        code?: string;
+    }>;
+}
+export type SpawnAuthorityCloseState = "active" | "close_requested" | "closed" | "uncertain";
+/**
+ * Exact, durable ownership evidence for a child substrate. It is deliberately
+ * structural: request text, capability material, and their derivatives never
+ * belong in this record.
+ */
+export type SpawnAuthorityV1 = {
+    version: 1;
+    authorityId: string;
+    claimId: string;
+    childId: string;
+    ownerSessionId: string;
+    lifecycleIdentity: string;
+    substrateKind: SpawnSubstrateProof["substrateKind"];
+    providerIdentity: string;
+    nativeSessionId?: string;
+    pid?: number;
+    processIncarnation?: string;
+    ownerGeneration?: number;
+    stateFileProof?: Readonly<Record<string, string | number>>;
+    /**
+     * Identity of the child HOST endpoint proven at registration. Distinct from
+     * the substrate `pid`/`processIncarnation` above: proving the multiplexer
+     * substrate is intact says nothing about which host answers on that session
+     * id. Optional so pre-pin v1 rows still reopen; recovery treats an absent
+     * pin as missing authority and fails closed rather than matching by id.
+     */
+    endpointGeneration?: number;
+    endpointPid?: number;
+    endpointIncarnation?: string;
+    /** Launch locator, so a colliding generation/pid in another workspace cannot pass. */
+    endpointCwd?: string;
+    endpointStateRoot?: string;
+    closeState: SpawnAuthorityCloseState;
+    orphanedAt?: number;
+    orphanRecoveredAt?: number;
+    closeRequestedAt?: number;
+    closedAt?: number;
+    createdAt: number;
+    updatedAt: number;
+};
+export type SpawnClaimTransition = {
+    claimId: string;
+    from: SpawnClaimV2["state"];
+    to: SpawnClaimV2["state"];
+    /** Required when the transition consumes the one pre-send lease. */
+    leaseEpoch?: string;
+    /** The fresh child ID is committed before substrate launch. */
+    childId?: string;
+    /** Required for seed and terminal state transitions that carry Q26 facts. */
+    seed?: SeedDeliveryV2;
+    failure?: SpawnSubstrateFailure;
+    /** Required when exact substrate authority becomes active or closes. */
+    authority?: SpawnAuthorityV1;
+    /** Required to downgrade dispatching only when no frame was handed off. */
+    provenNoHandoff?: true;
+};
+export type SpawnAuthorityTransitionResult = {
+    claim: SpawnClaimV2;
+    authority?: SpawnAuthorityV1;
+};
+export declare class SpawnAuthorityTransitionError extends Error {
+    readonly code: "claim_not_found" | "stale_transition" | "illegal_transition" | "invalid_transition";
+    constructor(code: "claim_not_found" | "stale_transition" | "illegal_transition" | "invalid_transition");
+}
+export type SpawnClaimDecision = {
+    kind: "owner";
+    claim: SpawnClaimV2;
+    recovery: boolean;
+} | {
+    kind: "in_progress";
+    claim: SpawnClaimV2;
+} | {
+    kind: "replay";
+    claim: SpawnClaimV2;
+} | {
+    kind: "terminal";
+    claim: SpawnClaimV2;
+} | {
+    kind: "terminal_uncertain";
+    claim: SpawnClaimV2;
+} | {
+    kind: "idempotency_conflict";
+    claim: SpawnClaimV2;
+};
+type SpawnAuthorityDurableWrite = {
+    claim: SpawnClaimV2;
+    authority?: SpawnAuthorityV1;
+};
+export interface SpawnAuthorityStoreOptions {
+    /** Test-only hook that runs before the journal record becomes durable. */
+    beforeSyncForTest?: (write: SpawnAuthorityDurableWrite) => Promise<void> | void;
+    /** Test-only hook after both file and parent-directory fsync complete. */
+    afterSyncForTest?: (write: SpawnAuthorityDurableWrite) => Promise<void> | void;
+    /** Test-only hook between the file barrier and the parent-directory barrier. */
+    beforeDirectorySyncForTest?: (write: SpawnAuthorityDurableWrite) => Promise<void> | void;
+}
+export declare function isSpawnSubstrateProof(value: unknown): value is SpawnSubstrateProof;
+export declare function isSpawnAuthorityV1(value: unknown): value is SpawnAuthorityV1;
+export declare function isSpawnClaimV2(value: unknown): value is SpawnClaimV2;
+/**
+ * Append-only source of spawn-effect authority. It deliberately records no request
+ * input: the opaque identity and raw/canonical structural binding MACs are its
+ * only correlators.
+ */
+export declare class SpawnAuthorityStore {
+    #private;
+    constructor(agentDir: string, brokerIdentityKey: string, options?: SpawnAuthorityStoreOptions);
+    get file(): string;
+    claims(): readonly SpawnClaimV2[];
+    claim(lifecycleIdentity: string): SpawnClaimV2 | undefined;
+    authority(lifecycleIdentity: string): SpawnAuthorityV1 | undefined;
+    open(): Promise<void>;
+    claimOrJoin(lifecycleIdentity: string, bindingMac: string | undefined, requestBindingMac?: string | undefined): Promise<SpawnClaimDecision>;
+    /**
+     * Fsyncs one allowlisted state edge. Callers cannot patch claims in place,
+     * which prevents a retry from downgrading a handoff-capable state.
+     */
+    persistTransition(lifecycleIdentity: string, transition: SpawnClaimTransition): Promise<SpawnAuthorityTransitionResult>;
+    /** Persists only an exact authority lifecycle update, never a proof replacement. */
+    persistAuthority(lifecycleIdentity: string, authority: SpawnAuthorityV1): Promise<SpawnAuthorityTransitionResult>;
+    /** Records an observed Q26 status without reopening or changing a state edge. */
+    persistSeedObservation(lifecycleIdentity: string, seed: SeedDeliveryV2): Promise<SpawnAuthorityTransitionResult>;
+    releaseOwner(lifecycleIdentity: string): Promise<void>;
+}
+export {};

package/dist/types/sdk/broker/spawn-substrate.d.ts

@@ -0,0 +1,30 @@
+import { type ManagedTmuxLaunchProof } from "../../gjc-runtime/tmux-sessions";
+import type { SpawnSubstrateLaunchSpec, SpawnSubstrateProvider } from "./spawn-authority";
+export type SpawnMultiplexerSelection = "none" | "tmux" | "psmux" | "proof_failed";
+export interface SpawnHeadlessProcess {
+    pid: number;
+    terminate(): void;
+}
+export interface SpawnSubstrateProviderDependencies {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    /** @internal Test seam for deterministic provider selection. */
+    selectMultiplexer?: () => SpawnMultiplexerSelection;
+    /** @internal Test seam for the managed multiplexer command layer. */
+    launchManaged?: (spec: SpawnSubstrateLaunchSpec, env: NodeJS.ProcessEnv, platform: NodeJS.Platform) => ManagedTmuxLaunchProof;
+    verifyManaged?: (proof: ManagedTmuxLaunchProof, env: NodeJS.ProcessEnv) => "verified" | "mismatch" | "gone";
+    closeManaged?: (proof: ManagedTmuxLaunchProof, env: NodeJS.ProcessEnv) => Promise<void>;
+    processIncarnation?: (pid: number) => string | undefined;
+    startHeadless?: (spec: SpawnSubstrateLaunchSpec, env: NodeJS.ProcessEnv) => SpawnHeadlessProcess;
+    signalHeadless?: (pid: number, incarnation: string, platform: NodeJS.Platform, signal: "SIGTERM" | "SIGKILL") => boolean;
+    isProcessGone?: (pid: number) => boolean;
+    /** @internal Test seam for bounded close polling. */
+    sleep?: (milliseconds: number) => Promise<void>;
+    /** @internal Test seam for non-secret inherited-environment launch diagnostics. */
+    onInheritedEnvironmentDrop?: (names: readonly string[]) => void;
+}
+/**
+ * Provides the Broker's only substrate authority. Every close and replay starts
+ * from its durable opaque proof; no PID/name-only operation is exposed.
+ */
+export declare function createSpawnSubstrateProvider(dependencies?: SpawnSubstrateProviderDependencies): SpawnSubstrateProvider;

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

@@ -1,5 +1,6 @@
 export declare const SDK_STATE_VERSION = 1;
-export declare const SESSION_INDEX_SNAPSHOT_VERSION = 3;
+export declare const SESSION_INDEX_SNAPSHOT_VERSION = 4;
+export declare const SESSION_INDEX_EVENT_VERSION = 4;
 export declare class UnsupportedStateVersionError extends Error {
     readonly file: string;
     readonly version: number;
@@ -8,4 +9,6 @@ export declare class UnsupportedStateVersionError extends Error {
     constructor(file: string, version: number, maximumSupportedVersion?: number);
 }
 export declare function assertSupportedStateVersion(file: string, value: unknown): void;
+/** Rejects session-index events outside the known legacy and current formats. */
+export declare function assertSupportedSessionIndexEventVersion(file: string, value: unknown): void;
 export declare function assertSupportedSnapshotVersion(file: string, value: unknown): void;

package/dist/types/sdk/broker/worktree-occupancy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Which session currently holds a GJC-managed worktree.
+ *
+ * Both launch paths need this answer and must not disagree about it: the broker
+ * refuses a lifecycle launch into an occupied worktree, and the interactive
+ * `gjc --worktree` launch refuses for the same reason. Keeping one predicate —
+ * and one definition of "still running" — here prevents the two from drifting
+ * into different notions of liveness.
+ */
+import type { IndexedSession } from "./session-index";
+export type ProcessObservation = "alive" | "exited" | "uncertain";
+/** Only ESRCH or a changed, readable incarnation proves the owned process exited. */
+export declare function observeProcess(pid: number, expectedIncarnation: string | undefined, readIncarnation?: (pid: number) => string | undefined): ProcessObservation;
+/**
+ * The id of a session still occupying `worktreePath`, or null when it is free.
+ *
+ * `ensureLaunchWorktree` reuses an existing worktree without asking whether
+ * anyone is in it, and an unnamed launch derives its directory deterministically
+ * from the repository's current branch. Two concurrent sessions in one
+ * repository therefore land in the same checkout and overwrite each other's
+ * files with no error.
+ *
+ * Only a process observed as definitively exited releases the worktree.
+ * `uncertain` counts as occupied: refusing a launch is recoverable by picking
+ * another worktree name, whereas two live sessions sharing a checkout corrupts
+ * work already done.
+ */
+export declare function worktreeOccupant(sessions: readonly IndexedSession[], worktreePath: string, observe?: (pid: number, expectedIncarnation: string | undefined) => ProcessObservation): string | null;

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

@@ -102,6 +102,9 @@ export type ChatDaemonAction = "stop" | "reload";
  * session-index lock every 2s; staleness retirement moved to a 30s sweep and
  * lease heartbeats no longer force an authority reconcile. A pre-upgrade owner
  * would retain the old hot polling loop, so replacement is required.
+ * Discord generation 72 / Slack generation 75 serialize same-generation
+ * successor attachment admission behind predecessor provider retirement, so a
+ * pre-upgrade owner cannot retain the queue race fixed by #5120.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

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

@@ -599,6 +599,12 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     controller?: NotificationSessionController;
     /** Whether this host mode can own the root SDK endpoint. Default: true. */
     sdkHostModeSupported?: boolean;
+    /** In-memory master capability for private broker verification only. */
+    masterCapability?: string;
+    /** Opaque direct-role epoch this effective host may adopt. */
+    masterAttestationEpoch?: string;
+    /** Stable master lineage identity retained across session switches/branches. */
+    masterOwnerSessionId?: string;
     onSdkRequest?: (kind: "control" | "query", connectionId: string, frame: Record<string, unknown>) => void;
     runBtwTurn?: (question: string, signal: AbortSignal) => Promise<{
         replyText: string;

package/dist/types/sdk/bus/telegram-daemon-contract.d.ts

@@ -286,7 +286,7 @@ export declare const SDK_LIFECYCLE_ROUTER_PROTOCOL_VERSION = 1;
  * killing a session's mirroring after one transient rejection and must be
  * replaced across this upgrade.
  */
-export declare const DAEMON_GENERATION = 179;
+export declare const DAEMON_GENERATION = 180;
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 7
  * requires durable publication receipts and acknowledged attachment dispatch,

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

@@ -1 +1,2 @@
+export * from "./master-cli";
 export * from "./session-cli";

package/dist/types/sdk/cli/master-cli.d.ts

@@ -0,0 +1,63 @@
+import { type IndexedSession } from "../broker/session-index";
+export declare class SdkMasterCliError extends Error {
+    readonly code: string;
+    readonly exitCode: 1 | 2;
+    constructor(code: string, message: string, exitCode?: 1 | 2);
+}
+export interface SdkSpawnArgs {
+    cwd?: string;
+    prompt?: string;
+    model?: string;
+    profile?: string;
+    agentDir?: string;
+    idempotencyKey?: string;
+    json?: boolean;
+}
+/** The allowlisted spawn result projection rendered to the operator. */
+export interface SdkSpawnRendered {
+    code: string;
+    claimId?: string;
+    sessionId?: string;
+    substrateKind?: string;
+    seed?: {
+        phase?: string;
+        clientRef?: string;
+        commandId?: string;
+        turnId?: string;
+        status?: string;
+    };
+    idempotencyKey?: string;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface SdkSpawnDependencies {
+    env: Record<string, string | undefined>;
+    dispatch: (agentDir: string, input: Record<string, unknown>, idempotencyKey: string) => Promise<unknown>;
+    resolveAttestationEpoch: (agentDir: string, ownerSessionId: string) => Promise<string | undefined>;
+}
+/**
+ * Select the newest retained master attestation for an owner session.
+ *
+ * `listSessionIdentities()` can retain both the direct-role row and one or
+ * more endpoint generations. Its iteration order is a projection detail, not
+ * authority ordering, so selecting the first matching row can resurrect an
+ * older epoch after a master relaunch. The broker's monotonically increasing
+ * `indexSeq` is the authoritative retained ordering.
+ */
+export declare function selectNewestMasterAttestationEpoch(rows: readonly IndexedSession[], ownerSessionId: string): string | undefined;
+/** Projects an arbitrary Broker response onto the allowlisted render shape. */
+export declare function safeSpawnRender(response: unknown): {
+    rendered: SdkSpawnRendered;
+    exitCode: 0 | 1;
+};
+export declare function renderSpawnTable(rendered: SdkSpawnRendered): string;
+/**
+ * Runs one local master spawn. A caller-provided idempotency key replays the
+ * matching durable claim; otherwise each invocation receives a fresh key.
+ */
+export declare function runSdkSpawn(args: SdkSpawnArgs, dependencies?: Partial<SdkSpawnDependencies>): Promise<{
+    rendered: SdkSpawnRendered;
+    exitCode: 0 | 1;
+}>;

package/dist/types/sdk/cli/rows.d.ts

@@ -1,5 +1,5 @@
 /**
- * Versioned DTO rows for `gjc sdk session` semantic verbs (row DTO v1, DR-12).
+ * Versioned DTO rows for `gjc sdk session` semantic verbs (row DTO v2, DR-12).
  *
  * Every semantic verb renders its output through these rows so machine
  * consumers get one deterministic, versioned envelope per verb. Credentials
@@ -7,7 +7,7 @@
  * credentials, and pass-through host payloads are redacted recursively before
  * rendering.
  */
-export declare const SESSION_ROWS_VERSION = 1;
+export declare const SESSION_ROWS_VERSION = 2;
 export type SdkSessionActivityState = "active" | "idle";
 export interface SdkSessionActivityV1 {
     state: SdkSessionActivityState;
@@ -16,7 +16,8 @@ export interface SdkSessionActivityV1 {
 export interface SdkSessionRowV1 {
     sessionId: string;
     locator: {
-        repo: string;
+        cwd: string;
+        worktreeRoot: string | null;
         stateRoot: string;
     };
     endpointGeneration: number;

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

@@ -1,6 +1,8 @@
+import { type SdkSearchResultV1, type SdkSearchRowV1 } from "../broker/session-scope";
+import type { SessionLifecycleService } from "../lifecycle/service";
 import { SessionRouter } from "../router";
 import { type SdkSessionRowV1 } from "./rows";
-export type SdkSessionCliAction = "list" | "inspect" | "send" | "status" | "tail" | "retire" | "global" | "raw" | "control" | "query" | "global";
+export type SdkSessionCliAction = "list" | "search" | "inspect" | "send" | "status" | "tail" | "retire" | "global" | "raw" | "control" | "query" | "global";
 export type SdkSessionListScope = "repo" | "cwd" | "worktree" | "all";
 export type SdkSessionCliRawKind = "control" | "query" | "global";
 export interface SdkSessionCliArgs {
@@ -15,7 +17,6 @@ export interface SdkSessionCliArgs {
     jsonInputFile?: string;
     jsonInputStdin?: boolean;
     idempotencyKey?: string;
-    scope?: string;
     confirm?: boolean;
     cursor?: string;
     wait?: boolean;
@@ -24,12 +25,24 @@ export interface SdkSessionCliArgs {
     untilIdle?: boolean;
     allEvents?: boolean;
     repo?: string;
+    scope?: string;
+    limit?: number;
+    json?: boolean;
     agentDir?: string;
 }
+type JsonRecord = Record<string, unknown>;
 export interface RetainedTranscriptTailReader {
     readonly size: number;
     readRange(start: number, end: number): Promise<Uint8Array>;
 }
+export declare function mergeProbedSearchRows(rows: readonly SdkSearchRowV1[], probedRows: readonly SdkSearchRowV1[]): readonly SdkSearchRowV1[];
+/** Resolves, lists, and probes only the exact rows selected by the Broker-scoped search. */
+export declare function runSdkSearch(args: Pick<SdkSessionCliArgs, "agentDir" | "repo" | "scope" | "limit" | "cursor">, createService?: (agentDir: string) => SessionLifecycleService, probe?: (agentDir: string, result: SdkSearchResultV1) => Promise<SdkSearchResultV1>): Promise<{
+    result: SdkSearchResultV1;
+    exitCode: 0 | 1;
+}>;
+/** Renders a credential-free scope/status preamble and bounded search table. */
+export declare function renderSdkSearchTable(result: SdkSearchResultV1): string;
 interface WorkspaceIdentity {
     /** Canonical workspace path (realpath when it exists, lexical resolve otherwise). */
     canonicalPath: string;
@@ -69,6 +82,9 @@ export declare function filterSessionRowsByScope(rows: readonly SdkSessionRowV1[
 }>;
 /** Creates a lowercase ULID operation reference for prompt reconciliation. */
 export declare function createOperationRef(now?: number): string;
+/** Builds the public CLI control envelope without leaking envelope fields into operation input. */
+export declare function controlRequestFrame(operation: string, input: JsonRecord, args: Pick<SdkSessionCliArgs, "confirm" | "idempotencyKey">): JsonRecord;
+export declare function operatorAbortBrokerRequest(sessionId: string, operation: string, input: JsonRecord, args: Pick<SdkSessionCliArgs, "confirm" | "idempotencyKey">): JsonRecord | undefined;
 /** Exported for tests: each status poll must stay inside the caller's wait window. */
 export declare function waitForTerminalStatus(router: SessionRouter, sessionId: string, clientRef: string, timeoutMs: number | undefined): Promise<{
     terminal: boolean;

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

@@ -90,12 +90,13 @@ export interface SdkDispatchContext {
     readonly connectionId: string | undefined;
     readonly generation: number;
 }
-/** Request identity retained after an uncertain send for lifecycle reconciliation. */
+/** Request identity retained after an uncertain send. */
 export interface SdkSentRecord {
     readonly id: string;
     readonly operation?: string;
     readonly idempotencyKey?: string;
-    readonly fingerprint: string;
+    /** Present for lifecycle lookups; `session.spawn` replays through its idempotency key. */
+    readonly fingerprint?: string;
 }
 export type SdkFrameHandler = (frame: SdkFrame) => void;
 export type SdkReconnectHandler = () => void;

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

@@ -31,5 +31,15 @@ export declare class BusyError extends TypedControlError {
     constructor(message?: string);
 }
 export declare function controlRequestFromFrame(frame: Record<string, unknown>): ControlRequest;
+export interface TerminalAbortIdentity {
+    input: {
+        mode: "terminal";
+        scope: "turn" | "owned";
+        operator?: true;
+    };
+    inputHash: string;
+}
+/** One strict, capability-free identity shared by dispatch, durable admission, and delivery observation. */
+export declare function terminalAbortIdentity(input: unknown, operatorAuthorized: boolean): TerminalAbortIdentity | undefined;
 /** 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

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

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

@@ -10,6 +10,8 @@ export type AbortScope = "turn" | "owned";
 export interface TerminalAbortInput {
     mode: "terminal";
     scope?: AbortScope;
+    /** Broker-authorized local override; public SDK callers cannot grant this authority. */
+    operator?: boolean;
 }
 export type ControlInput = Record<string, unknown>;
 /**

package/dist/types/sdk/host/control/runtime-gate.d.ts

@@ -1,15 +1,26 @@
 /**
- * Private field carried only on the Broker's endpoint close request.
+ * Private fields carried only on Broker-authorized endpoint controls.
  *
- * The value is the lifecycle effect marker bound to the serving process. It is
- * never published in endpoint discovery or lifecycle service results; callers
- * that do not hold the Broker's indexed lifecycle record cannot satisfy this
- * gate.
+ * Their values are lifecycle effect markers bound to the serving process. They
+ * are never published in endpoint discovery or lifecycle service results;
+ * callers that do not hold the Broker's indexed lifecycle record cannot satisfy
+ * either gate.
  */
 export declare const BROKER_RUNTIME_CLOSE_CAPABILITY_FIELD = "__gjcBrokerCloseCapability";
+/** Private field carried only on the Broker-authorized terminal-abort request. */
+export declare const BROKER_RUNTIME_ABORT_CAPABILITY_FIELD = "__gjcBrokerAbortCapability";
 export declare function brokerRuntimeCloseCapability(input: unknown): string | undefined;
-/** Remove the private close capability before a request is exposed to diagnostics. */
-export declare function redactBrokerRuntimeCloseCapability(frame: Record<string, unknown>): Record<string, unknown>;
+export declare function brokerRuntimeAbortCapability(input: unknown): string | undefined;
+/** Remove private Broker capabilities before a request is exposed to diagnostics. */
+export declare function redactBrokerRuntimeCapabilities(frame: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Strips caller content from a request frame before it reaches a diagnostic
+ * observer. Known protocol operation names and finite enum values survive so
+ * instrumentation stays useful; caller-chosen ids and all other values are
+ * redacted, including nested objects, so a field this module has never heard
+ * of cannot leak.
+ */
+export declare function redactObservedRequestContent(frame: Record<string, unknown>): Record<string, unknown>;
 /**
  * Runtime-local authority check for the Broker-only graceful close executor.
  *
@@ -17,3 +28,6 @@ export declare function redactBrokerRuntimeCloseCapability(frame: Record<string,
  * environment. Generic SDK requests never receive that private marker.
  */
 export declare function hasBrokerRuntimeCloseCapability(input: unknown): boolean;
+/** Test-only override for the abort gate; production authority remains process-local. */
+export declare function setBrokerRuntimeAbortCapabilityForTest(capability: string | undefined): void;
+export declare function hasBrokerRuntimeAbortCapability(input: unknown): boolean;

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

@@ -64,6 +64,16 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
      * that fails is never read as authorization.
      */
     activationGate?: SessionActivationGate;
+    /** Private one-shot master-capability verification; never durable or public SDK surface. */
+    masterCapabilityVerify?: (frame: {
+        nonce: unknown;
+        attestationEpoch: unknown;
+        capability: unknown;
+    }) => {
+        ok: boolean;
+        nonce: string;
+        attestationEpoch: string;
+    };
 }
 /** Shared by the replay filter and transport live broadcasts: a connection
  *  must see the same capability-gated event kinds on both legs, or live and

package/dist/types/sdk/host/session-runtime.d.ts

@@ -1,10 +1,27 @@
 import { type Settings } from "../../config/settings";
 import type { ExtensionAPI, ExtensionContext } from "../../extensibility/extensions";
+import { type MasterRoleAttestationV2, SessionIndex, type SessionLocatorV2 } from "../broker/session-index";
 import { type TurnResultContent } from "../turn-result";
 import { SessionSdkHost, type SessionSdkHostOptions } from "./host";
 import { type SessionSurface } from "./query";
 import { type SdkCapabilities, type SdkSurfacePolicy } from "./surface-policy";
 import type { BrokerIndexWriter, SdkFrame } from "./types";
+export type MasterCapabilityReplayState = Map<string, number>;
+export declare function verifyMasterCapabilityFrame(input: {
+    frame: {
+        nonce: unknown;
+        attestationEpoch: unknown;
+        capability: unknown;
+    };
+    expectedCapability: string | undefined;
+    expectedEpoch: string | undefined;
+    replay: MasterCapabilityReplayState;
+    now?: number;
+}): {
+    ok: boolean;
+    nonce: string;
+    attestationEpoch: string;
+};
 /** Transport-neutral endpoint contract consumed by the SDK session runtime. */
 export interface SessionSdkTransport {
     readonly sessionId: string;
@@ -27,6 +44,8 @@ export interface SessionSdkRuntimeOptions extends Omit<SessionSdkHostOptions, "s
     settings?: Settings;
     /** Mutable shadow of patched config values merged into query readback. */
     configOverrides?: Map<string, unknown>;
+    /** Stable master lineage identity retained across session switches/branches. */
+    masterOwnerSessionId?: string;
 }
 export interface SdkOnlyInvocationRecord extends InvocationCorrelation {
     kind: InvocationKind | "terminal" | "steer";
@@ -161,6 +180,8 @@ export interface CreateSdkSessionRuntimeOptions {
     agentDir: string;
     /** Lifecycle-owned sessions require broker publication before they become usable. */
     brokerRegistrationRequired?: boolean;
+    /** Trusted broker-issued lifecycle marker bound to lifecycle host index events. */
+    lifecycleRequestId?: string;
     createTransport(input: {
         sessionId: string;
         stateRoot: string;
@@ -172,6 +193,12 @@ export interface CreateSdkSessionRuntimeOptions {
     onSdkRequest?: SessionSdkHostOptions["onRequest"];
     /** Mutable shadow of patched config values merged into query readback. */
     configOverrides?: Map<string, unknown>;
+    /** In-memory master capability for private broker verification only. */
+    masterCapability?: string;
+    /** Opaque direct-role epoch this effective host may adopt. */
+    masterAttestationEpoch?: string;
+    /** Stable master lineage identity retained across session switches/branches. */
+    masterOwnerSessionId?: string;
     /** Private session-owned terminal-abort capabilities; never exposed on ExtensionContext. */
     terminalAbortSeams?: SdkOnlyTerminalAbortSeams;
     /** Callback when a frame is admitted to the runtime (test harness). */
@@ -293,6 +320,31 @@ export declare function createSdkSurfaceFactory(options: SdkSurfaceFactoryOption
 }): SdkSurfaceFactory;
 /** Register the default-session notification command without loading notification adapters. */
 export declare function registerSdkOnlyNotificationCommand(api: ExtensionAPI): void;
+export declare function masterAttestationForEffectiveHost(input: {
+    masterCapability: string | undefined;
+    attestationEpoch: string | undefined;
+    ownerSessionId?: string;
+    sessionId: string;
+    pid: number;
+    processIncarnation: string | undefined;
+    direct: MasterRoleAttestationV2 | undefined;
+}): MasterRoleAttestationV2 | undefined;
+/**
+ * Establish direct master authority for the session currently hosted by this
+ * process. Session identity transitions retain the master capability and epoch
+ * but require a new direct attestation before their effective endpoint can
+ * adopt that authority.
+ */
+export declare function reattestMasterSessionIdentity(input: {
+    index: SessionIndex;
+    locator: SessionLocatorV2;
+    masterCapability: string | undefined;
+    attestationEpoch: string | undefined;
+    ownerSessionId?: string;
+    sessionId: string;
+    pid: number;
+    processIncarnation: string | undefined;
+}): Promise<MasterRoleAttestationV2 | undefined>;
 /** Install a complete SDK host for a session when notifications are inactive. */
 export declare function createSdkSessionRuntimeExtension(api: ExtensionAPI, options: CreateSdkSessionRuntimeOptions): void;
 export {};