@gajae-code/coding-agent 0.12.16-nightly.20260807070805.31156495595.g91c4eff67ce2 → 0.12.16

package/CHANGELOG.md

@@ -1,23 +1,42 @@
 # Changelog
 
 ## [Unreleased]
+
+## [0.12.16] - 2026-08-08
+
+### Added
+
+- `gjc gc` now reports managed session scope capacity when a scope is at or past 75% of the managed byte budget. A scope is snapshotted in full on every session start and fails closed once it exceeds the budget, but it is filled by GJC's own session records, so a working directory in sustained use can cross the limit with no prior signal — the first symptom is a launch that aborts. The probe is read-only and never fails a gc run: an absent, unreadable, or non-directory scope is reported as `unavailable`, an unreadable subtree is skipped so a partial walk still answers "am I near the budget?", and scopes below the threshold are omitted entirely so existing output is unchanged. `gc` still reclaims nothing here; the report names the scope path so stale session directories can be moved out by hand.
+- `--clipboard-transport <auto|native|osc52|ssh>` and `--clipboard-ssh-host <alias>` CLI flags, plus persisted `clipboard.transport` / `clipboard.sshHost` settings (CLI overrides config, config overrides the `auto` default). `ssh` mode routes text copy/paste through `ssh -o BatchMode=yes -o ConnectTimeout=3 -- <host> pbcopy/pbpaste` via argv spawn (never a shell string) with a 5-second hard timeout covering the whole operation lifecycle, a 1 MiB payload cap enforced during streaming (never fully buffered before the check), fatal UTF-8 decoding on the inbound side (invalid bytes are rejected, not silently normalized to U+FFFD), and outbound NUL-byte/unpaired-surrogate rejection. Explicit `ssh` failures (nonzero exit, timeout, invalid host, oversize/invalid payload) surface a sanitized error and never silently fall back to native clipboard or OSC 52 — clipboard payloads are never written to logs or artifacts. `auto`/`native`/`osc52` behave exactly as before. New `app.clipboard.pasteText` action (no default key; command palette only, so it never collides with the existing image-paste binding) reads the configured `ssh` clipboard and inserts it at the cursor.
+
 ### Fixed
 
+- SDK snapshot shutdown now reserves a revision write synchronously before any asynchronous serialization work, so an immediate `close()` cannot begin terminal cleanup ahead of an in-progress spill write under heavily contended CI scheduling. The coordinator owner-intent negative matrix also receives the same 30-second contention budget used by other filesystem-backed integration cases; its assertions and four-case coverage are unchanged.
 - `todo_write` and `ask` no longer reject valid calls before the tool loads. Both tools carried two independent copies of their raw-argument rules — one in the loaded tool, one in the cold descriptor registry that runs first — and the deferred copies had drifted: `todo_write`'s dropped the `content` synonym for `task` and the `complete`/`completed` aliases for `done`, accepted targetless `complete` entries the loaded tool rejects, and returned every rejection without its correction code, so the model saw a bare "raw arguments rejected before coercion" with nothing to fix and retried the same shape until the turn died. Both also rejected the harness's own injected `_i` intent field, failing any call carrying it with an unknown-root-key error the model could not repair. `todo_write` validation now lives in a single shared contract module (`tools/todo-contract.ts`) used by both paths, and both tools tolerate `_i` at the root while still rejecting genuinely unknown keys.
+- A stalled ACP session is no longer unrecoverable. The SDK host drops a session whose client has not ponged within `HEARTBEAT_TTL_MS` (20s), but the ACP client inherited the transport's one-shot reconnect defaults — 3 attempts at a 25ms base backoff, a total budget of 175ms — so any event-loop stall long enough for the host to reap the session exceeded the client's entire retry window by two orders of magnitude and surfaced as a terminal `-32603 ACP session transport was lost: SDK WebSocket reconnect attempts exhausted`. Under machine load this killed long-running agent sessions outright while their processes stayed alive. The ACP adapter and the broker connection now share an explicit `ACP_SESSION_RECONNECT` budget derived from `HEARTBEAT_TTL_MS` rather than a magic number: backoff ramps 250ms → 500ms → 1s and holds at a 2s cap for 23 attempts (~41.75s), so the client outlives twice the host TTL while individual sleeps stay short enough to reattach promptly once the host answers again.
 - Managed scope prepare and legacy-local resume no longer report success while group/other-readable descendants remain on disk (e.g. mode `0o036`/`0o644`): prepare uses a mode-only walk (not `snapshotManagedTree("")`, which races concurrent writers and broke `/move`) to detect drift, re-secures with apply+verify, and retries once; legacy-local capture uses the same resecure helper.
 - ACP `session/request_permission` responses are now normalized from the spec-shaped `RequestPermissionResponse` (`{ outcome: { outcome, optionId } }`) into the SDK's flat permission-decision contract before reaching the permission provider. Standards-compliant ACP clients such as Paseo can now authorize permission-gated shell/eval and destructive file operations (`bash`, `monitor`, `eval`, `delete`, `move`, and `edit` only for delete/move operations) without an invalid-response failure; `write` and ordinary edits remain ungated. Nested and flat selected/cancelled responses are accepted by reconstructing the canonical SDK decision fields, while malformed or unknown decisions fail closed.
+- `bun run restart:sdk-broker --close-session-hosts` no longer aborts the whole restart when one session host refuses to close. A host whose endpoint is unreachable and whose durable process identity cannot be verified — an orphan left behind by an earlier broker — made the broker reply `close_refused`, which surfaced as an uncaught `SdkClientError`, so the broker was never replaced and kept serving the source it started with: precisely the stale-code failure the flag exists to prevent, and worse than the broker-only restart because part of the teardown had already run. Every listed host is now attempted, the replacement broker starts regardless, and surviving hosts are named with their failure reason on stderr with a non-zero exit so a partial teardown is never reported as a clean one.
+- An ACP turn can no longer outlive its own end and wedge the session. A prompt whose terminal frame carried no normalized outcome — what an SDK-side `terminal_uncertain` closure produces when agent-owned async work (subagents, IRC deliveries) outlives the turn — was rejected without ever publishing the matching `session_info_update`, so the client stayed in the `working` phase forever. `session/cancel` had the same open end: `turn.abort` was acknowledged but nothing settled the pending `session/prompt` when the aborted run never published a terminal, leaving the waiter pending, the composer spinning, and every later prompt refused with `conflict` (surfacing in Paseo as `cancelAgentRun: acknowledged turn still active after timeout` followed by a permanent `A foreground turn is already active`). Every prompt rejection now releases the running phase, and an acknowledged cancel settles as ACP's mandated `cancelled` stop reason once a bounded grace expires, with a real terminal still winning inside that grace.
+- Intent tracing (`_i`) is no longer disabled on every headless surface. It was gated on `hasUI`, so an ACP, print-mode, or SDK-embedded top-level session ran a measurably different turn than the TUI on identical settings: the `_i` guidance line was dropped from the system prompt and the field was stripped from every tool schema, removing the model's pre-call intent statement and leaving ACP `tool_call.title` permanently falling back to `tool: <path>`. The original intent of the gate was to spare *sub-agents* the per-call token cost, so the omission now keys on canonical sub-sessions (`taskDepth`/`parentTaskPrefix`/`currentAgentType`) instead of surface shape. `tools.intentTracing` and `PI_INTENT_TRACING` are unchanged and still authoritative. **Breaking (SDK):** `resolveIntentTracingEnabled`'s second parameter is now `{ subSession: boolean }` instead of `hasUI: boolean`; a boolean is rejected at compile time rather than silently inverting behavior.
+- A 61MB `bun build --compile` intermediate (`packages/coding-agent/.18c95f9fdbe9bff8-00000000.bun-build`) had been committed to `dev`, and five more sat untracked in the worktree. `bun build --compile` writes these hidden temporaries next to the entrypoint and leaves them behind when interrupted, and no ignore rule covered them. `*.bun-build` is now ignored and the committed copy is untracked.
 
 ### Added
 
+- The SDK `models.list/current` (Q10) catalog now lists model profiles as synthetic `gajae-code/<profile>` entries (e.g. `gajae-code/codex-eco`), and selecting one through `model.set` (or the ACP Model picker) activates the profile for the live session only; global persistence remains the explicit `gjc --mpreset <name> --default` or TUI default-selection path. ACP/SDK clients such as Paseo can therefore offer presets like ordinary models; only availability-filtered profiles are advertised, the reserved `gajae-code` namespace fails closed on collision, and `config.patch` serializes with profile activation through the session admission boundary.
 - Added first-class `cline-pass` and `commandcode-goat` provider presets with documented API endpoints, environment-variable credentials, non-hardcoded live model discovery from models.dev and the Command Code Provider API, and prefix-based Claude routing.
+- Registered the `jetbrains-junie` provider in the famous-provider ordering and the `JUNIE_API_KEY` credential help so JetBrains AI (Junie) Claude models surface in `/model`, `--list-models` and `gjc --help` alongside the other first-class providers (#3626).
 - Added lease-backed MCP connection pooling with typed recovery, shared HTTP/SSE sessions, per-lease callback demultiplexing, and authorization binding scopes that keep credential secrets out of pool keys.
 - Added plugin registry v2 as the single execution authority for plugin tools, subskills, and prompt appendices, with digest verification at final use.
 - Added module-trace and process-tree RSS verification harnesses for startup-memory regressions.
+- Added `bun run clean` / `bun run clean:native` (`scripts/clean.ts`) to remove build output — `dist/`, `binaries/`, `coverage/`, stray `*.bun-build`, `*.tsbuildinfo`, and with `--native` compiled `.node` addons. Sources, `node_modules/`, `.gjc/` runtime state, and `artifacts/` test evidence are refused as targets rather than silently skipped, and `--dry-run` lists targets without deleting.
 
 ### Changed
 
+- Workflow skills are no longer implicitly auto-routed. The UserPromptSubmit keyword autoroute now matches only explicit `$`-prefixed tokens (`$deep-interview`, `$ralplan`, `$ultragoal`, `$team`); natural-language phrases ("don't assume", "consensus plan", "interview me", "coordinated team") and bare skill names no longer activate workflows. The system prompt now ranks explicit user intent above every routing heuristic, forbids workflow self-invocation and plan stacking, bans task-difficulty overestimation, directs the agent to offer heuristic workflow escalation (especially deep-interview for vague requirements) through the `ask` tool with an opt-out, and adds an `<engineering>` principles section.
 - Deferred notification adapters, native bindings, provider construction, tools, skills, eval, session artifacts, and history storage until their feature paths are used, reducing the CLI startup module graph without changing default behavior.
 - Split SDK session hosting into a transport-neutral runtime and lazy notification adapters.
+- `sticky-viewport-showcase.test.ts` runs in ~53s instead of ~192s, cutting the slowest CI test shard from ~369s to ~167s locally. Each of its 17 cases spawned a `bun` subprocess that re-rendered all 20 showcase frames (~9.4s per capture, ~187s of the file's ~192s) purely to obtain a pristine bundle it then corrupted. The bundle is now captured once and handed out as filesystem copies; the one case that must observe mutated `GJC_STICKY_VIEWPORT_ORACLE_COMMIT` state still captures for itself. Isolation is load-bearing and verified: sharing the directory instead of copying it fails 9 cases.
 
 ### Fixed
 

package/dist/types/cli/args.d.ts

@@ -14,6 +14,8 @@ export interface Args {
     credential?: string;
     systemPrompt?: string;
     appendSystemPrompt?: string;
+    clipboardTransport?: "auto" | "native" | "osc52" | "ssh";
+    clipboardSshHost?: string;
     mcpConfig?: string;
     thinking?: Effort;
     continue?: boolean;

package/dist/types/cli.d.ts

@@ -60,6 +60,13 @@ export declare class RootHelpCommand extends Command {
         "mcp-config": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        "clipboard-transport": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            options: string[];
+        };
+        "clipboard-ssh-host": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         "allow-home": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };

package/dist/types/commands/launch.d.ts

@@ -50,6 +50,13 @@ export default class Index extends Command {
         "mcp-config": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        "clipboard-transport": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            options: string[];
+        };
+        "clipboard-ssh-host": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         "allow-home": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };

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

@@ -22,6 +22,7 @@ interface AppKeybindings {
     "app.message.queue": true;
     "app.message.dequeue": true;
     "app.clipboard.pasteImage": true;
+    "app.clipboard.pasteText": true;
     "app.clipboard.copyLine": true;
     "app.clipboard.copyPrompt": true;
     "app.session.new": true;
@@ -261,6 +262,10 @@ export declare const KEYBINDINGS: {
         readonly defaultKeys: KeyId;
         readonly description: "Paste image from clipboard";
     };
+    readonly "app.clipboard.pasteText": {
+        readonly defaultKeys: [];
+        readonly description: "Paste text from configured clipboard transport (command palette only; no default key to avoid colliding with image paste)";
+    };
     readonly "app.clipboard.copyLine": {
         readonly defaultKeys: "alt+shift+l";
         readonly description: "Copy current line";

package/dist/types/config/model-bindings-applier.d.ts

@@ -7,7 +7,16 @@ export interface ConfiguredModelBindings {
 /** Synchronizes config-owned model bindings while preserving user edits. */
 export declare class ModelBindingsApplier {
     #private;
+    /** The currently configured bindings (as installed at startup), for baseline lookup. */
+    getBindings(): ConfiguredModelBindings | undefined;
     setBindings(bindings: ConfiguredModelBindings | undefined): void;
     applyTo(targetSettings: Settings): void;
+    /**
+     * Re-assert configured bindings into the target override slots, bypassing
+     * the user-edit-preservation heuristic. Used after a session-scoped profile
+     * reset removes profile-installed keys, so configured role/agent routing is
+     * restored exactly as it was installed at startup.
+     */
+    forceApplyTo(targetSettings: Settings): void;
     apply(): void;
 }

package/dist/types/config/model-profile-activation.d.ts

@@ -9,6 +9,15 @@ type ModelProfileActivationSession = Pick<AgentSession, "model" | "thinkingLevel
     setModelTemporary?: AgentSession["setModelTemporary"];
     setActiveModelProfile?: (name: string | undefined) => void;
     getActiveModelProfile?: () => string | undefined;
+    /** Record which runtime override keys this activation installed (session-scoped). */
+    noteProfileInstalledOverrides?: (modelRoles: readonly string[], agentModelOverrides: readonly string[], preProfileModel: Model<Api> | undefined) => void;
+    /** Drop the recorded profile-installed override keys (e.g. after materialization). */
+    clearProfileInstalledOverrides?: () => void;
+    /** Current profile-installed override keys, for deriving the activation base. */
+    getProfileInstalledOverrideKeys?: () => {
+        modelRoles: readonly string[];
+        agentModelOverrides: readonly string[];
+    };
     getSessionDefaultModelSelector?: () => string | undefined;
     recordResumeDefaultModel?: (selector: string) => void;
     seedDefaultFallbackResolution?: (activeIndex: number, skips: Array<{
@@ -21,7 +30,7 @@ export interface PrepareModelProfileActivationOptions {
     modelRegistry: Pick<ModelRegistry, "getModelProfile" | "getModelProfiles" | "getAvailableModelProfileNames" | "getApiKeyForProvider" | "getAll" | "resolveCanonicalModel" | "getCanonicalVariants" | "getCanonicalId"> & {
         getError?: ModelRegistry["getError"];
     };
-    settings: Pick<Settings, "get">;
+    settings: Pick<Settings, "get" | "getGlobal">;
     profileName: string;
 }
 export interface ApplyModelProfileActivationOptions {
@@ -38,6 +47,8 @@ export interface PreparedModelProfileActivation {
     previousThinkingLevel: ThinkingLevel | undefined;
     previousAgentModelOverrides: Record<string, ModelSelectorValue>;
     previousModelRoles: Record<string, ModelSelectorValue>;
+    baseAgentModelOverrides: Record<string, ModelSelectorValue>;
+    baseModelRoles: Record<string, ModelSelectorValue>;
     previousDefaultChain: readonly string[] | undefined;
     defaultModel: Model<Api> | undefined;
     defaultThinkingLevel: ThinkingLevel | undefined;
@@ -63,13 +74,17 @@ export interface PreparedModelProfileActivation {
     previousSessionDefaultModel: string | undefined;
 }
 export interface MaterializeModelProfileAssignmentOptions {
-    session: Pick<ModelProfileActivationSession, "model" | "thinkingLevel" | "getConfiguredModelChain" | "setActiveModelProfile" | "getActiveModelProfile">;
+    session: Pick<ModelProfileActivationSession, "model" | "thinkingLevel" | "getConfiguredModelChain" | "setActiveModelProfile" | "getActiveModelProfile"> & {
+        clearProfileInstalledOverrides?: () => void;
+    };
     settings: Pick<Settings, "clearOverride" | "get" | "override" | "set" | "unset">;
     role: GjcModelAssignmentTargetId;
     selector: string;
 }
 export interface MaterializeModelProfileAssignmentsOptions {
-    session: Pick<ModelProfileActivationSession, "model" | "thinkingLevel" | "getConfiguredModelChain" | "setActiveModelProfile" | "getActiveModelProfile">;
+    session: Pick<ModelProfileActivationSession, "model" | "thinkingLevel" | "getConfiguredModelChain" | "setActiveModelProfile" | "getActiveModelProfile"> & {
+        clearProfileInstalledOverrides?: () => void;
+    };
     settings: Pick<Settings, "clearOverride" | "get" | "override" | "set" | "unset">;
     assignments: ReadonlyMap<GjcModelAssignmentTargetId, string> | Partial<Record<GjcModelAssignmentTargetId, string>>;
 }

package/dist/types/config/model-registry.d.ts

@@ -6,6 +6,7 @@ import type { AuthStorage } from "../session/auth-storage";
 import type { ActiveSearchModelContext, WebSearchMode } from "../web/search/types";
 import { type ConfigError, ConfigFile } from "./config-file";
 import { isAuthenticated, kNoAuth } from "./model-auth";
+import { type ConfiguredModelBindings } from "./model-bindings-applier";
 import { type ProviderDiscoveryState } from "./model-discovery-manager";
 export type { ProviderDiscoveryState, ProviderDiscoveryStatus } from "./model-discovery-manager";
 import { type CanonicalModelIndex, type CanonicalModelRecord, type CanonicalModelVariant, type ModelEquivalenceConfig } from "./model-equivalence";
@@ -353,11 +354,21 @@ export declare class ModelRegistry {
     renameCustomModelProfile(name: string, displayName: string): Promise<ModelProfileDefinition>;
     deleteCustomModelProfile(name: string): Promise<ModelProfileConfig>;
     applyConfiguredModelBindings(targetSettings: Settings): void;
+    /**
+     * Re-assert configured modelBindings into the target override slots after a
+     * session-scoped profile reset removed profile-installed keys. Bypasses the
+     * user-edit heuristic so the startup role/agent routing is restored.
+     */
+    reapplyConfiguredModelBindings(targetSettings: Settings): void;
+    /** The currently configured modelBindings, for pre-profile baseline lookup. */
+    getConfiguredModelBindings(): ConfiguredModelBindings | undefined;
     /**
      * Get all models (built-in + custom).
      * If models.json had errors, returns only built-in models.
      */
     getAll(): Model<Api>[];
+    /** Provider ids declared in models.yml, including override-only providers. */
+    getConfiguredProviderIds(): readonly string[];
     getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[];
     getCanonicalVariants(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
     resolveCanonicalModel(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;

package/dist/types/config/settings-schema.d.ts

@@ -3133,6 +3133,26 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Past soft TTL but within hard TTL, the tool returns the cached row and refreshes it in the background. Past hard TTL, the row is dropped. Default 7 days.";
         };
     };
+    readonly "clipboard.transport": {
+        readonly type: "enum";
+        readonly values: readonly ["auto", "native", "osc52", "ssh"];
+        readonly default: "auto";
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Clipboard Transport";
+            readonly description: "auto keeps current OSC52+native best-effort behavior. native/osc52 restrict copy to one mechanism. ssh routes text copy/paste through `ssh <clipboard.sshHost> pbcopy/pbpaste` via argv spawn and never silently falls back to native/OSC52 on failure.";
+        };
+    };
+    readonly "clipboard.sshHost": {
+        readonly type: "string";
+        readonly default: "";
+        readonly validate: (value: string) => boolean;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Clipboard SSH Host";
+            readonly description: "SSH host alias (from ~/.ssh/config) used when clipboard.transport is ssh. Required in that mode.";
+        };
+    };
     readonly "web_search.enabled": {
         readonly type: "boolean";
         readonly default: true;
@@ -4304,6 +4324,17 @@ export type SettingsSchemaReport = {
     issues: SettingsSchemaIssue[];
     valid: boolean;
 };
+/**
+ * Validate an external (SDK `config.patch`) path/value set against the
+ * settings schema before any durable write. Dotted sub-paths of record
+ * settings (e.g. `modelRoles.default`) are validated against the record's
+ * value schema. Returns the offending entries so the caller can reject the
+ * whole patch without durable side effects.
+ */
+export declare function validateSettingPatch(patch: Record<string, unknown>): Array<{
+    path: string;
+    detail: string;
+}>;
 /** Coerce supported scalar legacy values and report unknown or invalid settings without dropping them. */
 export declare function reconcileSettingsSchema(raw: Record<string, unknown>): {
     settings: Record<string, unknown>;

package/dist/types/extensibility/extensions/compact-handler.d.ts

@@ -18,6 +18,12 @@ interface SetModelCapableSession {
     setModel(model: Model, role?: string, options?: {
         cause?: string;
     }): Promise<unknown>;
+    /** Persist effective profile roles and clear its marker for a concrete default selection. */
+    materializeActiveDefaultModelProfileAssignment?(model: Model): boolean;
+    /** Drop a session-only profile marker and its runtime role overrides. */
+    clearSessionOnlyModelProfileState?(): void;
+    /** Fallback marker clear for legacy session adapters. */
+    setActiveModelProfile?(name: string | undefined): void;
 }
 /**
  * Helper for wiring the `setModel` action of an {@link ExtensionContext}.

package/dist/types/extensibility/extensions/types.d.ts

@@ -283,6 +283,18 @@ export interface ExtensionContext {
         thinkingLevel: ThinkingLevel | undefined;
     } | undefined>;
     setModelProfile?(name: string): Promise<boolean>;
+    /** Persist a model profile as the global default (SDK host seam). */
+    setDefaultModelProfile?(name: string, options?: {
+        persistDefault?: boolean;
+        thinkingLevelOverride?: ThinkingLevel;
+        /** Internal SDK host hooks invoked inside the profile activation admission. */
+        onBeforeActivation?: () => void;
+        onAfterActivation?: () => void;
+    }): Promise<DefaultModelProfileActivationResult>;
+    /** The in-session active-profile marker; sole source of logical current state. */
+    getActiveModelProfile?(): string | undefined;
+    /** Run a control-surface mutation inside the session admission boundary. */
+    withSdkControlMutation?<T>(body: () => Promise<T>): Promise<T>;
     cycleThinkingLevel(): ThinkingLevel | undefined;
     setQueueMode(kind: "steering" | "follow_up" | "interrupt", mode: unknown): boolean;
     getSkillState(): unknown;
@@ -812,7 +824,7 @@ export interface ExtensionAPI {
     /** Set thinking visibility from a session or durable global control surface. */
     setThinkingVisibilityForControl(visibility: "visible" | "hidden", persist: boolean): Promise<void>;
     /** Set the model for this session only. Returns false when it is unavailable. */
-    setModelTemporaryForControl(model: Model, expectedSessionId?: string): Promise<boolean>;
+    setModelTemporaryForControl(model: Model, expectedSessionId?: string, thinkingLevel?: ThinkingLevel): Promise<boolean>;
     /** Fetch provider usage through the session's canonical provider resolution. */
     fetchUsageReportsForControl(): Promise<UsageReport[] | null>;
     /** Report whether the current effort follows global config or a session override. */
@@ -965,7 +977,13 @@ export type SetModelHandler = (model: Model) => Promise<boolean>;
 export type CycleThinkingLevelHandler = () => ThinkingLevel | undefined;
 export type SetThinkingLevelForControlHandler = (level: ThinkingLevel, persist: boolean) => Promise<void>;
 export type SetThinkingVisibilityForControlHandler = (visibility: "visible" | "hidden", persist: boolean) => Promise<void>;
-export type SetModelTemporaryForControlHandler = (model: Model, expectedSessionId?: string) => Promise<boolean>;
+export type SetModelTemporaryForControlHandler = (model: Model, expectedSessionId?: string, thinkingLevel?: ThinkingLevel) => Promise<boolean>;
+/** Result of activating a model profile as the global default from a control surface. */
+export interface DefaultModelProfileActivationResult {
+    changed: boolean;
+    /** The canonical (alias-resolved) profile id. */
+    id: string;
+}
 export type FetchUsageReportsForControlHandler = () => Promise<UsageReport[] | null>;
 export type GetThinkingScopeForControlHandler = () => "session" | "global config";
 export type GetThinkingLevelHandler = () => ThinkingLevel | undefined;
@@ -1046,6 +1064,15 @@ export interface ExtensionContextActions {
         thinkingLevel: ThinkingLevel | undefined;
     } | undefined>;
     setModelProfile?: (name: string) => Promise<boolean>;
+    setDefaultModelProfile?: (name: string, options?: {
+        persistDefault?: boolean;
+        thinkingLevelOverride?: ThinkingLevel;
+        /** Internal SDK host hooks invoked inside the profile activation admission. */
+        onBeforeActivation?: () => void;
+        onAfterActivation?: () => void;
+    }) => Promise<DefaultModelProfileActivationResult>;
+    getActiveModelProfile?: () => string | undefined;
+    withSdkControlMutation?: <T>(body: () => Promise<T>) => Promise<T>;
     cycleThinkingLevel?: () => ThinkingLevel | undefined;
     setQueueMode?: (kind: "steering" | "follow_up" | "interrupt", mode: unknown) => boolean;
     getSkillState?: () => unknown;

package/dist/types/gjc-runtime/gc-runtime.d.ts

@@ -12,6 +12,7 @@
  *   error all mean KEEP — a live process is never signalled or killed.
  * - Dry-run by default: nothing is deleted unless `--prune`/`--force`.
  */
+import { type GcSessionScopeUsage } from "./gc-session-scope";
 export type GcStore = "harness_leases" | "team_workers" | "file_locks" | "tmux_sessions" | "registry_entries" | "local_roots";
 export declare const GC_STORES: readonly GcStore[];
 /** Why a probed pid is kept instead of treated as dead. */
@@ -119,6 +120,8 @@ export interface GcReport {
     /** Partial-result notices that do not fail the run (e.g. walk caps). */
     warnings: GcWarning[];
     session_index?: GcSessionIndexHealth;
+    /** Managed-scope capacity, reported only when it is near or past the budget. */
+    session_scope?: GcSessionScopeUsage;
 }
 export interface GcRunResult {
     stdout: string;

package/dist/types/gjc-runtime/gc-session-scope.d.ts

@@ -0,0 +1,21 @@
+export type GcSessionScopeStatus = "ok" | "approaching_limit" | "over_limit" | "unavailable";
+export interface GcSessionScopeUsage {
+    status: GcSessionScopeStatus;
+    /** Absolute path of the managed scope for the current working directory. */
+    path: string;
+    total_bytes: number;
+    limit_bytes: number;
+    entries: number;
+    /** True when the walk stopped at `MAX_WALK_ENTRIES`, so totals are a floor. */
+    truncated: boolean;
+    reason?: string;
+}
+/**
+ * Measure the managed scope directory backing `scopePath`.
+ *
+ * Never throws: an unreadable or absent scope is reported as `unavailable` so
+ * a capacity probe can never fail a gc run.
+ */
+export declare function collectSessionScopeUsage(scopePath: string, limitBytes?: number): Promise<GcSessionScopeUsage>;
+/** Whether the usage is worth putting in front of an operator. */
+export declare function shouldReportSessionScope(usage: GcSessionScopeUsage): boolean;

package/dist/types/modes/acp/acp-agent.d.ts

@@ -249,6 +249,7 @@ export declare class AcpAgent implements Agent {
     constructor(connection: AgentSideConnection, options?: {
         agentDir?: string;
         startupOptions?: AcpStartupOptions;
+        cancelSettlementGraceMs?: number;
     } | unknown);
     initialize(params: InitializeRequest): Promise<InitializeResponse>;
     authenticate(params: AuthenticateRequest): Promise<AuthenticateResponse>;

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

@@ -35,6 +35,15 @@ export declare class InputController {
     handleForegroundToolBackgroundFold(): boolean;
     handleTextPaste(text: string, context: PasteTextContext): boolean | Promise<boolean>;
     handleImagePaste(): Promise<boolean>;
+    /**
+     * Explicit "Paste text from configured clipboard" action (P3-b v1). Only
+     * meaningful when `clipboard.transport` is `ssh` — reads via `pbpaste` on
+     * the configured host and inserts the result at the cursor. No default
+     * key (command palette only), so it never collides with the platform
+     * image-paste binding. Explicit ssh failures are surfaced verbatim and
+     * never fall back to native/OSC52 or leave stale text inserted.
+     */
+    handlePasteText(): Promise<boolean>;
     createAutocompleteProvider(commands: SlashCommand[], basePath: string): AutocompleteProvider;
     /** Copy the current editor line to the system clipboard. */
     handleCopyCurrentLine(): void;

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

@@ -14,6 +14,7 @@ interface PromptActionAutocompleteOptions {
     copyCurrentLine: () => void;
     copyPrompt: () => void;
     pasteImage: () => void;
+    pasteText: () => void;
     newSession: () => void;
     showHelp: () => void;
     scrollTmuxToPreviousUserInput: () => void;

package/dist/types/sdk/acp/adapter.d.ts

@@ -1,4 +1,4 @@
-import { SdkClient, SdkClientError, type SdkFrame } from "../client";
+import { SdkClient, SdkClientError, type SdkClientOptions, type SdkFrame } from "../client";
 type JsonObject = Record<string, unknown>;
 /** The small agent-side ACP surface used for reverse requests. */
 export interface AcpReverseConnection {
@@ -28,6 +28,21 @@ export declare class AcpSdkAdapterError extends Error {
 }
 export type AcpReconnectFailedHandler = (error: SdkClientError) => void;
 export type AcpFrameHandler = (frame: SdkFrame) => void;
+type AcpSessionReconnectOptions = Required<Pick<SdkClientOptions, "reconnectAttempts" | "reconnectBackoffMs" | "reconnectMaxBackoffMs">>;
+/**
+ * Reconnect budget for long-lived ACP sessions.
+ *
+ * Invariant: the client's total reconnect budget must outlive the host heartbeat
+ * TTL ({@link HEARTBEAT_TTL_MS}). The SDK host drops a session whose client has
+ * not ponged within that TTL, so a client that gives up reconnecting sooner turns
+ * every stall the host reaps into a permanently lost session ("SDK WebSocket
+ * reconnect attempts exhausted"). The transport defaults (3 attempts at 25ms base
+ * = 175ms total) are correct only for one-shot request clients.
+ *
+ * Backoff ramps 250 -> 500 -> 1000 and then holds at the 2s cap, so individual
+ * sleeps stay short and recovery is prompt once the host answers again.
+ */
+export declare const ACP_SESSION_RECONNECT: AcpSessionReconnectOptions;
 /**
  * Pure ACP-to-SDK adapter. It deliberately owns neither an AgentSession nor an
  * ACP bridge: all session work is performed through authenticated v3 frames.

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

@@ -1,2 +1,2 @@
 export type { AcpProviderRegistration, AcpReverseConnection, AcpSdkAdapterOptions } from "./adapter";
-export { AcpSdkAdapter, AcpSdkAdapterError } from "./adapter";
+export { ACP_SESSION_RECONNECT, AcpSdkAdapter, AcpSdkAdapterError } from "./adapter";

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

@@ -1,3 +1,4 @@
+import { type Settings } from "../../config/settings";
 import type { ExtensionAPI, ExtensionContext } from "../../extensibility/extensions";
 import { SessionSdkHost, type SessionSdkHostOptions } from "./host";
 import { type SessionSurface } from "./query";
@@ -21,6 +22,10 @@ export interface SessionSdkTransport {
 }
 export interface SessionSdkRuntimeOptions extends Omit<SessionSdkHostOptions, "sessionId" | "stateRoot" | "token" | "sendFrame" | "onFrame"> {
     transport: SessionSdkTransport;
+    /** Session settings; enables `config.patch` application on this runtime. */
+    settings?: Settings;
+    /** Mutable shadow of patched config values merged into query readback. */
+    configOverrides?: Map<string, unknown>;
 }
 /**
  * The transport-neutral SDK session runtime.
@@ -58,6 +63,10 @@ export interface CreateSdkSessionRuntimeOptions {
         token: string;
     }): SessionSdkTransport | Promise<SessionSdkTransport>;
     onSdkRequest?: SessionSdkHostOptions["onRequest"];
+    /** Session settings; enables `config.patch` application on this runtime. */
+    settings?: Settings;
+    /** Mutable shadow of patched config values merged into query readback. */
+    configOverrides?: Map<string, unknown>;
 }
 export interface InvocationCorrelation {
     commandId: string;
@@ -93,6 +102,8 @@ export interface SdkSurfaceFactoryOptions {
         followupQueueDepth: number;
     };
     configOverrides?: ReadonlyMap<string, unknown>;
+    /** Session settings; used for model-usage preferences in profile-limit resolution. */
+    settings?: Settings;
     promptStatusLookup?: (selector: {
         commandId?: string;
         turnId?: string;

package/dist/types/sdk/model-profile-model.d.ts

@@ -0,0 +1,58 @@
+import type { ModelProfileDefinition } from "../config/model-profiles";
+/**
+ * Reserved logical provider namespace for the preset-as-model facade.
+ *
+ * `gajae-code/<profile>` is not a real API provider: rows under this namespace
+ * exist only in the SDK Q10 projection and `model.set` selection routes to a
+ * session-scoped model-profile activation transaction. The namespace is
+ * reserved so a user-defined `models.yml` provider of the same name cannot
+ * silently shadow the facade (see {@link syntheticNamespaceCollision}).
+ */
+export declare const SYNTHETIC_PROVIDER_ID = "gajae-code";
+/**
+ * Display metadata used for synthetic rows whose profile default model cannot
+ * be resolved to a registered model. Mirrors the shared unknown-model
+ * constants from `@gajae-code/ai`; the real model's window is authoritative.
+ */
+export declare const SYNTHETIC_UNKNOWN_CONTEXT_WINDOW = 222222;
+export declare const SYNTHETIC_UNKNOWN_MAX_TOKENS = 8888;
+export declare function isSyntheticModelId(modelId: string): boolean;
+export declare function buildSyntheticModelId(profileName: string): string;
+/**
+ * Parse a synthetic model id losslessly. Only the first namespace slash is
+ * consumed; the full suffix (which may itself contain slashes or punctuation,
+ * matching the configured-profile contract) is the profile id.
+ */
+export declare function parseSyntheticModelId(modelId: string): {
+    profileName: string;
+} | undefined;
+/** A bounded SDK `invalid_input`-coded error for the synthetic selection branch. */
+export declare function syntheticModelInputError(message: string): Error;
+export interface ResolvedSyntheticModelSelection {
+    /** The raw profile suffix after the first namespace slash. */
+    profileName: string;
+    /** The canonical profile id (legacy aliases resolved, errors fail closed). */
+    canonicalName: string;
+}
+/**
+ * Canonicalize a synthetic model id against the merged profile registry.
+ * Profile/registry failures are converted to the SDK's `invalid_input` code so
+ * the ACP adapter's existing `invalid_input -> invalidParams` mapping applies.
+ */
+export declare function resolveSyntheticModelSelection(modelId: string, profiles: ReadonlyMap<string, ModelProfileDefinition>, registryError?: unknown): ResolvedSyntheticModelSelection;
+/**
+ * True when a real registry entry shadows the reserved logical namespace.
+ * Callers must omit synthetic rows (and reject synthetic selection) in that
+ * case instead of silently shadowing or misrouting the user's provider.
+ */
+export declare function syntheticNamespaceCollision(models: readonly {
+    provider: string;
+}[], configuredProviderIds?: readonly string[]): boolean;
+/**
+ * Resolve the set of providers with usable credentials across every profile's
+ * strict requirements and alternative groups. This is the single availability
+ * derivation shared by the Q10 synthetic facade and the Q27 profile catalog so
+ * both surfaces agree; `kNoAuth` counts as available and per-provider lookup
+ * failures simply exclude that provider.
+ */
+export declare function collectAuthenticatedProfileProviders(profiles: ReadonlyMap<string, ModelProfileDefinition>, getApiKeyForProvider: (provider: string) => Promise<string | undefined>): Promise<ReadonlySet<string>>;

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

@@ -1,5 +1,6 @@
 import { ThinkingLevel } from "@gajae-code/agent-core";
 import { type Api, type Effort, type Model, type ThinkingControlMode } from "@gajae-code/ai/core";
+import { type ModelProfileDefinition } from "../config/model-profiles";
 export type Q10ThinkingEffort = Effort;
 export type Q10SettableThinkingLevel = typeof ThinkingLevel.Off | Q10ThinkingEffort;
 export type Q10CurrentThinkingLevel = Q10SettableThinkingLevel | typeof ThinkingLevel.Inherit;
@@ -36,6 +37,19 @@ export interface Q10ModelProjectionInput {
     currentModel?: Model<Api>;
     currentThinkingLevel?: Q10CurrentThinkingLevel;
     resolveSupportedEfforts?: (model: Model<Api>) => readonly Effort[];
+    /**
+     * Logical model-profile facade inputs. When supplied, deterministic,
+     * availability-filtered synthetic rows (`gajae-code/<profile>`) are
+     * appended after the real rows; the underlying `Model` registry entries
+     * are never touched.
+     */
+    profiles?: ReadonlyMap<string, ModelProfileDefinition>;
+    /** Profile ids whose providers are authenticated and therefore selectable. */
+    availableProfileIds?: ReadonlySet<string>;
+    /** Active in-session profile marker; its synthetic row is the logical current. */
+    activeProfile?: string;
+    /** Resolve a profile's default concrete model for display metadata. */
+    resolveProfileDefaultModel?: (profile: ModelProfileDefinition) => Model<Api> | undefined;
 }
 /**
  * Projects model registry entries into the Q10 public DTO without exposing

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

@@ -318,5 +318,18 @@ export interface BuildSystemPromptOptions {
 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;
+/**
+ * Intent tracing (`_i`) is a model-facing reasoning aid, not a UI feature: it
+ * makes the model state a tool call's purpose before the call executes, and the
+ * loop turns that string into `tool_execution_start.intent` for every consumer
+ * (TUI transcript, ACP `tool_call.title`, telemetry, session dumps).
+ *
+ * The per-call token cost is only worth forcing on the operator-facing session,
+ * so canonical sub-sessions (role agents spawned through `task`) stay omitted.
+ * Surface shape must not decide this — an ACP or print-mode top-level session is
+ * the same conversation the operator would have run in the TUI.
+ */
+export declare function resolveIntentTracingEnabled(intentTracingSetting: boolean | undefined, options: {
+    subSession: boolean;
+}): boolean;
 export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;