@gajae-code/coding-agent 0.5.3 → 0.5.4

package/src/skill-state/active-state.ts

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import {
 	type ActiveSessionScope,
+	readActiveEntries,
 	rebuildActiveSnapshot,
 	removeActiveEntry,
 	writeActiveEntry,
@@ -416,6 +417,62 @@ function rawActiveEntries(state: SkillActiveState | null): SkillActiveEntry[] {
 	return out;
 }
 
+async function readModeStatePhase(
+	cwd: string,
+	sessionId: string | undefined,
+	skill: CanonicalGjcWorkflowSkill,
+): Promise<string | undefined> {
+	const stateDir = path.join(cwd, ".gjc", "state");
+	const normalizedSessionId = safeString(sessionId).trim();
+	const filePath = normalizedSessionId
+		? path.join(stateDir, "sessions", encodePathSegment(normalizedSessionId), `${skill}-state.json`)
+		: path.join(stateDir, `${skill}-state.json`);
+	try {
+		const parsed = JSON.parse(await Bun.file(filePath).text());
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+		const record = parsed as Record<string, unknown>;
+		const phase = safeString(record.current_phase).trim();
+		if (!phase) return undefined;
+		if (record.active === false && !RALPLAN_CANONICAL_PHASE_OVERRIDES.has(phase)) return undefined;
+		return phase;
+	} catch {
+		return undefined;
+	}
+}
+
+const RALPLAN_CANONICAL_PHASE_OVERRIDES = new Set([
+	"final",
+	"handoff",
+	"complete",
+	"completed",
+	"failed",
+	"cancelled",
+	"canceled",
+	"inactive",
+]);
+
+function withCanonicalRalplanPhase(entry: SkillActiveEntry, canonicalPhase: string | undefined): SkillActiveEntry {
+	if (
+		entry.skill !== "ralplan" ||
+		!canonicalPhase ||
+		!RALPLAN_CANONICAL_PHASE_OVERRIDES.has(canonicalPhase) ||
+		entry.phase === canonicalPhase
+	) {
+		return entry;
+	}
+	const hud = entry.hud
+		? {
+				...entry.hud,
+				chips: entry.hud.chips?.map(chip => (chip.label === "stage" ? { ...chip, value: canonicalPhase } : chip)),
+			}
+		: undefined;
+	return {
+		...entry,
+		phase: canonicalPhase,
+		...(hud ? { hud } : {}),
+	};
+}
+
 function filterRootEntriesForSession(entries: SkillActiveEntry[], sessionId?: string): SkillActiveEntry[] {
 	const normalizedSessionId = safeString(sessionId).trim();
 	if (!normalizedSessionId) return entries;
@@ -538,19 +595,32 @@ export function collapsePlanningPipeline(entries: readonly SkillActiveEntry[]):
 	return entries.filter(entry => !PLANNING_PIPELINE_SKILLS.has(entry.skill) || entry === current);
 }
 
-function mergeVisibleEntries(
+async function mergeVisibleEntries(
+	cwd: string,
 	sessionState: SkillActiveState | null,
 	rootState: SkillActiveState | null,
 	sessionId?: string,
-): SkillActiveEntry[] {
+): Promise<SkillActiveEntry[]> {
 	// Use the raw (active + inactive) rows so a handoff demotion stays visible
 	// long enough to supersede a stale same-skill row before the active filter.
-	const rootEntries = filterRootEntriesForSession(rawActiveEntries(rootState), sessionId);
+	// Per-skill files in active/<skill>.json are authoritative and are merged
+	// after the derived snapshot cache, so a stale skill-active-state.json row
+	// cannot override the latest entry file.
+	const rootEntries = filterRootEntriesForSession(
+		[...rawActiveEntries(rootState), ...(await readActiveEntries(cwd))],
+		sessionId,
+	);
 	const merged = new Map(rootEntries.map(entry => [entryKey(entry), entry]));
-	for (const entry of rawActiveEntries(sessionState)) {
+	const sessionEntries = sessionId
+		? [...rawActiveEntries(sessionState), ...(await readActiveEntries(cwd, { sessionId }))]
+		: rawActiveEntries(sessionState);
+	for (const entry of sessionEntries) {
 		merged.set(entryKey(entry), entry);
 	}
-	return dedupeVisibleBySkill([...merged.values()], sessionId).filter(entry => entry.active !== false);
+	const canonicalRalplanPhase = await readModeStatePhase(cwd, sessionId, "ralplan");
+	return dedupeVisibleBySkill([...merged.values()], sessionId)
+		.filter(entry => entry.active !== false)
+		.map(entry => withCanonicalRalplanPhase(entry, canonicalRalplanPhase));
 }
 
 export async function readVisibleSkillActiveState(cwd: string, sessionId?: string): Promise<SkillActiveState | null> {
@@ -559,7 +629,7 @@ export async function readVisibleSkillActiveState(cwd: string, sessionId?: strin
 		readRawActiveStateForHandoff(rootPath, false),
 		sessionPath ? readRawActiveStateForHandoff(sessionPath, false) : Promise.resolve(null),
 	]);
-	const activeSkills = mergeVisibleEntries(sessionState, rootState, sessionId);
+	const activeSkills = await mergeVisibleEntries(cwd, sessionState, rootState, sessionId);
 	if (activeSkills.length === 0) return null;
 	const primary = activeSkills[0];
 	return {
@@ -622,7 +692,9 @@ async function activeSubskillsForExistingEntry(
 		readRawActiveStateForHandoff(rootPath, false),
 		sessionPath ? readRawActiveStateForHandoff(sessionPath, false) : Promise.resolve(null),
 	]);
-	const existing = mergeVisibleEntries(sessionState, rootState, sessionId).find(entry => entry.skill === skill);
+	const existing = (await mergeVisibleEntries(cwd, sessionState, rootState, sessionId)).find(
+		entry => entry.skill === skill,
+	);
 	return existing?.active_subskills;
 }
 

package/src/tools/browser/registry.ts

@@ -26,6 +26,13 @@ export interface BrowserHandle {
 
 const browsers = new Map<string, BrowserHandle>();
 
+/**
+ * Upper bound on the CDP `browser.close()` round-trip during a forced (signal-path)
+ * teardown before we fall back to killing the Chrome process tree. Only applies when
+ * `kill` is set; graceful release still awaits close() unbounded.
+ */
+const HEADLESS_FORCE_CLOSE_GRACE_MS = 1_500;
+
 function browserKey(kind: BrowserKind): string {
 	switch (kind.kind) {
 		case "headless":
@@ -164,13 +171,22 @@ export async function releaseBrowser(handle: BrowserHandle, opts: { kill: boolea
 
 async function disposeBrowserHandle(handle: BrowserHandle, opts: { kill: boolean }): Promise<void> {
 	if (handle.kind.kind === "headless") {
+		// Capture the launched Chrome process before close() so a forced (signal-path)
+		// teardown can SIGTERM/SIGKILL the tree even if the CDP close hangs on a wedged
+		// renderer. Otherwise the headless Chrome reparents to PID 1 (#698).
+		const proc = handle.browser.process();
 		if (handle.browser.connected) {
 			try {
-				await handle.browser.close();
+				const closing = handle.browser.close();
+				// Graceful release waits for close() to finish (it also removes the
+				// puppeteer_dev_chrome_profile-* temp dir). Forced release bounds it so
+				// the kill fallback below still runs within the signal handler's budget.
+				await (opts.kill ? Promise.race([closing, Bun.sleep(HEADLESS_FORCE_CLOSE_GRACE_MS)]) : closing);
 			} catch (err) {
 				logger.debug("Failed to close headless browser", { error: (err as Error).message });
 			}
 		}
+		if (opts.kill && proc?.pid !== undefined) await gracefulKillTreeOnce(proc.pid);
 		return;
 	}
 	if (handle.kind.kind === "connected") {

package/src/tools/cron.ts

@@ -700,13 +700,9 @@ export class CronDeleteTool implements AgentTool<typeof cronDeleteSchema, CronDe
 	): Promise<AgentToolResult<CronDeleteToolDetails>> {
 		const ownerId = this.session.getAgentId?.() ?? undefined;
 		const deleted = deleteRecord(ownerId, params.id);
+		const text = deleted ? `Cancelled ${params.id}` : `No scheduled task '${params.id}' found; nothing to cancel.`;
 		return {
-			content: [
-				{
-					type: "text",
-					text: deleted ? `Cancelled ${params.id}` : `Failed to remove scheduled task '${params.id}'`,
-				},
-			],
+			content: [{ type: "text", text }],
 			details: { id: params.id, deleted },
 		};
 	}

package/src/web/search/providers/codex.ts

@@ -19,8 +19,9 @@ import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const CODEX_RESPONSES_PATH = "/codex/responses";
-const FALLBACK_MODEL = "gpt-5.4";
+const FALLBACK_MODEL = "gpt-5.5";
 const DEFAULT_MODEL_PREFERENCES = [
+	"gpt-5.5",
 	"gpt-5.4",
 	"gpt-5-codex",
 	"gpt-5",
@@ -453,12 +454,12 @@ async function callCodexSearch(
  * Executes a web search using OpenAI code provider's built-in web search tool.
  *
  * Default-model behavior:
- * - If `PI_OPENAI_CODE_WEB_SEARCH_MODEL` is set, use it exactly once and surface any
+ * - If `PI_CODEX_WEB_SEARCH_MODEL` is set, use it exactly once and surface any
  *   upstream error verbatim.
- * - Otherwise prefer ChatGPT-account-safe bundled defaults (GPT-5.4, GPT-5
- *   OpenAI code backend, GPT-5, …) and retry the next candidate only when OpenAI code backend returns the
+ * - Otherwise prefer ChatGPT-account-safe bundled defaults (GPT-5.5, GPT-5.4,
+ *   GPT-5 code backend, …) and retry the next candidate only when OpenAI code backend returns the
  *   known 400 "model is not supported" family. This avoids selecting
- *   `gpt-5-OpenAI code backend-mini` first on ChatGPT accounts, which OpenAI rejects.
+ *   `gpt-5-codex-mini` first on ChatGPT accounts, which OpenAI rejects.
  */
 export async function searchCodex(params: SearchParams): Promise<SearchResponse> {
 	const auth = await findCodexAuth(params.authStorage, params.sessionId, params.signal);