@gajae-code/coding-agent 0.11.1 → 0.11.2

package/src/debug/index.ts

@@ -443,7 +443,7 @@ export class DebugSelectorComponent extends Container {
 		return {
 			model: this.ctx.session.model?.id,
 			thinkingLevel: this.ctx.session.thinkingLevel,
-			planModeEnabled: this.ctx.planModeEnabled,
+			planModeEnabled: this.ctx.planModeController.enabled,
 			toolOutputExpanded: this.ctx.toolOutputExpanded,
 			hideThinkingBlock: this.ctx.hideThinkingBlock,
 		};

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

@@ -248,11 +248,19 @@ I'm reading this as {N} top-level component(s):
 1. {component_name}: {one_sentence_description}
 2. ...
 
-Is that topology right? Should any component be added, removed, merged, split, or explicitly deferred?
+Locked intent:
+- Artifacts: {category-prefixed IDs and concrete outputs}
+- Surfaces: {category-prefixed IDs and user-visible surfaces}
+- Integrations: {category-prefixed IDs and external/system boundaries}
+- Constraints: {category-prefixed IDs and user-locked constraints}
+
+Is that topology and locked intent right? Should any component or intent be added, removed, merged, split, or explicitly deferred?
 ```
 
 Options should include contextually relevant choices such as **Looks right**, **Add/remove/merge components**, **Defer one or more components**, plus free-text, translated/localized according to `language.instruction` when present. This is the only pre-scoring question and preserves the one-question-per-round rule.
 
+The Round 0 `ask` call MUST include `deepInterview.round = 0`, `deepInterview.component = "review-topology"`, `deepInterview.dimension = "topology"`, `deepInterview.intent_contract.items` containing the exact displayed locked-intent items, and `deepInterview.intent_contract.confirmation_options` listing only the displayed affirmative labels that lock the proposal (normally **Looks right**). The runtime recorder canonicalizes and locks this contract only when the user selects one of those labels; correction, deferral, free-text, and clarification answers never lock the pre-question proposal. Do not manually copy raw free text into intent evidence, and do not continue if this required recorder write fails.
+
 3. **Lock topology into state** after the answer. Store a normalized component list and confirmation timestamp:
 
 ```json
@@ -288,6 +296,10 @@ Options should include contextually relevant choices such as **Looks right**, **
 }
 ```
 
+In the same Round 0 answer, the runtime recorder persists `state.intent_contract` version 1 from `deepInterview.intent_contract.items`. It contains the four exact categories `artifact`, `surface`, `integration`, and `constraint`; every item has a unique category-prefixed ID (for example `surface:review`) and a bounded non-empty statement. The recorder canonically sorts items, persists the full SHA-256 manifest digest, and binds confirmation to a redacted answer-hash reference. The confirmation answer locks this manifest before Round 1; later prose, inferred implementation detail, raw answer content, or a regenerated digest cannot replace it.
+
+Before spec persistence, include every preserved locked ID literally in the final spec. Additions and clarifications need no extra question; the runtime derives and persists a `not_required` review when every locked ID remains. For any proposed missing locked ID, ask one intent-review question through `ask` and include `deepInterview.intent_review` with the proposed `observed_items`, every `supporting_substitution`, and the exact `approval_options` labels that count as approval. The runtime recorder writes `pending` when the user does not approve and writes `approved` only when an approval option is selected, binding the review to the recorder-generated answer hash without storing raw answer text. Approved reductions require every removed ID to map to an observed replacement ID. Spec persistence and handoff fail closed for missing, pending, malformed, stale, or unrecorded reduction review evidence. Intent review approves only that output reduction and never authorizes execution or ralplan handoff.
+
 4. **Legacy state migration:** When resuming an existing `deep-interview` state file that lacks `topology`, treat it as `"status": "legacy_missing"`. If no final `spec_path` exists yet, run Round 0 before the next ambiguity scoring pass and then continue with the existing transcript. If a final spec already exists, do not rewrite history; note in any handoff that topology was not captured for that legacy interview.
 
 5. **Single-component pass-through:** If the user confirms one active component, Phase 2 proceeds with the existing flow while still carrying `topology.components[0]` into scoring and spec output.

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

@@ -203,6 +203,22 @@ sleep 30 && gjc team monitor <team-name>
 ```
 The mutating monitor path also performs bounded liveness recovery: expired task claims, stale heartbeat claims, and missing recorded worker panes are requeued instead of leaving work permanently `in_progress`.
 
+### Opt-in stalled-worker continuation
+
+`GJC_TEAM_AUTO_CONTINUE_STALLED_WORKERS=1` enables a separate, default-off monitor-only nudge for a stalled live worker. It is considered only when the team is running (not dry-run), the worker heartbeat is stale (using `GJC_TEAM_HEARTBEAT_STALE_MS`, default `120000` ms), and all of these checks pass:
+
+- The recorded pane id is a non-leader `%<number>` pane that tmux currently reports in the recorded `tmux_target` as that same pane id; no other pane is targeted.
+- Shutdown authority is proven absent; valid-present and invalid/unreadable records veto continuation without suppressing normal stale-claim recovery.
+- Lifecycle is `ready` or `working`, and worker status is a structurally valid non-terminal state (not `draining`, `failed`, or `unknown`).
+- One current non-terminal task is `in_progress`, assigned to and claimed by that worker; the stored claim record exactly matches its owner, token, and lease.
+- The lease remains valid through the entire next hold interval.
+
+The policy has at most two attempts per immutable incident: attempt 1 reserves a 30-second hold, then attempt 2 reserves a 120-second hold only after attempt 1 was recorded as sent and its hold elapsed. A retry still requires the heartbeat to be stale and every fence above to pass. Reservations and outcomes are create-without-clobber journal records keyed to the incident identity; a pre-existing reservation, an unknown/missing/non-sent outcome after restart, or a second-attempt record fails closed rather than sending again.
+
+Each eligible attempt sends only the fixed continuation prompt to that verified recorded worker pane, followed by Enter. It does not replay provider output or a prior prompt, inspect or inject dynamic pane content, cross pane boundaries, kill or relaunch workers, create/split panes, or extend/rewrite claims. This bounded nudge is not automatic recovery for a dead, shutdown, reassigned, terminal, or lease-expired worker. When it cannot act, use `gjc team status <team-name>` / `gjc team monitor <team-name>` and the documented state evidence; manual pane intervention remains the last-resort fallback.
+
+Continuation input is unsupported on psmux and native Windows send-keys fallback transports: the fixed prompt is not dispatched there because equivalent literal-input semantics are not proven. Startup's existing empty-pane worker command fallback is separate and unchanged.
+
 ## Operational Commands
 
 ```bash

package/src/discovery/helpers.ts

@@ -20,8 +20,6 @@ import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 import type { ForkContextPolicy } from "../task/types";
 import { parseThinkingLevel } from "../thinking";
 
-import { buildPluginDirRoot } from "./plugin-dir-roots";
-
 /**
  * Standard paths for each config source.
  */
@@ -900,14 +898,6 @@ export async function listClaudePluginRoots(
 		roots.push(...projectRoots, ...deduped);
 	}
 
-	// Merge --plugin-dir roots (highest precedence) on every fresh load
-	if (injectedPluginDirRoots.length > 0) {
-		const injectedIds = new Set(injectedPluginDirRoots.map(r => r.id));
-		const filtered = roots.filter(r => !injectedIds.has(r.id));
-		roots.length = 0;
-		roots.push(...injectedPluginDirRoots, ...filtered);
-	}
-
 	const result = { roots, warnings };
 	pluginRootsCache.set(cacheKey, result);
 	return result;
@@ -918,7 +908,7 @@ export async function listClaudePluginRoots(
  */
 export function clearClaudePluginRootsCache(): void {
 	pluginRootsCache.clear();
-	preloadedPluginRoots = [...injectedPluginDirRoots];
+	preloadedPluginRoots = [];
 	// Re-warm preloaded roots asynchronously so sync LSP config reads stay valid
 	if (lastPreloadHome) {
 		void preloadPluginRoots(lastPreloadHome, getProjectDir());
@@ -941,7 +931,6 @@ export function clearPluginRootsAndCaches(extraPaths?: readonly string[]): void
 // getPreloadedPluginRoots(). Safe degradation: empty array if not warmed.
 
 let preloadedPluginRoots: ClaudePluginRoot[] = [];
-let injectedPluginDirRoots: ClaudePluginRoot[] = [];
 let lastPreloadHome: string | undefined;
 
 /**
@@ -962,41 +951,3 @@ export async function preloadPluginRoots(home: string, cwd?: string): Promise<vo
 export function getPreloadedPluginRoots(): readonly ClaudePluginRoot[] {
 	return preloadedPluginRoots;
 }
-
-// ── --plugin-dir injection ──────────────────────────────────────────────────
-
-/**
- * Inject synthetic plugin roots from --plugin-dir paths.
- * These are prepended to the cache with highest precedence (before GJC/Anthropic model entries).
- * Must be called before any listAnthropic modelPluginRoots() access.
- */
-export async function injectPluginDirRoots(home: string, dirs: string[], cwd?: string): Promise<void> {
-	const injected: ClaudePluginRoot[] = [];
-	for (const dir of dirs) {
-		const resolved = path.resolve(dir);
-		// Read plugin name from manifest
-		let pluginName = path.basename(resolved);
-		try {
-			const manifestPath = path.join(resolved, ".claude-plugin", "plugin.json");
-			const content = await Bun.file(manifestPath).text();
-			const manifest = JSON.parse(content);
-			if (typeof manifest.name === "string" && manifest.name) {
-				pluginName = manifest.name;
-			}
-		} catch {
-			// No manifest or invalid — use directory name
-		}
-
-		injected.push(buildPluginDirRoot(resolved, pluginName));
-	}
-
-	// Set injected roots BEFORE populating cache so listAnthropic modelPluginRoots merges them.
-	injectedPluginDirRoots = injected;
-	lastPreloadHome = home; // ensure cache-clear re-warm fires even when injectPluginDirRoots was the startup path
-	// Clear any stale cache entries (populated before injected roots were set).
-	pluginRootsCache.clear();
-	// Rebuild — cache miss triggers fresh load that includes both user+project registries
-	// and prepends injectedPluginDirRoots at highest precedence.
-	const { roots } = await listClaudePluginRoots(home, cwd);
-	preloadedPluginRoots = roots;
-}

package/src/edit/index.ts

@@ -57,6 +57,69 @@ type VimParams = z.infer<typeof vimSchema>;
 type EditParams = ReplaceParams | PatchParams | HashlineParams | VimParams | ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;
 
+const UNSAFE_EDIT_SUMMARY_PATH =
+	/(?:\b(?:https?|wss?):\/\/|\b(?:api[-_ ]?key|access[-_ ]?token|bearer|secret|password)\b|\b(?:sk|pk|rk)-[A-Za-z0-9_-]{12,})/i;
+
+const MAX_APPLY_PATCH_ACTIVITY_FILES = 2;
+
+function isSafeEditSummaryPath(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0 && value.length <= 100 && !UNSAFE_EDIT_SUMMARY_PATH.test(value);
+}
+
+/** Summarize only apply_patch file-operation headers, never its patch body. */
+function summarizeApplyPatchActivity(input: string): string | undefined {
+	if (!input.trimStart().startsWith("*** Begin Patch")) return undefined;
+
+	const paths: string[] = [];
+	const marker = /^\*\*\* (?:Add|Delete|Update) File: ([^\r\n]+)\r?$/gm;
+	let count = 0;
+	let match = marker.exec(input);
+	while (match !== null) {
+		const editPath = match[1]!.trim();
+		if (!isSafeEditSummaryPath(editPath)) return undefined;
+		count++;
+		if (paths.length < MAX_APPLY_PATCH_ACTIVITY_FILES) paths.push(editPath);
+		match = marker.exec(input);
+	}
+	if (count === 0) return undefined;
+
+	const displayedPaths =
+		count > MAX_APPLY_PATCH_ACTIVITY_FILES ? `${paths.join(", ")}, +${count - paths.length} more` : paths.join(", ");
+	return `${displayedPaths}, ${count} edit${count === 1 ? "" : "s"}`;
+}
+
+/** Project edit targets and operation counts without exposing patches, diffs, or file contents. */
+export function summarizeEditToolActivity(kind: "args" | "result", value: unknown): string | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	if (kind === "args") {
+		const applyPatchInput = record.input;
+		if (typeof applyPatchInput === "string") return summarizeApplyPatchActivity(applyPatchInput);
+
+		const editPath = record.path;
+		if (!isSafeEditSummaryPath(editPath)) return undefined;
+		const edits = record.edits;
+		const count = Array.isArray(edits) ? edits.length : 1;
+		return `${editPath}, ${count} edit${count === 1 ? "" : "s"}`;
+	}
+
+	const details = record.details;
+	if (!details || typeof details !== "object" || Array.isArray(details)) return undefined;
+	const perFileResults = (details as Record<string, unknown>).perFileResults;
+	const count = Array.isArray(perFileResults)
+		? perFileResults.length
+		: "path" in (details as Record<string, unknown>)
+			? 1
+			: 0;
+	if (count === 0) return undefined;
+	const failed =
+		record.isError === true ||
+		(Array.isArray(perFileResults) &&
+			perFileResults.some(
+				entry => typeof entry === "object" && entry !== null && (entry as Record<string, unknown>).isError === true,
+			));
+	return `${failed ? "failed" : "applied"}, ${count} file${count === 1 ? "" : "s"}`;
+}
 type EditModeDefinition = {
 	description: (session: ToolSession) => string;
 	parameters: TInput;
@@ -279,6 +342,7 @@ export class EditTool implements AgentTool<TInput> {
 	readonly nonAbortable = true;
 	readonly concurrency = "exclusive";
 	readonly strict = true;
+	readonly safeSummary = summarizeEditToolActivity;
 
 	readonly #allowFuzzy: boolean;
 	readonly #fuzzyThreshold: number;

package/src/eval/py/env.ts

@@ -0,0 +1,26 @@
+/** Environment values consulted by the Python subprocess integration. */
+export type PythonEnv = Record<string, string | undefined>;
+
+const PYTHON_TRUTHY = new Set(["1", "true", "yes", "on", "y"]);
+
+/** True when `value` is a non-empty string matching a truthy boolean token. */
+export function isTruthyPythonFlag(value: string | undefined): boolean {
+	return value !== undefined && PYTHON_TRUTHY.has(value.trim().toLowerCase());
+}
+
+/** Resolve paired GJC/legacy PI flags using OR semantics. */
+export function resolvePythonFlag(env: PythonEnv, gjcName: string, piName: string): boolean {
+	return isTruthyPythonFlag(env[gjcName]) || isTruthyPythonFlag(env[piName]);
+}
+
+export function resolvePythonSkipCheck(env: PythonEnv): boolean {
+	return resolvePythonFlag(env, "GJC_PYTHON_SKIP_CHECK", "PI_PYTHON_SKIP_CHECK");
+}
+
+export function resolvePythonIpcTrace(env: PythonEnv): boolean {
+	return resolvePythonFlag(env, "GJC_PYTHON_IPC_TRACE", "PI_PYTHON_IPC_TRACE");
+}
+
+export function resolvePythonIntegrationGate(env: PythonEnv): boolean {
+	return resolvePythonFlag(env, "GJC_PYTHON_INTEGRATION", "PI_PYTHON_INTEGRATION");
+}

package/src/eval/py/kernel.ts

@@ -11,11 +11,12 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { $flag, isBunTestRuntime, logger, Snowflake } from "@gajae-code/utils";
+import { $env, isBunTestRuntime, logger, Snowflake } from "@gajae-code/utils";
 import type { Subprocess } from "bun";
 import { $ } from "bun";
 import { Settings } from "../../config/settings";
 import { type KernelDisplayOutput, renderKernelDisplay } from "./display";
+import { resolvePythonIpcTrace, resolvePythonSkipCheck } from "./env";
 import { PYTHON_PRELUDE } from "./prelude";
 import RUNNER_SCRIPT from "./runner.py" with { type: "text" };
 import { ensurePythonRuntime, filterEnv, type PythonRuntimeOptions } from "./runtime";
@@ -23,7 +24,8 @@ import { ensurePythonRuntime, filterEnv, type PythonRuntimeOptions } from "./run
 export type { KernelDisplayOutput, PythonStatusEvent } from "./display";
 export { renderKernelDisplay } from "./display";
 
-const TRACE_IPC = $flag("PI_PYTHON_IPC_TRACE");
+// Dual-read: `GJC_PYTHON_IPC_TRACE` is preferred, then legacy `PI_PYTHON_IPC_TRACE`.
+const TRACE_IPC = resolvePythonIpcTrace($env);
 
 // Cache the runner script on disk so the subprocess loads it normally. Cached
 // per script hash so installs don't race across versions.
@@ -125,7 +127,7 @@ export async function checkPythonKernelAvailability(
 	cwd: string,
 	runtimeOptions?: PythonRuntimeOptions,
 ): Promise<PythonKernelAvailability> {
-	if (isBunTestRuntime() || $flag("PI_PYTHON_SKIP_CHECK")) {
+	if (isBunTestRuntime() || resolvePythonSkipCheck($env)) {
 		return { ok: true };
 	}
 	try {

package/src/extensibility/extensions/loader.ts

@@ -5,7 +5,7 @@ import type * as fs1 from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { ThinkingLevel } from "@gajae-code/agent-core";
-import type { ImageContent, Model, TextContent, UsageReport } from "@gajae-code/ai";
+import type { ImageContent, Model, TextContent, Tool, UsageReport } from "@gajae-code/ai";
 import type { KeyId } from "@gajae-code/tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@gajae-code/utils";
 import * as Zod from "zod/v4";
@@ -82,6 +82,10 @@ export class ExtensionRuntime implements IExtensionRuntime {
 		throw new ExtensionRuntimeNotInitializedError();
 	}
 
+	resolveTool(): Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined {
+		throw new ExtensionRuntimeNotInitializedError();
+	}
+
 	setActiveTools(): Promise<void> {
 		throw new ExtensionRuntimeNotInitializedError();
 	}
@@ -257,6 +261,10 @@ class ConcreteExtensionAPI implements ExtensionAPI, IExtensionRuntime {
 		return this.runtime.getAllTools();
 	}
 
+	resolveTool(name: string): Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined {
+		return this.runtime.resolveTool(name);
+	}
+
 	setActiveTools(toolNames: string[]): Promise<void> {
 		return this.runtime.setActiveTools(toolNames);
 	}

package/src/extensibility/extensions/runner.ts

@@ -8,7 +8,7 @@ import { logger } from "@gajae-code/utils";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/workflow-gate-broker";
 import { type Theme, theme } from "../../modes/theme/theme";
-import type { SessionManager } from "../../session/session-manager";
+import { createReadonlySessionManager, type SessionManager } from "../../session/session-manager";
 import type {
 	AfterProviderResponseEvent,
 	BeforeAgentStartEvent,
@@ -199,6 +199,7 @@ export class ExtensionRunner {
 	#getQueuedMessagesFn: ExtensionContext["getQueuedMessages"] = () => [];
 	#getActiveToolsFn: ExtensionContext["getActiveTools"] = () => [];
 	#getAllToolsFn: ExtensionContext["getAllTools"] = () => [];
+	#getResolveToolFn: ExtensionContext["resolveTool"] = () => undefined;
 	#cycleModelFn: ExtensionContextActions["cycleModel"] = undefined;
 	#cycleThinkingLevelFn: ExtensionContextActions["cycleThinkingLevel"] = undefined;
 	#setQueueModeFn: ExtensionContextActions["setQueueMode"] = undefined;
@@ -275,6 +276,7 @@ export class ExtensionRunner {
 		this.runtime.appendEntry = actions.appendEntry;
 		this.runtime.getActiveTools = actions.getActiveTools;
 		this.runtime.getAllTools = actions.getAllTools;
+		this.runtime.resolveTool = actions.resolveTool ?? (() => undefined);
 		this.runtime.setActiveTools = actions.setActiveTools;
 		this.runtime.getCommands = actions.getCommands;
 		this.runtime.setModel = actions.setModel;
@@ -309,6 +311,7 @@ export class ExtensionRunner {
 		this.#getQueuedMessagesFn = contextActions.getQueuedMessages ?? (() => []);
 		this.#getActiveToolsFn = contextActions.getActiveTools ?? (() => []);
 		this.#getAllToolsFn = contextActions.getAllTools ?? (() => []);
+		this.#getResolveToolFn = contextActions.resolveTool ?? (() => undefined);
 		this.#cycleModelFn = contextActions.cycleModel;
 		this.#cycleThinkingLevelFn = contextActions.cycleThinkingLevel;
 		this.#setQueueModeFn = contextActions.setQueueMode;
@@ -540,7 +543,7 @@ export class ExtensionRunner {
 			compact: instructionsOrOptions => this.#compactFn(instructionsOrOptions),
 			hasUI: this.hasUI(),
 			cwd: this.cwd,
-			sessionManager: this.sessionManager,
+			sessionManager: createReadonlySessionManager(this.sessionManager),
 			sessionMetadata: this.sessionMetadata,
 			modelRegistry: this.modelRegistry,
 			get model() {
@@ -557,6 +560,7 @@ export class ExtensionRunner {
 			getQueuedMessages: () => this.#getQueuedMessagesFn(),
 			getActiveTools: () => this.#getActiveToolsFn(),
 			getAllTools: () => this.#getAllToolsFn(),
+			resolveTool: name => this.#getResolveToolFn(name),
 			cycleModel: async () => await this.#cycleModelFn?.(),
 			cycleThinkingLevel: () => this.#cycleThinkingLevelFn?.(),
 			setQueueMode: (kind, mode) => this.#setQueueModeFn?.(kind, mode) ?? false,
@@ -678,7 +682,10 @@ export class ExtensionRunner {
 		}
 	}
 
-	async emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>> {
+	async emit<TEvent extends RunnerEmitEvent>(
+		event: TEvent,
+		continueWhile?: () => boolean,
+	): Promise<RunnerEmitResult<TEvent>> {
 		const handlers = this.#handlersByEvent.get(event.type) ?? [];
 		if (handlers.length === 0) return undefined as RunnerEmitResult<TEvent>;
 
@@ -686,7 +693,9 @@ export class ExtensionRunner {
 		let result: SessionBeforeEventResult | SessionCompactingResult | undefined;
 
 		for (const { ext, handler } of handlers) {
+			if (continueWhile && !continueWhile()) return result as RunnerEmitResult<TEvent>;
 			const handlerResult = await this.#runHandlerWithTimeout(handler, event, ctx, ext, extensionHandlerTimeoutMs);
+			if (continueWhile && !continueWhile()) return result as RunnerEmitResult<TEvent>;
 
 			if (this.#isSessionBeforeEvent(event) && handlerResult) {
 				result = handlerResult as SessionBeforeEventResult;

package/src/extensibility/extensions/types.ts

@@ -21,6 +21,7 @@ import type {
 	SimpleStreamOptions,
 	Static,
 	TextContent,
+	Tool,
 	TSchema,
 	UsageReport,
 } from "@gajae-code/ai";
@@ -271,7 +272,11 @@ export interface ExtensionUIContext {
 	/** Get current tool output expansion state. */
 	getToolsExpanded(): boolean;
 
-	/** Set tool output expansion state. */
+	/**
+	 * Set tool output expansion state. This is an explicit fold choice, pinning
+	 * existing tool and read components for their renderer instance lifetime,
+	 * the same as the user shortcut.
+	 */
 	setToolsExpanded(expanded: boolean): void;
 }
 
@@ -352,6 +357,8 @@ export interface ExtensionContext {
 	getQueuedMessages(): unknown[];
 	getActiveTools(): string[];
 	getAllTools(): string[];
+	/** Resolve display-safe metadata for a configured tool without exposing its implementation. */
+	resolveTool(name: string): Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined;
 	/** Session control seams used by the SDK host. */
 	cycleModel(): Promise<{ model: Model; thinkingLevel: ThinkingLevel | undefined } | undefined>;
 	cycleThinkingLevel(): ThinkingLevel | undefined;
@@ -589,6 +596,26 @@ export interface MessageUpdateEvent {
 	assistantMessageEvent: AssistantMessageEvent;
 }
 
+export interface ReasoningSummaryStartEvent {
+	type: "reasoning_summary_start";
+	message: AgentMessage;
+	contentIndex: number;
+}
+
+export interface ReasoningSummaryDeltaEvent {
+	type: "reasoning_summary_delta";
+	message: AgentMessage;
+	contentIndex: number;
+	delta: string;
+}
+
+export interface ReasoningSummaryEndEvent {
+	type: "reasoning_summary_end";
+	message: AgentMessage;
+	contentIndex: number;
+	content: string;
+}
+
 /** Fired when a message ends */
 export interface MessageEndEvent {
 	type: "message_end";
@@ -838,6 +865,9 @@ export type ExtensionEvent =
 	| MessageStartEvent
 	| MessageUpdateEvent
 	| MessageEndEvent
+	| ReasoningSummaryStartEvent
+	| ReasoningSummaryDeltaEvent
+	| ReasoningSummaryEndEvent
 	| ToolExecutionStartEvent
 	| ToolExecutionUpdateEvent
 	| ToolExecutionEndEvent
@@ -999,6 +1029,9 @@ export interface ExtensionAPI {
 	on(event: "turn_end", handler: ExtensionHandler<TurnEndEvent>): void;
 	on(event: "message_start", handler: ExtensionHandler<MessageStartEvent>): void;
 	on(event: "message_update", handler: ExtensionHandler<MessageUpdateEvent>): void;
+	on(event: "reasoning_summary_start", handler: ExtensionHandler<ReasoningSummaryStartEvent>): void;
+	on(event: "reasoning_summary_delta", handler: ExtensionHandler<ReasoningSummaryDeltaEvent>): void;
+	on(event: "reasoning_summary_end", handler: ExtensionHandler<ReasoningSummaryEndEvent>): void;
 	on(event: "message_end", handler: ExtensionHandler<MessageEndEvent>): void;
 	on(event: "tool_execution_start", handler: ExtensionHandler<ToolExecutionStartEvent>): void;
 	on(event: "tool_execution_update", handler: ExtensionHandler<ToolExecutionUpdateEvent>): void;
@@ -1103,6 +1136,8 @@ export interface ExtensionAPI {
 
 	/** Get all configured tools (built-in + extension tools). */
 	getAllTools(): string[];
+	/** Resolve display-safe metadata for a configured tool without exposing its implementation. */
+	resolveTool(name: string): Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined;
 
 	/** Set the active tools by name. */
 	setActiveTools(toolNames: string[]): Promise<void>;
@@ -1304,6 +1339,7 @@ export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) =>
 export type GetActiveToolsHandler = () => string[];
 
 export type GetAllToolsHandler = () => string[];
+export type ResolveToolHandler = (name: string) => Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined;
 
 export type GetCommandsHandler = () => SlashCommandInfo[];
 
@@ -1349,6 +1385,7 @@ export interface ExtensionActions {
 	setLabel: (targetId: string, label: string | undefined) => void;
 	getActiveTools: GetActiveToolsHandler;
 	getAllTools: GetAllToolsHandler;
+	resolveTool: ResolveToolHandler;
 	setActiveTools: SetActiveToolsHandler;
 	getCommands: GetCommandsHandler;
 	setModel: SetModelHandler;
@@ -1381,6 +1418,7 @@ export interface ExtensionContextActions {
 	getQueuedMessages?: () => unknown[];
 	getActiveTools?: () => string[];
 	getAllTools?: () => string[];
+	resolveTool?: (name: string) => Pick<Tool, "safeSummary" | "safeSummaryFields"> | undefined;
 	shutdown: () => void;
 	getContextUsage: () => ContextUsage | undefined;
 	compact: (instructionsOrOptions?: string | CompactOptions) => Promise<void>;

package/src/extensibility/gjc-plugins/installer.ts

@@ -211,23 +211,23 @@ async function resolveTarball(source: string): Promise<ResolvedSource> {
 }
 
 function runGit(args: string[], cwd?: string): Promise<string> {
-	return new Promise((resolve, reject) => {
-		// argv array (no shell) — repo/ref are passed as discrete args, not interpolated.
-		const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
-		let stdout = "";
-		let stderr = "";
-		child.stdout.on("data", d => {
-			stdout += d;
-		});
-		child.stderr.on("data", d => {
-			stderr += d;
-		});
-		child.on("error", reject);
-		child.on("close", code => {
-			if (code === 0) resolve(stdout.trim());
-			else reject(new GjcPluginLoadError("install_conflict", `git ${args[0]} failed: ${stderr.trim()}`));
-		});
+	const { promise, resolve, reject } = Promise.withResolvers<string>();
+	// argv array (no shell) — repo/ref are passed as discrete args, not interpolated.
+	const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+	let stdout = "";
+	let stderr = "";
+	child.stdout.on("data", d => {
+		stdout += d;
+	});
+	child.stderr.on("data", d => {
+		stderr += d;
+	});
+	child.on("error", reject);
+	child.on("close", code => {
+		if (code === 0) resolve(stdout.trim());
+		else reject(new GjcPluginLoadError("install_conflict", `git ${args[0]} failed: ${stderr.trim()}`));
 	});
+	return promise;
 }
 
 async function resolveGit(source: string): Promise<ResolvedSource> {

package/src/extensibility/hooks/runner.ts

@@ -4,7 +4,7 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 import type { Model } from "@gajae-code/ai";
 import type { ModelRegistry } from "../../config/model-registry";
-import type { SessionManager } from "../../session/session-manager";
+import { createReadonlySessionManager, type SessionManager } from "../../session/session-manager";
 import { createNoOpUIContext } from "../utils";
 import type {
 	AppendEntryHandler,
@@ -226,7 +226,7 @@ export class HookRunner {
 			ui: this.#uiContext,
 			hasUI: this.#hasUI,
 			cwd: this.cwd,
-			sessionManager: this.sessionManager,
+			sessionManager: createReadonlySessionManager(this.sessionManager),
 			modelRegistry: this.modelRegistry,
 			model: this.#getModel(),
 			isIdle: () => this.#isIdleFn(),

package/src/extensibility/runtime-skill-discovery.ts

@@ -4,7 +4,8 @@ import * as path from "node:path";
 import { findRepoRoot } from "../capability/fs";
 import type { Skill as CapabilitySkill } from "../capability/skill";
 import type { SkillsSettings } from "../config/settings-schema";
-import { compareSkillOrder, scanSkillsFromDir } from "../discovery/helpers";
+import { compareSkillOrder, SOURCE_PATHS, scanSkillsFromDir } from "../discovery/helpers";
+import { CANONICAL_GJC_WORKFLOW_SKILLS } from "../skill-state/canonical-skills";
 import type { Skill } from "./skills";
 
 export type RuntimeSkillDiscoverySource = "project" | "user";
@@ -32,6 +33,7 @@ function getRuntimeHome(): string {
 
 const DEFAULT_LIMIT = 20;
 const MAX_LIMIT = 50;
+const BUILT_IN_SKILL_NAMES = new Set<string>(CANONICAL_GJC_WORKFLOW_SKILLS);
 
 function normalizeLimit(limit: number | undefined): number {
 	if (limit === undefined || !Number.isFinite(limit)) return DEFAULT_LIMIT;
@@ -56,6 +58,18 @@ async function getProjectSkillDirs(cwd: string, home: string): Promise<{ dirs: s
 	return { dirs, repoRoot };
 }
 
+function getUserSkillDirs(home: string): string[] {
+	const canonicalUserDir = SOURCE_PATHS.native.userAgent;
+	const configuredLegacyDir = SOURCE_PATHS.native.userBase;
+	return [
+		...new Set([
+			path.join(home, canonicalUserDir, "skills"),
+			path.join(home, configuredLegacyDir, "skills"),
+			path.join(home, ".gjc", "skills"),
+		]),
+	];
+}
+
 function getUseWhen(skill: CapabilitySkill): string[] | undefined {
 	const frontmatter = skill.frontmatter as Record<string, unknown> | undefined;
 	const values: string[] = [];
@@ -110,6 +124,7 @@ function isAllowedByPolicy(
 	source: RuntimeSkillDiscoverySource,
 	policy: SkillsSettings | undefined,
 ): boolean {
+	if (BUILT_IN_SKILL_NAMES.has(skill.name)) return false;
 	if (!sourceEnabled(source, policy)) return false;
 	if (isDisabledSkill(skill.name, policy?.disabledExtensions)) return false;
 	if (matchesIgnorePatterns(skill.name, policy?.ignoredSkills)) return false;
@@ -158,12 +173,14 @@ export async function discoverRuntimeSkills(
 		}
 	}
 	if ((source === "all" || source === "user") && sourceEnabled("user", policy)) {
-		scanJobs.push(
-			scanSkillsFromDir(
-				{ cwd: options.cwd, home, repoRoot: home },
-				{ dir: path.join(home, ".gjc", "skills"), providerId: "runtime", level: "user", requireDescription: true },
-			).then(result => result.items.map(skill => ({ skill, source: "user" as const }))),
-		);
+		for (const dir of getUserSkillDirs(home)) {
+			scanJobs.push(
+				scanSkillsFromDir(
+					{ cwd: options.cwd, home, repoRoot: home },
+					{ dir, providerId: "runtime", level: "user", requireDescription: true },
+				).then(result => result.items.map(skill => ({ skill, source: "user" as const }))),
+			);
+		}
 	}
 
 	const seenNames = new Set<string>();
@@ -175,6 +192,7 @@ export async function discoverRuntimeSkills(
 		if (seenPaths.has(realPath) || seenNames.has(entry.skill.name)) continue;
 		seenPaths.add(realPath);
 		seenNames.add(entry.skill.name);
+
 		const candidate: RuntimeSkillDiscoveryCandidate = {
 			name: entry.skill.name,
 			description:
@@ -213,12 +231,14 @@ export async function findRuntimeSkillByName(
 		);
 	}
 	if (sourceEnabled("user", policy)) {
-		scanJobs.push(
-			scanSkillsFromDir(
-				{ cwd, home, repoRoot: home },
-				{ dir: path.join(home, ".gjc", "skills"), providerId: "runtime", level: "user", requireDescription: true },
-			).then(result => result.items.map(skill => ({ skill, source: "user" as const }))),
-		);
+		for (const dir of getUserSkillDirs(home)) {
+			scanJobs.push(
+				scanSkillsFromDir(
+					{ cwd, home, repoRoot: home },
+					{ dir, providerId: "runtime", level: "user", requireDescription: true },
+				).then(result => result.items.map(skill => ({ skill, source: "user" as const }))),
+			);
+		}
 	}
 	for (const entry of (await Promise.all(scanJobs)).flat()) {
 		if (entry.skill.name === normalized && isAllowedByPolicy(entry.skill, entry.source, policy)) {