@gajae-code/coding-agent 0.13.2 → 0.14.0

package/dist/types/async/job-manager.d.ts

@@ -129,8 +129,15 @@ export interface SubagentRecord {
         ownerId?: string;
         seq: number;
         message?: string;
+        resumeToolCallId?: string;
         createdAt: number;
     };
+    /** Last queued-resume seq for a CANCELLED queued resume (rec.queued is
+     *  cleared on cancel): retained on the record so owned settlement's second
+     *  proof can still see the generation as provably cancelled, without a
+     *  separate FIFO-capped evidence set that could evict an in-flight
+     *  settlement's generation (review thread P2). */
+    terminalQueuedSeq?: number;
     /** Resolved model the subagent was asked to use, e.g. "openai-codex/gpt-5.5". */
     requestedModel?: string;
     /** Model actually used after auth fallback (#985); equals requestedModel when no fallback. */
@@ -155,7 +162,7 @@ export interface ResumeDescriptor {
  * In-memory resume runner bound to the session that originally launched a
  * subagent. Never serialized: process restart drops it so resume fails closed.
  */
-export type ResumeRunner = (subagentId: string, message?: string, descriptor?: ResumeDescriptor) => string | undefined;
+export type ResumeRunner = (subagentId: string, message?: string, descriptor?: ResumeDescriptor, resumeToolCallId?: string) => string | undefined;
 export interface AsyncJobManagerOptions {
     onJobComplete: (jobId: string, text: string, job?: AsyncJob) => void | Promise<void>;
     maxRunningJobs?: number;
@@ -233,6 +240,9 @@ export interface AsyncJobWaitHandle {
     };
     close(): void;
 }
+export interface AsyncJobWatchHandle {
+    close(): number;
+}
 /**
  * A slice of process-stream output for a background job, as recorded by
  * `appendOutput` / read by `readOutputSince`.
@@ -258,6 +268,41 @@ export declare class AsyncJobManager {
     #private;
     /** Process-global instance shared by internal URL protocol handlers and tools. */
     static instance(): AsyncJobManager | undefined;
+    /** Register a manager for a top-level session endpoint so concurrent
+     *  sessions' owned work can be settled in the ABORTING endpoint's manager
+     *  instead of the last-created process-global instance (review thread P1).
+     *  Returns TRUE when the mapping was installed (or already held by this
+     *  manager); returns FALSE when the endpoint id is already held by a
+     *  FOREIGN live manager — a second top-level session constructed or
+     *  resumed under that endpoint must then fail construction instead of
+     *  silently replacing the first manager, which would make the first
+     *  session's tools resolve the second manager and let same-id jobs be
+     *  queried, registered, or cancelled across sessions (review thread P1). */
+    static registerForEndpoint(endpointId: string, manager: AsyncJobManager): boolean;
+    static forEndpoint(endpointId: string | undefined): AsyncJobManager | undefined;
+    static unregisterForEndpoint(endpointId: string): void;
+    /** Reverse lookup: the endpoint this manager is registered under, if any
+     *  (review thread P1 — endpoint-scoped lineage resolution). */
+    static endpointIdOf(manager: AsyncJobManager | undefined): string | undefined;
+    /** Re-register a manager under a successor endpoint id after a committed
+     *  session-identity transition (newSession / switchSession / handoff).
+     *  Lineage bindings made after the transition use the successor id, so the
+     *  process-global endpoint registry must follow — otherwise
+     *  `endpointIdOf()` keeps resolving the predecessor and a queued subagent
+     *  resume can neither resolve its lineage nor register its owned tuple
+     *  (review thread P1). Returns TRUE when the mapping was moved (or no move
+     *  was needed); returns FALSE when the successor endpoint is owned by a
+     *  FOREIGN live manager — the transition must then abort or roll back
+     *  BEFORE retiring predecessor state, because leaving this manager under
+     *  the predecessor while tools resolve the successor to the foreign
+     *  manager sends jobs to the wrong session and owned aborts lose their
+     *  causal set (review thread P1). */
+    static rekeyForEndpoint(predecessorEndpointId: string, successorEndpointId: string, manager: AsyncJobManager | undefined): boolean;
+    /** Remove every endpoint registration owned by the manager. Disposal-safe:
+     *  covers registrations whose key drifted from the session's current id
+     *  (provider session ids, mid-transition teardown) and stale predecessor
+     *  keys, so teardown cannot leave a dead manager behind. */
+    static unregisterManager(manager: AsyncJobManager | undefined): void;
     /** Install or clear the process-global instance. */
     static setInstance(value: AsyncJobManager | undefined): void;
     /** Reset the process-global instance. Test-only. */
@@ -345,7 +390,7 @@ export declare class AsyncJobManager {
      * descriptor or a legacy session file. Workflow routing keeps `not_found`,
      * `context_unavailable`, `no_runner`, and `resume_failed` distinct.
      */
-    resumeSubagent(subagentId: string, filter?: AsyncJobFilter, message?: string): {
+    resumeSubagent(subagentId: string, filter?: AsyncJobFilter, message?: string, resumeToolCallId?: string): {
         ok: boolean;
         status?: SubagentLifecycle;
         jobId?: string;
@@ -355,6 +400,13 @@ export declare class AsyncJobManager {
     /** Cancel a subagent by stable id across running/paused/queued states (keeps the session file). */
     cancelSubagent(subagentId: string, filter?: AsyncJobFilter): boolean;
     getJob(id: string): AsyncJob | undefined;
+    /**
+     * The EXECUTION promise of the job record whose generation matches the
+     * captured generation, or undefined when the record is gone or rebound.
+     * The promise settles only when the job's function actually unwinds — the
+     * eagerly-updated cancel status is not proof of quiescence (review P1).
+     */
+    getJobPromise(id: string, generation: string): Promise<void> | undefined;
     getRunningJobs(filter?: AsyncJobFilter): AsyncJob[];
     getRecentJobs(limit?: number, filter?: AsyncJobFilter): AsyncJob[];
     getAllJobs(filter?: AsyncJobFilter): AsyncJob[];
@@ -396,6 +448,7 @@ export declare class AsyncJobManager {
     runOwnerCleanups(filter?: AsyncJobFilter): void;
     getDeliveryState(filter?: AsyncJobFilter): AsyncJobDeliveryState;
     hasPendingDeliveries(filter?: AsyncJobFilter): boolean;
+    watchJobGenerations(jobIds: string[]): AsyncJobWatchHandle;
     watchJobs(jobIds: string[]): number;
     unwatchJobs(jobIds: string[]): number;
     acknowledgeDeliveries(jobIds: string[]): number;

package/dist/types/async/support.d.ts

@@ -1,2 +1,16 @@
 import type { Settings } from "../config/settings";
 export declare function isBackgroundJobSupportEnabled(settings: Pick<Settings, "get">): boolean;
+/**
+ * Single source of truth for the AsyncJobManager endpoint key.
+ *
+ * A session with an explicit provider session id is keyed by (provider id,
+ * transcript path); everything else is keyed by its logical session id. The
+ * transcript component is canonicalized so a path alias — symlink, `..`
+ * segment, or unresolved relative path — cannot register the manager under one
+ * key at construction and look it up under another across a session-identity
+ * transition, stranding ownership.
+ *
+ * Both the SDK constructor and AgentSession's transition rekeying must derive
+ * the key here; duplicating the shape lets the two drift apart silently.
+ */
+export declare function asyncJobEndpointId(providerSessionId: string | undefined, sessionId: string, sessionFile: string | undefined): string;

package/dist/types/capability/mcp.d.ts

@@ -13,6 +13,12 @@ export interface MCPServer {
     /** MCP connection pool identity mode; defaults to one lease per session. */
     sharing?: "per-session" | "shared";
     timeout?: number;
+    /**
+     * Protocol preference for remote (http/sse) servers: `auto` (default) negotiates
+     * MCP 2026-07-28 (stateless) first with a bounded observable legacy fallback,
+     * `2026-07-28` is strict modern-only, `legacy` forces the compatibility handshake.
+     */
+    protocol?: "auto" | "2026-07-28" | "legacy";
     /** Command to run (for stdio transport) */
     command?: string;
     /** Command arguments */

package/dist/types/capability/types.d.ts

@@ -63,6 +63,12 @@ export interface LoadOptions {
     includeInvalid?: boolean;
     /** Include items disabled via settings. Default: false */
     includeDisabled?: boolean;
+    /**
+     * Include providers disabled via settings (for diagnostics). Default: false.
+     * Items loaded from a disabled provider are not marked by the registry; callers
+     * compare `_source.provider` against the disabled-provider set themselves.
+     */
+    includeDisabledProviders?: boolean;
     /** Explicit disabled extension IDs to apply instead of settings. */
     disabledExtensions?: string[];
     /** Session settings whose provider policy applies to this load. */

package/dist/types/cli/accounts-cli.d.ts

@@ -0,0 +1,19 @@
+export declare const ACCOUNTS_ACTIONS: readonly ["list", "check", "pin", "logout"];
+export type AccountsAction = (typeof ACCOUNTS_ACTIONS)[number];
+export interface AccountsCommandArgs {
+    action: AccountsAction;
+    provider?: string;
+    selector?: string;
+    flags: {
+        json?: boolean;
+        persistent?: boolean;
+        clear?: boolean;
+        account?: string;
+        all?: boolean;
+    };
+}
+declare class AccountsCommandError extends Error {
+    constructor(message: string);
+}
+export declare function runAccountsCommand(cmd: AccountsCommandArgs): Promise<void>;
+export { AccountsCommandError };

package/dist/types/cli/args.d.ts

@@ -13,11 +13,14 @@ export interface Args {
     default?: boolean;
     apiKey?: string;
     credential?: string;
+    preferCredential?: string;
     systemPrompt?: string;
     appendSystemPrompt?: string;
     clipboardTransport?: "auto" | "native" | "osc52" | "ssh";
     clipboardSshHost?: string;
     mcpConfig?: string;
+    /** Opt a standalone session out of conventional MCP autoload (mutually exclusive with --mcp-config). */
+    noMcp?: boolean;
     thinking?: Effort;
     continue?: boolean;
     resume?: string | true;

package/dist/types/cli/config-cli.d.ts

@@ -20,6 +20,12 @@ export interface ConfigCommandArgs {
  */
 export declare function parseConfigArgs(args: string[]): ConfigCommandArgs | undefined;
 export declare function runConfigCommand(cmd: ConfigCommandArgs): Promise<void>;
+/**
+ * Configuration conflicts that no schema check can see: an explicit
+ * `task.eager false` keeps a vendor-separated profile's workers unused, so the
+ * main provider's quota pays for work the layout meant to offload.
+ */
+export declare function collectConfigAdvisories(): string[];
 type ConfigDoctorReport = {
     unknownKeys: string[];
     invalidValues: Array<{

package/dist/types/cli/crash-cli.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Terminal adapter for `gjc crash`.
+ *
+ * Keeps all I/O concerns (readline, TTY detection, stdout) out of the flow in
+ * `crash/report.ts`, which is the part that carries the consent contract and is
+ * therefore tested against stubbed boundaries.
+ */
+import { type CrashReportOutcome } from "../crash/report";
+export declare function runCrashReportCommand(): Promise<CrashReportOutcome>;
+export declare function runCrashListCommand(json: boolean): Promise<void>;

package/dist/types/cli/customize-doctor.d.ts

@@ -0,0 +1,145 @@
+/**
+ * `gjc customize doctor` — provenance-aware customization inspection.
+ *
+ * Answers, for one project: what did GJC discover, which source convention won,
+ * what is disabled/shadowed/rejected/quarantined, and why is a tool, skill,
+ * hook, extension, command, MCP server, or plugin bundle absent.
+ *
+ * The command is read-only and reuses the canonical discovery registry
+ * (`loadCapability`) and the exact session-startup consumers (`loadSkills`,
+ * `loadSlashCommands`, `loadAllMCPConfigs`, plugin-bundle registry). It never
+ * re-implements discovery, never executes hooks, never connects MCP servers,
+ * and never prints credentials, endpoint tokens, auth headers, env values, or
+ * raw config dumps.
+ */
+import { type Settings as SettingsInstance } from "../config/settings";
+export type CustomizeSurfaceKind = "mcp" | "skill" | "hook" | "tool" | "extension" | "command" | "plugin-bundle";
+/**
+ * Provenance class of a discovered item — the reusable read model for the
+ * `/extensions` surface (#4291) and CI/setup tooling.
+ *
+ * - `canonical`: project/global `.gjc` entries and GJC bundled defaults — the
+ *   primary load path and the persisted authority for sessions.
+ * - `convention`: items from registered non-native conventions that are part of
+ *   the discovery load path (claude-plugins, claude/codex hooks, agents,
+ *   cursor, gemini, opencode, windsurf, cline, github, mcp-json, ssh).
+ * - `import-candidate`: Claude Code / Codex project (+ global) files on
+ *   surfaces GJC deliberately never loads. Reported for provenance only; never
+ *   active runtime authority. Candidates for a future import flow (#4291).
+ * - `imported`: items carrying explicit import provenance (reserved; no import
+ *   command exists yet, so nothing emits this today).
+ * - `plugin`: plugin bundles (npm plugin packages + GJC plugin bundles).
+ */
+export type CustomizeSourceClass = "canonical" | "convention" | "import-candidate" | "imported" | "plugin";
+export type CustomizeItemStatus = "loaded" | "disabled" | "shadowed" | "rejected" | "quarantined" | "stored-only" | "ignored";
+/**
+ * Bounded, documented reason codes. One reason per item; distinct examples
+ * (malformed, disabled, shadowed, quarantined, policy-blocked) are always
+ * distinguishable by `reason` alone.
+ */
+export type CustomizeReasonCode = "loaded" | "managed" | "storage-only" | "disabled-extension" | "disabled-provider" | "disabled-server" | "disabled-bundle" | "shadowed-by-precedence" | "invalid-config" | "load-error" | "quarantined" | "policy-blocked" | "source-ignored";
+export interface CustomizePrecedenceEntry {
+    provider: string;
+    displayName: string;
+    priority: number;
+    enabled: boolean;
+}
+export interface McpSafeSummary {
+    transport?: "stdio" | "http" | "sse";
+    /** Executable path for stdio servers (safe: no credential values). */
+    command?: string;
+    /** Arguments with secret-looking values replaced by "<redacted>". */
+    args?: string[];
+    /** Endpoint with userinfo/path/query redacted via redactMCPEndpoint. */
+    url?: string;
+    /** Environment variable names only — values are never emitted. */
+    envKeys?: string[];
+    hasHeaders: boolean;
+    hasAuth: boolean;
+    hasOauth: boolean;
+    enabled?: boolean;
+    autoload?: boolean;
+    /** True when session startup would include this server in its connect set. */
+    connectable: boolean;
+}
+export interface CustomizeDoctorItem {
+    name: string;
+    kind: CustomizeSurfaceKind;
+    /** Provenance class (see CustomizeSourceClass). */
+    sourceClass: CustomizeSourceClass;
+    convention: string;
+    provider: string;
+    providerName: string;
+    scope: "user" | "project" | "native";
+    path: string;
+    status: CustomizeItemStatus;
+    reason: CustomizeReasonCode;
+    detail: string;
+    remediation: string[];
+    trust: string;
+    restartRequired: boolean;
+    precedence: {
+        priority: number;
+        shadowedBy?: {
+            provider: string;
+            scope: string;
+        };
+    };
+    /** Present only for MCP servers. */
+    mcp?: McpSafeSummary;
+    /** Present only for quarantined plugin-bundle surfaces. */
+    quarantineCode?: string;
+}
+export interface CustomizeDoctorSurface {
+    kind: CustomizeSurfaceKind;
+    displayName: string;
+    description: string;
+    precedence: CustomizePrecedenceEntry[];
+    items: CustomizeDoctorItem[];
+    /** Skill-surface policy notes (why discovery is off or scoped). */
+    skillScopeNotes?: string[];
+    /** Surface-level warnings (for example a failed startup projection). */
+    warnings?: string[];
+}
+export interface CustomizeDoctorReport {
+    schemaVersion: 1;
+    command: "customize doctor";
+    cwd: string;
+    generatedAt: string;
+    policy: {
+        skillsEnabled: boolean;
+        skillScopeNotes: string[];
+        disabledProviders: string[];
+        mcpNote: string;
+        /** Conventions present on disk but deliberately not in the load path. */
+        conventionsNotLoaded: string[];
+        /** User-home convention directories present (global import candidates). */
+        globalImportCandidateDirs: string[];
+        /** Stable descriptor table for the sourceClass taxonomy (CI contract). */
+        sourceClasses: Array<{
+            sourceClass: CustomizeSourceClass;
+            description: string;
+        }>;
+    };
+    surfaces: CustomizeDoctorSurface[];
+    summary: Record<string, number>;
+    warnings: string[];
+}
+export interface CustomizeDoctorCommandOptions {
+    json: boolean;
+    cwd?: string;
+}
+/**
+ * Build the full doctor report for a project directory.
+ *
+ * @param cwd Project directory; defaults to getProjectDir().
+ * @param activeSettings Session-equivalent settings; when omitted,
+ *   Settings.loadReadonly is called for the given cwd (CLI path). The
+ *   read-only load never opens the DB, runs migrations, or writes files.
+ *   Tests pass an in-memory instance.
+ */
+export declare function runCustomizeDoctor(cwd?: string, activeSettings?: SettingsInstance): Promise<CustomizeDoctorReport>;
+export declare function renderCustomizeDoctorText(report: CustomizeDoctorReport): string;
+export declare function renderCustomizeDoctorJson(report: CustomizeDoctorReport): string;
+/** CLI entry: run the doctor and write text or JSON to stdout. */
+export declare function runCustomizeDoctorCommand(options: CustomizeDoctorCommandOptions): Promise<void>;

package/dist/types/cli/daemon-cli.d.ts

@@ -6,7 +6,7 @@
  */
 import { Settings } from "../config/settings";
 import type { BuiltInDaemonController, DaemonKind } from "../daemon/control-types";
-export type DaemonCliAction = "list" | "status" | "stop" | "reload";
+export type DaemonCliAction = "list" | "status" | "stop" | "restart";
 export type DaemonInternalCliAction = "discord-internal" | "slack-internal";
 export type DaemonCommandAction = DaemonCliAction | DaemonInternalCliAction;
 export declare class UnknownDaemonKindError extends Error {
@@ -24,6 +24,7 @@ export interface DaemonCommandArgs {
     gracefulTimeoutMs?: number;
     killTimeoutMs?: number;
     spawnIfStopped?: boolean;
+    allowDisabledNoop?: boolean;
     smoke?: boolean;
     ownerId?: string;
     agentDir?: string;
@@ -33,6 +34,7 @@ export interface DaemonCommandArgs {
 export interface DaemonCommandDeps {
     settings?: Settings;
     controllers?: BuiltInDaemonController[];
+    setExitCode?: (code: number) => void;
 }
 export declare function parseDaemonArgs(argv: string[]): DaemonCommandArgs | undefined;
 export declare function runDaemonCommand(cmd: DaemonCommandArgs, deps?: DaemonCommandDeps): Promise<void>;

package/dist/types/cli/mcp-cli.d.ts

@@ -22,5 +22,16 @@ export interface MCPCommandArgs {
 }
 export declare class MCPArgsError extends Error {
 }
+/** Runtime status of a stored registration for conventional autoload. */
+type AutoloadStatus = "autoload" | "autoload-off" | "disabled";
+/**
+ * Compute the conventional-autoload status of a stored server.
+ *
+ * - `autoload-off`: the server opted out of startup connection via `autoload: false`.
+ * - `disabled`: the server is disabled via `enabled: false` or the `disabledServers` list.
+ * - `autoload`: connected by ordinary standalone sessions at startup.
+ */
+export declare function computeAutoloadStatus(name: string, config: MCPServerConfig, disabledServers: ReadonlySet<string>): AutoloadStatus;
 export declare function redactMCPServerConfig(config: MCPServerConfig): MCPServerConfig;
 export declare function runMCPCommand(args: MCPCommandArgs): Promise<void>;
+export {};

package/dist/types/cli/notify-cli.d.ts

@@ -1,9 +1,9 @@
 import { Settings } from "../config/settings";
 import { type EnsureChatDaemonResult } from "../sdk/bus/chat-daemon-control";
-import { type ActivatedPreparedSession } from "../sdk/bus/existing-thread-readiness";
 import { type BoundSlackThread } from "../sdk/bus/slack-thread-binding";
 import { type EnsureTelegramDaemonDetailedResult } from "../sdk/bus/telegram-daemon";
 import { type TelegramSetupPreflight, type TelegramSetupTimers } from "../sdk/bus/telegram-setup";
+import type { ActivatedPreparedSession } from "../sdk/session-activation";
 export type NotifyAction = "setup" | "status" | "health" | "test" | "recovery" | "bind-thread" | "activate-thread" | "daemon-internal";
 export type NotifySetupProvider = "telegram" | "discord" | "slack";
 export interface NotifyCommandArgs {

package/dist/types/cli/root-flags.d.ts

@@ -28,6 +28,9 @@ export declare const ROOT_LAUNCH_FLAGS: {
     credential: FlagDescriptor<"string"> & {
         description: string;
     };
+    "prefer-credential": FlagDescriptor<"string"> & {
+        description: string;
+    };
     "system-prompt": FlagDescriptor<"string"> & {
         description: string;
     };
@@ -37,6 +40,9 @@ export declare const ROOT_LAUNCH_FLAGS: {
     "mcp-config": FlagDescriptor<"string"> & {
         description: string;
     };
+    "no-mcp": FlagDescriptor<"boolean"> & {
+        description: string;
+    };
     "clipboard-transport": FlagDescriptor<"string"> & {
         description: string;
         options: string[];
@@ -150,6 +156,9 @@ export declare const LAUNCH_PARSE_FLAGS: {
     credential: FlagDescriptor<"string"> & {
         description: string;
     };
+    "prefer-credential": FlagDescriptor<"string"> & {
+        description: string;
+    };
     "system-prompt": FlagDescriptor<"string"> & {
         description: string;
     };
@@ -159,6 +168,9 @@ export declare const LAUNCH_PARSE_FLAGS: {
     "mcp-config": FlagDescriptor<"string"> & {
         description: string;
     };
+    "no-mcp": FlagDescriptor<"boolean"> & {
+        description: string;
+    };
     "clipboard-transport": FlagDescriptor<"string"> & {
         description: string;
         options: string[];

package/dist/types/cli/setup-cli.d.ts

@@ -5,7 +5,7 @@
  */
 import { AuthStorage, SqliteAuthCredentialStore } from "@gajae-code/ai/core";
 import { runExternalCredentialAutoImport } from "../setup/credential-auto-import";
-export type SetupComponent = "claude" | "codex" | "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
+export type SetupComponent = "claude" | "codex" | "credentials" | "defaults" | "hermes" | "hooks" | "paseo" | "provider" | "python" | "stt";
 export interface SetupCommandArgs {
     component: SetupComponent;
     flags: {
@@ -25,6 +25,8 @@ export interface SetupCommandArgs {
         repo?: string;
         profile?: string;
         sessionCommand?: string;
+        remove?: boolean;
+        mpreset?: string;
         noWorktree?: boolean;
         worktreeName?: string;
         stateRoot?: string;

package/dist/types/cli/skills-cli.d.ts

@@ -1,9 +1,10 @@
-export type SkillsAction = "list" | "read";
+export type SkillsAction = "list" | "read" | "discover";
 export interface SkillsCommandArgs {
     action: SkillsAction;
     name?: string;
     flags?: {
         json?: boolean;
+        source?: "all" | "project" | "user";
     };
 }
 export declare function runSkillsCommand(cmd: SkillsCommandArgs): Promise<void>;

package/dist/types/cli/update-cli.d.ts

@@ -1,4 +1,6 @@
+import { Settings } from "../config/settings";
 import { type UpdateChannel } from "../config/update-channel";
+import { type NotificationProvider } from "../sdk/bus/config";
 import { type NpmRegistryLookupOptions } from "../utils/npm-registry";
 export interface UpdateCommandOptions {
     force: boolean;
@@ -108,10 +110,26 @@ export declare function runBinaryUpdateFlow(targetPath: string, url: string, exp
 export interface UpdateCommandDependencies {
     getLatestRelease?: (options?: LatestReleaseLookupOptions) => Promise<ReleaseInfo>;
     resolveUpdateTarget?: () => Promise<UpdateTarget>;
-    performUpdate?: (target: UpdateTarget, expectedVersion: string, registry?: string) => Promise<void>;
+    performUpdate?: (target: UpdateTarget, expectedVersion: string, registry?: string) => Promise<InstalledVersionVerification | undefined>;
     refreshInstalledDefaultSkills?: () => Promise<void>;
+    settings?: () => Promise<Settings>;
+    stopDaemon?: (settings: Settings) => Promise<void>;
+    restartDaemon?: (settings: Settings) => Promise<void>;
+    recoverNotifications?: (settings: Settings) => Promise<void>;
+    runPostUpdateRecovery?: (runtimePath: string) => Promise<void>;
     exit?: (code: number) => never;
 }
+export type PostUpdateRecoverySpawn = (argv: string[]) => Promise<number>;
+export type PostUpdateRecoverySupportCheck = (runtimePath: string) => Promise<boolean>;
+export type LegacyRecoveryDaemonKinds = () => Promise<NotificationProvider[]>;
+/**
+ * A complete, non-quarantined provider with provider-level desired intent is a
+ * durable managed-notify setup. The global switch is deliberately excluded:
+ * disabling delivery must not leave credential-backed daemon locks unrecovered.
+ */
+export declare function hasManagedNotifySetup(settings: Settings): boolean;
+export declare function runPostUpdateRecoveryForTest(runtimePath: string, spawn?: PostUpdateRecoverySpawn, supportsRecovery?: PostUpdateRecoverySupportCheck, managedKinds?: LegacyRecoveryDaemonKinds): Promise<void>;
+export declare function runManagedNotifyRecovery(deps: Pick<UpdateCommandDependencies, "settings" | "stopDaemon" | "restartDaemon" | "recoverNotifications">): Promise<void>;
 /** How the update command should proceed after comparing versions. */
 export interface UpdateDecision {
     install: boolean;

package/dist/types/cli.d.ts

@@ -51,6 +51,9 @@ export declare class RootHelpCommand extends Command {
         credential: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        "prefer-credential": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         "system-prompt": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
@@ -60,6 +63,9 @@ export declare class RootHelpCommand extends Command {
         "mcp-config": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        "no-mcp": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
         "clipboard-transport": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
             options: string[];

package/dist/types/commands/accounts.d.ts

@@ -0,0 +1,40 @@
+/** Manage stored OAuth accounts without exposing credential payloads. */
+import { Command } from "@gajae-code/utils/cli";
+export default class Accounts extends Command {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        action: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: ("check" | "list" | "logout" | "pin")[];
+        };
+        provider: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+        };
+        selector: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+        };
+    };
+    static flags: {
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        persistent: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        clear: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        account: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        all: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/types/commands/crash.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `gjc crash` — inspect local crash signatures and file an assisted, fully
+ * consented bug report. Nothing leaves the machine without an explicit,
+ * digest-confirmed confirmation for that exact invocation.
+ */
+import { Command } from "@gajae-code/utils/cli";
+export default class Crash extends Command {
+    static description: string;
+    static args: {
+        action: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+        };
+    };
+    static flags: {
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/types/commands/customize.d.ts

@@ -0,0 +1,22 @@
+import { Command } from "@gajae-code/utils/cli";
+export default class Customize extends Command {
+    #private;
+    static description: string;
+    static delegateHelp: boolean;
+    static examples: string[];
+    static args: {
+        action: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+            options: readonly ["doctor"];
+        };
+    };
+    static flags: {
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+    };
+    run(): Promise<void>;
+}

package/dist/types/commands/daemon.d.ts

@@ -1,5 +1,5 @@
 /**
- * Manage GJC background daemons (status/list/stop/reload).
+ * Manage GJC background daemons (status/list/stop/restart).
  */
 import { Command } from "@gajae-code/utils/cli";
 export default class Daemon extends Command {