@gajae-code/coding-agent 0.2.2 → 0.2.4

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;

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

@@ -5,6 +5,7 @@ import { type TaskSimpleMode } from "./simple-mode";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
+export type ForkContextPolicy = "forbidden" | "allowed";
 /** Maximum output bytes per agent */
 export declare const MAX_OUTPUT_BYTES: number;
 /** Maximum output lines per agent */
@@ -40,6 +41,7 @@ export declare const taskItemSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
     assignment: z.ZodString;
+    inheritContext: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type TaskItem = z.infer<typeof taskItemSchema>;
 export declare const taskSchema: z.ZodObject<{
@@ -48,6 +50,7 @@ export declare const taskSchema: z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        inheritContext: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const taskSchemaNoIsolation: z.ZodObject<{
@@ -56,6 +59,7 @@ export declare const taskSchemaNoIsolation: z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        inheritContext: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
@@ -64,6 +68,7 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        inheritContext: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -71,6 +76,7 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        inheritContext: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -78,6 +84,7 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        inheritContext: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -85,6 +92,7 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        inheritContext: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -92,6 +100,7 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        inheritContext: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
@@ -99,6 +108,7 @@ declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
         id: z.ZodString;
         description: z.ZodString;
         assignment: z.ZodString;
+        inheritContext: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>];
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
@@ -150,6 +160,7 @@ export interface AgentDefinition {
     blocking?: boolean;
     autoloadSkills?: string[];
     hide?: boolean;
+    forkContext?: ForkContextPolicy;
     source: AgentSource;
     filePath?: string;
 }

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

@@ -1,5 +1,5 @@
 import type { AgentTelemetryConfig, AgentTool } from "@gajae-code/agent-core";
-import type { ToolChoice } from "@gajae-code/ai";
+import type { Model, ToolChoice } from "@gajae-code/ai";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
@@ -7,10 +7,12 @@ import type { GoalModeState, GoalRuntime } from "../goals";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { PlanModeState } from "../plan-mode/state";
 import type { AgentRegistry } from "../registry/agent-registry";
+import type { ForkContextSeed, ForkContextSeedOptions } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { ClientBridge } from "../session/client-bridge";
 import type { CustomMessage } from "../session/messages";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
+import type { SkillActiveEntry } from "../skill-state/active-state";
 import type { AgentOutputManager } from "../task/output-manager";
 import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
 import type { EventBus } from "../utils/event-bus";
@@ -48,6 +50,7 @@ export * from "./resolve";
 export * from "./review";
 export * from "./search";
 export * from "./search-tool-bm25";
+export * from "./skill";
 export * from "./ssh";
 export * from "./subagent";
 export * from "./todo-write";
@@ -77,6 +80,12 @@ export interface ToolSession {
     workspaceTree?: WorkspaceTree;
     /** Pre-loaded skills */
     skills?: Skill[];
+    /** Currently executing skill prompt, when this tool session is inside one. */
+    getActiveSkillState?: () => Pick<SkillActiveEntry, "skill" | "session_id"> | undefined;
+    /** Get the active skill prompt's current phase so the skill tool can apply
+     *  its terminal-phase chain guard. Returns the raw phase string or undefined
+     *  when no active skill (or accessor) is available. */
+    getActiveSkillPhase?: () => string | undefined;
     /** Pre-loaded prompt templates */
     promptTemplates?: PromptTemplate[];
     /** Whether LSP integrations are enabled */
@@ -122,6 +131,8 @@ export interface ToolSession {
     getSessionSpawns: () => string | null;
     /** Get resolved model string if explicitly set for this session */
     getModelString?: () => string | undefined;
+    /** Current model, when selected. */
+    model?: Model;
     /** Get the current session model string, regardless of how it was chosen */
     getActiveModelString?: () => string | undefined;
     /** Auth storage for passing to subagents (avoids re-discovery) */
@@ -204,9 +215,17 @@ export interface ToolSession {
     conflictHistory?: import("./conflict-detect").ConflictHistory;
     /** Queue a hidden message to be injected at the next agent turn. */
     queueDeferredMessage?(message: CustomMessage): void;
+    /** Dispatch a custom message through the active session. Used by the `skill`
+     *  tool to dispatch another skill prompt same-turn after recording a handoff. */
+    sendCustomMessage?(message: Pick<CustomMessage, "customType" | "content" | "display" | "details" | "attribution">, options?: {
+        triggerTurn?: boolean;
+        deliverAs?: "steer" | "followUp" | "nextTurn";
+    }): Promise<void>;
     /** Get the active OpenTelemetry config so subagent dispatch can forward
      *  the parent's tracer/hooks with the subagent's own identity stamped. */
     getTelemetry?: () => AgentTelemetryConfig | undefined;
+    /** Build a sanitized fork-context seed for task subagents. */
+    buildForkContextSeed?: (options: ForkContextSeedOptions) => Promise<ForkContextSeed>;
 }
 export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 export type BuiltinToolLoadMode = "essential" | "discoverable";

package/dist/types/tools/skill.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Skill Tool — agent-initiated skill chaining.
+ *
+ * Lets the agent hand off to another available skill in the current turn. The
+ * callee's SKILL.md is dispatched through the same custom-message path used by
+ * `/skill:<name>` typing, as a user-attribution message delivered same-turn
+ * (without `deliverAs: "nextTurn"`). Before dispatch, the tool calls
+ * `gjc state <caller> handoff --to <callee>` in-process via the state-runtime
+ * function so caller and callee mode-states plus `skill-active-state.json`
+ * transition atomically.
+ *
+ * Chaining is refused unless the caller's `current_phase` is in
+ * `{complete, completed, handoff, failed, cancelled, canceled, inactive}`. The
+ * agent declares readiness either by writing `current_phase: "handoff"` to its
+ * mode-state or by running the handoff verb directly.
+ */
+import type { AgentTool, AgentToolResult } from "@gajae-code/agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+declare const skillSchema: z.ZodObject<{
+    name: z.ZodString;
+    args: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SkillToolInput = z.infer<typeof skillSchema>;
+export interface SkillToolDetails {
+    name: string;
+    path: string;
+    args?: string;
+    lineCount: number;
+}
+export declare class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails> {
+    #private;
+    readonly name = "skill";
+    readonly label = "Skill";
+    readonly summary = "Chain into another available skill in the current turn";
+    readonly loadMode = "discoverable";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): SkillTool | null;
+    execute(_toolCallId: string, input: SkillToolInput, signal?: AbortSignal): Promise<AgentToolResult<SkillToolDetails>>;
+}
+export {};

package/dist/types/utils/changelog.d.ts

@@ -5,10 +5,26 @@ export interface ChangelogEntry {
     content: string;
 }
 /**
- * Parse changelog entries from CHANGELOG.md
- * Scans for ## lines and collects content until next ## or EOF
+ * Parse changelog entries from a CHANGELOG.md text body.
+ * Scans for ## lines and collects content until next ## or EOF.
+ * Pure and synchronous so it can be reused by the embedded display path.
+ */
+export declare function parseChangelogContent(content: string): ChangelogEntry[];
+/**
+ * Parse changelog entries from a CHANGELOG.md file on disk.
+ * Returns [] on ENOENT; logs and returns [] on other read/parse errors.
  */
 export declare function parseChangelog(changelogPath: string): Promise<ChangelogEntry[]>;
+/**
+ * Return changelog entries from the CHANGELOG.md that shipped with this binary.
+ *
+ * The text is embedded at build time via `with { type: "text" }`, so the
+ * displayed changelog is deterministic across compiled binaries, source-tree
+ * dev runs, and `GJC_PACKAGE_DIR` / `PI_PACKAGE_DIR` overrides (which scope to
+ * optional package assets like docs/examples and do not influence the
+ * binary-identity changelog).
+ */
+export declare function getDisplayChangelogEntries(): ChangelogEntry[];
 /**
  * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
  */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.2.2",
+	"version": "0.2.4",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -48,12 +48,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.2.2",
-		"@gajae-code/agent-core": "0.2.2",
-		"@gajae-code/ai": "0.2.2",
-		"@gajae-code/natives": "0.2.2",
-		"@gajae-code/tui": "0.2.2",
-		"@gajae-code/utils": "0.2.2",
+		"@gajae-code/stats": "0.2.4",
+		"@gajae-code/agent-core": "0.2.4",
+		"@gajae-code/ai": "0.2.4",
+		"@gajae-code/natives": "0.2.4",
+		"@gajae-code/tui": "0.2.4",
+		"@gajae-code/utils": "0.2.4",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/cli/setup-cli.ts

@@ -16,6 +16,7 @@ import {
 import { theme } from "../modes/theme/theme";
 import {
 	addApiCompatibleProvider,
+	formatProviderPresetList,
 	formatProviderSetupResult,
 	parseProviderCompatibility,
 } from "../setup/provider-onboarding";
@@ -28,6 +29,7 @@ export interface SetupCommandArgs {
 		json?: boolean;
 		check?: boolean;
 		force?: boolean;
+		preset?: string;
 		compat?: string;
 		provider?: string;
 		baseUrl?: string;
@@ -42,6 +44,7 @@ const VALID_COMPONENTS: SetupComponent[] = ["defaults", "hooks", "provider", "py
 function hasProviderSetupFlags(flags: SetupCommandArgs["flags"]): boolean {
 	return (
 		flags.compat !== undefined ||
+		flags.preset !== undefined ||
 		flags.provider !== undefined ||
 		flags.baseUrl !== undefined ||
 		flags.apiKeyEnv !== undefined ||
@@ -57,7 +60,7 @@ function rejectProviderFlagsOutsideProvider(component: SetupComponent, flags: Se
 	console.error(chalk.red("Provider setup flags require the explicit `provider` component."));
 	console.error(
 		chalk.dim(
-			`Run: ${APP_NAME} setup provider --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <id>`,
+			`Run: ${APP_NAME} setup provider --preset <minimax|glm> or ${APP_NAME} setup provider --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <id>`,
 		),
 	);
 	process.exit(1);
@@ -87,6 +90,8 @@ export function parseSetupArgs(args: string[]): SetupCommandArgs | undefined {
 			flags.force = true;
 		} else if (arg === "--compat") {
 			flags.compat = args[++i];
+		} else if (arg === "--preset") {
+			flags.preset = args[++i];
 		} else if (arg === "--provider") {
 			flags.provider = args[++i];
 		} else if (arg === "--base-url") {
@@ -190,6 +195,7 @@ export async function runSetupCommand(cmd: SetupCommandArgs): Promise<void> {
 async function handleProviderSetup(flags: {
 	json?: boolean;
 	force?: boolean;
+	preset?: string;
 	compat?: string;
 	provider?: string;
 	baseUrl?: string;
@@ -199,20 +205,25 @@ async function handleProviderSetup(flags: {
 }): Promise<void> {
 	try {
 		const missing: string[] = [];
-		if (!flags.compat) missing.push("--compat");
-		if (!flags.provider) missing.push("--provider");
-		if (!flags.baseUrl) missing.push("--base-url");
-		if (!flags.apiKeyEnv) missing.push("--api-key-env");
-		if (!flags.model || flags.model.length === 0) missing.push("--model");
+		if (!flags.preset) {
+			if (!flags.compat) missing.push("--compat");
+			if (!flags.provider) missing.push("--provider");
+			if (!flags.baseUrl) missing.push("--base-url");
+			if (!flags.apiKeyEnv) missing.push("--api-key-env");
+			if (!flags.model || flags.model.length === 0) missing.push("--model");
+		}
 		if (missing.length > 0) {
-			throw new Error(`Missing required provider setup option(s): ${missing.join(", ")}`);
+			throw new Error(
+				`Missing required provider setup option(s): ${missing.join(", ")}. Or use --preset <preset>.\nAvailable presets:\n${formatProviderPresetList()}`,
+			);
 		}
 		const result = await addApiCompatibleProvider({
-			compatibility: parseProviderCompatibility(flags.compat!),
-			providerId: flags.provider!,
-			baseUrl: flags.baseUrl!,
+			compatibility: flags.compat ? parseProviderCompatibility(flags.compat) : undefined,
+			preset: flags.preset,
+			providerId: flags.provider,
+			baseUrl: flags.baseUrl,
 			apiKeyEnv: flags.apiKeyEnv,
-			models: flags.model!,
+			models: flags.model,
 			modelsPath: flags.modelsPath,
 			force: flags.force,
 		});
@@ -400,18 +411,21 @@ ${chalk.bold("Usage:")}
 ${chalk.bold("Components:")}
   defaults  Install bundled GJC default workflow skills (default)
   hooks     Optional: install GJC native Codex UserPromptSubmit/Stop skill-state hooks
-  provider  Optional: add an OpenAI-compatible or Anthropic-compatible API provider
+  provider  Optional: add a preset, OpenAI-compatible, or Anthropic-compatible API provider
   python    Optional: verify a Python 3 interpreter is reachable for code execution
   stt       Optional: install speech-to-text dependencies (openai-whisper, recording tools)
 
 
 ${chalk.bold("Provider example:")}
+  ${APP_NAME} setup provider --preset minimax
+  ${APP_NAME} setup provider --preset glm
   MY_PROVIDER_KEY=sk-... ${APP_NAME} setup provider --compat openai --provider my-oai --base-url https://api.example.com/v1 --api-key-env MY_PROVIDER_KEY --model gpt-example
 
 ${chalk.bold("Options:")}
   -c, --check       Check if dependencies are installed without installing
   -f, --force       Overwrite existing default workflow skill files
   --json            Output status as JSON
+  --preset          Provider preset: minimax, minimax-cn, or glm (aliases include minimax-code and zai)
   --compat          Provider compatibility: openai or anthropic
   --provider        Provider id to add to models.yml
   --base-url        Provider API base URL