@gajae-code/coding-agent 0.7.2 → 0.7.4

package/dist/types/extensibility/gjc-plugins/types.d.ts

@@ -7,12 +7,56 @@ export declare const GJC_SUBSKILL_PARENT_AGENTS: readonly ["executor", "architec
 export type GjcSubskillParentAgent = (typeof GJC_SUBSKILL_PARENT_AGENTS)[number];
 export type GjcSubskillParent = GjcSubskillParentSkill | GjcSubskillParentAgent;
 export declare const GJC_AGENT_SUBSKILL_PHASES: Record<GjcSubskillParentAgent, string[]>;
+export interface GjcPluginToolManifestEntry {
+    name: string;
+    path: string;
+    description?: string;
+    sha256?: string;
+    /**
+     * "always-on" object entries are activated for the whole session; legacy
+     * string shorthand stays "subskill"-scoped and is only attached to subskill
+     * bindings (never registered as an always-on tool surface).
+     */
+    surface: "subskill" | "always-on";
+}
+export interface GjcPluginHookManifestEntry {
+    name: string;
+    event: string;
+    target?: string;
+    phase?: "before" | "after";
+    path: string;
+    sha256?: string;
+}
+export type GjcPluginMcpTransport = "stdio" | "http" | "sse";
+export interface GjcPluginMcpManifestEntry {
+    name: string;
+    transport: GjcPluginMcpTransport;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    url?: string;
+    headers?: Record<string, string>;
+    sha256?: string;
+}
+export interface GjcPluginAppendixManifestEntry {
+    name: string;
+    path?: string;
+    content?: string;
+    sha256?: string;
+}
+export interface GjcPluginAgentAppendixManifestEntry extends GjcPluginAppendixManifestEntry {
+    agent: GjcSubskillParentAgent;
+}
 export interface GjcPluginManifest {
     name: string;
     version: string;
     kind: "gajae-code-plugin";
     subskills: string[];
-    tools: string[];
+    tools: GjcPluginToolManifestEntry[];
+    hooks: GjcPluginHookManifestEntry[];
+    mcps: GjcPluginMcpManifestEntry[];
+    systemAppendix: GjcPluginAppendixManifestEntry[];
+    agentAppendix: GjcPluginAgentAppendixManifestEntry[];
 }
 export interface SubskillFrontmatter {
     name: string;
@@ -57,8 +101,120 @@ export interface LoadedGjcPlugin {
     bindings: LoadedSubskillBinding[];
     toolBindings: PhaseScopedToolBinding[];
 }
-export type GjcPluginLoadErrorCode = "forbidden_surface" | "invalid_manifest" | "invalid_frontmatter" | "invalid_parent" | "invalid_phase" | "duplicate_arg" | "duplicate_parent_phase" | "missing_file" | "invalid_kind";
+export type GjcPluginLoadErrorCode = "forbidden_surface" | "invalid_manifest" | "invalid_kind" | "unsupported_surface" | "invalid_frontmatter" | "invalid_parent" | "invalid_phase" | "missing_file" | "hash_mismatch" | "invalid_appendix" | "invalid_hook" | "invalid_mcp" | "duplicate_arg" | "duplicate_parent_phase" | "duplicate_tool" | "duplicate_hook" | "duplicate_mcp" | "duplicate_appendix" | "security_policy" | "install_conflict" | "session_collision" | "runtime_mismatch" | "quarantined_surface";
 export declare class GjcPluginLoadError extends Error {
     readonly code: GjcPluginLoadErrorCode;
     constructor(code: GjcPluginLoadErrorCode, message: string, options?: ErrorOptions);
 }
+export type GjcPluginScope = "user" | "project";
+export type GjcPluginSourceKind = "path" | "git" | "tarball";
+export interface GjcPluginCopiedFile {
+    relativePath: string;
+    sha256: string;
+    bytes: number;
+}
+export interface NormalizedSubskillSurface {
+    extensionId: string;
+    name: string;
+    description: string;
+    parent: string;
+    phase: string;
+    activationArg: string;
+    relativePath: string;
+    sha256: string;
+}
+export interface NormalizedToolSurface {
+    extensionId: string;
+    name: string;
+    relativePath: string;
+    sha256: string;
+    description?: string;
+}
+export interface NormalizedHookSurface {
+    extensionId: string;
+    name: string;
+    event: string;
+    target?: string;
+    phase?: "before" | "after";
+    relativePath: string;
+    sha256: string;
+}
+export interface NormalizedMcpSurface {
+    extensionId: string;
+    name: string;
+    transport: GjcPluginMcpTransport;
+    configHash: string;
+    config: GjcPluginMcpManifestEntry;
+}
+export interface NormalizedAppendixSurface {
+    extensionId: string;
+    name: string;
+    relativePath?: string;
+    /** Inline appendix body (when the manifest used `content` instead of `path`). */
+    content?: string;
+    contentHash: string;
+    bytes: number;
+}
+export interface NormalizedAgentAppendixSurface extends NormalizedAppendixSurface {
+    agent: GjcSubskillParentAgent;
+}
+export interface NormalizedGjcPluginSurfaces {
+    subskills: NormalizedSubskillSurface[];
+    tools: NormalizedToolSurface[];
+    hooks: NormalizedHookSurface[];
+    mcps: NormalizedMcpSurface[];
+    systemAppendices: NormalizedAppendixSurface[];
+    agentAppendices: NormalizedAgentAppendixSurface[];
+}
+/**
+ * Result of the pure compile step. Computed from manifest, frontmatter, and
+ * declared files read as bytes only — never by importing plugin code.
+ */
+export interface NormalizedGjcPluginBundle {
+    name: string;
+    version: string;
+    root: string;
+    manifestPath: string;
+    manifestHash: string;
+    surfaces: NormalizedGjcPluginSurfaces;
+    files: GjcPluginCopiedFile[];
+}
+export interface GjcPluginQuarantineEntry {
+    surfaceId: string;
+    code: GjcPluginLoadErrorCode;
+    message: string;
+    detectedAt: string;
+}
+export interface GjcPluginRegistrySource {
+    kind: GjcPluginSourceKind;
+    uri: string;
+    ref?: string;
+    sha?: string;
+    resolvedAt: string;
+}
+export interface GjcPluginRegistryEntry {
+    name: string;
+    version: string;
+    scope: GjcPluginScope;
+    enabled: boolean;
+    pluginRoot: string;
+    manifestPath: string;
+    manifestHash: string;
+    source: GjcPluginRegistrySource;
+    installedAt: string;
+    updatedAt: string;
+    copiedFiles: GjcPluginCopiedFile[];
+    surfaces: NormalizedGjcPluginSurfaces;
+    disabledSurfaceIds: string[];
+    quarantine?: GjcPluginQuarantineEntry[];
+}
+export interface GjcPluginRegistry {
+    version: 1;
+    scope: GjcPluginScope;
+    plugins: GjcPluginRegistryEntry[];
+}
+/**
+ * Stable identifiers for plugin-contributed surfaces used by observability,
+ * disabledSurfaceIds, and quarantine bookkeeping.
+ */
+export type GjcPluginSurfaceExtensionId = string;

package/dist/types/extensibility/gjc-plugins/validation.d.ts

@@ -1,4 +1,11 @@
-import { type LoadedSubskillBinding, type SubskillFrontmatter } from "./types";
+import { type GjcPluginRegistryEntry, type LoadedSubskillBinding, type NormalizedGjcPluginBundle, type SubskillFrontmatter } from "./types";
 export declare function validateBinding(fm: SubskillFrontmatter): void;
 export declare function buildParentArgMap(bindings: readonly LoadedSubskillBinding[]): Map<string, Map<string, LoadedSubskillBinding>>;
 export declare function buildParentPhaseSet(bindings: readonly LoadedSubskillBinding[]): Set<string>;
+/**
+ * Hard install-time collision + security validation for a compiled bundle
+ * against the effective installed registry (other plugins in the target scope
+ * universe). Collisions are hard errors; the registry is the collision
+ * authority, never capability first-wins.
+ */
+export declare function validateInstallPlan(bundle: NormalizedGjcPluginBundle, effectiveEntries: readonly GjcPluginRegistryEntry[]): void;

package/dist/types/gjc-runtime/launch-tmux.d.ts

@@ -4,6 +4,7 @@ export { buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND
 export declare const GJC_TMUX_LAUNCHED_ENV = "GJC_TMUX_LAUNCHED";
 export declare const GJC_LAUNCH_POLICY_ENV = "GJC_LAUNCH_POLICY";
 export declare const GJC_TMUX_WINDOW_LABEL_MAX_WIDTH = 48;
+export declare const GJC_PSMUX_PROFILE_FORCE_ENV = "GJC_PSMUX_PROFILE_FORCE";
 interface TtyState {
     stdin: boolean;
     stdout: boolean;

package/dist/types/gjc-runtime/psmux-detect.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Windows psmux detection and tmux-binary resolution.
+ *
+ * Recent psmux releases (see docs/compatibility.md in the psmux repo) close
+ * the round-trip gap for set-option / show-options user options and the
+ * set-window-option profile values gjc emits, which is what unblocks the
+ * native Windows gjc --tmux path. This module detects that capability so gjc
+ * can pick psmux when tmux is missing on Windows, and so callers can decide
+ * whether to treat a given tmux binary as psmux (affecting e.g. the untagged
+ * diagnostic wording and namespace handling).
+ *
+ * The probe is intentionally lightweight: it runs a single tmux -V (or
+ * --version) once per process and caches the verdict. Cache invalidation
+ * knobs:
+ *   - force: true re-probes on every call (used by tests).
+ *   - GJC_PSMUX_FORCE_DETECT=1 re-probes each call.
+ *   - GJC_PSMUX_DETECTION=off skips probing entirely.
+ */
+export declare const GJC_PSMUX_COMMAND_ENV = "GJC_PSMUX_COMMAND";
+export declare const GJC_PSMUX_DETECTION_ENV = "GJC_PSMUX_DETECTION";
+export declare const GJC_PSMUX_FORCE_DETECT_ENV = "GJC_PSMUX_FORCE_DETECT";
+/** Names that psmux installs as the canonical executable / alias. */
+export declare const PSMUX_BINARY_NAMES: readonly ["psmux", "pmux", "tmux"];
+export type PsmuxSpawnRunner = (command: string, args: string[]) => {
+    exitCode: number | null;
+    stdout?: string;
+    stderr?: string;
+};
+/**
+ * Resolves a tmux-class binary name (e.g. "psmux", "tmux") to an absolute
+ * filesystem path or returns null when the binary cannot be located. The
+ * default implementation uses `Bun.which`; production callers leave it
+ * alone and unit tests inject a stub via `__setBinaryResolverForTests`
+ * so the version-banner probe can be exercised hermetically.
+ */
+export type BinaryResolver = (candidate: string) => string | null;
+/** @internal Test-only seam; production code never calls this. */
+export declare function __setBinaryResolverForTests(resolver: BinaryResolver | null): void;
+export declare function envDisabled(value: string | undefined): boolean;
+/**
+ * Decide whether command resolves to a psmux binary by probing its version
+ * output. The result is cached per process unless force is set or
+ * GJC_PSMUX_FORCE_DETECT=1.
+ */
+export declare function detectPsmux(command: string, options?: {
+    force?: boolean;
+    env?: NodeJS.ProcessEnv;
+    runner?: PsmuxSpawnRunner;
+}): boolean;
+export interface ResolveGjcTmuxBinaryOptions {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    runner?: PsmuxSpawnRunner;
+}
+export interface ResolvedTmuxBinary {
+    command: string;
+    isPsmux: boolean;
+    viaExplicitOverride: boolean;
+}
+/**
+ * Resolve the tmux command GJC should invoke. Honors the existing
+ * GJC_TMUX_COMMAND / GJC_TEAM_TMUX_COMMAND overrides; on Windows when no
+ * override is set, psmux (installed as psmux, pmux, or tmux) is picked
+ * automatically so the default gjc --tmux flow lands on a real multiplexer.
+ */
+export declare function resolveGjcTmuxBinary(options?: ResolveGjcTmuxBinaryOptions): ResolvedTmuxBinary;
+/** Test-only helper: drop the in-process detection cache. */
+export declare function clearPsmuxDetectionCache(): void;
+export interface PsmuxProbe {
+    command: string;
+    versionOutput: string;
+    isPsmux: boolean;
+}
+export declare function probePsmux(command: string, options?: {
+    env?: NodeJS.ProcessEnv;
+    runner?: PsmuxSpawnRunner;
+    force?: boolean;
+}): PsmuxProbe;

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

@@ -281,6 +281,8 @@ export declare function persistGjcTeamModeStateSummary(snapshot: GjcTeamSnapshot
 export declare function recoverGjcTeamStaleClaims(teamName: string, cwd?: string, env?: NodeJS.ProcessEnv): Promise<GjcTeamLivenessRecoveryResult>;
 type GjcTeamTaskMetadataInput = Partial<Pick<GjcTeamTask, "owner" | "lane" | "required_role" | "allowed_roles" | "depends_on" | "blocked_by">>;
 export declare function resolveGjcWorkerCommand(cwd?: string, env?: NodeJS.ProcessEnv): string;
+/** @internal Exported for unit tests. */
+export declare function buildWorkerCommand(config: GjcTeamConfig, worker: GjcTeamWorker, platform?: NodeJS.Platform): string;
 export type GjcWorkerCheckpointClassification = {
     kind: "clean";
     files: string[];

package/dist/types/gjc-runtime/tmux-common.d.ts

@@ -23,7 +23,26 @@ export interface TmuxCommandResult {
 }
 export type TmuxCommandRunner = (args: string[]) => TmuxCommandResult;
 export declare function envDisabled(value: string | undefined): boolean;
-export declare function resolveGjcTmuxCommand(env?: NodeJS.ProcessEnv): string;
+/**
+ * Resolve the tmux (or tmux-compatible multiplexer) command GJC should invoke.
+ *
+ * This is the shared entry point used by every GJC code path that needs to talk
+ * to a multiplexer: `gjc --tmux` planning, `gjc session ...`, `gjc team ...`,
+ * the lifecycle controller, and the harness resident owner. Routing all of
+ * them through the same resolver means a single `GJC_TMUX_COMMAND` override or
+ * a single Windows psmux / pmux detection wins for the whole process — the
+ * failure mode where `gjc --tmux` creates a psmux-backed session and then
+ * `gjc session status` fails because it queries literal `tmux` is closed off.
+ *
+ * Explicit `GJC_TMUX_COMMAND` / `GJC_TEAM_TMUX_COMMAND` overrides are honored on
+ * every platform. On native Windows without an override the resolver walks
+ * `psmux`, then `pmux`, then `tmux` and uses the first binary present on PATH.
+ * On POSIX the resolver returns `tmux` (the historical default) and only
+ * falls through to the platform-aware walker if the caller opts in.
+ */
+export declare function resolveGjcTmuxCommand(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
+export type { PsmuxProbe, ResolvedTmuxBinary, ResolveGjcTmuxBinaryOptions } from "./psmux-detect";
+export { clearPsmuxDetectionCache, detectPsmux, probePsmux, resolveGjcTmuxBinary } from "./psmux-detect";
 /**
  * Build the exact-session target for tmux *option* commands
  * (`show-options` / `set-option`) and `display-message -t`.

package/dist/types/gjc-runtime/tmux-sessions.d.ts

@@ -41,4 +41,22 @@ export declare function createGjcTmuxSession(env?: NodeJS.ProcessEnv): GjcTmuxSe
 /** @internal */
 export declare function readTmuxSessionTagsForGc(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionTagsForGc;
 export declare function removeGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
+/**
+ * Force-close a GJC-managed tmux session, even if a live pane is attached.
+ *
+ * This is the lifecycle-control counterpart to {@link removeGjcTmuxSession}: it
+ * intentionally does NOT refuse live/attached panes (hard-kill is the contract),
+ * but it keeps every safety check so it can only ever kill a genuinely
+ * GJC-managed session:
+ * - re-reads the exact tmux profile immediately before kill (never a non-GJC
+ *   session, even one that collides by name);
+ * - when `expectedSessionId` is given, requires the `@gjc-session-id` tag match;
+ * - when `expectedStateFile` is given, requires the `@gjc-session-state-file`
+ *   tag match.
+ *
+ * Returns the prior status (for audit). Throws a tagged error otherwise:
+ * `gjc_tmux_session_not_found`, `gjc_tmux_session_not_managed`,
+ * `gjc_tmux_session_id_mismatch`, or `gjc_tmux_session_state_file_mismatch`.
+ */
+export declare function forceCloseGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string): GjcTmuxSessionStatus;
 export declare function attachGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): never;

package/dist/types/main.d.ts

@@ -12,6 +12,7 @@ import type { SubmittedUserInput } from "./modes/types";
 import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
+import { SessionManager } from "./session/session-manager";
 export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;
@@ -48,6 +49,7 @@ export declare function applyStartupModelProfilesOrExit(args: Parameters<typeof
  * tool registry and shadow the client-supplied servers (issue #1234).
  */
 export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
+export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings): Promise<SessionManager | undefined>;
 /**
  * Research-mode (RLM) preset hook. Lets `gjc rlm` augment the session options
  * (system prompt, restricted toolset, custom python tool) and assert the tool

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,6 +1,6 @@
 import { Editor, type KeyId } from "@gajae-code/tui";
 import { type AppKeybinding } from "../../config/keybindings";
-type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.message.queue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
+type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.message.followUp" | "app.message.queue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
 type PastePendingClearReason = "timeout" | "queue-limit";
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.

package/dist/types/modes/components/model-selector.d.ts

@@ -35,7 +35,15 @@ export declare class ModelSelectorComponent extends Container {
         sessionId?: string;
         isFastForProvider?: (provider?: string) => boolean;
         isFastForSubagentProvider?: (provider?: string) => boolean;
+        isCurrentModelFastModeActive?: () => boolean;
+        currentThinkingLevel?: ThinkingLevel;
+        activeModelProfile?: string;
     });
+    refreshRoleAssignments(options?: {
+        currentModel?: Model;
+        currentThinkingLevel?: ThinkingLevel;
+        activeModelProfile?: string;
+    }): void;
     handleInput(keyData: string): void;
     getSearchInput(): Input;
     __testSelectProfile(profileName: string, setDefault: boolean): Promise<void>;

package/dist/types/modes/components/status-line/git-utils.d.ts

@@ -1,3 +1,4 @@
+import type { GitHeadState } from "../../../utils/git";
 /**
  * Extract "owner/repo" from a GitHub remote URL.
  * Handles HTTPS, SSH (scp-style), and git:// protocols.
@@ -20,3 +21,8 @@ export declare function canReuseCachedPr(cachedPr: {
     number: number;
     url: string;
 } | null | undefined, cachedContext: PrCacheContext | undefined, currentContext: PrCacheContext | null): boolean;
+export interface CurrentBranchState {
+    readonly branch: string | null;
+    readonly repoId: string | null;
+}
+export declare function resolveCurrentBranch(cwd: string, resolveHead?: (cwd: string) => GitHeadState | null): CurrentBranchState;

package/dist/types/modes/theme/defaults/index.d.ts

@@ -325,6 +325,105 @@ export declare const defaultThemes: {
             "preset": string;
         };
     };
+    "gruvbox-dark": {
+        $schema: string;
+        name: string;
+        vars: {
+            "bgHard": string;
+            "surface": string;
+            "surfaceBright": string;
+            "borderNeutral": string;
+            "borderSubtle": string;
+            "fg": string;
+            "muted": string;
+            "dim": string;
+            "gray": string;
+            "red": string;
+            "green": string;
+            "yellow": string;
+            "blue": string;
+            "purple": string;
+            "aqua": string;
+            "orange": string;
+            "diffRemovalRed": string;
+        };
+        colors: {
+            "accent": string;
+            "border": string;
+            "borderAccent": string;
+            "borderMuted": string;
+            "success": string;
+            "error": string;
+            "warning": string;
+            "muted": string;
+            "dim": string;
+            "text": string;
+            "thinkingText": string;
+            "selectedBg": string;
+            "userMessageBg": string;
+            "userMessageText": string;
+            "customMessageBg": string;
+            "customMessageText": string;
+            "customMessageLabel": string;
+            "toolPendingBg": string;
+            "toolSuccessBg": string;
+            "toolErrorBg": string;
+            "toolTitle": string;
+            "toolOutput": string;
+            "mdHeading": string;
+            "mdLink": string;
+            "mdLinkUrl": string;
+            "mdCode": string;
+            "mdCodeBlock": string;
+            "mdCodeBlockBorder": string;
+            "mdQuote": string;
+            "mdQuoteBorder": string;
+            "mdHr": string;
+            "mdListBullet": string;
+            "toolDiffAdded": string;
+            "toolDiffRemoved": string;
+            "toolDiffContext": string;
+            "syntaxComment": string;
+            "syntaxKeyword": string;
+            "syntaxFunction": string;
+            "syntaxVariable": string;
+            "syntaxString": string;
+            "syntaxNumber": string;
+            "syntaxType": string;
+            "syntaxOperator": string;
+            "syntaxPunctuation": string;
+            "thinkingOff": string;
+            "thinkingMinimal": string;
+            "thinkingLow": string;
+            "thinkingMedium": string;
+            "thinkingHigh": string;
+            "thinkingXhigh": string;
+            "bashMode": string;
+            "pythonMode": string;
+            "statusLineBg": string;
+            "statusLineSep": string;
+            "statusLineModel": string;
+            "statusLinePath": string;
+            "statusLineGitClean": string;
+            "statusLineGitDirty": string;
+            "statusLineContext": string;
+            "statusLineSpend": string;
+            "statusLineStaged": string;
+            "statusLineDirty": string;
+            "statusLineUntracked": string;
+            "statusLineOutput": string;
+            "statusLineCost": string;
+            "statusLineSubagents": string;
+        };
+        export: {
+            "pageBg": string;
+            "cardBg": string;
+            "infoBg": string;
+        };
+        symbols: {
+            "preset": string;
+        };
+    };
     opencode: {
         $schema: string;
         name: string;

package/dist/types/notifications/html-format.d.ts

@@ -49,10 +49,21 @@ export declare function finalizeTelegramHtml(message?: string): string | undefin
  * `1. 1. …` and keeps the displayed number aligned with the button's real index.
  */
 export declare function buttonLabel(label: string, index: number): string;
+/** Numbered, escaped option list for the Telegram message body. */
+export declare function numberedOptionList(labels: string[]): string;
+/** Compact numeric button label; full option text belongs in the message body. */
+export declare function choiceButtonLabel(index: number): string;
 export interface InlineButton {
     text: string;
     callback_data: string;
 }
+/**
+ * Lay out option callbacks as compact numeric buttons. Telegram mobile clients
+ * ellipsize long inline-keyboard labels and tall keyboards can be obscured by
+ * the composer, so the full choice text is rendered in the message body while
+ * the keyboard keeps only stable one-based tap targets.
+ */
+export declare function buildCompactChoiceGrid(labels: string[], callbackForIndex: (index: number) => string): InlineButton[][];
 /**
  * Lay out option labels as a numbered button grid. Long buttons take a
  * full-width row; runs of short buttons are packed into rows of up to 3. The