@gajae-code/coding-agent 0.2.1 → 0.2.3

package/src/tools/gh.ts

@@ -225,6 +225,10 @@ const RUN_SUCCESS_CONCLUSIONS = new Set(["success", "neutral", "skipped"]);
 const RUN_FAILURE_CONCLUSIONS = new Set(["failure", "timed_out", "cancelled", "action_required", "startup_failure"]);
 const JOB_FAILURE_CONCLUSIONS = new Set(["failure", "timed_out", "cancelled", "action_required"]);
 
+const PR_CREATE_BASE_CONFIG_KEYS = ["github.prBase", "gh.prBase", "gjc.github.prBase"] as const;
+const ISSUE_CLOSING_REFERENCE_PATTERN =
+	/(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+(?:https:\/\/github\.com\/([^\s/]+\/[^\s/]+)\/issues\/)?#(\d+)\b/gi;
+
 const githubSchema = z
 	.object({
 		op: z
@@ -407,6 +411,23 @@ interface GhIssueViewData {
 	updatedAt?: string;
 	url?: string;
 }
+interface GhPrListData {
+	baseRefName?: string;
+	headRefName?: string;
+	isDraft?: boolean;
+	number?: number;
+	state?: string;
+	title?: string;
+	url?: string;
+}
+
+interface PrCreateDuplicateCheck {
+	base: string;
+	head: string;
+	issue?: GhIssueViewData;
+	linkedPr?: GhPrListData;
+	pr?: GhPrListData;
+}
 
 interface GhPrFile {
 	path?: string;
@@ -659,6 +680,185 @@ function resolveSearchLimit(value: number | undefined): number {
 
 	return Math.min(Math.floor(value), SEARCH_LIMIT_MAX);
 }
+async function resolvePrCreateBase(
+	cwd: string,
+	explicitBase: string | undefined,
+	repo: string | undefined,
+	signal?: AbortSignal,
+): Promise<string | undefined> {
+	if (explicitBase) return explicitBase;
+	try {
+		for (const key of PR_CREATE_BASE_CONFIG_KEYS) {
+			const configured = normalizeOptionalString(await git.config.get(cwd, key, signal));
+			if (configured) return configured;
+		}
+	} catch {
+		// Repository config is optional for pr_create; prefer GitHub metadata when
+		// local git metadata is unavailable.
+	}
+	try {
+		const resolvedRepo = repo ?? (await resolveDefaultRepoMemoized(cwd, signal));
+		const repoView = await git.github.json<GhRepoViewData>(
+			cwd,
+			["repo", "view", resolvedRepo, "--json", "defaultBranchRef"],
+			signal,
+			{ repoProvided: true },
+		);
+		const defaultBranch = normalizeOptionalString(repoView.defaultBranchRef?.name);
+		if (defaultBranch) return defaultBranch;
+	} catch {
+		// Fall back to local git metadata below so pr_create can still work when gh
+		// cannot resolve repository metadata in otherwise-valid checkouts.
+	}
+	return (await git.branch.default(cwd, signal)) ?? undefined;
+}
+
+function normalizePrHead(value: string): string {
+	const separator = value.lastIndexOf(":");
+	return separator >= 0 ? value.slice(separator + 1) : value;
+}
+
+function extractClosingIssueReferences(body: string | undefined, repo: string | undefined): number[] {
+	if (!body) return [];
+	const issueNumbers: number[] = [];
+	ISSUE_CLOSING_REFERENCE_PATTERN.lastIndex = 0;
+	let match = ISSUE_CLOSING_REFERENCE_PATTERN.exec(body);
+	while (match !== null) {
+		const issueRepo = normalizeOptionalString(match[1]);
+		if (!issueRepo || !repo || issueRepo.toLowerCase() === repo.toLowerCase()) {
+			const issueNumber = Number(match[2]);
+			if (Number.isInteger(issueNumber) && issueNumber > 0) issueNumbers.push(issueNumber);
+		}
+		match = ISSUE_CLOSING_REFERENCE_PATTERN.exec(body);
+	}
+	return issueNumbers;
+}
+
+async function resolvePrCreateHead(
+	cwd: string,
+	explicitHead: string | undefined,
+	signal?: AbortSignal,
+): Promise<string | undefined> {
+	if (explicitHead) return explicitHead;
+	try {
+		return (await git.branch.current(cwd, signal)) ?? undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+async function fetchPrCreateDuplicateCheck(
+	cwd: string,
+	repo: string | undefined,
+	base: string | undefined,
+	head: string | undefined,
+	body: string | undefined,
+	signal: AbortSignal | undefined,
+): Promise<PrCreateDuplicateCheck | undefined> {
+	if (!base || !head) return undefined;
+	const resolvedRepo = repo ?? (await resolveDefaultRepoMemoized(cwd, signal));
+	const normalizedHead = normalizePrHead(head);
+	const prs = await git.github.json<GhPrListData[]>(
+		cwd,
+		[
+			"pr",
+			"list",
+			"--repo",
+			resolvedRepo,
+			"--head",
+			normalizedHead,
+			"--base",
+			base,
+			"--state",
+			"all",
+			"--json",
+			"number,title,state,url,baseRefName,headRefName,isDraft",
+		],
+		signal,
+		{ repoProvided: true },
+	);
+	const existingPr = prs.find(pr => pr.headRefName === normalizedHead && pr.baseRefName === base) ?? prs[0];
+	const issueNumbers = existingPr ? [] : extractClosingIssueReferences(body, resolvedRepo);
+	let issue: GhIssueViewData | undefined;
+	let linkedPr: GhPrListData | undefined;
+	for (const issueNumber of issueNumbers) {
+		const candidateIssue = await git.github.json<GhIssueViewData>(
+			cwd,
+			[
+				"issue",
+				"view",
+				String(issueNumber),
+				"--repo",
+				resolvedRepo,
+				"--json",
+				GH_ISSUE_FIELDS_NO_COMMENTS.join(","),
+			],
+			signal,
+			{ repoProvided: true },
+		);
+		issue = candidateIssue;
+		if (candidateIssue.state && candidateIssue.state.toUpperCase() !== "OPEN") break;
+		const linkedPrs = await git.github.json<GhPrListData[]>(
+			cwd,
+			[
+				"pr",
+				"list",
+				"--repo",
+				resolvedRepo,
+				"--search",
+				`${issueNumber} linked:issue`,
+				"--state",
+				"open",
+				"--json",
+				"number,title,state,url,baseRefName,headRefName,isDraft",
+			],
+			signal,
+			{ repoProvided: true },
+		);
+		linkedPr = linkedPrs.find(pr => pr.headRefName !== normalizedHead) ?? linkedPrs[0];
+		if (linkedPr) break;
+	}
+	return { base, head: normalizedHead, issue, linkedPr, pr: existingPr };
+}
+
+function formatPrCreateExistingResult(check: PrCreateDuplicateCheck): string | undefined {
+	if (check.issue?.state && check.issue.state.toUpperCase() !== "OPEN") {
+		const lines = [
+			"# Pull Request Not Created",
+			"",
+			`Issue #${check.issue.number ?? ""} is ${check.issue.state.toLowerCase()}.`,
+		];
+		pushLine(lines, "Issue", check.issue.url);
+		if (check.pr) pushLine(lines, "Existing PR", check.pr.url);
+		pushLine(lines, "Base", check.base);
+		pushLine(lines, "Head", check.head);
+		return lines.join("\n").trim();
+	}
+	if (check.linkedPr) {
+		const number = check.linkedPr.number !== undefined ? ` #${check.linkedPr.number}` : "";
+		const title = check.linkedPr.title ? `: ${check.linkedPr.title}` : "";
+		const lines = [`# Pull Request Already Linked${number}${title}`, ""];
+		pushLine(lines, "URL", check.linkedPr.url);
+		pushLine(lines, "Issue", check.issue?.url);
+		pushLine(lines, "State", check.linkedPr.state);
+		pushLine(lines, "Draft", check.linkedPr.isDraft);
+		pushLine(lines, "Base", check.linkedPr.baseRefName ?? check.base);
+		pushLine(lines, "Head", check.linkedPr.headRefName ?? check.head);
+		return lines.join("\n").trim();
+	}
+	if (check.pr) {
+		const number = check.pr.number !== undefined ? ` #${check.pr.number}` : "";
+		const title = check.pr.title ? `: ${check.pr.title}` : "";
+		const lines = [`# Pull Request Already Exists${number}${title}`, ""];
+		pushLine(lines, "URL", check.pr.url);
+		pushLine(lines, "State", check.pr.state);
+		pushLine(lines, "Draft", check.pr.isDraft);
+		pushLine(lines, "Base", check.pr.baseRefName ?? check.base);
+		pushLine(lines, "Head", check.pr.headRefName ?? check.head);
+		return lines.join("\n").trim();
+	}
+	return undefined;
+}
 
 function resolveTailLimit(value: number | undefined): number {
 	if (value === undefined) {
@@ -3117,8 +3317,8 @@ async function executePrCreate(
 	const repo = normalizeOptionalString(params.repo);
 	const title = normalizeOptionalString(params.title);
 	const body = params.body;
-	const base = normalizeOptionalString(params.base);
-	const head = normalizeOptionalString(params.head);
+	const requestedBase = normalizeOptionalString(params.base);
+	const requestedHead = normalizeOptionalString(params.head);
 	const draft = params.draft ?? false;
 	const fill = params.fill ?? false;
 	const reviewers = normalizePrIdentifierList(params.reviewer);
@@ -3131,6 +3331,16 @@ async function executePrCreate(
 	if (fill && (title || body !== undefined)) {
 		throw new ToolError("fill is mutually exclusive with title and body");
 	}
+	const base = await resolvePrCreateBase(session.cwd, requestedBase, repo, signal);
+	const head = await resolvePrCreateHead(session.cwd, requestedHead, signal);
+	const duplicateCheck = await fetchPrCreateDuplicateCheck(session.cwd, repo, base, head, body, signal);
+	const existingText = duplicateCheck ? formatPrCreateExistingResult(duplicateCheck) : undefined;
+	if (existingText) {
+		return buildTextResult(
+			existingText,
+			duplicateCheck?.pr?.url ?? duplicateCheck?.linkedPr?.url ?? duplicateCheck?.issue?.url,
+		);
+	}
 
 	const args = ["pr", "create"];
 	appendRepoFlag(args, repo);

package/src/tools/index.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 { $env, $flag, logger } from "@gajae-code/utils";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
@@ -7,15 +7,17 @@ import { EditTool } from "../edit";
 import { checkPythonKernelAvailability } from "../eval/py/kernel";
 import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
-import { CreateGoalTool, GetGoalTool, GoalTool, UpdateGoalTool } from "../goals/tools/goal-tool";
+import { GoalTool } from "../goals/tools/goal-tool";
 import type { HindsightSessionState } from "../hindsight/state";
 import { LspTool } from "../lsp";
 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 { TaskTool } from "../task";
 import type { AgentOutputManager } from "../task/output-manager";
 import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
@@ -47,6 +49,7 @@ import { ResolveTool } from "./resolve";
 import { reportFindingTool } from "./review";
 import { SearchTool } from "./search";
 import { SearchToolBm25Tool } from "./search-tool-bm25";
+import { SkillTool } from "./skill";
 import { loadSshTool } from "./ssh";
 import { SubagentTool } from "./subagent";
 import { type TodoPhase, TodoWriteTool } from "./todo-write";
@@ -84,6 +87,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";
@@ -122,6 +126,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 */
@@ -164,6 +174,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) */
@@ -246,9 +258,17 @@ export interface ToolSession {
 
 	/** 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>;
@@ -308,13 +328,11 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	retain: HindsightRetainTool.createIf,
 	recall: HindsightRecallTool.createIf,
 	reflect: HindsightReflectTool.createIf,
+	skill: SkillTool.createIf,
 	goal: s => new GoalTool(s),
-	get_goal: GetGoalTool.createIf,
-	create_goal: CreateGoalTool.createIf,
-	update_goal: UpdateGoalTool.createIf,
 };
 
-const GOAL_MODE_TOOL_NAMES = ["get_goal", "create_goal", "update_goal"] as const;
+const GOAL_MODE_TOOL_NAMES = [] as const;
 
 export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
 	yield: s => new YieldTool(s),
@@ -467,6 +485,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		// search_tool_bm25 is allowed when either legacy mcp.discoveryMode or new tools.discoveryMode is active.
 		if (name === "search_tool_bm25") return discoveryActive;
 		if (name === "calc") return session.settings.get("calc.enabled");
+		if (name === "skill") return session.settings.get("skill.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
 		if (name === "irc") {

package/src/tools/skill.ts

@@ -0,0 +1,153 @@
+/**
+ * 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 { prompt, untilAborted } from "@gajae-code/utils";
+import * as z from "zod/v4";
+import { buildSkillPromptMessage } from "../extensibility/skills";
+import { runNativeStateCommand } from "../gjc-runtime/state-runtime";
+import skillDescription from "../prompts/tools/skill.md" with { type: "text" };
+import { SKILL_PROMPT_MESSAGE_TYPE } from "../session/messages";
+import type { ToolSession } from ".";
+import { ToolError } from "./tool-errors";
+
+const TERMINAL_PHASES = new Set(["complete", "completed", "handoff", "failed", "cancelled", "canceled", "inactive"]);
+
+const skillSchema = z.object({
+	name: z.string().describe("skill name as it appears in /skill:<name>"),
+	args: z.string().describe("argument string passed to the skill").optional(),
+});
+
+function normalizeSkillName(name: string | undefined): string {
+	return (name ?? "").trim();
+}
+
+type SkillToolInput = z.infer<typeof skillSchema>;
+
+export interface SkillToolDetails {
+	name: string;
+	path: string;
+	args?: string;
+	lineCount: number;
+}
+
+export class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails> {
+	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 = skillSchema;
+	readonly strict = true;
+
+	readonly #session: ToolSession;
+
+	constructor(session: ToolSession) {
+		this.#session = session;
+		this.description = prompt.render(skillDescription);
+	}
+
+	static createIf(session: ToolSession): SkillTool | null {
+		// The tool can only chain when the session can deliver the same-turn
+		// custom message. Without `sendCustomMessage` (e.g. minimal tool
+		// harnesses in tests) there is nothing useful to do.
+		if (!session.sendCustomMessage) return null;
+		const skills = session.skills ?? [];
+		if (skills.length === 0) return null;
+		return new SkillTool(session);
+	}
+
+	async execute(
+		_toolCallId: string,
+		input: SkillToolInput,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<SkillToolDetails>> {
+		return untilAborted(signal, async () => {
+			const sendCustomMessage = this.#session.sendCustomMessage;
+			if (!sendCustomMessage) {
+				throw new ToolError("skill tool: session has no custom-message bridge");
+			}
+			const skills = this.#session.skills ?? [];
+			const requestedName = normalizeSkillName(input.name);
+			if (!requestedName) {
+				throw new ToolError("skill tool: `name` is required");
+			}
+			const activeState = this.#session.getActiveSkillState?.();
+			const activeSkill = normalizeSkillName(activeState?.skill);
+			if (activeSkill && requestedName === activeSkill) {
+				throw new ToolError(
+					`skill tool: refusing to chain into currently active skill "${requestedName}". Follow the active skill instructions instead of invoking it recursively.`,
+				);
+			}
+
+			const skill = skills.find(s => s.name === requestedName);
+			if (!skill) {
+				const available = skills.map(s => s.name).sort();
+				const hint = available.length > 0 ? ` Available: ${available.join(", ")}` : "";
+				throw new ToolError(`skill tool: unknown skill "${requestedName}".${hint}`);
+			}
+
+			// Phase guard + atomic handoff. Only runs when transitioning between
+			// distinct skills (same-skill recursion was already refused above).
+			if (activeSkill) {
+				const phase = (this.#session.getActiveSkillPhase?.() ?? "running").trim().toLowerCase();
+				if (!TERMINAL_PHASES.has(phase)) {
+					throw new ToolError(
+						`skill tool: refusing to chain from "${activeSkill}" (phase=${phase}) into "${requestedName}". Finalize the current skill (gjc state ${activeSkill} write --input '{"current_phase":"handoff"}' --json) or run gjc state ${activeSkill} handoff --to ${requestedName} --json directly before chaining.`,
+					);
+				}
+				const cwd = this.#session.cwd;
+				const sessionId = activeState?.session_id?.trim();
+				const handoffArgs = ["handoff", "--mode", activeSkill, "--to", requestedName, "--json"];
+				if (sessionId) {
+					handoffArgs.push("--session-id", sessionId);
+				}
+				const handoff = await runNativeStateCommand(handoffArgs, cwd);
+				if (handoff.status !== 0) {
+					throw new ToolError(
+						`skill tool: handoff failed (status=${handoff.status}): ${(handoff.stderr ?? "").trim() || "no detail"}`,
+					);
+				}
+			}
+
+			const args = (input.args ?? "").trim();
+			const built = await buildSkillPromptMessage(skill, args);
+
+			await sendCustomMessage(
+				{
+					customType: SKILL_PROMPT_MESSAGE_TYPE,
+					content: built.message,
+					display: true,
+					details: built.details,
+					attribution: "user",
+				},
+				{ triggerTurn: false },
+			);
+
+			const summary = args ? `Handed off to /skill:${skill.name} ${args}.` : `Handed off to /skill:${skill.name}.`;
+			return {
+				content: [{ type: "text", text: summary }],
+				details: {
+					name: skill.name,
+					path: skill.filePath,
+					args: args || undefined,
+					lineCount: built.details.lineCount,
+				},
+			};
+		});
+	}
+}

package/src/utils/changelog.ts

@@ -1,4 +1,5 @@
 import { isEnoent, logger } from "@gajae-code/utils";
+import CHANGELOG_TEXT from "../../CHANGELOG.md" with { type: "text" };
 
 export interface ChangelogEntry {
 	major: number;
@@ -8,58 +9,67 @@ export interface ChangelogEntry {
 }
 
 /**
- * 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 async function parseChangelog(changelogPath: string): Promise<ChangelogEntry[]> {
-	try {
-		const content = await Bun.file(changelogPath).text();
-		const lines = content.split("\n");
-		const entries: ChangelogEntry[] = [];
+export function parseChangelogContent(content: string): ChangelogEntry[] {
+	const lines = content.split("\n");
+	const entries: ChangelogEntry[] = [];
 
-		let currentLines: string[] = [];
-		let currentVersion: { major: number; minor: number; patch: number } | null = null;
+	let currentLines: string[] = [];
+	let currentVersion: { major: number; minor: number; patch: number } | null = null;
 
-		for (const line of lines) {
-			// Check if this is a version header (## [x.y.z] ...)
-			if (line.startsWith("## ")) {
-				// Save previous entry if exists
-				if (currentVersion && currentLines.length > 0) {
-					entries.push({
-						...currentVersion,
-						content: currentLines.join("\n").trim(),
-					});
-				}
+	for (const line of lines) {
+		// Check if this is a version header (## [x.y.z] ...)
+		if (line.startsWith("## ")) {
+			// Save previous entry if exists
+			if (currentVersion && currentLines.length > 0) {
+				entries.push({
+					...currentVersion,
+					content: currentLines.join("\n").trim(),
+				});
+			}
 
-				// Try to parse version from this line
-				const versionMatch = line.match(/##\s+\[?(\d+)\.(\d+)\.(\d+)\]?/);
-				if (versionMatch) {
-					currentVersion = {
-						major: Number.parseInt(versionMatch[1], 10),
-						minor: Number.parseInt(versionMatch[2], 10),
-						patch: Number.parseInt(versionMatch[3], 10),
-					};
-					currentLines = [line];
-				} else {
-					// Reset if we can't parse version
-					currentVersion = null;
-					currentLines = [];
-				}
-			} else if (currentVersion) {
-				// Collect lines for current version
-				currentLines.push(line);
+			// Try to parse version from this line
+			const versionMatch = line.match(/##\s+\[?(\d+)\.(\d+)\.(\d+)\]?/);
+			if (versionMatch) {
+				currentVersion = {
+					major: Number.parseInt(versionMatch[1], 10),
+					minor: Number.parseInt(versionMatch[2], 10),
+					patch: Number.parseInt(versionMatch[3], 10),
+				};
+				currentLines = [line];
+			} else {
+				// Reset if we can't parse version
+				currentVersion = null;
+				currentLines = [];
 			}
+		} else if (currentVersion) {
+			// Collect lines for current version
+			currentLines.push(line);
 		}
+	}
 
-		// Save last entry
-		if (currentVersion && currentLines.length > 0) {
-			entries.push({
-				...currentVersion,
-				content: currentLines.join("\n").trim(),
-			});
-		}
+	// Save last entry
+	if (currentVersion && currentLines.length > 0) {
+		entries.push({
+			...currentVersion,
+			content: currentLines.join("\n").trim(),
+		});
+	}
+
+	return entries;
+}
 
-		return entries;
+/**
+ * Parse changelog entries from a CHANGELOG.md file on disk.
+ * Returns [] on ENOENT; logs and returns [] on other read/parse errors.
+ */
+export async function parseChangelog(changelogPath: string): Promise<ChangelogEntry[]> {
+	try {
+		const content = await Bun.file(changelogPath).text();
+		return parseChangelogContent(content);
 	} catch (error) {
 		if (isEnoent(error)) {
 			return [];
@@ -69,6 +79,19 @@ export async function parseChangelog(changelogPath: string): Promise<ChangelogEn
 	}
 }
 
+/**
+ * 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 function getDisplayChangelogEntries(): ChangelogEntry[] {
+	return parseChangelogContent(CHANGELOG_TEXT);
+}
+
 /**
  * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
  */

package/dist/types/commands/gjc-runtime-bridge.d.ts

@@ -1,30 +0,0 @@
-import { type WorkflowHudSummary } from "../skill-state/active-state";
-export declare const WORKFLOW_HUD_PROTOCOL = "workflow-hud-summary-v1";
-export interface GjcRuntimeBridgeResult {
-    status: number;
-    error?: string;
-}
-export interface WorkflowHudBridgePayload {
-    version: 1;
-    skill: string;
-    phase?: string;
-    active?: boolean;
-    session_id?: string;
-    thread_id?: string;
-    turn_id?: string;
-    hud: WorkflowHudSummary;
-}
-export interface GjcRuntimeHudBridgeResult extends GjcRuntimeBridgeResult {
-    hudPayload?: WorkflowHudBridgePayload;
-}
-export interface GjcRuntimeHudBridgeOptions {
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    sidecarSkill: string;
-    onHudPayload?: (payload: WorkflowHudBridgePayload) => Promise<void> | void;
-    pollIntervalMs?: number;
-}
-export declare function normalizeWorkflowHudBridgePayload(raw: unknown, expectedSkill: string): WorkflowHudBridgePayload | null;
-export declare function runGjcRuntimeBridge(endpoint: string, args: string[], env?: NodeJS.ProcessEnv): GjcRuntimeBridgeResult;
-export declare function runGjcRuntimeBridgeWithHudSidecar(endpoint: string, args: string[], options: GjcRuntimeHudBridgeOptions): Promise<GjcRuntimeHudBridgeResult>;
-export declare function runBridgedRuntimeEndpoint(endpoint: string, args: string[]): Promise<void>;

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

@@ -1,7 +0,0 @@
-import { Command } from "@gajae-code/utils/cli";
-export default class Question extends Command {
-    static description: string;
-    static strict: boolean;
-    static examples: string[];
-    run(): Promise<void>;
-}