@gajae-code/coding-agent 0.6.3 → 0.6.4

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [0.6.4] - 2026-06-20
+
+### Changed
+
+- Added `startup.welcomeBannerMode = "square"` for a square-corner Unicode welcome-logo fallback, and stopped treating Windows Terminal (`WT_SESSION`) as an automatic ASCII downgrade; `auto` now preserves the rounded Unicode logo while `unicode`, `square`, and `ascii` remain explicit overrides.
+
+- Improved image input discoverability by adding an interactive `#paste-image` prompt action and clearer clipboard fallback guidance when no image is available.
+
+- Improved skill migration guidance for users moving custom skills onto the current skill system (#899).
+
+### Fixed
+
+- Fixed native Windows tmux launch and hardened Windows tmux root launch, and resolved follow-up Windows tmux launch and input regressions (#884, #895, #906).
+- Fixed `EXDEV` failures when moving session artifacts across filesystems (cross-device session artifact moves) (#886).
+- Excluded user context files from the project prompt so file-level context filtering no longer leaks user-scoped files into project context (#885).
+- Fixed a bash cancellation descendant-cleanup race so cancellation now waits for child-process cleanup within a bounded stall prompt (#893).
+- Fixed the TUI dropping the first `/goal set <objective>` command from input history: the typed command is now recorded whenever args are supplied, regardless of prior goal-mode state (#910).
+- Fixed Ctrl+Enter/Ctrl+Shift+Enter newline handling in the editor: idle Ctrl+Enter now falls through to newline insertion while keeping Ctrl+Enter as the busy-session follow-up shortcut, and Ctrl+Shift+Enter inserts a newline (#911).
+- Fixed parsing of psmux modified-enter key sequences in the TUI (#918).
+
+### Documentation
+
+- Documented Windows Terminal welcome-logo troubleshooting with Cascadia Mono / Cascadia Mono Nerd Font and the profile `fontFace` setting.
+- Documented CLI `@image` attachments and interactive TUI clipboard image paste fallbacks in the root README.
+
+- Documented lifecycle notification hooks (#903).
+- Added a routed GJC session guide for Clawhip/Hermes/OpenClaw visible routed sessions and linked it from the Hermes docs and operator instructions.
+
 ## [0.6.3] - 2026-06-19
 
 ### Fixed

package/README.md

@@ -11,9 +11,69 @@ Package-specific references:
 - [DEVELOPMENT](./DEVELOPMENT.md)
 - [RenderMermaid guide](../../docs/render-mermaid.md)
 
+## External lifecycle notifications
+
+GJC already exposes public lifecycle events through the extension/hook event contract. External notification integrations for Discord, Hermes, clawhip, or similar channels should be opt-in and subscribe to these events instead of scraping transcripts or logs:
+
+- `turn_end` — a model/tool turn finished. The public payload is `{ type: "turn_end", turnIndex, message, toolResults }`.
+- `agent_end` — the agent loop for a submitted prompt reached a terminal boundary. The public payload is `{ type: "agent_end", messages }`.
+
+Recommended external mapping:
+
+| Notification | Public event | Status guidance |
+|---|---|---|
+| Turn finished | `turn_end` | Use the handler's own sanitized status such as `"finished"`. |
+| Agent stopped/finished | `agent_end` | Treat as terminal for the prompt. |
+| Waiting/blocked/failed | `agent_end` plus a caller-supplied safe summary | Current lifecycle events do not expose a separate structured waiting/blocked reason; inspect only public-safe, integration-owned state. |
+
+Forward only a minimal, caller-sanitized payload. Do not include raw prompts, assistant transcripts, hidden prompts, tool outputs, raw logs, host paths, private config, webhook URLs, channel IDs, tokens, or secrets. A safe notification payload should be built by the extension/hook itself, for example:
+
+```ts
+import type { ExtensionAPI } from "@gajae-code/coding-agent";
+
+type PublicLifecycleNotification = {
+	type: "turn_end" | "agent_end";
+	status: "finished" | "stopped" | "failed" | "blocked" | "waiting";
+	turnIndex?: number;
+	timestamp: string;
+	summary: string;
+};
+
+export default function lifecycleNotifier(pi: ExtensionAPI) {
+	const enabled = process.env.GJC_LIFECYCLE_NOTIFY === "1";
+	if (!enabled) return;
+
+	const send = async (payload: PublicLifecycleNotification) => {
+		// POST to Discord/Hermes/clawhip here. Keep target URLs and channel IDs in
+		// private config or environment variables; never include them in payloads.
+	};
+
+	pi.on("turn_end", event =>
+		send({
+			type: "turn_end",
+			status: "finished",
+			turnIndex: event.turnIndex,
+			timestamp: new Date().toISOString(),
+			summary: "GJC turn finished",
+		}),
+	);
+
+	pi.on("agent_end", () =>
+		send({
+			type: "agent_end",
+			status: "stopped",
+			timestamp: new Date().toISOString(),
+			summary: "GJC prompt reached a terminal lifecycle boundary",
+		}),
+	);
+}
+```
+
+This is the supported repo-native lifecycle notification path. It is not Claude Code hook compatibility, and it remains disabled unless the user configures an extension/hook handler and private delivery target.
+
 ## Memory backends
 
-The agent supports three mutually-exclusive memory backends, selected via the `memory.backend` setting (Settings → Memory tab, or `~/.gjc/config.yml`):
+The agent supports three mutually-exclusive memory backends, selected via the `memory.backend` setting (Settings → Memory tab, or `~/.gjc/agent/config.yml`):
 
 - `off` (default) — no memory subsystem runs.
 - `local` — existing rollout-summarisation pipeline; writes `memory_summary.md` and consolidated artifacts under the agent dir.
@@ -35,3 +95,15 @@ Switching backends mid-session is honoured on the next system-prompt rebuild and
 ## Red-claw TUI theme
 
 The interactive TUI defaults to the bundled `red-claw` crustacean theme for dark terminals and the bundled `blue-crab` theme for light-appearance terminals, with matching welcome/icon assets. Three additional bundled migration themes — `claude-code`, `codex`, and `opencode` — mirror the look of those tools for easy eye-migration and are selectable from Settings or `/theme`. Explicit user theme settings still win; set `theme.dark: red-claw` and `theme.light: blue-crab` in `~/.gjc/agent/config.yml` to pin them.
+
+### Welcome banner fonts on Windows Terminal
+
+The startup logo defaults to rounded Unicode box drawing. Windows Terminal can render it correctly when the selected profile font has the needed box-drawing glyphs; recommended choices are `Cascadia Mono` or `Cascadia Mono Nerd Font`. In Windows Terminal Settings, set the profile font face to one of those fonts, or add it to the profile JSON:
+
+```json
+"font": {
+  "face": "Cascadia Mono"
+}
+```
+
+For terminals or fonts with broken rounded corners, set `startup.welcomeBannerMode` in `~/.gjc/agent/config.yml` to one of `unicode`, `square`, or `ascii`. `square` keeps a Unicode-looking logo using square corners (`┌ ┐ └ ┘`) while `ascii` uses only `+`, `-`, and `|`.

package/dist/types/config/settings-schema.d.ts

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

package/dist/types/gjc-runtime/tmux-sessions.d.ts

@@ -32,6 +32,8 @@ export declare function listGjcTmuxSessions(env?: NodeJS.ProcessEnv): GjcTmuxSes
 /** @internal */
 export declare function listTmuxSessionsForGc(env?: NodeJS.ProcessEnv): GjcTmuxSessionsForGc;
 export declare function findGjcTmuxSessionByBranch(branch: string, env?: NodeJS.ProcessEnv, project?: string | null): GjcTmuxSessionStatus | undefined;
+export declare function findGjcTmuxSessionByName(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus | undefined;
+export declare function findGjcTmuxSessionByScope(project: string, branch: string | null | undefined, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus | undefined;
 export declare function statusGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
 export declare function createGjcTmuxSession(env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
 /** @internal */

package/dist/types/modes/components/welcome.d.ts

@@ -8,6 +8,7 @@ export interface LspServerInfo {
     status: "ready" | "error" | "connecting";
     fileTypes: string[];
 }
+export type WelcomeLogoMode = "unicode" | "square" | "ascii";
 /**
  * GJC-native launch surface with compact command affordances, project
  * signals, and a claw/talon mark without copying another agent shell.
@@ -19,7 +20,8 @@ export declare class WelcomeComponent implements Component {
     private providerName;
     private recentSessions;
     private lspServers;
-    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], lspServers?: LspServerInfo[]);
+    private readonly logoMode;
+    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], lspServers?: LspServerInfo[], logoMode?: WelcomeLogoMode);
     invalidate(): void;
     /**
      * Play a one-shot intro that sweeps the gradient through every phase

package/dist/types/modes/interactive-mode.d.ts

@@ -23,9 +23,12 @@ import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
 import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
+import { type WelcomeLogoMode } from "./components/welcome";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
 import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
+export type WelcomeBannerSettingMode = "auto" | "unicode" | "square" | "ascii";
+export declare function resolveWelcomeLogoMode(mode: WelcomeBannerSettingMode, env?: Record<string, string | undefined>, platform?: NodeJS.Platform): WelcomeLogoMode;
 /** Options for creating an InteractiveMode instance (for future API use) */
 export interface InteractiveModeOptions {
     /** Providers that were migrated during startup */

package/dist/types/modes/prompt-action-autocomplete.d.ts

@@ -13,6 +13,7 @@ interface PromptActionAutocompleteOptions {
     keybindings: KeybindingsManager;
     copyCurrentLine: () => void;
     copyPrompt: () => void;
+    pasteImage: () => void;
     undo: (prefix: string) => void;
     moveCursorToMessageEnd: () => void;
     moveCursorToMessageStart: () => void;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.6.3",
+	"version": "0.6.4",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -51,12 +51,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.6.3",
-		"@gajae-code/agent-core": "0.6.3",
-		"@gajae-code/ai": "0.6.3",
-		"@gajae-code/natives": "0.6.3",
-		"@gajae-code/tui": "0.6.3",
-		"@gajae-code/utils": "0.6.3",
+		"@gajae-code/stats": "0.6.4",
+		"@gajae-code/agent-core": "0.6.4",
+		"@gajae-code/ai": "0.6.4",
+		"@gajae-code/natives": "0.6.4",
+		"@gajae-code/tui": "0.6.4",
+		"@gajae-code/utils": "0.6.4",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/cli/setup-cli.ts

@@ -374,6 +374,7 @@ async function handleHooksSetup(flags: { json?: boolean; check?: boolean }): Pro
 async function handleDefaultsSetup(flags: { json?: boolean; check?: boolean; force?: boolean }): Promise<void> {
 	const result = await installDefaultGjcDefinitions({ check: flags.check, force: flags.force });
 	const hasCheckFailure = result.missing > 0 || result.different > 0;
+	const inspectGuidance = `Inspect bundled skills with: ${APP_NAME} skills list; read one with: ${APP_NAME} skills read ralplan`;
 
 	if (flags.json) {
 		console.log(JSON.stringify(result, null, 2));
@@ -388,18 +389,30 @@ async function handleDefaultsSetup(flags: { json?: boolean; check?: boolean; for
 			console.error(
 				chalk.dim(`Missing: ${result.missing}; different: ${result.different}; matching: ${result.matching}`),
 			);
+			console.error(chalk.dim(inspectGuidance));
+			console.error(
+				chalk.dim(
+					`Compare embedded defaults before overwriting local files with: ${APP_NAME} setup defaults --force`,
+				),
+			);
 			process.exit(1);
 		}
 		console.log(chalk.green(`${theme.status.success} Default GJC workflow skills are installed`));
 		console.log(chalk.dim(`Target: ${result.targetRoot}`));
+		console.log(chalk.dim(inspectGuidance));
 		return;
 	}
 
 	console.log(chalk.green(`${theme.status.success} Default GJC workflow skills installed`));
 	console.log(chalk.dim(`Target: ${result.targetRoot}`));
 	console.log(chalk.dim(`Written: ${result.written}; skipped: ${result.skipped}`));
+	console.log(chalk.dim(inspectGuidance));
 	if (result.skipped > 0 && !flags.force) {
-		console.log(chalk.dim("Use --force to overwrite existing default workflow skill files."));
+		console.log(
+			chalk.dim(
+				`Existing local default workflow skill files were preserved. Use ${APP_NAME} setup defaults --force to overwrite them intentionally.`,
+			),
+		);
 	}
 }
 

package/src/commands/launch.ts

@@ -169,7 +169,7 @@ export default class Index extends Command {
 				rawArgs: launch.args,
 				cwd: launch.cwd,
 				worktreeBranch: launch.worktree.enabled && !launch.worktree.detached ? launch.worktree.branchName : null,
-				project: launch.worktree.enabled ? launch.worktree.repoRoot : launch.cwd,
+				project: launch.cwd,
 			})
 		)
 			return;

package/src/config/model-registry.ts

@@ -872,7 +872,13 @@ const customReferenceMap = buildCustomReferenceMap();
 
 function getCustomReferenceCandidateIds(modelId: string): string[] {
 	const candidates = new Set<string>();
-	const queue = [modelId];
+	const minimaxM = /^minimax-m(\d+(?:\.\d+)*)$/i.exec(modelId.trim());
+	const queue = minimaxM ? [`MiniMax-M${minimaxM[1]}`, modelId] : [modelId];
+	if (minimaxM) {
+		// MiniMax catalogs include lowercase wire ids plus display-cased aliases.
+		// Custom providers should keep the lowercase wire id while inheriting the
+		// canonical display casing when the alias exists.
+	}
 	for (let index = 0; index < queue.length; index += 1) {
 		const candidate = queue[index]?.trim();
 		if (!candidate || candidates.has(candidate)) continue;
@@ -1212,13 +1218,14 @@ export class ModelRegistry {
 			const existingIndex = indexByKey.get(key);
 			if (existingIndex !== undefined) {
 				const existingModel = merged[existingIndex];
+				const referenceModel = resolveCustomModelReference(customModel.id);
 				merged[existingIndex] = enrichModelThinking({
 					...existingModel,
 					id: customModel.id,
 					provider: customModel.provider,
 					api: customModel.api,
 					baseUrl: customModel.baseUrl,
-					name: customModel.name ?? existingModel.name,
+					name: customModel.name ?? referenceModel?.name ?? existingModel.name,
 					reasoning: customModel.reasoning ?? existingModel.reasoning,
 					thinking: customModel.thinking ?? existingModel.thinking,
 					input: customModel.input ?? existingModel.input,

package/src/config/model-resolver.ts

@@ -147,12 +147,23 @@ export function resolveProviderModelReference(
 	modelId: string,
 	availableModels: readonly Model<Api>[],
 ): Model<Api> | undefined {
-	const normalizedProvider = provider.trim().toLowerCase();
-	const normalizedModelId = modelId.trim().toLowerCase();
+	const trimmedProvider = provider.trim();
+	const trimmedModelId = modelId.trim();
+	const normalizedProvider = trimmedProvider.toLowerCase();
+	const normalizedModelId = trimmedModelId.toLowerCase();
 	if (!normalizedProvider || !normalizedModelId) {
 		return undefined;
 	}
 
+	// Prefer an exact provider/model id match before falling back to the
+	// case-insensitive index. Some provider catalogs intentionally carry both a
+	// machine-id form (for example `minimax-m3`) and a display-cased alias
+	// (`MiniMax-M3`). The lowercase index correctly treats those aliases as
+	// ambiguous for fuzzy/case-insensitive lookup, but an exact selector should
+	// still resolve deterministically.
+	const caseExact = availableModels.find(m => m.provider === trimmedProvider && m.id === trimmedModelId);
+	if (caseExact) return caseExact;
+
 	const index = getProviderModelIndex(availableModels);
 	const exact = index.get(`${normalizedProvider}\u0000${normalizedModelId}`);
 	if (exact === null) {

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/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/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,