@gajae-code/coding-agent 0.7.8 → 0.7.9

package/src/modes/shared/agent-wire/deep-interview-gate.ts

@@ -11,7 +11,7 @@
  * the interactive select/editor UI) when an unattended controller + gate broker
  * are attached is wired with the transport in #321 and exercised by #323.
  */
-import type { RpcJsonSchema } from "../../rpc/rpc-types";
+import type { RpcJsonSchema, RpcWorkflowGateKind, RpcWorkflowStage } from "../../rpc/rpc-types";
 import type { OpenGateInput } from "./workflow-gate-broker";
 
 /** "Other (type your own)" sentinel, mirroring the interactive ask tool. */
@@ -26,6 +26,11 @@ export interface AskGateDeepInterviewState {
 	ambiguity: number;
 }
 
+export interface AskGateWorkflowGateMeta {
+	stage: RpcWorkflowStage;
+	kind: RpcWorkflowGateKind;
+}
+
 export interface AskGateQuestion {
 	id: string;
 	question: string;
@@ -37,6 +42,8 @@ export interface AskGateQuestion {
 	 * `stage_state`; when absent, the question text is regex-parsed as a fallback.
 	 */
 	deepInterview?: AskGateDeepInterviewState;
+	/** Override the emitted workflow gate address for non-deep-interview ask prompts. */
+	workflowGate?: AskGateWorkflowGateMeta;
 }
 
 export interface AskGateResult {
@@ -157,13 +164,13 @@ function structuredDeepInterviewState(meta: AskGateDeepInterviewState): Record<s
 	return state;
 }
 
-/** Build the `workflow_gate` open-input for one deep-interview question. */
+/** Build the `workflow_gate` open-input for one ask question. */
 export function questionToGate(question: AskGateQuestion): OpenGateInput {
 	const labels = question.options.map(o => o.label);
 	const schema = questionAnswerSchema(question, labels);
 	return {
-		stage: "deep-interview",
-		kind: "question",
+		stage: question.workflowGate?.stage ?? "deep-interview",
+		kind: question.workflowGate?.kind ?? "question",
 		schema,
 		options: question.options.map((o, i) => ({
 			value: o.label,

package/src/modes/types.ts

@@ -290,7 +290,12 @@ export interface InteractiveModeContext {
 		dialogOptions?: ExtensionUIDialogOptions,
 	): Promise<string | undefined>;
 	hideHookSelector(): void;
-	showHookInput(title: string, placeholder?: string): Promise<string | undefined>;
+	showHookInput(
+		title: string,
+		placeholder?: string,
+		dialogOptions?: ExtensionUIDialogOptions,
+		inputOptions?: { readonly initialValue?: string },
+	): Promise<string | undefined>;
 	hideHookInput(): void;
 	showHookEditor(
 		title: string,

package/src/notifications/daemon-paths.ts

@@ -0,0 +1,22 @@
+import * as path from "node:path";
+
+export interface DaemonPaths {
+	dir: string;
+	lock: string;
+	state: string;
+	roots: string;
+	steal: string;
+	aliases: string;
+}
+
+export function daemonPaths(agentDir: string): DaemonPaths {
+	const dir = path.join(agentDir, "notifications");
+	return {
+		dir,
+		lock: path.join(dir, "telegram-daemon.lock"),
+		state: path.join(dir, "telegram-daemon.state.json"),
+		roots: path.join(dir, "telegram-daemon.roots.json"),
+		steal: path.join(dir, "telegram-daemon.steal"),
+		aliases: path.join(dir, "telegram-callback-aliases.json"),
+	};
+}

package/src/notifications/telegram-daemon-cli.ts

@@ -3,12 +3,19 @@ import * as path from "node:path";
 import { YAML } from "bun";
 import type { Settings } from "../config/settings";
 import { getNotificationConfig, isGloballyConfigured } from "./config";
-import { daemonPaths, TelegramNotificationDaemon } from "./telegram-daemon";
-import { clearTelegramControlRequest, readTelegramControlRequest } from "./telegram-daemon-control";
+import { daemonPaths } from "./daemon-paths";
+import type { TelegramDaemonOptions } from "./telegram-daemon";
+
+type TelegramDaemonRunner = {
+	run(): Promise<void>;
+	requestStop(reason?: "reload" | "signal" | "stop"): void;
+};
+
+type TelegramDaemonConstructor = new (opts: TelegramDaemonOptions) => TelegramDaemonRunner;
 
 export interface RunDaemonInternalDeps {
 	SettingsImpl?: { init: (options?: { agentDir?: string }) => Promise<Pick<Settings, "get" | "getAgentDir">> };
-	DaemonImpl?: typeof TelegramNotificationDaemon;
+	DaemonImpl?: TelegramDaemonConstructor;
 	processPid?: number;
 	pidAlive?: (pid: number) => boolean;
 }
@@ -140,7 +147,9 @@ export async function runDaemonInternal(argv: string[], deps: RunDaemonInternalD
 	const settings = await resolveDaemonSettings(resolvedAgentDir, deps);
 	const cfg = getNotificationConfig(settings as Settings);
 	if (!isGloballyConfigured(cfg) || !cfg.botToken || !cfg.chatId) return;
-	const Daemon = deps.DaemonImpl ?? TelegramNotificationDaemon;
+	const { clearTelegramControlRequest, readTelegramControlRequest } = await import("./telegram-daemon-control");
+	const Daemon: TelegramDaemonConstructor =
+		deps.DaemonImpl ?? (await import("./telegram-daemon")).TelegramNotificationDaemon;
 	const daemon = new Daemon({
 		settings: settings as Settings,
 		ownerId,

package/src/notifications/telegram-daemon.ts

@@ -10,6 +10,7 @@ import type { DaemonRuntimeInfo } from "../daemon/control-types";
 import { resolveGjcRuntimeSpawnInfo } from "../daemon/runtime";
 import { getNotificationConfig, isGloballyConfigured, tokenFingerprint } from "./config";
 import { parseInThreadConfigCommand } from "./config-commands";
+import { daemonPaths } from "./daemon-paths";
 import { buildCompactChoiceGrid, TELEGRAM_PARSE_MODE } from "./html-format";
 import type {
 	SessionCloseTarget,
@@ -62,16 +63,6 @@ export interface DaemonState {
 	version: 1;
 	stoppedAt?: number;
 }
-
-export interface DaemonPaths {
-	dir: string;
-	lock: string;
-	state: string;
-	roots: string;
-	steal: string;
-	aliases: string;
-}
-
 export interface TelegramDaemonFs {
 	mkdir(path: string, opts?: fs.MakeDirectoryOptions): Promise<void>;
 	readFile(path: string, encoding: BufferEncoding): Promise<string>;
@@ -184,17 +175,7 @@ async function fetchWithRetry(
 	throw lastErr;
 }
 
-export function daemonPaths(agentDir: string): DaemonPaths {
-	const dir = path.join(agentDir, "notifications");
-	return {
-		dir,
-		lock: path.join(dir, "telegram-daemon.lock"),
-		state: path.join(dir, "telegram-daemon.state.json"),
-		roots: path.join(dir, "telegram-daemon.roots.json"),
-		steal: path.join(dir, "telegram-daemon.steal"),
-		aliases: path.join(dir, "telegram-callback-aliases.json"),
-	};
-}
+export { type DaemonPaths, daemonPaths } from "./daemon-paths";
 
 /**
  * Attach session-lifecycle control (create/close/resume) to the running daemon.

package/src/prompts/system/system-prompt.md

@@ -82,6 +82,11 @@ Use for read-only plan critique. It approves only when execution can proceed wit
 - Do not load or inject user-home Anthropic model or provider instructions (`~/.anthropic-model`, `~/.openai-code`) into the model context.
 - Public commands, paths, examples, and workflow names must use `gjc` and `.gjc`.
 </runtime-state>
+<self-awareness>
+- When the user asks about GJC usage, how to use a GJC feature/command/workflow, or about the gajae-code system itself, do not answer from memory alone. First clone the canonical source repository into `/tmp` (e.g. `git clone --depth 1 https://github.com/Yeachan-Heo/gajae-code /tmp/gajae-code-<unique>`), then read and analyze the actual source there to ground your answer.
+- Reuse an existing fresh clone under `/tmp` instead of re-cloning when one is already present in the session.
+- Base usage and system answers on what the cloned source actually says; cite concrete files/paths from the clone rather than guessing.
+</self-awareness>
 </gjc-runtime>
 
 <communication>

package/src/sdk.ts

@@ -2007,7 +2007,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			.map(name => toolRegistry.get(name))
 			.filter((tool): tool is AgentTool => tool !== undefined)
 			// AgentSession tool wrapping is not installed until after Agent construction.
-			.map(tool => guardToolForUltragoalAsk(tool, () => sessionManager.getCwd()));
+			.map(tool =>
+				guardToolForUltragoalAsk(
+					tool,
+					() => sessionManager.getCwd(),
+					() => ({
+						activeSkillState: session?.getActiveSkillState(),
+						sessionId: sessionManager.getSessionId?.() ?? null,
+					}),
+				),
+			);
 
 		const openaiWebsocketSetting = settings.get("providers.openaiWebsockets") ?? "off";
 		const preferOpenAICodexWebsockets =

package/src/session/agent-session.ts

@@ -3920,7 +3920,16 @@ export class AgentSession {
 
 	#prepareToolForExecution<T extends AgentTool>(tool: T): T {
 		return this.#wrapToolForDeepInterviewMutationGuard(
-			this.#wrapToolForAcpPermission(guardToolForUltragoalAsk(tool, () => this.sessionManager.getCwd())),
+			this.#wrapToolForAcpPermission(
+				guardToolForUltragoalAsk(
+					tool,
+					() => this.sessionManager.getCwd(),
+					() => ({
+						activeSkillState: this.getActiveSkillState(),
+						sessionId: this.sessionManager.getSessionId(),
+					}),
+				),
+			),
 		);
 	}
 

package/src/tools/ask.ts

@@ -62,6 +62,11 @@ const DeepInterviewMeta = z.object({
 	ambiguity: z.number().min(0).max(1).describe("ambiguity at ask time (0..1)"),
 });
 
+const WorkflowGateMeta = z.object({
+	stage: z.enum(["deep-interview", "ralplan", "ultragoal"]).describe("workflow gate stage"),
+	kind: z.enum(["question", "approval", "execution"]).describe("workflow gate kind"),
+});
+
 const QuestionItem = z.object({
 	id: z.string().describe("question id"),
 	question: z.string().describe("question text"),
@@ -69,6 +74,7 @@ const QuestionItem = z.object({
 	multi: z.boolean().describe("allow multiple selections").optional(),
 	recommended: z.number().describe("recommended option index").optional(),
 	deepInterview: DeepInterviewMeta.describe("optional deep-interview round metadata").optional(),
+	workflowGate: WorkflowGateMeta.describe("optional workflow gate stage/kind override").optional(),
 });
 
 export const askSchema = z.object({
@@ -551,7 +557,10 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 		_onUpdate?: AgentToolUpdateCallback<AskToolDetails>,
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<AskToolDetails>> {
-		await assertUltragoalAskAllowed(this.session.cwd);
+		await assertUltragoalAskAllowed(this.session.cwd, {
+			activeSkillState: this.session.getActiveSkillState?.(),
+			sessionId: this.session.getSessionId?.() ?? null,
+		});
 		const gateEmitter = this.session.getWorkflowGateEmitter?.();
 		const canUseWorkflowGate = gateEmitter?.isUnattended() === true;
 
@@ -665,6 +674,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					multi: q.multi,
 					recommended: q.recommended,
 					deepInterview: q.deepInterview,
+					workflowGate: q.workflowGate,
 				};
 				const answer = await gateEmitter.emitGate(questionToGate(gateQuestion));
 				const decoded = gateAnswerToResult(gateQuestion, answer);

package/src/tools/eval.ts

@@ -754,8 +754,8 @@ function formatStatusEventExpanded(event: EvalStatusEvent, theme: Theme): string
 		case "git_log":
 			if (data.entries) {
 				addItems(data.entries as unknown[], e => {
-					const entry = e as { sha: string; subject: string };
-					return `${entry.sha} ${truncateToWidth(entry.subject, 50)}`;
+					const entry = e as { sha?: string; subject?: string };
+					return `${String(entry.sha ?? "")} ${truncateToWidth(String(entry.subject ?? ""), 50)}`;
 				});
 			}
 			break;

package/src/tools/render-utils.ts

@@ -86,6 +86,7 @@ export const EXPAND_HINT = "(Ctrl+O for more)";
  * Get first N lines of text as preview, with each line truncated.
  */
 export function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis?: Ellipsis): string[] {
+	if (typeof text !== "string") return [];
 	const lines = text.split("\n").filter(l => l.trim());
 	return lines.slice(0, maxLines).map(l => truncateToWidth(l.trim(), maxLineLen, ellipsis));
 }
@@ -568,6 +569,7 @@ export function truncateDiffByHunk(
 // =============================================================================
 
 export function shortenPath(filePath: string, homeDir?: string): string {
+	if (typeof filePath !== "string") return "";
 	const home = homeDir ?? os.homedir();
 	if (home && filePath.startsWith(home)) {
 		return `~${filePath.slice(home.length)}`;

package/src/tools/ultragoal-ask-guard.ts

@@ -10,6 +10,29 @@ const ULTRAGOAL_ASK_GUARD = Symbol.for("gajae-code.ultragoalAskGuard");
 
 type GuardedTool = AgentTool & { [ULTRAGOAL_ASK_GUARD]?: true };
 
+export interface UltragoalAskGuardContext {
+	activeSkillState?: { skill?: string; session_id?: string } | null;
+	sessionId?: string | null;
+}
+
+const UPSTREAM_PLANNING_ASK_SKILLS = new Set(["deep-interview", "ralplan"]);
+
+function normalizedActiveSkill(context?: UltragoalAskGuardContext): string | undefined {
+	const skill = context?.activeSkillState?.skill?.trim();
+	return skill || undefined;
+}
+
+function sessionScopedAskGuardId(
+	context: UltragoalAskGuardContext,
+	activeSkill: string | undefined,
+): string | undefined {
+	if (activeSkill !== "ultragoal" && !UPSTREAM_PLANNING_ASK_SKILLS.has(activeSkill ?? "")) return undefined;
+	const activeSessionId = context.activeSkillState?.session_id?.trim();
+	if (activeSessionId) return activeSessionId;
+	const sessionId = context.sessionId?.trim();
+	return sessionId || undefined;
+}
+
 export function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiagnostic): string {
 	return [
 		diagnostic.message,
@@ -18,15 +41,26 @@ export function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiag
 	].join("\n");
 }
 
-export async function assertUltragoalAskAllowed(cwd: string): Promise<void> {
-	const diagnostic = await isUltragoalAskBlocked(cwd);
+export async function assertUltragoalAskAllowed(cwd: string, context: UltragoalAskGuardContext = {}): Promise<void> {
+	const activeSkill = normalizedActiveSkill(context);
+	// Deep-interview and ralplan are upstream planning workflows whose core gates
+	// are `ask` calls. Scope their Ultragoal check to the current session so stale
+	// or ambiguous Ultragoal durable state from another session cannot hijack those
+	// prompts; same-session active Ultragoal state still falls through to the
+	// blocker/nudge checks below.
+	const sessionId = sessionScopedAskGuardId(context, activeSkill);
+	const diagnostic = await isUltragoalAskBlocked(cwd, { sessionId });
 	if (!diagnostic.active) return;
-	const nudge = await consumeUltragoalAskNudge(cwd);
+	const nudge = await consumeUltragoalAskNudge(cwd, sessionId);
 	if (nudge.nudged) throw new ToolError(nudge.message);
 	throw new ToolError(formatUltragoalAskBlockMessage(diagnostic));
 }
 
-export function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: () => string): T {
+export function guardToolForUltragoalAsk<T extends AgentTool>(
+	tool: T,
+	getCwd: () => string,
+	getContext: () => UltragoalAskGuardContext = () => ({}),
+): T {
 	if (tool.name !== "ask") return tool;
 	const candidate = tool as GuardedTool;
 	if (candidate[ULTRAGOAL_ASK_GUARD]) return tool;
@@ -35,7 +69,7 @@ export function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: (
 			if (prop === ULTRAGOAL_ASK_GUARD) return true;
 			if (prop !== "execute") return Reflect.get(target, prop, receiver);
 			return async (...args: unknown[]): Promise<unknown> => {
-				await assertUltragoalAskAllowed(getCwd());
+				await assertUltragoalAskAllowed(getCwd(), getContext());
 				return Reflect.apply(target.execute, target, args);
 			};
 		},