@gajae-code/coding-agent 0.15.6 → 0.16.1

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/startup-budget.d.ts

@@ -2,8 +2,16 @@
 export declare const DEFAULT_READINESS_TIMEOUT_MS = 10000;
 export declare const MIN_READINESS_TIMEOUT_MS = 4000;
 export declare const MAX_READINESS_TIMEOUT_MS = 60000;
+/** Bounded git worktree add/reuse window; independent of child semantic readiness. */
+export declare const DEFAULT_WORKTREE_PREPARATION_TIMEOUT_MS = 30000;
+export declare const MIN_PREPARATION_TIMEOUT_MS = 1000;
+export declare const MAX_PREPARATION_TIMEOUT_MS = 120000;
+/** Bounded workspace install window; independent of child semantic readiness. */
+export declare const DEFAULT_DEPENDENCY_PREPARATION_TIMEOUT_MS = 30000;
 export declare function isValidReadinessTimeoutMs(value: unknown): value is number;
+export declare function isValidPreparationTimeoutMs(value: unknown): value is number;
 export declare const READINESS_TIMEOUT_INVALID_MESSAGE = "readinessTimeoutMs must be an integer between 4000 and 60000.";
+export declare const PREPARATION_TIMEOUT_INVALID_MESSAGE = "worktreePreparationTimeoutMs and dependencyPreparationTimeoutMs must be integers between 1000 and 120000.";
 /**
  * Sleep until the duration elapses or the caller cancels the wait. Queue admission
  * uses this so a granted or refused waiter does not retain its cutoff timer for the
@@ -40,5 +48,49 @@ export declare function lifecycleStartupBudgetMs(requestedReadinessTimeoutMs: nu
  * rather than left unextended: the broker queues it for exactly as long as one that
  * asked, so the common path would otherwise fail client-side while the broker runs
  * the startup to a durably persisted terminal result.
+ *
+ * Worktree launches add independent preparation budgets so git add / install cannot
+ * cut the caller while the broker still owns the request. One-arg
+ * {@link lifecycleStartupBudgetMs} stays queue+readiness for no-worktree callers.
  */
 export declare function lifecycleRequestTimeoutMs(operation: string, input: Record<string, unknown>): number | undefined;
+/**
+ * True when this request will run named or detached worktree preparation.
+ * Coordinator nests the selector at `target.worktree`; Direct/lifecycle service
+ * put `worktree` on the mutation target itself; broker serialization also
+ * accepts `{ worktree: { name } }` without `enabled`.
+ */
+export declare function lifecycleRequestHasWorktree(input: Record<string, unknown>): boolean;
+/**
+ * Sum of worktree and dependency preparation budgets, or 0 when the request
+ * has no worktree. Returns `undefined` when an explicit prep field is present
+ * but invalid so callers fail closed instead of silently dropping prep time.
+ */
+export declare function preparationBudgetMs(input: Record<string, unknown>): number | undefined;
+export interface LifecycleOuterDeadlines {
+    admittedAt: number;
+    worktreePrepTimeoutMs: number;
+    dependencyPrepTimeoutMs: number;
+    requestedReadinessTimeoutMs: number;
+    worktreePreparationDeadlineAt: number;
+    lifecycleCleanupDeadlineAt: number;
+}
+/**
+ * Whole-request outer deadlines for a worktree launch. Child semantic readiness
+ * is still derived later at prepSucceededAt. Dependency start is sequential:
+ * callers clip remaining dep budget against `lifecycleCleanupDeadlineAt`
+ * after worktreeDoneAt.
+ */
+export declare function deriveLifecycleOuterDeadlines(input: {
+    admittedAt: number;
+    worktreePrepTimeoutMs: number;
+    dependencyPrepTimeoutMs: number;
+    requestedReadinessTimeoutMs: number;
+}): LifecycleOuterDeadlines;
+export declare function readPreparationTimeouts(input: Record<string, unknown>): {
+    ok: true;
+    worktreePrepTimeoutMs: number;
+    dependencyPrepTimeoutMs: number;
+} | {
+    ok: false;
+};

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

@@ -1,5 +1,16 @@
 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;
+/**
+ * Thrown when a persisted SDK state file carries a version this build does not
+ * support. `assertSupportedStateVersion` fences only generic SDK state (broker
+ * discovery, lifecycle-ledger rows, guide cache meta) whose current format is
+ * exactly `SDK_STATE_VERSION`. Session-index files carry their own versions
+ * (see `assertSupportedSessionIndexEventVersion` and
+ * `assertSupportedSnapshotVersion`) and MUST NOT be validated with the generic
+ * guard — a supported v4 index row would crash with "maximum supported version
+ * is 1" (#5181).
+ */
 export declare class UnsupportedStateVersionError extends Error {
     readonly file: string;
     readonly version: number;
@@ -7,5 +18,14 @@ export declare class UnsupportedStateVersionError extends Error {
     readonly code = "unsupported_state_version";
     constructor(file: string, version: number, maximumSupportedVersion?: number);
 }
+/**
+ * Generic SDK-state fence: rejects any version above `SDK_STATE_VERSION`.
+ * ONLY for generic state whose current format is exactly `SDK_STATE_VERSION`
+ * (broker discovery `broker.json`, lifecycle-ledger rows, guide cache meta).
+ * Never validate session-index rows or snapshots with this guard — they have
+ * dedicated version fences and currently accept v4 (#5181).
+ */
 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/discord-daemon.d.ts

@@ -47,7 +47,7 @@ export declare class DiscordNotificationDaemon {
     /** Posts a safe command outcome to the active mapped conversation. */
     postCommandResult(sessionId: string, content: string): Promise<boolean>;
     close(sessionId: string, endpointGeneration?: number): Promise<void>;
-    recoverCleanup(sessionId: string, endpointGeneration: number): Promise<void>;
+    recoverCleanup(sessionId: string, endpointGeneration: number, authorityId?: string): Promise<boolean>;
     retireAttachment(sessionId: string, endpointGeneration: number): Promise<void>;
     archive(sessionId: string): Promise<void>;
     resume(sessionId: string, endpointGeneration: number, attachmentAuthorityId?: string): Promise<DiscordConversation | undefined>;

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

@@ -116,7 +116,7 @@ export interface SessionResumeResponseFrame {
     sessionId: string;
     mode: ResumeMode;
 }
-export type LifecycleErrorReason = "unauthorized" | "rate_limited" | "duplicate_conflict" | "invalid_target" | "ambiguous_target" | "spawn_failed" | "discovery_timeout" | "readiness_timeout" | "close_refused" | "not_found" | "terminal_uncertain" | "unsupported_platform";
+export type LifecycleErrorReason = "unauthorized" | "rate_limited" | "duplicate_conflict" | "invalid_target" | "ambiguous_target" | "spawn_failed" | "discovery_timeout" | "readiness_timeout" | "worktree_preparation_timeout" | "dependency_preparation_timeout" | "close_refused" | "not_found" | "terminal_uncertain" | "unsupported_platform";
 export interface ResumeCandidate {
     sessionId: string;
     path?: string;
@@ -310,6 +310,8 @@ interface SessionRuntime {
     disposeGateTerminalController: () => void;
     disposeAckRecoveryParticipant: () => void;
     disposeGateEmitterListener: () => void;
+    /** Deregisters this session's job-fold listener (`bash_folded`). */
+    disposeFoldListener: () => void;
     /** Aborts and fences side turns while notification delivery is disabled. */
     disableEphemeralTurns: () => void;
     waitForGateResolutionQuiescence: () => Promise<void>;
@@ -599,6 +601,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/kind-aware-reconciliation.d.ts

@@ -1,5 +1,5 @@
 import type { PromptReconciliationStatus, SdkPromptTerminalOutcome, TurnPromptReconciliation } from "../prompt-status";
-import type { ReceiptState } from "../receipt-state";
+import { type ReceiptState } from "../receipt-state";
 import { type TurnResultContent, type TurnResultPage } from "../turn-result";
 import { type PromptCorrelation } from "./prompt-reconciliation";
 import type { DurableReconciliationRecord, ReconciliationKind, ReconciliationStore } from "./reconciliation-store";

package/dist/types/sdk/bus/prompt-reconciliation.d.ts

@@ -23,7 +23,7 @@
  */
 import { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure } from "../prompt-failure";
 import type { SdkPromptTerminalOutcome } from "../prompt-status";
-import type { ReceiptState } from "../receipt-state";
+import { type ReceiptState } from "../receipt-state";
 export { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure };
 export declare const PROMPT_RECONCILIATION_ACTIVE_CAPACITY = 128;
 export declare const PROMPT_RECONCILIATION_TERMINAL_CAPACITY = 256;

package/dist/types/sdk/bus/slack-conversation.d.ts

@@ -5,7 +5,7 @@ export interface SlackInboundDispatchReceipt {
     interactionId: string;
     retryKey: string;
     eventContext?: string;
-    kind: "action" | "command";
+    kind: "action" | "command" | "message";
     actionId?: string;
     /** The endpoint generation and SDK effect captured before Socket Mode ACK. */
     endpointGeneration: number;

package/dist/types/sdk/bus/slack-daemon.d.ts

@@ -69,7 +69,7 @@ export declare class SlackNotificationDaemon {
     postCommandResult(sessionId: string, content: string): Promise<boolean>;
     resolveAction(sessionId: string, actionId: string): Promise<void>;
     close(sessionId: string, marker?: string, endpointGeneration?: number): Promise<boolean>;
-    recoverCleanup(sessionId: string, endpointGeneration: number): Promise<void>;
+    recoverCleanup(sessionId: string, endpointGeneration: number, authorityId?: string): Promise<boolean>;
     retireAttachment(sessionId: string, endpointGeneration: number): Promise<void>;
     resume(sessionId: string, body: string, endpointGeneration?: number, publicationId?: string): Promise<SlackConversation>;
     findSession(sessionId: string, includeInactive: boolean): Promise<{

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 = 181;
 /**
  * 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;
@@ -39,24 +40,29 @@ export interface SdkSessionRowV1 {
     /** True when the same sessionId maps to more than one stateRoot (cross-repo duplicate). */
     ambiguous?: boolean;
 }
-export interface SdkCheckpointRecordV1 {
+export interface SdkRingPositionV1 {
     revision: number;
     generation: number;
     seq: number;
 }
+export interface SdkCheckpointRecordV1 extends SdkRingPositionV1 {
+    idle: boolean;
+}
 export interface SdkRetentionGapV1 {
     code: "retention_gap";
     missing?: {
         from: number;
         to: number;
     };
-    resync?: SdkCheckpointRecordV1;
+    resync?: SdkRingPositionV1;
 }
 /** One tail item: a retained transcript entry or a live event-ring event. */
 export interface SdkTailItemV1 {
     /** "transcript" for retained transcript entries, otherwise the event-ring kind. */
     kind: string;
     id?: string;
+    /** Durable revision at emission; (revision,generation,seq) is unique per session. generation:seq alone is revision-local. */
+    revision?: number;
     generation?: number;
     seq?: number;
     payload: unknown;
@@ -84,6 +90,7 @@ export declare function toRetentionGapV1(value: unknown): SdkRetentionGapV1 | un
 /** Projects a transcript entry or ring event into a tail item with dedupe keys. */
 export declare function toTailItemV1(value: unknown, fallback: {
     kind: string;
+    revision?: number;
     generation?: number;
     seq?: number;
 }): SdkTailItemV1;

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;
@@ -54,7 +67,8 @@ export declare function parseSessionListScope(value: string | undefined): SdkSes
 /**
  * Resolves the list selection from `--repo` (default: process cwd) under the
  * effective scope. Outside Git, `repo`/`worktree` fail typed and actionable —
- * they never broaden to `all`; `cwd` remains an exact canonical match.
+ * they never broaden to `all`; `cwd` remains an exact canonical match, and
+ * `all` ignores the selection entirely so it works outside any checkout.
  */
 export declare function resolveSessionListSelection(scope: SdkSessionListScope, repoArg: string | undefined): Promise<SdkSessionListSelection>;
 /**
@@ -69,6 +83,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;