@gajae-code/coding-agent 0.11.6 → 0.11.8

package/dist/types/gjc-runtime/repository-binding.d.ts

@@ -0,0 +1,63 @@
+import { type GitRepository } from "../utils/git";
+export declare const REPOSITORY_BINDING_SCHEMA: "gjc.repository_binding.v1";
+export interface RepositoryBinding {
+    schema: typeof REPOSITORY_BINDING_SCHEMA;
+    /** Canonical realpath of the git worktree root (or resolved cwd root). */
+    worktreeRoot: string;
+    /** Git common dir realpath when available; null outside a git checkout. */
+    commonDir: string | null;
+    /** Optional repo-relative subdirectory the lane should operate under. */
+    relativeSubdir?: string;
+    /** Optional display path (may be non-canonical); never used for authority. */
+    displayPath?: string;
+    /** Optional baseline HEAD at capture time. */
+    head?: string;
+    /** Optional branch name at capture time (when not detached). */
+    branch?: string;
+}
+export type RepositoryBindingErrorCode = "not_a_repository" | "identity_mismatch" | "path_outside_root" | "invalid_binding";
+export declare class RepositoryBindingError extends Error {
+    readonly code: RepositoryBindingErrorCode;
+    constructor(code: RepositoryBindingErrorCode, message: string);
+}
+/** Capture a durable binding from the active cwd/worktree. */
+export declare function captureRepositoryBinding(cwd: string, options?: {
+    relativeSubdir?: string;
+    displayPath?: string;
+}): Promise<RepositoryBinding>;
+/** Parse a binding from JSON/plan payload; fail closed on malformed shapes. */
+export declare function parseRepositoryBinding(value: unknown): RepositoryBinding;
+/** True when two bindings refer to the same repository identity (linked worktrees ok). */
+export declare function repositoryBindingsMatch(left: RepositoryBinding, right: RepositoryBinding): boolean;
+/**
+ * Ensure `cwd` is inside the bound repository (or the same linked worktree family).
+ * Fails closed on sibling-repo drift.
+ */
+export declare function assertCwdMatchesRepositoryBinding(cwd: string, binding: RepositoryBinding): Promise<RepositoryBinding>;
+/** Ensure a declared target path resolves under the bound worktree root. */
+export declare function assertPathUnderRepositoryBinding(binding: RepositoryBinding, targetPath: string): string;
+/**
+ * Public identity snapshot for receipts/handoffs (no display-only fields required).
+ * Always includes the schema + durable roots so downstream lanes can re-verify.
+ */
+export declare function publicRepositoryBinding(binding: RepositoryBinding): RepositoryBinding;
+/**
+ * Resolve the authoritative binding for a delegated task before discovery/spawn.
+ *
+ * - Missing declaration → stamp from session cwd (never leave authority implicit).
+ * - Declared binding → parse + fail closed unless it matches the active session worktree.
+ * - relativeSubdir (when present) must resolve under the bound root.
+ */
+export declare function resolveTaskRepositoryBinding(sessionCwd: string, declared: unknown | undefined): Promise<RepositoryBinding>;
+/**
+ * Ensure an execution/isolation root (cwd or worktree) still matches the bound identity.
+ * Used after isolation workspace creation so linked worktrees keep the source repository.
+ */
+export declare function assertExecutionRootMatchesRepositoryBinding(executionRoot: string, binding: RepositoryBinding): Promise<RepositoryBinding>;
+/** Optional helper for tests and diagnostics. */
+export declare function bindingFromGitRepository(repository: GitRepository, options?: {
+    relativeSubdir?: string;
+    displayPath?: string;
+    head?: string;
+    branch?: string;
+}): RepositoryBinding;

package/dist/types/gjc-runtime/ultragoal-guard.d.ts

@@ -1,5 +1,5 @@
 import { type UltragoalGoal, type UltragoalLedgerEvent, type UltragoalNudgeSurface, type UltragoalPlan, type UltragoalReceiptKind } from "./ultragoal-runtime";
-export type UltragoalGuardState = "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "unreadable_fail_closed";
+export type UltragoalGuardState = "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "active_missing_critic_verdict" | "unreadable_fail_closed";
 export interface UltragoalGuardDiagnostic {
     state: UltragoalGuardState;
     message: string;
@@ -25,6 +25,7 @@ export interface CurrentGoalLike {
         source: "user";
     };
 }
+export declare function isKnownUltragoalObjective(currentObjective: string): boolean;
 export declare function validateCompletionReceipt(input: {
     plan: UltragoalPlan;
     ledger: readonly UltragoalLedgerEvent[];
@@ -78,10 +79,10 @@ export interface UltragoalPauseBlockDiagnostic {
 }
 /**
  * While an Ultragoal run is active, `goal({"op":"pause"})` is only allowed when the
- * current durable Ultragoal state is readable and the latest durable ledger event
- * classifies the current blocker as `human_blocked`. Resolvable blockers must be
- * worked, not parked. Reads fail closed so unreadable durable state or ledger data
- * blocks pause rather than silently allowing a give-up.
+ * current durable Ultragoal state is readable, the latest `blocker_classified`
+ * event is `human_blocked`, and a later fresh clean pause terminal critic verdict is bound to
+ * that exact classification. Reads fail closed so unreadable durable state or
+ * ledger data blocks pause rather than silently allowing a give-up.
  */
 export declare function isUltragoalPauseBlocked(cwd: string): Promise<UltragoalPauseBlockDiagnostic>;
 export declare function assertUltragoalPauseAllowed(cwd: string): Promise<void>;

package/dist/types/gjc-runtime/ultragoal-receipt-freshness.d.ts

@@ -1,10 +1,30 @@
 import type { UltragoalCompletionVerification, UltragoalGoal, UltragoalGoalStatus, UltragoalLedgerEvent, UltragoalPlan, UltragoalReceiptKind } from "./ultragoal-runtime";
+export declare const CRITIC_VERDICT_EVENT = "critic_verdict";
+export declare const CRITIC_GATE_HARD_STOP_EVENT = "critic_gate_hard_stop";
+export declare const CRITIC_GATE_OVERRIDE_EVENT = "critic_gate_override";
+export declare const TERMINAL_CRITIC_CEILING = 5;
+export type CriticVerdict = "OKAY" | "ITERATE" | "REJECT";
 export type UltragoalReceiptFreshnessDiagnostic = {
     state: "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "unreadable_fail_closed";
     message: string;
     goalId?: string;
 };
 export declare function requiredUltragoalGoals(plan: UltragoalPlan): UltragoalGoal[];
+/** Hash the current required-goal set for terminal critic verdict freshness. */
+export declare function computeCriticVerdictPlanGeneration(plan: UltragoalPlan): string;
+export declare function isCleanPauseCriticVerdictShape(candidate: UltragoalLedgerEvent, planGeneration: string, classificationEventId: string): boolean;
+export declare function isCleanPauseCriticVerdict(event: UltragoalLedgerEvent, opts: {
+    planGeneration: string;
+    classificationEventId: string;
+}): boolean;
+export declare function findCleanPauseCriticVerdict(plan: UltragoalPlan, ledger: readonly UltragoalLedgerEvent[], classificationEventId: string): UltragoalLedgerEvent | null;
+/** Pure: count all ledger `critic_verdict` rows for an exact plan generation. */
+export declare function countTerminalCriticVerdicts(ledger: readonly UltragoalLedgerEvent[], planGeneration: string): number;
+/** Pure: count every non-OKAY terminal critic verdict recorded for this run. */
+export declare function countNonOkayTerminalCriticVerdicts(ledger: readonly UltragoalLedgerEvent[], _legacyPlanGeneration?: string): number;
+export declare function terminalCriticHardStopReached(ledger: readonly UltragoalLedgerEvent[], _legacyPlanGeneration?: string): boolean;
+export declare function terminalCriticGateOverridden(ledger: readonly UltragoalLedgerEvent[]): boolean;
+export declare function terminalCriticCeilingReached(ledger: readonly UltragoalLedgerEvent[], _legacyPlanGeneration?: string): boolean;
 export declare function receiptRelevantGoals(plan: UltragoalPlan, goal: UltragoalGoal, receiptKind: UltragoalReceiptKind): UltragoalGoal[];
 export declare function computeUltragoalPlanGeneration(input: {
     plan: UltragoalPlan;

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

@@ -1,5 +1,7 @@
 import type { WorkflowHudSummary } from "../skill-state/active-state";
-export { computeUltragoalPlanGeneration, receiptRelevantGoals } from "./ultragoal-receipt-freshness";
+import { type RepositoryBinding } from "./repository-binding";
+import { type CriticVerdict } from "./ultragoal-receipt-freshness";
+export { CRITIC_GATE_HARD_STOP_EVENT, CRITIC_GATE_OVERRIDE_EVENT, CRITIC_VERDICT_EVENT, type CriticVerdict, computeUltragoalPlanGeneration, countTerminalCriticVerdicts, receiptRelevantGoals, TERMINAL_CRITIC_CEILING, terminalCriticCeilingReached, terminalCriticGateOverridden, } from "./ultragoal-receipt-freshness";
 export { captureUltragoalRecoverySnapshot, parseStrictTerminalTranscript, persistUltragoalRecoveryDecision, planUltragoalOwnerLossRecovery, type UltragoalOwnerLossReceipt, type UltragoalRecoveryBinding, type UltragoalRecoveryDecision, type UltragoalRecoverySnapshot, validateOwnerLossBinding, validateRawUltragoalEvidence, validateRecoveryAdmission, validateRecoveryPath, } from "./ultragoal-owner-loss-recovery";
 export type UltragoalGjcGoalMode = "aggregate" | "per-story";
 export type UltragoalGoalStatus = "pending" | "active" | "complete" | "failed" | "blocked" | "review_blocked" | "superseded";
@@ -95,6 +97,8 @@ export interface UltragoalPlan {
     gjcObjective: string;
     gjcObjectiveAliases?: string[];
     goals: UltragoalGoal[];
+    /** Authoritative repository identity for multi-repo fail-closed spawn (#2901). */
+    repositoryBinding?: RepositoryBinding;
     createdAt: string;
     updatedAt: string;
     [key: string]: unknown;
@@ -307,6 +311,26 @@ export { joinUltragoalPipelineOverlap, rebaselineUltragoalPipelineOverlap, start
 export declare function getUltragoalRunCompletionState(plan: UltragoalPlan, options?: {
     retryFailed?: boolean;
 }): UltragoalRunCompletionState;
+/**
+ * Discriminated next-action for `complete-goals` handoff (#2903).
+ * `none` is reserved for genuine completion; `execute-goal` always carries a goal.
+ */
+export type UltragoalCompleteNextActionKind = "none" | "execute-goal" | "retry-failed" | "resolve-blockers" | "final-aggregate-receipt";
+export type UltragoalCompleteNextAction = {
+    kind: UltragoalCompleteNextActionKind;
+    goal?: UltragoalGoal;
+    blockedGoals?: UltragoalGoal[];
+    failedGoals?: UltragoalGoal[];
+};
+/**
+ * Resolve the actionable next step after scheduling / complete-goals.
+ * Blocked and review_blocked goals remain unschedulable; they surface as
+ * `resolve-blockers` instead of a contradictory `execute-goal` without goal_id.
+ */
+export declare function resolveUltragoalCompleteNextAction(plan: UltragoalPlan, options?: {
+    retryFailed?: boolean;
+    selectedGoal?: UltragoalGoal;
+}): UltragoalCompleteNextAction;
 export declare function startNextUltragoalGoal(input: {
     cwd: string;
     retryFailed?: boolean;
@@ -315,6 +339,7 @@ export declare function startNextUltragoalGoal(input: {
     plan: UltragoalPlan;
     goal?: UltragoalGoal;
     allComplete: boolean;
+    nextAction: UltragoalCompleteNextAction;
 }>;
 export declare function qualityGateObject(value: unknown): JsonObject | null;
 export declare function nonEmptyStringArray(value: unknown): string[] | null;
@@ -401,10 +426,10 @@ export declare function recordUltragoalReviewBlockers(input: {
 }): Promise<UltragoalPlan>;
 export type UltragoalBlockerClassification = "human_blocked" | "resolvable";
 /**
- * Record an audited blocker triage classification in the durable ledger. A
- * `human_blocked` classification is the only thing that authorizes
- * `goal({"op":"pause"})` while an Ultragoal run is active; `resolvable` is an
- * audit note and never unblocks pause.
+ * Record an audited blocker triage classification in the durable ledger. Pause
+ * requires the latest `blocker_classified` event to be `human_blocked` and a
+ * later clean pause terminal critic verdict bound to that classification; `resolvable`
+ * is an audit note and never unblocks pause.
  */
 export declare function recordUltragoalBlockerClassification(input: {
     cwd: string;
@@ -412,6 +437,19 @@ export declare function recordUltragoalBlockerClassification(input: {
     evidence: string;
     goalId?: string;
 }): Promise<UltragoalLedgerEvent>;
+export declare function recordUltragoalCriticVerdict(input: {
+    cwd: string;
+    terminus: "completion" | "pause";
+    verdict: CriticVerdict;
+    evidence: string;
+    blockers?: string[];
+    goalId?: string;
+    classificationEventId?: string;
+}): Promise<UltragoalLedgerEvent>;
+export declare function recordUltragoalCriticGateOverride(input: {
+    cwd: string;
+    evidence: string;
+}): Promise<UltragoalLedgerEvent>;
 type UltragoalReviewContractStrength = "strong" | "thin-derived";
 interface UltragoalReviewFinding extends JsonObject {
     severity: "blocker";

package/dist/types/main.d.ts

@@ -85,11 +85,15 @@ interface InteractiveModeFactoryOptions {
 }
 type CreateInteractiveMode = (options: InteractiveModeFactoryOptions) => InteractiveMode;
 type ResumePickerTerminalCheck = () => boolean;
-type ListForResumePickerReadOnly = (cwd: string, sessionDir?: string) => Promise<SessionInfo[]>;
+type ListForResumePickerReadOnly = (cwd: string, sessionDir?: string, storage?: undefined) => Promise<SessionInfo[]>;
+type ListManagedForResumePickerReadOnly = (cwd: string, managedAgentDir?: string, storage?: undefined) => Promise<SessionInfo[]>;
+type ResolveManagedAgentDirForScope = (cwd: string) => string;
 type SelectResumeSession = (sessions: SessionInfo[]) => Promise<SessionSelectionResult>;
 type OpenExistingSessionStrict = (identity: ResumeSessionIdentity, destination: SessionDestination, storage?: undefined, migrationPolicy?: SessionDirectoryMigrationPolicy) => Promise<StrictSessionOpenResult>;
 export declare const BARE_RESUME_CONFLICT_ERROR = "--resume without a session cannot be combined with --continue, --fork, or --no-session.";
 export declare const BARE_RESUME_INTERACTIVE_ERROR = "--resume requires an interactive terminal; use --resume <id>.";
+/** Resolves only the managed agent root needed for pre-consent picker inventory. */
+export declare function resolveManagedAgentDirForScope(_cwd: string): string;
 export declare const BARE_RESUME_OPEN_ERROR = "Could not open the selected session. Use --resume <id>.";
 export declare function runInteractiveMode(session: AgentSession, version: string, changelogMarkdown: string | undefined, notifs: (InteractiveModeNotify | null)[], startupUpdate: StartupUpdateOrchestrator, initialMessages: string[], setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers: LspStartupServerInfo[] | undefined, mcpManager: MCPManager | undefined, eventBus?: EventBus, initialMessage?: string, initialImages?: ImageContent[], createInteractiveMode?: CreateInteractiveMode, resumeAction?: "continue-tail" | "open-idle"): Promise<void>;
 declare function getChangelogForDisplay(parsed: Args): Promise<string | undefined>;
@@ -125,11 +129,38 @@ export interface RunRootCommandDependencies {
     runPrintMode?: RunPrintMode;
     isResumePickerTerminal?: ResumePickerTerminalCheck;
     listForResumePickerReadOnly?: ListForResumePickerReadOnly;
+    listManagedForResumePickerReadOnly?: ListManagedForResumePickerReadOnly;
+    resolveManagedAgentDirForScope?: ResolveManagedAgentDirForScope;
     selectResumeSession?: SelectResumeSession;
     openExistingSessionStrict?: OpenExistingSessionStrict;
     initializeSettings?: typeof Settings.init;
     loadSettingsForScope?: typeof Settings.loadForScope;
 }
+export interface ModelRoleOverrides {
+    smol?: string;
+    slow?: string;
+    plan?: string;
+}
+/**
+ * Resolve the ephemeral `smol`/`slow`/`plan` model-role overrides.
+ *
+ * Precedence per role is CLI flag > documented `GJC_*_MODEL` > legacy
+ * `PI_*_MODEL`, matching the repo-wide GJC-first/PI-fallback convention.
+ * Resolution reads the process environment via `$pickenv`, which trims values
+ * and treats empty/whitespace as unset; it is deliberately kept separate from
+ * credential env resolution (`$credentialEnv`/`$pickCredentialEnv`). The
+ * function is pure and stateless, so it reads fresh each call and a later
+ * invocation never inherits an earlier one's values.
+ */
+export declare function resolveModelRoleOverrides(parsed: Pick<Args, "smol" | "slow" | "plan">): ModelRoleOverrides;
+/**
+ * Apply the `--no-pty` / `--no-title` terminal-control flags to the environment.
+ *
+ * Sets the canonical `GJC_*` name (so an explicit flag wins over a user-set
+ * `GJC_*` value under the GJC-first resolver — CLI authority) and the legacy
+ * `PI_*` name for backward compatibility. `--acp` mode implies `--no-title`.
+ */
+export declare function applyTerminalControlFlagsToEnv(parsed: Pick<Args, "noPty" | "noTitle" | "mode">, env?: NodeJS.ProcessEnv): void;
 export declare function runRootCommand(parsed: Args, rawArgs: string[], deps?: RunRootCommandDependencies): Promise<void>;
 export declare function main(args: string[]): Promise<void>;
 export {};

package/dist/types/modes/components/btw-panel.d.ts

@@ -6,6 +6,7 @@ interface BtwPanelComponentOptions {
 export declare class BtwPanelComponent extends Container {
     #private;
     constructor(options: BtwPanelComponentOptions);
+    beginTurn(question: string): void;
     appendText(delta: string): void;
     setAnswer(text: string): void;
     markComplete(): void;

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

@@ -26,6 +26,8 @@ export type ModelSelectorSelection = {
 } | {
     kind: "deleteProfile";
     profileName: string;
+} | {
+    kind: "imageGeneration";
 };
 type RoleSelectCallback = (selection: ModelSelectorSelection) => void | Promise<void>;
 /**

package/dist/types/modes/components/runtime-mcp-add-wizard.d.ts

@@ -14,12 +14,13 @@ type Scope = "user" | "project";
  */
 export interface MCPAddWizardOAuthResult {
     credentialId: string;
+    tokenEndpoint: string;
     clientId?: string;
     clientSecret?: string;
 }
 export declare class MCPAddWizard extends Container {
     #private;
-    constructor(onComplete: (name: string, config: MCPServerConfig, scope: Scope) => void, onCancel: () => void, onOAuth?: (authUrl: string, tokenUrl: string, clientId: string, clientSecret: string, scopes: string) => Promise<MCPAddWizardOAuthResult>, onTestConnection?: (config: MCPServerConfig) => Promise<void>, onRender?: () => void, initialName?: string);
+    constructor(onComplete: (name: string, config: MCPServerConfig, scope: Scope) => void, onCancel: () => void, onOAuth?: (endpointUrl: string, authUrl: string, tokenUrl: string, clientId: string, clientSecret: string, scopes: string) => Promise<MCPAddWizardOAuthResult>, onTestConnection?: (config: MCPServerConfig) => Promise<void>, onRender?: () => void, initialName?: string);
     dispose(): void;
     handleInput(keyData: string): void;
 }

package/dist/types/modes/components/tool-status-header.d.ts

@@ -1,5 +1,5 @@
 import { type Component } from "@gajae-code/tui";
-import type { AppKeybinding, KeybindingsManager } from "../../config/keybindings";
+import { type AppKeybinding, type KeybindingsManager, type KeyDisplayContext } from "../../config/keybindings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import type { AgentSession } from "../../session/agent-session";
 import { type SkillActiveEntry } from "../../skill-state/active-state";
@@ -38,6 +38,7 @@ export interface StatusLineSettings {
     previewHighlightSegment?: StatusLineSegmentId;
     showHookStatus?: boolean;
     showSkillHud?: boolean;
+    showActionHints?: boolean;
     sessionAccent?: boolean;
     maxRows?: number;
 }
@@ -46,6 +47,7 @@ export interface StatusLineComponentOptions {
     actionRegistry?: ActionRegistry<void>;
     getKeybindings?: () => KeybindingsManager;
     focusDomain?: FocusDomain;
+    keyDisplayContext?: KeyDisplayContext;
 }
 export interface StatusLineActionHint {
     id: AppKeybinding;
@@ -56,7 +58,7 @@ export interface StatusLineActionHint {
  * remains the authority for availability; KEYBINDINGS remains the authority for
  * whether an action has a binding and the active manager supplies overrides.
  */
-export declare function getAvailableActionHints(actionRegistry: ActionRegistry<void> | undefined, getKeybindings: (() => KeybindingsManager) | undefined, width: number, domain?: FocusDomain): StatusLineActionHint[];
+export declare function getAvailableActionHints(actionRegistry: ActionRegistry<void> | undefined, getKeybindings: (() => KeybindingsManager) | undefined, width: number, domain?: FocusDomain, keyDisplayContext?: KeyDisplayContext): StatusLineActionHint[];
 export declare class StatusLineComponent implements Component {
     #private;
     private readonly session;

package/dist/types/modes/components/welcome.d.ts

@@ -1,4 +1,5 @@
 import { type Component } from "@gajae-code/tui";
+import { type KeyDisplayContext } from "../../config/keybindings";
 export interface RecentSession {
     name: string;
     timeAgo: string;
@@ -15,6 +16,7 @@ export interface WelcomeComponentOptions {
     changelogMarkdown?: string;
     collapseChangelog?: boolean;
     buildLabel?: string;
+    keyDisplayContext?: KeyDisplayContext;
 }
 /**
  * GJC-native launch surface with compact command affordances, project

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

@@ -1,10 +1,15 @@
 import type { InteractiveModeContext } from "../types";
+type BtwFollowUpResult = "accepted" | "busy" | "closed" | "rejected";
 export declare class BtwController {
     #private;
     private readonly ctx;
     constructor(ctx: InteractiveModeContext);
     hasActiveRequest(): boolean;
+    hasOpenPanel(): boolean;
+    isTurnInFlight(): boolean;
     handleEscape(): boolean;
     dispose(): void;
     start(question: string): Promise<void>;
+    submitFollowUp(question: string): Promise<BtwFollowUpResult>;
 }
+export {};

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

@@ -1,8 +1,10 @@
 import { type CompactionOutcome } from "@gajae-code/agent-core/compaction";
 import { type ProviderDetails, type UsageReport } from "@gajae-code/ai";
+import type { KeybindingsManager } from "../../config/keybindings";
 import type { CompactOptions } from "../../extensibility/extensions/types";
 import { theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
+export declare function buildHelpMarkdown(keybindings: Pick<KeybindingsManager, "getAccessibleDisplayString">): string;
 export declare class CommandController {
     #private;
     private readonly ctx;

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

@@ -5,7 +5,7 @@ import type { InteractiveModeContext, OAuthSelectorOptions } from "../../modes/t
 import { getNotificationConfig, maskToken } from "../../sdk/bus/config";
 import { proposedTelegramIdentity, reconcileCommittedTelegramConfiguration, removeTelegramConfiguration, saveTelegramInactive } from "../../sdk/bus/notification-orchestration";
 import { buildNotificationStatusReport, checkNotificationHealth, recoverNotifications, sanitizeDiagnostic, sendNotificationTest } from "../../sdk/bus/notification-service";
-import { ensureTelegramDaemonRunningDetailed, unregisterNotificationRoot } from "../../sdk/bus/telegram-daemon";
+import { ensureTelegramDaemonRunningDetailed, resolveTelegramSetupPreflight, unregisterNotificationRoot } from "../../sdk/bus/telegram-daemon";
 import { runTelegramSetup } from "../../sdk/bus/telegram-setup";
 import { type CredentialAutoImportStateStore } from "../../setup/credential-auto-import";
 import { type CommandPaletteAction } from "../components/command-palette";
@@ -38,6 +38,7 @@ export interface NotificationsEditorOperationDependencies {
     sanitizeDiagnostic: typeof sanitizeDiagnostic;
     ensureTelegramDaemonRunningDetailed: typeof ensureTelegramDaemonRunningDetailed;
     runTelegramSetup: typeof runTelegramSetup;
+    resolveTelegramSetupPreflight: typeof resolveTelegramSetupPreflight;
     proposedTelegramIdentity: typeof proposedTelegramIdentity;
     reconcileCommittedTelegramConfiguration: typeof reconcileCommittedTelegramConfiguration;
     saveTelegramInactive: typeof saveTelegramInactive;

package/dist/types/modes/interactive-mode.d.ts

@@ -3,7 +3,7 @@ import type { CompactionOutcome } from "@gajae-code/agent-core/compaction";
 import type { AssistantMessage, ImageContent, Message, UsageReport } from "@gajae-code/ai";
 import type { Component, EditorTheme, SlashCommand } from "@gajae-code/tui";
 import { Container, Loader, Spacer, Text, TUI } from "@gajae-code/tui";
-import { KeybindingsManager } from "../config/keybindings";
+import { KeybindingsManager, type KeyDisplayContext } from "../config/keybindings";
 import { type Settings } from "../config/settings";
 import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
@@ -30,9 +30,11 @@ import { GoalModeController } from "./controllers/goal-mode-controller";
 import { PlanModeController } from "./controllers/plan-mode-controller";
 import { IrcObservationLedger } from "./irc-observation-ledger";
 import { OAuthManualInputManager } from "./oauth-manual-input";
+import { PromptSuggestionController } from "./prompt-suggestion-controller";
 import type { Theme } from "./theme/theme";
 import { type CompactionQueuedMessage, type ComposerSubmissionOptions, type InteractiveModeContext, type IrcArrivalSnapshot, type SubmittedUserInput, type TodoItem, type TodoPhase, type TranscriptRebuildPolicy } from "./types";
 import type { ParsedIrcMessage } from "./utils/irc-message";
+export declare function getDefaultComposerPlaceholder(context?: KeyDisplayContext): string;
 export declare const DEFAULT_COMPOSER_PLACEHOLDER: string;
 export declare function getWelcomeTranscriptReservedRows(chatContainer: Container, width: number): number;
 export type WelcomeBannerSettingMode = "auto" | "unicode" | "square" | "ascii";
@@ -50,6 +52,7 @@ export interface InteractiveModeOptions {
     /** Additional initial messages to queue */
     initialMessages?: string[];
 }
+export declare function selectShutdownDraft(editorText: string, hasActiveBtw: boolean): string;
 export declare class InteractiveMode implements InteractiveModeContext {
     #private;
     session: AgentSession;
@@ -114,12 +117,13 @@ export declare class InteractiveMode implements InteractiveModeContext {
     fileSlashCommands: Set<string>;
     skillCommands: Map<string, Skill>;
     oauthManualInput: OAuthManualInputManager;
+    promptSuggestion: PromptSuggestionController;
     readonly lspServers: LspStartupServerInfo[] | undefined;
     mcpManager?: import("../runtime-mcp").MCPManager;
     /** Direct controller capabilities for consumers that coordinate mode transitions. */
     get planModeController(): PlanModeController;
     get goalModeController(): GoalModeController;
-    constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: import("../runtime-mcp").MCPManager, eventBus?: EventBus);
+    constructor(session: AgentSession, version: string, changelogMarkdown?: string | undefined, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers?: LspStartupServerInfo[] | undefined, mcpManager?: import("../runtime-mcp").MCPManager, eventBus?: EventBus, keyDisplayContext?: KeyDisplayContext);
     getCurrentSessionNotificationStatus(): NotificationSessionStatus | undefined;
     setCurrentSessionNotificationsEnabled(enabled: boolean): Promise<NotificationSessionReconcileResult | undefined>;
     init(): Promise<void>;
@@ -261,6 +265,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleImagePaste(): Promise<boolean>;
     handleBtwCommand(question: string): Promise<void>;
     hasActiveBtw(): boolean;
+    handleBtwFollowUp(question: string): Promise<"accepted" | "busy" | "closed" | "rejected">;
     handleBtwEscape(): boolean;
     cycleThinkingLevel(): void;
     cycleRoleModel(options?: {

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

@@ -22,10 +22,15 @@ interface PromptActionAutocompleteOptions {
     moveCursorToMessageStart: () => void;
     moveCursorToLineStart: () => void;
     moveCursorToLineEnd: () => void;
+    /**
+     * Ghost-text next-prompt prediction shown in the empty composer as a dim
+     * inline hint (Tab accepts it via the editor's onTab handler).
+     */
+    getPromptSuggestion?: () => string | null;
 }
 export declare class PromptActionAutocompleteProvider implements AutocompleteProvider {
     #private;
-    constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[]);
+    constructor(commands: SlashCommand[], basePath: string, actions: PromptActionDefinition[], getPromptSuggestion?: () => string | null);
     getSuggestions(lines: string[], cursorLine: number, cursorCol: number): Promise<{
         items: AutocompleteItem[];
         prefix: string;

package/dist/types/modes/prompt-suggestion-controller.d.ts

@@ -0,0 +1,35 @@
+import type { InteractiveModeContext } from "./types";
+/**
+ * Owns the ghost-text next-prompt prediction lifecycle for interactive mode.
+ *
+ * After each agent turn ends (and only when `promptSuggestions` is enabled
+ * and the composer is empty), a smol-model prediction of the user's next
+ * prompt is generated in the background. The result renders as dim ghost
+ * text in the empty composer via the autocomplete provider's inline hint;
+ * Tab accepts it, typing dismisses it, and a new turn clears it.
+ */
+export declare class PromptSuggestionController {
+    #private;
+    constructor(ctx: InteractiveModeContext);
+    /** Current suggestion to render as ghost text, or null. */
+    get current(): string | null;
+    /** Drop the current suggestion and invalidate any in-flight generation. */
+    clear(): void;
+    /** A new agent turn started; any pending suggestion is stale. */
+    onAgentStart(): void;
+    /**
+     * Editor content changed. A non-empty composer means the user is writing
+     * their own prompt: dismiss the suggestion and cancel pending generation.
+     */
+    notifyEditorChanged(text: string): void;
+    /**
+     * Agent turn ended; kick off background generation when the feature is
+     * enabled and the composer is idle and empty.
+     */
+    onAgentEnd(): void;
+    /**
+     * Tab handler for the composer: accept the suggestion when the composer
+     * is empty. Returns true when Tab was consumed.
+     */
+    tryAcceptOnTab(text: string): boolean;
+}

package/dist/types/modes/shared/agent-wire/workflow-gate-broker.d.ts

@@ -59,7 +59,7 @@ export interface AskSelectedAckRecoveryParticipant {
 }
 /** SDK-native surface for emitting a workflow gate and awaiting its answer. */
 export interface WorkflowGateEmitter {
-    isUnattended(): boolean;
+    supportsRemoteGateAnswers(): boolean;
     emitGate(input: OpenGateInput): Promise<unknown>;
     onGateEmitted?(listener: (gate: WorkflowGate) => void): () => void;
     resolveGate?(response: WorkflowGateResponse): Promise<WorkflowGateResolution>;
@@ -96,7 +96,7 @@ export interface WorkflowGateEmitter {
 export declare class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
     #private;
     constructor(runId: string, store: GateStore, emitterHooks?: Pick<BrokerHooks, "advance">);
-    isUnattended(): boolean;
+    supportsRemoteGateAnswers(): boolean;
     setRuntimeTurnProvider(provider: (() => string | undefined) | null): void;
     emitGate(input: OpenGateInput): Promise<unknown>;
     onGateEmitted(listener: (gate: WorkflowGate) => void): () => void;

package/dist/types/modes/types.d.ts

@@ -27,6 +27,7 @@ import type { ToolExecutionHandle } from "./components/tool-execution";
 import type { StatusLineComponent } from "./components/tool-status-header";
 import type { IrcObservationLedger } from "./irc-observation-ledger";
 import type { OAuthManualInputManager } from "./oauth-manual-input";
+import type { PromptSuggestionController } from "./prompt-suggestion-controller";
 import type { Theme } from "./theme/theme";
 import type { ParsedIrcMessage } from "./utils/irc-message";
 export type TranscriptRebuildPolicy = "replace-identity" | "reconcile-same-transcript";
@@ -133,6 +134,8 @@ export interface InteractiveModeContext {
     skillCommands: Map<string, Skill>;
     oauthManualInput: OAuthManualInputManager;
     todoPhases: TodoPhase[];
+    /** Ghost-text next-prompt prediction; absent in ACP/lightweight test contexts. */
+    promptSuggestion?: PromptSuggestionController;
     init(): Promise<void>;
     shutdown(): Promise<void>;
     checkShutdownRequested(): Promise<void>;
@@ -295,6 +298,7 @@ export interface InteractiveModeContext {
     handleBackgroundCommand(): void;
     handleImagePaste(): Promise<boolean>;
     handleBtwCommand(question: string): Promise<void>;
+    handleBtwFollowUp(question: string): Promise<"accepted" | "busy" | "closed" | "rejected">;
     hasActiveBtw(): boolean;
     handleBtwEscape(): boolean;
     cycleThinkingLevel(): void;

package/dist/types/modes/utils/hotkeys-markdown.d.ts

@@ -1,5 +1,6 @@
 import type { KeybindingsManager } from "../../config/keybindings";
 export interface HotkeysMarkdownBindings {
-    keybindings: Pick<KeybindingsManager, "getDisplayString">;
+    keybindings: Pick<KeybindingsManager, "formatAccessibleKeyHint" | "getAccessibleDisplayString">;
 }
+export declare function formatHotkeyMarkdownCode(label: string, escapeTablePipes?: boolean): string;
 export declare function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string;

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

@@ -0,0 +1,7 @@
+export declare const MCP_MAX_CONTENT_BYTES: number;
+export declare const MCP_MAX_ERROR_BYTES: number;
+export declare const MCP_MAX_SSE_REQUEST_MESSAGES = 1024;
+export declare const MCP_MAX_SSE_BATCH_MESSAGES = 1024;
+export declare const MCP_HTTP_TIMEOUT_MS = 30000;
+export declare function cancelMCPStream(stream: ReadableStream<Uint8Array> | null): void;
+export declare function readMCPResponseText(response: Response, limit: number, truncate?: boolean, signal?: AbortSignal): Promise<string>;

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

@@ -1,4 +1,4 @@
-import type { TSchema } from "@gajae-code/ai";
+import { type TSchema } from "@gajae-code/ai";
 import type { SourceMeta } from "../capability/types";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { AuthStorage } from "../session/auth-storage";

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

@@ -52,8 +52,3 @@ export declare class MCPOAuthFlow extends OAuthCallbackFlow {
     }>;
     exchangeToken(code: string, _state: string, redirectUri: string): Promise<OAuthCredentials>;
 }
-/**
- * Refresh an MCP OAuth token using the standard refresh_token grant.
- * Returns updated credentials; preserves the old refresh token if the server doesn't rotate it.
- */
-export declare function refreshMCPOAuthToken(tokenUrl: string, refreshToken: string, clientId?: string, clientSecret?: string): Promise<OAuthCredentials>;

package/dist/types/runtime-mcp/plugin-network-boundary.d.ts

@@ -0,0 +1,14 @@
+import { type AddressResolver } from "../web/insane/url-guard";
+import type { MCPHttpServerConfig, MCPSseServerConfig } from "./types";
+/** Mark an in-memory plugin-bundle remote MCP config for connection-bound public-network enforcement. */
+export declare function bindPluginMcpToPublicNetwork<T extends MCPHttpServerConfig | MCPSseServerConfig>(config: T): T;
+/** The marker is an internal symbol, so persisted user MCP configs cannot opt into or forge this path. */
+export declare function isPluginMcpPublicNetworkBound(config: MCPHttpServerConfig | MCPSseServerConfig): boolean;
+/**
+ * Fetch a plugin-bundle MCP request through a DNS-pinned public address. Every
+ * redirect is handled manually and revalidated before the next connection.
+ */
+export declare function fetchPluginMcpRequest(rawUrl: string, init: BunFetchRequestInit, options?: {
+    resolver?: AddressResolver;
+    maxRedirects?: number;
+}): Promise<Response>;

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

@@ -1,4 +1,5 @@
 import type { NativeDirectoryTreeSnapshot } from "@gajae-code/natives";
+import type { ModelProfileErrorDetails } from "../../config/model-profile-contract";
 import { type DirectoryMigrationPolicy } from "../session-directory";
 import { type BrokerDiscovery, type RedactedBrokerDiscovery } from "./discovery";
 import { type LifecycleDurableEffectsReceipt, LifecycleLedger, type LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
@@ -93,6 +94,7 @@ export type BrokerResponse = {
     error: {
         code: BrokerErrorCode;
         message: string;
+        details?: ModelProfileErrorDetails;
         endpoint?: "unavailable";
         cleanup?: BrokerCleanupEvidence;
     };