@gajae-code/coding-agent 0.2.1 → 0.2.3

package/dist/types/session/contribution-prep.d.ts

@@ -0,0 +1,47 @@
+import type { AgentMessage } from "@gajae-code/agent-core";
+export declare const CONTRIBUTION_PREP_SCHEMA_VERSION = 1;
+export interface ContributionPrepArtifact {
+    path: string;
+    description: string;
+}
+export interface ContributionPrepManifest {
+    schema_version: number;
+    source_session_id: string;
+    created_at: string;
+    cwd: string;
+    git_head: string | null;
+    changed_files: string[];
+    artifacts: ContributionPrepArtifact[];
+    redactions: string[];
+    recommended_output: string[];
+    worker_prompt_path: string;
+}
+export interface ContributionPrepResult {
+    manifestPath: string;
+    workerPromptPath: string;
+    artifactDir: string;
+    changedFiles: string[];
+    spawned: boolean;
+}
+export interface ContributionPrepOptions {
+    customInstructions?: string;
+    spawnWorker?: boolean;
+    artifactRoot?: string;
+    now?: Date;
+    spawn?: (args: string[], cwd: string, shell: boolean) => Promise<void>;
+}
+export interface ContributionPrepContext {
+    sessionId: string;
+    cwd: string;
+    sessionFile?: string;
+    messages: AgentMessage[];
+    customInstructions?: string;
+    now?: Date;
+}
+interface RedactionState {
+    labels: Set<string>;
+}
+export declare function redactContributionPrepText(text: string, cwd: string, state?: RedactionState): string;
+export declare function buildContributionPrepWorkerPrompt(manifestPath: string): string;
+export declare function prepareContributionPrep(context: ContributionPrepContext, options?: ContributionPrepOptions): Promise<ContributionPrepResult>;
+export {};

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,5 +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";
@@ -17,6 +17,7 @@ export interface WorkflowHudSummary {
     severity?: WorkflowHudSeverity;
     updated_at?: string;
 }
+export type { WorkflowStateReceipt } from "./workflow-state-contract";
 export interface SkillActiveEntry {
     skill: string;
     phase?: string;
@@ -28,6 +29,10 @@ export interface SkillActiveEntry {
     turn_id?: string;
     hud?: WorkflowHudSummary;
     stale?: boolean;
+    receipt?: WorkflowStateReceipt;
+    handoff_from?: string;
+    handoff_to?: string;
+    handoff_at?: string;
 }
 export interface SkillActiveState {
     version?: number;
@@ -59,6 +64,10 @@ export interface SyncSkillActiveStateOptions {
     nowIso?: string;
     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;
@@ -67,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,6 @@
 import type { AgentTool } from "@gajae-code/agent-core";
-export declare const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE = "Deep-interview is active; either continue interviewing with `ask`, or write/finalize the pending spec under `.gjc/specs/` / update state under `.gjc/state/`. Do not edit product code 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;
     customWireName?: unknown;
@@ -10,18 +11,22 @@ export interface DeepInterviewMutationGuardInput {
     threadId?: string;
     tool: ToolWithEditMode;
     args: unknown;
+    forceOverride?: boolean;
+    enforceWorkflowState?: boolean;
 }
 export interface DeepInterviewMutationDecision {
     blocked: boolean;
     message?: string;
     targets: string[];
     reason?: string;
+    command?: string;
 }
 export declare function assertDeepInterviewMutationRawPathsAllowed(input: {
     cwd: string;
     sessionId?: string;
     threadId?: string;
     rawPaths: string[];
+    forceOverride?: boolean;
 }): Promise<void>;
 export declare function getDeepInterviewMutationDecision(input: DeepInterviewMutationGuardInput): Promise<DeepInterviewMutationDecision>;
 export declare function assertDeepInterviewMutationAllowed(input: DeepInterviewMutationGuardInput): Promise<void>;

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/skill-state/workflow-hud.d.ts

@@ -1,5 +1,10 @@
 import type { WorkflowHudSummary } from "./active-state";
-interface DeepInterviewHudState {
+interface WorkflowGateHudState {
+    approvalStatus?: string;
+    blockedReason?: string;
+    nextAction?: string;
+}
+interface DeepInterviewHudState extends WorkflowGateHudState {
     phase?: string;
     ambiguity?: number;
     threshold?: number;
@@ -9,7 +14,7 @@ interface DeepInterviewHudState {
     specStatus?: string;
     updatedAt?: string;
 }
-interface RalplanHudState {
+interface RalplanHudState extends WorkflowGateHudState {
     stage?: string;
     waiting?: string;
     iteration?: number;
@@ -23,7 +28,7 @@ interface UltragoalLikeGoal {
     title: string;
     status: string;
 }
-interface UltragoalHudState {
+interface UltragoalHudState extends WorkflowGateHudState {
     status: string;
     currentGoal?: UltragoalLikeGoal;
     counts: Record<string, number>;
@@ -39,7 +44,7 @@ interface TeamHudWorker {
     id: string;
     status?: string;
 }
-interface TeamHudState {
+interface TeamHudState extends WorkflowGateHudState {
     phase: string;
     task_total: number;
     task_counts: Record<string, number>;

package/dist/types/skill-state/workflow-state-contract.d.ts

@@ -0,0 +1,34 @@
+import { type CanonicalGjcWorkflowSkill } from "./active-state";
+export type { CanonicalGjcWorkflowSkill };
+export declare const WORKFLOW_STATE_RECEIPT_VERSION = 1;
+export declare const WORKFLOW_STATE_RECEIPT_FRESH_MS: number;
+export type WorkflowStateMutationOwner = "gjc-state-cli" | "gjc-runtime" | "gjc-hook";
+export type WorkflowStateReceiptStatus = "fresh" | "stale";
+export interface WorkflowStateReceipt {
+    version: 1;
+    skill: CanonicalGjcWorkflowSkill;
+    owner: WorkflowStateMutationOwner;
+    command: string;
+    state_path: string;
+    storage_path: string;
+    mutated_at: string;
+    fresh_until: string;
+    status: WorkflowStateReceiptStatus;
+    mutation_id: string;
+}
+export declare function workflowModeStateFileName(skill: CanonicalGjcWorkflowSkill): string;
+export declare function workflowStateStoragePath(cwd: string, skill: CanonicalGjcWorkflowSkill, sessionId?: string): string;
+export declare function workflowActiveStatePath(cwd: string, sessionId?: string): string;
+export declare function buildWorkflowStateReceipt(input: {
+    cwd: string;
+    skill: CanonicalGjcWorkflowSkill;
+    owner: WorkflowStateMutationOwner;
+    command: string;
+    sessionId?: string;
+    nowIso?: string;
+    mutationId?: string;
+}): WorkflowStateReceipt;
+export declare function workflowReceiptStatus(receipt: WorkflowStateReceipt | undefined, nowMs?: number): WorkflowStateReceiptStatus | undefined;
+export declare function canonicalWorkflowSkill(value: string): CanonicalGjcWorkflowSkill | null;
+export declare function sanctionedWorkflowStateCommand(skill: CanonicalGjcWorkflowSkill): string;
+export declare function describeWorkflowStateContract(skill: CanonicalGjcWorkflowSkill): 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.1",
+	"version": "0.2.3",
 	"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.1",
-		"@gajae-code/agent-core": "0.2.1",
-		"@gajae-code/ai": "0.2.1",
-		"@gajae-code/natives": "0.2.1",
-		"@gajae-code/tui": "0.2.1",
-		"@gajae-code/utils": "0.2.1",
+		"@gajae-code/stats": "0.2.3",
+		"@gajae-code/agent-core": "0.2.3",
+		"@gajae-code/ai": "0.2.3",
+		"@gajae-code/natives": "0.2.3",
+		"@gajae-code/tui": "0.2.3",
+		"@gajae-code/utils": "0.2.3",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/cli/args.ts

@@ -245,9 +245,10 @@ export function getExtraHelpText(): string {
   GJC_SLOW_MODEL              - Override slow/reasoning model (see --slow)
   GJC_PLAN_MODEL              - Override planning model (see --plan)
   GJC_NO_PTY                  - Disable PTY-based interactive bash execution
-  --tmux                       - Launch interactive startup inside tmux
+  --tmux                       - Launch interactive startup inside a new tmux session
+  gjc session                  - List, inspect, create, remove, or attach tagged GJC-managed tmux sessions
   GJC_LAUNCH_POLICY           - Launch policy for --tmux startup: tmux or direct
-  GJC_TMUX_SESSION            - tmux session name for default interactive startup (default: gajae_code)
+  GJC_TMUX_SESSION            - Explicit tmux session name override for --tmux startup
 
   For complete environment variable reference, see:
   ${chalk.dim("docs/environment-variables.md")}