@gajae-code/coding-agent 0.6.1 → 0.6.4

package/CHANGELOG.md

@@ -2,11 +2,64 @@
 
 ## [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
+
+- Reverted the experimental minified npm-bundle distribution introduced in 0.6.2. The published `@gajae-code/coding-agent` shipped both `src/` and ~30MB of `dist/` bundles (`cli.js` plus stats/browser/eval worker bundles), which pushed the package past npm's registry payload limit (`E413 Payload Too Large`) and blocked publishing of `@gajae-code/coding-agent` and the `gajae-code` wrapper (so 0.6.2 only partially published the sibling libraries). The CLI `bin`/`./cli` export ships from `src/` again, matching the layout that published cleanly through 0.6.1; the embedded tiktoken/o200k tokenizer removal is unaffected. Local measurement showed the bundle gave no idle-RAM benefit over running from source.
+- Fixed `edit-mode.ts` importing the full `@gajae-code/utils` barrel (which re-exports native-addon-backed `ptree`/`procmgr`); it now imports `$env` from the `@gajae-code/utils/env` subpath, so schema generation and other lightweight paths no longer eagerly load the native addon.
+
+## [0.6.2] - 2026-06-19
+
+### Changed
+
+- Reconciled the planning-phase mutation guard into one uniform policy across skill states (`deep-interview-mutation-guard.ts`). Previously only `deep-interview` blocked product-code mutation (and it blocked *all* `write`/`edit`/`ast_edit` targets, including neutral `/tmp` scratch), while `ralplan`/`ultragoal` planning enforced nothing beyond the always-on `.gjc/**` runtime-owned block, and `bash` got a free pass to mutate product code during the interview. Now: (1) the phase-boundary block is shared by every pre-approval planning phase — `deep-interview`, `ralplan`, and `ultragoal`'s `goal-planning` phase (`team` and executing `ultragoal` are unaffected); (2) `bash` reaches parity with `write`/`edit`/`ast_edit` so product-mutating shell commands are blocked too; and (3) neutral scratch writes to a system temp directory (`os.tmpdir()`/`$TMPDIR`, `/tmp`, `/var/tmp`) outside the project tree are always allowed, so an agent can stage a draft and persist it through the sanctioned CLI (`gjc deep-interview --write --spec <temp-path>`, `gjc ralplan --write --artifact <temp-path>`). The `.gjc/**` block is unchanged. Each planning skill now emits its own block message.
+- Made the reconciled mutation guard skill-transition/return safe by keying the block off the single canonical *current* workflow skill (the resolved top-level `skill` the HUD and skill-tool chain guard already use) instead of independently scanning every skill. Phase semantics now match the manifest and the Stop hook's `STOP_RELEASING_PHASES`: `handoff` and ralplan's pre-approval `final` keep blocking for `deep-interview`/`ralplan` (until the skill is demoted or cleared), executor phases (`ultragoal` `pending`/`active`/`blocked`) release, and a missing/corrupt mode-state still fails open. As a result a handoff (e.g. ralplan → ultragoal) never lets a stale planning entry block the executor, and a return (e.g. re-entering ralplan/deep-interview after a goal completes) reliably re-blocks.
+- Hardened the reconciled guard after architect + red-team review: the `gjc …` bash fast-path no longer skips scanning for compound/redirected/multiline commands (`gjc …; tee src/x`, `gjc … && echo x > .gjc/state/foo`, and newline-separated `gjc …\ntouch src/x` are now caught); the current-skill resolver prefers the most-recently-updated active entry so a stale planning row can never block a newer executor; neutral-temp classification canonicalizes paths (realpath of the nearest existing ancestor) so a `/tmp` symlink or macOS `/tmp`→`/private/tmp` alias pointing back into the project/`.gjc` is blocked; the deferred `ast_edit` apply path now mirrors the always-on `.gjc/**` block; and a heredoc delimiter (`<<EOF`) is no longer mis-read as a write target. Bash mutation detection remains best-effort defense-in-depth (the authoritative guard is the fully-pathed `write`/`edit`/`ast_edit` tools). Added generic guard exports (`getWorkflowMutationDecision`/`assertWorkflowMutationAllowed`/`assertWorkflowMutationRawPathsAllowed`) used by the session and `ast_edit` callers, with the `*DeepInterview*` names retained as compatibility aliases.
+- The published `@gajae-code/coding-agent` npm package now ships a prebuilt **minified** `dist/cli.js` (built with `bun build --minify`, not `--compile`) as the CLI entrypoint; the native addon and the stats/browser/eval worker entrypoints are emitted as externals so the bundle loads them from `node_modules` at runtime, and release compiled binaries also gain `--minify`. Measured `gjc --help` RSS dropped from ~302MB (running from source) to ~120MB (#879, #881).
+- Lazy-loaded the `eval` tool and its Python-kernel backend via dynamic import, so the kernel and its dependencies are no longer eagerly imported at startup and load only when the `eval` tool actually runs (#879).
+- `rust-analyzer` is now treated as an optional LSP server: its startup failure no longer raises a startup warning (it is auto-installed lazily on demand), while non-optional LSP server startup failures still warn (#872).
+
+### Fixed
+
+- Fixed planning-pipeline stage precedence so activating a downstream stage (`deep-interview → ralplan → ultragoal`) supersedes upstream stages by pipeline rank, preventing a stale upstream row from continuing to own the HUD, mutation gate, or primary active-state snapshot (#878).
+- Made `gjc state doctor` resolve the session id like every other state command (explicit `--session-id`, then payload `session_id`, then the `GJC_SESSION_ID` env var set for agent-initiated invocations), so it inspects the caller's session-scoped state files instead of a default location (#880).
+- Fixed a second workspace-relative import that the 0.6.0 #867 fix missed: `edit-mode.ts` now imports `$env` through the `@gajae-code/utils` package boundary instead of `../../../utils/src/env`, so global Bun installs no longer crash resolving edit mode, with package-boundary regression coverage (#868).
+
 ## [0.6.1] - 2026-06-18
 
 ### Fixed
 
 - Fixed the `computer` tool (and any other `z.union`/discriminated-union tool) shipping a bare top-level `anyOf`/`oneOf`/`allOf` `input_schema` root that strict providers (Amazon Bedrock Converse incl. Kiro/CodeWhisperer relays, OpenAI strict mode, Gemini) reject. Tool schema roots are now flattened to a single `type: "object"` across all providers via the shared `flattenToolRootCombinators`. See `@gajae-code/ai` 0.6.1.
+- `gjc update` now runs the freshly installed `gjc --smoke-test` after version verification and tells users to restart running sessions, surfacing stale or partial runtime updates such as native-addon release mismatches immediately.
 
 ## [0.6.0] - 2026-06-18
 ### Added
@@ -14,6 +67,7 @@
 - Exposed the existing goal-pause capability through the `goal` tool as `goal({op:"pause"})`. The runtime `pauseGoal()` method and `paused` status already existed and were reachable via the `/goal pause` slash command and the goal menu, but the agent-facing `goal` tool only enumerated `create | get | complete | resume | drop` — so an agent could not park a goal whose remaining work was blocked on human input. It was forced to either `drop` (clearing the goal) or leave the goal `active`, which re-fired the hidden autonomous-continuation steer every turn with no exit condition. `pause` reuses the existing `paused` status and continuation gate (`buildContinuationPrompt` already returns `undefined` when `enabled=false`), parks the goal without dropping it, persists as `goal_paused`, and is resumable via the existing `resume` op. The active-goal and continuation prompts now instruct the agent to pause when every outstanding deliverable is genuinely human-blocked. `pauseGoal()` now rejects any goal whose status is not `active`, so a completed or dropped goal cannot be driven into a paused-mode lifecycle when paused through the tool.
 
 ### Fixed
+- Fixed global Bun installs crashing during interactive startup when edit-mode resolution followed a workspace-relative `packages/utils/src` import that is absent from the published package layout; coding-agent now imports `$env` through the `@gajae-code/utils` package boundary and has regression coverage for sibling workspace source imports (#867).
 
 - Restored steer-by-default while the agent is busy: `busyPromptMode` now defaults to `steer`, so Enter on a normal prompt interrupts the active turn. Queueing for the next turn is reserved for the explicit Ctrl+Enter follow-up keystroke (or `busyPromptMode: "queue"`); existing steer/cancel plus explicit queue/dequeue controls remain separate (#829).
 - Fixed `gjc rlm "<question>"` consuming the seeded question as a one-shot autonomous run that exited immediately; a seeded prompt now lands in the interactive composer so the research session stays interactive.

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/cli/update-cli.d.ts

@@ -3,6 +3,8 @@ export interface InstalledVersionVerification {
     ok: boolean;
     actual?: string;
     path?: string;
+    smokeTestFailed?: boolean;
+    smokeTestOutput?: string;
 }
 /** Paths and verifier used while replacing a downloaded binary update. */
 export interface BinaryReplacementOptions {
@@ -24,6 +26,7 @@ export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: s
 export declare function formatBinaryDownloadFailureMessageForTest(binaryName: string, url: string, status: string | number, platform?: NodeJS.Platform): string;
 export declare function buildReleaseBinaryUrlForTest(version: string, platform?: NodeJS.Platform, arch?: string): string;
 export declare function formatManualUpdateInstructionsForTest(platform?: NodeJS.Platform): string;
+export declare function formatVerificationFailureForTest(result: InstalledVersionVerification, expectedVersion: string): string;
 /**
  * Atomically replace the installed binary and roll back if version verification fails.
  */

package/dist/types/config/model-registry.d.ts

@@ -51,6 +51,7 @@ export declare const ModelsConfigFile: ConfigFile<{
         compat?: {
             supportsStore?: boolean | undefined;
             supportsDeveloperRole?: boolean | undefined;
+            sendSessionHeaders?: boolean | undefined;
             supportsMultipleSystemMessages?: boolean | undefined;
             supportsReasoningEffort?: boolean | undefined;
             reasoningEffortMap?: {
@@ -129,6 +130,7 @@ export declare const ModelsConfigFile: ConfigFile<{
             compat?: {
                 supportsStore?: boolean | undefined;
                 supportsDeveloperRole?: boolean | undefined;
+                sendSessionHeaders?: boolean | undefined;
                 supportsMultipleSystemMessages?: boolean | undefined;
                 supportsReasoningEffort?: boolean | undefined;
                 reasoningEffortMap?: {
@@ -202,6 +204,7 @@ export declare const ModelsConfigFile: ConfigFile<{
             compat?: {
                 supportsStore?: boolean | undefined;
                 supportsDeveloperRole?: boolean | undefined;
+                sendSessionHeaders?: boolean | undefined;
                 supportsMultipleSystemMessages?: boolean | undefined;
                 supportsReasoningEffort?: boolean | undefined;
                 reasoningEffortMap?: {

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

@@ -2,6 +2,7 @@ import * as z from "zod/v4";
 export declare const OpenAICompatSchema: z.ZodObject<{
     supportsStore: z.ZodOptional<z.ZodBoolean>;
     supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
+    sendSessionHeaders: z.ZodOptional<z.ZodBoolean>;
     supportsMultipleSystemMessages: z.ZodOptional<z.ZodBoolean>;
     supportsReasoningEffort: z.ZodOptional<z.ZodBoolean>;
     reasoningEffortMap: z.ZodOptional<z.ZodObject<{
@@ -163,6 +164,7 @@ export declare const ModelOverrideSchema: z.ZodObject<{
     compat: z.ZodOptional<z.ZodObject<{
         supportsStore: z.ZodOptional<z.ZodBoolean>;
         supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
+        sendSessionHeaders: z.ZodOptional<z.ZodBoolean>;
         supportsMultipleSystemMessages: z.ZodOptional<z.ZodBoolean>;
         supportsReasoningEffort: z.ZodOptional<z.ZodBoolean>;
         reasoningEffortMap: z.ZodOptional<z.ZodObject<{
@@ -276,6 +278,7 @@ export declare const ModelsConfigSchema: z.ZodObject<{
         compat: z.ZodOptional<z.ZodObject<{
             supportsStore: z.ZodOptional<z.ZodBoolean>;
             supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
+            sendSessionHeaders: z.ZodOptional<z.ZodBoolean>;
             supportsMultipleSystemMessages: z.ZodOptional<z.ZodBoolean>;
             supportsReasoningEffort: z.ZodOptional<z.ZodBoolean>;
             reasoningEffortMap: z.ZodOptional<z.ZodObject<{
@@ -442,6 +445,7 @@ export declare const ModelsConfigSchema: z.ZodObject<{
             compat: z.ZodOptional<z.ZodObject<{
                 supportsStore: z.ZodOptional<z.ZodBoolean>;
                 supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
+                sendSessionHeaders: z.ZodOptional<z.ZodBoolean>;
                 supportsMultipleSystemMessages: z.ZodOptional<z.ZodBoolean>;
                 supportsReasoningEffort: z.ZodOptional<z.ZodBoolean>;
                 reasoningEffortMap: z.ZodOptional<z.ZodObject<{
@@ -582,6 +586,7 @@ export declare const ModelsConfigSchema: z.ZodObject<{
             compat: z.ZodOptional<z.ZodObject<{
                 supportsStore: z.ZodOptional<z.ZodBoolean>;
                 supportsDeveloperRole: z.ZodOptional<z.ZodBoolean>;
+                sendSessionHeaders: z.ZodOptional<z.ZodBoolean>;
                 supportsMultipleSystemMessages: z.ZodOptional<z.ZodBoolean>;
                 supportsReasoningEffort: z.ZodOptional<z.ZodBoolean>;
                 reasoningEffortMap: z.ZodOptional<z.ZodObject<{

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/lsp/startup-events.d.ts

@@ -9,3 +9,4 @@ export type LspStartupEvent = {
     type: "failed";
     error: string;
 };
+export declare function getLspStartupWarningMessage(event: LspStartupEvent): string | null;

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/dist/types/skill-state/deep-interview-mutation-guard.d.ts

@@ -1,6 +1,8 @@
 import type { AgentTool } from "@gajae-code/agent-core";
 export declare const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE = "Deep-interview phase boundary: continue gathering context/questions/risks and emit a handoff/spec before code edits. Mutation tools and patch execution are blocked while deep-interview is active; finalize specs through `gjc deep-interview --write --stage final` or hand off to an execution phase.";
 export declare const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE = ".gjc workflow state and artifacts are runtime-owned. Agent mutation tools cannot edit `.gjc/**`; use the sanctioned `gjc` CLI instead.";
+export declare const RALPLAN_MUTATION_BLOCK_MESSAGE = "Ralplan planning phase boundary: keep refining the consensus plan and persist plan artifacts through `gjc ralplan --write` (stage scratch files under a temp dir if needed). Product-code mutation tools and patch execution are blocked while ralplan is active; mutate only after the plan is approved and execution begins.";
+export declare const ULTRAGOAL_GOAL_PLANNING_MUTATION_BLOCK_MESSAGE = "Ultragoal goal-planning phase boundary: finish goal planning and record goals through `gjc ultragoal` before editing code. Product-code mutation tools and patch execution are blocked until goal planning completes and execution begins.";
 type ToolWithEditMode = AgentTool & {
     mode?: unknown;
     customWireName?: unknown;
@@ -30,4 +32,7 @@ export declare function assertDeepInterviewMutationRawPathsAllowed(input: {
 }): Promise<void>;
 export declare function getDeepInterviewMutationDecision(input: DeepInterviewMutationGuardInput): Promise<DeepInterviewMutationDecision>;
 export declare function assertDeepInterviewMutationAllowed(input: DeepInterviewMutationGuardInput): Promise<void>;
+export declare const getWorkflowMutationDecision: typeof getDeepInterviewMutationDecision;
+export declare const assertWorkflowMutationAllowed: typeof assertDeepInterviewMutationAllowed;
+export declare const assertWorkflowMutationRawPathsAllowed: typeof assertDeepInterviewMutationRawPathsAllowed;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.6.1",
+	"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.1",
-		"@gajae-code/agent-core": "0.6.1",
-		"@gajae-code/ai": "0.6.1",
-		"@gajae-code/natives": "0.6.1",
-		"@gajae-code/tui": "0.6.1",
-		"@gajae-code/utils": "0.6.1",
+		"@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/scripts/build-binary.ts

@@ -5,12 +5,6 @@ import * as path from "node:path";
 const packageDir = path.join(import.meta.dir, "..");
 const outputPath = path.join(packageDir, "dist", "gjc");
 const nativeDir = path.join(packageDir, "..", "natives", "native");
-// Lazy native tokenizer entrypoint. `agent-core/compaction` loads this from
-// the explicit native entrypoint instead of a package-name dynamic require of
-// `@gajae-code/natives`, because those fail inside Bun standalone `$bunfs`.
-// Listing the module here makes the absolute target path exist in the compiled
-// bunfs.
-const nativeTokenizerEntrypoint = "../natives/native/index.js";
 
 function shouldAdhocSignDarwinBinary(): boolean {
 	return process.platform === "darwin";
@@ -72,7 +66,6 @@ async function main(): Promise<void> {
 					"../stats/src/sync-worker.ts",
 					"./src/tools/browser/tab-worker-entry.ts",
 					"./src/eval/js/worker-entry.ts",
-					nativeTokenizerEntrypoint,
 					"--outfile",
 					"dist/gjc",
 				],

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/cli/update-cli.ts

@@ -25,6 +25,8 @@ export interface InstalledVersionVerification {
 	ok: boolean;
 	actual?: string;
 	path?: string;
+	smokeTestFailed?: boolean;
+	smokeTestOutput?: string;
 }
 
 /** Paths and verifier used while replacing a downloaded binary update. */
@@ -226,6 +228,36 @@ async function verifyInstalledVersion(expectedVersion: string): Promise<Installe
 	}
 }
 
+async function verifyInstalledRuntime(expectedVersion: string): Promise<InstalledVersionVerification> {
+	const versionResult = await verifyInstalledVersion(expectedVersion);
+	if (!versionResult.ok || !versionResult.path) {
+		return versionResult;
+	}
+	try {
+		const smokeResult = await $`${versionResult.path} --smoke-test`.quiet().nothrow();
+		if (smokeResult.exitCode === 0) {
+			return versionResult;
+		}
+		return {
+			...versionResult,
+			ok: false,
+			smokeTestFailed: true,
+			smokeTestOutput: smokeResult.text().trim(),
+		};
+	} catch (error) {
+		return {
+			...versionResult,
+			ok: false,
+			smokeTestFailed: true,
+			smokeTestOutput: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+function printRestartGuidance(): void {
+	console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
+}
+
 function printVerifiedVersion(expectedVersion: string): void {
 	console.log(chalk.green(`\n${theme.status.success} Updated to ${expectedVersion}`));
 }
@@ -289,20 +321,38 @@ export function formatManualUpdateInstructionsForTest(platform: NodeJS.Platform
 	return formatManualUpdateInstructions(platform);
 }
 
+function normalizeVerificationOutput(output: string | undefined): string {
+	return output?.replace(/\s+/g, " ").trim() ?? "";
+}
+
 function formatVerificationFailure(result: InstalledVersionVerification, expectedVersion: string): string {
+	if (result.smokeTestFailed) {
+		const output = normalizeVerificationOutput(result.smokeTestOutput);
+		const outputSuffix = output ? `: ${output}` : "";
+		const pathSuffix = result.path ? ` at ${result.path}` : "";
+		return `${APP_NAME}${pathSuffix} reports ${result.actual ?? expectedVersion}, but --smoke-test failed${outputSuffix}. Close running ${APP_NAME} sessions and reinstall to repair a stale or partial update.`;
+	}
 	if (result.actual) {
 		return `${APP_NAME} at ${result.path} still reports ${result.actual} (expected ${expectedVersion})`;
 	}
 	return `could not verify updated version${result.path ? ` at ${result.path}` : ""}`;
 }
 
+export function formatVerificationFailureForTest(
+	result: InstalledVersionVerification,
+	expectedVersion: string,
+): string {
+	return formatVerificationFailure(result, expectedVersion);
+}
+
 /**
  * Print post-update verification result.
  */
 async function printVerification(expectedVersion: string): Promise<void> {
-	const result = await verifyInstalledVersion(expectedVersion);
+	const result = await verifyInstalledRuntime(expectedVersion);
 	if (result.ok) {
 		printVerifiedVersion(expectedVersion);
+		printRestartGuidance();
 		return;
 	}
 	console.log(chalk.yellow(`\nWarning: ${formatVerificationFailure(result, expectedVersion)}`));
@@ -385,10 +435,10 @@ async function updateViaBinaryAt(targetPath: string, expectedVersion: string): P
 		tempPath,
 		backupPath,
 		expectedVersion,
-		verifyInstalledVersion,
+		verifyInstalledVersion: verifyInstalledRuntime,
 	});
 	printVerifiedVersion(expectedVersion);
-	console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
+	printRestartGuidance();
 }
 
 /**

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/models-config-schema.ts

@@ -22,6 +22,7 @@ const ReasoningEffortMapSchema = z.object({
 export const OpenAICompatSchema = z.object({
 	supportsStore: z.boolean().optional(),
 	supportsDeveloperRole: z.boolean().optional(),
+	sendSessionHeaders: z.boolean().optional(),
 	supportsMultipleSystemMessages: z.boolean().optional(),
 	supportsReasoningEffort: z.boolean().optional(),
 	reasoningEffortMap: ReasoningEffortMapSchema.optional(),