@gajae-code/coding-agent 0.14.2 → 0.15.0

package/dist/types/config/autorouting.d.ts

@@ -0,0 +1,35 @@
+import type { Model } from "@gajae-code/ai/core";
+import { type AutoroutingEffective, type AutoroutingTier } from "./autorouting-contract";
+export type TierSelectorNormalization = {
+    pinned: string;
+} | {
+    rejected: "selector_not_provider_qualified";
+} | {
+    unmatched: true;
+};
+export type RoutingOutcome = {
+    kind: "disabled";
+} | {
+    kind: "routed";
+    tier: AutoroutingTier;
+    requestedTier?: AutoroutingTier;
+    defaultTierApplied?: true;
+    pinnedSelector: string;
+} | {
+    kind: "manual-fallback";
+    tier: AutoroutingTier;
+    requestedTier?: AutoroutingTier;
+    defaultTierApplied?: true;
+    attemptedSelectorCount: number;
+    reason: "tier_unmatched" | "tier_missing_in_map";
+};
+/**
+ * Pin one configured selector against exactly the supplied ordered snapshot.
+ * No settings, role aliases, usage ordering, or fuzzy matching participate.
+ */
+export declare function normalizeTierSelector(selector: string, snapshot: readonly Model[]): TierSelectorNormalization;
+export declare function resolveTaskRouting(input: {
+    effectiveAutorouting: AutoroutingEffective;
+    requestedTier?: AutoroutingTier;
+    availableModels?: readonly Model[];
+}): RoutingOutcome;

package/dist/types/config/model-discovery-manager.d.ts

@@ -36,6 +36,13 @@ export interface ProviderDiscoveryCallbacks<TProvider extends DiscoveryProvider>
     fetchModels: (provider: TProvider, apiKey: string | undefined) => Promise<Model<Api>[]>;
     getEvidenceGeneration?: (provider: TProvider) => string;
     canPublishCache?: (provider: TProvider) => boolean;
+    /**
+     * Stable fingerprint of the discovery fetch context (credential evidence +
+     * endpoint). When supplied, the published cache row records it alongside the
+     * discovered model ids so a later `online-if-uncached` refresh can trust a
+     * fresh cache instead of treating the ids as provenance-less and re-fetching.
+     */
+    cacheDynamicModelProvenance?: string;
 }
 /** Owns configured discovery inputs, status, cache lifecycle, and refresh generations. */
 export declare class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
@@ -47,7 +54,7 @@ export declare class ModelDiscoveryManager<TProvider extends DiscoveryProvider>
     providerIds(): Set<string>;
     getState(provider: string): ProviderDiscoveryState | undefined;
     invalidate(provider: string): void;
-    loadCached(provider: TProvider, cacheDbPath?: string): readonly Model<Api>[];
+    loadCached(provider: TProvider, cacheDbPath?: string, expectedProvenance?: string): readonly Model<Api>[];
     beginRefresh(provider: string): DiscoveryRefreshToken;
     isCurrent(token: DiscoveryRefreshToken): boolean;
     discover(provider: TProvider, strategy: ModelRefreshStrategy, callbacks: ProviderDiscoveryCallbacks<TProvider>): Promise<DiscoveryMergeInput>;

package/dist/types/config/model-registry.d.ts

@@ -335,6 +335,11 @@ export interface CanonicalModelQueryOptions {
     /** Credential-selection session used to classify effective provider auth. Defaults to sessionId. */
     credentialSessionId?: string;
 }
+/** One canonical record with its winning variant resolved, from a batch query. */
+export interface CanonicalModelSelection {
+    record: CanonicalModelRecord;
+    model: Model<Api> | undefined;
+}
 /**
  * Model registry - loads and manages models, resolves API keys via AuthStorage.
  */
@@ -344,8 +349,10 @@ export declare class ModelRegistry {
     /**
      * @param authStorage - Auth storage for API key resolution
      */
-    constructor(authStorage: AuthStorage, modelsPath?: string);
+    constructor(authStorage: AuthStorage, modelsPath?: string, registrySettings?: Pick<Settings, "get" | "getGlobal">);
     onCatalogChanged(listener: () => void): () => void;
+    /** Replace the read-only settings snapshot used by profile-scoped resolution. */
+    setScopedSettings(settingsReader: Pick<Settings, "get" | "getGlobal">): void;
     /**
      * Reload models from disk (built-in + custom from models.json).
      */
@@ -378,7 +385,29 @@ export declare class ModelRegistry {
     getAll(): Model<Api>[];
     /** Provider ids declared in models.yml, including override-only providers. */
     getConfiguredProviderIds(): readonly string[];
+    /**
+     * Deterministic provider priority for autorouting tier generation: configured
+     * `modelProviderOrder` first, then first-wins catalog order.
+     *
+     * Deliberately takes no session and never touches `authStorage`. It bypasses
+     * `#buildProviderSelectionPolicy` entirely so no `effectiveAuth` map is even
+     * assembled — auth-independence is structural here, not a convention. Ranking
+     * that *is* auth-aware stays private to the policy.
+     *
+     * Providers absent from the catalog are dropped so a dead declaration cannot
+     * pollute the generated setup's `declarationFingerprint`. Returned ids use the
+     * catalog's original spelling because the generator matches provider prefixes
+     * with case-sensitive exact strings.
+     */
+    autoroutingProviderOrder(): readonly string[];
     getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[];
+    /**
+     * Batch form of {@link resolveCanonicalModel} over every canonical record:
+     * one candidate-key set, one provider policy, and one catalog order for the
+     * whole query instead of per record. `model` is `undefined` only when a
+     * record has surviving variants but none can win resolution.
+     */
+    getCanonicalModelSelections(options?: CanonicalModelQueryOptions): CanonicalModelSelection[];
     getCanonicalVariants(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
     /**
      * Resolve an exact canonical id to a concrete model.

package/dist/types/config/provider-selection-policy.d.ts

@@ -48,6 +48,16 @@ export interface ProviderSelectionPolicy {
  * current values in so ranking stays deterministic and testable.
  */
 export declare function createProviderSelectionPolicy(input: ProviderSelectionPolicyInput): ProviderSelectionPolicy;
+/**
+ * Project the deterministic provider order: normalized explicit order first, then
+ * first-wins catalog order for everything else.
+ *
+ * This is the single implementation of that ordering. It reads no credentials and
+ * takes no auth input at all, so any consumer that only needs "which providers, in
+ * what priority" cannot accidentally acquire auth sensitivity. Auth-aware banding
+ * lives exclusively in {@link ProviderSelectionPolicy.rank}.
+ */
+export declare function projectProviderOrder(explicitProviderOrder: readonly string[], catalogProviders: readonly string[]): string[];
 export interface ProviderSelectionCatalog {
     /** Lowercased provider ids in first-wins registry catalog order. */
     readonly catalogProviders: readonly string[];
@@ -60,3 +70,16 @@ export interface ProviderSelectionCatalog {
  * candidates never changes ranking.
  */
 export declare function buildProviderSelectionCatalog(models: readonly Model<Api>[]): ProviderSelectionCatalog;
+/**
+ * Deterministic provider priority for a catalog, returned in the catalog's own
+ * spelling.
+ *
+ * Ordering and de-duplication run on normalized ids, but the result restores each
+ * provider's first-seen catalog spelling because the autorouting generator matches
+ * provider prefixes with case-sensitive exact strings — a lowercased id would
+ * silently empty that provider's tiers. Providers absent from the catalog are
+ * dropped so a dead declaration cannot pollute a generated declarationFingerprint.
+ *
+ * Reads no credentials: it takes a catalog and an explicit order, nothing else.
+ */
+export declare function projectCatalogProviderOrder(explicitProviderOrder: readonly string[], models: readonly Model<Api>[]): string[];

package/dist/types/config/settings-schema.d.ts

@@ -1,5 +1,6 @@
 import type { Effort } from "@gajae-code/ai/model-thinking";
 import { type EditMode } from "../utils/edit-mode";
+import { type AutoroutingLocalIssue, type AutoroutingProvenance, type AutoroutingSetup, type AutoroutingTierMapInput } from "./autorouting-contract";
 import type { ModelSelectorValue } from "./model-selector-value";
 import { type SkillDiscoverySettings } from "./skill-settings-defaults";
 /** Unified settings schema - single source of truth for all settings.
@@ -68,6 +69,21 @@ interface UiString extends UiBase {
 export type AnyUiMetadata = UiBase & {
     options?: ReadonlyArray<SubmenuOption> | "runtime";
 };
+/** JSON Schema fragment carried by settings definitions that own nested validation. */
+export type JsonSchemaObject = {
+    [key: string]: unknown;
+    type?: string;
+    properties?: Record<string, JsonSchemaObject>;
+    additionalProperties?: boolean | JsonSchemaObject;
+    items?: JsonSchemaObject;
+    required?: readonly string[];
+    pattern?: string;
+    minItems?: number;
+    minLength?: number;
+    uniqueItems?: boolean;
+    minimum?: number;
+    const?: unknown;
+};
 interface BooleanDef {
     type: "boolean";
     default?: boolean;
@@ -106,13 +122,33 @@ type RecordValueDef = {
 } | {
     type: "credential-selector";
 };
+interface ConstrainedRecordValueDef {
+    type: "autorouting-selector-value";
+    pattern: string;
+    description: string;
+}
+interface ConstrainedRecordDef<T> {
+    type: "constrained-record";
+    default: T;
+    keys: readonly string[];
+    valueSchema: ConstrainedRecordValueDef;
+    description?: string;
+    ui?: UiBase;
+}
 interface RecordDef<T> {
     type: "record";
     default: Record<string, T>;
     valueSchema?: RecordValueDef;
     ui?: UiBase;
 }
-type SettingDef = BooleanDef | StringDef | NumberDef | EnumDef<readonly string[]> | ArrayDef<unknown> | RecordDef<unknown>;
+export interface OptionalObjectDef<T> {
+    type: "optional-object";
+    default: undefined;
+    jsonSchema: JsonSchemaObject;
+    validate: (value: unknown) => AutoroutingLocalIssue[];
+    _value?: T;
+}
+export type SettingDef = BooleanDef | StringDef | NumberDef | EnumDef<readonly string[]> | ArrayDef<unknown> | RecordDef<unknown> | ConstrainedRecordDef<unknown> | OptionalObjectDef<unknown>;
 export interface ModelTagDef {
     name: string;
     color?: string;
@@ -548,7 +584,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "gjc.ralplan.autoHandoff": {
         readonly type: "enum";
-        readonly values: readonly ["off", "ultragoal", "team"];
+        readonly values: readonly ["off", "ultragoal", "autoresearch"];
         readonly default: "off";
     };
     readonly "gjc.ralplan.maxIterations": {
@@ -3972,6 +4008,25 @@ export declare const SETTINGS_SCHEMA: {
             readonly type: "model-selector-value";
         };
     };
+    readonly "task.autorouting.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly "task.autorouting.tiers": {
+        readonly type: "constrained-record";
+        readonly default: AutoroutingTierMapInput;
+        readonly keys: readonly ["fast", "balanced", "strong"];
+        readonly valueSchema: {
+            readonly type: "autorouting-selector-value";
+            readonly minLength: 1;
+            readonly maxLength: 256;
+            readonly pattern: "^[^/\\s*?\\[\\x00-\\x1F\\x7F-\\x9F\\u2028\\u2029]+\\/[^\\s*?\\[\\x00-\\x1F\\x7F-\\x9F\\u2028\\u2029]+(?::(?:minimal|low|medium|high|xhigh))?$";
+            readonly description: "provider/modelId with an optional valid thinking suffix (:minimal|low|medium|high|xhigh), no globs, no bare model ids, no pi/<role> role aliases.";
+        };
+        readonly description: "provider/modelId with an optional valid thinking suffix (:minimal|low|medium|high|xhigh), no globs, no bare model ids, no pi/<role> role aliases.";
+    };
+    readonly "task.autorouting.setup": OptionalObjectDef<AutoroutingSetup>;
+    readonly "task.autorouting.provenance": OptionalObjectDef<AutoroutingProvenance>;
     readonly "tasks.todoClearDelay": {
         readonly type: "number";
         readonly default: 60;
@@ -4384,7 +4439,10 @@ export type SettingValue<P extends SettingPath> = Schema[P] extends {
 } ? D : Schema[P] extends {
     type: "record";
     default: infer D;
-} ? D : never;
+} ? D : Schema[P] extends {
+    type: "constrained-record";
+    default: infer D;
+} ? D : Schema[P] extends OptionalObjectDef<infer D> ? D | undefined : never;
 /** Get the default value for a setting path */
 export declare function getDefault<P extends SettingPath>(path: P): SettingValue<P>;
 /** Check if a path has UI metadata (should appear in settings panel) */

package/dist/types/config/settings.d.ts

@@ -15,6 +15,7 @@ import { type NotificationSettingsReader, type NotificationSettingsSnapshot } fr
 import { AgentStorage } from "../session/agent-storage";
 import { type EditMode, type EditVariantMatch } from "../utils/edit-mode";
 import { type CasReceipt } from "./atomic-yaml-patch";
+import { type AutoroutingEffective } from "./autorouting-contract";
 import { type ModelSelectorValue } from "./model-selector-value";
 import { type BashInterceptorRule, type GroupPrefix, type GroupTypeMap, type SettingPath, type SettingsSchemaReport, type SettingValue } from "./settings-schema";
 export type * from "./settings-schema";
@@ -139,6 +140,8 @@ export declare class Settings implements NotificationSettingsReader {
     has(path: SettingPath): boolean;
     /** Diagnostics from schema reconciliation during the most recent load. */
     getSchemaReport(): SettingsSchemaReport;
+    /** Effective merged autorouting state shared by settings diagnostics and routing policy. */
+    getEffectiveAutorouting(): AutoroutingEffective;
     onChanged(listener: (path: SettingPath) => void): () => void;
     /** Whether durable settings mutations are permitted for the loaded configuration. */
     canWriteDurableConfig(): boolean;

package/dist/types/coordinator/contract.d.ts

@@ -1,4 +1,4 @@
 export declare const COORDINATOR_MCP_PROTOCOL_VERSION = "2024-11-05";
 export declare const COORDINATOR_MCP_SERVER_NAME = "gjc-coordinator-mcp";
-export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["gjc_coordinator_list_sessions", "gjc_coordinator_read_status", "gjc_coordinator_read_tail", "gjc_coordinator_list_questions", "gjc_coordinator_list_artifacts", "gjc_coordinator_read_artifact", "gjc_coordinator_read_coordination_status", "gjc_coordinator_watch_events", "gjc_coordinator_register_session", "gjc_coordinator_start_session", "gjc_coordinator_activate_session", "gjc_coordinator_stop_session", "gjc_coordinator_send_prompt", "gjc_coordinator_submit_question_answer", "gjc_coordinator_read_turn", "gjc_coordinator_await_turn", "gjc_coordinator_report_status", "gjc_coordinator_register_codex_handoff", "gjc_coordinator_read_codex_handoff", "gjc_coordinator_ack_codex_handoff", "gjc_delegate_plan", "gjc_delegate_execute", "gjc_delegate_team"];
+export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["gjc_coordinator_list_sessions", "gjc_coordinator_read_status", "gjc_coordinator_read_tail", "gjc_coordinator_list_questions", "gjc_coordinator_list_artifacts", "gjc_coordinator_read_artifact", "gjc_coordinator_read_coordination_status", "gjc_coordinator_watch_events", "gjc_coordinator_register_session", "gjc_coordinator_start_session", "gjc_coordinator_activate_session", "gjc_coordinator_stop_session", "gjc_coordinator_send_prompt", "gjc_coordinator_submit_question_answer", "gjc_coordinator_read_turn", "gjc_coordinator_await_turn", "gjc_coordinator_report_status", "gjc_coordinator_register_codex_handoff", "gjc_coordinator_read_codex_handoff", "gjc_coordinator_ack_codex_handoff", "gjc_delegate_plan", "gjc_delegate_execute"];
 export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/dist/types/coordinator-mcp/durability.d.ts

@@ -0,0 +1,29 @@
+import * as fs from "node:fs/promises";
+export interface CoordinatorDirectoryBarrierOptions {
+    platform?: NodeJS.Platform;
+    openDirectory?: (directory: string) => Promise<fs.FileHandle>;
+}
+export interface CoordinatorFileDurabilityOptions {
+    syncFile?: (handle: fs.FileHandle) => Promise<void>;
+}
+export interface CoordinatorAtomicWriteOptions extends CoordinatorDirectoryBarrierOptions, CoordinatorFileDurabilityOptions {
+    rename?: (source: string, destination: string) => Promise<void>;
+}
+/** The file was published, but its final directory barrier did not complete. */
+export declare class CoordinatorPublicationUncertainError extends Error {
+    constructor(cause: unknown);
+}
+export declare function ensureCoordinatorDirectory(directory: string, options?: CoordinatorDirectoryBarrierOptions): Promise<void>;
+/**
+ * Windows does not support fsync on directory handles. File contents must be
+ * synced before publication; this barrier only makes the renamed directory
+ * entry durable where the platform supports that operation.
+ */
+export declare function isUnsupportedWindowsDirectorySyncError(error: unknown, platform?: NodeJS.Platform): boolean;
+export declare function syncCoordinatorDirectory(directory: string, options?: CoordinatorDirectoryBarrierOptions): Promise<void>;
+/** File durability is never best-effort: callers must abort on every failure. */
+export declare function syncCoordinatorFile(handle: fs.FileHandle, options?: CoordinatorFileDurabilityOptions): Promise<void>;
+/** Append a durable coordinator journal or diagnostic record, then barrier its parent. */
+export declare function appendCoordinatorFile(file: string, contents: string, options?: CoordinatorDirectoryBarrierOptions & CoordinatorFileDurabilityOptions): Promise<void>;
+/** Atomically publish a synced coordinator state file, then barrier its parent. */
+export declare function writeCoordinatorAtomic(file: string, contents: string, options?: CoordinatorAtomicWriteOptions): Promise<void>;

package/dist/types/coordinator-mcp/event-webhook.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Opt-in webhook delivery of existing coordinator `watch_events` journal rows
+ * (issue #4706). Delivery is a durable outbox keyed by the journal row's stable
+ * `id`: each delivered row is recorded once, retried with bounded exponential
+ * backoff, and never blocks or rewrites the journal append path.
+ */
+export interface EventWebhookConfig {
+    url: string;
+    tokenFile: string | null;
+    sessionIds: Set<string> | null;
+    timeoutMs: number;
+    maxAttempts: number;
+}
+/** Result of one webhook POST attempt; 2xx is ok, anything else carries the reason. */
+interface WebhookPostOutcome {
+    ok: boolean;
+    status: number | null;
+    error: string | null;
+}
+export interface WebhookDelivery {
+    /** Called with the exact JSON body to POST and per-attempt request options. */
+    post(body: string, options: {
+        url: string;
+        token: string | null;
+        timeoutMs: number;
+        signal: AbortSignal;
+    }): Promise<WebhookPostOutcome>;
+    /** Test seam: delay between retries; default is `Bun.sleep`. */
+    sleep(ms: number): Promise<void>;
+    /** Monotonic-ish clock for deadline math; default is `Date.now`. */
+    now(): number;
+}
+/** Default `WebhookDelivery` over `fetch`: POST, 2xx = ok, no redirects, abort on timeout. */
+export declare function createDefaultEventWebhookDelivery(): WebhookDelivery;
+export declare const DEFAULT_EVENT_WEBHOOK_TIMEOUT_MS = 5000;
+export declare const MAX_EVENT_WEBHOOK_TIMEOUT_MS = 30000;
+export declare const DEFAULT_EVENT_WEBHOOK_MAX_ATTEMPTS = 5;
+export declare const MAX_EVENT_WEBHOOK_MAX_ATTEMPTS = 10;
+export declare function parseEventWebhookConfig(explicitEnv?: NodeJS.ProcessEnv): EventWebhookConfig | null;
+/**
+ * Records the row in the durable outbox and, unless the row is already
+ * delivered or exhausted, performs one bounded delivery attempt series. The
+ * returned promise settles only after bounded attempts/backoff, so a dead sink
+ * can never wedge the caller's persistence; callers run it off the append path.
+ */
+export declare function deliverEventWebhook(namespaceDir: string, config: EventWebhookConfig, event: {
+    id: string;
+    session_id?: string;
+}, renderBody: () => string, delivery: WebhookDelivery): Promise<void>;
+export {};

package/dist/types/coordinator-mcp/question-state.d.ts

@@ -266,7 +266,7 @@ export type CanonicalCreateIntentV1 = {
     initial_events: Record<string, string | number | boolean | null>[];
 } | {
     kind: "delegate";
-    workflow: "plan" | "execute" | "team";
+    workflow: "plan" | "execute";
     session: CanonicalSessionSnapshotV1;
     remote_create_key: string;
     initial_state: CoordinatorSessionState;

package/dist/types/coordinator-mcp/server.d.ts

@@ -4,6 +4,7 @@ import { type EnsureBrokerSettings } from "../sdk/broker/ensure";
 import { SdkClient } from "../sdk/client/client";
 import { SessionRouter, type SessionRouterDeps } from "../sdk/router";
 import { type CodexTransportFactory } from "./codex-wake-publisher";
+import { type WebhookDelivery } from "./event-webhook";
 import { type CoordinatorModelProfileLoader } from "./model-preset";
 import { type CoordinatorMcpConfig } from "./policy";
 import { type SessionReaper } from "./session-reaper";
@@ -33,9 +34,20 @@ interface CoordinatorServices {
     readSdkBrokerDiscovery?: (agentDir: string) => Promise<BrokerDiscovery | null>;
     getAgentDir?: () => string;
     resolveModelProfiles?: CoordinatorModelProfileLoader;
+    resolveModelPin?: (raw: unknown, cwd?: string) => Promise<CoordinatorModelResolution>;
     canonicalizePath?: (value: string) => Promise<string>;
     codexTransportFactory?: CodexTransportFactory;
+    eventWebhookDelivery?: WebhookDelivery;
 }
+type CoordinatorModelResolution = {
+    ok: true;
+    model: string | null;
+} | {
+    ok: false;
+    reason: "unknown_model";
+    model: string;
+    error: string;
+};
 interface CoordinatorMcpServerOptions {
     env?: NodeJS.ProcessEnv;
     services?: CoordinatorServices;
@@ -69,6 +81,8 @@ interface CoordinatorEventInput {
     payloadRef?: string | null;
     metadata?: Record<string, string | number | boolean | null>;
 }
+/** Test-only helper that waits for queued event webhook deliveries in a namespace. */
+export declare function awaitEventWebhookDeliveriesForTest(namespaceDir: string): Promise<void>;
 /** Test-only helper that waits for queued Codex wake publishes in a namespace. */
 export declare function awaitCodexWakePublishesForTest(namespaceDir: string): Promise<void>;
 /** Test-only event injection for coordinator wake-pipeline coverage. */

package/dist/types/crash/index-store.d.ts

@@ -30,6 +30,9 @@ export interface CrashSignatureEntry {
     relayedAt?: number;
     /** Occurrence record represented by the durable upstream watermark. */
     relayedRecordId?: string;
+    /** Refusal marker for the exact record and sanitizer contract. */
+    relayRefusedRecordId?: string;
+    relayRefusedVersion?: string;
     /** Issues this install already "+1"ed, so re-invocations cannot spam comments. */
     commentedIssues?: string[];
 }

package/dist/types/crash/record-loader.d.ts

@@ -15,3 +15,5 @@ export declare function parseCrashRecords(contents: string): LoadedCrashRecord[]
 export declare function parseRecoverableCrashRecords(contents: string): LoadedCrashRecord[];
 /** Newest identity-bearing record for a fingerprint, or `undefined` when unmatchable. */
 export declare function findLatestRecord(contents: string, fingerprint: string): LoadedCrashRecord | undefined;
+/** Identity-bearing record bound to the indexed append-order identity. */
+export declare function findRecordById(contents: string, fingerprint: string, recordId: string): LoadedCrashRecord | undefined;

package/dist/types/crash/upstream/relay.d.ts

@@ -20,6 +20,8 @@
  */
 import { type CrashSignatureView, type CrashStatePaths } from "../index-store";
 import { type SentryDsn } from "./dsn";
+/** Version of the complete sanitizer/egress contract persisted in refusals. */
+export declare const SANITIZER_EGRESS_CONTRACT_VERSION = "sanitize-external-crash-v1";
 /** Trusted environment variable form of the DSN, for CI and one-off runs. */
 export declare const CRASH_UPSTREAM_DSN_ENV = "GJC_CRASH_SENTRY_DSN";
 export interface CrashRelayConfig {
@@ -113,9 +115,9 @@ export declare function resolveRelayDsn(config: CrashRelayConfig, env?: Record<s
  */
 export declare function isRelayDue(signature: CrashSignatureView): boolean;
 /**
- * Automatic relay stores use the normal XDG state location only when the XDG
- * value came from a trusted environment. `dirs.ts` rejects checkout `.env`
- * declarations before resolving these paths, including dotenv-expanded values.
+ * Automatic relay always reads the trusted agent stores. XDG-aware paths remain
+ * available to ordinary crash state operations, but never select automatic-egress
+ * input files.
  */
 export declare function resolveTrustedRelayStatePaths(): CrashStatePaths;
 export declare function resolveTrustedHandledRelayStatePaths(): CrashStatePaths;

package/dist/types/cursor.d.ts

@@ -14,6 +14,11 @@ type CursorExecEventEmitter = (event: AgentEvent, dispatchedTool?: AgentTool) =>
 interface CursorExecBridgeOptions {
     cwd: string;
     tools: Map<string, AgentTool>;
+    getEditReplaceTool?: () => AgentTool | undefined;
+    createSearchTool?: (options: {
+        context?: number;
+        totalMatchLimit?: number;
+    }) => AgentTool | undefined;
     getToolContext?: () => AgentToolContext | undefined;
     emitEvent?: CursorExecEventEmitter;
     createEventEmitter?: () => ((event: AgentEvent) => void) | undefined;
@@ -29,6 +34,13 @@ export declare class CursorExecHandlers implements ICursorExecHandlers {
     delete(args: Parameters<NonNullable<ICursorExecHandlers["delete"]>>[0]): Promise<ToolResultMessage<any>>;
     shell(args: Parameters<NonNullable<ICursorExecHandlers["shell"]>>[0]): Promise<ToolResultMessage<any>>;
     shellStream(args: Parameters<NonNullable<ICursorExecHandlers["shellStream"]>>[0], callbacks: CursorShellStreamCallbacks): Promise<ToolResultMessage<any>>;
+    piRead(call: Parameters<NonNullable<ICursorExecHandlers["piRead"]>>[0]): Promise<ToolResultMessage<any>>;
+    piBash(call: Parameters<NonNullable<ICursorExecHandlers["piBash"]>>[0]): Promise<ToolResultMessage<any>>;
+    piEdit(call: Parameters<NonNullable<ICursorExecHandlers["piEdit"]>>[0]): Promise<ToolResultMessage<any>>;
+    piWrite(call: Parameters<NonNullable<ICursorExecHandlers["piWrite"]>>[0]): Promise<ToolResultMessage<any>>;
+    piGrep(call: Parameters<NonNullable<ICursorExecHandlers["piGrep"]>>[0]): Promise<ToolResultMessage<any>>;
+    piFind(call: Parameters<NonNullable<ICursorExecHandlers["piFind"]>>[0]): Promise<ToolResultMessage<any>>;
+    piLs(call: Parameters<NonNullable<ICursorExecHandlers["piLs"]>>[0]): Promise<ToolResultMessage<any>>;
     diagnostics(args: Parameters<NonNullable<ICursorExecHandlers["diagnostics"]>>[0]): Promise<ToolResultMessage<any>>;
     mcp(call: CursorMcpCall): Promise<ToolResultMessage<any>>;
 }

package/dist/types/defaults/gjc-defaults.d.ts

@@ -1,5 +1,5 @@
 import { type BundledGjcSkillCatalogEntry } from "./gjc-skills.generated";
-export declare const DEFAULT_GJC_DEFINITION_NAMES: readonly ["deep-interview", "ralplan", "team", "ultragoal"];
+export declare const DEFAULT_GJC_DEFINITION_NAMES: readonly ["autoresearch", "deep-interview", "ralplan", "ultragoal"];
 export type DefaultGjcDefinitionName = (typeof DEFAULT_GJC_DEFINITION_NAMES)[number];
 export type DefaultGjcDefinitionKind = "skill" | "skill-fragment";
 export type EmbeddedDefaultGjcSkill = {
@@ -52,6 +52,29 @@ export type DefaultGjcDefinitionInstallFile = {
     path: string;
     status: DefaultGjcInstallStatus;
 };
+/**
+ * Bundled workflow definitions that GJC used to ship and no longer does.
+ *
+ * Installing defaults only ever wrote the CURRENT set, so a definition dropped
+ * from the bundle stayed on disk under the agent dir forever — where
+ * filesystem skill discovery still found it and `/skill:<name>` still resolved.
+ * `team` was the first removal, so it was the first to expose that gap.
+ *
+ * Retirement QUARANTINES rather than deletes: the directory is moved aside to
+ * `<targetRoot>/retired/<name>.<timestamp>/`. A user who customized the skill
+ * keeps their content, and nothing is destroyed to satisfy a rename.
+ */
+export declare const RETIRED_GJC_DEFINITION_NAMES: readonly ["team"];
+export type RetiredGjcDefinitionName = (typeof RETIRED_GJC_DEFINITION_NAMES)[number];
+export type RetiredGjcDefinitionStatus = "absent" | "quarantined";
+export interface RetiredGjcDefinitionFile {
+    name: RetiredGjcDefinitionName;
+    /** Directory that held the retired definition. */
+    path: string;
+    /** Where it was moved, when quarantined. */
+    quarantinedTo?: string;
+    status: RetiredGjcDefinitionStatus;
+}
 export interface DefaultGjcDefinitionInstallResult {
     targetRoot: string;
     total: number;
@@ -61,6 +84,8 @@ export interface DefaultGjcDefinitionInstallResult {
     missing: number;
     different: number;
     files: DefaultGjcDefinitionInstallFile[];
+    /** Retired bundled definitions found under `targetRoot`, and what happened to them. */
+    retired: RetiredGjcDefinitionFile[];
 }
 export declare class BundledDefaultContentError extends Error {
     readonly sourcePath: string;
@@ -74,3 +99,12 @@ export declare function getDefaultGjcAgentDefinitions(): readonly DefaultGjcDefi
 export declare function getEmbeddedDefaultGjcSkillFragments(parentSkillName: DefaultGjcDefinitionName): DefaultGjcSkillFragmentDefinition[];
 export declare function getEmbeddedDefaultGjcSkills(): EmbeddedDefaultGjcSkill[];
 export declare function installDefaultGjcDefinitions(options?: InstallDefaultGjcDefinitionsOptions): Promise<DefaultGjcDefinitionInstallResult>;
+/**
+ * Quarantine any retired bundled definition still present under `targetRoot`.
+ *
+ * `check` reports what WOULD move without touching the filesystem, so
+ * `--check` callers stay read-only.
+ */
+export declare function retireRemovedGjcDefinitions(targetRoot: string, options?: {
+    check?: boolean;
+}): Promise<RetiredGjcDefinitionFile[]>;

package/dist/types/defaults/gjc-skills.generated.d.ts

@@ -4,7 +4,7 @@
  * Keep this module metadata-only: skill bodies are loaded through literal
  * dynamic imports only when a caller asks for their content.
  */
-export type BundledGjcSkillName = "deep-interview" | "ralplan" | "team" | "ultragoal";
+export type BundledGjcSkillName = "autoresearch" | "deep-interview" | "ralplan" | "ultragoal";
 export interface BundledGjcSkillCatalogEntry {
     readonly kind: "skill" | "skill-fragment";
     readonly name?: BundledGjcSkillName;

package/dist/types/discovery/helpers.d.ts

@@ -232,7 +232,7 @@ export declare function resolveActiveProjectRegistryPath(cwd: string): Promise<s
  * bootstrapped directory (no .gjc/ or .git/ yet) works: writeInstalledPluginsRegistry auto-creates
  * the directory tree on first write.
  *
- * Returns undefined when cwd is os.homedir() — that path is already the user registry and must
+ * Returns undefined when cwd is the trusted home — that path is already the user registry and must
  * never alias as the project registry.
  */
 export declare function resolveOrDefaultProjectRegistryPath(cwd: string): Promise<string | undefined>;

package/dist/types/edit/index.d.ts

@@ -29,6 +29,7 @@ export declare function summarizeEditToolActivity(kind: "args" | "result", value
 export declare class EditTool implements AgentTool<TInput> {
     #private;
     private readonly session;
+    private readonly modeOverride?;
     readonly name = "edit";
     readonly label = "Edit";
     readonly loadMode = "essential";
@@ -36,7 +37,7 @@ export declare class EditTool implements AgentTool<TInput> {
     readonly concurrency = "exclusive";
     readonly strict = true;
     readonly safeSummary: typeof summarizeEditToolActivity;
-    constructor(session: ToolSession);
+    constructor(session: ToolSession, modeOverride?: EditMode | undefined);
     get mode(): EditMode;
     get description(): string;
     get parameters(): TInput;

package/dist/types/eval/py/executor.d.ts

@@ -21,6 +21,8 @@ export interface PythonExecutorOptions {
     kernelOwnerId?: string;
     /** Kernel mode (session reuse vs per-call) */
     kernelMode?: PythonKernelMode;
+    /** Called when a retained session kernel is acquired or replaced. */
+    onKernelStart?: (kernelInstanceId: string) => void;
     /** Restart the kernel before executing */
     reset?: boolean;
     /** Session file path for accessing task outputs */

package/dist/types/extensibility/extensions/loader.d.ts

@@ -39,6 +39,38 @@ export declare class ExtensionRuntime implements IExtensionRuntime {
     getSessionName(): string | undefined;
     setSessionName(): Promise<void>;
 }
+/**
+ * Per-extension activation transaction over the shared runtime state.
+ *
+ * Registration writes from a factory are staged here (stage); the factory
+ * completing without throwing is the validation step; commit copies the
+ * staged mutations into the shared runtime; rollback discards them, so a
+ * factory that fails midway leaves no registration behind (issue #4718).
+ */
+export declare class ExtensionActivationScope {
+    #private;
+    /** True while staged writes may still be added or committed. */
+    get open(): boolean;
+    constructor(runtime: IExtensionRuntime);
+    get flagValues(): Map<string, boolean | string>;
+    get pendingProviderRegistrations(): Array<{
+        name: string;
+        config: import("./types").ProviderConfig;
+        sourceId: string;
+    }>;
+    /**
+     * Publish the staged mutations into the shared runtime as one transaction.
+     *
+     * Prior state is journaled before any live mutation so a throw partway
+     * through publication is undone before it escapes: flag entries that did
+     * not exist are removed, overwritten entries are restored, and the
+     * provider queue is truncated to its prior length. The scope only becomes
+     * terminal once publication has fully succeeded, so a failed commit
+     * leaves the shared runtime exactly as it was (issue #4718).
+     */
+    commit(): void;
+    rollback(): void;
+}
 /**
  * Create an Extension from an inline factory function.
  */

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

@@ -1,7 +1,7 @@
 import type { CanonicalGjcWorkflowSkill } from "../../skill-state/active-state";
 export declare const GJC_PLUGIN_MANIFEST_FILENAME = "gajae-plugin.json";
 export declare const GJC_PLUGIN_KIND = "gajae-code-plugin";
-export declare const GJC_SUBSKILL_PARENT_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
+export declare const GJC_SUBSKILL_PARENT_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "autoresearch"];
 export type GjcSubskillParentSkill = CanonicalGjcWorkflowSkill;
 export declare const GJC_SUBSKILL_PARENT_AGENTS: readonly ["executor", "architect", "planner", "critic"];
 export type GjcSubskillParentAgent = (typeof GJC_SUBSKILL_PARENT_AGENTS)[number];