@gajae-code/coding-agent 0.6.1 → 0.6.4

package/src/config/settings-schema.ts

@@ -1065,6 +1065,23 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"startup.welcomeBannerMode": {
+		type: "enum",
+		values: ["auto", "unicode", "square", "ascii"] as const,
+		default: "auto",
+		ui: {
+			tab: "interaction",
+			label: "Welcome Banner Mode",
+			description: "Logo style for the startup welcome screen",
+			options: [
+				{ value: "auto", label: "Auto", description: "Use the rounded Unicode logo" },
+				{ value: "unicode", label: "Unicode", description: "Force the rounded Unicode logo" },
+				{ value: "square", label: "Square Unicode", description: "Force the square-corner Unicode fallback" },
+				{ value: "ascii", label: "ASCII", description: "Force the ASCII-safe logo" },
+			],
+		},
+	},
+
 	"startup.checkUpdate": {
 		type: "boolean",
 		default: true,

package/src/defaults/gjc/skills/deep-interview/SKILL.md

@@ -123,6 +123,8 @@ Deep Interview threshold: <resolvedThresholdPercent> (source: <resolvedThreshold
    - Final specs MUST resolve to `.gjc/specs/deep-interview-{slug}.md` exactly.
    - Write final specs and all ephemeral interview artifacts through the active GJC workflow/state CLI when available.
    - Direct `.gjc/` file edits are forbidden unless an explicit force override is active; do not use `write`, `edit`, or `ast_edit` against `.gjc/specs`, `.gjc/plans`, `.gjc/state`, or other `.gjc/` paths during normal workflow operation.
+   - Preferred: pass the spec markdown **inline** to the native deep-interview write command (`--write … --spec "<markdown>"`) — no scratch file is needed. The CLI is the only sanctioned writer for `.gjc/specs`.
+   - Only if a spec is too large to pass inline, stage it with the `write` tool to a system temp directory (`os.tmpdir()`/`$TMPDIR`, `/tmp`, `/var/tmp`) outside the project tree, then pass that path to `--spec`. The planning phase-boundary block tolerates these neutral temp writes; never stage interview artifacts inside the repo or under `.gjc/`, and do not improvise repo-relative scratch files.
 
 4. **Initialize state** via `gjc state write`:
 
@@ -495,7 +497,7 @@ When ambiguity ≤ threshold (or hard cap / early exit):
    - Apply `language.instruction` when present so user-facing prose in the spec preserves the session language; keep code identifiers, file paths, commands, JSON/settings keys, and quoted source text unchanged.
    - Apply the self-proofread once to newly generated spec prose before persistence, including generated natural-language table cells such as coverage notes, while preserving transcript answers, quoted/source text, code identifiers, file paths, commands, JSON/settings keys, table structure/fixed labels, and `.gjc/specs/deep-interview-{slug}.md` unchanged.
 2. **Write the final spec through the workflow CLI**: persist the artifact at `.gjc/specs/deep-interview-{slug}.md`
-   - Always use this exact final spec path. Do not write temporary working files to the repo root or other ad hoc paths; repos may allowlist `.gjc/` for planning artifacts while protecting product branches.
+   - Always use this exact final spec path. Prefer passing the spec markdown **inline** as the `--spec` value; only when it is too large to pass inline, stage it as a file in a system temp directory (`os.tmpdir()`/`$TMPDIR`, `/tmp`, `/var/tmp`) outside the project tree and pass that path — never write scratch specs to the repo root, the project tree, or `.gjc/`.
    - Use the native deep-interview write command with `--write --stage final --slug {slug} --spec <markdown-or-path> [--json]` for artifact and state persistence; direct `.gjc/` file edits are forbidden unless an explicit force override is active.
    - Persist the final `spec_path` in state when available so downstream skills and resumed sessions can pass the artifact path explicitly.
    - If the user preselected the deliberate ralplan path, use the native deep-interview write command with `--write --stage final --slug {slug} --spec <markdown-or-path> --deliberate [--json]` so the final spec is persisted before deep-interview hands off to ralplan.

package/src/defaults/gjc/skills/ralplan/SKILL.md

@@ -45,6 +45,8 @@ gjc ralplan --write --stage <type> --stage_n <N> --artifact "markdown file path
 
 Use stage values that match the producer or artifact kind, such as `planner`, `architect`, `critic`, `revision`, `adr`, or `final`. Increment `--stage_n` for each consensus-loop pass. The `--artifact` value may be either a markdown file path prepared outside `.gjc/` for ingestion or the markdown content string itself. The native `--write` handler persists markdown under `.gjc/plans/ralplan/<run-id>/stage-<NN>-<stage>.md`, maintains an `index.jsonl` audit log, and for `final` stages additionally writes a `pending-approval.md` copy. Direct `write`, `edit`, or `ast_edit` calls against `.gjc/specs`, `.gjc/plans`, `.gjc/state`, or any other `.gjc/` path are forbidden unless an explicit force override is active.
 
+While ralplan is active it is a pre-approval planning phase: product-code mutation tools (`write`/`edit`/`ast_edit`) and product-mutating `bash` (e.g. `tee src/...`, redirects into the project tree) are blocked, exactly like deep-interview. Prefer passing the `--artifact` markdown **inline** (the content string) so no scratch file is needed; this is mandatory for restricted role agents (see below). Only the leader, and only when an artifact is too large to pass inline, may stage it as a file in a system temp directory (`os.tmpdir()`/`$TMPDIR`, `/tmp`, `/var/tmp`) outside the project tree and pass that path — never write scratch files into the repo or `.gjc/`. Product code is mutated only after the plan is approved and execution begins.
+
 Restricted read-only role agents (`planner`, `architect`, and `critic`) must pass markdown content directly in `--artifact`; their restricted bash environment intentionally disables artifact file-path ingestion so a verdict command cannot persist arbitrary file contents.
 
 After a role agent persists a stage artifact, its model-facing response to the caller SHOULD be receipt-only: return the `gjc ralplan --write --json` receipt (`run_id`, `path`, `stage`, `stage_n`, `sha256`, `created_at`) plus the minimal verdict/status fields the caller needs for routing, and do **not** paste the full persisted markdown back into the parent conversation. Downstream reviewers should receive the artifact path/receipt and read the persisted file themselves when they actually need the body. This preserves the audit trail while preventing Planner/Architect/Critic verdict bodies from being duplicated into the main-agent context.

package/src/exec/bash-executor.ts

@@ -66,7 +66,9 @@ export interface BashResult {
 const shellSessions = new Map<string, Shell>();
 const brokenShellSessions = new Set<string>();
 const retiringShellSessions = new Set<Shell>();
-const CANCEL_CLEANUP_WAIT_MS = 250;
+// Cover pi-shell's normal cancellation kill waves without turning a stalled
+// native cleanup into a multi-second JavaScript tool stall.
+const CANCEL_CLEANUP_WAIT_MS = 400;
 
 /** Number of persistent shell sessions currently retained (owner gauge). */
 export function getShellSessionCount(): number {

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

@@ -1,3 +1,4 @@
+import { Buffer } from "node:buffer";
 import * as path from "node:path";
 import { safeStderrWrite } from "@gajae-code/utils";
 import type { Args } from "../cli/args";
@@ -14,7 +15,7 @@ import {
 	type GjcTmuxProfileCommand,
 	resolveGjcTmuxCommand,
 } from "./tmux-common";
-import { findGjcTmuxSessionByBranch } from "./tmux-sessions";
+import { findGjcTmuxSessionByName, findGjcTmuxSessionByScope } from "./tmux-sessions";
 
 export {
 	buildGjcTmuxProfileCommands,
@@ -83,6 +84,20 @@ export interface TmuxLaunchPlan {
 	sessionStateFile?: string | null;
 }
 
+function explicitTmuxSessionName(env: NodeJS.ProcessEnv): string | undefined {
+	return env.GJC_TMUX_SESSION?.trim() || undefined;
+}
+
+function findExistingSessionForLaunch(context: {
+	env: NodeJS.ProcessEnv;
+	project: string;
+	branch?: string | null;
+}): string | undefined {
+	const explicit = explicitTmuxSessionName(context.env);
+	if (explicit) return findGjcTmuxSessionByName(explicit, context.env)?.name;
+	return findGjcTmuxSessionByScope(context.project, context.branch, context.env)?.name;
+}
+
 export interface GjcTmuxProfileResult {
 	skipped: boolean;
 	commands: GjcTmuxProfileCommand[];
@@ -107,6 +122,7 @@ interface CommandResolutionContext {
 	argv: string[];
 	execPath: string;
 	extraEnv?: Record<string, string>;
+	platform?: NodeJS.Platform;
 }
 
 function parseLaunchPolicy(env: NodeJS.ProcessEnv): LaunchPolicy {
@@ -148,6 +164,26 @@ function buildEnvAssignments(values: Record<string, string> | undefined): string
 	const entries = Object.entries(values ?? {});
 	return entries.length === 0 ? "" : ` ${entries.map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ")}`;
 }
+function powershellQuote(value: string): string {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+function stripRootTmuxFlag(rawArgs: string[]): string[] {
+	return rawArgs.filter(arg => arg !== "--tmux");
+}
+
+function buildWindowsPowerShellInnerCommand(context: CommandResolutionContext, rawArgs: string[]): string {
+	const command = resolveCurrentGjcCommand(context);
+	const envLines = Object.entries({ [GJC_TMUX_LAUNCHED_ENV]: "1", ...(context.extraEnv ?? {}) }).map(
+		([key, value]) => `$env:${key} = ${powershellQuote(value)}`,
+	);
+	const invocation = ["&", ...command.map(powershellQuote), ...stripRootTmuxFlag(rawArgs).map(powershellQuote)].join(
+		" ",
+	);
+	const exitLine = "if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE } else { exit 1 }";
+	const script = [...envLines, invocation, exitLine].join("\n");
+	const encodedCommand = Buffer.from(script, "utf16le").toString("base64");
+	return `pwsh -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encodedCommand}`;
+}
 
 export function applyGjcTmuxProfile(context: GjcTmuxProfileContext): GjcTmuxProfileResult {
 	const env = context.env ?? process.env;
@@ -177,16 +213,26 @@ function resolveCurrentGjcCommand(context: CommandResolutionContext): string[] {
 	if (isBunVirtualPath(entrypoint)) {
 		return isBunVirtualPath(context.execPath) ? ["gjc"] : [context.execPath];
 	}
-	const resolvedEntrypoint = path.isAbsolute(entrypoint) ? entrypoint : path.resolve(context.cwd, entrypoint);
+	const pathModule = pathModuleForPlatform(context.platform);
+	const resolvedEntrypoint = pathModule.isAbsolute(entrypoint)
+		? entrypoint
+		: pathModule.resolve(context.cwd, entrypoint);
 	if (entrypoint.endsWith(".ts") || entrypoint.endsWith(".js") || entrypoint.endsWith(".mjs")) {
 		return [context.execPath, resolvedEntrypoint];
 	}
 	return [resolvedEntrypoint];
 }
+function isWindowsPlatform(platform: NodeJS.Platform | undefined): boolean {
+	return platform === "win32";
+}
+function pathModuleForPlatform(platform: NodeJS.Platform | undefined): typeof path.win32 | typeof path {
+	return isWindowsPlatform(platform) ? path.win32 : path;
+}
 
 function buildInnerCommand(context: CommandResolutionContext, rawArgs: string[]): string {
+	if (isWindowsPlatform(context.platform)) return buildWindowsPowerShellInnerCommand(context, rawArgs);
 	const command = resolveCurrentGjcCommand(context);
-	const quoted = [...command, ...rawArgs].map(shellQuote).join(" ");
+	const quoted = [...command, ...stripRootTmuxFlag(rawArgs)].map(shellQuote).join(" ");
 	return `exec env ${GJC_TMUX_LAUNCHED_ENV}=1${buildEnvAssignments(context.extraEnv)} ${quoted}`;
 }
 
@@ -305,7 +351,6 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 	if (!context.parsed.tmux || policy === "direct") return undefined;
 	if (env.TMUX || env[GJC_TMUX_LAUNCHED_ENV] === "1") return undefined;
 	const platform = context.platform ?? process.platform;
-	if (platform === "win32") return undefined;
 	const tty = context.tty ?? { stdin: Boolean(process.stdin.isTTY), stdout: Boolean(process.stdout.isTTY) };
 	if (policy === "tmux" && !isInteractiveRootLaunch(context.parsed, tty)) return undefined;
 
@@ -320,12 +365,14 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 		path.join(cwd, ".gjc", "runtime", "tmux-sessions", `${buildGjcTmuxSessionSlug(sessionName)}.json`);
 	const tmuxAvailable = context.tmuxAvailable ?? Bun.which(tmuxCommand) !== null;
 	if (!tmuxAvailable) return undefined;
-	const existingBranchSessionName =
+	const existingSessionName =
 		"existingBranchSessionName" in context
 			? (context.existingBranchSessionName ?? undefined)
-			: context.worktreeBranch
-				? findGjcTmuxSessionByBranch(context.worktreeBranch, env, project)?.name
-				: undefined;
+			: findExistingSessionForLaunch({
+					env,
+					project,
+					branch,
+				});
 	const innerCommand = buildInnerCommand(
 		{
 			cwd,
@@ -335,6 +382,7 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 				[GJC_COORDINATOR_SESSION_ID_ENV]: sessionId,
 				[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]: sessionStateFile,
 			},
+			platform,
 		},
 		context.rawArgs,
 	);
@@ -348,7 +396,7 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 		project,
 		sessionId,
 		sessionStateFile,
-		attachSessionName: existingBranchSessionName,
+		attachSessionName: existingSessionName,
 	};
 }
 
@@ -405,19 +453,19 @@ export function launchDefaultTmuxIfNeeded(context: TmuxLaunchContext): boolean {
 			sessionId: plan.sessionId ?? null,
 			sessionStateFile: plan.sessionStateFile ?? null,
 		});
-		if (profile.failures.length > 0) {
+		const ownershipFailure = profile.failures.find(item => item.command.args.includes("@gjc-profile"));
+		if (ownershipFailure) {
 			cleanupCreatedTmuxSession(plan, spawnSync, options);
-			const failure =
-				profile.failures.find(item => item.command.args.includes("@gjc-profile")) ?? profile.failures[0];
 			(context.diagnosticWriter ?? safeStderrWrite)(
-				formatTmuxLaunchDiagnostic("profile tagging failed", failure?.stderr),
+				formatTmuxLaunchDiagnostic("profile tagging failed", ownershipFailure.stderr),
 			);
 			return true;
 		}
 	}
 	if (created.exitCode !== 0) return false;
-	const attached = spawnSync(plan.tmuxCommand, ["attach-session", "-t", plan.sessionName], options);
+	const attached = spawnSync(plan.tmuxCommand, ["attach-session", "-t", `=${plan.sessionName}`], options);
 	if (attached.exitCode === 0) return true;
+	cleanupCreatedTmuxSession(plan, spawnSync, options);
 	(context.diagnosticWriter ?? safeStderrWrite)(formatTmuxLaunchDiagnostic("attach failed", attached.stderr));
 	return true;
 }

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

@@ -297,12 +297,26 @@ async function resolveSelectors(
 	}
 	if (mode) assertKnownMode(mode);
 
+	const sessionId = resolveSessionIdFromArgs(args, payload);
+
+	const threadId = flagValue(args, "--thread-id")?.trim() || undefined;
+	if (threadId) assertSafePathComponent(threadId, "thread-id");
+	const turnId = flagValue(args, "--turn-id")?.trim() || undefined;
+	if (turnId) assertSafePathComponent(turnId, "turn-id");
+
+	return { mode: mode as CanonicalGjcWorkflowSkill | undefined, sessionId, threadId, turnId, payload };
+}
+
+// Session-id resolution order: explicit --session-id flag, then payload
+// session_id, then GJC_SESSION_ID env var (set by AgentSession.sdk for
+// agent-initiated CLI invocations). The env-var default keeps shell
+// snippets in skill docs short while still routing state commands to the
+// caller's session-scoped state files.
+function resolveSessionIdFromArgs(
+	args: readonly string[],
+	payload: Record<string, unknown> | undefined,
+): string | undefined {
 	const explicitSessionId = flagValue(args, "--session-id");
-	// Session-id resolution order: explicit --session-id flag, then payload
-	// session_id, then GJC_SESSION_ID env var (set by AgentSession.sdk for
-	// agent-initiated CLI invocations). The env-var default keeps shell
-	// snippets in skill docs short while still routing writes/reads to the
-	// caller's session-scoped state files.
 	let sessionId = explicitSessionId !== undefined ? explicitSessionId.trim() || undefined : undefined;
 	if (!sessionId && payload && typeof payload.session_id === "string") {
 		sessionId = payload.session_id.trim() || undefined;
@@ -312,13 +326,7 @@ async function resolveSelectors(
 		if (envSessionId) sessionId = envSessionId;
 	}
 	if (sessionId) assertSafePathComponent(sessionId, "session-id");
-
-	const threadId = flagValue(args, "--thread-id")?.trim() || undefined;
-	if (threadId) assertSafePathComponent(threadId, "thread-id");
-	const turnId = flagValue(args, "--turn-id")?.trim() || undefined;
-	if (turnId) assertSafePathComponent(turnId, "turn-id");
-
-	return { mode: mode as CanonicalGjcWorkflowSkill | undefined, sessionId, threadId, turnId, payload };
+	return sessionId;
 }
 
 async function inferModeFromActiveState(
@@ -718,8 +726,8 @@ async function handleDoctor(
 ): Promise<StateCommandResult> {
 	const rawSkill = flagValue(args, "--skill")?.trim() || flagValue(args, "--mode")?.trim() || positionalSkill?.trim();
 	if (rawSkill) assertKnownMode(rawSkill);
-	const sessionId = flagValue(args, "--session-id")?.trim() || undefined;
-	if (sessionId) assertSafePathComponent(sessionId, "session-id");
+	const payload = await readInputJson(flagValue(args, "--input"), cwd);
+	const sessionId = resolveSessionIdFromArgs(args, payload);
 	const summary = await collectDoctorSummary(cwd, rawSkill as CanonicalGjcWorkflowSkill | undefined, sessionId);
 	return {
 		status: summary.ok ? 0 : 1,

package/src/gjc-runtime/state-writer.ts

@@ -298,8 +298,28 @@ function flattenActiveSubskills(entries: SkillActiveEntry[]): ActiveSubskillEntr
 	return [...deduped.values()];
 }
 
+const CANONICAL_PIPELINE_RANK = new Map<string, number>([
+	["deep-interview", 0],
+	["ralplan", 1],
+	["ultragoal", 2],
+]);
+
+function canonicalPipelineRank(skill: string): number | undefined {
+	return CANONICAL_PIPELINE_RANK.get(skill);
+}
+
+function compareActiveEntryPrimary(a: SkillActiveEntry, b: SkillActiveEntry): number {
+	const aRank = canonicalPipelineRank(a.skill);
+	const bRank = canonicalPipelineRank(b.skill);
+	if (aRank !== undefined || bRank !== undefined) return (bRank ?? -1) - (aRank ?? -1);
+	const aTime = Date.parse(safeString(a.updated_at));
+	const bTime = Date.parse(safeString(b.updated_at));
+	if (Number.isFinite(aTime) || Number.isFinite(bTime)) return (bTime || 0) - (aTime || 0);
+	return 0;
+}
+
 function buildActiveSnapshot(entries: SkillActiveEntry[]): SkillActiveState {
-	const visible = entries.filter(entry => entry.active !== false);
+	const visible = entries.filter(entry => entry.active !== false).toSorted(compareActiveEntryPrimary);
 	const primary = visible[0];
 	return {
 		version: 1,

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

@@ -137,6 +137,8 @@ function listRawTmuxSessionNames(env: NodeJS.ProcessEnv = process.env): string[]
 export function listGjcTmuxSessions(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus[] {
 	return listSessionLines(env)
 		.map(parseSessionLine)
+		.filter((session): session is GjcTmuxSessionStatus => session != null)
+		.map(session => hydrateSessionFromExactOptions(session, env))
 		.filter((session): session is GjcTmuxSessionStatus => session?.profile === GJC_TMUX_PROFILE_VALUE)
 		.sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -145,7 +147,8 @@ export function listGjcTmuxSessions(env: NodeJS.ProcessEnv = process.env): GjcTm
 export function listTmuxSessionsForGc(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionsForGc {
 	const sessions = listSessionLines(env)
 		.map(parseSessionLine)
-		.filter((session): session is GjcTmuxSessionStatus => session != null);
+		.filter((session): session is GjcTmuxSessionStatus => session != null)
+		.map(session => hydrateSessionFromExactOptions(session, env));
 	const tagged = sessions
 		.filter(session => session.profile === GJC_TMUX_PROFILE_VALUE)
 		.sort((a, b) => a.name.localeCompare(b.name));
@@ -179,6 +182,22 @@ export function findGjcTmuxSessionByBranch(
 	);
 }
 
+export function findGjcTmuxSessionByName(
+	sessionName: string,
+	env: NodeJS.ProcessEnv = process.env,
+): GjcTmuxSessionStatus | undefined {
+	return listGjcTmuxSessions(env).find(session => session.name === sessionName);
+}
+
+export function findGjcTmuxSessionByScope(
+	project: string,
+	branch: string | null | undefined,
+	env: NodeJS.ProcessEnv = process.env,
+): GjcTmuxSessionStatus | undefined {
+	return listGjcTmuxSessions(env).find(
+		session => session.project === project && (branch ? session.branch === branch : session.branch === undefined),
+	);
+}
 export function statusGjcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus {
 	const session = listGjcTmuxSessions(env).find(candidate => candidate.name === sessionName);
 	if (session) return session;
@@ -227,6 +246,22 @@ function readExactOptionForGc(sessionName: string, option: string, env: NodeJS.P
 	}
 }
 
+function hydrateSessionFromExactOptions(session: GjcTmuxSessionStatus, env: NodeJS.ProcessEnv): GjcTmuxSessionStatus {
+	if (session.profile === GJC_TMUX_PROFILE_VALUE) return session;
+	const profile = readExactOptionForGc(session.name, GJC_TMUX_PROFILE_OPTION, env);
+	if (profile !== GJC_TMUX_PROFILE_VALUE) return session;
+	return {
+		...session,
+		profile,
+		branch: session.branch ?? readExactOptionForGc(session.name, GJC_TMUX_BRANCH_OPTION, env),
+		branchSlug: session.branchSlug ?? readExactOptionForGc(session.name, GJC_TMUX_BRANCH_SLUG_OPTION, env),
+		project: session.project ?? readExactOptionForGc(session.name, GJC_TMUX_PROJECT_OPTION, env),
+		sessionId: session.sessionId ?? readExactOptionForGc(session.name, GJC_TMUX_SESSION_ID_OPTION, env),
+		sessionStateFile:
+			session.sessionStateFile ?? readExactOptionForGc(session.name, GJC_TMUX_SESSION_STATE_FILE_OPTION, env),
+	};
+}
+
 /** @internal */
 export function readTmuxSessionTagsForGc(
 	sessionName: string,