@gajae-code/coding-agent 0.11.9 → 0.11.11

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

@@ -149,6 +149,13 @@ export interface CreateAgentSessionOptions {
     goalToolAllowedOps?: readonly ("create" | "get" | "complete" | "resume" | "drop" | "pause")[];
     /** Optional per-session allowlist for tools exposed through search_tool_bm25. */
     discoverableToolAllowedNames?: readonly string[];
+    /**
+     * Discoverable built-in tools that must stay in the initial active set even when
+     * `tools.discoveryMode === "all"` would otherwise hide them behind `search_tool_bm25`.
+     * Used for coordination tools (e.g. `irc`) that a subagent must be able to use
+     * immediately without first spending a discovery round-trip to find them.
+     */
+    alwaysActiveToolNames?: readonly string[];
     /** Optional shared agent registry for IRC routing. Default: AgentRegistry.global(). */
     agentRegistry?: AgentRegistry;
     /** Parent task ID prefix for nested artifact naming (e.g., "6-Extensions") */

package/dist/types/sdk/startup-capability.d.ts

@@ -16,6 +16,12 @@ export type SdkStartupResult = {
 };
 /** Internal symbols for lifecycle-only SDK startup construction and bus wiring. */
 export declare const lifecycleStartupCapabilityOption: unique symbol;
+/**
+ * Internal option carrying the startup budget for ACP lifecycle MCP launches.
+ * Only set when the lifecycle request actually supplies `mcpServers`, so the
+ * longer ceiling never leaks to ordinary CLI/SDK `mcpConfigPath` consumers.
+ */
+export declare const lifecycleMcpStartupTimeoutOption: unique symbol;
 export declare function attachLifecycleStartupCapability(api: object, capability: SdkStartupCapability): void;
 export declare function lifecycleStartupCapabilityForApi(api: object): SdkStartupCapability | undefined;
 export interface SdkStartupRollbackResult {

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

@@ -80,7 +80,7 @@ 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 Skill, type SkillWarning } from "../extensibility/skills";
 import { type FileSlashCommand } from "../extensibility/slash-commands";
 import { GoalRuntime } from "../goals/runtime";
@@ -102,7 +102,7 @@ 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 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 */
@@ -677,6 +677,8 @@ export declare class AgentSession {
      * Get a tool by name from the registry.
      */
     getToolByName(name: string): AgentTool | undefined;
+    /** Get a registered tool with the same guards used for model-facing execution. */
+    getToolForExecution(name: string): AgentTool | undefined;
     /**
      * Register a UI/control-plane request handler for a currently foregrounded
      * managed bash execution. This is intentionally narrower than generic
@@ -760,6 +762,8 @@ export declare class AgentSession {
     /** 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. */
@@ -783,7 +787,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">): Promise<{
         name: string;
         path: string;
         args?: string;
@@ -791,13 +795,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;
@@ -844,7 +842,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">): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
@@ -986,6 +984,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. */

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,15 +121,42 @@ 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): Promise<void>;
+export declare function reconcileManagedTombstones(scope: ManagedScope, expectedCandidate?: ManagedCandidate): Promise<void>;
 /** Create the v2 binding and private write protocol directories before managed writes. */
 export declare function prepareManagedSessionScopeForWrite(scope: ManagedScope, policy?: ManagedSessionSecurityPolicy, authority?: ManagedCandidateWriteAuthority, expectedCandidate?: ManagedCandidate, expectedIdentity?: ResumeSessionIdentity): Promise<ManagedScopeResolution>;
 /**

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

@@ -27,6 +27,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;
@@ -597,6 +604,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>;
     /**

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;

package/dist/types/task/provider-retry-status.d.ts

@@ -0,0 +1,13 @@
+import type { AgentProgress, TaskToolDetails } from "./types";
+export type ProviderRetryKind = NonNullable<AgentProgress["retryState"]>["kind"];
+export declare function classifyProviderRetry(errorMessage: string): ProviderRetryKind;
+export declare function providerNameFromModel(model: string | undefined): string | undefined;
+export declare function providerRetryPhaseLabel(kind: ProviderRetryKind): string;
+export declare function providerProgressAgeLabel(retryState: NonNullable<AgentProgress["retryState"]>, nowMs: number): string;
+export declare function hasActiveProviderRetryInTaskDetails(details: TaskToolDetails, seen?: WeakSet<object>): boolean;
+export declare function hasActiveProviderRetryInProgress(progress: AgentProgress, seen?: WeakSet<object>): boolean;
+export interface ProviderDegradationGroup {
+    provider: string;
+    count: number;
+}
+export declare function collectProviderDegradationGroups(progress: readonly AgentProgress[]): ProviderDegradationGroup[];

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

@@ -45,6 +45,10 @@ export declare const taskItemSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
     assignment: z.ZodString;
+    executionMode: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        "ultragoal-red-team": "ultragoal-red-team";
+    }>>;
     inheritContext: z.ZodOptional<z.ZodEnum<{
         bounded: "bounded";
         full: "full";
@@ -69,6 +73,10 @@ export declare const taskSchema: z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        executionMode: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "ultragoal-red-team": "ultragoal-red-team";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             bounded: "bounded";
             full: "full";
@@ -100,6 +108,10 @@ export declare const taskSchemaNoIsolation: z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        executionMode: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "ultragoal-red-team": "ultragoal-red-team";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             bounded: "bounded";
             full: "full";
@@ -131,6 +143,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        executionMode: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "ultragoal-red-team": "ultragoal-red-team";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             bounded: "bounded";
             full: "full";
@@ -161,6 +177,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        executionMode: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "ultragoal-red-team": "ultragoal-red-team";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             bounded: "bounded";
             full: "full";
@@ -191,6 +211,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        executionMode: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "ultragoal-red-team": "ultragoal-red-team";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             bounded: "bounded";
             full: "full";
@@ -221,6 +245,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        executionMode: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "ultragoal-red-team": "ultragoal-red-team";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             bounded: "bounded";
             full: "full";
@@ -251,6 +279,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        executionMode: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "ultragoal-red-team": "ultragoal-red-team";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             bounded: "bounded";
             full: "full";
@@ -281,6 +313,10 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        executionMode: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "ultragoal-red-team": "ultragoal-red-team";
+        }>>;
         inheritContext: z.ZodOptional<z.ZodEnum<{
             bounded: "bounded";
             full: "full";
@@ -416,6 +452,9 @@ export interface AgentProgress {
         attempt: number;
         maxAttempts: number;
         unbounded?: boolean;
+        kind: "first_event_timeout" | "idle_stream_stall" | "provider_error";
+        provider?: string;
+        lastProviderProgressAtMs?: number;
         delayMs: number;
         errorMessage: string;
         startedAtMs: number;

package/dist/types/task/ultragoal-redteam-activation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Decide whether an executor assignment should inject the ultragoal red-team
+ * prompt fragment.
+ *
+ * Preference order (parse, don't re-validate later):
+ * 1. Explicit typed `executionMode` on the task / ExecutorOptions — authoritative.
+ * 2. Assignment text heuristics — only explicit Ultragoal QA/red-team phrasing.
+ *
+ * Bare mentions of `executorQa` (docs, quality-gate field names, negative
+ * instructions) must not flip the mode (#2698 / #2456).
+ *
+ * Mirrors `executor.md`:
+ * "activates only when the assignment explicitly labels Executor as Ultragoal
+ * completion QA/red-team or asks for `executorQa` red-team evidence."
+ */
+export declare const EXECUTOR_EXECUTION_MODES: readonly ["default", "ultragoal-red-team"];
+export type ExecutorExecutionMode = (typeof EXECUTOR_EXECUTION_MODES)[number];
+export declare function isExecutorExecutionMode(value: unknown): value is ExecutorExecutionMode;
+/**
+ * Parse a caller-supplied mode. Unknown values fail closed to `undefined`
+ * so the assignment heuristic (or default off) still applies — never invent on.
+ */
+export declare function parseExecutorExecutionMode(value: unknown): ExecutorExecutionMode | undefined;
+export declare function assignmentRequestsUltragoalRedTeam(assignment: string | undefined): boolean;
+export interface ResolveUltragoalRedTeamArgs {
+    readonly executionMode?: unknown;
+    readonly assignment?: string;
+}
+/**
+ * Final activation decision for the executor prompt fragment.
+ * Typed mode wins; assignment text is a compatibility fallback only.
+ */
+export declare function resolveUltragoalRedTeamActivation(args: ResolveUltragoalRedTeamArgs): boolean;

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

@@ -198,9 +198,11 @@ export interface ToolSession {
     /** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
     getAgentId?: () => string | null;
     /** Look up a registered tool by name (used by the eval js backend's tool bridge). */
+    getToolByName?: (name: string) => AgentTool | undefined;
+    /** Look up a registered tool with the session's execution guards applied. */
+    getToolForExecution?: (name: string) => AgentTool | undefined;
     /** Purge undelivered queued custom messages matching the predicate. Returns counts. */
     purgeQueuedCustomMessages?: (predicate: (message: CustomMessage) => boolean) => PurgeQueuedCustomMessagesResult;
-    getToolByName?: (name: string) => AgentTool | undefined;
     /** Agent registry for IRC routing across live sessions. */
     agentRegistry?: AgentRegistry;
     /** Optional restricted bash command prefixes for read-only role agents and constrained modes. */

package/dist/types/tools/resource-gc.d.ts

@@ -1,3 +1,4 @@
+import type { WindowsJobMemoryProbeResult } from "@gajae-code/natives";
 import type { Settings } from "../config/settings";
 import { type TabGcSnapshot } from "./browser/tab-supervisor";
 export interface BrowserGcPolicy {
@@ -16,7 +17,10 @@ export declare function resolveSweepIntervalMs(settings: Settings): number;
 /** Injectable seams so the controller is fully testable without real browsers/filesystem/RSS. */
 export interface ResourceGcDeps {
     now: () => number;
+    monotonicNow: () => number;
     rssBytes: () => number;
+    memorySnapshot: () => Promise<MemoryPressureSnapshot>;
+    runGc: () => void;
     logWarn: (msg: string, meta?: Record<string, unknown>) => void;
     listTabs: () => TabGcSnapshot[];
     releaseTab: (name: string, policy: {
@@ -43,6 +47,21 @@ export interface ResourceGcRegistration {
  */
 export declare function registerResourceGcSession(reg: ResourceGcRegistration): () => void;
 export declare function sweepOnce(d?: ResourceGcDeps): Promise<void>;
+export interface MemoryPressureDomain {
+    hardCapBytes: number;
+    totalUsageBytes: number;
+    source: MemoryPressureSnapshot["source"];
+}
+export interface MemoryPressureSnapshot {
+    hardCapBytes: number;
+    totalUsageBytes: number;
+    parentBytes: number;
+    source: "host" | "linux_cgroup_v2" | "linux_cgroup_v1" | "windows_job" | "windows_process_job_limit";
+    domains?: MemoryPressureDomain[];
+}
+export declare function __sampleLinuxCgroupHierarchyForTest(mountInfo: string, membership: string, fsType: "cgroup" | "cgroup2", hostBytes: number, parentBytes: number): Promise<MemoryPressureSnapshot | null>;
+export declare function __sampleWindowsJobMemoryForTest(hostBytes: number, parentBytes: number, probeResult?: WindowsJobMemoryProbeResult): MemoryPressureSnapshot | null;
+export declare function __selectMemoryPressureDomainForTest(snapshot: MemoryPressureSnapshot, policyLimitBytes: number | null): MemoryPressureSnapshot;
 export declare function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>): void;
 export declare function __setResourceGcSchedulerNowForTest(now: () => number): void;
 export declare function __runResourceGcTickForTest(): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.11.9",
+	"version": "0.11.11",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -53,13 +53,13 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.11.9",
-		"@gajae-code/agent-core": "0.11.9",
-		"@gajae-code/ai": "0.11.9",
-		"@gajae-code/bridge-client": "0.11.9",
-		"@gajae-code/natives": "0.11.9",
-		"@gajae-code/tui": "0.11.9",
-		"@gajae-code/utils": "0.11.9",
+		"@gajae-code/stats": "0.11.11",
+		"@gajae-code/agent-core": "0.11.11",
+		"@gajae-code/ai": "0.11.11",
+		"@gajae-code/bridge-client": "0.11.11",
+		"@gajae-code/natives": "0.11.11",
+		"@gajae-code/tui": "0.11.11",
+		"@gajae-code/utils": "0.11.11",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/scripts/generate-sdk-operation-inventory.ts

@@ -70,6 +70,7 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:getAsyncDeliveryStateForAcp":
 		"internal ACP lifecycle quiescence plumbing, not a user-facing control seam",
 	"agent_session:getToolByName": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:getToolForExecution": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:registerForegroundBashBackgroundRequestHandler":
 		"internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:hasForegroundBashBackgroundRequestHandler":
@@ -85,6 +86,7 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 	"agent_session:refreshMCPTools": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:refreshGjcSubskillTools": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:buildDisplaySessionContext": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:buildPreparedDisplaySessionContext": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:convertMessagesToLlm": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:prepareSimpleStreamOptions": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:getPlanModeState": "internal accessor/plumbing, not a user-facing control seam",
@@ -197,6 +199,7 @@ const SEAM_TO_SDK: Readonly<Record<string, string>> = {
 	"agent_session:setSessionName": "session.rename",
 	"agent_session:setModel": "model.set",
 	"agent_session:setDefaultModelSelection": "model.set",
+	"agent_session:activateModelProfileForControl": "model.profile.set",
 	"agent_session:cycleModel": "model.cycle",
 	"agent_session:setThinkingLevel": "thinking.set",
 	"agent_session:cycleThinkingLevel": "thinking.cycle",

package/scripts/run-test-manifest.ts

@@ -36,6 +36,8 @@ try {
 function validateRowReceipts(rows: ManifestAdapterRow[]): void {
 	const ids = new Set<string>();
 	const counts = new Map<string, number>();
+	// Each operation has one receipt, plus the dedicated config.patch secret-input receipt.
+	const expectedRowsPerAdapter = OPERATIONS.length + 1;
 	for (const row of rows) {
 		if (ids.has(row.adapterTestId)) throw new Error(`Duplicate adapter test ID: ${row.adapterTestId}`);
 		ids.add(row.adapterTestId);
@@ -60,11 +62,11 @@ function validateRowReceipts(rows: ManifestAdapterRow[]): void {
 		}
 		counts.set(row.adapter, (counts.get(row.adapter) ?? 0) + 1);
 	}
-	if (rows.length !== ADAPTERS.length * 93)
-		throw new Error(`Expected ${ADAPTERS.length * 93} adapter rows; received ${rows.length}.`);
+	if (rows.length !== ADAPTERS.length * expectedRowsPerAdapter)
+		throw new Error(`Expected ${ADAPTERS.length * expectedRowsPerAdapter} adapter rows; received ${rows.length}.`);
 	for (const adapter of ADAPTERS) {
-		if (counts.get(adapter) !== 93)
-			throw new Error(`Expected 93 ${adapter} rows; received ${counts.get(adapter) ?? 0}.`);
+		if (counts.get(adapter) !== expectedRowsPerAdapter)
+			throw new Error(`Expected ${expectedRowsPerAdapter} ${adapter} rows; received ${counts.get(adapter) ?? 0}.`);
 	}
 	process.stdout.write(
 		`manifest check: ${rows.length} row receipts (${[...counts].map(([adapter, count]) => `${adapter}=${count}`).join(", ")})\n`,

package/src/cli/args.ts

@@ -205,17 +205,23 @@ export function parseArgs(args: string[]): Args {
 				}
 			}
 			result.tools = validTools;
-		} else if (arg === "--thinking" && i + 1 < args.length) {
+		} else if (arg === "--thinking") {
+			// Match --credential / --mcp-config: a missing value or a following flag is
+			// a usage error, not a silent no-op / accidental consumption of `-p`.
+			const next = args[i + 1];
+			if (!next || next.startsWith("-")) {
+				throw new CliParseError(`--thinking requires <level> (${THINKING_EFFORTS.join(", ")})`);
+			}
 			const rawThinking = args[++i];
 			const thinking = parseEffort(rawThinking);
-			if (thinking !== undefined) {
-				result.thinking = thinking;
-			} else {
-				logger.warn("Invalid thinking level passed to --thinking", {
-					level: rawThinking,
-					validThinkingLevels: THINKING_EFFORTS,
-				});
+			if (thinking === undefined) {
+				// Fail closed: a silent ignore left users believing `ultra` (or any typo)
+				// was applied. Help / Flags.options advertise the real Effort enum.
+				throw new CliParseError(
+					`Invalid --thinking level "${rawThinking}". Expected one of: ${THINKING_EFFORTS.join(", ")}`,
+				);
 			}
+			result.thinking = thinking;
 		} else if (arg === "--print" || arg === "-p") {
 			result.print = true;
 		} else if (arg === "--export" && i + 1 < args.length) {

package/src/cli/fast-help.ts

@@ -84,7 +84,7 @@ Environment Variables:
   GJC_LAUNCH_POLICY           - Launch policy for --tmux startup: tmux or direct
   GJC_TMUX_SESSION            - Explicit tmux session name override for --tmux startup
   GJC_TMUX_PROFILE            - Apply GJC tmux scroll/mouse/clipboard profile to --tmux sessions (set 0/off to skip)
-  GJC_MOUSE                   - Mouse-wheel scroll in --tmux sessions (set 0/off to let the host terminal scroll)
+  GJC_MOUSE                   - Apply tmux copy-mode mouse capture in --tmux sessions (set 0/off to skip)
 
   For complete environment variable reference, see:
   docs/environment-variables.md

package/src/cli/notify-cli.ts

@@ -413,6 +413,7 @@ async function runTelegramSetup(cmd: NotifyCommandArgs, deps: NotifyCommandDeps)
 								settings,
 								cwd: process.cwd(),
 								sessionId: `notify-cli-${process.pid}`,
+								registerRoot: false,
 							}),
 				persistInactive: async marker => await persistTelegramActivationMarker(settings, marker),
 				clearInactive: async marker => await clearTelegramActivationMarker(settings, marker),