@gajae-code/coding-agent 0.11.10 → 0.12.0

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

@@ -80,9 +80,11 @@ import type { TtsrManager } from "../export/ttsr";
 import type { LoadedCustomCommand } from "../extensibility/custom-commands";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { ExtensionRunner } from "../extensibility/extensions";
-import type { CompactOptions, ContextUsage } from "../extensibility/extensions/types";
+import type { CompactOptions, ContextUsage, ExtensionTranscriptEntry } from "../extensibility/extensions/types";
+import type { SessionSwitchEvent } from "../extensibility/shared-events";
 import { type Skill, type SkillWarning } from "../extensibility/skills";
 import { type FileSlashCommand } from "../extensibility/slash-commands";
+import { type MemoryGuardClaimsLease } from "../gjc-runtime/memory-guard-owner-claims";
 import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
@@ -101,8 +103,9 @@ import { type DefaultModelSelectionResult } from "./default-model-selection";
 export { DefaultModelSelectionRecoveryError } from "./default-model-selection";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "./client-bridge";
 import { type ContributionPrepOptions, type ContributionPrepResult } from "./contribution-prep";
+import type { MemoryGuardRestoreResult } from "./memory-guard-checkpoint-participant";
 import { type CustomMessage } from "./messages";
-import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, RecoveryHydrationContext, RecoveryHydrationPromotionFence, SessionContext, SessionManager, SessionManagerCloseOutcome } from "./session-manager";
+import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, PreparedNewSession, RecoveryHydrationContext, RecoveryHydrationPromotionFence, SessionContext, SessionManager, SessionManagerCloseOutcome } from "./session-manager";
 import { ToolChoiceQueue } from "./tool-choice-queue";
 import { YieldQueue } from "./yield-queue";
 /** Session-specific events that extend the core AgentEvent */
@@ -314,6 +317,24 @@ export interface AgentSessionConfig {
     /** Optional provider-facing cache identity, distinct from logical session identity. */
     providerCacheSessionId?: string;
 }
+export interface AgentSessionMemoryGuardRestoreInput extends Omit<AgentSessionConfig, "sessionManager" | "recoveryHydrationContext"> {
+    staged: Extract<MemoryGuardRestoreResult, {
+        kind: "staged";
+    }>;
+    claimsLease: MemoryGuardClaimsLease;
+    claimsStateDir: string;
+}
+export interface AgentMemoryGuardPromotionFence extends RecoveryHydrationPromotionFence {
+    readonly claimsLease: MemoryGuardClaimsLease;
+}
+export type AgentMemoryGuardRestoreResult = {
+    kind: "staged";
+    session: AgentSession;
+    promotionFence: AgentMemoryGuardPromotionFence;
+} | {
+    kind: "blocked";
+    reason: "transcript-mismatch" | "hydration-context-mismatch" | "claim-mismatch" | "agent-messages-mismatch";
+};
 type MidRunMaintenanceLifecycle = Parameters<NonNullable<AgentLoopConfig["maintainContext"]>>[1];
 /** Options for AgentSession.prompt() */
 export interface PromptOptions {
@@ -336,8 +357,21 @@ export interface PromptOptions {
     /**
      * Invoked after all prompt preflight checks pass and immediately before agent execution begins.
      * Cancellation before this callback rejects the prompt.
+     * Prefer `onPreflightAcceptCommit` for async durable acceptance (#3031/#3032).
      */
     onPreflightAccepted?: () => void;
+    /**
+     * Awaitable durable-accept fence. Called after preflight and before queue mutation
+     * or `#promptAgentWithIdleRetry`. SDK bus installs a closure that fsyncs acceptance.
+     */
+    onPreflightAcceptCommit?: () => void | Promise<void>;
+    /** Skill-only: prepared metadata before the durable fence (path/lineCount/cleanedArgs). */
+    onSkillPrepared?: (meta: {
+        name: string;
+        path: string;
+        lineCount?: number;
+        cleanedArgs?: string;
+    }) => void;
 }
 /** Result from a handoff operation. */
 export interface HandoffResult {
@@ -755,13 +789,16 @@ export declare class AgentSession {
     /** All messages including custom types like BashExecutionMessage */
     get messages(): AgentMessage[];
     get transcriptPromptGeneration(): number;
+    static restoreFromMemoryGuardCheckpoint(input: AgentSessionMemoryGuardRestoreInput): Promise<AgentMemoryGuardRestoreResult>;
     /** The immutable recovery authority, present only before external ownership promotion. */
     get recoveryHydrationContext(): RecoveryHydrationContext | undefined;
     /** Enables normal session mutations after the owner has published its durable fence and writer lease. */
-    promoteRecoveryHydrationAfterOwnershipReadyFence(fence: RecoveryHydrationPromotionFence): Promise<void>;
+    promoteRecoveryHydrationAfterOwnershipReadyFence(fence: AgentMemoryGuardPromotionFence): Promise<void>;
     /** Main startup calls this exactly once, after a strict open returned `kind: "opened"`. */
     continuePersistedHistory(): Promise<void>;
     buildDisplaySessionContext(): SessionContext;
+    /** Build display context from an unpublished successor without changing active session state. @internal */
+    buildPreparedDisplaySessionContext(prepared: PreparedNewSession): SessionContext;
     /** Convert session messages using the same pre-LLM pipeline as the active session. */
     convertMessagesToLlm(messages: AgentMessage[], signal?: AbortSignal): Promise<Message[]>;
     /** Apply session-level stream hooks to a direct side request. */
@@ -785,7 +822,7 @@ export declare class AgentSession {
     /** Live SDK configuration values exposed through the session query surface. */
     getSdkConfigItems(): Record<string, string>;
     setPlanModeState(state: PlanModeState | undefined): void;
-    invokeSkill(name: string, args?: string): Promise<{
+    invokeSkill(name: string, args?: string, options?: Pick<PromptOptions, "onPreflightAccepted" | "onPreflightAcceptCommit" | "onSkillPrepared">): Promise<{
         name: string;
         path: string;
         args?: string;
@@ -793,13 +830,7 @@ export declare class AgentSession {
     }>;
     setSdkPlanMode(on: boolean): Promise<PlanModeState | undefined>;
     operateGoal(op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string): Promise<unknown>;
-    getTranscript(): Array<{
-        id: string;
-        role: string;
-        textSummary: string;
-        ts: string;
-        body: string;
-    }>;
+    getTranscript(): ExtensionTranscriptEntry[];
     getTranscriptBody(entryId: string): string | undefined;
     getGoalModeState(): GoalModeState | undefined;
     setGoalModeState(state: GoalModeState | undefined): void;
@@ -846,7 +877,7 @@ export declare class AgentSession {
      * @throws Error if no model selected or no API key available (when not streaming)
      */
     prompt(text: string, options?: PromptOptions): Promise<void>;
-    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy">): Promise<void>;
+    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy" | "onPreflightAccepted" | "onPreflightAcceptCommit">): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
@@ -886,6 +917,7 @@ export declare class AgentSession {
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";
         onPreflightAccepted?: () => void;
+        onPreflightAcceptCommit?: () => void | Promise<void>;
     }): Promise<void>;
     /**
      * Clear queued messages and return them.
@@ -988,6 +1020,8 @@ export declare class AgentSession {
     }): Promise<void>;
     setActiveModelProfile(name: string | undefined): void;
     getActiveModelProfile(): string | undefined;
+    /** Activate a complete model profile through a nonvisual session control. */
+    activateModelProfileForControl(profileName: string): Promise<boolean>;
     /** Return the persisted configured fallback selectors for a model role. */
     getConfiguredModelChain(role: string): readonly string[] | undefined;
     /** Persist the configured fallback selectors for a model role. */
@@ -1067,20 +1101,16 @@ export declare class AgentSession {
      * Get all available models with valid API keys.
      */
     getAvailableModels(): Model[];
-    /**
-     * Set thinking level.
-     * Saves the effective metadata-clamped level to the session, and to settings when requested.
-     */
     setThinkingLevel(level: ThinkingLevel | undefined, persist?: boolean): void;
     /**
-     * Set thinking level from a control surface. Global changes are durable or rolled back.
+     * Set thinking level from a control surface. Global changes commit before affecting live state.
      */
     setThinkingLevelForControl(level: ThinkingLevel, persist: boolean): Promise<void>;
     getThinkingScopeForControl(): "session" | "global config";
     getThinkingVisibility(): "visible" | "hidden";
     setThinkingVisibility(visibility: "visible" | "hidden", persist?: boolean): void;
     /**
-     * Set thinking visibility from a control surface. Global changes are durable or rolled back.
+     * Set thinking visibility from a control surface. Global changes commit before affecting live state.
      */
     setThinkingVisibilityForControl(visibility: "visible" | "hidden", persist: boolean): Promise<void>;
     /**
@@ -1318,7 +1348,9 @@ export declare class AgentSession {
      * Listeners are preserved and will continue receiving events.
      * @returns true if switch completed, false if cancelled by hook
      */
-    switchSession(sessionPath: string): Promise<boolean>;
+    switchSession(sessionPath: string, options?: {
+        transition?: SessionSwitchEvent["transition"];
+    }): Promise<boolean>;
     /**
      * Create a branch from a specific entry.
      * Emits before_branch/branch session events to hooks.

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

@@ -47,8 +47,9 @@ export declare class FallbackChainController {
     onAttemptFailure(triggerClass: FallbackTriggerClass, reason: string): FallbackFailureResult;
     advance(): boolean;
     /**
-     * Restore the entry that just advanced when credential rotation permits a retry.
-     * The chain-wide budget and failure history remain charged.
+     * Restore the entry that just advanced for one attempt with a rotated credential.
+     * Each non-terminal entry may be restored once, so credential rotation remains
+     * bounded and cannot consume the attempts reserved for downstream entries.
      */
     restorePreviousEntryForRetry(): boolean;
     isExhausted(): boolean;
@@ -56,5 +57,20 @@ export declare class FallbackChainController {
     resetSticky(): void;
 }
 export declare function cappedExponentialWithFullJitter(baseDelayMs: number, maxDelayMs: number, attemptK: number, random?: () => number): number;
+/**
+ * Legacy auto-compaction retry delay.
+ *
+ * Deliberately the mirror image of `effectiveFallbackDelay`: this path recovers
+ * Retry-After by regex over provider error prose (`#parseRetryAfterMsFromError`),
+ * so it follows the documented legacy rule — `retry.maxDelayMs` caps every
+ * legacy session retry delay, including provider retry-after hints. Managed
+ * fallback stays uncapped because it retries within its own per-entry budget;
+ * compaction has no such budget, so the final candidate would otherwise sleep
+ * for the full server-suggested duration.
+ *
+ * `maxDelayMs <= 0` means "no cap", matching `cappedExponentialWithFullJitter`.
+ * A missing, NaN, or infinite hint collapses to "no usable hint".
+ */
+export declare function compactionRetryDelay(baseDelayMs: number, maxDelayMs: number, attempt: number, retryAfterMs: number | undefined): number;
 /** Retry-After is intentionally uncapped. */
 export declare function effectiveFallbackDelay(baseDelayMs: number, maxDelayMs: number, attemptK: number, retryAfterMs: number | undefined, random?: () => number): number;

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

@@ -121,12 +121,39 @@ export declare function ensureManagedScope(scope: ManagedScope, policy?: Managed
 /** Synchronously create and validate the v2 binding before a default session writer exists. */
 export declare function prepareManagedSessionScopeForWriteSync(scope: ManagedScope, policy?: ManagedSessionSecurityPolicy, authority?: ManagedCandidateWriteAuthority): ManagedScopeResolution;
 export declare function listManagedCandidates(scope: ManagedScope): ManagedCandidateListing;
+type DetachedArtifactRoot = {
+    originalPath: string;
+    detachedPath: string;
+    identity: {
+        dev: bigint;
+        ino: bigint;
+        size: bigint;
+        mtimeNs: bigint;
+    };
+    tree: NativeDirectoryTreeSnapshot;
+};
 export declare function matchesMigrationArtifactRoot(pathname: string, identity: {
     dev: bigint;
     ino: bigint;
     size: bigint;
     mtimeNs: bigint;
 }, expectedTree: NativeDirectoryTreeSnapshot, platform?: NodeJS.Platform): boolean;
+type SourceArtifactCleanup = {
+    state: "cleanup_pending";
+    role: "exchange_placeholder";
+    retainedPath: string;
+    identity: DetachedArtifactRoot["identity"];
+    tree: NativeDirectoryTreeSnapshot;
+};
+export declare function cleanupAuthorityMatches(cleanup: SourceArtifactCleanup, parent: string, platform?: NodeJS.Platform): boolean;
+export declare function detachArtifactRootForMigration(plan: DetachedArtifactRoot, platform?: NodeJS.Platform): {
+    detached: DetachedArtifactRoot;
+    detachOutcome: "clean";
+} | {
+    detached: DetachedArtifactRoot;
+    detachOutcome: "cleanup_pending";
+    cleanup: SourceArtifactCleanup;
+};
 export declare function restorePreparedArtifactRoot(scope: ManagedScope, source: ManagedCandidate, lock?: ManagedStorageLock): void;
 /** Resume tombstoned cleanup under its original operation lease without restoring retired candidates. */
 export declare function reconcileManagedTombstones(scope: ManagedScope, expectedCandidate?: ManagedCandidate): Promise<void>;

package/dist/types/session/memory-guard-checkpoint-participant.d.ts

@@ -0,0 +1,69 @@
+import type { RecoveryFsRoot } from "@gajae-code/natives";
+import type { RecoveryHydrationContext, ResumeSessionIdentity, SessionDestinationInput, SessionManager, SessionManagerCheckpointRevisionStrings, StrictSessionOpenFailure } from "./session-manager";
+export interface MemoryGuardTranscriptDescriptorV1 {
+    bytes: string;
+    relative_path: string;
+    sha256: string;
+}
+export interface MemoryGuardCheckpointBlobAuthorityV1 {
+    kind: "checkpoint_blob_tree_v1";
+    manifest_relative_path: string;
+    manifest_sha256: string;
+    root_relative_path: string;
+}
+export interface MemoryGuardCheckpointBlobManifestEntryV1 {
+    bytes: string;
+    relative_path: string;
+    sha256: string;
+}
+export interface MemoryGuardCheckpointBlobManifestV1 {
+    entries: MemoryGuardCheckpointBlobManifestEntryV1[];
+    schema_version: 1;
+}
+export interface MemoryGuardSessionManagerCheckpointV1 {
+    blob_authority: MemoryGuardCheckpointBlobAuthorityV1;
+    revisions: SessionManagerCheckpointRevisionStrings;
+    schema_version: 1;
+    session_id: string;
+    session_name: string | null;
+    transcript: MemoryGuardTranscriptDescriptorV1;
+}
+export interface MemoryGuardParticipantDescriptorV1 {
+    ordinal: number;
+    checkpoint: MemoryGuardCheckpointBlobAuthorityV1;
+    revisions: SessionManagerCheckpointRevisionStrings;
+    session_id: string;
+    session_name: string | null;
+    transcript: MemoryGuardTranscriptDescriptorV1;
+}
+export interface MemoryGuardParticipantIngressLease {
+    readonly token: symbol;
+    release(): void;
+}
+export interface MemoryGuardCreateCheckpointInput {
+    ingressLease: MemoryGuardParticipantIngressLease;
+    checkpointRoot: string;
+}
+export type MemoryGuardRestoreBlockedReason = StrictSessionOpenFailure["reason"] | "checkpoint-mismatch" | "participant-mismatch" | "transcript-mismatch" | "blob-manifest-mismatch" | "blob-missing" | "blob-hash-mismatch" | "blob-authority-mismatch" | "destination-unavailable";
+export interface MemoryGuardRestoreInput {
+    incidentAuthority: RecoveryFsRoot;
+    participant: MemoryGuardParticipantDescriptorV1;
+    checkpoint: MemoryGuardSessionManagerCheckpointV1;
+    destination: SessionDestinationInput;
+}
+export type MemoryGuardRestoreResult = {
+    kind: "staged";
+    manager: SessionManager;
+    hydrationContext: RecoveryHydrationContext;
+    transcriptIdentity: ResumeSessionIdentity;
+    cleanup: () => Promise<void>;
+} | {
+    kind: "blocked";
+    reason: MemoryGuardRestoreBlockedReason;
+};
+export declare function memoryGuardCanonicalJson(value: unknown): string;
+export declare function memoryGuardSha256Hex(value: Uint8Array | string): string;
+export declare function isMemoryGuardDecimalString(value: unknown): value is string;
+export declare function isMemoryGuardSha256Hex(value: unknown): value is string;
+export declare function isMemoryGuardRelativePath(value: unknown): value is string;
+export declare function hasOnlyKeys(value: Record<string, unknown>, allowed: readonly string[]): boolean;

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

@@ -8,6 +8,7 @@ import { ArtifactManager } from "./artifacts";
 import { type BlobPutResult, BlobStore } from "./blob-store";
 import { type ManagedMigrationPolicy } from "./internal/managed-session-scope";
 import { type ManagedDirectoryRoot, ManagedSessionDescendantStore } from "./internal/managed-session-storage";
+import { type MemoryGuardCreateCheckpointInput, type MemoryGuardParticipantIngressLease, type MemoryGuardRestoreInput, type MemoryGuardRestoreResult, type MemoryGuardSessionManagerCheckpointV1 } from "./memory-guard-checkpoint-participant";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
 import { type SessionManagerReadAccess, sessionManagerReadCapability } from "./session-manager-internal";
 import type { ManagedSessionSecurityContext, SessionStorage, SessionStorageStat, VerifiedSessionDeleteResult, VerifiedSessionDeleteTarget } from "./session-storage";
@@ -27,6 +28,13 @@ export interface NewSessionOptions {
     /** Skip flushing the current session and delete it instead of saving. */
     drop?: boolean;
 }
+/** Internal successor prepared without changing the manager's visible identity. */
+export interface PreparedNewSession {
+    readonly sessionId: string;
+    readonly sessionFile: string | undefined;
+    readonly artifactsDir: string | null;
+    readonly managedLegacyLocalMigrationSource: ManagedLegacyLocalMigrationSource | null;
+}
 export interface SessionEntryBase {
     type: string;
     id: string;
@@ -252,6 +260,21 @@ export type DefaultModelSelectionStage = {
     readonly tempPath: string | undefined;
     readonly persistsToExistingFile: boolean;
 };
+export interface SessionManagerRevisionSnapshot {
+    entry: number;
+    leaf: number;
+    headerExport: number;
+    label: number;
+    replayMetadata: number;
+}
+export interface SessionManagerCheckpointRevisionStrings {
+    entry: string;
+    leaf: string;
+    headerExport: string;
+    label: string;
+    replayMetadata: string;
+}
+export declare function toSessionManagerCheckpointRevisionStrings(snapshot: SessionManagerRevisionSnapshot): SessionManagerCheckpointRevisionStrings;
 export type DefaultModelSelectionPromotion = {
     readonly kind: "promoted";
 } | {
@@ -534,6 +557,10 @@ export declare function residentBlobSentinelForTests(kind: ResidentBlobKind, ref
 export declare function materializeResidentEntriesForPersistenceForTests<T>(entries: T[], textStore: BlobStore, imageStore?: BlobStore): T[];
 /** Get recent sessions for display in welcome screen */
 export declare function getRecentSessions(sessionDir: string, limit?: number, storage?: SessionStorage): Promise<RecentSessionInfo[]>;
+export declare function getRecentSessionDisplay(sessions: readonly SessionInfo[], limit?: number): Array<{
+    name: string;
+    timeAgo: string;
+}>;
 /**
  * Manages conversation sessions as append-only trees stored in JSONL files.
  *
@@ -582,13 +609,7 @@ export declare class SessionManager {
      * revision contract). Tests assert the invalidation mapping through this;
      * future export/label-view caches key off their respective domains.
      */
-    revisionSnapshot(): {
-        entry: number;
-        leaf: number;
-        headerExport: number;
-        label: number;
-        replayMetadata: number;
-    };
+    revisionSnapshot(): SessionManagerRevisionSnapshot;
     /** Puts a binary blob into the blob store and returns the blob reference */
     putBlob(data: Buffer): Promise<BlobPutResult>;
     captureState(): SessionManagerStateSnapshot;
@@ -597,6 +618,33 @@ export declare class SessionManager {
     setSessionFile(sessionFile: string): Promise<void>;
     /** Start a new session. Closes any existing writer first. */
     newSession(options?: NewSessionOptions): Promise<string | undefined>;
+    /**
+     * Allocate a fresh successor without publishing it through the manager's public
+     * getters. The returned authority is deliberately immutable so readiness work
+     * can resolve local:// against the successor while the predecessor stays live.
+     * @internal
+     */
+    prepareNewSession(options?: NewSessionOptions): Promise<PreparedNewSession>;
+    /** Append a model selection to an unpublished successor. @internal */
+    appendPreparedModelChange(prepared: PreparedNewSession, model: string): string;
+    /** Append a thinking-level selection to an unpublished successor. @internal */
+    appendPreparedThinkingLevelChange(prepared: PreparedNewSession, thinkingLevel?: string): string;
+    /** Append a service-tier selection to an unpublished successor. @internal */
+    appendPreparedServiceTierChange(prepared: PreparedNewSession, serviceTier: ServiceTier | null): string;
+    /** Append a displayable custom message to an unpublished successor. @internal */
+    appendPreparedCustomMessageEntry<T = unknown>(prepared: PreparedNewSession, customType: string, content: string | (TextContent | ImageContent)[], display: boolean, details?: T, attribution?: MessageAttribution): string;
+    /** Persist an unpublished successor without adopting it. @internal */
+    ensurePreparedNewSessionOnDisk(prepared: PreparedNewSession): Promise<void>;
+    /** Build context from an unpublished successor without reading active manager state. @internal */
+    buildPreparedNewSessionContext(prepared: PreparedNewSession): SessionContext;
+    /** Prepare a forked successor without publishing it through public manager state. @internal */
+    prepareFork(): Promise<PreparedNewSession | undefined>;
+    /** Prepare a path-only branch successor without publishing it through public manager state. @internal */
+    prepareBranchedSession(leafId: string): Promise<PreparedNewSession>;
+    /** Publish a prepared successor synchronously after all readiness awaits succeed. @internal */
+    commitPreparedNewSession(prepared: PreparedNewSession): void;
+    /** Exact-discard only an uncommitted successor prepared by this manager. @internal */
+    discardPreparedNewSession(prepared: PreparedNewSession): Promise<void>;
     /** Tombstone and exact-delete managed transcripts, detaching the active transcript first. */
     dropSession(sessionPath: string): Promise<void>;
     /**
@@ -657,6 +705,8 @@ export declare class SessionManager {
     listForResumePickerReadOnly(): Promise<SessionInfo[]>;
     getSessionId(): string;
     getSessionFile(): string | undefined;
+    acquireMemoryGuardParticipantIngressLease(): MemoryGuardParticipantIngressLease;
+    createMemoryGuardCheckpoint(input: MemoryGuardCreateCheckpointInput): Promise<MemoryGuardSessionManagerCheckpointV1>;
     /**
      * Returns the session artifacts directory path (session file path without .jsonl).
      * Returns null when the session is not persisted to a file.
@@ -713,11 +763,6 @@ export declare class SessionManager {
     /** The source that set the session name: "user" (manual /rename or RPC) or "auto" (generated title). */
     get titleSource(): "auto" | "user" | undefined;
     getSessionName(): string | undefined;
-    /**
-     * Set the session display name.
-     * @param source - "user" for explicit renames (/rename command, RPC); "auto" for generated titles.
-     *   Auto-generated titles are silently ignored when the user has already set a name.
-     */
     setSessionName(name: string, source?: "auto" | "user"): Promise<boolean>;
     _persist(entry: SessionEntry): void;
     /** Append a configured fallback chain as child of current leaf, then advance leaf. Returns entry id. */
@@ -937,7 +982,7 @@ export declare class SessionManager {
      * legacy sibling directories.
      */
     static listForResumePickerReadOnly(cwd: string, sessionDir?: string, storage?: SessionStorage): Promise<SessionInfo[]>;
-    /** Tombstone and exact-delete a default-managed candidate. */
+    /** Delete an authorized managed or project-local picker candidate. */
     static deleteManagedCandidate(sessionPath: string): Promise<void>;
     /** Capture exact source content for a strict fork without granting write ownership. */
     static captureTranscriptStrict(filePath: string, storage?: SessionStorage): StrictSessionCaptureResult;
@@ -947,6 +992,7 @@ export declare class SessionManager {
      * persistence; destination history always comes from the captured bytes.
      */
     static forkFromCaptured(snapshot: CapturedSessionTranscriptSnapshot, cwd: string, destinationInput?: SessionDestinationInput, _migrationPolicy?: SessionDirectoryMigrationPolicy): Promise<StrictSessionForkResult>;
+    static restoreMemoryGuardCheckpoint(input: MemoryGuardRestoreInput): Promise<MemoryGuardRestoreResult>;
     /** Inspect a selected session without acquiring write-capable ownership. */
     static inspectSessionTailReadOnly(filePath: string, storage?: SessionStorage): Promise<ResumeTailInspection>;
     /**

package/dist/types/session/streaming-output.d.ts

@@ -83,7 +83,10 @@ export interface TruncationResult {
     elidedLines?: number;
     lastLinePartial?: boolean;
     firstLineExceedsLimit?: boolean;
+    lastLineExceedsLimit?: boolean;
 }
+/** Direction vocabulary used by callers that select which end of content to retain. */
+export type TruncationDirection = "head" | "last" | "both";
 export interface TruncationOptions {
     /** Maximum number of lines (default: 3000) */
     maxLines?: number;
@@ -99,6 +102,8 @@ export interface TruncationOptions {
      * window receives `maxLines - maxHeadLines`. Default `floor(maxLines/2)`.
      */
     maxHeadLines?: number;
+    /** Direction to dispatch through truncateContent (head, last, or both). */
+    direction?: TruncationDirection;
 }
 /** Result from byte-level truncation helpers. */
 export interface ByteTruncationResult {
@@ -155,14 +160,64 @@ export declare function truncateTail(content: string, options?: TruncationOption
  */
 export declare function formatMiddleElisionMarker(elidedLines: number, elidedBytes: number): string;
 /**
- * Truncate content keeping a head window and a tail window, eliding the middle.
+ * A retained source segment returned by {@link truncateMiddleWindows}.
+ * Line coordinates are 1-indexed and inclusive.
+ */
+export type ReadSegment = {
+    kind: "lines";
+    content: string;
+    lines: number;
+    bytes: number;
+    origin: {
+        startLine: number;
+        endLine: number;
+    };
+    lastLinePartial: false;
+} | {
+    kind: "partial-line";
+    content: string;
+    lines: 1;
+    bytes: number;
+    origin: {
+        startLine: number;
+        endLine: number;
+    };
+    sourceLineBytes: number;
+    lastLinePartial: true;
+};
+/** The actual windows retained by middle truncation. */
+export interface ReadWindow {
+    kind: "full" | "head-only" | "tail-only" | "middle";
+    head?: ReadSegment;
+    tail?: ReadSegment;
+    overlap: "disjoint" | "adjacent" | "overlapping";
+    elidedLines: number;
+    elidedBytes: number;
+    totalLines: number;
+    totalBytes: number;
+    /** @deprecated Non-enumerable compatibility reason for older consumers. */
+    truncatedBy?: "lines" | "bytes" | "middle";
+}
+/**
+ * Truncate content while exposing the exact retained head/tail windows.
  *
- * The combined output is `<head>\n<marker>\n<tail>` when truncation is needed.
- * `maxHeadBytes` defaults to `floor(maxBytes / 2)`; the tail receives the
- * remainder. Falls back to `truncateTail` / `truncateHead` if either side's
- * budget is empty or the content already fits.
+ * The budget split and fallback ordering intentionally mirror truncateMiddle.
+ * The overlap classification is performed before resolving an overlap to a
+ * full window, so callers can distinguish disjoint, adjacent and overlapping
+ * candidate windows even when no marker is needed.
+ */
+export declare function truncateMiddleWindows(content: string, options?: TruncationOptions): ReadWindow;
+/**
+ * Truncate content keeping a head window and a tail window, eliding the middle.
+ * The composed return shape remains field-for-field compatible with the
+ * historical implementation; callers that need coordinates use
+ * truncateMiddleWindows directly.
  */
 export declare function truncateMiddle(content: string, options?: TruncationOptions): TruncationResult;
+/**
+ * Dispatch truncation using the caller-facing direction vocabulary.
+ */
+export declare function truncateContent(content: string, options?: TruncationOptions): TruncationResult;
 export declare class TailBuffer {
     #private;
     readonly maxBytes: number;

package/dist/types/skill-state/active-state.d.ts

@@ -45,8 +45,6 @@ export interface SkillActiveEntry {
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
     source_state_revision?: number;
-    /** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
-    committed_mode_state_revision?: number;
 }
 export interface SkillActiveState {
     version?: number;
@@ -87,8 +85,6 @@ export interface SyncSkillActiveStateOptions {
     handoff_at?: string;
     active_subskills?: ActiveSubskillEntry[];
     sourceRevision?: number;
-    /** Durable ordering token from the source workflow mode-state, not this cache file's revision. */
-    committedModeRevision?: number;
 }
 export declare function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined;
 export declare function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGjcWorkflowSkill;

package/dist/types/skill-state/workflow-hud.d.ts

@@ -20,6 +20,9 @@ interface RalplanHudState extends WorkflowGateHudState {
     iteration?: number;
     iterationFromIndex?: number;
     stages?: string;
+    architectPasses?: number;
+    criticPasses?: number;
+    reviewPassBudget?: number;
     verdict?: string;
     latestSummary?: string;
     pendingApproval?: boolean;

package/dist/types/task/executor.d.ts

@@ -20,6 +20,7 @@ import type { ContextFileEntry } from "../tools";
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
 import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult } from "./types";
+import { type ExecutorExecutionMode } from "./ultragoal-redteam-activation";
 export declare function trimForkContextSeedForModel(seed: ForkContextSeed, model: Model | undefined): ForkContextSeed;
 /** Options for subagent execution */
 export interface ExecutorOptions {
@@ -28,6 +29,11 @@ export interface ExecutorOptions {
     agent: AgentDefinition;
     task: string;
     assignment?: string;
+    /**
+     * Typed executor execution mode. When set, overrides assignment-text heuristics
+     * for ultragoal red-team prompt injection (#2698 / #2456).
+     */
+    executionMode?: ExecutorExecutionMode;
     context?: string;
     description?: string;
     index: number;