@gajae-code/coding-agent 0.12.12 → 0.12.13

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [Unreleased]
 
+## [0.12.13] - 2026-08-06
+
+### Fixed
+- ACP session configuration now emits the spec-defined `category` field on the Mode, Model, and Thinking select options (`mode`, `model`, `thought_level`), so standards-compliant ACP clients such as Paseo discover models, modes, and thinking levels instead of an empty model picker (#3922).
+- The ACP session model catalog is now filtered to active providers via `providers.list/active`, falling back to the full catalog on older session hosts, so ACP clients no longer list models for providers without usable credentials (#3922).
+
+- `todo_write` now rejects malformed raw arguments with bounded, authority-controlled correction codes instead of a generic rejection: unknown root keys, unknown operation-entry keys, done/drop entries without a task or phase target, and unknown init list-entry keys each surface a fixed message naming the accepted shape without echoing the offending input, while recoverable payloads keep the passthrough/coercion path and the existing ask-tool codes are untouched (#3916).
+- The Alibaba Token Plan onboarding preset and `alibaba-token-plan-qwen-deepseek` profile now reference the provider-supported `qwen3.8-max` model id instead of `qwen-3.8-max`, preventing the built-in profile from selecting an HTTP 400 unsupported model (#3909).
+- `/model` reasoning menu header now shows the highlighted reasoning level (not the model id), seeds the cursor from the role badge when re-editing the same model, and uses a provider-neutral label for `max` instead of "Opus maximum reasoning" (#3847).
+- Resume listing now reverse-scans for buried but canonically valid `header_patch` titles, so a persisted manual title remains visible in the picker after later transcript growth instead of falling back to an empty/line-1 projection (#3633).
+- Custom OpenAI-compatible models whose wire id is namespaced (for example `cline-pass/deepseek-v4-flash`) now inherit capability metadata from the bundled leaf model when `contextWindow` / `maxTokens` are omitted, instead of silently falling back to the generic 128K / 16K defaults. True unknown leaf ids still default; explicit limits remain authoritative (#3856).
+- `gjc gc` file-lock discovery now budgets the walk **per lock root** and reports a hit entry cap as a **warning**, not a hard error. Truncating one root no longer skips the remaining roots, and a healthy run with only cap warnings exits `0` so scripts/cron/`&&` chains stay usable (#3852).
+
+- `gjc models` is no longer treated as a free-form agent prompt. The mistaken subcommand spelling now routes to the existing `--list-models` listing path so a nested bash-tool invocation cannot recursively spawn unbounded GJC agents (#3857).
+- Always-apply and rulebook rules are injected on the default system prompt path again. Discovery still loaded `.gjc/rules/`, `~/.gjc/agent/rules/`, and sticky `RULES.md`, but only `custom-system-prompt.md` rendered them, so normal sessions silently dropped the content while AGENTS.md in the same directory continued to work (#3859).
+- Made Telegram reference-client capability diagnostics safe for TUI embedding.
+- Custom `anthropic-messages` providers can now configure `compat.promptCacheMode` (`none`, `explicit`, or `automatic`) and `compat.supportsLongCacheRetention` at provider, model, and model-override levels. This makes the automatic Claude-family caching default safely overridable for compatible endpoints that require block-level cache markers or do not support 1-hour retention.
+- A Telegram notification daemon whose reconciliation pass fails no longer exits. The pass persists through the shared topic authority, and a momentarily unavailable authority (lock contention or a rejected compare-and-set) rejected out of both the scan timer and the run loop into the process-level fatal handler, killing the owner. Every session topic was then left behind as an unarchived shell that answers nothing — including for sessions that were still live and lost their notifications. The pass now reports the failure and the next scan interval retries it; the queue-flush timer is guarded the same way.
+- MiniMax M3 preset and profile ids canonicalized to `MiniMax-M3` (issue #3896): the `minimax` / `minimax-cn` onboarding presets and the `minimax-eco` / `minimax-medium` / `minimax-pro` builtin model profiles no longer reference the removed lowercase `minimax-m3` / `minimax-v3` first-class catalog ids.
+- Deep-interview round identity and input caps are now Unicode-canonical. Question text, selected options, and custom input are canonicalized to NFC before hashing and persisting, so the same Korean answer arriving in decomposed form (macOS-sourced pastes and some IME/clipboard paths emit NFD) no longer produces a second `answer_hash` — the documented append-or-merge no-op holds, and intent-review approval evidence still matches the user's recorded answer. Free-text caps are measured on the NFC form, so decomposed Hangul is charged the same character budget as the identical composed text instead of 2–3 code points per syllable (#3871).
+- Telegram notifications no longer disappear in a paired private chat whose bot has no Threaded Mode. Telegram answers `createForumTopic` there with `Bad Request: the chat is not a forum`, which was not recognized as a capability refusal, and the refusal verdict lived in caller-local flags — so every frame that joined the shared in-flight topic creation rethrew and its message (identity headers after `/resume`, asks, context updates) was dropped instead of being delivered flat. The rejection is now carried by typed errors that every awaiter of the same creation classifies identically, `the chat is not a forum` counts as a capability refusal, and a confirmed refusal is latched so later frames stop re-issuing a rejected `createForumTopic` per message.
+- Slash commands now expand in non-interactive runs. `gjc -p "/init"` previously reached the model as the literal text `/init`, so no command body was injected, no file was written, and the model still answered as if the command had run. Print mode now loads the same bundled and file-based command list interactive mode uses before it prompts.
+- `gjc plugin install <name>` now names the marketplaces that offer `<name>` when the npm resolution it falls back to fails, so a plugin name copied out of `gjc plugin discover` no longer dead-ends on a bare `install_failed`.
+- A remote multi-select ask now shows what is already selected. The ask tool re-issues one remote request per toggle, but the request carried no selection state, so Telegram kept posting an identical prompt with no sign that option 1 had been picked — the checkbox rendering existed only for durable workflow gates. `AskAnswerRequest` now carries `multi` and the selected option labels, the notification bus publishes them as `selectedOptionIndices` with the `(N selected)` question prefix while keeping the ask tool's own Next/Done control, and pre-numbered options (deep interview) are renumbered once instead of rendering as `1. ☑ 1. …`.
+
 ## [0.12.12] - 2026-08-05
 
 ### Added
@@ -15,7 +40,10 @@
 
 ### Fixed
 
+- Fixed deep-interview prompts exposing the literal argument placeholder.
+
 - Automatic session retry now refuses to re-issue a request once the failed attempt carries observable assistant text, thinking, or tool-call content — including under explicit legacy `retry.*` settings. Content-free clean failures keep their existing bounded/unbounded policy; managed provisional discard, credential rotation, first-event timeout scope checks, and manual `/retry` are unchanged (#3791).
+- Resuming a session whose transcript file is at or above the ~64 MiB managed-storage per-file bound no longer OOMs, stalls the process, or fails with a bare unhandled rejection. Resume/open now fail closed with a structured `oversized` reason (`SessionTranscriptOversizedError`) and recovery guidance before the full read/decode/parse path, instead of loading the entire file into memory. The bound matches the existing managed-artifact per-file limit and is not raised; sub-limit sessions resume unchanged (#3851).
 
 - Parent sessions and their subagent trees now share one identity-authorized artifact manager across persistent and ephemeral operation. Non-persistent roots are retired on committed session transitions and terminal close, failed transitions retain predecessor ownership, and atomic numeric-ID claims prevent same-root managers from creating ambiguous artifact references (#3813).
 
@@ -82,6 +110,8 @@
 - Windows automatic tmux resolution now selects `psmux` then `pmux` by canonical command order without rejecting distinct lower-priority aliases; it probes `tmux` only when neither named provider is available (#3725).
 - CI failure extraction now aggregates Bun failure and suite-error summaries across every test invocation in a job log instead of silently using only the first summary.
 - The GitHub status-line lookup now binds terminal links to positive PR numbers and canonical matching HTTP(S) pull-request URLs, rejecting ambiguous or control-bearing targets.
+- Fork-context subagents no longer inherit the parent's provider continuity identity. Each child session now presents its own `session_id`/`prompt_cache_key`, so concurrent subagent fleets stop colliding on session-owning upstream transports (`owner_busy` websocket-to-HTTP fallbacks) and keep per-worker cache affinity. Explicit `providerSessionId` overrides and serial same-session continuity are unchanged.
+- Fork-context subagents no longer inherit the parent's provider continuity identity. Each child session now presents its own `session_id`/`prompt_cache_key`, so concurrent subagent fleets stop colliding on session-owning upstream transports (`owner_busy` websocket-to-HTTP fallbacks) and keep per-worker cache affinity. Because `providerSessionId` scopes sticky credential selection as well as prompt-cache affinity, each child also selects its provider credential independently instead of following the parent's sticky choice. Explicit `providerSessionId` overrides and serial same-session continuity are unchanged.
 - Ordinary `ask` selectors now bound long question premises and page through every premise row without skipping rows hidden by overflow indicators (#3675).
 - First-event timeout retries now require a typed, content-free failure from the current clean attempt scope, preventing prior or stale extension activity from suppressing or admitting a later request (#3553).
 - The issue-1979 Korean prose wrap test now cleans up inherited multiplexer env vars (`TMUX`, `TMUX_PANE`, etc.) so it deterministically exercises the plain-terminal render path regardless of the CI runner's terminal session (#1979).

package/dist/types/cli/marketplace-hint.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Install-failure hints for marketplace-shaped plugin names.
+ *
+ * A bare spec (no `@marketplace`) is always classified as npm, so a user who
+ * copies a plugin name out of `plugin discover` gets an npm resolution failure
+ * with no hint that the same name is offered by a registered marketplace.
+ *
+ * Kept dependency-free — the marketplace barrel loads native addons — so this
+ * takes the narrow catalog surface it actually reads instead of the manager.
+ */
+/** The catalog lookups this module needs; `MarketplaceManager` satisfies it. */
+export interface MarketplaceCatalogLookup {
+    listMarketplaces(): Promise<ReadonlyArray<{
+        name: string;
+    }>>;
+    getPluginInfo(name: string, marketplace: string): Promise<unknown | null>;
+}
+/**
+ * A bare name carries no `@scope`, version specifier, or path separator, so it
+ * is the only install spec shape that is safe to echo back in an error.
+ */
+export declare function isBareInstallName(spec: string): boolean;
+/**
+ * Names of registered marketplaces whose catalog offers a plugin under exactly
+ * `name`. Only marketplace names are returned: they are user-chosen registry
+ * labels, never the plugin source, so they carry no credentials or home paths.
+ */
+export declare function findMarketplacesOffering(catalogs: MarketplaceCatalogLookup, name: string): Promise<string[]>;

package/dist/types/cli.d.ts

@@ -144,6 +144,16 @@ export declare class RootHelpCommand extends Command {
 }
 /** Normalize the sole `gjc resume` alias into the value-less launch intent. */
 export declare function normalizeResumeAlias(argv: readonly string[]): string[];
+/**
+ * Map the common mistaken `models` subcommand spelling to non-agent listing.
+ *
+ * Agents frequently run `gjc models` from the bash tool expecting a catalog.
+ * Without this route, `models` was a positional launch prompt and nested agents
+ * re-invoked `gjc models`, spawning an unbounded process chain (#3857).
+ * Always rewrite to `launch --list-models` so the invocation exits after a
+ * bounded listing and never starts an interactive agent session.
+ */
+export declare function routeModelsAlias(argv: readonly string[]): string[] | undefined;
 /** Apply the same default-launch routing used by runCli after root fast paths. */
 export declare function routeRootArgv(argv: readonly string[]): string[];
 /** Run the CLI with the given argv (no `process.argv` prefix). */

package/dist/types/config/file-lock-gc.d.ts

@@ -1,5 +1,17 @@
 /**
  * GC adapter for config file-locks (`<file>.lock` dirs holding `{pid, timestamp}`).
  */
-import type { GcStoreAdapter } from "../gjc-runtime/gc-runtime";
+import type { GcCollectResult, GcContext, GcStoreAdapter } from "../gjc-runtime/gc-runtime";
+/** Default per-root walk budget. Truncation is a warning, not a hard error. */
+export declare const FILE_LOCK_GC_MAX_WALK_ENTRIES = 20000;
+export interface FileLocksGcCollectOptions {
+    /** Override per-root entry budget (tests). Defaults to {@link FILE_LOCK_GC_MAX_WALK_ENTRIES}. */
+    maxWalkEntries?: number;
+}
+/**
+ * Discover + classify file-lock records. Each known lock root gets its own walk
+ * budget so truncating one root never skips the others. Caps surface as
+ * warnings (partial results), not hard discovery errors.
+ */
+export declare function collectFileLocksForGc(ctx: GcContext, options?: FileLocksGcCollectOptions): Promise<GcCollectResult>;
 export declare const fileLocksGcAdapter: GcStoreAdapter;

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

@@ -94,6 +94,8 @@ export declare const ModelsConfigFile: ConfigFile<{
             extraBody?: Record<string, unknown> | undefined;
             supportsStrictMode?: boolean | undefined;
             toolStrictMode?: "all_strict" | "none" | undefined;
+            supportsLongCacheRetention?: boolean | undefined;
+            promptCacheMode?: "automatic" | "explicit" | "none" | undefined;
         } | undefined;
         webSearch?: "auto" | "off" | "on" | undefined;
         authHeader?: boolean | undefined;
@@ -173,6 +175,8 @@ export declare const ModelsConfigFile: ConfigFile<{
                 extraBody?: Record<string, unknown> | undefined;
                 supportsStrictMode?: boolean | undefined;
                 toolStrictMode?: "all_strict" | "none" | undefined;
+                supportsLongCacheRetention?: boolean | undefined;
+                promptCacheMode?: "automatic" | "explicit" | "none" | undefined;
             } | undefined;
             contextPromotionTarget?: string | undefined;
             wireModelId?: string | undefined;
@@ -247,6 +251,8 @@ export declare const ModelsConfigFile: ConfigFile<{
                 extraBody?: Record<string, unknown> | undefined;
                 supportsStrictMode?: boolean | undefined;
                 toolStrictMode?: "all_strict" | "none" | undefined;
+                supportsLongCacheRetention?: boolean | undefined;
+                promptCacheMode?: "automatic" | "explicit" | "none" | undefined;
             } | undefined;
             contextPromotionTarget?: string | undefined;
             wireModelId?: string | undefined;

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

@@ -1,4 +1,73 @@
 import * as z from "zod/v4";
+export declare const ModelCompatSchema: z.ZodObject<{
+    supportsStore: z.ZodOptional<z.ZodBoolean>;
+    supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
+    sendSessionHeaders: z.ZodOptional<z.ZodBoolean>;
+    supportsMultipleSystemMessages: z.ZodOptional<z.ZodBoolean>;
+    supportsReasoningEffort: z.ZodOptional<z.ZodBoolean>;
+    reasoningEffortMap: z.ZodOptional<z.ZodObject<{
+        minimal: z.ZodOptional<z.ZodString>;
+        low: z.ZodOptional<z.ZodString>;
+        medium: z.ZodOptional<z.ZodString>;
+        high: z.ZodOptional<z.ZodString>;
+        xhigh: z.ZodOptional<z.ZodString>;
+        max: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    maxTokensField: z.ZodOptional<z.ZodEnum<{
+        max_completion_tokens: "max_completion_tokens";
+        max_tokens: "max_tokens";
+    }>>;
+    supportsUsageInStreaming: z.ZodOptional<z.ZodBoolean>;
+    requiresToolResultName: z.ZodOptional<z.ZodBoolean>;
+    requiresMistralToolIds: z.ZodOptional<z.ZodBoolean>;
+    requiresAssistantAfterToolResult: z.ZodOptional<z.ZodBoolean>;
+    requiresThinkingAsText: z.ZodOptional<z.ZodBoolean>;
+    reasoningContentField: z.ZodOptional<z.ZodEnum<{
+        reasoning: "reasoning";
+        reasoning_content: "reasoning_content";
+        reasoning_text: "reasoning_text";
+    }>>;
+    requiresReasoningContentForToolCalls: z.ZodOptional<z.ZodBoolean>;
+    allowsSyntheticReasoningContentForToolCalls: z.ZodOptional<z.ZodBoolean>;
+    requiresAssistantContentForToolCalls: z.ZodOptional<z.ZodBoolean>;
+    supportsToolChoice: z.ZodOptional<z.ZodBoolean>;
+    supportsForcedToolChoice: z.ZodOptional<z.ZodBoolean>;
+    toolChoiceSupport: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        named: "named";
+        none: "none";
+        required: "required";
+    }>>;
+    disableReasoningOnForcedToolChoice: z.ZodOptional<z.ZodBoolean>;
+    disableReasoningOnToolChoice: z.ZodOptional<z.ZodBoolean>;
+    thinkingFormat: z.ZodOptional<z.ZodEnum<{
+        openai: "openai";
+        openrouter: "openrouter";
+        qwen: "qwen";
+        "qwen-chat-template": "qwen-chat-template";
+        zai: "zai";
+    }>>;
+    openRouterRouting: z.ZodOptional<z.ZodObject<{
+        only: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        order: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    vercelGatewayRouting: z.ZodOptional<z.ZodObject<{
+        only: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        order: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    extraBody: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    supportsStrictMode: z.ZodOptional<z.ZodBoolean>;
+    toolStrictMode: z.ZodOptional<z.ZodEnum<{
+        all_strict: "all_strict";
+        none: "none";
+    }>>;
+    supportsLongCacheRetention: z.ZodOptional<z.ZodBoolean>;
+    promptCacheMode: z.ZodOptional<z.ZodEnum<{
+        automatic: "automatic";
+        explicit: "explicit";
+        none: "none";
+    }>>;
+}, z.core.$strip>;
 export declare const OpenAICompatSchema: z.ZodObject<{
     supportsStore: z.ZodOptional<z.ZodBoolean>;
     supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
@@ -61,6 +130,12 @@ export declare const OpenAICompatSchema: z.ZodObject<{
         all_strict: "all_strict";
         none: "none";
     }>>;
+    supportsLongCacheRetention: z.ZodOptional<z.ZodBoolean>;
+    promptCacheMode: z.ZodOptional<z.ZodEnum<{
+        automatic: "automatic";
+        explicit: "explicit";
+        none: "none";
+    }>>;
 }, z.core.$strip>;
 export declare const GJC_MODEL_EFFORT_IDS: readonly ["minimal", "low", "medium", "high", "xhigh", "max"];
 export declare const GJC_MODEL_ASSIGNMENT_TARGET_IDS: readonly ["default", "executor", "architect", "planner", "critic"];
@@ -238,6 +313,12 @@ export declare const ModelOverrideSchema: z.ZodObject<{
             all_strict: "all_strict";
             none: "none";
         }>>;
+        supportsLongCacheRetention: z.ZodOptional<z.ZodBoolean>;
+        promptCacheMode: z.ZodOptional<z.ZodEnum<{
+            automatic: "automatic";
+            explicit: "explicit";
+            none: "none";
+        }>>;
     }, z.core.$strip>>;
     contextPromotionTarget: z.ZodOptional<z.ZodString>;
     wireModelId: z.ZodOptional<z.ZodString>;
@@ -352,6 +433,12 @@ export declare const ModelsConfigSchema: z.ZodObject<{
                 all_strict: "all_strict";
                 none: "none";
             }>>;
+            supportsLongCacheRetention: z.ZodOptional<z.ZodBoolean>;
+            promptCacheMode: z.ZodOptional<z.ZodEnum<{
+                automatic: "automatic";
+                explicit: "explicit";
+                none: "none";
+            }>>;
         }, z.core.$strip>>;
         webSearch: z.ZodOptional<z.ZodEnum<{
             auto: "auto";
@@ -519,6 +606,12 @@ export declare const ModelsConfigSchema: z.ZodObject<{
                     all_strict: "all_strict";
                     none: "none";
                 }>>;
+                supportsLongCacheRetention: z.ZodOptional<z.ZodBoolean>;
+                promptCacheMode: z.ZodOptional<z.ZodEnum<{
+                    automatic: "automatic";
+                    explicit: "explicit";
+                    none: "none";
+                }>>;
             }, z.core.$strip>>;
             contextPromotionTarget: z.ZodOptional<z.ZodString>;
             wireModelId: z.ZodOptional<z.ZodString>;
@@ -660,6 +753,12 @@ export declare const ModelsConfigSchema: z.ZodObject<{
                     all_strict: "all_strict";
                     none: "none";
                 }>>;
+                supportsLongCacheRetention: z.ZodOptional<z.ZodBoolean>;
+                promptCacheMode: z.ZodOptional<z.ZodEnum<{
+                    automatic: "automatic";
+                    explicit: "explicit";
+                    none: "none";
+                }>>;
             }, z.core.$strip>>;
             contextPromotionTarget: z.ZodOptional<z.ZodString>;
             wireModelId: z.ZodOptional<z.ZodString>;

package/dist/types/gjc-runtime/deep-interview-state.d.ts

@@ -76,6 +76,18 @@ export interface DeepInterviewStateEnvelope {
     [key: string]: unknown;
 }
 export declare function hashContent(value: string): string;
+/**
+ * Canonicalize interview prose to NFC.
+ *
+ * Hangul, unlike most Latin prose, routinely reaches the interview in both
+ * composed and decomposed form (macOS-sourced pastes and some IME/clipboard
+ * paths emit NFD), and the two forms are the same text for the user while
+ * being different JavaScript strings. Canonicalizing at the identity and
+ * length boundaries keeps one round per answer and keeps the character caps
+ * script-fair: decomposed Hangul otherwise costs two to three code points per
+ * syllable against the same budget.
+ */
+export declare function canonicalizeDeepInterviewText(value: string): string;
 export declare function questionHash(questionText: string): string;
 export declare function answerHash(selectedOptions: string[] | undefined, customInput: string | undefined): string;
 /**
@@ -151,6 +163,8 @@ export declare function assertDeepInterviewStructuredResponseWithinLimit(value:
 /**
  * Assert a free-text input is within its size cap. Never inspects content for shell
  * metacharacters — free-text fields accept prose verbatim; this only bounds length.
+ * The cap is measured on the NFC form so decomposed Hangul is charged the same
+ * budget as the identical composed text.
  */
 export declare function assertDeepInterviewInputWithinLimit(value: string, max: number, fieldName?: string): void;
 /** Validate user-supplied deep-interview prose before an envelope is persisted. */

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

@@ -49,9 +49,17 @@ export interface GcError {
     scope: string;
     message: string;
 }
+/** Non-fatal discovery partials (e.g. traversal caps). Does not affect exit code. */
+export interface GcWarning {
+    store: GcStore;
+    scope: string;
+    message: string;
+}
 export interface GcCollectResult {
     records: GcRecord[];
     errors: GcError[];
+    /** Optional partial-result notices; omitted by adapters that have none. */
+    warnings?: GcWarning[];
 }
 export interface GcPruneOutcome {
     removed: boolean;
@@ -108,6 +116,8 @@ export interface GcReport {
     stores: Record<GcStore, GcRecord[]>;
     counts: GcCounts;
     errors: GcError[];
+    /** Partial-result notices that do not fail the run (e.g. walk caps). */
+    warnings: GcWarning[];
     session_index?: GcSessionIndexHealth;
 }
 export interface GcRunResult {
@@ -134,6 +144,7 @@ export declare function collectGcReport(adapters: GcStoreAdapter[], ctx: GcConte
  * - usage/parse error => 2
  * - hard discovery errors => 1 (both modes)
  * - prune mode with a failed intended removal => 1
+ * - warnings alone never fail the run
  * - otherwise => 0
  */
 export declare function computeExitCode(report: GcReport): number;

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

@@ -32,11 +32,32 @@ export interface TranscriptReplayContent {
     };
 }
 export declare function transcriptReplayContent(entry: unknown): TranscriptReplayContent;
+/**
+ * Collect every page of `providers.list/active` (Q29, GJC >= 0.12.8) and
+ * return the providers with usable stored credentials or credentialless
+ * connection kinds, mirroring the TUI model picker's
+ * `modelRegistry.getAvailable()`. The openwebui-gjc-adapter applies the same
+ * filter to `/v1/models`. Q29 pages are byte-bounded and can span multiple
+ * pages when custom provider ids inflate the payload, so all pages are
+ * consumed before the provider set is built. Returns undefined only when the
+ * session host rejects the query with `operation_not_session_owned`; any
+ * other query failure or malformed page is thrown.
+ */
+export declare function collectActiveProviderIds(adapter: Pick<AcpSdkAdapter, "query">): Promise<ReadonlySet<string> | undefined>;
+/**
+ * Collect every page of `models.list/current` (Q10) into one catalog so the
+ * active-provider filter never drops models that only appear on later pages.
+ * The SDK pages Q10 at a fixed byte target (256 KiB), which a fully
+ * configured catalog can exceed. Returns the same
+ * `{ result: { page: { items } } }` envelope `pageItems` consumes.
+ */
+export declare function collectModelCatalog(adapter: Pick<AcpSdkAdapter, "query">): Promise<unknown>;
 /** Maps live canonical SDK config and the selected model catalog into the ACP 1.2.1 session state surface. */
-export declare function acpSessionStateFromConfig(query: unknown, modelCatalogQuery?: unknown, modelPreset?: string): {
+export declare function acpSessionStateFromConfig(query: unknown, modelCatalogQuery?: unknown, modelPreset?: string, activeProviders?: ReadonlySet<string>): {
     configOptions: ({
         id: string;
         name: string;
+        category: "mode";
         type: "select";
         currentValue: string;
         options: {
@@ -46,6 +67,7 @@ export declare function acpSessionStateFromConfig(query: unknown, modelCatalogQu
     } | {
         id: "model";
         name: string;
+        category: "model";
         type: "select";
         currentValue: string;
         options: {
@@ -73,6 +95,7 @@ export declare function acpSessionStateFromConfig(query: unknown, modelCatalogQu
     } | {
         id: "thinking";
         name: string;
+        category: "thought_level";
         type: "select";
         currentValue: string;
         options: {

package/dist/types/sdk/bus/html-format.d.ts

@@ -43,6 +43,16 @@ export declare function truncateTelegramHtml(message: string, max?: number, mark
 export declare function splitTelegramHtml(message: string, max?: number): string[];
 /** Finalize an optional message: undefined passthrough, else safe-truncate. */
 export declare function finalizeTelegramHtml(message?: string): string | undefined;
+/** Multi-select state marker a transport may prepend to an option label. */
+export declare const SELECTION_MARK_CHECKED = "\u2611";
+export declare const SELECTION_MARK_UNCHECKED = "\u2610";
+/**
+ * Drop a leading `N.`/`N)` index already embedded in an option label (e.g.
+ * deep-interview options pre-numbered by the ask tool) so the canonical
+ * one-based index can be applied instead. A selection marker stays in front of
+ * the text: the label is renumbered, not un-marked.
+ */
+export declare function renumberableOptionText(label: string): string;
 /**
  * One-based, plain-text button label (Telegram does not parse HTML in labels).
  *

package/dist/types/sdk/bus/telegram-daemon-contract.d.ts

@@ -73,9 +73,13 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * final-component file symlinks fail-closed under AT_SYMLINK_NOFOLLOW (bounded
  * #3761 multi-account activation repair). Generation 51 adds shared durable
  * topic authority, archive recovery, and requires Telegram's documented error
- * code for idempotent archive settlement.
+ * code for idempotent archive settlement. Generation 52 is claimed by the
+ * pre-readiness daemon-child exit diagnostics slice (#3761). Generation 53
+ * renders multi-select state for ask-tool asks, not only durable workflow
+ * gates, and renumbers pre-numbered options exactly once around the selection
+ * marker.
  */
-export declare const DAEMON_GENERATION = 51;
+export declare const DAEMON_GENERATION = 53;
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 5
  * requires the complete generation-36 topic authority contract, so older

package/dist/types/sdk/bus/telegram-daemon.d.ts

@@ -990,6 +990,8 @@ export declare class TelegramNotificationDaemon {
     private readonly flatIdentitySent;
     /** Cached delivery boundary for the private owner chat or validation forum. */
     private pairedChatPrivacy;
+    /** Latched once Telegram confirms this chat cannot host forum topics. */
+    private topicCapabilityRefused;
     /** Bot username from getMe, cached once at owner startup for group/forum command targeting. */
     private botUsername;
     /** Sessions whose agent loop is currently busy (drives the typing indicator). */
@@ -1229,7 +1231,19 @@ export declare class TelegramNotificationDaemon {
      */
     private startOwnershipHeartbeatTimer;
     private stopOwnershipHeartbeatTimer;
-    /** Run a root scan, guarding against overlapping scans from the timer + loop. */
+    /**
+     * Run a root scan, guarding against overlapping scans from the timer + loop.
+     *
+     * A reconciliation pass is retried every scan interval, so a failed one must
+     * never tear the owner down. Both callers are fatal boundaries: the timer
+     * fires and forgets, and the run loop awaits without a handler. A rejection
+     * escaping either one (a shared topic authority whose lock or compare-and-set
+     * is momentarily unavailable is the observed case) reaches the process-level
+     * handler, which exits the daemon: every session topic is then left as an
+     * unarchived shell that answers nothing, and the sessions that were still
+     * live lose notifications too. Report the failure and let the next scan
+     * retry instead.
+     */
     private runScan;
     private startScanTimer;
     private stopScanTimer;

package/dist/types/sdk/bus/telegram-reference.d.ts

@@ -139,6 +139,11 @@ export declare function readEndpoint(path: string): {
     pid?: number;
     stale?: boolean;
 };
+/** A bounded, diagnostic-only notification mirrored to reference-client embedders. */
+export type TelegramReferenceDiagnostic = Readonly<{
+    code: "action_unavailable";
+    requiredCapabilities: readonly string[];
+}>;
 /** Options for {@link runTelegramReferenceClient}. */
 export interface TelegramReferenceOptions {
     botToken: string;
@@ -147,6 +152,11 @@ export interface TelegramReferenceOptions {
     apiBase?: string;
     fetchImpl?: typeof fetch;
     sound?: TelegramNotificationSound;
+    /**
+     * Additive mirror of bounded logger diagnostics. It never receives tokens,
+     * identifiers, raw frames, Telegram content, or WebSocket replies.
+     */
+    onDiagnostic?: (diagnostic: TelegramReferenceDiagnostic) => void;
 }
 /**
  * Run the reference bridge until the WebSocket closes. Sends `action_needed` to

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

@@ -58,14 +58,12 @@ export interface ForkContextSeed {
     messages: Message[];
     agentMessages: AgentMessage[];
     metadata: ForkContextSeedMetadata;
-    cacheIdentity?: string;
     appendOnlyPrefixSnapshot?: StablePrefixSnapshot;
 }
 export interface ForkContextSeedOptions {
     maxMessages: number;
     maxTokens: number;
     preserveLatestUser?: boolean;
-    cacheIdentity?: string;
     signal?: AbortSignal;
 }
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";

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

@@ -346,10 +346,20 @@ export interface ResumeTailTerminal {
 }
 export interface ResumeTailError {
     kind: "error";
-    reason: "missing" | "malformed" | "unstable" | "read-failed" | "legacy_migration_disabled";
+    reason: "missing" | "malformed" | "unstable" | "read-failed" | "legacy_migration_disabled" | "oversized";
+    size?: number;
 }
 export type SessionDirectoryMigrationPolicy = ManagedMigrationPolicy;
 export type SessionAppendPersistenceFailurePhase = "current_append" | "prior_failure";
+/**
+ * Safety bound for resuming a single transcript file. Matches the managed-storage
+ * per-file artifact limit (`MANAGED_ARTIFACT_MAX_FILE_BYTES`): transcripts at or above
+ * this size are not loaded into memory wholesale because the decode + per-line JSON
+ * parse + identity hash would OOM or stall the process (#3851). The bound is a
+ * load-time guard only; it does not raise the on-disk managed-storage limit.
+ */
+export declare const RESUME_TRANSCRIPT_MAX_BYTES: number;
+export declare const SESSION_OVERSIZED_RECOVERY_MESSAGE = "The selected session transcript is too large to resume safely. Use `gjc export <session-file>` to export its content into a new session, or remove/archive it after confirming its content is no longer needed.";
 export declare class SessionAppendPersistenceError extends Error {
     readonly phase: SessionAppendPersistenceFailurePhase;
     readonly entryId: string;
@@ -368,6 +378,11 @@ export declare class SessionArtifactCapacityError extends Error {
     readonly code = "artifact_capacity_exceeded";
     constructor(message: string);
 }
+export declare class SessionTranscriptOversizedError extends Error {
+    readonly code = "oversized";
+    readonly size: number;
+    constructor(size: number);
+}
 export type ResumeTailInspection = ResumeTailResumable | ResumeTailTerminal | ResumeTailError;
 export interface StrictSessionOpenSuccess {
     kind: "opened";
@@ -377,6 +392,7 @@ export interface StrictSessionOpenFailure {
     kind: "error";
     reason: ResumeTailError["reason"] | "identity-mismatch" | "migration-required" | "artifact_capacity_exceeded" | "migration_busy";
     message?: string;
+    size?: number;
 }
 /** Exact transcript bytes and authority captured from one descriptor-bound read. */
 export interface CapturedSessionTranscriptSnapshot {

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

@@ -84,6 +84,13 @@ export interface AskAnswerRequest {
     controls: readonly AskRemoteControl[];
     /** Optional zero-based recommendation into the authoritative raw options. */
     recommendedIndex?: number;
+    /** True while the question accepts several options before the navigation control commits. */
+    multi?: boolean;
+    /**
+     * Options currently selected in the multi-select loop, as authoritative option
+     * labels. Remote transports render the selection state so a toggle is visible.
+     */
+    selectedOptions?: readonly string[];
 }
 export type AskRemoteInteraction = {
     kind: "value";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.12.12",
+	"version": "0.12.13",
 	"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.3.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.12.12",
-		"@gajae-code/agent-core": "0.12.12",
-		"@gajae-code/ai": "0.12.12",
-		"@gajae-code/bridge-client": "0.12.12",
-		"@gajae-code/natives": "0.12.12",
-		"@gajae-code/tui": "0.12.12",
-		"@gajae-code/utils": "0.12.12",
+		"@gajae-code/stats": "0.12.13",
+		"@gajae-code/agent-core": "0.12.13",
+		"@gajae-code/ai": "0.12.13",
+		"@gajae-code/bridge-client": "0.12.13",
+		"@gajae-code/natives": "0.12.13",
+		"@gajae-code/tui": "0.12.13",
+		"@gajae-code/utils": "0.12.13",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/cli/fast-help.ts

@@ -106,5 +106,6 @@ Available Tools (default-enabled unless noted):
 
 Useful Commands:
   ${APP_NAME} --list-models        - List configured provider models
+  ${APP_NAME} models               - Alias for --list-models (never starts an agent)
   ${APP_NAME} --help               - Show this help`;
 }