@gajae-code/coding-agent 0.11.7 → 0.11.9

package/src/session/agent-session.ts

@@ -245,6 +245,7 @@ import { loadActiveSubskillTools } from "../extensibility/gjc-plugins/tools";
 import type { HookCommandContext } from "../extensibility/hooks/types";
 import { buildSkillPromptMessage, type Skill, type SkillWarning } from "../extensibility/skills";
 import { expandSlashCommand, type FileSlashCommand } from "../extensibility/slash-commands";
+import { assertDeepInterviewIntentManifest } from "../gjc-runtime/deep-interview-state";
 import { buildGjcRuntimeSessionEnv, consumePendingGoalModeRequest } from "../gjc-runtime/goal-mode-request";
 import {
 	assertNonEmptyGjcSessionId,
@@ -252,6 +253,7 @@ import {
 	sessionStateDir,
 } from "../gjc-runtime/session-layout";
 import {
+	ownerTerminalContextFromEnvironment,
 	persistCoordinatorRuntimeStateFromEvent,
 	registerCoordinatorRuntimeStateFinalizer,
 } from "../gjc-runtime/session-state-sidecar";
@@ -260,7 +262,7 @@ import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
 import { buildSkillStopOutput, ensureWorkflowSkillActivationState } from "../hooks/skill-state";
-import { type LocalProtocolOptions, resolveLocalUrlToPath } from "../internal-urls";
+import { initializeLocalRoot, type LocalProtocolOptions, resolveLocalUrlToPath } from "../internal-urls";
 import { shutdownAll as shutdownAllLspClients } from "../lsp/client";
 import { resolveMemoryBackend } from "../memory-backend";
 import {
@@ -783,6 +785,22 @@ type RetryErrorClassification =
 
 const BARE_DEFAULT_WATCHDOG_ERROR =
 	/^(?:[A-Za-z][A-Za-z0-9-]*(?: [A-Za-z][A-Za-z0-9-]*){0,3} )stream (?:timed out while waiting for the first event|stalled while waiting for the next event)$/;
+const KIMI_CODE_FIRST_EVENT_TIMEOUT_MESSAGES = {
+	"anthropic-messages": new Set([
+		"Provider stream timed out while waiting for the first event",
+		"Anthropic stream timed out while waiting for the first event",
+	]),
+	"openai-completions": new Set([
+		"Provider stream timed out while waiting for the first event",
+		"OpenAI completions stream timed out while waiting for the first event",
+	]),
+} as const;
+
+const ALIBABA_TOKEN_PLAN_PROVIDER = "alibaba-token-plan";
+const ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MESSAGES = {
+	"openai-responses": "OpenAI responses stream timed out while waiting for the first event",
+	"openai-completions": "OpenAI completions stream timed out while waiting for the first event",
+} as const;
 
 function hasBareDefaultRetryDisqualifyingFacts(message: AssistantMessage): boolean {
 	if (message.errorKind !== undefined || message.errorStatus !== undefined) return true;
@@ -1668,6 +1686,7 @@ export class AgentSession {
 
 	#skillsSettings: SkillsSettings | undefined;
 	#activeSkillState: { skill: string; sessionId?: string } | undefined;
+	#restoredWorkflowSkillState: { skill: string; sessionId: string } | undefined;
 
 	// Model registry for API key resolution
 	#modelRegistry: ModelRegistry;
@@ -2487,6 +2506,34 @@ export class AgentSession {
 			return undefined;
 		}
 	}
+	/** Provider-facing ask metadata must expose only the active deep-interview phase. */
+	getDeepInterviewAskStage(): "topology" | "post-topology" | undefined {
+		const currentSessionId = this.sessionManager.getSessionId();
+		const inMemory = this.#activeSkillState;
+		const active =
+			inMemory && (!inMemory.sessionId || inMemory.sessionId === currentSessionId)
+				? inMemory
+				: this.#restoredWorkflowSkillState?.sessionId === currentSessionId
+					? this.#restoredWorkflowSkillState
+					: undefined;
+		if (active?.skill !== "deep-interview") return undefined;
+		try {
+			assertNonEmptyGjcSessionId(currentSessionId, "AgentSession.getDeepInterviewAskStage");
+			const stateDir = sessionStateDir(this.sessionManager.getCwd(), currentSessionId);
+			const filePath = path.join(
+				stateDir,
+				path.basename(sessionModeStatePath(this.sessionManager.getCwd(), currentSessionId, active.skill)),
+			);
+			const raw = fs.readFileSync(filePath, "utf-8");
+			const parsed = JSON.parse(raw) as { state?: { intent_contract?: unknown } };
+			const intentContract = parsed.state?.intent_contract;
+			if (intentContract === undefined) return "topology";
+			assertDeepInterviewIntentManifest(intentContract);
+			return "post-topology";
+		} catch {
+			return undefined;
+		}
+	}
 
 	/** Peek the in-flight directive's invocation handler for use by the resolve tool. */
 	peekQueueInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined {
@@ -4553,6 +4600,8 @@ export class AgentSession {
 		return {
 			getArtifactsDir: () => this.sessionManager.getArtifactsDir(),
 			isManagedDestination: () => this.sessionManager.isManagedDestination(),
+			// Required for verified legacy local:// migration on managed sessions (#2797 / #2925).
+			getManagedLegacyLocalMigrationSource: () => this.sessionManager.getManagedLegacyLocalMigrationSource(),
 			getSessionId: () => this.sessionManager.getSessionId(),
 		};
 	}
@@ -5127,7 +5176,7 @@ export class AgentSession {
 		// No-op when this session opened no tabs. Failure is logged, not thrown.
 		this.#unregisterResourceGc?.();
 		this.#unregisterResourceGc = undefined;
-		this.#unregisterRuntimeStateFinalizer?.();
+		if (ownerTerminalContextFromEnvironment() === null) this.#unregisterRuntimeStateFinalizer?.();
 		this.#unregisterRuntimeStateFinalizer = undefined;
 		await releaseTabsForOwner(this.sessionManager.getSessionId()).catch((error: unknown) =>
 			logger.warn("session dispose: releaseTabsForOwner failed", { error }),
@@ -6780,8 +6829,9 @@ export class AgentSession {
 		if (!activeSkill) {
 			try {
 				const activeState = await readVisibleSkillActiveState(this.sessionManager.getCwd(), sessionId);
-				activeSkill =
-					activeState?.skill ?? activeState?.active_skills?.find(entry => entry.active !== false)?.skill;
+				activeSkill = activeState?.active_skills?.find(
+					entry => entry.active !== false && entry.session_id === sessionId,
+				)?.skill;
 			} catch (error) {
 				logger.warn("Failed to read durable workflow skill state while restoring ask tool", {
 					error: error instanceof Error ? error.message : String(error),
@@ -6793,7 +6843,12 @@ export class AgentSession {
 			// a predecessor session's workflow state to the current identity.
 			if (this.#isDisposed || this.sessionManager.getSessionId() !== sessionId) return;
 		}
-		if (activeSkill && isCanonicalGjcWorkflowSkill(activeSkill.trim())) this.#attachAskTool();
+		if (activeSkill && isCanonicalGjcWorkflowSkill(activeSkill.trim())) {
+			if (!inMemoryActiveSkill) this.#restoredWorkflowSkillState = { skill: activeSkill.trim(), sessionId };
+			this.#attachAskTool();
+		} else if (this.#restoredWorkflowSkillState?.sessionId === sessionId) {
+			this.#restoredWorkflowSkillState = undefined;
+		}
 	}
 
 	#attachAskTool(): void {
@@ -7345,6 +7400,7 @@ export class AgentSession {
 			}
 		}
 		// In-memory tracking keeps `getActiveSkillState` accurate for the chain guard.
+		this.#restoredWorkflowSkillState = undefined;
 		this.#activeSkillState = active ? { skill, sessionId } : undefined;
 		if (active) {
 			await this.refreshGjcSubskillTools();
@@ -12392,6 +12448,7 @@ export class AgentSession {
 							}
 							const retryAfterMs = this.#parseRetryAfterMsFromError(message);
 							const shouldRetry =
+								!this.#isTerminalProviderCompactionTimeout(candidate, message) &&
 								retrySettings.enabled &&
 								attempt < retrySettings.maxRetries &&
 								(retryAfterMs !== undefined ||
@@ -12577,7 +12634,61 @@ export class AgentSession {
 	 * unknown/no-code errors are retryable.
 	 */
 
+	#isKimiCodeFirstEventTimeout(message: AssistantMessage): boolean {
+		if (message.stopReason !== "error" || message.provider !== "kimi-code") return false;
+		const errorMessage = message.errorMessage ?? "";
+		if (message.api === "anthropic-messages") {
+			return KIMI_CODE_FIRST_EVENT_TIMEOUT_MESSAGES["anthropic-messages"].has(errorMessage);
+		}
+		if (message.api === "openai-completions") {
+			return KIMI_CODE_FIRST_EVENT_TIMEOUT_MESSAGES["openai-completions"].has(errorMessage);
+		}
+		return false;
+	}
+
+	#isKimiCodeCompactionTimeout(candidate: Model, errorMessage: string): boolean {
+		if (candidate.provider !== "kimi-code") return false;
+		return /^(?:Summarization failed|Turn prefix summarization failed): (?:Provider|Anthropic|OpenAI completions) stream timed out while waiting for the first event$/.test(
+			errorMessage,
+		);
+	}
+
+	#alibabaTokenPlanCanonicalTimeoutForApi(api: string): string | undefined {
+		if (api === "openai-responses" || api === "openai-completions") {
+			return ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MESSAGES[api];
+		}
+		return undefined;
+	}
+
+	#isAlibabaTokenPlanFirstEventTimeout(message: AssistantMessage): boolean {
+		if (message.stopReason !== "error" || message.provider !== ALIBABA_TOKEN_PLAN_PROVIDER) return false;
+		const canonicalMessage = this.#alibabaTokenPlanCanonicalTimeoutForApi(message.api);
+		return canonicalMessage !== undefined && message.errorMessage === canonicalMessage;
+	}
+
+	#isAlibabaTokenPlanCompactionTimeout(candidate: Model, errorMessage: string): boolean {
+		if (candidate.provider !== ALIBABA_TOKEN_PLAN_PROVIDER) return false;
+		const canonicalMessage = this.#alibabaTokenPlanCanonicalTimeoutForApi(candidate.api);
+		if (canonicalMessage === undefined) return false;
+		return (
+			errorMessage === `Summarization failed: ${canonicalMessage}` ||
+			errorMessage === `Turn prefix summarization failed: ${canonicalMessage}`
+		);
+	}
+
+	#isTerminalProviderFirstEventTimeout(message: AssistantMessage): boolean {
+		return this.#isKimiCodeFirstEventTimeout(message) || this.#isAlibabaTokenPlanFirstEventTimeout(message);
+	}
+
+	#isTerminalProviderCompactionTimeout(candidate: Model, errorMessage: string): boolean {
+		return (
+			this.#isKimiCodeCompactionTimeout(candidate, errorMessage) ||
+			this.#isAlibabaTokenPlanCompactionTimeout(candidate, errorMessage)
+		);
+	}
+
 	#isRetryableError(message: AssistantMessage): boolean {
+		if (this.#isTerminalProviderFirstEventTimeout(message)) return false;
 		if (message.errorMessage?.startsWith("Model fallback chain exhausted;")) return false;
 		const transportFailure = message.transportFailure;
 		const contextWindow = this.model?.contextWindow ?? 0;
@@ -12727,6 +12838,9 @@ export class AgentSession {
 		if (isTerminalHttp4xx && (explicitStatus !== undefined || !/rate.?limit|too many requests/i.test(err))) {
 			return "terminal";
 		}
+		if (this.#isTerminalProviderFirstEventTimeout(message)) {
+			return "terminal";
+		}
 		// A first-event timeout on ollama-cloud (the ollama-chat API) must not
 		// join the unbounded transient class: each continuation retry re-issues
 		// the full request to a remote, billable backend, so an unbounded loop
@@ -12909,6 +13023,18 @@ export class AgentSession {
 				},
 			};
 		}
+		if (this.#isTerminalProviderFirstEventTimeout(outcome.failure.message)) {
+			// The managed transport discarded this attempt before session policy saw it.
+			// Remove its provisional controller charge and surface the original message.
+			this.#defaultFallbackChain().discardStartedAttempt();
+			return {
+				type: "terminal",
+				terminal: {
+					stopReason: "error",
+					messages: [outcome.failure.message],
+				},
+			};
+		}
 		return this.#handleRetryableError(
 			outcome.failure.message,
 			true,
@@ -14507,6 +14633,13 @@ export class AgentSession {
 				await this.sessionManager.ensureOnDisk();
 
 				if (switchingToDifferentSession) {
+					// Interactive /resume (and any other switchSession identity change) must
+					// await verified legacy local:// migration for the *new* session before
+					// post-commit session_switch / local path resolution. createAgentSession
+					// already does this at cold start (#2797); switchSession previously omitted
+					// it, so resolving local:// after /resume could fail-closed with
+					// "legacy migration must complete before path resolution" (#2925).
+					await initializeLocalRoot(this.#localProtocolOptions());
 					this.#resetHindsightConversationTrackingIfHindsight();
 					this.#resetIrcRosterDeliveryState();
 				}

package/src/session/blob-store.ts

@@ -124,8 +124,13 @@ export class BlobStore {
 			},
 		};
 
-		await Bun.write(blobPath, data);
-		await fsp.chmod(blobPath, BLOB_FILE_MODE);
+		// Create the blob directory 0700 and the file 0600 at creation, mirroring
+		// putSync/putImmutableSync. The previous Bun.write let the parent dir be
+		// created with the process umask (e.g. 0755) and the file at 0644 before a
+		// follow-up chmod, violating the owner-only contract above and leaving a
+		// group/other-readable window a managed-tree snapshot fails closed on.
+		await fsp.mkdir(this.dir, { recursive: true, mode: BLOB_DIR_MODE });
+		await fsp.writeFile(blobPath, data, { mode: BLOB_FILE_MODE });
 		return result;
 	}