@gajae-code/coding-agent 0.13.3 → 0.14.0

package/dist/types/sdk/bus/lifecycle-orchestrator.d.ts

@@ -1,141 +0,0 @@
-import type { LifecycleErrorReason, ResumeCandidate, SessionCreateFrame, SessionLifecycleRequest } from "./index";
-/** Durable idempotency state for a single lifecycle request. */
-export type LedgerState = "in_progress" | "success" | "failure" | "terminal_uncertain";
-/** One persisted idempotency entry, keyed by `chatId:updateId`. */
-export interface LedgerEntry {
-    requestHash: string;
-    state: LedgerState;
-    requestId: string;
-    verb: SessionLifecycleRequest["type"];
-    intendedSessionId?: string;
-    startupPromptRef?: string;
-    createdAt: number;
-    updatedAt: number;
-    targetSummary: Record<string, unknown>;
-    sessionId?: string;
-    tmuxSession?: string;
-    sessionStateFile?: string;
-    endpointUrl?: string;
-    /** Close effect outcome: whether the tmux process is confirmed gone. */
-    processGone?: boolean;
-    reason?: LifecycleErrorReason;
-    resumeMode?: ResumeEffectResult["mode"];
-}
-/** The full on-disk ledger document. */
-export interface LedgerDoc {
-    version: 1;
-    entries: Record<string, LedgerEntry>;
-}
-/** Persistence boundary: atomic + fsynced read/write of the ledger document. */
-export interface LedgerStore {
-    read(): Promise<LedgerDoc>;
-    /** Write atomically (temp + fsync + rename) under a per-ledger lock. */
-    write(doc: LedgerDoc): Promise<void>;
-}
-/** Redacted audit-v2 event. */
-export interface AuditEvent {
-    schemaVersion: 2;
-    ts: string;
-    event: "accepted" | "rejected" | "duplicate_reack" | "rate_limited" | "spawn_started" | "recovered_in_progress" | "success" | "failure" | "terminal_uncertain";
-    chatRef: string;
-    updateId: number;
-    requestRef: string;
-    verb: SessionLifecycleRequest["type"];
-    targetKind: CanonicalTargetKind;
-    targetRef: string;
-    reason?: LifecycleErrorReason;
-}
-export interface CreateEffectResult {
-    sessionId: string;
-    tmuxSession: string;
-    sessionStateFile?: string;
-    endpointUrl: string;
-    topicThreadId: string;
-}
-export interface ResumeEffectResult extends CreateEffectResult {
-    mode: "reattached" | "cold_restarted";
-}
-/** Injected effects + policy. Pure orchestration calls into these. */
-export interface OrchestratorDeps {
-    /** The single paired chat id. Anything else is rejected before parsing. */
-    pairedChatId: string;
-    /** In-memory, derived 32-byte audit-v2 HMAC key. */
-    auditRedactionKey: Uint8Array;
-    now: () => number;
-    store: LedgerStore;
-    audit: (event: AuditEvent) => Promise<void> | void;
-    /** Resolves the returned tmux provider once per request for psmux preflight. */
-    isPsmuxProvider: () => boolean;
-    /** Per-chat create rate limiter: returns true when allowed. */
-    allowCreate: (chatId: string, nowMs: number) => boolean;
-    /** Persist the once-consumed 0600 startup-prompt file after durably recording its ref. */
-    writeStartupPrompt: (requestId: string, prompt: string | undefined, persistRef: (ref: string) => Promise<void>) => Promise<string | undefined>;
-    /** Spawn a session for a create/cold-restart. */
-    spawnCreate: (frame: SessionCreateFrame, ids: {
-        lifecycleRequestId: string;
-        intendedSessionId: string;
-        startupPromptRef?: string;
-    }) => Promise<CreateEffectResult>;
-    closeSession: (target: {
-        sessionId: string;
-        tmuxSession?: string;
-        sessionStateFile?: string;
-    }) => Promise<{
-        processGone: boolean;
-    }>;
-    resumeSession: (target: {
-        sessionIdOrPrefix: string;
-        path?: string;
-    }) => Promise<ResumeEffectResult | {
-        ambiguous: ResumeCandidate[];
-    } | {
-        notFound: true;
-    }>;
-}
-export type CanonicalTargetKind = "existing_path" | "worktree" | "plain_dir" | "session_close" | "session_resume";
-export declare function canonicalTarget(frame: SessionLifecycleRequest): string;
-export declare function canonicalRequest(frame: SessionLifecycleRequest): string;
-export declare function requestHash(frame: SessionLifecycleRequest): string;
-export declare function auditRedactionRef(key: Uint8Array, domain: string, value: string): string;
-export declare function summarizeTarget(frame: SessionLifecycleRequest): Record<string, unknown>;
-export declare function ledgerKey(chatId: string, updateId: number): string;
-/** How a freshly-arrived request relates to the durable ledger. */
-export type DuplicateClass = {
-    kind: "new";
-} | {
-    kind: "reack_success";
-    entry: LedgerEntry;
-} | {
-    kind: "reack_failure";
-    entry: LedgerEntry;
-} | {
-    kind: "in_progress";
-    entry: LedgerEntry;
-} | {
-    kind: "terminal_uncertain";
-    entry: LedgerEntry;
-} | {
-    kind: "conflict";
-    entry: LedgerEntry;
-};
-/** Classify a request against an existing ledger entry (pure). */
-export declare function classifyDuplicate(existing: LedgerEntry | undefined, hash: string): DuplicateClass;
-/** The structured outcome the daemon translates into a wire response frame. */
-export type LifecycleOutcome = {
-    status: "ok";
-    entry: LedgerEntry;
-    mode?: "reattached" | "cold_restarted";
-} | {
-    status: "error";
-    reason: LifecycleErrorReason;
-    message: string;
-    candidates?: ResumeCandidate[];
-} | {
-    status: "pending";
-    entry: LedgerEntry;
-};
-/**
- * Handle one authenticated lifecycle request. Enforces paired-chat gating,
- * idempotency, and rate limiting BEFORE any side effect, then dispatches.
- */
-export declare function handleLifecycleRequest(frame: SessionLifecycleRequest, deps: OrchestratorDeps): Promise<LifecycleOutcome>;

package/dist/types/sdk/bus/telegram-cli.d.ts

@@ -1,31 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Reference CLI for the Gajae-Code SDK Telegram client.
- *
- * Bridges a running GJC session's notification endpoint to a Telegram bot so you
- * can answer asks / see idle pings from your phone — no RPC mode required. This
- * is an EXAMPLE/template (the SDK contract is in `docs/sdk.md`);
- * Discord/Slack clients are written the same way.
- *
- * Usage:
- *   bun run packages/coding-agent/src/sdk/bus/telegram-cli.ts \
- *     --bot-token <token> [--chat-id <id>] [--endpoint-file <path> | --session-id <id>] [--repo <dir>]
- *
- * Env fallbacks: GJC_TG_BOT_TOKEN, GJC_TG_CHAT_ID.
- * If --chat-id is omitted it is auto-resolved from getUpdates (message the bot once).
- * If neither --endpoint-file nor --session-id is given, the newest endpoint file
- * under <repo>/.gjc/state/sdk/ is used.
- */
-import { type TelegramNotificationSound } from "./telegram-reference";
-interface CliArgs {
-    botToken?: string;
-    chatId?: string;
-    endpointFile?: string;
-    sessionId?: string;
-    repo: string;
-    apiBase?: string;
-    sound: TelegramNotificationSound;
-    force: boolean;
-}
-export declare function parseArgs(argv: string[]): CliArgs;
-export {};

package/dist/types/sdk/elevation/allowlist.d.ts

@@ -1,20 +0,0 @@
-/**
- * Exact elevation-gated allowlist, fully qualified and enumerative.
- *
- * The elevation allowlist is the exact set of registry operations below (the
- * raw destructive lifecycle and workflow-approval operations). It is declared
- * ONCE here as a `Set<string>` of `"kind:sdkId"` keys and mechanically pinned
- * against `operation-registry.ts` by the allowlist unit test: every key must
- * resolve via `findOperation(kind, sdkId)` and no elevatable operation may be
- * silently missing. Any operation NOT in this set is rejected at issue with
- * `elevation_not_allowlisted` before any ledger reservation. There is no
- * generalized policy engine: this is the deterministic predicate.
- */
-export declare const ELEVATION_ALLOWLIST_KEYS: readonly ["global:session.close", "global:session.delete", "control:session.delete", "control:session.close", "control:context.clear", "control:session.cwd.move", "control:compaction.run", "control:bash.execute", "control:bash.background", "control:queue.message.remove", "control:queue.message.update", "control:retry.abort", "control:retry.now", "control:bash.abort", "control:retry.auto.set", "control:compaction.auto.set", "control:extension.set_enabled", "control:queue.interrupt_mode.set", "control:queue.follow_up_mode.set", "control:queue.steering_mode.set", "control:tools.active.set", "control:permission_mode.set", "control:service_tier.set", "control:workflow.gate_answer", "control:workflow.plan_approve"];
-/**
- * Whether `(kind, sdkId)` is the fully qualified identity of an allowlisted
- * elevation-gated operation. The pair is validated against the operation
- * registry before any elevation is admitted, so a key can never name an
- * operation that does not exist.
- */
-export declare function isElevationAllowlisted(kind: unknown, sdkId: unknown): boolean;

package/dist/types/sdk/elevation/audit.d.ts

@@ -1,93 +0,0 @@
-import { SDK_STATE_VERSION } from "../broker/state-version";
-import { classifyProcessIncarnationLiveness } from "./owner";
-/**
- * Durable elevation audit trail.
- *
- * Append-only JSONL under the same elevation-local lock as the grant ledger,
- * mode 0600. Every state transition of a grant — issue, operator answer,
- * expiry, misuse, duplicate answer, claim, and dispatch outcome — is
- * recorded with the exact identity evidence the transition consumed, so an
- * auditor can reproduce why a grant reached its terminal state without
- * trusting in-memory state.
- *
- * The audit stream is an evidence trail, never an authority: audit rows are
- * append-only, are never re-read to drive decisions, and a corrupted row is
- * quarantined (like ledger rows) instead of failing the ledger.
- */
-export type ElevationAuditEvent = {
-    kind: "issued";
-} | {
-    kind: "answered";
-    outcome: "granted" | "denied" | "expired" | "misused" | "target_unavailable" | "duplicate_answer";
-} | {
-    kind: "expired";
-} | {
-    kind: "misused";
-} | {
-    kind: "duplicate_answer";
-} | {
-    kind: "claimed";
-    claim: {
-        ownerId: string;
-        epoch: number;
-        pid: number;
-        incarnation: string;
-    };
-} | {
-    kind: "dispatched";
-    dispatch: {
-        ownerId: string;
-        epoch: number;
-        dispatchedAt: number;
-    };
-    outcome: {
-        status: "ok" | "failed";
-        code?: string;
-        message?: string;
-        dispatchedAt: number;
-    };
-} | {
-    kind: "consumed";
-    message: string;
-} | {
-    kind: "unavailable";
-    reason: string;
-};
-export interface ElevationAuditEntry {
-    version: typeof SDK_STATE_VERSION;
-    ts: number;
-    elevationRequestId: string;
-    issueIndex: number;
-    event: ElevationAuditEvent;
-}
-export type ElevationAuditEventName = ElevationAuditEvent["kind"];
-export declare function isElevationAuditEntry(value: unknown): value is ElevationAuditEntry;
-export interface ElevationAuditOptions {
-    /** Injectable clock. */
-    now?: () => number;
-    /**
-     * Injectable tri-state process-incarnation liveness classifier, defaulting
-     * to `classifyProcessIncarnationLiveness`. The audit trail records the
-     * liveness verdict behind `consumed`/`unavailable` settlements so the
-     * crash-truth settlement is reproducible; the verdict never drives the
-     * settlement itself (that lives in the ledger).
-     */
-    classifyLiveness?: typeof classifyProcessIncarnationLiveness;
-}
-export declare class ElevationAudit {
-    #private;
-    constructor(agentDir: string, options?: ElevationAuditOptions);
-    get warnings(): readonly string[];
-    /**
-     * Appends one audit row for an elevation grant transition. Callers MUST
-     * hold the same elevation-local lock that guards the grant ledger; the
-     * audit row and the grant row therefore commit together.
-     */
-    append(entry: Omit<ElevationAuditEntry, "version">): Promise<void>;
-    /**
-     * Opens the audit stream: creates the 0600 directory/file if absent and
-     * quarantines any corrupt tail so subsequent appends are always readable.
-     * Called under the same lock as `ElevationLedger.open()`.
-     */
-    open(): Promise<this>;
-}

package/dist/types/sdk/elevation/capability.d.ts

@@ -1,3 +0,0 @@
-export declare function signElevationCapability(authorityToken: string, requestId: string, sdkId: string, input: Record<string, unknown>): string;
-export declare function verifyElevationCapability(authorityToken: string, capability: string, sdkId: string, input: Record<string, unknown>): boolean;
-export declare function elevationAuthorityPath(stateRoot: string, sessionId: string): string;

package/dist/types/sdk/elevation/digest.d.ts

@@ -1,72 +0,0 @@
-/**
- * Fully qualified elevation request digest.
- *
- * An elevation grant binds the exact operation the operator approved. The
- * digest covers the complete `{kind, sdkId, input}` triple so substituting a
- * different operation or different input bytes changes the digest and the
- * gate presentation fails closed (`misused`). The top-level
- * `elevationRequestId` correlation field is deliberately excluded: it is the
- * durable correlation ID assigned to a request, not part of the approved
- * content, and the same content re-issued under a new ID must produce the
- * same digest.
- *
- * Only allowlisted operations can be elevated; anything else is refused so a
- * caller cannot mint a grant for an operation outside the elevation policy.
- */
-export declare const ELEVATION_OPERATION_KINDS: readonly ["control", "query", "global"];
-export type ElevationOperationKind = (typeof ELEVATION_OPERATION_KINDS)[number];
-export interface ElevationOperation {
-    kind: ElevationOperationKind;
-    sdkId: string;
-}
-/**
- * Operations that require an elevation grant. Default SDK scope
- * (list/query/send/tail) stays grant-free; destructive lifecycle operations
- * and workflow approval operations are elevatable and therefore gated.
- */
-export declare const ELEVATION_ALLOWLIST: readonly {
-    kind: ElevationOperationKind;
-    sdkId: string;
-}[];
-export declare function isElevatableOperation(kind: unknown, sdkId: unknown): boolean;
-/**
- * Whether the `(kind, sdkId)` pair names a registry operation that the
- * elevation allowlist recognizes. Used by the ledger row validator so a
- * persisted row can never bind an operation outside the allowlist.
- */
-export declare function isKnownElevationOperation(kind: unknown, sdkId: unknown): boolean;
-/**
- * Canonical JSON encoding for elevation digest leaves.
- *
- * Intentionally byte-compatible with the broker's identity canonicalization
- * (`canonicalJson` in `sdk/broker/broker.ts`): object keys sorted, compact
- * separators, `undefined` fields preserved verbatim, arrays joined without
- * separators. The broker computes the request digest at issue time and the
- * ledger recomputes/compares the same encoding, so digest verification is
- * stable across issue, gate presentation, and answer.
- */
-export declare function canonicalElevationJson(value: unknown): string;
-export type ElevationDigestResult = {
-    ok: true;
-    digest: string;
-} | {
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-    };
-};
-/**
- * Computes the fully qualified digest for an elevation request.
- *
- * `input` is digested exactly as supplied except that a top-level
- * `elevationRequestId` field is removed first (it is the correlation ID, not
- * approved content). Operations outside `ELEVATION_ALLOWLIST` are refused
- * with `elevation_not_required` so the broker never mints a grant for an
- * operation that does not need one.
- */
-export declare function elevationRequestDigest(request: {
-    kind: unknown;
-    sdkId: unknown;
-    input: unknown;
-}): ElevationDigestResult;

package/dist/types/sdk/elevation/dispatch-receipt.d.ts

@@ -1,85 +0,0 @@
-export declare const ELEVATION_RECEIPT_VERSION = 1;
-/**
- * Identity of the broker tenure that claims a grant and dispatches it.
- *
- * `ownerId` is the broker instance owner id and `epoch` increments per broker
- * start, so a restart (even of the same object) yields a new tenure. `pid` and
- * `incarnation` are retained for truthful tri-state liveness replay.
- */
-export interface ElevationClaimIdentity {
-    ownerId: string;
-    epoch: number;
-    pid: number;
-    incarnation: string;
-}
-export type ElevationReceiptState = "claimed" | "dispatched" | "uncertain";
-/**
- * Durable dispatch outcome. `unknown` is the crash truth: the grant was
- * consumed by a claim but the dispatch outcome is not knowable, so retry
- * requires a new grant.
- */
-export type ElevationDispatchOutcome = {
-    status: "ok";
-    dispatchedAt: number;
-} | {
-    status: "failed";
-    code: string;
-    message: string;
-    dispatchedAt: number;
-} | {
-    status: "unknown";
-    message: string;
-    dispatchedAt: number;
-};
-/**
- * Owner/epoch-bound dispatch receipt.
- *
- * State machine: `claimed` (grant spent, dispatch in flight, bound to the
- * claiming broker tenure) -> `dispatched` (terminal, outcome recorded) or
- * `uncertain` (terminal truth: the claim's outcome is unknowable after its
- * broker tenure died). Replay never fabricates an outcome: a receipt left in
- * `claimed` by a dead tenure is truthfully terminalized to `uncertain`.
- */
-export interface ElevationDispatchReceipt {
-    version: typeof ELEVATION_RECEIPT_VERSION;
-    elevationRequestId: string;
-    issueIndex: number;
-    state: ElevationReceiptState;
-    claim: ElevationClaimIdentity & {
-        claimedAt: number;
-    };
-    dispatch?: {
-        ownerId: string;
-        epoch: number;
-        dispatchedAt: number;
-    };
-    outcome?: ElevationDispatchOutcome;
-    ts: number;
-}
-export declare function isElevationRequestId(value: unknown): value is string;
-export declare function isElevationClaimIdentity(value: unknown): value is ElevationClaimIdentity;
-export declare function isElevationDispatchOutcome(value: unknown): value is ElevationDispatchOutcome;
-export declare function isElevationDispatchReceipt(value: unknown): value is ElevationDispatchReceipt;
-export declare function claimReceipt(requestId: string, issueIndex: number, claim: ElevationClaimIdentity, claimedAt: number): ElevationDispatchReceipt;
-export declare function dispatchReceipt(receipt: ElevationDispatchReceipt, dispatch: {
-    ownerId: string;
-    epoch: number;
-    dispatchedAt: number;
-}, outcome: ElevationDispatchOutcome): ElevationDispatchReceipt;
-export declare function uncertainReceipt(receipt: ElevationDispatchReceipt, at: number): ElevationDispatchReceipt;
-export declare function receiptClaimMatches(receipt: ElevationDispatchReceipt, identity: ElevationClaimIdentity): boolean;
-/**
- * Who may answer an elevation gate.
- *
- * Internal operator-only: the answer boundary is the broker's internal
- * operator attestation (`local_operator`), reached only through broker-owned
- * surfaces. There is no public `elevation.answer` operation and no
- * requester-correlation check: the answerer is structurally an operator
- * attestation, so requester self-approval is impossible by construction.
- */
-export type ElevationAnswerAuthority = {
-    source: "local_operator";
-    attestedBy: string;
-};
-/** Structural guard for the internal operator attestation. */
-export declare function isElevationAnswerAuthority(value: unknown): value is ElevationAnswerAuthority;

package/dist/types/sdk/elevation/grant-ledger.d.ts

@@ -1,163 +0,0 @@
-import { SDK_STATE_VERSION } from "../broker/state-version";
-import { type ElevationOperation } from "./digest";
-import { type ElevationAnswerAuthority, type ElevationClaimIdentity, type ElevationDispatchOutcome, type ElevationDispatchReceipt } from "./dispatch-receipt";
-import { type BrokerOwnerPrincipal, classifyProcessIncarnationLiveness } from "./owner";
-/**
- * Broker-owned elevation grant ledger.
- *
- * Durable state machine (per elevation request):
- * `requested -> granted -> claimed -> dispatched(outcome)`; terminal
- * `denied`/`expired`/`misused`/`target_unavailable`; crash truth
- * `consumed` (claimed but outcome unknown). Grants are single-use: the claim
- * CAS consumes the grant before dispatch, and a crash between consume and
- * dispatch is replayed truthfully as `consumed` with outcome `unknown`
- * (retry requires a new grant — fail closed).
- *
- * All mutations and reads serialize on one elevation-local
- * `withFileLock` transaction covering grants (`grants.jsonl`), dispatch
- * receipts (`receipts.jsonl`), the issue index (`index.json`), and the
- * audit trail (`audit.jsonl`), so a claim, its receipt, and the issue
- * sequence commit together.
- *
- * The answer boundary is internal operator-only: there is no public
- * `elevation.answer` operation; answers are admitted only from the internal
- * operator attestation, so requester self-approval is impossible by
- * construction.
- */
-export type ElevationGrantState = "requested" | "granted" | "claimed" | "dispatched" | "consumed" | "denied" | "expired" | "misused" | "target_unavailable";
-export interface ElevationSessionIdentity {
-    sessionId: string;
-    /** Exact endpoint state root bound at issue time; never the repo root. */
-    endpointStateRoot: string;
-    endpointGeneration: number;
-    endpointIncarnation: string;
-}
-/** Audit-only requester binding; never an identity claim. */
-export interface ElevationRequester {
-    source: "broker_connection";
-    connectionId: string;
-}
-export interface ElevationGrantRecord {
-    version: typeof SDK_STATE_VERSION;
-    /** Durable correlation ID; UUID, path-safe. */
-    elevationRequestId: string;
-    /** Monotonic path-safe issue sequence, allocated under the ledger lock. */
-    issueIndex: number;
-    state: ElevationGrantState;
-    operation: ElevationOperation;
-    requestDigest: string;
-    sessionIdentity: ElevationSessionIdentity;
-    principal: BrokerOwnerPrincipal;
-    requester: ElevationRequester;
-    requestedAt: number;
-    expiresAt: number;
-    outcome?: ElevationDispatchOutcome;
-    ts: number;
-}
-export type ElevationErrorCode = "not_found" | "invalid_input" | "idempotency_conflict" | "grant_spent" | "elevation_claim_in_progress" | "elevation_required" | "elevation_unavailable" | "elevation_not_required" | "endpoint_stale" | "target_unavailable" | "expired" | "misused" | "duplicate_answer" | "terminal_uncertain" | (string & {});
-export type ElevationResult<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    error: {
-        code: ElevationErrorCode;
-        message: string;
-    };
-};
-export interface ElevationIssueParams {
-    /** Optional caller-supplied correlation ID for idempotent retry; the broker generates a UUID otherwise. */
-    elevationRequestId?: string;
-    operation: ElevationOperation;
-    input: Record<string, unknown>;
-    sessionIdentity: ElevationSessionIdentity;
-    principal: BrokerOwnerPrincipal;
-    requester: ElevationRequester;
-    expiresInMs?: number;
-}
-export interface ElevationIssueValue {
-    replay: boolean;
-    elevationRequestId: string;
-    issueIndex: number;
-    requestDigest: string;
-    state: ElevationGrantState;
-    requestedAt: number;
-    expiresAt: number;
-    grant: ElevationGrantRecord;
-}
-export interface ElevationAnswerParams {
-    elevationRequestId: string;
-    answer: "approve" | "deny";
-    /** Digest the answering surface presented from the gate payload. */
-    presentedDigest: string;
-    /** Broker-owner principal attesting the answer authority. */
-    principal: BrokerOwnerPrincipal;
-    answerer: ElevationAnswerAuthority;
-    /** Current broker-resolved target identity; undefined means the session is unreachable. */
-    currentSessionIdentity?: ElevationSessionIdentity;
-}
-export type ElevationAnswerOutcome = "granted" | "denied" | "expired" | "misused" | "target_unavailable" | "duplicate_answer";
-export interface ElevationAnswerValue {
-    outcome: ElevationAnswerOutcome;
-    grant: ElevationGrantRecord;
-}
-export interface ElevationClaimParams {
-    elevationRequestId: string;
-    claimIdentity: ElevationClaimIdentity;
-    /** Current broker-resolved target identity; undefined means the session is unreachable. */
-    currentSessionIdentity?: ElevationSessionIdentity;
-}
-export interface ElevationClaimValue {
-    grant: ElevationGrantRecord;
-    receipt: ElevationDispatchReceipt;
-}
-export interface ElevationDispatchParams {
-    elevationRequestId: string;
-    dispatchIdentity: ElevationClaimIdentity;
-    outcome: ElevationDispatchOutcome;
-}
-export interface ElevationDispatchValue {
-    grant: ElevationGrantRecord;
-    receipt: ElevationDispatchReceipt;
-}
-export interface ElevationReadValue {
-    grant: ElevationGrantRecord;
-    receipt?: ElevationDispatchReceipt;
-}
-export interface ElevationListValue {
-    grants: ElevationReadValue[];
-}
-export interface ElevationLedgerOptions {
-    /** Defaults to the GJC_SDK_ELEVATION_ENABLED environment flag. */
-    enabled?: boolean;
-    /** Request lifetime before the grant expires. */
-    ttlMs?: number;
-    /** Injectable clock. */
-    now?: () => number;
-    /**
-     * Injectable tri-state process-incarnation liveness classifier (defaults to
-     * `classifyProcessIncarnationLiveness`). Test seam for crash-state replay:
-     * "unknown" must always fail closed as `elevation_claim_in_progress`.
-     */
-    classifyLiveness?: typeof classifyProcessIncarnationLiveness;
-}
-declare function isElevationOperation(value: unknown): value is ElevationOperation;
-declare function isElevationGrantRecord(value: unknown): value is ElevationGrantRecord;
-export declare class ElevationLedger {
-    #private;
-    constructor(agentDir: string, options?: ElevationLedgerOptions);
-    get warnings(): readonly string[];
-    open(): Promise<this>;
-    assertSupportedStateVersions(): Promise<void>;
-    issue(params: ElevationIssueParams): Promise<ElevationResult<ElevationIssueValue>>;
-    answer(params: ElevationAnswerParams): Promise<ElevationResult<ElevationAnswerValue>>;
-    claim(params: ElevationClaimParams): Promise<ElevationResult<ElevationClaimValue>>;
-    dispatch(params: ElevationDispatchParams): Promise<ElevationResult<ElevationDispatchValue>>;
-    /** Pure read without reconciliation writes; used before actions. */
-    get(elevationRequestId: string): Promise<ElevationResult<ElevationReadValue>>;
-    /** Truthful read: reconciles expiry and crash-state claims before returning. */
-    resolve(elevationRequestId: string, claimIdentity: ElevationClaimIdentity): Promise<ElevationResult<ElevationReadValue>>;
-    /** Truthful listing: reconciles every grant before returning. */
-    list(claimIdentity: ElevationClaimIdentity): Promise<ElevationResult<ElevationListValue>>;
-}
-export { isElevationGrantRecord, isElevationOperation };

package/dist/types/sdk/elevation/owner.d.ts

@@ -1,48 +0,0 @@
-/**
- * Broker-owner principal.
- *
- * The elevation authority is the broker itself under the existing loopback
- * trust model: one local OS-user/broker authority derived entirely from
- * broker-owned state, never from caller input. `agentDirUid` is the uid that
- * owns the agent directory, `brokerPid`/`brokerIncarnation` identify the
- * broker process tenure so a restarted broker cannot attest the same
- * authority.
- */
-export interface BrokerOwnerPrincipal {
-    kind: "broker_owner";
-    owner: {
-        agentDirUid: number;
-        brokerPid: number;
-        brokerIncarnation: string;
-    };
-}
-export declare function isBrokerOwnerPrincipal(value: unknown): value is BrokerOwnerPrincipal;
-export declare function sameBrokerOwnerPrincipal(left: BrokerOwnerPrincipal, right: BrokerOwnerPrincipal): boolean;
-/**
- * Reads the broker-owner principal from broker-owned state. Throws when the
- * broker cannot attest a canonical process incarnation (the broker refuses to
- * start in that case anyway), so callers treat a throw as "authority
- * unavailable".
- */
-export declare function readBrokerOwnerPrincipal(agentDir: string, brokerPid: number, brokerIncarnation: string): Promise<BrokerOwnerPrincipal>;
-export type ProcessIncarnationLiveness = "alive" | "dead" | "unknown";
-/**
- * Tri-state liveness of a process incarnation.
- *
- * - `alive`: the pid is running and its current incarnation matches the
- *   stored one, so the original process tenure is still live.
- * - `dead`: ESRCH (the pid is provably gone — independent of any persisted
- *   incarnation text), or the pid is running under a *different* canonical
- *   incarnation (PID reuse), which provably means the original process
- *   ended.
- * - `unknown`: the pid is malformed, the persisted or observed incarnation
- *   is malformed/undefined, or the current incarnation cannot be read.
- *   Unknown never implies death: elevation claims must fail closed with
- *   `elevation_claim_in_progress` instead of terminalizing state on
- *   unprovable liveness.
- *
- * ESRCH is independent positive death proof: a pid that provably does not
- * exist is dead regardless of the persisted incarnation text, so a corrupt
- * persisted incarnation can never stall recovery forever.
- */
-export declare function classifyProcessIncarnationLiveness(pid: unknown, incarnation: unknown): ProcessIncarnationLiveness;

package/dist/types/sdk/host/import-graph.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/sdk/host/sdk-surface-parity.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-export {};

package/dist/types/sdk/host/websocket-transport.lifecycle.test.d.ts

@@ -1 +0,0 @@
-export {};