@gajae-code/coding-agent 0.6.0 → 0.6.3

package/CHANGELOG.md

@@ -2,12 +2,44 @@
 
 ## [Unreleased]
 
+## [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
 
 - 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/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/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/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.0",
+	"version": "0.6.3",
 	"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.0",
-		"@gajae-code/agent-core": "0.6.0",
-		"@gajae-code/ai": "0.6.0",
-		"@gajae-code/natives": "0.6.0",
-		"@gajae-code/tui": "0.6.0",
-		"@gajae-code/utils": "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",
 		"@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/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/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(),

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