@gajae-code/coding-agent 0.7.3 → 0.7.5

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

@@ -0,0 +1,144 @@
+import type { LifecycleErrorReason, ResumeCandidate, SessionCreateFrame, SessionLifecycleRequest } from "./index";
+/** Durable idempotency state for a single lifecycle request. */
+export type LedgerState = "in_progress" | "success" | "failure" | "terminal_uncertain";
+/** One persisted idempotency entry, keyed by `chatId:updateId`. */
+export interface LedgerEntry {
+    requestHash: string;
+    state: LedgerState;
+    requestId: string;
+    verb: SessionLifecycleRequest["type"];
+    intendedSessionId?: string;
+    startupPromptRef?: string;
+    createdAt: number;
+    updatedAt: number;
+    targetSummary: Record<string, unknown>;
+    sessionId?: string;
+    tmuxSession?: string;
+    sessionStateFile?: string;
+    endpointUrl?: string;
+    /** Close effect outcome: whether the tmux process is confirmed gone. */
+    processGone?: boolean;
+    reason?: LifecycleErrorReason;
+}
+/** The full on-disk ledger document. */
+export interface LedgerDoc {
+    version: 1;
+    entries: Record<string, LedgerEntry>;
+}
+/** Persistence boundary: atomic + fsynced read/write of the ledger document. */
+export interface LedgerStore {
+    read(): Promise<LedgerDoc>;
+    /** Write atomically (temp + fsync + rename) under a per-ledger lock. */
+    write(doc: LedgerDoc): Promise<void>;
+}
+/** One audit line. Tokens and raw prompts are NEVER included. */
+export interface AuditEvent {
+    ts: string;
+    event: "accepted" | "rejected" | "duplicate_reack" | "rate_limited" | "spawn_started" | "recovered_in_progress" | "success" | "failure" | "terminal_uncertain";
+    chatId: string;
+    updateId: number;
+    requestId: string;
+    requestHash: string;
+    verb: SessionLifecycleRequest["type"];
+    targetSummary: Record<string, unknown>;
+    sessionId?: string;
+    tmuxSession?: string;
+    reason?: LifecycleErrorReason;
+    /** Prompt byte length only (never the prompt text). */
+    promptBytes?: number;
+    /** Prompt content hash only (never the prompt text). */
+    promptHash?: string;
+}
+export interface CreateEffectResult {
+    sessionId: string;
+    tmuxSession: string;
+    sessionStateFile?: string;
+    endpointUrl: string;
+    topicThreadId: string;
+}
+export interface ResumeEffectResult extends CreateEffectResult {
+    mode: "reattached" | "cold_restarted";
+}
+/** Injected effects + policy. Pure orchestration calls into these. */
+export interface OrchestratorDeps {
+    /** The single paired chat id. Anything else is rejected before parsing. */
+    pairedChatId: string;
+    now: () => number;
+    store: LedgerStore;
+    audit: (event: AuditEvent) => Promise<void> | void;
+    /** Per-chat create rate limiter: returns true when allowed. */
+    allowCreate: (chatId: string, nowMs: number) => boolean;
+    /** Persist the once-consumed 0600 startup-prompt file; returns its ref. */
+    writeStartupPrompt: (requestId: string, prompt: string | undefined) => Promise<string | undefined>;
+    /** Spawn a session for a create/cold-restart. */
+    spawnCreate: (frame: SessionCreateFrame, ids: {
+        lifecycleRequestId: string;
+        intendedSessionId: string;
+        startupPromptRef?: string;
+    }) => Promise<CreateEffectResult>;
+    closeSession: (target: {
+        sessionId: string;
+        tmuxSession?: string;
+        sessionStateFile?: string;
+    }) => Promise<{
+        processGone: boolean;
+    }>;
+    resumeSession: (target: {
+        sessionIdOrPrefix: string;
+        path?: string;
+    }) => Promise<ResumeEffectResult | {
+        ambiguous: ResumeCandidate[];
+    } | {
+        notFound: true;
+    }>;
+    newLifecycleRequestId: () => string;
+    newSessionId: () => string;
+}
+/** A redaction-safe summary of a request target (never includes the token). */
+export declare function summarizeTarget(frame: SessionLifecycleRequest): Record<string, unknown>;
+/**
+ * Stable request hash over the meaningful (non-token) request content. Used to
+ * detect a duplicate update id reused with a DIFFERENT body (conflict).
+ */
+export declare function requestHash(frame: SessionLifecycleRequest): string;
+export declare function ledgerKey(chatId: string, updateId: number): string;
+/** How a freshly-arrived request relates to the durable ledger. */
+export type DuplicateClass = {
+    kind: "new";
+} | {
+    kind: "reack_success";
+    entry: LedgerEntry;
+} | {
+    kind: "reack_failure";
+    entry: LedgerEntry;
+} | {
+    kind: "in_progress";
+    entry: LedgerEntry;
+} | {
+    kind: "terminal_uncertain";
+    entry: LedgerEntry;
+} | {
+    kind: "conflict";
+    entry: LedgerEntry;
+};
+/** Classify a request against an existing ledger entry (pure). */
+export declare function classifyDuplicate(existing: LedgerEntry | undefined, hash: string): DuplicateClass;
+/** The structured outcome the daemon translates into a wire response frame. */
+export type LifecycleOutcome = {
+    status: "ok";
+    entry: LedgerEntry;
+    mode?: "reattached" | "cold_restarted";
+} | {
+    status: "error";
+    reason: LifecycleErrorReason;
+    message: string;
+    candidates?: ResumeCandidate[];
+} | {
+    status: "pending";
+    entry: LedgerEntry;
+};
+/**
+ * Handle one authenticated lifecycle request. Enforces paired-chat gating,
+ * idempotency, and rate limiting BEFORE any side effect, then dispatches.
+ */
+export declare function handleLifecycleRequest(frame: SessionLifecycleRequest, deps: OrchestratorDeps): Promise<LifecycleOutcome>;

package/dist/types/notifications/rate-limit-pool.d.ts

@@ -81,6 +81,8 @@ export declare class RateLimitPool<T = unknown> {
      * single session monopolises a lane), consuming one token each.
      */
     drain(nowMs?: number): RateLimitItem<T>[];
+    /** Remove queued items matching `predicate` without consuming tokens. Returns removed items in lane/FIFO order. */
+    removeWhere(predicate: (item: RateLimitItem<T>) => boolean): RateLimitItem<T>[];
     private refill;
     /** Pop the next item by lane priority + per-session round-robin fairness. */
     private takeNext;

package/dist/types/notifications/recent-activity.d.ts

@@ -0,0 +1,35 @@
+/** One ranked recent-session entry surfaced to the picker. */
+export interface RecentSessionEntry {
+    /** Session id (the `.jsonl` file stem). */
+    sessionId: string;
+    /** Working directory / repo path, when recoverable from the header. */
+    path?: string;
+    /** Branch, when recoverable from the header. */
+    branch?: string;
+    /** A short title (first user message), when recoverable. */
+    title?: string;
+    /** Absolute path of the session history (state) file. */
+    sessionStateFile: string;
+    /** Last-activity epoch-millis (history file mtime). */
+    mtimeMs: number;
+    /** True when a terminal breadcrumb points at this session file. */
+    currentTerminal?: boolean;
+}
+export interface RecentActivityDeps {
+    /** Root holding `<encoded-cwd>/<sessionId>.jsonl` history files. */
+    sessionsRoot: string;
+    /** Optional breadcrumb session-file paths (current terminals). */
+    breadcrumbPaths?: string[];
+    /** Max entries to return (default 20). */
+    limit?: number;
+    /** Injection seam for tests. */
+    readFirstLine?: (file: string) => string | undefined;
+}
+/**
+ * List recent sessions ranked by history-file mtime (newest first).
+ *
+ * Scans `<sessionsRoot>/<encoded-cwd>/<sessionId>.jsonl`, stats each file, and
+ * returns up to `limit` entries enriched with header metadata and a
+ * `currentTerminal` flag for any breadcrumb-referenced session file.
+ */
+export declare function listRecentSessions(deps: RecentActivityDeps): RecentSessionEntry[];

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

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 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";
@@ -59,6 +60,22 @@ export declare const CLIENT_PING_PONG_CAPABILITY = "client_ping_pong";
 /** Protocol version the daemon advertises in its ClientHello. */
 export declare const NOTIFICATION_PROTOCOL_VERSION = 2;
 export declare function daemonPaths(agentDir: string): DaemonPaths;
+/**
+ * Attach session-lifecycle control (create/close/resume) to the running daemon.
+ *
+ * Wires an already-started, authenticated control server to the lifecycle
+ * orchestrator with real daemon-side effects (tmux launcher / force-close /
+ * resume), a durable fsynced idempotency ledger + audit JSONL under the agent
+ * notifications dir, and strict paired-chat gating. The control server itself
+ * (NotificationControlServer) is owned/started by the daemon process; this
+ * function only connects it to policy. Returns the orchestrator deps for tests.
+ */
+export declare function startDaemonLifecycleControl(input: {
+    controlServer: ControlServerLike;
+    pairedChatId: string;
+    agentDir: string;
+    env?: NodeJS.ProcessEnv;
+}): void;
 export declare function registerNotificationRoot(input: {
     settings: Settings;
     cwd: string;
@@ -209,8 +226,17 @@ export interface TelegramDaemonOptions {
     idleTimeoutMs?: number;
     scanIntervalMs?: number;
     pid?: number;
+    /** Liveness probe for skipping dead-PID endpoint records in {@link TelegramNotificationDaemon.scanRoots}. */
+    pidAlive?: (pid: number) => boolean;
     botApi?: BotApi;
     control?: DaemonControlHooks;
+    /**
+     * Factory for the session-lifecycle control server. Defaults to the real
+     * native NotificationControlServer; tests inject a fake to verify the
+     * owner-bound start/stop lifecycle without a socket. When `undefined` AND no
+     * default applies (e.g. lifecycle control disabled), no control server starts.
+     */
+    createLifecycleControlServer?: LifecycleControlServerFactory | null;
 }
 interface SessionSocket {
     sessionId: string;
@@ -259,12 +285,45 @@ export declare class TelegramNotificationDaemon {
     private get busy();
     /** Inbound update id → originating Telegram message, for delivery reactions. */
     private get inboundReactions();
+    /**
+     * The owner-bound session-lifecycle control server (create/close/resume).
+     * Started in {@link run} after ownership is confirmed (so exactly one owner
+     * ever runs one), stopped in run()'s finally on any exit path.
+     */
+    private controlServer;
+    /** True while lifecycle control is active, so the loop keeps polling at idle. */
+    private lifecycleControlActive;
+    /** Control token (in-memory) the loopback client presents; never persisted/logged. */
+    private controlToken;
+    /** Loopback WS client to the daemon's own control endpoint (Option A real wire path). */
+    private controlClient;
+    /** Pending lifecycle responses awaiting a control-endpoint reply, by requestId. */
+    private readonly pendingLifecycle;
+    /** Monotonic counter for unique lifecycle request ids. */
+    private lifecycleSeq;
     /**
      * Cooperatively stop the daemon: set the stop flag and abort the in-flight
      * long poll so the run loop wakes immediately instead of waiting out the
      * ~25s getUpdates timeout. Safe to call from a signal handler.
      */
     requestStop(_reason?: "reload" | "stop" | "signal"): void;
+    private startLifecycleControl;
+    /** Stop the lifecycle control server (idempotent); called from run()'s finally. */
+    private stopLifecycleControl;
+    /**
+     * Connect the loopback control client and resolve responses by requestId.
+     * Resolves true once the socket is OPEN (bounded), false on error/timeout, so
+     * the caller only marks lifecycle control active when commands can be sent.
+     */
+    private connectControlClient;
+    /** Send a lifecycle frame over the loopback client and await the response. */
+    private submitLifecycleFrame;
+    private nextLifecycleRequestId;
+    /** Build an authenticated lifecycle frame from a parsed command + identity. */
+    private buildLifecycleFrame;
+    private handleLifecycleCommand;
+    /** Map a lifecycle response/error to a user-facing message (G010 surfacing). */
+    private formatLifecycleResponse;
     constructor(opts: TelegramDaemonOptions);
     private createSessionRouter;
     loadAliases(): Promise<void>;
@@ -295,6 +354,7 @@ export declare class TelegramNotificationDaemon {
     private rememberPendingThreadedFrame;
     private flushPendingThreadedFrames;
     private ensureTopic;
+    private deleteTopic;
     private persistTopics;
     loadTopics(): Promise<void>;
     private downloadTelegramFile;

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

@@ -90,10 +90,12 @@ export interface RouteInboundContext {
 }
 /** Route a Telegram update to a session/action without I/O. Fail closed under ambiguity. */
 export declare function routeInboundUpdate(update: unknown, ctx: RouteInboundContext): RouteDecision;
-/** Read `{url, token}` from an endpoint discovery file. */
+/** Read `{url, token, pid?, stale?}` from an endpoint discovery file. */
 export declare function readEndpoint(path: string): {
     url: string;
     token: string;
+    pid?: number;
+    stale?: boolean;
 };
 /** Options for {@link runTelegramReferenceClient}. */
 export interface TelegramReferenceOptions {

package/dist/types/notifications/topic-registry.d.ts

@@ -1,11 +1,11 @@
 /**
  * Per-session forum-topic registry for the threaded session surface.
  *
- * Each GJC session owns exactly one Telegram forum topic in the paired private
- * DM. The topic is created once (via `createForumTopic`) and REUSED on resume,
- * keyed by session id, so a resumed session streams back into its existing
- * thread/history. The registry also tracks whether the one-time identity header
- * has already been pinned, so it is sent exactly once per topic even across
+ * Each GJC session owns one active Telegram forum topic in the paired private
+ * DM. The topic is created via `createForumTopic`, reused while the session
+ * remains active, and removed from the registry when the daemon deletes it on
+ * shutdown. The registry also tracks whether the one-time identity header has
+ * already been pinned, so it is sent exactly once per active topic, even across
  * reconnects.
  *
  * State is a plain serialisable map persisted beside the daemon state files;
@@ -50,11 +50,10 @@ export declare class TopicRegistry {
     /** The existing topic record for a session, if any. */
     get(sessionId: string): TopicRecord | undefined;
     /**
-     * Return the existing topic for `sessionId`, or create one via `create`
-     * (called only on first use). Reuse-on-resume: an existing record is
-     * returned without invoking `create`.
+     * Return the existing active topic for `sessionId`, or create one via
+     * `create` (called only on first use).
      */
-    getOrCreateTopic(sessionId: string, create: () => Promise<string>, now?: () => number): Promise<TopicRecord>;
+    getOrCreateTopic(sessionId: string, create: () => Promise<string>, now?: () => number, name?: string): Promise<TopicRecord>;
     /** Mark the identity header as sent for a session. Idempotent. */
     markIdentitySent(sessionId: string): void;
     /** Whether the identity header still needs sending for this session. */
@@ -64,6 +63,8 @@ export declare class TopicRegistry {
      * caller should `editForumTopic`), `false` when already current or unknown.
      */
     applyName(sessionId: string, name: string): boolean;
+    /** Remove a session topic record after Telegram deletes the topic. */
+    delete(sessionId: string): boolean;
     /** Serialise for atomic persistence beside the daemon state. */
     serialize(): TopicRegistryState;
 }

package/dist/types/runtime-mcp/types.d.ts

@@ -64,6 +64,13 @@ export interface MCPStdioServerConfig extends MCPServerConfigBase {
     command: string;
     args?: string[];
     env?: Record<string, string>;
+    /**
+     * When true, the child process is NOT given the host environment. Only a
+     * minimal OS allowlist (PATH/HOME/temp/locale) plus any explicit `env` keys
+     * are passed. Used for third-party plugin-bundle MCP servers so they cannot
+     * read host secrets from the inherited environment.
+     */
+    noInheritEnv?: boolean;
     cwd?: string;
 }
 /** HTTP server configuration (Streamable HTTP transport) */

package/dist/types/sdk.d.ts

@@ -10,6 +10,7 @@ import "./discovery";
 import type { CustomCommandsLoadResult } from "./extensibility/custom-commands";
 import type { CustomTool } from "./extensibility/custom-tools/types";
 import { type ExtensionFactory, type ExtensionUIContext, type LoadExtensionsResult, type ToolDefinition } from "./extensibility/extensions";
+import { type ConstrainedPluginHook } from "./extensibility/gjc-plugins/constrained-hooks";
 import { type Skill, type SkillWarning } from "./extensibility/skills";
 import type { FileSlashCommand } from "./extensibility/slash-commands";
 import type { HindsightSessionState } from "./hindsight/state";
@@ -240,4 +241,5 @@ export interface BuildSystemPromptOptions {
  * as separate entries so providers can cache prompt prefixes without concatenating blocks.
  */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+export declare function createPluginHooksExtension(hooks: ConstrainedPluginHook[]): ExtensionFactory;
 export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;

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

@@ -69,6 +69,7 @@ import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-
 import type { PlanModeState } from "../plan-mode/state";
 import { type AgentRegistry } from "../registry/agent-registry";
 import { type DiscoverableMCPSearchIndex, type DiscoverableMCPTool } from "../runtime-mcp/discoverable-tool-metadata";
+import { MCPManager } from "../runtime-mcp/manager";
 import { type SecretObfuscator } from "../secrets/obfuscator";
 import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
 import type { AskAnswerSource, ToolSession } from "../tools";
@@ -77,7 +78,7 @@ import { type TodoItem, type TodoPhase } from "../tools/todo-write";
 import type { ClientBridge } from "./client-bridge";
 import { type ContributionPrepOptions, type ContributionPrepResult } from "./contribution-prep";
 import { type CustomMessage } from "./messages";
-import type { BranchSummaryEntry, NewSessionOptions, SessionContext, SessionManager } from "./session-manager";
+import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, SessionContext, SessionManager } from "./session-manager";
 import { ToolChoiceQueue } from "./tool-choice-queue";
 import { YieldQueue } from "./yield-queue";
 /** Session-specific events that extend the core AgentEvent */
@@ -233,6 +234,13 @@ export interface AgentSessionConfig {
      * **MUST NOT** dispose it on their own teardown.
      */
     ownedAsyncJobManager?: AsyncJobManager;
+    /**
+     * MCPManager whose lifecycle this session owns (top-level sessions that
+     * connected plugin-bundle MCP servers). Only the owned manager is
+     * disconnected on dispose; subagents and callers that merely observe the
+     * process-global manager **MUST NOT** dispose it on their own teardown.
+     */
+    ownedMcpManager?: MCPManager;
     /** Optional fork-context seed used to initialize a child session before its first prompt. */
     forkContextSeed?: ForkContextSeed;
     /** Optional provider state override. Fork-context children should omit this by default. */
@@ -676,6 +684,7 @@ export declare class AgentSession {
     get skillWarnings(): readonly SkillWarning[];
     getTodoPhases(): TodoPhase[];
     setTodoPhases(phases: TodoPhase[]): void;
+    applyCompactionPostAppendForTests(compactionEntryId: string, firstKeptEntryId: string, fromExtension?: boolean): Promise<CompactionEntry | undefined>;
     /**
      * Abort current operation and wait for agent to become idle.
      */
@@ -807,9 +816,10 @@ export declare class AgentSession {
     isFastForSubagentProvider(provider?: string): boolean;
     /**
      * True when the configured `serviceTier` resolves to `"priority"` for the
-     * *currently selected model's provider*. Returns false for scoped tiers
-     * that don't match (e.g. `"openai-only"` on an anthropic model) and when
-     * no model is selected.
+     * *currently selected model's provider* AND fast mode was not auto-disabled
+     * for that provider this session. This is the current-model EFFECTIVE
+     * predicate (what the next request actually does); use {@link isFastForProvider}
+     * for pure configured intent (e.g. subagent/`modelRoles` display rows).
      */
     isFastModeActive(): boolean;
     setServiceTier(serviceTier: ServiceTier | undefined): void;

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

@@ -3,6 +3,14 @@ export interface BlobPutResult {
     path: string;
     get ref(): string;
 }
+export interface CheckedBlobPutResult extends BlobPutResult {
+    bytes: number;
+}
+export declare class BlobCorruptError extends Error {
+    readonly hash: string;
+    readonly path: string;
+    constructor(hash: string, path: string);
+}
 /**
  * Content-addressed blob store for externalizing large binary data (images) from session JSONL files.
  *
@@ -24,10 +32,22 @@ export declare class BlobStore {
      * Returns once the bytes are in the kernel page cache.
      */
     putSync(data: Buffer): BlobPutResult;
+    /**
+     * Durably install binary data as an immutable content-addressed blob.
+     *
+     * Callers that persist references to this blob must mutate canonical session entries only
+     * after this method returns successfully. A corrupt pre-existing target is reported with
+     * {@link BlobCorruptError}; it is never silently overwritten or trusted.
+     */
+    putImmutableSync(data: Buffer): CheckedBlobPutResult;
     /** Read blob by hash, returns Buffer or null if not found. */
     get(hash: string): Promise<Buffer | null>;
     /** Synchronously read blob by hash, returns Buffer or null if not found. */
     getSync(hash: string): Buffer | null;
+    /** Read blob by hash and verify its content hash; returns null if not found. */
+    getChecked(hash: string): Promise<Buffer | null>;
+    /** Synchronously read blob by hash and verify its content hash; returns null if not found. */
+    getCheckedSync(hash: string): Buffer | null;
     /** Check if a blob exists. */
     has(hash: string): Promise<boolean>;
 }
@@ -35,7 +55,9 @@ export declare class EphemeralBlobStore extends BlobStore {
     #private;
     constructor(dir: string);
     putSync(data: Buffer): BlobPutResult;
+    putImmutableSync(data: Buffer): CheckedBlobPutResult;
     getSync(hash: string): Buffer | null;
+    getCheckedSync(hash: string): Buffer | null;
     clear(): void;
     dispose(): void;
 }
@@ -44,8 +66,11 @@ export declare class MemoryBlobStore extends BlobStore {
     constructor();
     put(data: Buffer): Promise<BlobPutResult>;
     putSync(data: Buffer): BlobPutResult;
+    putImmutableSync(data: Buffer): CheckedBlobPutResult;
     get(hash: string): Promise<Buffer | null>;
     getSync(hash: string): Buffer | null;
+    getChecked(hash: string): Promise<Buffer | null>;
+    getCheckedSync(hash: string): Buffer | null;
     has(hash: string): Promise<boolean>;
 }
 export declare class ResidentBlobMissingError extends Error {

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

@@ -26,9 +26,51 @@ export interface SessionEntryBase {
     parentId: string | null;
     timestamp: string;
 }
+export interface ColdSpillRef {
+    kind: "cold_spill";
+    ref: string;
+    encoding: "utf8" | "json";
+    originalChars: number;
+    sha256: string;
+    bytes: number;
+}
+export interface EvictedContentMarker {
+    evictedAt: number;
+    reason: "compacted_history";
+    compactionEntryId: string;
+    firstKeptEntryId: string;
+    payloads: Record<string, ColdSpillRef>;
+}
+export interface EvictCompactedContentResult {
+    evictedEntries: number;
+    hotCharsRemoved: number;
+    coldBlobBytes: number;
+    payloadRefs: number;
+    alreadyEvictedEntries: number;
+    coldSpillWriteCount: number;
+    coldSpillReadCount: number;
+    residentTextReadCount: number;
+    residentImageReadCount: number;
+}
+export interface SessionManagerObservabilityStats {
+    coldSpillWriteCount: number;
+    coldSpillReadCount: number;
+    residentTextReadCount: number;
+    residentImageReadCount: number;
+    publicMaterializerCallCount: number;
+    getEntryMaterializerCallCount: number;
+    getBranchMaterializerCallCount: number;
+    getEntriesMaterializerCallCount: number;
+    materializedEntriesCachePopulateCount: number;
+    pathOnlyContextBuildCount: number;
+}
 export interface SessionMessageEntry extends SessionEntryBase {
     type: "message";
     message: AgentMessage;
+    /** Cold-spill marker: when present, heavy message content was moved to durable
+     *  content-addressed blobs after compaction. The marker is entry-level session
+     *  metadata (not a message field) so strict message types stay intact. */
+    evictedContent?: EvictedContentMarker;
 }
 export interface ThinkingLevelChangeEntry extends SessionEntryBase {
     type: "thinking_level_change";
@@ -148,6 +190,8 @@ export interface CustomMessageEntry<T = unknown> extends SessionEntryBase {
     display: boolean;
     /** Who initiated this message for billing/attribution semantics. */
     attribution?: MessageAttribution;
+    /** Cold-spill marker for custom-message content evicted after compaction. */
+    evictedContent?: EvictedContentMarker;
 }
 /** Session entry - has id/parentId for tree structure (returned by "read" methods in SessionManager) */
 export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry;
@@ -480,6 +524,19 @@ export declare class SessionManager {
      * Returns undefined if no model change has been recorded.
      */
     getLastModelChangeRole(): string | undefined;
+    evictCompactedContent(firstKeptEntryId: string, compactionEntryId: string): EvictCompactedContentResult;
+    getObservabilityStatsForTests(): SessionManagerObservabilityStats;
+    hotRetainedMessageCharsForTests(): number;
+    getCanonicalEntryForTests(id: string): SessionEntry | undefined;
+    getEntryForFidelity(id: string): SessionEntry | undefined;
+    getBranchForFidelity(fromId?: string): SessionEntry[];
+    /**
+     * Walk the active branch without materializing resident blobs or rehydrating
+     * cold-spill payloads. Intended for metadata-only scans such as todo-phase
+     * sync; callers must not mutate returned entries.
+     */
+    getActivePathEntriesCanonical(fromId?: string): SessionEntry[];
+    getEntriesForExport(): SessionEntry[];
     getEntry(id: string): SessionEntry | undefined;
     /**
      * Get all direct children of an entry.

package/dist/types/slash-commands/helpers/fast-status-report.d.ts

@@ -37,6 +37,12 @@ export interface FastStatusSessionLike {
     readonly model?: Model;
     /** Fast predicate against the main session tier (current model + `modelRoles`). */
     isFastForProvider(provider?: string): boolean;
+    /**
+     * Current-model EFFECTIVE fast state (intent minus any provider auto-disable).
+     * Used for the current-model row so it matches what the next request does.
+     * Optional so lightweight fakes can omit it; falls back to `isFastForProvider`.
+     */
+    isFastModeActive?(): boolean;
     /** Fast predicate against the effective subagent tier (`task.agentModelOverrides` roles). */
     isFastForSubagentProvider(provider?: string): boolean;
     resolveRoleModelWithThinking(role: string): {

package/dist/types/system-prompt.d.ts

@@ -47,6 +47,8 @@ export interface BuildSystemPromptOptions {
     toolNames?: string[];
     /** Text to append to system prompt. */
     appendSystemPrompt?: string;
+    /** Rendered GJC plugin system-appendix blocks (lower-authority, appended last). */
+    pluginAppendices?: string;
     /** Repeat full tool descriptions in system prompt. Default: false */
     repeatToolDescriptions?: boolean;
     /** Skills settings for discovery. */

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

@@ -4,6 +4,7 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 import type { AgentTelemetryConfig, ThinkingLevel } from "@gajae-code/agent-core";
+import type { ServiceTier } from "@gajae-code/ai";
 import { ModelRegistry } from "../config/model-registry";
 import type { PromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
@@ -58,6 +59,13 @@ export interface ExecutorOptions {
     authStorage?: AuthStorage;
     modelRegistry?: ModelRegistry;
     settings?: Settings;
+    /**
+     * Live service-tier intent of the parent session (`AgentSession.serviceTier`),
+     * used as the inherited tier when `task.serviceTier === "inherit"`. Passing the
+     * live value (not the stale settings snapshot) lets a runtime `/fast on` reach
+     * subagents, and a main-model fast-mode auto-disable does not clobber it.
+     */
+    inheritedServiceTier?: ServiceTier;
     /** Override local:// protocol options so subagent shares parent's local:// root */
     localProtocolOptions?: LocalProtocolOptions;
     /**
@@ -105,7 +113,7 @@ interface FinalizeSubprocessOutputResult {
 export declare const SUBAGENT_WARNING_NULL_YIELD = "SYSTEM WARNING: Subagent called yield with null data.";
 export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent exited without calling yield tool after 3 reminders.";
 export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
-export declare function createSubagentSettings(baseSettings: Settings): Settings;
+export declare function createSubagentSettings(baseSettings: Settings, inheritedServiceTier?: ServiceTier): Settings;
 /**
  * Run a single agent in-process.
  */

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

@@ -1,5 +1,5 @@
 import type { AgentTelemetryConfig, AgentTool } from "@gajae-code/agent-core";
-import type { Model, ToolChoice } from "@gajae-code/ai";
+import type { Model, ServiceTier, ToolChoice } from "@gajae-code/ai";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
@@ -173,6 +173,8 @@ export interface ToolSession {
     agentOutputManager?: AgentOutputManager;
     /** Settings instance for passing to subagents */
     settings: Settings;
+    /** Live service-tier intent of the parent session, inherited by `inherit` subagents. */
+    serviceTier?: ServiceTier;
     /** Plan mode state (if active) */
     getPlanModeState?: () => PlanModeState | undefined;
     /** Goal mode state (if active or paused) */

package/dist/types/utils/changelog.d.ts

@@ -25,6 +25,7 @@ export declare function parseChangelog(changelogPath: string): Promise<Changelog
  * binary-identity changelog).
  */
 export declare function getDisplayChangelogEntries(): ChangelogEntry[];
+export declare function getInstalledVersionChangelogEntry(entries: readonly ChangelogEntry[], installedVersion: string): ChangelogEntry | undefined;
 /**
  * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
  */