@gajae-code/coding-agent 0.18.11 → 0.19.0

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

@@ -1,3 +1,4 @@
+import { type ProjectEnvSnapshot } from "@gajae-code/utils/env-file";
 import { type ProviderAuthority } from "./tmux-common";
 import { type OwnerIsolationProbeSync, type OwnerVerdict, type PlanResponse, type TmuxOwnerIsolationExecutionDependencies, type TmuxOwnerIsolationExecutionResult } from "./tmux-owner-isolation";
 export interface ManagedTmuxLaunchSpec {
@@ -106,6 +107,29 @@ export type CreateOwnerIsolationTestDependencies = {
 export declare function __setCreateOwnerIsolationForTests(dependencies: CreateOwnerIsolationTestDependencies | null): void;
 /** @internal Test-only seam; production mutations always use live fail-closed proofs. */
 export declare function __setMutationServerProofForTests(dependency: ((tmuxCommand: string, env: NodeJS.ProcessEnv) => unknown) | null): void;
+/**
+ * Drop project-dotenv copies of the tmux session name, coordinator id, and
+ * state-file path. A pin is kept only when every snapshot accepts it, so a
+ * declaration Bun loaded before `chdir` is refused even if the launch cwd no
+ * longer contains that file. Acceptance uses the shared helper, but the
+ * original string stays: callers trim at use, and a later check must see the
+ * same value that was accepted.
+ */
+export declare function trustedTmuxLaunchIdentityEnv(env: NodeJS.ProcessEnv, snapshots: readonly ProjectEnvSnapshot[]): NodeJS.ProcessEnv;
+export declare function tmuxLaunchIdentityEnv(env: NodeJS.ProcessEnv, cwd: string): NodeJS.ProcessEnv;
+/**
+ * Session id the launched child must see. A trusted pin is passed through.
+ * A rejected project pin is replaced by the same fallback the launch plan uses
+ * for the session root, which also stops Bun from reloading that dotenv value
+ * (`GJC_TMUX_LAUNCHED=1` skips the planner filter). An omitted id stays omitted.
+ */
+export declare function resolvedChildGjcSessionId(input: {
+    trusted: string | undefined;
+    inherited: string | undefined;
+    projectDeclared: boolean;
+    fallback: string;
+}): string | undefined;
+export declare function childGjcSessionIdAssignment(env: NodeJS.ProcessEnv, identityEnv: NodeJS.ProcessEnv, cwd: string, fallbackSessionId: string): Record<string, string>;
 export declare function listGjcTmuxSessions(env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus[];
 /** @internal */
 export declare function listTmuxSessionsForGc(env?: NodeJS.ProcessEnv): GjcTmuxSessionsForGc;

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

@@ -28,11 +28,17 @@ export declare function computeUltragoalReviewSourceHash(changeSet: UltragoalCha
 export declare function spawnText(command: string[], options: {
     cwd: string;
     timeoutMs?: number;
+    stdin?: string;
 }): Promise<{
     ok: boolean;
     stdout: string;
     stderr: string;
 }>;
+/**
+ * The canonical empty tree object for SHA-1 repositories. Use getEmptyTreeId()
+ * to derive the format-specific ID for a given repository.
+ */
+export declare const GIT_EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 export declare function resolveGitBase(cwd: string, branch?: string): Promise<string>;
 export declare function parseGitNameStatus(output: string): UltragoalChangeSetPath[];
 export declare function parseGitUntrackedPaths(output: string): UltragoalChangeSetPath[];

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

@@ -191,6 +191,7 @@ export declare function resolveUltragoalNudgeBudget(cwd: string, agentDir?: stri
 export declare function selectUltragoalNudgeTarget(plan: UltragoalPlan, options?: {
     currentGoalObjective?: string;
     retryFailed?: boolean;
+    excludedGoalIds?: readonly string[];
 }): UltragoalNudgeTarget | null;
 /**
  * Atomic consuming writer. Locks the ledger path, rereads + counts nudge rows for the

package/dist/types/harness-control-plane/receipt-spool.d.ts

@@ -10,6 +10,10 @@ export interface ReceiptSpoolAppendResult {
     cursor: string;
     path: string;
 }
+/** True only when an exception's `code` is `ENOENT`. Other codes propagate. */
+export declare function isEnoent(error: unknown): boolean;
+/** A spool directory the startup project snapshot does not declare. */
+export declare function trustedReceiptSpoolDir(raw: string | undefined): string | undefined;
 /** @internal Test-only instrumentation for steady-state spool scan coverage. */
 export declare function receiptSpoolFullScanCountForTesting(): number;
 /** @internal Test-only cache reset. */

package/dist/types/hindsight/content.d.ts

@@ -20,12 +20,11 @@ export interface RecallResultLike {
 /**
  * Strip `<memories>`, `<mental_models>`, and legacy memory blocks.
  *
- * Both `<memories>` (per-turn recall) and `<mental_models>` (curated semantic
- * memory) are injected into the system prompt. If either leaks into the
- * retention transcript, every retain becomes a tighter feedback loop —
- * paraphrased memories feed the next consolidation, which feeds the next
- * mental-model refresh, which feeds the next retain. Always strip before
- * retaining.
+ * Matching is case-insensitive and allows whitespace inside the tag.
+ * Both per-turn recall and curated mental models are injected around the
+ * prompt. If a closer, a case variant, or an early-ended frame leaks into
+ * the retention transcript, the next retain stores the breakout as a new
+ * memory. Always strip before retaining.
  */
 export declare function stripMemoryTags(content: string): string;
 /** Format recall results into a bullet list for context injection. */

package/dist/types/internal-urls/types.d.ts

@@ -20,6 +20,8 @@ export interface InternalResource {
     size?: number;
     /** Underlying filesystem path (for debugging, not exposed to agent) */
     sourcePath?: string;
+    /** True when model-facing reads must wrap the selected content as untrusted. */
+    untrusted?: boolean;
     /** Additional notes about resolution */
     notes?: string[];
     /**

package/dist/types/lsp/clients/swiftlint-client.d.ts

@@ -1,7 +1,3 @@
-/**
- * SwiftLint CLI-based linter client.
- * Parses SwiftLint's JSON reporter output into LSP Diagnostic format.
- */
 import type { Diagnostic, LinterClient, ServerConfig } from "../../lsp/types";
 /**
  * SwiftLint CLI-based linter client.

package/dist/types/main.d.ts

@@ -6,7 +6,7 @@
  */
 import type { ImageContent } from "@gajae-code/ai/core";
 import { postmortem } from "@gajae-code/utils";
-import type { Args } from "./cli/args";
+import { type Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
 import { Settings } from "./config/settings";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
@@ -45,7 +45,7 @@ export declare function initializeInteractiveModeWithStartupUpdate(mode: Startup
  * Every other local-session flag is rejected so the broker-backed ACP host
  * never appears to accept options it cannot apply to its remote session.
  */
-export declare function resolveAcpStartupOptions(parsed: Pick<Args, "allowHome" | "apiKey" | "appendSystemPrompt" | "credential" | "preferCredential" | "continue" | "default" | "cwd" | "fileArgs" | "fork" | "hooks" | "messages" | "mpreset" | "mcpConfig" | "model" | "models" | "noLsp" | "noMcp" | "noPty" | "noRules" | "noSession" | "noSkills" | "noTitle" | "noTools" | "pluginDirs" | "print" | "provider" | "providerSessionId" | "resume" | "sessionDir" | "skills" | "slow" | "smol" | "plan" | "systemPrompt" | "thinking" | "tmux" | "tools" | "extensions" | "unknownFlags">, sessionOptions: Pick<CreateAgentSessionOptions, "model" | "modelPattern" | "thinkingLevel">): AcpStartupOptions;
+export declare function resolveAcpStartupOptions(parsed: Pick<Args, "allowHome" | "apiKey" | "appendSystemPrompt" | "credential" | "preferCredential" | "continue" | "default" | "cwd" | "fileArgs" | "fork" | "hooks" | "messages" | "mpreset" | "mcpConfig" | "model" | "models" | "noLsp" | "noMcp" | "noPty" | "noRules" | "noSession" | "noSkills" | "noTitle" | "noTools" | "pluginDirs" | "print" | "provider" | "providerSessionId" | "resume" | "sessionDir" | "skills" | "plan" | "systemPrompt" | "thinking" | "tmux" | "tools" | "extensions" | "unknownFlags">, sessionOptions: Pick<CreateAgentSessionOptions, "model" | "modelPattern" | "thinkingLevel">): AcpStartupOptions;
 declare function readPipedInput(): Promise<string | undefined>;
 export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
@@ -130,6 +130,7 @@ type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promis
 export interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     createSessionManager?: typeof createSessionManager;
+    registerDirectSession?: typeof registerDirectSession;
     discoverAuthStorage?: typeof discoverAuthStorage;
     resolveStartupAuthConfig?: typeof resolveStartupAuthConfig;
     runAcpMode?: (options?: {
@@ -173,25 +174,29 @@ interface DirectSessionRegistrationDependencies {
         attestationEpoch: string;
     };
 }
-/** Register a durable direct CLI session while leaving ephemeral sessions lock-free. */
-export declare function registerDirectSession(sessionManager: DirectSessionManager | undefined, agentDir: string, lifecycleRequestId: string | undefined, dependencies?: DirectSessionRegistrationDependencies): Promise<void>;
-export interface ModelRoleOverrides {
-    smol?: string;
-    slow?: string;
-    plan?: string;
-}
 /**
- * Resolve the ephemeral `smol`/`slow`/`plan` model-role overrides.
+ * Handle for a direct CLI session's broker-index registration.
  *
- * 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.
+ * A direct session registers once at startup, but `/new`, `/resume` and forks
+ * replace the manager's session id inside the same process. The index row is
+ * keyed on that id, so without a follow-up the successor is never indexed and the
+ * predecessor stays live for as long as this pid is alive (the broker keeps
+ * heartbeating a live pid). `syncIdentity` moves the registration to whichever
+ * id the manager the session has adopted currently reports.
  */
-export declare function resolveModelRoleOverrides(parsed: Pick<Args, "smol" | "slow" | "plan">): ModelRoleOverrides;
+export interface DirectSessionRegistration {
+    /**
+     * Register the current manager's session id and release the one it replaced.
+     *
+     * `adoptedManager` rebinds the registration to the manager the session now
+     * owns: a bounded cold-sidecar fork adopts its own forked manager before it
+     * emits `session_switch`, so the wired handler must hand that manager over or
+     * the sync keeps reading the startup manager's predecessor id.
+     */
+    syncIdentity(adoptedManager?: DirectSessionManager): Promise<void>;
+}
+/** Register a durable direct CLI session while leaving ephemeral sessions lock-free. */
+export declare function registerDirectSession(sessionManager: DirectSessionManager | undefined, agentDir: string, lifecycleRequestId: string | undefined, dependencies?: DirectSessionRegistrationDependencies): Promise<DirectSessionRegistration>;
 /**
  * Apply the `--no-pty` / `--no-title` terminal-control flags to the environment.
  *

package/dist/types/migrate/action-planner.d.ts

@@ -1,4 +1,12 @@
-import type { AdapterResult, MigrateAction, MigrateDestinations, MigrateWarning } from "./types";
+/**
+ * Central migration action planner.
+ *
+ * Reads destination state ONCE and produces an immutable list of actions that
+ * both dry-run and live execution consume unchanged. This is the single place
+ * that decides add/update/skip/fail, destinations, and warnings, guaranteeing
+ * dry-run/live parity.
+ */
+import type { AdapterResult, ManualAction, MigrateAction, MigrateDestinations, MigrateWarning } from "./types";
 export interface PlanInput {
     results: AdapterResult[];
     destinations: MigrateDestinations;
@@ -7,5 +15,6 @@ export interface PlanInput {
 export interface PlanOutput {
     actions: MigrateAction[];
     warnings: MigrateWarning[];
+    manualActions: ManualAction[];
 }
 export declare function planMigration(input: PlanInput): Promise<PlanOutput>;

package/dist/types/migrate/adapters/codex.d.ts

@@ -1,5 +1,6 @@
 /**
- * Codex adapter: reads `~/.codex/config.toml` ([mcp_servers]) and `~/.codex/prompts`.
+ * Codex adapter: reads `~/.codex/config.toml` ([mcp_servers]), user prompts,
+ * and user-level `~/.codex/AGENTS.md` instructions. Project AGENTS.md is native GJC input.
  */
 import { type Adapter } from "./index";
 export declare const codexAdapter: Adapter;

package/dist/types/migrate/adapters/index.d.ts

@@ -1,19 +1,39 @@
-import type { AdapterResult, MigrateSource, SkillCandidate, SourceDiagnostic } from "../types";
+import type { AdapterResult, AgentCandidate, InstructionCandidate, MigrateSource, SkillCandidate, SlashCommandCandidate, SourceDiagnostic } from "../types";
 export interface AdapterOptions {
     /** Home directory root; overridable for tests. */
     homeDir: string;
+    /** Source scope for instructions and Claude Code commands. */
+    scope: "project" | "user";
+    /** Project root used when importing project instructions and commands. */
+    cwd: string;
 }
 export interface Adapter {
     source: MigrateSource;
     collect(options: AdapterOptions): Promise<AdapterResult>;
 }
 export declare function getAdapter(source: MigrateSource): Adapter;
+/** Collect one source instruction file without interpreting or rewriting its content. */
+export declare function collectInstructionFile(filePath: string, source: MigrateSource): Promise<{
+    candidates: InstructionCandidate[];
+    diagnostics: SourceDiagnostic[];
+}>;
 /** Read a text file, classifying absence/IO errors into source diagnostics. */
 export declare function readSourceText(filePath: string, source: MigrateSource, type: SourceDiagnostic["type"]): Promise<{
     text: string;
 } | {
     diagnostic: SourceDiagnostic;
 }>;
+/**
+ * Read an optional settings file. A missing file is expected (most setups do not
+ * have every settings file), so unlike `readSourceText` it produces no diagnostic.
+ */
+export declare function readOptionalJson(filePath: string, source: MigrateSource, type: SourceDiagnostic["type"]): Promise<{
+    data: Record<string, unknown>;
+} | {
+    diagnostic: SourceDiagnostic;
+} | {
+    absent: true;
+}>;
 /** Parse JSON text, classifying parse errors into a `failed_invalid_source` diagnostic. */
 export declare function parseSourceJson(text: string, filePath: string, source: MigrateSource, type: SourceDiagnostic["type"]): {
     data: Record<string, unknown>;
@@ -35,6 +55,27 @@ export declare function collectMarkdownPrompts(dir: string, source: MigrateSourc
     candidates: SkillCandidate[];
     diagnostics: SourceDiagnostic[];
 }>;
+/** Bundled agent names an imported agent must never shadow. */
+export declare const PROTECTED_AGENT_NAMES: ReadonlySet<string>;
+/**
+ * Collect subagents from a flat `<agentsDir>/*.md` directory. Frontmatter is
+ * rewritten so the loaded name matches the destination file name, and tool lists
+ * are translated to GJC tools.
+ */
+export declare function collectMarkdownAgents(dir: string, source: MigrateSource): Promise<{
+    candidates: AgentCandidate[];
+    diagnostics: SourceDiagnostic[];
+}>;
+/**
+ * Collect Markdown slash commands. Nested command directories are represented
+ * with colon-separated names, matching Claude Code's `/group:command` syntax.
+ */
+export declare function collectMarkdownCommands(dir: string, source: MigrateSource, options?: {
+    recursive?: boolean;
+}): Promise<{
+    candidates: SlashCommandCandidate[];
+    diagnostics: SourceDiagnostic[];
+}>;
 /**
  * Recursively collect skill candidates from any `**​/SKILL.md` under `root`.
  * The slug derives from the directory that directly contains the `SKILL.md`.

package/dist/types/migrate/executor.d.ts

@@ -1,2 +1,4 @@
 import type { MigrateAction } from "./types";
-export declare function executeActions(actions: MigrateAction[]): Promise<MigrateAction[]>;
+export declare function executeActions(actions: MigrateAction[], options?: {
+    project?: boolean;
+}): Promise<MigrateAction[]>;

package/dist/types/migrate/hook-module.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Render a gjc hook module from imported foreign hook commands.
+ *
+ * Claude Code hooks are shell commands: the runtime writes a JSON payload to
+ * stdin and reads the exit code. `PreToolUse` blocks on exit 2 with stderr as the
+ * reason; every other event is observational. gjc hooks are TypeScript modules
+ * that subscribe to events in-process, so the importer reproduces the foreign
+ * contract rather than rewriting the commands.
+ *
+ * Only events whose semantics are unambiguous are translated. The payload keeps
+ * the foreign field names so an existing script that reads its JSON keeps working;
+ * fields this host cannot supply are omitted instead of guessed, which the module
+ * header states.
+ */
+import type { HookCandidate, MigrateSource } from "./types";
+export declare function isSupportedHookEvent(event: string): boolean;
+/** Foreign events this importer translates, for user-facing messages. */
+export declare const SUPPORTED_HOOK_EVENTS: readonly string[];
+/**
+ * Build the module source. The result is deterministic for a given candidate
+ * list, so a dry-run report and a live write describe the same file.
+ */
+export declare function renderHookModule(source: MigrateSource, candidates: readonly HookCandidate[]): string;

package/dist/types/migrate/report.d.ts

@@ -4,12 +4,13 @@
  * Secret values are never read upstream, so the report only ever contains field
  * names in warnings — but rendering still treats action/warning text as opaque.
  */
-import { type MigrateAction, type MigrateDestinations, type MigrateReport, type MigrateSource, type MigrateWarning } from "./types";
+import { type ManualAction, type MigrateAction, type MigrateDestinations, type MigrateReport, type MigrateSource, type MigrateWarning } from "./types";
 export interface BuildReportInput {
     actions: MigrateAction[];
     warnings: MigrateWarning[];
     sources: MigrateSource[];
     destinations: MigrateDestinations;
+    manualActions: ManualAction[];
     dryRun: boolean;
     project: boolean;
     force: boolean;

package/dist/types/migrate/types.d.ts

@@ -1,8 +1,8 @@
 /**
  * Shared types for `gjc migrate`.
  *
- * Imports MCP servers and skills from other coding agents (Claude Code, Codex,
- * OpenCode) into native GJC config. See the consensus plan under
+ * Imports MCP servers, skills, slash commands, and instruction files from other coding agents
+ * (Claude Code, Codex, OpenCode) into native GJC config. See the consensus plan under
  * `.gjc/plans/ralplan/` for the full taxonomy and force/collision semantics.
  */
 import type { MCPServerConfig } from "../runtime-mcp/types";
@@ -12,7 +12,7 @@ export declare const MIGRATE_SOURCES: readonly MigrateSource[];
 /** Canonical, deterministic ordering used when expanding `--from all` / repeated `--from`. */
 export declare const CANONICAL_SOURCE_ORDER: readonly MigrateSource[];
 /** What kind of thing an action/coverage row is about. */
-export type MigrateItemType = "mcp" | "skill" | "source";
+export type MigrateItemType = "mcp" | "skill" | "command" | "agent" | "hook" | "instruction" | "source";
 /**
  * Per-item outcome taxonomy.
  *
@@ -42,6 +42,28 @@ export interface SkillCandidate {
     content: string;
     warnings: string[];
 }
+/** An instructions file imported as the active GJC AGENTS.md for its scope. */
+export interface InstructionCandidate {
+    source: MigrateSource;
+    name: string;
+    content: string;
+}
+/** A Markdown subagent collected from a foreign coding-agent setup. */
+export interface AgentCandidate {
+    source: MigrateSource;
+    /** Agent name exactly as it will be loaded from `<agentsDir>/<name>.md`. */
+    name: string;
+    /** Full Markdown content with normalized GJC frontmatter. */
+    content: string;
+    warnings: string[];
+}
+/** A Markdown slash command collected from a foreign coding-agent setup. */
+export interface SlashCommandCandidate {
+    source: MigrateSource;
+    /** Name without the leading slash; nested path components use `:`. */
+    name: string;
+    content: string;
+}
 /**
  * Source-level diagnostic for a single source/type pair (e.g. "codex mcp config
  * was malformed"). Distinct from per-item actions so absent/unreadable sources
@@ -53,11 +75,46 @@ export interface SourceDiagnostic {
     status: Extract<MigrationStatus, "skipped_absent_source" | "failed_invalid_source" | "failed_io">;
     message: string;
 }
+/**
+ * A foreign hook command that maps onto a gjc hook event.
+ *
+ * Claude Code hooks are shell commands that receive a JSON payload on stdin and
+ * signal a block with exit code 2; gjc hooks are TypeScript modules. The
+ * importer generates a module that reproduces that contract for the events whose
+ * semantics are unambiguous.
+ */
+export interface HookCandidate {
+    source: MigrateSource;
+    /** Foreign event name, e.g. `PreToolUse`. */
+    event: string;
+    /** Tool-name matcher; empty or absent means every tool. */
+    matcher?: string;
+    /** Shell command exactly as the source declared it. */
+    command: string;
+}
+/**
+ * A source setting the migration cannot express in gjc. Reported instead of
+ * guessed at: silently translating an approval or hook policy would change what
+ * the agent is allowed to do. Secret values are never read, so detail may name
+ * keys but never their contents.
+ */
+export interface ManualAction {
+    source: MigrateSource;
+    /** Setting area, e.g. `hooks`, `settings.model`, `env`. */
+    area: string;
+    /** One-line instruction naming the concrete follow-up. */
+    detail: string;
+}
 /** Normalized candidates + diagnostics returned by an adapter. */
 export interface AdapterResult {
     mcpCandidates: McpCandidate[];
     skillCandidates: SkillCandidate[];
+    slashCommandCandidates: SlashCommandCandidate[];
+    agentCandidates: AgentCandidate[];
+    hookCandidates: HookCandidate[];
+    instructionCandidates: InstructionCandidate[];
     diagnostics: SourceDiagnostic[];
+    manualActions: ManualAction[];
 }
 /** A single planned action consumed identically by dry-run and live execution. */
 export interface MigrateAction {
@@ -80,6 +137,18 @@ export interface MigrateAction {
     skill?: {
         content: string;
     };
+    command?: {
+        content: string;
+    };
+    agent?: {
+        content: string;
+    };
+    hook?: {
+        content: string;
+    };
+    instruction?: {
+        content: string;
+    };
 }
 export interface MigrateWarning {
     source: MigrateSource;
@@ -91,6 +160,11 @@ export type StatusCounts = Record<MigrationStatus, number>;
 export interface MigrateDestinations {
     mcpConfigPath: string;
     skillsDir: string;
+    commandsDir: string;
+    agentsDir: string;
+    /** Directory that receives generated hook modules. */
+    hooksDir: string;
+    instructionsPath: string;
 }
 /** The full machine-readable report emitted with `--json`. */
 export interface MigrateReport {
@@ -105,6 +179,10 @@ export interface MigrateReport {
         byType: {
             mcp: StatusCounts;
             skill: StatusCounts;
+            command: StatusCounts;
+            agent: StatusCounts;
+            hook: StatusCounts;
+            instruction: StatusCounts;
             source: StatusCounts;
         };
         bySource: Record<MigrateSource, StatusCounts>;
@@ -121,6 +199,7 @@ export interface MigrateReport {
         warnings?: string[];
     }>;
     warnings: MigrateWarning[];
+    manualActions: ManualAction[];
 }
 /** Create a zeroed status-count record. */
 export declare function emptyStatusCounts(): StatusCounts;

package/dist/types/modes/components/agent-dashboard.d.ts

@@ -8,7 +8,7 @@ interface AgentDashboardModelContext {
     defaultModelPattern?: string;
     credentialSessionId?: string;
 }
-export declare function resolveAgentCreationModel(modelPatterns: string[], modelRegistry: ModelRegistry, settings: Settings | undefined): import("@gajae-code/ai").Model<import("@gajae-code/ai").Api>;
+export declare function resolveAgentCreationModel(modelPatterns: string[], modelRegistry: ModelRegistry, settings: Settings | undefined, credentialSessionId?: string): import("@gajae-code/ai").Model<import("@gajae-code/ai").Api>;
 export declare function updateAgentModelOverride(overrides: Record<string, ModelSelectorValue>, agentName: string, rawValue: string): Record<string, ModelSelectorValue>;
 export declare class AgentDashboard extends Container {
     #private;

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

@@ -5,10 +5,53 @@ import { type AutoroutingSetup } from "../../config/autorouting-contract";
 import type { GjcModelAssignmentTargetId, ModelRegistry } from "../../config/model-registry";
 import { type ScopedModelSelection } from "../../config/model-resolver";
 import type { ModelProfileConfig } from "../../config/models-config-schema";
+import { type ProviderAuthState } from "../../config/provider-ranking";
 import type { Settings } from "../../config/settings";
 import type { SmartRoutingIntent, SmartRoutingPreview } from "./smart-routing-panel";
 import { SmartRoutingPanelComponent } from "./smart-routing-panel";
+export declare function assignFuzzyScoresToModels(items: ModelItem[], query: string): void;
+/**
+ * Compute and assign fuzzy scores to canonical model items based on a query.
+ */
+export declare function assignFuzzyScoresToCanonicalModels(items: CanonicalModelItem[], query: string): void;
+export interface RankedModelOrderContext {
+    roles: RoleAssignments;
+    mruIndex: ReadonlyMap<string, number>;
+    providerAuthStateById: ReadonlyMap<string, ProviderAuthState>;
+}
+/** Ranking shared by the provider view: fuzzy quality, default, MRU, provider, recency. */
+export declare function compareModelItemsForRanking(a: ModelItem, b: ModelItem, context: RankedModelOrderContext): number;
+/** Ranking shared by the canonical view: fuzzy quality, default, MRU, provider, then id. */
+export declare function compareCanonicalModelItemsForRanking(a: CanonicalModelItem, b: CanonicalModelItem, context: RankedModelOrderContext): number;
+interface ModelItem {
+    kind: "provider";
+    provider: string;
+    id: string;
+    model: Model;
+    selector: string;
+    thinkingLevel?: ThinkingLevel;
+    explicitThinkingLevel?: boolean;
+    fuzzyScore?: number;
+}
+interface CanonicalModelItem {
+    kind: "canonical";
+    id: string;
+    model: Model;
+    selector: string;
+    variantCount: number;
+    searchText: string;
+    normalizedSearchText: string;
+    compactSearchText: string;
+    thinkingLevel?: ThinkingLevel;
+    explicitThinkingLevel?: boolean;
+    fuzzyScore?: number;
+}
 type ScopedModelItem = ScopedModelSelection;
+interface RoleAssignment {
+    model: Model;
+    thinkingLevel: ThinkingLevel;
+}
+type RoleAssignments = Record<string, RoleAssignment | undefined>;
 export type ModelSelectorSelection = {
     kind: "assignment";
     model: Model;

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

@@ -69,6 +69,10 @@ export interface SettingsCallbacks {
     onPetCommit?: (mode: string) => boolean;
     /** Called for status line preview while configuring */
     onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
+    /** Called when a status-line submenu begins an uncommitted preview. */
+    onStatusLinePreviewStart?: () => void;
+    /** Called when a status-line preview is committed, cancelled, or disposed. */
+    onStatusLinePreviewEnd?: () => void;
     /** Get current rendered status line for inline preview */
     getStatusLinePreview?: (width?: number) => string;
     /** Render a status-line preview for supplied draft settings without mutating the live status line. */
@@ -97,6 +101,8 @@ export declare class SettingsSelectorComponent extends Container {
     private readonly notificationsOperations?;
     constructor(context: SettingsRuntimeContext, callbacks: SettingsCallbacks, notificationsOperations?: NotificationsEditorOperations | undefined);
     getFocusComponent(): Component;
+    /** Refresh saved rows and model-profile choices without replacing active editors. */
+    refreshFromConfiguration(availableModelProfiles: readonly string[]): void;
     dispose(): void;
     handleInput(data: string): void;
 }

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

@@ -84,6 +84,8 @@ export declare class SelectorController {
         component: Component;
         focus: Component;
     }): void;
+    /** Refresh accepted disk configuration without discarding an open preview. */
+    refreshConfiguration(): void;
     showCommandPalette(commands: SlashCommand[], actions: CommandPaletteAction[], executeSlashCommand: (name: string) => Promise<void>): void;
     showProviderOnboarding(): void;
     showFrictionlessOnboarding(): Promise<void>;

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

@@ -3,7 +3,7 @@ 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
+ * and the composer is empty), a 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.

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

@@ -27,6 +27,7 @@ export declare class Theme {
     strikethrough(text: string): string;
     inverse(text: string): string;
     getFgAnsi(color: ThemeColor): string;
+    getSvgPalette(): Readonly<Record<string, string>>;
     getBgAnsi(color: ThemeBg): string;
     getColorMode(): ColorMode;
     getThinkingBorderColor(level: ThinkingLevel | Effort): (str: string) => string;

package/dist/types/modes/utils/host-status.d.ts

@@ -1,23 +1,27 @@
 /**
  * Host-terminal agent status markers.
  *
- * Interactive turns announce their state as an OSC 777 sequence:
+ * Interactive turns can announce their state as an OSC 777 sequence:
  *
  *     ESC ] 777 ; notify;Terax;gjc;<event> BEL
  *
- * A terminal that understands the sequence (Terax reads it to drive its per-tab
- * agent status and header bell) reacts; every other terminal discards the OSC
- * as unknown, exactly like the OSC 133 prompt marks and OSC 7 cwd reports that
- * shells emit unconditionally. So there is no host sniffing and no env gate:
- * any host that wants agent status can parse the stream without gjc knowing it
- * exists.
+ * OSC 777 is the rxvt `notify` extension, not a private sequence: a terminal
+ * that implements it does not discard the payload, it raises a desktop
+ * notification. Ghostty parses `777;notify` in `osc/parsers/rxvt_extension.zig`
+ * and maps it to `show_desktop_notification`, so emitting it unconditionally
+ * made every turn pop notifications titled `Terax` in Ghostty and cmux.
  *
- * `notify;Terax;` is the wire identifier of the only protocol that currently
- * carries per-turn agent state, not a host check - the payload names gjc as the
- * reporting agent.
+ * Emission is therefore opt-in. A host that wants per-turn agent status exports
+ * `GJC_HOST_STATUS=terax` from its shell integration; every other host gets no
+ * escape sequence at all. `notify;Terax;` is the wire identifier of that
+ * protocol, and gjc is still named in the payload as the reporting agent.
  *
  * Interactive TUI only. Print and RPC mode stdout stays byte-for-byte parseable
  * because they never reach these controllers.
  */
 export type HostStatusEvent = "working" | "attention" | "finished";
-export declare function emitHostStatus(event: HostStatusEvent, output?: Pick<NodeJS.WriteStream, "write">): void;
+/** The host marker value that opts a terminal into agent-status markers. */
+export declare const HOST_STATUS_MARKER_ENV = "GJC_HOST_STATUS";
+/** Whether the current host opted in to agent-status markers. */
+export declare function hostStatusEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function emitHostStatus(event: HostStatusEvent, output?: Pick<NodeJS.WriteStream, "write">, env?: NodeJS.ProcessEnv): void;