@gajae-code/coding-agent 0.11.7 → 0.11.9

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

@@ -1,3 +1,4 @@
+import { computeAmbiguityFloor, type DeepInterviewAmbiguityMilestone } from "./deep-interview-ambiguity";
 /**
  * Pure, dependency-free foundation for deep-interview state shape.
  *
@@ -35,10 +36,6 @@ export interface DeepInterviewTriggerMetadata {
     status: DeepInterviewTriggerStatus;
     component: string;
     dimension: string;
-    priorDimensionScore?: number;
-    newDimensionScore?: number;
-    priorAmbiguity?: number;
-    newAmbiguity?: number;
     evidence?: string;
     contradictedFactId?: string;
     /** Required when status is `disputed` or `unresolved` to exempt the invariant. */
@@ -68,9 +65,11 @@ export interface DeepInterviewRoundRecord {
     /** Deterministic floor in effect when this round was scored, when it clamped. */
     ambiguity_floor?: number;
     triggers?: DeepInterviewTriggerMetadata[];
+    round_result_digest?: string;
 }
 export interface DeepInterviewStateEnvelope {
     threshold?: number;
+    threshold_units?: number;
     threshold_source?: string;
     state?: Record<string, unknown>;
     [key: string]: unknown;
@@ -197,3 +196,135 @@ export declare function assertDeepInterviewIntentReview(value: unknown, locked:
     round: unknown;
     answer_hash: unknown;
 }[]): asserts value is DeepInterviewIntentReview;
+export type DeepInterviewDimension = "goal" | "constraints" | "criteria" | "context";
+export type DeepInterviewResolution = "auto_research_accepted" | "auto_answer" | "direct" | "refined" | "cited_confirmation";
+export interface DeepInterviewFactOperation {
+    op: "add" | "dispute" | "supersede";
+    id: string;
+    statement?: string;
+    component?: string;
+    dimension?: DeepInterviewDimension;
+    evidence?: string;
+    target_id?: string;
+}
+export interface DeepInterviewOntologyEntity {
+    id: string;
+    name: string;
+    type: string;
+    fields: string[];
+}
+export interface DeepInterviewOntologyRelationship {
+    id: string;
+    from_entity_id: string;
+    to_entity_id: string;
+    type: string;
+}
+export interface DeepInterviewOntologyReasoning {
+    statement: string;
+    evidence?: string;
+}
+export interface DeepInterviewOntologyInput {
+    entities: DeepInterviewOntologyEntity[];
+    relationships: DeepInterviewOntologyRelationship[];
+    reasoning: DeepInterviewOntologyReasoning[];
+}
+export interface DeepInterviewComponentUpdate {
+    component_id: string;
+    scores: Record<DeepInterviewDimension, number>;
+}
+/**
+ * Optional legacy assertions accepted only when they agree with the native
+ * target. The persisted target is always derived from component scores.
+ */
+export interface DeepInterviewTargetingInput {
+    target_component_id?: string;
+    target_dimension?: DeepInterviewDimension;
+    weakest_component_id?: string;
+    weakest_dimension?: DeepInterviewDimension;
+    last_targeted_component_id?: string | null;
+}
+export interface DeepInterviewRoundBookkeeping {
+    resolution: DeepInterviewResolution;
+    round_ids?: string[];
+    counter_deltas?: Record<string, number>;
+}
+/**
+ * Closed evidence submitted for one scoring transaction. All convergence values
+ * (ambiguity, floor, milestone, ontology counts, rotation, and streak) are
+ * native-derived and intentionally cannot be supplied here.
+ */
+export interface DeepInterviewRoundResultV1 {
+    global_scores: Record<DeepInterviewDimension, number>;
+    component_updates?: DeepInterviewComponentUpdate[];
+    targeting?: DeepInterviewTargetingInput;
+    triggers?: DeepInterviewTriggerMetadata[];
+    fact_ops?: DeepInterviewFactOperation[];
+    ontology?: DeepInterviewOntologyInput | DeepInterviewOntologyEntity[];
+    bookkeeping?: DeepInterviewRoundBookkeeping;
+    /** Compatibility adapter for recorder callers; never persisted as the v1 wire shape. */
+    component_scores?: Record<string, Record<DeepInterviewDimension, number>>;
+    auto_answered?: boolean;
+}
+/**
+ * Version 1 native projection returned by `apply-round-result` as
+ * `native_projection`. This is the complete renderable convergence surface;
+ * callers must not derive or supplement it from candidate scorer input.
+ */
+export interface DeepInterviewRoundResultProjection {
+    score_units: Partial<Record<DeepInterviewDimension, number>>;
+    weighted_ambiguity: number;
+    weighted_ambiguity_units: number;
+    floor: number;
+    floor_units: number;
+    floor_cause: ReturnType<typeof computeAmbiguityFloor>;
+    effective_ambiguity: number;
+    effective_ambiguity_units: number;
+    prior_effective_ambiguity: number | null;
+    direction: "increased" | "decreased" | "unchanged" | "initial";
+    ambiguity_milestone: DeepInterviewAmbiguityMilestone;
+    topology: unknown;
+    topology_counts: {
+        active: number;
+        deferred: number;
+        total: number;
+    };
+    ontology: unknown;
+    ontology_counts: {
+        stable: number;
+        changed: number;
+        new: number;
+        basis: string;
+    };
+    targeting: {
+        target_component_id: string | null;
+        target_dimension: DeepInterviewDimension | null;
+        last_targeted_component_id: string | null;
+    };
+    transition: {
+        round_key: string;
+        lifecycle: "scored";
+        auto_answer_streak: number;
+    };
+}
+export type DeepInterviewApplyRoundResult = {
+    kind: "noop";
+    envelope: DeepInterviewStateEnvelope;
+    projection?: DeepInterviewRoundResultProjection;
+} | {
+    kind: "write";
+    envelope: DeepInterviewStateEnvelope;
+    projection: DeepInterviewRoundResultProjection;
+};
+/** Strict UTF-8 JSON serialization used by v1 replay digests. */
+export declare function canonicalDeepInterviewJson(value: unknown): string;
+export declare function deepInterviewRoundResultDigest(input: {
+    round: number;
+    question_id: string;
+    round_id?: string | null;
+    result: unknown;
+}): string;
+/** Complete persisted answer identity; omitted optional values normalize to null. */
+export declare function deepInterviewAnswerIdentityEqual(a: Pick<DeepInterviewRoundRecord, "round" | "round_key" | "round_id" | "question_id" | "component" | "dimension" | "question_text" | "question_hash" | "selected_options" | "custom_input">, b: Pick<DeepInterviewRoundRecord, "round" | "round_key" | "round_id" | "question_id" | "component" | "dimension" | "question_text" | "question_hash" | "selected_options" | "custom_input">): boolean;
+/** Apply one closed v1 scoring round. The input contains evidence only; all convergence state is derived here. */
+export declare function applyDeepInterviewRoundResultV1(envelopeValue: unknown, roundKey: string, result: DeepInterviewRoundResultV1, now: string): DeepInterviewApplyRoundResult;
+export declare function validateDeepInterviewV1Envelope(value: Record<string, unknown>): void;

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/state-writer.d.ts

@@ -46,6 +46,47 @@ export interface WorkflowEnvelopeIntegrityMismatch {
     expected: string;
     actual: string;
 }
+export type WorkflowReceiptVerification = "legacy" | "native-valid" | "receipt-malformed" | "receipt-missing" | "checksum-mismatch";
+export interface GuardedWorkflowEnvelopeTransformOptions extends StateWriterOptions {
+    expectedRevision: number;
+    /** Additional native schema validation applied to both current and candidate envelopes. */
+    validate?: (value: Record<string, unknown>, legacy: boolean) => void;
+    transform: (current: Record<string, unknown>, context: {
+        revision: number;
+        legacy: boolean;
+    }) => {
+        kind: "noop";
+    } | {
+        kind: "write";
+        value: Record<string, unknown>;
+    } | Promise<{
+        kind: "noop";
+    } | {
+        kind: "write";
+        value: Record<string, unknown>;
+    }>;
+}
+export interface GuardedWorkflowEnvelopeWarning {
+    code: "DI_POST_COMMIT_AUDIT_FAILED";
+    message: string;
+}
+export type GuardedWorkflowEnvelopeTransformResult = {
+    path: string;
+    written: false;
+    reason: "noop";
+    revision: number;
+    warnings: [];
+} | {
+    path: string;
+    written: true;
+    revision: number;
+    stamped: Record<string, unknown>;
+    warnings: GuardedWorkflowEnvelopeWarning[];
+};
+export declare class GuardedWorkflowEnvelopeError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
 export interface WorkflowTransactionJournal {
     version: 1;
     mutation_id: string;
@@ -80,6 +121,7 @@ export interface StateWriterOptions {
     receipt?: StateWriterReceiptContext;
     audit?: StateWriterAuditContext;
     sourceRevision?: number;
+    orderingRevision?: number;
     /**
      * Cross-process lock tuning for read-modify-write paths that route through
      * `withWorkflowStateLock` / `updateJsonAtomic`. Omit for the hardened
@@ -141,6 +183,7 @@ export type StrictMutationReadResult = {
 };
 export declare function readExistingStateForMutation(filePath: string): Promise<StrictMutationReadResult>;
 export declare function workflowEnvelopeContentSha256(value: unknown): string;
+export declare function verifyWorkflowEnvelopeReceiptValue(value: unknown, filePath: string): WorkflowReceiptVerification;
 export declare function stampWorkflowEnvelopeChecksum<T>(value: T, filePath: string, computedAt?: string): T;
 export declare function detectWorkflowEnvelopeIntegrityMismatch(filePath: string): Promise<WorkflowEnvelopeIntegrityMismatch | undefined>;
 type ActiveStateCacheInvalidator = (cwd?: string, sessionId?: string) => void;
@@ -148,6 +191,7 @@ export declare function setActiveStateCacheInvalidator(invalidator: ActiveStateC
 export declare function persistedStateRevision(value: unknown): number;
 export declare function writeGuardedJsonAtomic(targetPath: string, value: unknown, options: GuardedStateWriterOptions): Promise<GuardedWriteResult>;
 export declare function writeGuardedWorkflowEnvelopeAtomic(targetPath: string, value: unknown, options: GuardedStateWriterOptions): Promise<GuardedWriteResult>;
+export declare function transformGuardedWorkflowEnvelopeAtomic(targetPath: string, options: GuardedWorkflowEnvelopeTransformOptions): Promise<GuardedWorkflowEnvelopeTransformResult>;
 export declare function writeJsonAtomic(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function writeWorkflowEnvelopeAtomic(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function writeTextAtomic(targetPath: string, text: string, options?: StateWriterOptions): Promise<string>;

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

@@ -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[];

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

@@ -1,4 +1,5 @@
 import type { WorkflowHudSummary } from "../skill-state/active-state";
+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";
@@ -96,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;
@@ -308,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;
@@ -316,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;

package/dist/types/gjc-runtime/workflow-manifest.d.ts

@@ -1,7 +1,6 @@
 /**
  * TypeScript is the authoritative source of truth for GJC workflow manifests.
- * Any JSON manifest projection is derived from this module and must never be
- * hand-edited.
+ * Keep the checked-in JSON projection synchronized manually with this module.
  */
 import { type CanonicalGjcWorkflowSkill } from "../skill-state/canonical-skills";
 export interface WorkflowState {
@@ -18,7 +17,9 @@ export interface WorkflowVerb {
     name: string;
     planned?: boolean;
     /** Invocation surface that exposes this verb in the real CLI parser. */
-    surface?: "state-action" | "command-positional" | "command-flag";
+    surface?: "state-action" | "command-positional" | "command-flag" | "draft-action";
+    /** Legacy surface retained for callers that have not migrated to normal typed commands. */
+    compatibilityOnly?: boolean;
 }
 export interface TypedArgSpec {
     name: string;
@@ -26,6 +27,7 @@ export interface TypedArgSpec {
     enumValues?: string[];
     required?: boolean;
     appliesToVerbs?: string[];
+    compatibilityOnly?: boolean;
     planned?: boolean;
 }
 export interface RetentionPolicy {

package/dist/types/main.d.ts

@@ -153,6 +153,14 @@ export interface ModelRoleOverrides {
  * 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/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";
@@ -47,6 +47,7 @@ export interface StatusLineComponentOptions {
     actionRegistry?: ActionRegistry<void>;
     getKeybindings?: () => KeybindingsManager;
     focusDomain?: FocusDomain;
+    keyDisplayContext?: KeyDisplayContext;
 }
 export interface StatusLineActionHint {
     id: AppKeybinding;
@@ -57,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
@@ -43,3 +45,5 @@ export declare class WelcomeComponent implements Component {
     setLspServers(servers: LspServerInfo[]): void;
     render(termWidth: number): string[];
 }
+/** Resolve the intro cadence without making tests mutate global process state. */
+export declare function resolveWelcomeIntroTickMs(platform?: NodeJS.Platform, tmux?: string | undefined): number;

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";
@@ -115,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>;

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>;

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/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>;