@gajae-code/coding-agent 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [0.2.3] - 2026-06-01
+
+### Added
+
+- Added `/provider add --preset minimax|minimax-cn|glm` and matching `gjc setup provider --preset ...` shortcuts for OpenAI-compatible MiniMax and GLM/zAI custom-provider onboarding.
+- Added a built-in `skill` tool so the agent can chain into another loaded skill on its next turn. Mirrors `/skill:<name>` typing and subagent `autoloadSkills` by dispatching the chained skill's SKILL.md as a user-attribution custom message; controlled by the new `skill.enabled` setting (default true).
+- Added explicit fork-context task subagents with sanitized bounded parent-history seeds, global `task.forkContext.enabled`, per-agent `forkContext: allowed`, per-task `inheritContext: true`, audit-visible seed metadata, and fresh provider transport state by default.
+- Defaulted the bundled `executor` and `architect` agents to `forkContext: allowed` so callers can opt them into a sanitized parent-context seed via `task({ inheritContext: true })`; per-task selection remains explicit (default false).
+- Added a `/context` slash command that surfaces the active session's token usage breakdown via `buildSessionContext` without forking prompt assembly, so users can see active context before sessions overflow ([#150](https://github.com/Yeachan-Heo/gajae-code/pull/150)).
+- Added multi-line focused-option rendering to the `ask` tool's `HookSelectorComponent` via an opt-in `wrapFocused` flag so long option labels stay readable in plan-mode and other shared consumers ([#148](https://github.com/Yeachan-Heo/gajae-code/pull/148)).
+- Added a sanctioned native deep-interview spec persistence bridge so deep-interview can save final specs under `.gjc/specs/` before deliberate ralplan chaining without caller-side `.gjc` writes ([#134](https://github.com/Yeachan-Heo/gajae-code/pull/134)).
+- Added the skill chaining lifecycle's `handoff` state verb with same-turn dispatch and atomic HUD-truth synchronization across callee mode-state, caller mode-state, session active-state, and root active-state ([#132](https://github.com/Yeachan-Heo/gajae-code/pull/132)).
+
+### Changed
+
+- Clarified the README to position team as optional and ultragoal as implementation-through-evidence, so docs readers see workflow handoffs without spelunking into skill sources ([#145](https://github.com/Yeachan-Heo/gajae-code/pull/145)).
+- Migrated CI to the gajae self-hosted Linux runner with fork-PR guards, idempotent `fd` symlink setup, and Node 24 pinning for self-hosted jobs ([#124](https://github.com/Yeachan-Heo/gajae-code/pull/124)).
+
+### Fixed
+
+- Enforced the deep-interview phase boundary so active interviews block mutation tools until a handoff/spec is produced.
+- Made settings theme browsing confirm-only so arrowing through themes no longer changes the rendered theme before the displayed/persisted theme name changes.
+- Made startup CHANGELOG display deterministic by embedding `packages/coding-agent/CHANGELOG.md` into the binary so post-update launches show the shipped history regardless of cwd or `GJC_PACKAGE_DIR`/`PI_PACKAGE_DIR` overrides.
+- Registered `gjc update` as a public root subcommand so it invokes the bundled updater instead of routing into the interactive launcher.
+- Fixed local memory backend persistence so manual enqueue/rebuild starts maintenance immediately and prompt injection reads the active session's memory root.
+- Aligned release-bump CI tests with the highest bundled upstream Claude family and stopped cancelling TTSR retries when an aborted partial was not persisted, so dev PRs no longer regress on v0.2.2-style release assumptions ([#142](https://github.com/Yeachan-Heo/gajae-code/pull/142)).
+- Added a runtime guard in the built-in `skill` tool that rejects re-entry into the currently active skill via a typed active-skill bridge from agent sessions into tool sessions, preventing recursive skill handoffs that prompt-only guidance could not stop ([#129](https://github.com/Yeachan-Heo/gajae-code/pull/129)).
+
 ## [0.2.2] - 2026-05-31
 
 ### Added

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

@@ -5,6 +5,7 @@ export interface SetupCommandArgs {
         json?: boolean;
         check?: boolean;
         force?: boolean;
+        preset?: string;
         compat?: string;
         provider?: string;
         baseUrl?: string;

package/dist/types/commands/deep-interview.d.ts

@@ -2,6 +2,47 @@ import { Command } from "@gajae-code/utils/cli";
 export default class DeepInterview extends Command {
     static description: string;
     static strict: boolean;
+    static flags: {
+        quick: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        standard: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        deep: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        threshold: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "threshold-source": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "session-id": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        write: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        stage: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        slug: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        spec: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        handoff: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        deliberate: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+    };
     static examples: string[];
     run(): Promise<void>;
 }

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

@@ -24,6 +24,9 @@ export default class Setup extends Command {
         json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        preset: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         compat: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };

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

@@ -2295,6 +2295,15 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable the checkpoint and rewind tools for context checkpointing";
         };
     };
+    readonly "skill.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Skill";
+            readonly description: "Enable the skill tool so the agent can chain into another available skill on its next turn";
+        };
+    };
     readonly "fetch.enabled": {
         readonly type: "boolean";
         readonly default: true;
@@ -2705,6 +2714,33 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Allow subagents spawned via the task tool to use the lsp tool. Off by default to keep subagents cheap; enable when LSP-aware delegation is worth the extra tokens.";
         };
     };
+    readonly "task.forkContext.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Fork Context for Subagents";
+            readonly description: "Allow explicitly opted-in subagents to start from a sanitized snapshot of parent context when both the agent and task item also opt in.";
+        };
+    };
+    readonly "task.forkContext.maxMessages": {
+        readonly type: "number";
+        readonly default: 50;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Fork Context Max Messages";
+            readonly description: "Maximum parent messages copied into an explicitly opted-in subagent fork-context seed.";
+        };
+    };
+    readonly "task.forkContext.maxTokens": {
+        readonly type: "number";
+        readonly default: 0;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Fork Context Max Tokens";
+            readonly description: "Approximate token cap for fork-context seeds. 0 uses 25% of the target model context window.";
+        };
+    };
     readonly "task.maxRecursionDepth": {
         readonly type: "number";
         readonly default: 2;

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

@@ -3,6 +3,7 @@ import type { ExtensionModule } from "../capability/extension-module";
 import { type Rule } from "../capability/rule";
 import type { Skill } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import type { ForkContextPolicy } from "../task/types";
 /**
  * Standard paths for each config source.
  */
@@ -104,6 +105,7 @@ export interface ParsedAgentFields {
     autoloadSkills?: string[];
     blocking?: boolean;
     hide?: boolean;
+    forkContext?: ForkContextPolicy;
 }
 /**
  * Parse agent fields from frontmatter.

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

@@ -50,6 +50,12 @@ export interface ExtensionUIDialogOptions {
     onExternalEditor?: () => void;
     /** Optional footer hint text rendered by interactive selector */
     helpText?: string;
+    /**
+     * For interactive TUI select dialogs, render the focused option across
+     * multiple rows instead of truncating it. This is a select-only rendering
+     * hint; non-TUI bridges (RPC, ACP) drop it and do not serialize it.
+     */
+    wrapFocused?: boolean;
 }
 /** Raw terminal input listener for extensions. */
 export type TerminalInputHandler = (data: string) => {

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

@@ -12,4 +12,22 @@ export interface DeepInterviewCommandResult {
     stdout?: string;
     stderr?: string;
 }
+export interface ResolvedDeepInterviewSpecWriteArgs {
+    stage: "final";
+    slug: string;
+    spec: string;
+    sessionId?: string;
+    json: boolean;
+    deliberate: boolean;
+    handoff?: "ralplan";
+}
+export interface PersistedDeepInterviewSpec {
+    slug: string;
+    path: string;
+    stage: "final";
+    sha256: string;
+    createdAt: string;
+    statePath: string;
+}
+export declare function persistDeepInterviewSpec(cwd: string, resolved: ResolvedDeepInterviewSpecWriteArgs): Promise<PersistedDeepInterviewSpec>;
 export declare function runNativeDeepInterviewCommand(args: string[], cwd?: string): Promise<DeepInterviewCommandResult>;

package/dist/types/hooks/skill-state.d.ts

@@ -50,6 +50,9 @@ export interface ModeState {
     thread_id?: string;
     cwd?: string;
     updated_at?: string;
+    handoff_from?: string;
+    handoff_to?: string;
+    handoff_at?: string;
     [key: string]: unknown;
 }
 export interface RecordSkillActivationInput {
@@ -79,6 +82,8 @@ export interface UserPromptSubmitStateInput {
 export declare function detectSkillKeywords(text: string): SkillKeywordMatch[];
 export declare function detectPrimarySkillKeyword(text: string): SkillKeywordMatch | null;
 export declare function resolveGjcStateDir(cwd: string, stateDir?: string): string;
+import { initialPhaseForSkill } from "../skill-state/initial-phase";
+export { initialPhaseForSkill };
 export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string, stateDir?: string): Promise<SkillActiveState | null>;
 export declare function recordSkillActivation(input: RecordSkillActivationInput): Promise<SkillActiveState | null>;
 export declare function buildActiveUltragoalPromptContext(input: UserPromptSubmitStateInput): Promise<string | null>;

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

@@ -16,7 +16,7 @@ export declare function startMemoryStartupTask(options: {
 /**
  * Build memory usage instructions for prompt injection.
  */
-export declare function buildMemoryToolDeveloperInstructions(agentDir: string, settings: Settings): Promise<string | undefined>;
+export declare function buildMemoryToolDeveloperInstructions(agentDir: string, settings: Settings, session?: AgentSession): Promise<string | undefined>;
 /**
  * Clear all persisted memory state and generated artifacts.
  */

package/dist/types/memory-backend/local-backend.d.ts

@@ -2,8 +2,8 @@ import type { MemoryBackend } from "./types";
 /**
  * Wraps the existing `memories/` module as a `MemoryBackend`.
  *
- * No behavioural change — every call delegates to the legacy entry points so
- * the local memory pipeline (rollout summarisation → SQLite → memory_summary.md)
- * keeps working exactly as before.
+ * The local pipeline owns rollout summarisation, SQLite retention, and
+ * `memory_summary.md`. Prompt reads use the live session cwd when available so
+ * manual enqueue/rebuild and startup hydration address the same memory root.
  */
 export declare const localBackend: MemoryBackend;

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

@@ -14,6 +14,13 @@ export interface HookSelectorOptions {
     onRight?: () => void;
     onExternalEditor?: () => void;
     helpText?: string;
+    /**
+     * When true, the focused option's label wraps across multiple rows so the
+     * full text is visible. Non-focused options remain single-row with the
+     * existing `…` truncation hint. When unset/false, rendering is
+     * byte-identical to the previous implementation for all consumers.
+     */
+    wrapFocused?: boolean;
 }
 export declare class HookSelectorComponent extends Container {
     #private;

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

@@ -29,8 +29,6 @@ export interface StatusLinePreviewSettings {
 export interface SettingsCallbacks {
     /** Called when any setting value changes */
     onChange: (path: SettingPath, newValue: unknown) => void;
-    /** Called for theme preview while browsing */
-    onThemePreview?: (theme: string) => void | Promise<void>;
     /** Called for status line preview while configuring */
     onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
     /** Get current rendered status line for inline preview */

package/dist/types/modes/utils/context-usage.d.ts

@@ -1,9 +1,10 @@
+import type { AgentMessage } from "@gajae-code/agent-core";
 import type { Model } from "@gajae-code/ai";
 import type { Skill } from "../../extensibility/skills";
 import type { AgentSession } from "../../session/agent-session";
 import type { Tool } from "../../tools";
 import type { theme as Theme } from "../theme/theme";
-type CategoryId = "systemPrompt" | "systemContext" | "systemTools" | "skills" | "messages";
+type CategoryId = "systemPrompt" | "systemContext" | "rules" | "tools" | "skills" | "messages" | "lastUserTurn";
 interface CategoryInfo {
     id: CategoryId;
     label: string;
@@ -15,6 +16,7 @@ export interface ContextBreakdown {
     model: Model | undefined;
     contextWindow: number;
     categories: CategoryInfo[];
+    lastUserTurnTokens: number;
     usedTokens: number;
     autoCompactBufferTokens: number;
     freeTokens: number;
@@ -38,7 +40,9 @@ export declare function computeNonMessageTokens(session: AgentSession): number;
  * Compute a breakdown of estimated context usage by category for the active
  * session and model.
  */
-export declare function computeContextBreakdown(session: AgentSession): ContextBreakdown;
+export declare function computeContextBreakdown(session: AgentSession, options?: {
+    messages?: readonly AgentMessage[];
+}): ContextBreakdown;
 /**
  * Render a colorful context-usage panel as ANSI text. Output is a series of
  * lines pairing the grid (left) with the legend (right).

package/dist/types/sdk.d.ts

@@ -1,5 +1,5 @@
 import { type AgentTelemetryConfig, type ThinkingLevel } from "@gajae-code/agent-core";
-import { type Model } from "@gajae-code/ai";
+import { type Model, type ProviderSessionState } from "@gajae-code/ai";
 import { type Rule } from "./capability/rule";
 import { ModelRegistry } from "./config/model-registry";
 import { type ScopedModelSelection } from "./config/model-resolver";
@@ -15,7 +15,7 @@ import type { HindsightSessionState } from "./hindsight/state";
 import { type LocalProtocolOptions } from "./internal-urls";
 import { AgentRegistry } from "./registry/agent-registry";
 import { MCPManager } from "./runtime-mcp";
-import { AgentSession } from "./session/agent-session";
+import { AgentSession, type ForkContextSeed } from "./session/agent-session";
 import { AuthStorage } from "./session/auth-storage";
 import { SessionManager } from "./session/session-manager";
 import { type BuildSystemPromptResult } from "./system-prompt";
@@ -121,6 +121,10 @@ export interface CreateAgentSessionOptions {
      * `@opentelemetry/api` package returns a no-op tracer in that case.
      */
     telemetry?: AgentTelemetryConfig;
+    /** Optional fork-context seed used to initialize a child session before its first prompt. */
+    forkContextSeed?: ForkContextSeed;
+    /** Optional provider state override. Fork-context children should omit this by default. */
+    providerSessionState?: Map<string, ProviderSessionState>;
 }
 /** Result from createAgentSession */
 export interface CreateAgentSessionResult {

package/dist/types/session/agent-session.d.ts

@@ -12,9 +12,32 @@
  *
  * Modes use this class and add their own I/O layer on top.
  */
-import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, ThinkingLevel } from "@gajae-code/agent-core";
+import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type StablePrefixSnapshot, ThinkingLevel } from "@gajae-code/agent-core";
 import { type CompactionResult } from "@gajae-code/agent-core/compaction";
 import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@gajae-code/ai";
+export interface ForkContextSeedMetadata {
+    sourceSessionId: string;
+    parentMessageCount: number;
+    includedMessages: number;
+    skippedMessages: number;
+    approximateTokens: number;
+    maxMessages: number;
+    maxTokens: number;
+    skippedReasons: Record<string, number>;
+}
+export interface ForkContextSeed {
+    messages: Message[];
+    agentMessages: AgentMessage[];
+    metadata: ForkContextSeedMetadata;
+    cacheIdentity?: string;
+    appendOnlyPrefixSnapshot?: StablePrefixSnapshot;
+}
+export interface ForkContextSeedOptions {
+    maxMessages: number;
+    maxTokens: number;
+    cacheIdentity?: string;
+    signal?: AbortSignal;
+}
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
 import type { Rule } from "../capability/rule";
 import { type ModelRegistry } from "../config/model-registry";
@@ -138,6 +161,8 @@ export interface AgentSessionConfig {
     skillsSettings?: SkillsSettings;
     /** Model registry for API key resolution and model discovery */
     modelRegistry: ModelRegistry;
+    /** Task recursion depth for nested sessions. Top-level sessions use 0. */
+    taskDepth?: number;
     /** Tool registry for LSP and settings */
     toolRegistry?: Map<string, AgentTool>;
     /** Current session pre-LLM message transform pipeline */
@@ -188,6 +213,10 @@ export interface AgentSessionConfig {
      * **MUST NOT** dispose it on their own teardown.
      */
     ownedAsyncJobManager?: AsyncJobManager;
+    /** Optional fork-context seed used to initialize a child session before its first prompt. */
+    forkContextSeed?: ForkContextSeed;
+    /** Optional provider state override. Fork-context children should omit this by default. */
+    providerSessionState?: Map<string, ProviderSessionState>;
     /** Agent identity (registry id like "0-Main" or "3-Alice") used for IRC routing. */
     agentId?: string;
     /** Shared agent registry (for forwarding IRC observations to the main session UI). */
@@ -199,6 +228,8 @@ export interface AgentSessionConfig {
      * so that credential sticky selection is consistent with the session's streaming calls.
      */
     providerSessionId?: string;
+    /** Optional provider-facing cache identity, distinct from logical session identity. */
+    providerCacheSessionId?: string;
 }
 /** Options for AgentSession.prompt() */
 export interface PromptOptions {
@@ -263,6 +294,7 @@ export declare class AgentSession {
     readonly agent: Agent;
     readonly sessionManager: SessionManager;
     readonly settings: Settings;
+    readonly taskDepth: number;
     readonly yieldQueue: YieldQueue;
     readonly configWarnings: string[];
     readonly rawSseDebugBuffer: RawSseDebugBuffer;
@@ -279,12 +311,24 @@ export declare class AgentSession {
     setForcedToolChoice(toolName: string): void;
     /** The tool-choice queue: forces forthcoming tool invocations and carries handlers. */
     get toolChoiceQueue(): ToolChoiceQueue;
+    /** Current skill prompt executing in this session, if any. */
+    getActiveSkillState(): {
+        skill: string;
+        session_id?: string;
+    } | undefined;
+    /** Best-effort accessor for the active skill's `current_phase` field from
+     *  its persisted mode-state file. Used by the `skill` tool to enforce the
+     *  terminal-phase chain guard. Returns undefined when no active skill is
+     *  recorded or the mode-state file is missing/unreadable; callers should
+     *  treat undefined as a non-terminal phase (refuses to chain). */
+    getActiveSkillPhase(): string | undefined;
     /** Peek the in-flight directive's invocation handler for use by the resolve tool. */
     peekQueueInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     peekStandingResolveHandler(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     setStandingResolveHandler(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void;
     /** Provider-scoped mutable state store for transport/session caches. */
     get providerSessionState(): Map<string, ProviderSessionState>;
+    buildForkContextSeed(options: ForkContextSeedOptions): Promise<ForkContextSeed>;
     getHindsightSessionState(): HindsightSessionState | undefined;
     setHindsightSessionState(state: HindsightSessionState | undefined): HindsightSessionState | undefined;
     /** TTSR manager for time-traveling stream rules */

package/dist/types/session/session-manager.d.ts

@@ -111,6 +111,8 @@ export interface SessionInitEntry extends SessionEntryBase {
     tools: string[];
     /** Output schema if structured output was requested */
     outputSchema?: unknown;
+    /** Fork-context seed metadata for subagent debugging/replay. */
+    forkContext?: unknown;
 }
 /** Mode change entry - tracks agent mode transitions (e.g. plan mode). */
 export interface ModeChangeEntry extends SessionEntryBase {
@@ -393,6 +395,7 @@ export declare class SessionManager {
         task: string;
         tools: string[];
         outputSchema?: unknown;
+        forkContext?: unknown;
     }): string;
     /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
     appendCompaction<T = unknown>(summary: string, shortSummary: string | undefined, firstKeptEntryId: string, tokensBefore: number, details?: T, fromExtension?: boolean, preserveData?: Record<string, unknown>): string;

package/dist/types/setup/model-onboarding-guidance.d.ts

@@ -1,4 +1,5 @@
 export declare const MODEL_ONBOARDING_API_PROVIDER_COMMAND = "/provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model>";
+export declare const MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND = "/provider add --preset <minimax|minimax-cn|glm>";
 export declare const MODEL_ONBOARDING_SETUP_COMMAND = "gjc setup provider";
 export declare const MODEL_ONBOARDING_OAUTH_COMMAND = "/provider login [provider-id] or /login [provider-id]";
 export declare function formatModelOnboardingGuidance(): string;

package/dist/types/setup/provider-onboarding.d.ts

@@ -1,28 +1,52 @@
+import { type ModelsConfig } from "../config/models-config-schema";
 export type ProviderCompatibility = "openai" | "anthropic";
+export type ProviderSetupApi = "openai-responses" | "openai-completions" | "anthropic-messages";
 export interface ProviderSetupInput {
-    compatibility: ProviderCompatibility;
-    providerId: string;
-    baseUrl: string;
+    compatibility?: ProviderCompatibility;
+    preset?: string;
+    providerId?: string;
+    baseUrl?: string;
     apiKey?: string;
     apiKeyEnv?: string;
-    models: string[];
+    models?: string[];
     modelsPath?: string;
     force?: boolean;
 }
 export interface ProviderSetupResult {
     providerId: string;
     compatibility: ProviderCompatibility;
-    api: "openai-responses" | "anthropic-messages";
+    api: ProviderSetupApi;
     baseUrl: string;
     modelIds: string[];
     modelsPath: string;
     redactedApiKey: string;
     credentialSource: "literal" | "env";
+    preset?: string;
+    presetName?: string;
+}
+type ProviderConfig = NonNullable<NonNullable<ModelsConfig["providers"]>[string]>;
+type ProviderCompatConfig = NonNullable<ProviderConfig["compat"]>;
+interface ProviderPreset {
+    id: string;
+    aliases: readonly string[];
+    name: string;
+    description: string;
+    compatibility: ProviderCompatibility;
+    api: ProviderSetupApi;
+    providerId: string;
+    baseUrl: string;
+    apiKeyEnv: string;
+    models: readonly string[];
+    compat?: ProviderCompatConfig;
 }
+export declare const PROVIDER_PRESETS: readonly ProviderPreset[];
 export declare function getDefaultModelsPath(): string;
 export declare function normalizeProviderId(providerId: string): string;
 export declare function parseProviderCompatibility(value: string): ProviderCompatibility;
+export declare function findProviderPreset(value: string | undefined): ProviderPreset | undefined;
+export declare function formatProviderPresetList(): string;
 export declare function parseModelList(values: readonly string[]): string[];
 export declare function redactSecret(secret: string): string;
 export declare function addApiCompatibleProvider(input: ProviderSetupInput): Promise<ProviderSetupResult>;
 export declare function formatProviderSetupResult(result: ProviderSetupResult): string;
+export {};

package/dist/types/skill-state/active-state.d.ts

@@ -1,6 +1,5 @@
 import type { WorkflowStateReceipt } from "./workflow-state-contract";
 export declare const SKILL_ACTIVE_STATE_FILE = "skill-active-state.json";
-export declare const SKILL_ACTIVE_STALE_MS: number;
 export declare const CANONICAL_GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "team"];
 export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];
 export type WorkflowHudSeverity = "info" | "warning" | "blocked" | "error" | "success";
@@ -31,6 +30,9 @@ export interface SkillActiveEntry {
     hud?: WorkflowHudSummary;
     stale?: boolean;
     receipt?: WorkflowStateReceipt;
+    handoff_from?: string;
+    handoff_to?: string;
+    handoff_at?: string;
 }
 export interface SkillActiveState {
     version?: number;
@@ -63,6 +65,9 @@ export interface SyncSkillActiveStateOptions {
     source?: string;
     hud?: WorkflowHudSummary;
     receipt?: WorkflowStateReceipt;
+    handoff_from?: string;
+    handoff_to?: string;
+    handoff_at?: string;
 }
 export declare function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined;
 export declare function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGjcWorkflowSkill;
@@ -71,3 +76,23 @@ export declare function normalizeSkillActiveState(raw: unknown): SkillActiveStat
 export declare function getSkillActiveStatePaths(cwd: string, sessionId?: string): SkillActiveStatePaths;
 export declare function readVisibleSkillActiveState(cwd: string, sessionId?: string): Promise<SkillActiveState | null>;
 export declare function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<void>;
+export interface ApplyHandoffOptions {
+    cwd: string;
+    caller: SyncSkillActiveStateOptions;
+    callee: SyncSkillActiveStateOptions;
+    /** Shared timestamp; falls back to new Date().toISOString(). */
+    nowIso?: string;
+    /** When true, read errors other than ENOENT propagate. */
+    strict?: boolean;
+}
+/**
+ * Atomically apply a workflow-skill handoff to both the session-scoped and
+ * root `skill-active-state.json` files in a single write per file.
+ *
+ * Write order: **session first, root last**. The session file is the
+ * source of truth for HUD; the root aggregate must never lead the session
+ * during a handoff window. Each file is rewritten once with caller demoted
+ * to `active:false` (preserving `handoff_to`/`handoff_at` lineage) and
+ * callee promoted to `active:true` (with `handoff_from`/`handoff_at`).
+ */
+export declare function applyHandoffToActiveState(options: ApplyHandoffOptions): Promise<void>;

package/dist/types/skill-state/deep-interview-mutation-guard.d.ts

@@ -1,5 +1,5 @@
 import type { AgentTool } from "@gajae-code/agent-core";
-export declare const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE = "Deep-interview is active; continue interviewing with `ask`, write/finalize pending specs through the required GJC workflow CLI, or use an explicit force override. Direct `.gjc/` and product-code edits are blocked until explicit execution approval.";
+export declare const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE = "Deep-interview phase boundary: continue gathering context/questions/risks and emit a handoff/spec before code edits. Mutation tools and patch execution are blocked while deep-interview is active; finalize specs through `gjc deep-interview --write --stage final` or hand off to an execution phase.";
 export declare const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE = "Workflow state JSON is runtime-owned. Use `gjc state <skill> read|write --input '<json>'` for deep-interview, ralplan, ultragoal, and team. Planning artifacts under `.gjc/specs/` and `.gjc/plans/` remain allowed.";
 type ToolWithEditMode = AgentTool & {
     mode?: unknown;

package/dist/types/skill-state/initial-phase.d.ts

@@ -0,0 +1,12 @@
+import type { CanonicalGjcWorkflowSkill } from "./active-state";
+/**
+ * Canonical initial phase for each GJC workflow skill. Used by both
+ * `recordSkillActivation` (UserPromptSubmit hook seeding initial mode-state)
+ * and the `gjc state <caller> handoff --to <callee>` runtime when promoting
+ * the callee.
+ *
+ * Keeping this mapping in a neutral skill-state module avoids cycles between
+ * `gjc-runtime/state-runtime.ts` and `hooks/skill-state.ts` (which pulls in
+ * session-manager and ultragoal verification code).
+ */
+export declare function initialPhaseForSkill(skill: CanonicalGjcWorkflowSkill | string): string;

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

@@ -10,6 +10,7 @@ import { Settings } from "../config/settings";
 import { type Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
+import type { ForkContextSeed } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { AuthStorage } from "../session/auth-storage";
 import type { ContextFileEntry } from "../tools";
@@ -73,6 +74,7 @@ export interface ExecutorOptions {
     parentTelemetry?: AgentTelemetryConfig;
     /** Skills to autoload via sendCustomMessage before the first prompt */
     autoloadSkills?: Skill[];
+    forkContextSeed?: ForkContextSeed;
 }
 export interface YieldItem {
     data?: unknown;