@gajae-code/coding-agent 0.7.1 → 0.7.3

package/src/extensibility/shared-events.ts

@@ -217,6 +217,7 @@ export interface AutoCompactionEndEvent {
 	errorMessage?: string;
 	/** True when compaction was skipped for a benign reason (no model, no candidates, nothing to compact). */
 	skipped?: boolean;
+	continuationSkipReason?: "auto_continue_disabled_non_resumable_tail";
 }
 
 /** Fired when auto-retry starts */

package/src/gjc-runtime/launch-tmux.ts

@@ -93,6 +93,10 @@ function hasCurrentGjcVersion(session: GjcTmuxSessionStatus | undefined): boolea
 	return session?.version === VERSION;
 }
 
+function allowsExistingTmuxAttach(parsed: Args, env: NodeJS.ProcessEnv): boolean {
+	return Boolean(parsed.continue || parsed.resume || explicitTmuxSessionName(env));
+}
+
 function findExistingSessionForLaunch(context: {
 	env: NodeJS.ProcessEnv;
 	project: string;
@@ -352,6 +356,11 @@ function readCurrentBranch(cwd: string): string | null {
 function cleanupCreatedTmuxSession(plan: TmuxLaunchPlan, spawnSync: TmuxSpawnSync, options: TmuxSpawnOptions): void {
 	spawnSync(plan.tmuxCommand, ["kill-session", "-t", `=${plan.sessionName}`], options);
 }
+function isTmuxAttachDisconnectError(result: TmuxSpawnResult): boolean {
+	if (result.signalCode === "SIGHUP") return true;
+	const stderr = result.stderr?.toLowerCase() ?? "";
+	return stderr.includes("eio") || stderr.includes("input/output error");
+}
 
 export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaunchPlan | undefined {
 	const env = context.env ?? process.env;
@@ -377,14 +386,15 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 		tmuxRuntimeSessionPath(cwd, gjcSessionId, buildGjcTmuxSessionSlug(sessionName));
 	const tmuxAvailable = context.tmuxAvailable ?? Bun.which(tmuxCommand) !== null;
 	if (!tmuxAvailable) return undefined;
-	const existingSessionName =
-		"existingBranchSessionName" in context
+	const existingSessionName = allowsExistingTmuxAttach(context.parsed, env)
+		? "existingBranchSessionName" in context
 			? (context.existingBranchSessionName ?? undefined)
 			: findExistingSessionForLaunch({
 					env,
 					project,
 					branch,
-				});
+				})
+		: undefined;
 	const innerCommand = buildInnerCommand(
 		{
 			cwd,
@@ -478,6 +488,10 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 	if (created.exitCode !== 0) return false;
 	const attached = spawnSync(plan.tmuxCommand, ["attach-session", "-t", `=${plan.sessionName}`], options);
 	if (attached.exitCode === 0) return true;
+	if (isTmuxAttachDisconnectError(attached)) {
+		(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach disconnected", attached.stderr));
+		return true;
+	}
 	cleanupCreatedTmuxSession(plan, spawnSync, options);
 	(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach failed", attached.stderr));
 	return true;

package/src/gjc-runtime/ledger-event-renderer.ts

@@ -93,6 +93,7 @@ const RALPLAN_STAGE_CODES: Record<string, string> = {
 	architect: "A",
 	critic: "C",
 	adr: "D",
+	"post-interview": "I",
 	final: "F",
 };
 

package/src/gjc-runtime/ralplan-runtime.ts

@@ -37,7 +37,7 @@ import {
  *
  * 2. **Artifact write**: `gjc ralplan --write --stage <type> --stage_n <N> --artifact
  *    <path-or-string> [--run-id <id>] [--session-id <id>] [--json]` persists Planner / Architect
- *    / Critic / revision / ADR / final markdown under `.gjc/plans/ralplan/<run-id>/`, maintains
+ *    / Critic / revision / post-interview / ADR / final markdown under `.gjc/plans/ralplan/<run-id>/`, maintains
  *    an `index.jsonl` audit log, copies `final` stages to `pending-approval.md`, and advances
  *    the HUD chip to reflect the latest persisted stage.
  */
@@ -48,7 +48,7 @@ export interface RalplanCommandResult {
 	stderr?: string;
 }
 
-const KNOWN_STAGES = ["planner", "architect", "critic", "revision", "adr", "final"] as const;
+const KNOWN_STAGES = ["planner", "architect", "critic", "revision", "post-interview", "adr", "final"] as const;
 type RalplanStage = (typeof KNOWN_STAGES)[number];
 
 const KNOWN_ARCHITECT_KINDS = new Set(["openai-code"]);

package/src/gjc-runtime/tmux-common.ts

@@ -55,7 +55,9 @@ export function buildGjcTmuxUntaggedSessionHint(tmuxCommand: string): string {
 	return (
 		`the active multiplexer "${tmuxCommand}" lists this session but did not return GJC's ${GJC_TMUX_PROFILE_OPTION} ownership tag; ` +
 		"GJC-managed sessions and `gjc team` require a tmux provider that round-trips tmux user options. " +
-		"Alternative multiplexers such as psmux on Windows do not persist user options yet, so the Windows-native psmux path is not fully supported; " +
+		"For psmux on Windows, cwd/start-directory flags such as `-c` do not isolate the server namespace; psmux uses the tmux-compatible global `-L <namespace>` flag for that. " +
+		"GJC_TMUX_COMMAND and GJC_TEAM_TMUX_COMMAND are binary overrides, not shell command lines, so `psmux -L name` is not a supported value. " +
+		"Alternative multiplexers such as psmux on Windows do not reliably persist user options yet, so the Windows-native psmux path is not fully supported; " +
 		"use real tmux for GJC-managed session and team flows."
 	);
 }

package/src/gjc-runtime/ultragoal-guard.ts

@@ -65,15 +65,17 @@ function isKnownUltragoalObjective(currentObjective: string): boolean {
 	);
 }
 
-async function ultragoalReadPaths(cwd: string): Promise<UltragoalPaths> {
+async function ultragoalReadPaths(cwd: string): Promise<{ paths: UltragoalPaths; sessionId: string | null }> {
 	const envSessionId = process.env.GJC_SESSION_ID?.trim();
-	if (envSessionId) return getUltragoalPaths(cwd, envSessionId);
+	if (envSessionId) return { paths: getUltragoalPaths(cwd, envSessionId), sessionId: envSessionId };
 	try {
 		const session = await resolveGjcSessionForRead(cwd, { envSessionId: process.env.GJC_SESSION_ID });
-		return getUltragoalPaths(cwd, session.gjcSessionId);
+		return { paths: getUltragoalPaths(cwd, session.gjcSessionId), sessionId: session.gjcSessionId };
 	} catch (error) {
 		if (error instanceof SessionResolutionError && error.code === "no_session") {
-			return getUltragoalPaths(cwd, null);
+			// No session could be resolved (no env, no auto-detectable active session).
+			// Surface the null session id so callers can decide; ask-guard treats it as inactive.
+			return { paths: getUltragoalPaths(cwd, null), sessionId: null };
 		}
 		throw error;
 	}
@@ -82,7 +84,7 @@ async function ultragoalReadPaths(cwd: string): Promise<UltragoalPaths> {
 async function hasDurableUltragoalState(cwd: string): Promise<boolean> {
 	let paths: UltragoalPaths;
 	try {
-		paths = await ultragoalReadPaths(cwd);
+		({ paths } = await ultragoalReadPaths(cwd));
 	} catch (error) {
 		if (error instanceof SessionResolutionError) return true;
 		throw error;
@@ -368,14 +370,26 @@ export async function readUltragoalVerificationState(input: {
 
 export async function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBlockDiagnostic> {
 	let paths: UltragoalPaths;
+	let sessionId: string | null;
 	try {
-		paths = await ultragoalReadPaths(cwd);
+		({ paths, sessionId } = await ultragoalReadPaths(cwd));
 	} catch (error) {
 		return activeAskDiagnostic({
 			reason: `Unable to resolve durable Ultragoal state: ${error instanceof Error ? error.message : String(error)}`,
 			source: "durable_state_unreadable",
 		});
 	}
+	// Ultragoal state is session-scoped. When no session can be resolved (no env,
+	// no auto-detectable active session) there is no active run to protect, so the
+	// ask guard must fall open rather than block on legacy/global durable state.
+	if (sessionId === null) {
+		return inactiveAskDiagnostic({
+			reason: "No active GJC session resolved; ultragoal is inactive.",
+			source: "absent",
+			goalsPath: paths.goalsPath,
+			ledgerPath: paths.ledgerPath,
+		});
+	}
 	try {
 		await fs.stat(paths.dir);
 	} catch (error) {
@@ -398,8 +412,8 @@ export async function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBl
 	let plan: UltragoalPlan | null;
 	let ledger: UltragoalLedgerEvent[];
 	try {
-		plan = await readUltragoalPlan(cwd);
-		ledger = await readUltragoalLedger(cwd);
+		plan = await readUltragoalPlan(cwd, sessionId);
+		ledger = await readUltragoalLedger(cwd, sessionId);
 	} catch (error) {
 		return activeAskDiagnostic({
 			reason: `Unable to read durable Ultragoal state: ${error instanceof Error ? error.message : String(error)}`,
@@ -409,6 +423,9 @@ export async function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBl
 		});
 	}
 	if (!plan) {
+		// goals.json absent or empty while the state dir exists is an inconsistent
+		// durable state, not a clean "no run". Fail closed so the pause guard (which
+		// relies on this `durable_state_unreadable` signal) keeps blocking give-ups.
 		return activeAskDiagnostic({
 			reason: "Durable .gjc/ultragoal state exists but goals.json is missing or empty.",
 			source: "durable_state_unreadable",

package/src/gjc-runtime/workflow-manifest.generated.json

@@ -369,6 +369,9 @@
       {
         "id": "revision"
       },
+      {
+        "id": "post-interview"
+      },
       {
         "id": "adr"
       },
@@ -401,6 +404,26 @@
         "to": "revision",
         "verb": "write-artifact"
       },
+      {
+        "from": "revision",
+        "to": "post-interview",
+        "verb": "write-artifact"
+      },
+      {
+        "from": "critic",
+        "to": "post-interview",
+        "verb": "write-artifact"
+      },
+      {
+        "from": "post-interview",
+        "to": "revision",
+        "verb": "write-artifact"
+      },
+      {
+        "from": "post-interview",
+        "to": "adr",
+        "verb": "write-artifact"
+      },
       {
         "from": "revision",
         "to": "adr",
@@ -435,6 +458,11 @@
         "from": "adr",
         "to": "handoff",
         "verb": "handoff"
+      },
+      {
+        "from": "post-interview",
+        "to": "handoff",
+        "verb": "handoff"
       }
     ],
     "typedArgs": [
@@ -592,6 +620,7 @@
           "architect",
           "critic",
           "revision",
+          "post-interview",
           "adr",
           "final"
         ],

package/src/gjc-runtime/workflow-manifest.ts

@@ -172,12 +172,16 @@ export const WORKFLOW_MANIFEST: Record<CanonicalGjcWorkflowSkill, SkillManifest>
 	}),
 	ralplan: manifest({
 		skill: "ralplan",
-		states: ["planner", "architect", "critic", "revision", "adr", "final", "handoff"],
+		states: ["planner", "architect", "critic", "revision", "post-interview", "adr", "final", "handoff"],
 		terminalStates: ["final", "handoff"],
 		transitions: [
 			{ from: "planner", to: "architect", verb: "write-artifact" },
 			{ from: "architect", to: "critic", verb: "write-artifact" },
 			{ from: "critic", to: "revision", verb: "write-artifact" },
+			{ from: "revision", to: "post-interview", verb: "write-artifact" },
+			{ from: "critic", to: "post-interview", verb: "write-artifact" },
+			{ from: "post-interview", to: "revision", verb: "write-artifact" },
+			{ from: "post-interview", to: "adr", verb: "write-artifact" },
 			{ from: "revision", to: "adr", verb: "write-artifact" },
 			{ from: "adr", to: "final", verb: "write-artifact" },
 			{ from: "planner", to: "handoff", verb: "handoff" },
@@ -185,6 +189,7 @@ export const WORKFLOW_MANIFEST: Record<CanonicalGjcWorkflowSkill, SkillManifest>
 			{ from: "critic", to: "handoff", verb: "handoff" },
 			{ from: "revision", to: "handoff", verb: "handoff" },
 			{ from: "adr", to: "handoff", verb: "handoff" },
+			{ from: "post-interview", to: "handoff", verb: "handoff" },
 		],
 		verbs: [...stateVerbs(), ...flagVerbs(["kickoff", "write-artifact"]), ...plannedVerbs(PLANNED_ADMIN_VERBS)],
 		typedArgs: [
@@ -196,7 +201,7 @@ export const WORKFLOW_MANIFEST: Record<CanonicalGjcWorkflowSkill, SkillManifest>
 			{
 				name: "stage",
 				type: "enum",
-				enumValues: ["planner", "architect", "critic", "revision", "adr", "final"],
+				enumValues: ["planner", "architect", "critic", "revision", "post-interview", "adr", "final"],
 				appliesToVerbs: ["write-artifact"],
 			},
 			{ name: "stage_n", type: "number", appliesToVerbs: ["write-artifact"] },

package/src/hooks/skill-state.ts

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { logger } from "@gajae-code/utils";
 import type { SkillDiscoverySettings } from "../config/skill-settings-defaults";
+import { detectDeepInterviewPlaintextAskLeak } from "../deep-interview/plaintext-gate-guard";
 import { activeSnapshotPath, modeStatePath as sessionModeStatePath } from "../gjc-runtime/session-layout";
 import { resolveGjcSessionForRead } from "../gjc-runtime/session-resolution";
 import { ModeStateSchema, SkillActiveStateSchema } from "../gjc-runtime/state-schema";
@@ -675,6 +676,52 @@ async function readCurrentGoalObjectiveFromSessionFile(sessionFile: string | und
 	return typeof objective === "string" && objective.trim().length > 0 ? objective.trim() : null;
 }
 
+async function readLatestAssistantTextFromSessionFile(sessionFile: string | undefined): Promise<string | null> {
+	const trimmed = sessionFile?.trim();
+	if (!trimmed) return null;
+	let entries: SessionEntry[];
+	try {
+		entries = (await loadEntriesFromFile(trimmed)).filter((entry): entry is SessionEntry => entry.type !== "session");
+	} catch {
+		return null;
+	}
+	if (entries.length === 0) return null;
+	const context = buildSessionContext(entries);
+	for (let index = context.messages.length - 1; index >= 0; index--) {
+		const message = context.messages[index];
+		if (message?.role !== "assistant") continue;
+		const text = message.content
+			.filter(block => block.type === "text")
+			.map(block => block.text)
+			.join("");
+		const trimmedText = text.trim();
+		return trimmedText.length > 0 ? trimmedText : null;
+	}
+	return null;
+}
+
+async function shouldRescueDeepInterviewPlaintextAskLeak(
+	skill: GjcWorkflowSkill,
+	state: ModeState | null,
+	cwd: string,
+	sessionFile: string | undefined,
+): Promise<boolean> {
+	if (skill !== "deep-interview") return false;
+	if (state?.active !== true) return false;
+	const phase = String(state.current_phase ?? "")
+		.trim()
+		.toLowerCase();
+	if (DEEP_INTERVIEW_ABORT_PHASES.has(phase)) return false;
+	if (await deepInterviewSpecCrystallized(state, cwd)) return false;
+	const latestAssistantText = await readLatestAssistantTextFromSessionFile(sessionFile);
+	if (!latestAssistantText) return false;
+	return detectDeepInterviewPlaintextAskLeak(latestAssistantText) !== null;
+}
+
+function buildDeepInterviewPlaintextAskLeakMessage(statePath: string): string {
+	return `GJC deep-interview emitted a Deep Interview question/options block as plain text (${statePath}). It must not wait for a prose answer. Continue immediately by calling the ask tool with the Restate gate question and options: Yes, crystallize; Adjust wording; Missing scope; plus free text/custom input.`;
+}
+
 export async function buildActiveUltragoalPromptContext(input: UserPromptSubmitStateInput): Promise<string | null> {
 	const resolvedSessionId = await resolveBoundarySessionId(input.cwd, input.sessionId);
 	const visibleModeState = await readVisibleModeState(input.cwd, "ultragoal", resolvedSessionId, input.stateDir);
@@ -756,6 +803,16 @@ export async function buildSkillStopOutput(input: StopHookInput): Promise<Record
 				systemMessage: recoveryMessage,
 			};
 		}
+		if (await shouldRescueDeepInterviewPlaintextAskLeak(entry.skill, modeState, input.cwd, input.sessionFile)) {
+			const statePath = modeStatePath(input.cwd, entry.skill, resolvedSessionId);
+			const rescueMessage = buildDeepInterviewPlaintextAskLeakMessage(statePath);
+			return {
+				decision: "block",
+				reason: rescueMessage,
+				stopReason: "gjc_skill_deep_interview_plaintext_ask_leak",
+				systemMessage: rescueMessage,
+			};
+		}
 		if (modeStateReleasesStop(modeState, handoffRequired)) {
 			// A mode-state that claims it releases the Stop block must agree with
 			// authoritative durable state. If a stale/incoherent mode-state would