@gajae-code/coding-agent 0.2.2 → 0.2.4

package/src/defaults/gjc-defaults.ts

@@ -1,5 +1,9 @@
 import * as path from "node:path";
 import { getAgentDir, isEnoent, parseFrontmatter } from "@gajae-code/utils";
+import autoAnswerUncertainFragment from "./gjc/skills/deep-interview/auto-answer-uncertain.md" with { type: "text" };
+import autoResearchGreenfieldFragment from "./gjc/skills/deep-interview/auto-research-greenfield.md" with {
+	type: "text",
+};
 import deepInterviewSkill from "./gjc/skills/deep-interview/SKILL.md" with { type: "text" };
 import ralplanSkill from "./gjc/skills/ralplan/SKILL.md" with { type: "text" };
 import teamSkill from "./gjc/skills/team/SKILL.md" with { type: "text" };
@@ -7,7 +11,7 @@ import ultragoalSkill from "./gjc/skills/ultragoal/SKILL.md" with { type: "text"
 
 export const DEFAULT_GJC_DEFINITION_NAMES = ["deep-interview", "ralplan", "team", "ultragoal"] as const;
 export type DefaultGjcDefinitionName = (typeof DEFAULT_GJC_DEFINITION_NAMES)[number];
-export type DefaultGjcDefinitionKind = "skill";
+export type DefaultGjcDefinitionKind = "skill" | "skill-fragment";
 export type EmbeddedDefaultGjcSkill = {
 	name: DefaultGjcDefinitionName;
 	description: string;
@@ -19,25 +23,41 @@ export type EmbeddedDefaultGjcSkill = {
 };
 export type DefaultGjcInstallStatus = "different" | "matching" | "missing" | "skipped" | "written";
 
-export interface DefaultGjcDefinition {
-	kind: DefaultGjcDefinitionKind;
+export interface DefaultGjcSkillDefinition {
+	kind: "skill";
 	name: DefaultGjcDefinitionName;
 	relativePath: string;
 	content: string;
 }
 
+export interface DefaultGjcSkillFragmentDefinition {
+	kind: "skill-fragment";
+	parentSkillName: DefaultGjcDefinitionName;
+	relativePath: string;
+	content: string;
+}
+
+export type DefaultGjcDefinition = DefaultGjcSkillDefinition | DefaultGjcSkillFragmentDefinition;
+
 export interface InstallDefaultGjcDefinitionsOptions {
 	check?: boolean;
 	force?: boolean;
 	targetRoot?: string;
 }
 
-export interface DefaultGjcDefinitionInstallFile {
-	kind: DefaultGjcDefinitionKind;
-	name: DefaultGjcDefinitionName;
-	path: string;
-	status: DefaultGjcInstallStatus;
-}
+export type DefaultGjcDefinitionInstallFile =
+	| {
+			kind: "skill";
+			name: DefaultGjcDefinitionName;
+			path: string;
+			status: DefaultGjcInstallStatus;
+	  }
+	| {
+			kind: "skill-fragment";
+			parentSkillName: DefaultGjcDefinitionName;
+			path: string;
+			status: DefaultGjcInstallStatus;
+	  };
 
 export interface DefaultGjcDefinitionInstallResult {
 	targetRoot: string;
@@ -60,6 +80,18 @@ const DEFAULT_GJC_DEFINITIONS: readonly DefaultGjcDefinition[] = [
 	{ kind: "skill", name: "ralplan", relativePath: "skills/ralplan/SKILL.md", content: ralplanSkill },
 	{ kind: "skill", name: "team", relativePath: "skills/team/SKILL.md", content: teamSkill },
 	{ kind: "skill", name: "ultragoal", relativePath: "skills/ultragoal/SKILL.md", content: ultragoalSkill },
+	{
+		kind: "skill-fragment",
+		parentSkillName: "deep-interview",
+		relativePath: "skill-fragments/deep-interview/auto-research-greenfield.md",
+		content: autoResearchGreenfieldFragment,
+	},
+	{
+		kind: "skill-fragment",
+		parentSkillName: "deep-interview",
+		relativePath: "skill-fragments/deep-interview/auto-answer-uncertain.md",
+		content: autoAnswerUncertainFragment,
+	},
 ];
 
 export function getDefaultGjcDefinitions(): readonly DefaultGjcDefinition[] {
@@ -70,8 +102,19 @@ export function getDefaultGjcAgentDefinitions(): readonly DefaultGjcDefinition[]
 	return [];
 }
 
+export function getEmbeddedDefaultGjcSkillFragments(
+	parentSkillName: DefaultGjcDefinitionName,
+): DefaultGjcSkillFragmentDefinition[] {
+	return DEFAULT_GJC_DEFINITIONS.filter(
+		(definition): definition is DefaultGjcSkillFragmentDefinition =>
+			definition.kind === "skill-fragment" && definition.parentSkillName === parentSkillName,
+	);
+}
+
 export function getEmbeddedDefaultGjcSkills(): EmbeddedDefaultGjcSkill[] {
-	return DEFAULT_GJC_DEFINITIONS.filter(definition => definition.kind === "skill").map(definition => {
+	return DEFAULT_GJC_DEFINITIONS.filter(
+		(definition): definition is DefaultGjcSkillDefinition => definition.kind === "skill",
+	).map(definition => {
 		const { frontmatter } = parseFrontmatter(definition.content, {
 			source: `embedded:gjc/${definition.relativePath}`,
 			level: "warn",
@@ -110,12 +153,21 @@ export async function installDefaultGjcDefinitions(
 			status = "written";
 		}
 
-		files.push({
-			kind: definition.kind,
-			name: definition.name,
-			path: destination,
-			status,
-		});
+		if (definition.kind === "skill") {
+			files.push({
+				kind: definition.kind,
+				name: definition.name,
+				path: destination,
+				status,
+			});
+		} else {
+			files.push({
+				kind: definition.kind,
+				parentSkillName: definition.parentSkillName,
+				path: destination,
+				status,
+			});
+		}
 	}
 
 	return summarizeInstallResult(targetRoot, files);

package/src/discovery/helpers.ts

@@ -8,6 +8,7 @@ import {
 	getConfigDirName,
 	getPluginsDir,
 	getProjectDir,
+	logger,
 	parseFrontmatter,
 	tryParseJson,
 } from "@gajae-code/utils";
@@ -16,6 +17,7 @@ import { invalidate as invalidateFsCache, readDirEntries, readFile } from "../ca
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import type { ForkContextPolicy } from "../task/types";
 import { parseThinkingLevel } from "../thinking";
 
 import { buildPluginDirRoot } from "./plugin-dir-roots";
@@ -214,6 +216,7 @@ export interface ParsedAgentFields {
 	autoloadSkills?: string[];
 	blocking?: boolean;
 	hide?: boolean;
+	forkContext?: ForkContextPolicy;
 }
 
 /**
@@ -267,10 +270,30 @@ export function parseAgentFields(frontmatter: Record<string, unknown>): ParsedAg
 	const model = parseModelList(frontmatter.model);
 	const blocking = parseBoolean(frontmatter.blocking);
 	const hide = parseBoolean(frontmatter.hide);
+	const forkContext = parseForkContextPolicy(frontmatter.forkContext);
 	const autoloadSkills = parseArrayOrCSV(frontmatter.autoloadSkills)
 		?.map(s => s.trim())
 		.filter(Boolean);
-	return { name, description, tools, spawns, model, output, thinkingLevel, blocking, autoloadSkills, hide };
+	return {
+		name,
+		description,
+		tools,
+		spawns,
+		model,
+		output,
+		thinkingLevel,
+		blocking,
+		autoloadSkills,
+		hide,
+		forkContext,
+	};
+}
+
+function parseForkContextPolicy(value: unknown): ForkContextPolicy | undefined {
+	if (value === undefined) return undefined;
+	if (value === "forbidden" || value === "allowed") return value;
+	logger.warn("Invalid agent forkContext frontmatter; expected 'allowed' or 'forbidden', ignoring", { value });
+	return undefined;
 }
 
 async function globIf(

package/src/extensibility/extensions/types.ts

@@ -110,6 +110,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. */

package/src/gjc-runtime/deep-interview-runtime.ts

@@ -1,8 +1,11 @@
+import { createHash, randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { syncSkillActiveState } from "../skill-state/active-state";
 import { buildDeepInterviewHudSummary } from "../skill-state/workflow-hud";
+import { runNativeRalplanCommand } from "./ralplan-runtime";
+import { runNativeStateCommand } from "./state-runtime";
 
 /**
  * Native implementation of `gjc deep-interview`.
@@ -42,7 +45,15 @@ class DeepInterviewCommandError extends Error {
 	}
 }
 
-const VALUE_FLAGS = new Set(["--session-id", "--threshold", "--threshold-source"]);
+const VALUE_FLAGS = new Set([
+	"--session-id",
+	"--threshold",
+	"--threshold-source",
+	"--stage",
+	"--slug",
+	"--spec",
+	"--handoff",
+]);
 
 function flagValue(args: readonly string[], flag: string): string | undefined {
 	const index = args.indexOf(flag);
@@ -64,15 +75,108 @@ function encodeSessionSegment(value: string): string {
 	return encodeURIComponent(value).replaceAll(".", "%2E");
 }
 
+function defaultSpecSlug(now: Date = new Date()): string {
+	const yyyy = now.getUTCFullYear().toString().padStart(4, "0");
+	const mm = (now.getUTCMonth() + 1).toString().padStart(2, "0");
+	const dd = now.getUTCDate().toString().padStart(2, "0");
+	const hh = now.getUTCHours().toString().padStart(2, "0");
+	const min = now.getUTCMinutes().toString().padStart(2, "0");
+	return `${yyyy}-${mm}-${dd}-${hh}${min}-${randomBytes(2).toString("hex")}`;
+}
+
+function stateDirFor(cwd: string, sessionId: string | undefined): string {
+	return sessionId
+		? path.join(cwd, ".gjc", "state", "sessions", encodeSessionSegment(sessionId))
+		: path.join(cwd, ".gjc", "state");
+}
+
+function deepInterviewStatePath(cwd: string, sessionId: string | undefined): string {
+	return path.join(stateDirFor(cwd, sessionId), "deep-interview-state.json");
+}
+
+async function readJsonObject(filePath: string): Promise<Record<string, unknown>> {
+	try {
+		const parsed = JSON.parse(await fs.readFile(filePath, "utf-8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed as Record<string, unknown>;
+	} catch {
+		// Missing/corrupt state should not prevent the sanctioned persistence CLI from writing a receipt.
+	}
+	return {};
+}
+
+async function writeJsonAtomic(filePath: string, value: unknown): Promise<void> {
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	const tmp = `${filePath}.tmp-${randomBytes(6).toString("hex")}`;
+	await fs.writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`);
+	await fs.rename(tmp, filePath);
+}
+
+async function resolveSpecContent(rawSpec: string, cwd: string): Promise<string> {
+	const candidate = path.isAbsolute(rawSpec) ? rawSpec : path.resolve(cwd, rawSpec);
+	try {
+		const stat = await fs.stat(candidate);
+		if (stat.isFile()) return await fs.readFile(candidate, "utf-8");
+	} catch (error) {
+		const err = error as NodeJS.ErrnoException;
+		if (err.code !== "ENOENT" && err.code !== "ENOTDIR") {
+			throw new DeepInterviewCommandError(2, `failed to read --spec ${candidate}: ${err.message}`);
+		}
+	}
+	return rawSpec;
+}
+
 interface ResolvedDeepInterviewArgs {
 	resolution: DeepInterviewResolution;
 	threshold: number;
 	thresholdSource: string;
 	sessionId?: string;
 	idea: string;
+	language?: DeepInterviewLanguagePreference;
 	json: boolean;
 }
 
+interface DeepInterviewLanguagePreference {
+	code: "en" | "ko";
+	label: "English" | "Korean";
+	source: "explicit-user-request" | "initial-idea";
+	instruction: 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;
+}
+
+interface DeepInterviewSpecWriteSummary {
+	skill: "deep-interview";
+	stage: "final";
+	slug: string;
+	path: string;
+	sha256: string;
+	created_at: string;
+	state_path: string;
+	handoff?: {
+		to: "ralplan";
+		mode: "deliberate";
+		state_path?: string;
+		run_id?: string;
+	};
+}
+
 async function readSettingsAmbiguityThreshold(
 	settingsPath: string,
 ): Promise<{ threshold: number; source: string } | undefined> {
@@ -109,6 +213,97 @@ async function resolveConfiguredAmbiguityThreshold(
 	return await readSettingsAmbiguityThreshold(userSettings);
 }
 
+function englishLanguagePreference(): DeepInterviewLanguagePreference {
+	return {
+		code: "en",
+		label: "English",
+		source: "explicit-user-request",
+		instruction:
+			"Ask every user-facing deep-interview question in English because the user explicitly requested English.",
+	};
+}
+
+function resolveDeepInterviewLanguagePreference(idea: string): DeepInterviewLanguagePreference | undefined {
+	if (/\b(?:answer|ask|respond|reply|write|use|speak)\s+(?:only\s+)?in\s+English\b/i.test(idea)) {
+		return englishLanguagePreference();
+	}
+	if (/(?:영어로|영문으로|영어\s*(?:질문|답변|응답)|English\s+only)/i.test(idea)) {
+		return englishLanguagePreference();
+	}
+	if (/\p{Script=Hangul}/u.test(idea)) {
+		return {
+			code: "ko",
+			label: "Korean",
+			source: "initial-idea",
+			instruction:
+				"Ask every user-facing deep-interview question in Korean unless the user explicitly requests another language.",
+		};
+	}
+	return undefined;
+}
+
+function isDeepInterviewSpecWriteInvocation(args: readonly string[]): boolean {
+	return hasFlag(args, "--write");
+}
+
+async function resolveSpecWriteArgs(args: readonly string[], cwd: string): Promise<ResolvedDeepInterviewSpecWriteArgs> {
+	const stage = flagValue(args, "--stage")?.trim() || "final";
+	if (stage !== "final") {
+		throw new DeepInterviewCommandError(2, 'unknown --stage for deep-interview --write: expected "final"');
+	}
+
+	const slug = flagValue(args, "--slug")?.trim() || defaultSpecSlug();
+	assertSafePathComponent(slug, "slug");
+
+	const rawSpec = flagValue(args, "--spec");
+	if (rawSpec === undefined || rawSpec === "") {
+		throw new DeepInterviewCommandError(2, "--spec is required for deep-interview --write");
+	}
+
+	const sessionId = flagValue(args, "--session-id")?.trim() || undefined;
+	if (sessionId) assertSafePathComponent(sessionId, "session-id");
+
+	const rawHandoff = flagValue(args, "--handoff")?.trim() || undefined;
+	if (rawHandoff && rawHandoff !== "ralplan") {
+		throw new DeepInterviewCommandError(2, 'unknown --handoff target: expected "ralplan"');
+	}
+
+	const allowedFlags = new Set([
+		"--write",
+		"--stage",
+		"--slug",
+		"--spec",
+		"--session-id",
+		"--handoff",
+		"--deliberate",
+		"--json",
+	]);
+	let skipNext = false;
+	for (const arg of args) {
+		if (skipNext) {
+			skipNext = false;
+			continue;
+		}
+		if (["--stage", "--slug", "--spec", "--session-id", "--handoff"].includes(arg)) {
+			skipNext = true;
+			continue;
+		}
+		if (arg.startsWith("-") && !allowedFlags.has(arg)) {
+			throw new DeepInterviewCommandError(2, `unknown flag for gjc deep-interview --write: ${arg}`);
+		}
+	}
+
+	return {
+		stage: "final",
+		slug,
+		spec: await resolveSpecContent(rawSpec, cwd),
+		sessionId,
+		json: hasFlag(args, "--json"),
+		deliberate: hasFlag(args, "--deliberate"),
+		handoff: rawHandoff as "ralplan" | undefined,
+	};
+}
+
 async function resolveDeepInterviewArgs(args: readonly string[], cwd: string): Promise<ResolvedDeepInterviewArgs> {
 	const sessionId = flagValue(args, "--session-id")?.trim() || undefined;
 	if (sessionId) assertSafePathComponent(sessionId, "session-id");
@@ -169,10 +364,62 @@ async function resolveDeepInterviewArgs(args: readonly string[], cwd: string): P
 		thresholdSource,
 		sessionId,
 		idea,
+		language: resolveDeepInterviewLanguagePreference(idea),
 		json: hasFlag(args, "--json"),
 	};
 }
 
+export async function persistDeepInterviewSpec(
+	cwd: string,
+	resolved: ResolvedDeepInterviewSpecWriteArgs,
+): Promise<PersistedDeepInterviewSpec> {
+	const specsDir = path.join(cwd, ".gjc", "specs");
+	await fs.mkdir(specsDir, { recursive: true });
+	const specPath = path.join(specsDir, `deep-interview-${resolved.slug}.md`);
+	const content = resolved.spec.endsWith("\n") ? resolved.spec : `${resolved.spec}\n`;
+	await fs.writeFile(specPath, content);
+
+	const sha256 = createHash("sha256").update(content).digest("hex");
+	const createdAt = new Date().toISOString();
+	await fs.appendFile(
+		path.join(specsDir, "deep-interview-index.jsonl"),
+		`${JSON.stringify({ slug: resolved.slug, stage: resolved.stage, path: specPath, created_at: createdAt, sha256 })}\n`,
+	);
+
+	const statePath = deepInterviewStatePath(cwd, resolved.sessionId);
+	const existing = await readJsonObject(statePath);
+	const payload: Record<string, unknown> = {
+		...existing,
+		active: true,
+		current_phase: "handoff",
+		skill: "deep-interview",
+		version: typeof existing.version === "number" ? existing.version : 1,
+		spec_slug: resolved.slug,
+		spec_path: specPath,
+		spec_sha256: sha256,
+		spec_stage: resolved.stage,
+		spec_persisted_at: createdAt,
+		updated_at: createdAt,
+	};
+	if (resolved.sessionId) payload.session_id = resolved.sessionId;
+	await writeJsonAtomic(statePath, payload);
+	await syncDeepInterviewHud({
+		cwd,
+		sessionId: resolved.sessionId,
+		phase: "handoff",
+		specStatus: "persisted",
+	});
+
+	return {
+		slug: resolved.slug,
+		path: specPath,
+		stage: resolved.stage,
+		sha256,
+		createdAt,
+		statePath,
+	};
+}
+
 async function seedDeepInterviewState(cwd: string, resolved: ResolvedDeepInterviewArgs): Promise<string> {
 	const stateDir = resolved.sessionId
 		? path.join(cwd, ".gjc", "state", "sessions", encodeSessionSegment(resolved.sessionId))
@@ -196,6 +443,10 @@ async function seedDeepInterviewState(cwd: string, resolved: ResolvedDeepIntervi
 		},
 		updated_at: now,
 	};
+	if (resolved.language) {
+		payload.language = resolved.language;
+		(payload.state as Record<string, unknown>).language = resolved.language;
+	}
 	if (resolved.sessionId) payload.session_id = resolved.sessionId;
 	await fs.writeFile(statePath, `${JSON.stringify(payload, null, 2)}\n`);
 	return statePath;
@@ -232,11 +483,70 @@ async function syncDeepInterviewHud(options: {
 	}
 }
 
+async function handleSpecWrite(args: readonly string[], cwd: string): Promise<DeepInterviewCommandResult> {
+	const resolved = await resolveSpecWriteArgs(args, cwd);
+	const persisted = await persistDeepInterviewSpec(cwd, resolved);
+	const shouldHandoff = resolved.deliberate || resolved.handoff === "ralplan";
+	const summary: DeepInterviewSpecWriteSummary = {
+		skill: "deep-interview",
+		stage: persisted.stage,
+		slug: persisted.slug,
+		path: persisted.path,
+		sha256: persisted.sha256,
+		created_at: persisted.createdAt,
+		state_path: persisted.statePath,
+	};
+
+	if (shouldHandoff) {
+		const ralplanArgs = ["--deliberate", "--json"];
+		if (resolved.sessionId) ralplanArgs.push("--session-id", resolved.sessionId);
+		ralplanArgs.push(persisted.path);
+		const ralplanResult = await runNativeRalplanCommand(ralplanArgs, cwd);
+		if (ralplanResult.status !== 0) {
+			throw new DeepInterviewCommandError(
+				ralplanResult.status,
+				ralplanResult.stderr?.trim() || "failed to seed ralplan",
+			);
+		}
+
+		const handoffArgs = ["handoff", "--mode", "deep-interview", "--to", "ralplan", "--json"];
+		if (resolved.sessionId) handoffArgs.push("--session-id", resolved.sessionId);
+		else handoffArgs.push("--session-id", "");
+		const handoffResult = await runNativeStateCommand(handoffArgs, cwd);
+		if (handoffResult.status !== 0) {
+			throw new DeepInterviewCommandError(
+				handoffResult.status,
+				handoffResult.stderr?.trim() || "failed to hand off deep-interview to ralplan",
+			);
+		}
+
+		const ralplanPayload = ralplanResult.stdout ? (JSON.parse(ralplanResult.stdout) as Record<string, unknown>) : {};
+		summary.handoff = {
+			to: "ralplan",
+			mode: "deliberate",
+			state_path: typeof ralplanPayload.state_path === "string" ? ralplanPayload.state_path : undefined,
+			run_id: typeof ralplanPayload.run_id === "string" ? ralplanPayload.run_id : undefined,
+		};
+	}
+
+	const stdout = resolved.json
+		? `${JSON.stringify(summary, null, 2)}\n`
+		: [
+				`Persisted deep-interview ${persisted.stage} spec at ${persisted.path}.`,
+				shouldHandoff ? "Handed off deep-interview to ralplan (deliberate)." : undefined,
+				"",
+			]
+				.filter((line): line is string => Boolean(line))
+				.join("\n");
+	return { status: 0, stdout };
+}
+
 export async function runNativeDeepInterviewCommand(
 	args: string[],
 	cwd = process.cwd(),
 ): Promise<DeepInterviewCommandResult> {
 	try {
+		if (isDeepInterviewSpecWriteInvocation(args)) return await handleSpecWrite(args, cwd);
 		const resolved = await resolveDeepInterviewArgs(args, cwd);
 		if (!resolved.idea) {
 			throw new DeepInterviewCommandError(
@@ -260,6 +570,7 @@ export async function runNativeDeepInterviewCommand(
 			threshold: resolved.threshold,
 			threshold_source: resolved.thresholdSource,
 			idea: resolved.idea,
+			language: resolved.language,
 			state_path: statePath,
 			handoff: "Run `/skill:deep-interview` inside the GJC agent to drive the Socratic interview loop.",
 		};