@gajae-code/coding-agent 0.12.21 → 0.13.0

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

@@ -5,14 +5,15 @@ export type ControlInput = Record<string, unknown>;
  * AgentSession and its controllers without exposing those concrete types here.
  */
 export interface ControlSurface {
+    authorizeElevationClaim?(sdkId: string, input: ControlInput, capability: string): boolean;
     prompt(text: string, images?: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
     steer(text: string): Promise<ControlValue> | ControlValue;
     followUp(text: string): Promise<ControlValue> | ControlValue;
     abort(): Promise<ControlValue> | ControlValue;
     abortAndPrompt(text: string): Promise<ControlValue> | ControlValue;
     answerAsk(id: string, answer: ControlValue): Promise<ControlValue> | ControlValue;
-    answerGate(id: string, response: ControlValue, expectedSessionId?: string, idempotencyKey?: string): Promise<ControlValue> | ControlValue;
-    approvePlan(id: string, choice: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
+    answerGate(id: string, response: ControlValue, expectedSessionId?: string, idempotencyKey?: string, elevationRequestId?: string): Promise<ControlValue> | ControlValue;
+    approvePlan(id: string, choice: ControlValue, expectedSessionId?: string, elevationRequestId?: string): Promise<ControlValue> | ControlValue;
     invokeSkill(name: string, args: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
     setPlanMode(on: boolean): Promise<ControlValue> | ControlValue;
     operateGoal(op: string, objective?: string): Promise<ControlValue> | ControlValue;

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

@@ -7,8 +7,14 @@ export interface CursorEnvelope {
     protocolMajor: 3;
     sessionId: string;
     resource: string;
+    /** Unique per-grant identity so identical envelopes never alias into one pin. */
+    nonce?: string;
     revision: string;
     highWatermark?: unknown;
+    /** TTL metadata minted by `CursorRegistry.grant`: wall-clock ms when granted. */
+    issuedAt?: number;
+    /** TTL metadata minted by `CursorRegistry.grant`: wall-clock ms when the cursor expires. */
+    expiresAt?: number;
     position: unknown;
     direction: string;
     pageShape: unknown;
@@ -54,6 +60,10 @@ export declare class CursorRegistry {
     private readonly now;
     constructor(sessionToken: string | Uint8Array, revisions: RevisionStore, now?: () => number);
     grant(connectionId: string, envelope: CursorEnvelope, resourceKind: string, resourceId: string): Promise<string>;
+    exchange(cursor: string, connectionId: string, expected: CursorQueryContext, resourceKind: string, resourceId: string): Promise<{
+        cursor: string;
+        envelope: CursorEnvelope;
+    }>;
     consume(cursor: string, connectionId: string, expected: CursorQueryContext): CursorEnvelope;
     release(cursor: string): void;
     close(): void;

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

@@ -46,6 +46,15 @@ export interface SessionSurface {
     }): unknown | Promise<unknown>;
     /** Q27 effective model-profile catalog from the live session registry. */
     getModelProfiles?(): unknown[] | Promise<unknown[]>;
+    /**
+     * Q30 atomic checkpoint capture: the live transcript entries and the
+     * event-ring watermark read in ONE synchronous call, so the snapshot
+     * revision and the subscribe position can never straddle an append.
+     */
+    getCheckpointSnapshot?(): {
+        entries: unknown[];
+        watermark: SdkCheckpointRecord;
+    };
     /** Query rows backed by the session's installed binding map. */
     installedQueries?: ReadonlySet<string>;
 }
@@ -75,6 +84,18 @@ export interface QueryResponse {
         details?: unknown;
     };
 }
+/**
+ * Host-published durable transcript checkpoint (C9). `revision` is the
+ * transcript high-watermark (entry count/offset) at checkpoint time and bounds
+ * replay to exactly `[checkpointRevision, live)`; `generation`/`seq` anchor the
+ * event-ring subscribe position carried by replay cursors.
+ */
+export interface SdkCheckpointRecord {
+    revision: number;
+    generation: number;
+    seq: number;
+}
+export declare function isCheckpointRecord(value: unknown): value is SdkCheckpointRecord;
 export declare class QueryHandlers {
     #private;
     private readonly surface;

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

@@ -57,6 +57,10 @@ export declare class SessionSdkSessionRuntime {
 }
 /** Narrow extension-facing factory for the SDK-only session path. */
 export interface CreateSdkSessionRuntimeOptions {
+    /** Authoritative broker state root for this session's endpoint lifecycle. */
+    agentDir: string;
+    /** Lifecycle-owned sessions require broker publication before they become usable. */
+    brokerRegistrationRequired?: boolean;
     createTransport(input: {
         sessionId: string;
         stateRoot: string;
@@ -119,6 +123,11 @@ export interface SdkSurfaceFactoryOptions {
         clientRef?: string;
     }) => unknown;
     hostTools?: boolean | (() => boolean);
+    /** Q30 event-ring watermark source (the live session event stream); synchronous. */
+    getEventWatermark?: () => {
+        generation: number;
+        seq: number;
+    };
 }
 /** Shared policy, capability, and query-surface factory for every SDK transport. */
 export interface SdkSurfaceFactory {

package/dist/types/sdk/mcp/server.d.ts

@@ -21,7 +21,7 @@ export interface SdkMcpServerOptions {
     connect?: (url: string, token: string) => Promise<SdkClient>;
 }
 export declare const SDK_MCP_TOOL_NAMES: readonly ["gjc_session_control", "gjc_session_query", "gjc_session_global", "gjc_session_list"];
-/** Creates the model-facing MCP adapter using only SDK discovery records and v3 WebSockets. */
+/** Creates the model-facing MCP adapter; session targeting is broker-bound (C10). */
 export declare function createSdkMcpServer(options?: SdkMcpServerOptions): {
     callTool: (name: string, args?: Arguments) => Promise<unknown>;
     handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
@@ -31,7 +31,7 @@ export declare function createSdkMcpServer(options?: SdkMcpServerOptions): {
 /**
  * Runs the SDK MCP server over stdio (newline-delimited JSON-RPC), the shipped
  * `gjc mcp-serve sdk` entrypoint. Pure SDK client: session control/query flows
- * through discovery records and v3 WebSockets only.
+ * through the broker and v3 WebSockets only.
  */
 export declare function runSdkMcpStdio(options?: SdkMcpServerOptions): Promise<void>;
 export {};

package/dist/types/sdk/prompt-status.d.ts

@@ -24,6 +24,12 @@
  * - Q26 tracks prompts accepted through the SDK control surface (which always
  *   carries a requesting connection); submissions without a delivery owner are
  *   outside the reconciliation contract and hold no reservation.
+ * - A terminal outcome settles once: the first terminal transition wins. A late
+ *   `agent_failed` (arriving on a different delivery path than the one that
+ *   claimed the terminal) may still attach its bounded, sanitized reason to an
+ *   already-terminal record that has none, surfaced as `error` on `terminal_ok`.
+ *   It never changes status, `terminalAt`, retention order, or the clientRef
+ *   index, and the first recorded reason always wins over a later frame.
  */
 export declare const PROMPT_CLIENT_REF_MAX_LENGTH = 128;
 export interface TurnPromptImageInput {
@@ -82,6 +88,11 @@ export interface TurnPromptReconciliationTerminalOk extends TurnPromptReconcilia
     /** Epoch milliseconds of the terminal transition. */
     terminalAt: number;
     outcome?: SdkPromptTerminalOutcome;
+    /** Present when a late `agent_failed` supplied the only failure reason. */
+    error?: {
+        code: string;
+        message: string;
+    };
 }
 export interface TurnPromptReconciliationFailed extends TurnPromptReconciliationIdentity {
     status: "failed";

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

@@ -57,6 +57,8 @@ export interface CreateAgentSessionOptions {
     /** Raw model pattern string (e.g. from --model CLI flag) to resolve after extensions load.
      * Used when model lookup is deferred because extension-provided models aren't registered yet. */
     modelPattern?: string;
+    /** Active profile inherited by a nested SDK/subagent session. */
+    activeModelProfile?: string;
     /** Thinking selector. Default: from settings, else unset */
     thinkingLevel?: ThinkingLevel;
     /** Runtime substitution metadata for the initial model_change session event. */
@@ -71,6 +73,8 @@ export interface CreateAgentSessionOptions {
     /** Optional provider-facing session identifier for prompt caches and sticky auth selection.
      * Keeps persisted session files isolated while reusing provider-side caches. */
     providerSessionId?: string;
+    /** Optional credential-selection session identity, distinct from provider transport/cache identity. */
+    credentialSessionId?: string;
     /** Runtime credential selector for multi-account auth pools. */
     credentialSelector?: {
         provider?: string;

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

@@ -5,6 +5,7 @@ export type ServeOptions = {
     url: string;
     token: string;
     pendingCeilingBytes: number;
+    validateDownstreamFrame?: (frame: string) => boolean;
 };
 export type ServeHandle = {
     close(): Promise<void>;

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

@@ -38,6 +38,7 @@ export type RelayOptions = {
     onTransportError: (error: TransportError) => void;
     webSocketFactory?: (url: string) => RelayWebSocket;
     signal?: AbortSignal;
+    validateDownstreamFrame?: (frame: string) => boolean;
 };
 /** Starts a dedicated raw-WebSocket relay for exactly one downstream stream. */
 export declare function startRelayPair(options: RelayOptions): Promise<RelayPair>;

package/dist/types/sdk/transport/serve-cli.d.ts

@@ -1,4 +1,23 @@
+import { SdkClient } from "../client";
 /** Resolves the pending ceiling with flag > env > default precedence; exported for tests. */
 export declare function resolveServePendingCeiling(flagValue: string | undefined, envValue: string | undefined): number;
-/** Attaches a stdio or Unix-socket relay to one live SDK session endpoint. */
+type BrokerSessionRow = {
+    sessionId: string;
+    live: boolean;
+    ambiguous: boolean;
+};
+/**
+ * Exhausts broker `session.list` cursor pagination (default page limit 100) to
+ * one full snapshot; exported for tests.
+ */
+export declare function listBrokerSessions(broker: SdkClient): Promise<BrokerSessionRow[]>;
+/** Selects the session to serve through broker `session.list` truth (C10); exported for tests. */
+export declare function selectBrokerSession(sessions: BrokerSessionRow[], explicitSessionId: string | undefined): string;
+/**
+ * Attaches a stdio or Unix-socket relay to one live SDK session endpoint.
+ * Session targeting is broker-bound (C10): `session.list` resolves the session
+ * and `session.get_endpoint` mints the exact credential — never a direct
+ * endpoint-file read. A missing or unreachable broker fails closed.
+ */
 export declare function runSdkServe(argv: string[]): Promise<void>;
+export {};

package/dist/types/session/agent-session.d.ts

@@ -105,6 +105,7 @@ import type { CheckpointState } from "../tools/checkpoint";
 import { type TodoItem, type TodoPhase } from "../tools/todo-write";
 import { type WorkspaceTree } from "../workspace-tree";
 import { type DefaultModelSelectionResult } from "./default-model-selection";
+import { type ConfiguredFallbackChain, type FallbackChainRuntimeState } from "./fallback-chain-controller";
 export { DefaultModelSelectionRecoveryError } from "./default-model-selection";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "./client-bridge";
 import { type ContributionPrepOptions, type ContributionPrepResult } from "./contribution-prep";
@@ -339,6 +340,8 @@ export interface AgentSessionConfig {
      * so that credential sticky selection is consistent with the session's streaming calls.
      */
     providerSessionId?: string;
+    /** Optional auth-selection identity, distinct from logical/canonical and provider-cache identity. */
+    credentialSessionId?: string;
     /** Optional provider-facing cache identity, distinct from logical session identity. */
     providerCacheSessionId?: string;
 }
@@ -559,6 +562,11 @@ export declare class StreamingEditFileCache {
     has(path: string): boolean;
     get totalBytes(): number;
 }
+export interface DefaultFallbackRuntimeState {
+    chain: ConfiguredFallbackChain;
+    controller: FallbackChainRuntimeState;
+    exhaustedLastTurn: boolean;
+}
 export declare class AgentSession {
     #private;
     readonly agent: Agent;
@@ -851,6 +859,8 @@ export declare class AgentSession {
     get sessionFile(): string | undefined;
     /** Current session ID */
     get sessionId(): string;
+    /** Credential selection identity; defaults to the provider-facing session identity. */
+    get credentialSessionId(): string;
     /** Current session display name, if set */
     get sessionName(): string | undefined;
     /** Scoped models for cycling (from --models flag) */
@@ -1061,18 +1071,13 @@ export declare class AgentSession {
         selector?: string;
         thinkingLevel?: ThinkingLevel;
         cause?: ModelChangeCause;
+        onMutationStarted?: () => void;
     }): Promise<void>;
     setActiveModelProfile(name: string | undefined): void;
     getActiveModelProfile(): string | undefined;
-    /**
-     * Record which runtime override keys a profile activation installed together
-     * with their pre-profile effective baseline (durable/project value or a
-     * configured `modelBindings` value). First activation for a key wins, so a
-     * profile switch never captures the previous profile's roles as the
-     * baseline. The session-scoped reset restores exactly these keys.
-     */
+    /** Record runtime override keys installed by a profile activation. */
     noteProfileInstalledOverrides(modelRoles: readonly string[], agentModelOverrides: readonly string[], preProfileModel: Model | undefined): void;
-    /** Drop the recorded profile-installed override keys (after materialization). */
+    /** Drop the recorded profile-installed override keys after materialization. */
     clearProfileInstalledOverrides(): void;
     /** Current profile-installed override keys, for deriving the activation base. */
     getProfileInstalledOverrideKeys(): {
@@ -1120,6 +1125,13 @@ export declare class AgentSession {
     withSdkControlMutation<T>(body: () => Promise<T>): Promise<T>;
     /** Return the persisted configured fallback selectors for a model role. */
     getConfiguredModelChain(role: string): readonly string[] | undefined;
+    /** Return the persisted configured chain with its durable ownership metadata. */
+    getConfiguredModelChainState(role: string): {
+        entries: readonly string[];
+        origin: string;
+        identity?: string;
+        explicitHead: boolean;
+    } | undefined;
     /** Persist the configured fallback selectors for a model role. */
     setConfiguredModelChain(role: string, entries: readonly string[], origin: string, identity?: string, explicitHead?: boolean): void;
     /**
@@ -1136,6 +1148,8 @@ export declare class AgentSession {
         selector: string;
         reason: string;
     }>): void;
+    getDefaultFallbackRuntimeState(): DefaultFallbackRuntimeState;
+    restoreDefaultFallbackRuntimeState(state: DefaultFallbackRuntimeState): void;
     /**
      * The model selector ("provider/id") that resume restores as the session
      * default — the latest session-log `model_change` with role="default".
@@ -1152,13 +1166,12 @@ export declare class AgentSession {
      */
     resolveConfiguredDefaultModel(): Model | undefined;
     /**
-     * Re-assert the session resume default ("provider/id") in the session log
-     * WITHOUT touching the live runtime model. Appends a `model_change` with
-     * role="default"; never writes to global settings (apply-for-this-session
-     * semantics). Used by model-profile activation rollback to neutralize the
-     * profile main model the failed activation already recorded as the default.
+     * Record or clear the session resume default ("provider/id") without touching
+     * the live runtime model. An undefined selector appends an explicit clear
+     * marker so rollback preserves the absence of a prior default during replay.
+     * Never writes global settings.
      */
-    recordResumeDefaultModel(selector: string): void;
+    recordResumeDefaultModel(selector: string | undefined): void;
     /**
      * Set model temporarily (for this session only).
      * Validates API key, saves to session log but NOT to settings.
@@ -1166,10 +1179,9 @@ export declare class AgentSession {
      * The change is recorded in the session log as `role: "temporary"` by
      * default, which means it is NOT restored as the session default on resume —
      * transient retry/fallback/context-promotion/plan switches must not clobber
-     * the user's explicit pick (issue #849). Model-profile activation passes
-     * `persistAsSessionDefault: true` so the profile's main model becomes the
-     * session default and survives resume, while still not being written to
-     * global settings (new sessions keep the global default).
+     * the user's explicit pick (issue #849). Callers that intentionally own the
+     * session resume default may opt into `persistAsSessionDefault: true` without
+     * changing global settings.
      * @throws Error if no API key available for the model
      */
     setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel, options?: {
@@ -1179,6 +1191,8 @@ export declare class AgentSession {
         providerSessionScope?: TemporaryProviderSessionScope;
         signal?: AbortSignal;
     }): Promise<TemporaryProviderSessionScope | void>;
+    /** Restore the exact live-model state captured before a failed selector transaction. */
+    restoreModelSelectionForRollback(model: Model | undefined, thinkingLevel: ThinkingLevel | undefined): Promise<void>;
     /** Set a durable per-session model from a control surface without exposing credential errors. */
     setModelTemporaryForControl(model: Model, expectedSessionId?: string, thinkingLevel?: ThinkingLevel): Promise<boolean>;
     setDefaultModelSelection(model: Model, thinkingLevel: ThinkingLevel | undefined, options?: {

package/dist/types/session/blob-store.d.ts

@@ -27,18 +27,15 @@ export declare class ResidentCacheTrustError extends Error {
     readonly path: string;
     constructor(reason: string, path: string, options?: ErrorOptions);
 }
+export declare function disposeVerifiedResidentCacheInstanceDir(instanceDir: string): void;
 /**
  * Best-effort cleanup of abandoned resident-cache instances. The root is
  * re-verified before scanning, work is bounded, and all failures fail closed.
  */
 export declare function sweepResidentCacheRoot(root: string, options?: ResidentCacheGcSweepOptions): Promise<void>;
-/**
- * Create a private resident-cache instance directory beneath a trusted profile
- * root. The cache-owned root and nonce instance are both verified owner-only
- * directories; callers must use {@link EphemeralBlobStore.adoptVerifiedDir}
- * rather than the destructive EphemeralBlobStore constructor.
- */
 export declare function openVerifiedResidentCacheInstanceDir(root: string): string;
+/** Open the deterministic per-session managed-sidecar instance in its separate cache root. */
+export declare function openVerifiedSidecarCacheInstanceDir(root: string, sessionHash: string): string;
 /**
  * Content-addressed blob store for externalizing large binary data (images) from session JSONL files.
  *
@@ -216,6 +213,8 @@ export interface CanonicalBlobEntry {
     readonly path: string;
     readonly bytes: number;
     readonly mtimeMs: number;
+    readonly dev: number;
+    readonly ino: number;
 }
 /** Longest possible `blob:sha256:<hash>` reference, used to bound chunked scans. */
 export declare const BLOB_REFERENCE_MAX_LENGTH: number;
@@ -232,10 +231,17 @@ export declare function listCanonicalBlobs(dir: string): Promise<CanonicalBlobEn
  * at scan time must still describe the file at unlink time (same inode, size and
  * mtime, still a single-link regular file), otherwise the blob is left in place.
  *
+ * `beforeUnlink` runs after this function has verified the blob and immediately
+ * before it calls unlink. Callers use it to bind external liveness evidence to
+ * the verified blob identity, so a live reference that appears while the blob is
+ * being revalidated prevents the destructive syscall.
+ *
  * `failed` distinguishes an actual IO failure (which a caller should surface as
  * a failed reclaim) from a revalidation refusal (which is an ordinary KEEP).
  */
-export declare function removeCanonicalBlob(entry: CanonicalBlobEntry): Promise<{
+export declare function removeCanonicalBlob(entry: CanonicalBlobEntry, options?: {
+    beforeUnlink?: () => Promise<boolean>;
+}): Promise<{
     removed: true;
 } | {
     removed: false;

package/dist/types/session/fallback-chain-controller.d.ts

@@ -13,6 +13,19 @@ export interface FallbackFailure {
     reason: string;
 }
 export type FallbackFailureResult = "retry" | "advance" | "exhausted";
+export interface FallbackChainRuntimeState {
+    activeIndex: number;
+    attemptsUsed: number;
+    totalAttemptsUsed: number;
+    attemptStarted: boolean;
+    restoredEntryIndices: number[];
+    tried: FallbackFailure[];
+    skips: Array<{
+        selector: string;
+        reason: string;
+    }>;
+    exhaustedForTurn: boolean;
+}
 /**
  * In-memory policy state for one fallback-chain scope. A controller is deliberately
  * not serializable: configured chain intent is durable, current position is not.
@@ -30,6 +43,8 @@ export declare class FallbackChainController {
     }>;
     exhaustedForTurn: boolean;
     constructor(chain: ConfiguredFallbackChain, maxAttempts: number);
+    snapshotRuntimeState(): FallbackChainRuntimeState;
+    restoreRuntimeState(state: FallbackChainRuntimeState): void;
     get totalAttemptsUsed(): number;
     currentSelector(): string | undefined;
     onResolutionSkip(reason: string): boolean;

package/dist/types/session/internal/managed-session-storage.d.ts

@@ -1,5 +1,5 @@
 import type { NativeDirectoryTreeSnapshot, NativeExactUnlinkResult, NativeOwnerOnlySecurityResult, RecoveryFsRoot } from "@gajae-code/natives";
-import type { SessionStorageStat } from "../session-storage";
+import type { SessionStorageRangeSnapshot, SessionStorageStat } from "../session-storage";
 import { type NativePublishOutcome } from "./native-publish-outcome";
 export declare const MANAGED_ARTIFACT_MAX_DEPTH = 32;
 export declare const MANAGED_ARTIFACT_MAX_FILES = 50000;
@@ -21,6 +21,10 @@ export declare class ManagedReplaceError extends Error {
     readonly replacementCause: unknown;
     constructor(result: NativeExactUnlinkResult, cleanupReceiptPath: string, replacementCause?: unknown);
 }
+export declare class ManagedCommittedMutationError extends Error {
+    readonly operation: "replace" | "append";
+    constructor(operation: "replace" | "append", cause: unknown);
+}
 /** Cleanup is safe only when the native move reports that it did not commit. */
 export declare function mayCleanManagedTreeStaging(error: unknown): boolean;
 /**
@@ -83,6 +87,17 @@ export interface ManagedBoundedAppendExpectation {
     readonly ctimeNs: string;
     readonly sha256: string;
 }
+/**
+ * Best-effort removal of scrubbed write-protocol remnants from one managed
+ * directory. Only zero-length, single-link, non-symlink regular files whose
+ * names carry a terminal remnant prefix and whose timestamps are older than
+ * the age gate are removed: a zero-length single-link entry is exactly what
+ * the scrub proof leaves behind, and non-zero entries (displaced predecessors
+ * or detached receipts retained as evidence) are never touched. Failures are
+ * swallowed — a concurrent same-owner writer may legitimately own or already
+ * have reconciled any candidate.
+ */
+export declare function reapScrubbedProtocolRemnantsSync(directory: string, minAgeMs?: number): number;
 export declare function validateNativeSecurityResult(value: unknown, operation: "apply" | "verify", kind: "directory" | "file"): NativeOwnerOnlySecurityResult;
 export interface ManagedLockRetirementTestEvent {
     readonly path: string;
@@ -149,10 +164,19 @@ export declare class ManagedSessionDescendantStore {
     appendSync(relativePath: string, bytes: Uint8Array): ManagedAppendReceipt;
     /** Capture descriptor identity without copying file bytes when retained authority is available. */
     descriptorExpected(relativePath: string): SessionStorageStat | null;
+    /**
+     * Read one bounded range through a no-follow descriptor while binding the
+     * opened file to retained authority (when available) and the managed root
+     * before and after the read. This avoids whole-transcript capture for cold
+     * managed-session indexing without weakening pathname authority.
+     */
+    readRangeExpectedSync(relativePath: string, start: number, length: number, expectedDescriptor?: Pick<SessionStorageStat, "dev" | "ino" | "nlink" | "size" | "mtimeNs" | "ctimeNs">): SessionStorageRangeSnapshot;
     /** Read an exact managed file without exposing its pathname as authority. */
     readExpected(relativePath: string): ManagedFileSnapshot | null;
     /** Remove an exact captured file without reopening its pathname as authority. */
     removeExpected(relativePath: string, expected: ManagedFileSnapshot): void;
+    /** Remove one exact file without allocating its contents. */
+    removeIfExistsDescriptor(relativePath: string): boolean;
     /** Read and remove one managed descendant through retained authority. */
     consume(relativePath: string): Promise<Uint8Array | null>;
     /** Remove one managed descendant through retained authority when it exists. */

package/dist/types/session/internal/session-memory-sidecar.d.ts

@@ -186,7 +186,7 @@ export declare class ReducerBudget {
 /**
  * Single source of truth for every sidecar artifact and temp: `*.spill.idx`,
  * `*.spill.tail`, `*.spill.commit`, `*.spill.buckets`, `*.spill.dict-*`,
- * `*.spill.capture-*`, `*.spill.fork-*`, `*.spill.overlay-*`,
+ * `*.spill.capture-*`, `*.spill.fork-*`, `*.spill.overlay-*`, `*.spill.build-lock`,
  * `*.spill.parent-*` (persistent parent→children buckets),
  * `*.spill.metadata-*` (persistent metadata-delta section), and any
  * `*.spill.*.tmp`. Used at every fork/delete/sweep/Memory-parity callsite so
@@ -731,10 +731,10 @@ export interface DictionaryIdDetector {
     add(id: string): "added" | "duplicate" | "full";
 }
 /**
- * Bounded duplicate-id oracle. Small transcripts stay in a tiny exact set;
- * larger transcripts promote once to the fixed-capacity 48-bit hash table.
- * A hash collision can only produce a spurious duplicate (fail closed), never
- * miss a true duplicate.
+ * Bounded duplicate-id oracle. The fixed-capacity 48-bit hash table is allocated
+ * on the first record, so no attacker-controlled id string is retained by the
+ * detector. A hash collision can only produce a spurious duplicate (fail
+ * closed), never miss a true duplicate.
  */
 export declare class BoundedDictionaryIdSet implements DictionaryIdDetector {
     #private;