@gajae-code/coding-agent 0.17.2 → 0.17.4

package/src/modes/shared/agent-wire/workflow-gate-broker.ts

@@ -24,6 +24,7 @@ import type {
 	WorkflowGateOption,
 	WorkflowGateQueryRecord,
 	WorkflowGateResolution,
+	WorkflowGateResolutionDiagnostic,
 	WorkflowGateResponse,
 	WorkflowGateValidationError,
 	WorkflowStage,
@@ -35,6 +36,9 @@ export type PersistedResolutionOrigin =
 	| { kind: "generic"; channel: "sdk" | "other" }
 	| { kind: "telegram_notification"; interactionActionId: string };
 
+/** Keep accepted diagnostics below the coordinator's cumulative Q12 snapshot cap. */
+export const MAX_ACCEPTED_WORKFLOW_GATE_QUERY_RECORDS = 32;
+
 export type PersistedAckPolicy =
 	| { kind: "none"; reason: "non_telegram" | "semantic_noncommit" | "legacy_unproven" }
 	| {
@@ -152,7 +156,7 @@ export class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
 	readonly #emitterHooks: Pick<BrokerHooks, "advance">;
 	#runtimeTurnProvider: (() => string | undefined) | undefined;
 
-	constructor(runId: string, store: GateStore, emitterHooks: Pick<BrokerHooks, "advance"> = {}) {
+	constructor(runId: string, store: GateStore, emitterHooks: Pick<BrokerHooks, "advance" | "continuationLost"> = {}) {
 		this.#runId = runId;
 		this.#store = store;
 		this.#emitterHooks = emitterHooks;
@@ -164,6 +168,7 @@ export class BrokerWorkflowGateEmitter implements WorkflowGateEmitter {
 			completeAccepted: record => this.#completeAccepted(record),
 			finalizeAccepted: record => this.#finalizeAccepted(record),
 			terminalizeAccepted: record => this.#terminalizeAccepted(record),
+			continuationLost: record => emitterHooks.continuationLost?.(record),
 		});
 	}
 
@@ -1147,6 +1152,8 @@ export type GateAuditEvent =
 	| { event: "gate_response_accepted"; gate_id: string; answer_hash: string }
 	| { event: "gate_response_rejected"; gate_id: string; answer_hash: string }
 	| { event: "gate_response_idempotent_replay"; gate_id: string }
+	/** An idempotent replay refused because this runtime cannot prove the continuation ran. */
+	| { event: "gate_response_replay_unproven"; gate_id: string }
 	| { event: "gate_response_idempotency_conflict"; gate_id: string }
 	| { event: "gate_response_already_resolved"; gate_id: string }
 	| { event: "gate_response_unknown_gate"; gate_id: string }
@@ -1171,6 +1178,8 @@ export interface BrokerHooks {
 	terminalizeAccepted?(record: PersistedGate): WorkflowGateTerminalProof | Promise<WorkflowGateTerminalProof>;
 	/** Runs only after a successful advance has been durably marked advanced. */
 	completeAccepted?(record: PersistedGate): void | Promise<void>;
+	/** Notifies the owning runtime when the accepted answer cannot reach its continuation. */
+	continuationLost?(record: PersistedGate): void;
 	/** Append-only audit sink. */
 	audit?(event: GateAuditEvent): void;
 }
@@ -1222,6 +1231,14 @@ export class WorkflowGateBroker {
 	private readonly gateLocks = new Map<string, Promise<void>>();
 	private readonly continuations = new Map<string, GateContinuation>();
 	readonly #terminalProofs = new Map<string, WorkflowGateTerminalProof>();
+	/**
+	 * Gates whose `completeAccepted` hook threw after `advanced:true` was already
+	 * committed, so the durable record claims completion the continuation never
+	 * received. In-memory by design: the stranded turn belongs to this process's
+	 * waiter, so a restart cannot resolve it either way and must not inherit a
+	 * claim it cannot honor (#5599).
+	 */
+	readonly #continuationLost = new Set<string>();
 
 	private async withGateLock<T>(gateId: string, operation: () => Promise<T>): Promise<T> {
 		const previous = this.gateLocks.get(gateId) ?? Promise.resolve();
@@ -1282,6 +1299,34 @@ export class WorkflowGateBroker {
 				`idempotency_conflict: gate ${response.gate_id} resolved with a different body`,
 			);
 		if (response.idempotency_key !== undefined && sameKey && sameBody) {
+			// A record whose `completeAccepted` threw is durably indistinguishable from a
+			// genuinely completed one: `advanced:true` is committed before the waiter is
+			// resolved, so the shape below matches either way. Reporting `completed` there
+			// told `resolveSdkWorkflowGate`'s catch path to return a successful resolution
+			// for a turn whose continuation was never resolved — `ok:true status:"accepted"`
+			// with an empty pending-gate list and a prompt stuck `in_flight` forever, with
+			// no recovery path because `recover()` skips advanced records (#5599).
+			//
+			// Downgrading to `accepted_incomplete` routes it through the existing
+			// recover-then-recheck branch and, when that cannot resolve it, surfaces the
+			// documented `terminal_uncertain` instead of a false success.
+			//
+			// TWO conditions, because the loss cannot be persisted: an `accepted` record
+			// may not carry a `lifecycle` and a `quarantined` one must be `advanced:false`,
+			// so the durable shape has nowhere to record it.
+			//
+			// 1. This runtime saw the hook throw.
+			if (this.#continuationLost.has(response.gate_id)) return { kind: "accepted_incomplete" };
+			// 2. The record belongs to a PREVIOUS runtime. A continuation waiter is
+			//    process-local and cannot survive a restart, so this process can never
+			//    prove the prior turn was resolved — and the in-memory set above is empty
+			//    after a restart, which is exactly how the first fix still handed back a
+			//    false `completed` on a cross-restart idempotent retry (#5599 review).
+			//    Fail closed instead. The cost is telling a retry "uncertain" about a gate
+			//    that did complete under the dead runtime; that is the honest answer
+			//    regardless, because the turn it belonged to died with that process and no
+			//    retry can continue it.
+			if (record.ownerInstanceId !== this.instanceId) return { kind: "accepted_incomplete" };
 			if (record.terminalized === true && record.advanced === true && record.resolution)
 				return { kind: "completed", resolution: record.resolution };
 			return { kind: "accepted_incomplete" };
@@ -1311,6 +1356,17 @@ export class WorkflowGateBroker {
 		return this.continuations.get(gateId)?.isLive(gateId) === true;
 	}
 
+	private recordContinuationLoss(gateId: string): void {
+		this.#continuationLost.add(gateId);
+		const lost = this.store.get(gateId);
+		if (!lost) return;
+		try {
+			this.hooks.continuationLost?.(lost);
+		} catch {
+			// A settlement notification must never replace the original resolution error.
+		}
+	}
+
 	hasRecoverableAcceptedGate(): boolean {
 		return this.store
 			.list()
@@ -1395,8 +1451,10 @@ export class WorkflowGateBroker {
 			.filter(
 				(
 					record,
-				): record is PersistedGate & { status: "quarantined"; lifecycle: WorkflowGateDiagnostic["lifecycle"] } =>
-					record.status === "quarantined" && record.lifecycle !== undefined,
+				): record is PersistedGate & {
+					status: "quarantined";
+					lifecycle: WorkflowGateDiagnostic["lifecycle"];
+				} => record.status === "quarantined" && record.lifecycle !== undefined,
 			)
 			.sort(
 				(left, right) =>
@@ -1408,6 +1466,7 @@ export class WorkflowGateBroker {
 				id: `diagnostic:${record.gate.gate_id}`,
 				tag: "quarantined",
 				lifecycle: record.lifecycle,
+				answer_recorded: Object.hasOwn(record, "answer"),
 			}));
 	}
 
@@ -1421,8 +1480,38 @@ export class WorkflowGateBroker {
 					this.hasLiveContinuation(record.gate.gate_id),
 			)
 			.sort(compareGates)
-			.map(record => ({ ...record.gate, id: `pending:${record.gate.gate_id}`, tag: "pending" }));
-		return [...pending, ...this.listGateDiagnostics()];
+			.map(record => ({
+				...record.gate,
+				id: `pending:${record.gate.gate_id}`,
+				tag: "pending" as const,
+				answer_recorded: false as const,
+			}));
+		const accepted: WorkflowGateResolutionDiagnostic[] = this.store
+			.list()
+			.filter((record): record is PersistedGate & { status: "accepted" } => record.status === "accepted")
+			.sort(
+				(left, right) =>
+					(right.resolution?.resolved_at ?? "").localeCompare(left.resolution?.resolved_at ?? "") ||
+					right.gate.gate_id.localeCompare(left.gate.gate_id),
+			)
+			.slice(0, MAX_ACCEPTED_WORKFLOW_GATE_QUERY_RECORDS)
+			.map(record => ({
+				...record.gate,
+				id: `diagnostic:${record.gate.gate_id}`,
+				tag: "accepted" as const,
+				answer_recorded: true as const,
+				resolved_at: record.resolution?.resolved_at ?? record.gate.created_at,
+				post_accept_disposition: this.#continuationLost.has(record.gate.gate_id)
+					? "continuation_lost"
+					: record.advanced
+						? record.ownerInstanceId === this.instanceId
+							? "advanced"
+							: "unknown"
+						: record.terminalized === true
+							? "terminalized"
+							: "accepted",
+			}));
+		return [...pending, ...accepted, ...this.listGateDiagnostics()];
 	}
 
 	/** Open and emit a gate. The pending record is persisted BEFORE emission. */
@@ -1516,6 +1605,17 @@ export class WorkflowGateBroker {
 			const sameBody = record.responseHash === responseHash;
 			const sameKey = record.idempotencyKey === response.idempotency_key;
 			if (response.idempotency_key !== undefined && sameKey && sameBody) {
+				// Same provenance rule as `lookupCompletedResolution`: an idempotent replay must
+				// not hand back an accepted resolution for a continuation this runtime cannot
+				// prove was resolved. Without this, a direct `resolveGate()` retry bypassed the
+				// lookup entirely and reproduced the original false success (#5599 review).
+				if (this.#continuationLost.has(response.gate_id) || record.ownerInstanceId !== this.instanceId) {
+					this.hooks.audit?.({ event: "gate_response_replay_unproven", gate_id: response.gate_id });
+					throw new WorkflowGateBrokerError(
+						"unknown_gate",
+						`accepted gate ${response.gate_id} cannot be replayed: this runtime cannot prove its continuation was resolved`,
+					);
+				}
 				this.hooks.audit?.({ event: "gate_response_idempotent_replay", gate_id: response.gate_id });
 				return record.resolution as WorkflowGateResolution;
 			}
@@ -1609,7 +1709,16 @@ export class WorkflowGateBroker {
 				`accepted gate ${response.gate_id} lost its continuation before advance completed`,
 			);
 		this.store.put({ ...latest, advanced: true });
-		await this.hooks.completeAccepted?.(this.store.get(response.gate_id) as PersistedGate);
+		// `advanced:true` is already durable, so a throw here cannot be undone — but it
+		// must not be reported as a completed resolution either. Mark the loss before
+		// rethrowing so `lookupCompletedResolution` stops claiming completion for a
+		// continuation that was never resolved (#5599).
+		try {
+			await this.hooks.completeAccepted?.(this.store.get(response.gate_id) as PersistedGate);
+		} catch (error) {
+			this.recordContinuationLoss(response.gate_id);
+			throw error;
+		}
 		this.continuations.get(response.gate_id)?.release?.(response.gate_id);
 		this.continuations.delete(response.gate_id);
 		return resolution;
@@ -1659,7 +1768,15 @@ export class WorkflowGateBroker {
 					if (latest?.status !== "accepted" || latest.advanced || !this.hasLiveContinuation(listed.gate.gate_id))
 						return;
 					this.store.put({ ...latest, advanced: true });
-					await this.hooks.completeAccepted?.(this.store.get(latest.gate.gate_id) as PersistedGate);
+					// Same durable-commit-then-resolve ordering as `resolve()`; mark the
+					// loss so a recovery attempt cannot leave behind a record that claims
+					// completion its continuation never received (#5599).
+					try {
+						await this.hooks.completeAccepted?.(this.store.get(latest.gate.gate_id) as PersistedGate);
+					} catch (error) {
+						this.recordContinuationLoss(latest.gate.gate_id);
+						throw error;
+					}
 					this.continuations.get(latest.gate.gate_id)?.release?.(latest.gate.gate_id);
 					this.continuations.delete(latest.gate.gate_id);
 					this.hooks.audit?.({ event: "gate_advance_recovered", gate_id: latest.gate.gate_id });

package/src/modes/shared/agent-wire/workflow-gate-types.ts

@@ -375,12 +375,26 @@ export interface WorkflowGateDiagnostic extends WorkflowGate {
 	id: string;
 	tag: "quarantined";
 	lifecycle: WorkflowGateLifecycle;
+	/** Whether the durable broker retained an answer for this gate. */
+	answer_recorded: boolean;
+}
+
+/** Durable acceptance evidence for a gate that is no longer pending. */
+export interface WorkflowGateResolutionDiagnostic extends WorkflowGate {
+	id: string;
+	tag: "accepted";
+	/** True when the accepted record contains the answer body. */
+	answer_recorded: true;
+	resolved_at: string;
+	/** Single post-accept disposition; raw answers and derived answer values stay private. */
+	post_accept_disposition: "accepted" | "terminalized" | "advanced" | "continuation_lost" | "unknown";
 }
 
 /** Stable Q12 row preserving the root WorkflowGate shape. */
 export type WorkflowGateQueryRecord =
-	| (WorkflowGate & { id: string; tag: "pending"; lifecycle?: undefined })
-	| WorkflowGateDiagnostic;
+	| (WorkflowGate & { id: string; tag: "pending"; lifecycle?: undefined; answer_recorded: false })
+	| WorkflowGateDiagnostic
+	| WorkflowGateResolutionDiagnostic;
 
 /** Inbound: the agent's answer to a workflow gate. */
 export interface WorkflowGateResponse {

package/src/modes/types.ts

@@ -409,7 +409,7 @@ export interface InteractiveModeContext {
 	handleHandoffCommand(customInstructions?: string): Promise<void>;
 	handleContributionPrepCommand(customInstructions?: string): Promise<void>;
 	handleMoveCommand(targetPath: string): Promise<void>;
-	handleRenameCommand(title: string): Promise<void>;
+	handleRenameCommand(title?: string): Promise<void>;
 	handleMemoryCommand(text: string): Promise<void>;
 	handleSTTToggle(): Promise<void>;
 	executeCompaction(
@@ -490,7 +490,7 @@ export interface InteractiveModeContext {
 	>;
 	goalModeController: Pick<
 		import("./controllers/goal-mode-controller").GoalModeController,
-		"enabled" | "paused" | "handleCommand"
+		"enabled" | "paused" | "handleCommand" | "cancelContinuation" | "scheduleContinuation"
 	>;
 	setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
 	setHookStatus(key: string, text: string | undefined): void;

package/src/prompts/agent-fragments/browser-aside.md

@@ -5,6 +5,7 @@ Routing:
 - Every task that requires a rendered page, authenticated/private browser state, live tabs, browser UI, screenshots, downloads behind cookies, history, saved credentials, or profile data MUST use Bash to invoke the installed Aside CLI.
 - Default to `aside repl '<JavaScript>'` for deterministic Playwright inspection and actions, even when the answer is unknown but the procedure is discoverable from `snapshot(page, { interactive: true })`.
 - Use `aside exec '<prompt>'` only for runtime judgment, source-heavy research, browser-history search, MFA or opaque password autofill, approval/notification waits, long monitoring, multi-site synthesis, routines, or work worth a second model. Continue with `aside exec --session <id> '<follow-up>'`. Use `--account`, `--model`, `--provider`, `--speed`, or `--effort` only when the task requires overriding user defaults.
+- Declare every Aside invocation on the Bash call itself with the structured `activity` argument: `{"kind":"browser","provider":"aside","mode":"repl"}` for `aside repl`, and `{"kind":"browser","provider":"aside","mode":"exec"}` for `aside exec` including `--session <id>` follow-ups. The declaration names the operation, not the command spelling: send it unchanged across wrappers, env prefixes, absolute CLI paths, quoting, and multiline commands, and omit it on Bash calls that do not invoke Aside.
 - Cookie-free public HTTP content that does not require rendered or authenticated browser state may use GJC `read` directly.
 
 Deterministic procedure:

package/src/prompts/system/title-system.md

@@ -1,2 +1,2 @@
-Generate a 3-6 word title for a coding session from the user's first message. Capture the main task or topic.
+Generate a 3-6 word title for a coding session from the supplied user message or conversation digest. If multiple messages are supplied, identify the primary/current task from the digest, weighting the newest substantive message highest; do not assume the first message is the task. If one message is supplied, capture its main task or topic.
 Output ONLY the title. No quotes or trailing punctuation.

package/src/prompts/tools/bash.md

@@ -17,7 +17,7 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 - Use `async: true` for long-running commands when you don't need immediate output; the call returns a background job ID and the result is delivered automatically as a follow-up.
 {{/if}}
 {{#if foregroundFoldEnabled}}
-- In the interactive TUI, the user can press the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via the `app.tool.backgroundFold` keybinding) while a foreground command is still running to fold it into a background job. All three command surfaces fold: managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded command keeps its original timeout and is never killed or restarted by folding; a folded PTY continues output-only, so it stops accepting input. The turn then ends cleanly and a later turn resumes automatically with the command's result, so the interrupted task is finished rather than abandoned. `task`/`subagent` waits are deliberately NOT foldable. Do not instruct users to use raw shell `Ctrl+Z`/`bg` inside the GJC TUI; ownership and output routing are not safe there.
+- In the interactive TUI, the user can press the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via the `app.tool.backgroundFold` keybinding) while a foreground command is still running to fold it into a background job. All three command surfaces fold: managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded command keeps its original timeout and is never killed or restarted by folding; a folded PTY continues output-only, so it stops accepting input. The turn then ends cleanly and a later turn resumes automatically with the command's result, so the interrupted task is finished rather than abandoned. The `job` tool's own await uses the same steer-fold behavior and grace window; `task`/`subagent` waits are deliberately NOT foldable. Do not instruct users to use raw shell `Ctrl+Z`/`bg` inside the GJC TUI; ownership and output routing are not safe there.
 - A user steer folds the same way: when the user sends a message while a foreground command has already run for at least 2 seconds, the command is folded into a background job and this call returns the background-start result plus the line `Folded into background job <id> because a user steer arrived; the command keeps running with its original timeout and its result will wake a later turn.` The steer is then delivered at this tool boundary, so handle it next; do not re-run the folded command. Steers that arrive within the first 2 seconds let the command finish normally. This applies only while `busyPromptMode` is `steer`; `toolInterruptPolicy` is not a gate, since a fold never kills the command.
 {{/if}}
 </instruction>

package/src/prompts/tools/job.md

@@ -2,7 +2,7 @@ Inspects, waits, or cancels async jobs.
 
 Background job results are delivered automatically when complete. Jobs that back task subagents should be controlled via the `subagent` tool when it is available; use `job` for non-subagent jobs (async bash, monitors) and as a compatibility fallback. Running job output stays quiet by default to avoid flooding the conversation; use `tail` when you explicitly want to show/reopen retained output. Reach for this tool only when you need to inspect or intervene.
 
-In the interactive TUI, a running foreground command can be folded into a background job by pressing the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via `app.tool.backgroundFold`), or automatically when the user sends a steer after the command has run for at least 2 seconds (with `busyPromptMode=steer` (`toolInterruptPolicy` is not a gate)). This covers managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded job keeps its original deadline, is never killed or restarted by folding, and its result wakes a later turn automatically; a folded PTY continues output-only and no longer accepts input. Job listings expose `foldReason` (`steer`, `chord`, `timer`, or `sdk_control`) beside `backgrounded` so you can tell why a job left the foreground. `task`/`subagent` waits are not foldable. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
+In the interactive TUI, a running foreground command can be folded into a background job by pressing the fold chord twice (default `Alt+Shift+B`, plus `Cmd+B` on macOS; remappable via `app.tool.backgroundFold`), or automatically when the user sends a steer after the command has run for at least 2 seconds (with `busyPromptMode=steer` (`toolInterruptPolicy` is not a gate)). This covers managed non-PTY bash, editor/ACP client-terminal commands, and PTY-mode commands. A folded job keeps its original deadline, is never killed or restarted by folding, and its result wakes a later turn automatically; a folded PTY continues output-only and no longer accepts input. A `job` await also folds after the same 2-second grace window when a steer arrives, returning immediately with the still-running job id(s) while those jobs keep their original deadlines and wake a later turn with their results. Job listings expose `foldReason` (`steer`, `chord`, `timer`, or `sdk_control`) beside `backgrounded` so you can tell why a job left the foreground. `task`/`subagent` waits are not foldable. Raw shell `Ctrl+Z`/`bg` is not the supported path inside GJC because it bypasses job ownership and output-routing contracts.
 
 # Operations
 

package/src/prompts/tools/read.md

@@ -73,6 +73,8 @@ For `.sqlite`, `.sqlite3`, `.db`, `.db3`:
 
 `agent://<id>`, `artifact://<id>`, `rule://<name>`, and `local://<name>.md` resolve transparently and accept the same line selectors as filesystem paths. Use `artifact://<id>` to recover full output that a previous bash/eval/tool result spilled or truncated.
 
+Bundled skills have no filesystem home, so the skill tool and skill discovery report them as `embedded:gjc/skills/<name>/SKILL.md`; read that identifier verbatim. Bundled skill fragments, when surfaced, likewise use `embedded:gjc/skill-fragments/...` identifiers.
+
 <critical>
 - Always include `path`; never call `read` with `{}`.
 - For line ranges, append the selector to `path`.

package/src/runtime/network-prewarm-service.test.ts

@@ -42,7 +42,42 @@ describe("network prewarm runtime service", () => {
 		const runtime = await service.get("legacy-startup");
 		runtime.preconnect("https://example.test");
 
-		expect(calls).toEqual(["https://example.test"]);
+		expect(calls).toEqual(["https://example.test:443/"]);
+		await service.dispose();
+	});
+
+	test("normalizes a portless HTTPS model host before preconnect", async () => {
+		const calls: string[] = [];
+		const fetchWithPreconnect = Object.assign(async () => new Response("ok"), {
+			preconnect: (url: string) => {
+				calls.push(url);
+			},
+		}) as typeof fetch & { preconnect: (url: string) => void };
+		globalThis.fetch = fetchWithPreconnect;
+
+		const service = createNetworkPrewarmService(Settings.isolated());
+		const runtime = await service.get("portless-https");
+		runtime.preconnect("https://api.anthropic.com/v1/messages");
+
+		expect(calls).toEqual(["https://api.anthropic.com:443/v1/messages"]);
+		await service.dispose();
+	});
+
+	test("falls back to Bun's accepted TCP form when default-port HTTPS is rejected", async () => {
+		const calls: string[] = [];
+		const fetchWithPreconnect = Object.assign(async () => new Response("ok"), {
+			preconnect: (url: string) => {
+				calls.push(url);
+				if (url.startsWith("https://")) throw new TypeError("Invalid port");
+			},
+		}) as typeof fetch & { preconnect: (url: string) => void };
+		globalThis.fetch = fetchWithPreconnect;
+
+		const service = createNetworkPrewarmService(Settings.isolated());
+		const runtime = await service.get("bun-1.4.0");
+		runtime.preconnect("https://api.anthropic.com");
+
+		expect(calls).toEqual(["https://api.anthropic.com:443/", "http://api.anthropic.com:443/"]);
 		await service.dispose();
 	});
 });

package/src/runtime/network-prewarm-service.ts

@@ -4,6 +4,24 @@ import { createLazyService, type LazyService } from "./lazy-service";
 
 type FetchWithPreconnect = typeof fetch & { preconnect?: (url: string) => void };
 
+function withDefaultPort(baseUrl: string): { normalized: string; fallback?: string } {
+	try {
+		const parsed = new URL(baseUrl);
+		if (parsed.port || parsed.protocol !== "https:") return { normalized: baseUrl };
+		const port = "443";
+		const path = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+		const authority = parsed.host;
+		const normalized = `${parsed.protocol}//${authority}:${port}${path}`;
+		// Bun 1.4.0 rejects the default port after WHATWG URL normalization. Its
+		// HTTP-form URL still reaches the same port and keeps the TCP warmup alive
+		// until the runtime accepts the canonical HTTPS form.
+		const fallback = parsed.protocol === "https:" ? `http://${authority}:${port}${path}` : undefined;
+		return { normalized, fallback };
+	} catch {
+		return { normalized: baseUrl };
+	}
+}
+
 /** Runtime network prewarm and first-request latency diagnostics. */
 export interface NetworkPrewarmRuntime {
 	enabled: boolean;
@@ -30,11 +48,18 @@ export function createNetworkPrewarmService(settings: Settings): LazyService<Net
 						if (!enabled || !baseUrl) return;
 						const preconnect = (globalThis.fetch as FetchWithPreconnect).preconnect;
 						if (typeof preconnect !== "function") return;
+						const { normalized, fallback } = withDefaultPort(baseUrl);
 						try {
-							preconnect(baseUrl);
+							preconnect(normalized);
 						} catch (error) {
-							// Preserve the legacy best-effort optimization contract while keeping
-							// the diagnostic visible to debug logging.
+							if (fallback) {
+								try {
+									preconnect(fallback);
+									return;
+								} catch {
+									// Fall through to the best-effort diagnostic below.
+								}
+							}
 							logger.debug("Model-host preconnect failed", {
 								baseUrl,
 								error: error instanceof Error ? error.message : String(error),

package/src/runtime/process-lifecycle.ts

@@ -436,6 +436,7 @@ type ResourceDisposer = () => void | Promise<void>;
 
 const resourceOwners = new Map<string, ResourceDisposer>();
 let resourcePostmortemRegistered = false;
+let activeResourceOwnerDisposals = 0;
 
 function ensureResourcePostmortem(): void {
 	if (resourcePostmortemRegistered) return;
@@ -477,23 +478,33 @@ export function resourceOwnerCount(): number {
 	return resourceOwners.size;
 }
 
+/** True while a process-level resource-owner sweep is in progress. */
+export function isResourceOwnerDisposalActive(): boolean {
+	return activeResourceOwnerDisposals > 0;
+}
+
 /**
  * Run and clear every registered resource disposer. Attempts all disposers even
  * if some throw, then surfaces the failures as an `AggregateError` so callers
  * can distinguish "all closed" from "a resource may still be alive".
  */
 export async function disposeAllResourceOwners(): Promise<void> {
-	const disposers = [...resourceOwners.values()];
-	resourceOwners.clear();
-	const errors: unknown[] = [];
-	for (const disposer of disposers) {
-		try {
-			await disposer();
-		} catch (err) {
-			errors.push(err);
+	activeResourceOwnerDisposals += 1;
+	try {
+		const disposers = [...resourceOwners.values()];
+		resourceOwners.clear();
+		const errors: unknown[] = [];
+		for (const disposer of disposers) {
+			try {
+				await disposer();
+			} catch (err) {
+				errors.push(err);
+			}
 		}
-	}
-	if (errors.length > 0) {
-		throw new AggregateError(errors, `${errors.length} resource disposer(s) failed during teardown`);
+		if (errors.length > 0) {
+			throw new AggregateError(errors, `${errors.length} resource disposer(s) failed during teardown`);
+		}
+	} finally {
+		activeResourceOwnerDisposals -= 1;
 	}
 }

package/src/runtime-mcp/config.ts

@@ -4,7 +4,7 @@
  * Uses the capability system to load MCP servers from multiple sources.
  */
 
-import { getMCPConfigPath } from "@gajae-code/utils";
+import { getMCPConfigPath, logger } from "@gajae-code/utils";
 import { mcpCapability } from "../capability/mcp";
 import type { SourceMeta } from "../capability/types";
 import type { Settings } from "../config/settings";
@@ -16,6 +16,14 @@ import { canonicalizeMCPEndpoint } from "./pool-key";
 import { isMCPProtocolPreference } from "./protocol";
 import type { MCPServerConfig } from "./types";
 
+function logSkippedServer(name: string, reason: string): void {
+	logger.warn("Skipping MCP autoload registration", {
+		path: `mcp:${name}`,
+		serverName: name,
+		reason,
+	});
+}
+
 /** Options for loading MCP configs */
 export interface LoadMCPConfigsOptions {
 	/** Owning session settings for capability filtering. */
@@ -174,9 +182,16 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 	for (const server of servers) {
 		const config = convertToLegacyConfig(server);
 		if (config.enabled === false || disabledServers.has(server.name)) {
+			if (!exactConfig) {
+				logSkippedServer(
+					server.name,
+					config.enabled === false ? "registration is disabled" : "server is listed in disabledServers",
+				);
+			}
 			continue;
 		}
 		if (autoloadOnly && config.autoload === false) {
+			if (!exactConfig) logSkippedServer(server.name, "autoload is disabled for this registration");
 			continue;
 		}
 		configs[server.name] = config;