@gajae-code/coding-agent 0.8.1 → 0.9.0

package/dist/types/modes/controllers/command-controller.d.ts

@@ -23,6 +23,7 @@ export declare class CommandController {
     handleContextCommand(): void;
     handleMemoryCommand(text: string): Promise<void>;
     handleClearCommand(): Promise<void>;
+    handleContextClearCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;

package/dist/types/modes/controllers/event-controller.d.ts

@@ -1,5 +1,10 @@
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __eventControllerPerfCounters: {
+    messageUpdateContentVisits: number;
+    reset(): void;
+};
 export declare class EventController {
     #private;
     private ctx;

package/dist/types/modes/controllers/input-controller.d.ts

@@ -14,9 +14,7 @@ export declare class InputController {
     handleFollowUp(): Promise<void>;
     /** Send editor text explicitly as a queued next-turn message. */
     handleQueueSubmit(): Promise<void>;
-    restoreLatestQueuedMessageToEditor(options?: {
-        currentText?: string;
-    }): number;
+    restoreLatestQueuedMessageToEditor(): number;
     restoreQueuedMessagesToEditor(options?: {
         abort?: boolean;
         currentText?: string;

package/dist/types/modes/interactive-mode.d.ts

@@ -27,6 +27,7 @@ import { type WelcomeLogoMode } from "./components/welcome";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
 import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
+export declare const DEFAULT_COMPOSER_PLACEHOLDER: string;
 export type WelcomeBannerSettingMode = "auto" | "unicode" | "square" | "ascii";
 export declare function resolveWelcomeLogoMode(mode: WelcomeBannerSettingMode, env?: Record<string, string | undefined>, platform?: NodeJS.Platform): WelcomeLogoMode;
 /** Options for creating an InteractiveMode instance (for future API use) */
@@ -189,6 +190,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleToolsCommand(): void;
     handleContextCommand(): void;
     handleClearCommand(): Promise<void>;
+    handleContextClearCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;

package/dist/types/modes/print-mode.d.ts

@@ -5,7 +5,7 @@
  * - `gjc -p "prompt"` - text output
  * - `gjc --mode json "prompt"` - JSON event stream
  */
-import type { ImageContent } from "@gajae-code/ai";
+import { type ImageContent } from "@gajae-code/ai";
 import type { AgentSession } from "../session/agent-session";
 /**
  * Options for print mode.
@@ -26,6 +26,18 @@ export interface PrintModeOptions {
      */
     suppressProcessExit?: boolean;
 }
+/**
+ * Exit code used when a non-interactive **text-mode** run (`gjc -p`) terminates
+ * because the model context window is exhausted and automatic compaction could
+ * not bring the request under the limit. Distinct from the generic failure code
+ * (1) so text-mode callers can detect context exhaustion specifically instead of
+ * parsing the raw provider error string.
+ *
+ * Scope: text-mode final-response path only. JSON mode (`--mode json`) streams
+ * events from the subscription and does not run this terminal-error branch, so
+ * it is intentionally NOT covered by this exit code.
+ */
+export declare const CONTEXT_OVERFLOW_EXIT_CODE = 2;
 /**
  * Run in print (single-shot) mode.
  * Sends prompts to the agent and outputs the result.

package/dist/types/modes/prompt-action-autocomplete.d.ts

@@ -1,4 +1,4 @@
-import type { AutocompleteItem, AutocompleteProvider, SlashCommand } from "@gajae-code/tui";
+import { type AutocompleteItem, type AutocompleteProvider, type SlashCommand } from "@gajae-code/tui";
 import type { KeybindingsManager } from "../config/keybindings";
 interface PromptActionDefinition {
     id: string;

package/dist/types/modes/rpc/rpc-types.d.ts

@@ -12,6 +12,7 @@ import type { ContextUsage } from "../../extensibility/extensions/types";
 import type { SessionStats } from "../../session/agent-session";
 import type { TodoPhase } from "../../tools/todo-write";
 export type RpcGetStateInclude = "tools" | "dumpTools" | "systemPrompt";
+export type RpcCapability = "compact_message_update";
 export type RpcCommand = {
     id?: string;
     type: "prompt";
@@ -59,6 +60,10 @@ export type RpcCommand = {
 } | {
     id?: string;
     type: "get_pending_workflow_gates";
+} | {
+    id?: string;
+    type: "set_capabilities";
+    capabilities: RpcCapability[];
 } | {
     id?: string;
     type: "set_model";
@@ -258,6 +263,15 @@ export type RpcResponse = {
     data: {
         gates: RpcWorkflowGate[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_capabilities";
+    success: true;
+    data: {
+        acceptedCapabilities: RpcCapability[];
+        unsupported: string[];
+    };
 } | {
     id?: string;
     type: "response";

package/dist/types/modes/shared/agent-wire/event-contract.d.ts

@@ -13,6 +13,7 @@
  * an `AgentSessionEvent` variant fails typecheck until it is registered, and so
  * conformance tests can assert fixture coverage equals the registry exactly.
  */
+import type { AssistantMessageEvent } from "@gajae-code/ai";
 import type { AgentSessionEvent } from "../../../session/agent-session";
 /** Wire protocol version. Bump on breaking envelope/semantic changes. */
 export declare const AGENT_WIRE_PROTOCOL_VERSION: 2;
@@ -29,6 +30,23 @@ export interface AgentWireEventPayload {
     event_type: AgentWireEventType;
     event: AgentSessionEvent;
 }
+export type AgentWireCompactAssistantMessageEvent = AssistantMessageEvent extends infer TEvent ? TEvent extends {
+    type: string;
+} ? Omit<TEvent, "partial" | "message" | "error"> : never : never;
+export interface AgentWireCompactMessageUpdatePayload {
+    event_type: "message_update";
+    /** Compact RPC opt-in payload: delta-only update plus minimal routing metadata. */
+    compact: true;
+    message_id: string | null;
+    content_index: number | null;
+    assistantMessageEvent: AgentWireCompactAssistantMessageEvent;
+    /** Full message checkpoint, snapshotted synchronously when this frame is enqueued. */
+    checkpoint_message?: Extract<AgentSessionEvent, {
+        type: "message_update";
+    }>["message"];
+    checkpoint_reason?: "periodic";
+}
+export type AgentWireEventFramePayload = AgentWireEventPayload | AgentWireCompactMessageUpdatePayload;
 /**
  * Bounded observed-signal vocabulary surfaced to owner control planes. Mirrors
  * the Harness `ObservedSignal` set; the Harness type aliases this in a later
@@ -82,3 +100,4 @@ export interface AgentWireFrameEnvelope<TType extends AgentWireFrameType = Agent
 }
 /** An `AgentSessionEvent` serialized into a versioned wire frame. */
 export type AgentWireEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventPayload>;
+export type AgentWireCompactEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventFramePayload>;

package/dist/types/modes/shared/agent-wire/event-envelope.d.ts

@@ -1,5 +1,6 @@
 import type { AgentSessionEvent } from "../../../session/agent-session";
-import { type AgentWireEventFrame, type AgentWireEventPayload, type AgentWireEventType, type AgentWireFrameEnvelope, type AgentWireFrameType } from "./event-contract";
+import { type AgentWireCompactAssistantMessageEvent, type AgentWireCompactEventFrame, type AgentWireEventFrame, type AgentWireEventPayload, type AgentWireEventType, type AgentWireFrameEnvelope, type AgentWireFrameType } from "./event-contract";
+export declare const AGENT_WIRE_COMPACT_MESSAGE_UPDATE_CHECKPOINT_INTERVAL = 32;
 /**
  * Resolve the stable wire event-type for an `AgentSessionEvent`.
  *
@@ -27,6 +28,27 @@ export type BridgeFrameSequencer = AgentWireFrameSequencer;
 export declare function toAgentWireEventFrame(event: AgentSessionEvent, sequencer: AgentWireFrameSequencer): AgentWireEventFrame;
 /** Build the rich event payload (renderer-facing) for an `AgentSessionEvent`. */
 export declare function toAgentWireEventPayload(event: AgentSessionEvent): AgentWireEventPayload;
+export declare function sanitizeAssistantMessageEventForCompact(assistantMessageEvent: Extract<AgentSessionEvent, {
+    type: "message_update";
+}>["assistantMessageEvent"]): AgentWireCompactAssistantMessageEvent;
+export interface AgentWireCompactMessageUpdateOptions {
+    checkpointInterval?: number;
+}
+/**
+ * Stateful compact event serializer for opt-in RPC clients.
+ *
+ * Only `message_update` changes shape: it carries the immutable provider delta
+ * plus message/content identifiers, with periodic full-message checkpoints that
+ * are cloned synchronously before the caller returns to the event loop. All other
+ * event variants remain canonical full event frames so legacy bridge/RPC behavior
+ * and terminal `message_end` reconstruction are unchanged.
+ */
+export declare class AgentWireCompactEventEncoder {
+    #private;
+    constructor(sequencer: AgentWireFrameSequencer, options?: AgentWireCompactMessageUpdateOptions);
+    frame(event: AgentSessionEvent): AgentWireCompactEventFrame;
+}
+export declare function toAgentWireCompactEventFrame(event: AgentSessionEvent, encoder: AgentWireCompactEventEncoder): AgentWireCompactEventFrame;
 /** Back-compat alias for {@link toAgentWireEventFrame}. */
 export declare const toBridgeEventFrame: typeof toAgentWireEventFrame;
 /**

package/dist/types/modes/types.d.ts

@@ -198,6 +198,7 @@ export interface InteractiveModeContext {
     handleDumpCommand(): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleClearCommand(): Promise<void>;
+    handleContextClearCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -6,6 +6,7 @@ import type { SessionContext } from "../../session/session-manager";
 interface RenderInitialMessagesOptions {
     preserveExistingChat?: boolean;
 }
+export declare function argsWithPartialJson(args: unknown, partialJson: unknown): unknown;
 export declare class UiHelpers {
     #private;
     private ctx;

package/dist/types/notifications/config.d.ts

@@ -17,12 +17,24 @@ export interface NotificationConfig {
 }
 /** Read typed config from Settings. */
 export declare function getNotificationConfig(settings: Settings): NotificationConfig;
+export declare function hasNonBlankValue(value: string | undefined): boolean;
+/** Is Telegram configured with usable non-blank boundary credentials? */
+export declare function isTelegramConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+    botToken: string;
+    chatId: string;
+};
 /** Is global config sufficient for auto-on (enabled + at least one configured adapter)? */
 export declare function isGloballyConfigured(cfg: NotificationConfig): boolean;
 /** Resolve whether the notifications extension should be registered at SDK startup. */
 export declare function shouldRegisterNotificationsExtension(input: {
     env: NodeJS.ProcessEnv;
     cfg?: NotificationConfig;
+    /** Task recursion depth; helper/subagent sessions must not spawn remote surfaces. */
+    taskDepth?: number;
+    /** Parent subagent id/prefix; present for helper/subagent sessions even when depth is omitted. */
+    parentTaskPrefix?: string;
+    /** Role-agent type/name; present for task sessions even if depth metadata is lost. */
+    currentAgentType?: string;
 }): boolean;
 /**
  * Resolve whether THIS session should run notifications.
@@ -61,7 +73,8 @@ export interface RedactableAction {
  * When redact is false, return the action unchanged.
  *
  * Redaction still applies to streamed content frames (turn_stream, context_update,
- * image_attachment) which are suppressed at their emit sites, not here.
+ * image_attachment) which are suppressed at their emit sites, not here. Explicit
+ * `telegram_send` file attachments are rejected before the file is read or forwarded.
  */
 export declare function buildRedactedAction(action: RedactableAction, opts: {
     redact: boolean;

package/dist/types/notifications/daemon-paths.d.ts

@@ -5,5 +5,6 @@ export interface DaemonPaths {
     roots: string;
     steal: string;
     aliases: string;
+    seenUpdates: string;
 }
 export declare function daemonPaths(agentDir: string): DaemonPaths;

package/dist/types/notifications/index.d.ts

@@ -17,7 +17,8 @@
  * Enable with Settings notifications config, `GJC_NOTIFICATIONS=1` (a token is
  * generated), or `GJC_NOTIFICATIONS_TOKEN`.
  */
-import type { ExtensionFactory } from "../extensibility/extensions";
+import { Settings } from "../config/settings";
+import type { ExtensionAPI } from "../extensibility/extensions";
 /** Where a `session_create` should run. Discriminated by `kind`. */
 export type SessionCreateTarget = {
     kind: "existing_path";
@@ -69,7 +70,7 @@ export interface SessionCloseFrame {
     chatId: string;
     token: string;
     target: SessionCloseTarget;
-    /** Hard-kill even if a live pane is attached (GJC-managed only). */
+    /** Required force-only close flag; false/omitted is rejected by daemon policy. */
     force?: boolean;
 }
 /** Resume a session (reattach if alive, else cold-restart from history). */
@@ -173,4 +174,6 @@ export interface SessionReadyFrame {
  */
 export declare function readGitRepoName(cwd: string): string | undefined;
 export declare function notificationsEnabled(): boolean;
-export declare const createNotificationsExtension: ExtensionFactory;
+export declare function createNotificationsExtension(api: ExtensionAPI, options?: {
+    settings?: Settings;
+}): void;

package/dist/types/notifications/lifecycle-commands.d.ts

@@ -23,8 +23,13 @@ export type ParsedLifecycleCommand = {
 } | {
     kind: "none";
 };
-/** True when the text begins a /session_* command (cheap pre-gate). */
-export declare function isLifecycleCommandText(text: string | undefined): boolean;
+/** True when the text begins with any /session_* token, regardless of addressability. */
+export declare function isLifecycleCommandLikeText(text: string | undefined): boolean;
+/** True when the text begins an addressable /session_* command (cheap pre-gate). */
+export declare function isLifecycleCommandText(text: string | undefined, ctx?: {
+    chatType?: string;
+    botUsername?: string;
+}): boolean;
 /**
  * Parse a paired-chat message into a lifecycle command. Returns `none` for
  * non-lifecycle text, `usage`/`reject` for malformed input (no side effect), or
@@ -33,7 +38,10 @@ export declare function isLifecycleCommandText(text: string | undefined): boolea
  * The caller MUST have already enforced paired-chat authorization; this function
  * performs grammar + target validation only.
  */
-export declare function parseLifecycleCommand(text: string | undefined): ParsedLifecycleCommand;
+export declare function parseLifecycleCommand(text: string | undefined, ctx?: {
+    chatType?: string;
+    botUsername?: string;
+}): ParsedLifecycleCommand;
 /** The canonical usage text (exported for the daemon's help replies). */
 export declare function lifecycleUsage(): string;
 /**

package/dist/types/notifications/telegram-daemon.d.ts

@@ -3,8 +3,8 @@ import type { Settings } from "../config/settings";
 import type { DaemonRuntimeInfo } from "../daemon/control-types";
 import { type ControlServerLike, type LifecycleControlServerFactory } from "./lifecycle-control-runtime";
 import { NotificationOperatorRuntime, OperatorBackoffPolicy } from "./operator-runtime";
-import { type AliasTable, type CallbackRoute, type PendingAsk } from "./telegram-reference";
-export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled";
+import { type AliasTable, type CallbackRoute } from "./telegram-reference";
+export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled" | "blocked";
 export interface DaemonState {
     pid: number;
     ownerId: string;
@@ -95,6 +95,8 @@ export declare function acquireDaemonOwnership(input: {
     acquired: boolean;
     ownerId?: string;
     attached?: boolean;
+    blocked?: boolean;
+    reason?: "identity_mismatch";
 }>;
 export declare function renewDaemonHeartbeat(input: {
     settings: Settings;
@@ -252,6 +254,8 @@ export declare class TelegramNotificationDaemon {
     private readonly opts;
     readonly aliasTable: AliasTable;
     readonly messageRoutes: Map<string | number, CallbackRoute | Omit<CallbackRoute, "answer">>;
+    /** Telegram message id backing each streamed `${sessionId}:${coalesceKey}`, for in-place edits. */
+    private readonly liveMessages;
     readonly sessions: Map<string, SessionSocket>;
     private readonly runtime;
     private readonly sessionRouter;
@@ -276,6 +280,8 @@ export declare class TelegramNotificationDaemon {
     private readonly flatIdentitySent;
     /** Cached result of whether the paired chat is a private chat (flat-fallback gate). */
     private pairedChatPrivate;
+    /** Bot username from getMe, cached once at owner startup for group/forum command targeting. */
+    private botUsername;
     /** Sessions whose agent loop is currently busy (drives the typing indicator). */
     private get busy();
     /** Inbound update id → originating Telegram message, for delivery reactions. */
@@ -317,12 +323,17 @@ export declare class TelegramNotificationDaemon {
     /** Build an authenticated lifecycle frame from a parsed command + identity. */
     private buildLifecycleFrame;
     private handleLifecycleCommand;
+    private refreshBotIdentity;
     /** Map a lifecycle response/error to a user-facing message (G010 surfacing). */
     private formatLifecycleResponse;
     constructor(opts: TelegramDaemonOptions);
     private createSessionRouter;
     loadAliases(): Promise<void>;
     persistAliases(): Promise<void>;
+    loadSeenUpdateIds(): Promise<void>;
+    persistSeenUpdateIds(): Promise<void>;
+    private pruneSeenUpdateIds;
+    private rememberSeenUpdateId;
     scanRoots(): Promise<void>;
     connectSession(sessionId: string, url: string, token: string): void;
     /**
@@ -340,12 +351,15 @@ export declare class TelegramNotificationDaemon {
      * the socket. `scanRoots()` then reconnects the session.
      */
     private dropSession;
+    private deleteMessageRoutes;
     private static readonly THREADED_FRAMES;
     private topicNameFor;
     private topicIdentityKey;
     private topicIdentityBase;
     private topicOwnerForIdentity;
+    private sessionCanClaimIdentity;
     private submitThreadedFrame;
+    private existingTopicForPrivateChat;
     private rememberPendingThreadedFrame;
     private flushPendingThreadedFrames;
     private ensureTopic;
@@ -363,6 +377,12 @@ export declare class TelegramNotificationDaemon {
     private cleanupAllAttachmentDirs;
     private resolveInboundAttachment;
     private flushPool;
+    /**
+     * Track the Telegram message id backing a streamed `(sessionId, coalesceKey)`
+     * so later live/finalized frames edit it in place. Evicts this session's stale
+     * same-category entries (e.g. prior turns) so the map stays bounded.
+     */
+    private recordLiveMessage;
     private deliverFlatFallback;
     private pairedChatIsPrivate;
     private notifyThreadedFallback;
@@ -376,7 +396,7 @@ export declare class TelegramNotificationDaemon {
     private startTypingTimer;
     private stopTypingTimer;
     handleSessionMessage(session: SessionSocket, msg: any): Promise<void>;
-    pendingBySession: (sessionId?: string) => PendingAsk[];
+    private answerCallbackQueryBestEffort;
     private sendStaleGuidance;
     handleTelegramUpdate(update: unknown): Promise<void>;
     pollOnce(signal?: AbortSignal): Promise<number>;

package/dist/types/notifications/telegram-reference.d.ts

@@ -81,14 +81,9 @@ export type RouteDecision = ({
 } | {
     kind: "ignore";
 };
-export interface PendingAsk {
-    sessionId: string;
-    actionId: string;
-}
 export interface RouteInboundContext {
     aliasTable: Pick<AliasTable, "get">;
     messageRoutes: Map<string | number, CallbackRoute | Omit<CallbackRoute, "answer">>;
-    pendingBySession: (sessionId?: string) => PendingAsk[];
     pairedChatId: string;
 }
 /** Route a Telegram update to a session/action without I/O. Fail closed under ambiguity. */

package/dist/types/notifications/threaded-render.d.ts

@@ -28,6 +28,12 @@ export interface ThreadedSend {
     coalesceKey?: string;
     /** True for the one-time identity header (the daemon pins it once). */
     identity?: boolean;
+    /**
+     * When true the daemon may deliver this as an in-place edit of the message
+     * previously sent under the same `(sessionId, coalesceKey)` instead of a new
+     * message. Set for streamed turn frames so live + finalized share one message.
+     */
+    editable?: boolean;
 }
 interface ThreadedFrame {
     type?: unknown;

package/dist/types/runtime-api-key.d.ts

@@ -0,0 +1,7 @@
+export interface RuntimeApiKeyTarget {
+    setRuntimeApiKey(provider: string, apiKey: string): void;
+}
+export interface RuntimeApiKeyModel {
+    provider: string;
+}
+export declare function applyCliRuntimeApiKeyOverride(target: RuntimeApiKeyTarget, apiKey: string | undefined, model: RuntimeApiKeyModel | undefined): void;

package/dist/types/sdk.d.ts

@@ -1,5 +1,6 @@
 import { type AgentTelemetryConfig, type ThinkingLevel } from "@gajae-code/agent-core";
 import { type Model, type ProviderSessionState } from "@gajae-code/ai";
+import { createAppendOnlyContextManager, providerSupportsAppendOnlyAuto, resolveAppendOnlyMode } from "./append-only-mode";
 import { type Rule } from "./capability/rule";
 import { ModelRegistry } from "./config/model-registry";
 import { type ScopedModelSelection } from "./config/model-resolver";
@@ -241,5 +242,7 @@ export interface BuildSystemPromptOptions {
  * as separate entries so providers can cache prompt prefixes without concatenating blocks.
  */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+export { createAppendOnlyContextManager, providerSupportsAppendOnlyAuto, resolveAppendOnlyMode };
 export declare function createPluginHooksExtension(hooks: ConstrainedPluginHook[]): ExtensionFactory;
+export declare function resolveIntentTracingEnabled(intentTracingSetting: boolean | undefined, hasUI: boolean): boolean;
 export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;

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

@@ -14,7 +14,7 @@
  */
 import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type StablePrefixSnapshot, ThinkingLevel } from "@gajae-code/agent-core";
 import { type CompactionResult, type EmergencyCompactionSample } from "@gajae-code/agent-core/compaction";
-import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@gajae-code/ai";
+import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolCall, ToolChoice, UsageReport } from "@gajae-code/ai";
 export interface ForkContextSeedMetadata {
     sourceSessionId: string;
     parentMessageCount: number;
@@ -75,6 +75,7 @@ import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool
 import type { AskAnswerSource, ToolSession } from "../tools";
 import type { CheckpointState } from "../tools/checkpoint";
 import { type TodoItem, type TodoPhase } from "../tools/todo-write";
+import { type WorkspaceTree } from "../workspace-tree";
 import type { ClientBridge } from "./client-bridge";
 import { type ContributionPrepOptions, type ContributionPrepResult } from "./contribution-prep";
 import { type CustomMessage } from "./messages";
@@ -200,6 +201,8 @@ export interface AgentSessionConfig {
     rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{
         systemPrompt: string[];
     }>;
+    /** Initial workspace tree snapshot used for the first volatile per-turn context message. */
+    workspaceTree?: WorkspaceTree;
     /** Rebuild the SSH tool from current capability discovery results. */
     reloadSshTool?: () => Promise<AgentTool | null>;
     requestedToolNames?: ReadonlySet<string>;
@@ -317,6 +320,13 @@ export interface SessionStats {
     premiumRequests: number;
     cost: number;
 }
+export type QueuedMessageEditMode = "steer" | "followUp";
+export interface QueuedMessageEditEntry {
+    id: string;
+    text: string;
+    mode: QueuedMessageEditMode;
+    label: string;
+}
 /** A custom message contributed at the before-agent-start point. */
 export type BeforeAgentStartInternalMessage = Pick<CustomMessage, "customType" | "content" | "display" | "details" | "attribution">;
 /**
@@ -329,6 +339,33 @@ export type BeforeAgentStartContributor = (event: {
     images?: ImageContent[];
     sessionId: string | undefined;
 }) => Promise<BeforeAgentStartInternalMessage | undefined>;
+export declare class WorkerIntegrationRequestScheduler {
+    #private;
+    readonly request: () => Promise<void>;
+    constructor(request: () => Promise<void>);
+    enqueue(): void;
+    flush(): Promise<void>;
+}
+export type StreamingEditParsedToolCall = {
+    toolCall: ToolCall;
+    path: string;
+    resolvedPath: string;
+    diff?: string;
+    op?: string;
+    rename?: string;
+};
+export type StreamingEditParsedCacheEntry = {
+    version: string;
+    parsed: StreamingEditParsedToolCall | undefined;
+};
+export declare function getStreamingEditToolCallForEvent(event: AgentEvent, cache: Map<string, StreamingEditParsedCacheEntry>, resolvePath: (filePath: string) => string | undefined): StreamingEditParsedToolCall | undefined;
+/** Test-only counters for AgentSession event fan-out hot-path assertions. */
+export declare const __agentSessionPerfCounters: {
+    listenerSnapshotRebuilds: number;
+    messageUpdateExtensionQueues: number;
+    reset(): void;
+};
+export declare function buildContextInjectionSignature(kind: string, parts: readonly string[]): string;
 export declare class AgentSession {
     #private;
     readonly agent: Agent;
@@ -337,6 +374,13 @@ export declare class AgentSession {
     readonly taskDepth: number;
     readonly yieldQueue: YieldQueue;
     readonly configWarnings: string[];
+    readonly streamingEditDebugCounters: {
+        guardRuns: number;
+        processedChars: number;
+        checkedRemovedLines: number;
+        fullChecks: number;
+        nonEditDeterminations: number;
+    };
     readonly rawSseDebugBuffer: RawSseDebugBuffer;
     constructor(config: AgentSessionConfig);
     /** Model registry for API key resolution and model discovery */
@@ -670,6 +714,9 @@ export declare class AgentSession {
         steering: readonly string[];
         followUp: readonly string[];
     };
+    getQueuedMessageEntries(): QueuedMessageEditEntry[];
+    removeQueuedMessageForEditing(id: string): string | undefined;
+    moveQueuedMessageForEditing(id: string, direction: "up" | "down"): boolean;
     /**
      * Pop the newest queued message across steering and follow-up queues.
      * Used by dequeue keybinding to restore messages to editor one at a time.
@@ -706,6 +753,11 @@ export declare class AgentSession {
      * @returns true if completed, false if cancelled by hook
      */
     newSession(options?: NewSessionOptions): Promise<boolean>;
+    /**
+     * Clear active conversational/model context while preserving the current
+     * session identity and durable history trail.
+     */
+    clearContext(): Promise<boolean>;
     /**
      * Set a display name for the current session.
      */

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

@@ -93,6 +93,7 @@ export declare class AgentStorage {
      * Sets a cached value with expiry time (unix seconds).
      */
     setCache(key: string, value: string, expiresAtSec: number): void;
+    deleteCachePrefix(prefix: string): void;
     /**
      * Deletes expired cache entries. Call periodically for cleanup.
      */

package/dist/types/session/file-mention-pruning.d.ts

@@ -0,0 +1,8 @@
+import type { SessionEntry, SessionMessageEntry } from "./session-manager";
+export interface FileMentionPruneResult {
+    changed: SessionMessageEntry[];
+    bytesSaved: number;
+}
+/** Notice injected in place of a superseded file-mention body. */
+export declare function stalefileMentionNotice(path: string): string;
+export declare function pruneStaleFileMentions(entries: readonly SessionEntry[], resolveAbs: (path: string) => string): FileMentionPruneResult;

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

@@ -129,6 +129,10 @@ export interface FileMentionMessage {
         /** Why the file contents were omitted from auto-read. */
         skippedReason?: "tooLarge";
         image?: ImageContent;
+        /** Set when this mention duplicated a recently shown path (compact note, no full body). */
+        duplicate?: boolean;
+        /** Set when a stale entry was pruned to a digest notice (never silently deleted). */
+        pruned?: boolean;
     }>;
     timestamp: number;
 }

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

@@ -1,5 +1,6 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent } from "@gajae-code/ai";
+import type { TtsrInjectionRecord } from "../export/ttsr";
 import { ArtifactManager } from "./artifacts";
 import { type BlobPutResult, BlobStore } from "./blob-store";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
@@ -141,6 +142,10 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
     type: "ttsr_injection";
     /** Names of rules that were injected */
     injectedRules: string[];
+    /** Rich rule injection records with repeat state. */
+    injectedRuleRecords?: TtsrInjectionRecord[];
+    /** TTSR manager message count when this injection was recorded. */
+    ttsrMessageCount?: number;
 }
 /** Persisted MCP discovery selection state for a session branch. */
 export interface MCPToolSelectionEntry extends SessionEntryBase {
@@ -212,6 +217,10 @@ export interface SessionContext {
     models: Record<string, string>;
     /** Names of TTSR rules that have been injected this session */
     injectedTtsrRules: string[];
+    /** Rich TTSR rule injection records for repeat resume. */
+    injectedTtsrRuleRecords?: TtsrInjectionRecord[];
+    /** TTSR manager message count for repeat resume. */
+    ttsrMessageCount?: number;
     /** MCP tool names selected through discovery for this session branch. */
     selectedMCPToolNames: string[];
     /** Whether this branch contains an explicit persisted MCP selection entry. */
@@ -477,6 +486,13 @@ export declare class SessionManager {
     appendCompaction<T = unknown>(summary: string, shortSummary: string | undefined, firstKeptEntryId: string, tokensBefore: number, details?: T, fromExtension?: boolean, preserveData?: Record<string, unknown>): string;
     /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
     appendCustomEntry(customType: string, data?: unknown): string;
+    /**
+     * Append a root marker that starts a fresh active branch without changing the
+     * session id or deleting earlier durable entries. Subsequent messages descend
+     * from this marker, so provider context is clear while history remains
+     * available for diagnostics/export.
+     */
+    appendContextClearEntry(data?: Record<string, unknown>): string;
     /**
      * Write mutated message entries back into the canonical entry store by id.
      *
@@ -511,7 +527,7 @@ export declare class SessionManager {
      * @param ruleNames Names of rules that were injected
      * @returns Entry id
      */
-    appendTtsrInjection(ruleNames: string[]): string;
+    appendTtsrInjection(ruleNames: string[], records?: TtsrInjectionRecord[], ttsrMessageCount?: number): string;
     /**
      * Get all unique TTSR rule names that have been injected in the current branch.
      * Scans from root to current leaf for ttsr_injection entries.