@xopcai/xopc 0.0.333 → 0.0.335

package/dist/src/gateway/service/session-preparation-worker.js

@@ -0,0 +1,125 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
+import { init_session_repository } from "../../storage/sqlite/session-repository.js";
+import { resolveGitCommit } from "../../execution-environments/git.js";
+import { SessionEnvironmentService } from "../../execution-environments/session-environment-service.js";
+import { claimSessionPreparation, finishSessionPreparation, getSessionPreparation, pendingSessionPreparations } from "../../storage/sqlite/session-creation-repository.js";
+//#region src/gateway/service/session-preparation-worker.ts
+init_transaction();
+init_session_repository();
+init_logger();
+const log = createLogger("Gateway:SessionPreparation");
+var SessionPreparationWorker = class {
+	timer;
+	active = /* @__PURE__ */ new Map();
+	cleaning = false;
+	cleanupTask;
+	environments = new SessionEnvironmentService();
+	constructor(service) {
+		this.service = service;
+	}
+	start() {
+		if (this.timer) return;
+		const scan = () => {
+			for (const id of pendingSessionPreparations()) this.wake(id);
+			this.cleanupTask ??= this.cleanup().catch((err) => log.error({ err }, "Session reservation cleanup scan failed")).finally(() => {
+				this.cleanupTask = void 0;
+			});
+		};
+		scan();
+		this.timer = setInterval(scan, 5e3);
+		this.timer.unref();
+	}
+	async stop() {
+		clearInterval(this.timer);
+		this.timer = void 0;
+		await Promise.allSettled(this.active.values());
+		await this.cleanupTask;
+	}
+	wake(conversationId) {
+		if (this.active.has(conversationId)) return;
+		const work = this.prepare(conversationId).catch((err) => {
+			log.error({
+				err,
+				conversationId,
+				phase: "prepare"
+			}, "Session preparation failed");
+		}).finally(() => this.active.delete(conversationId));
+		this.active.set(conversationId, work);
+	}
+	async cleanup() {
+		if (this.cleaning) return;
+		this.cleaning = true;
+		try {
+			const pending = getSqliteDatabase().prepare("SELECT * FROM session_preparation_cleanup WHERE not_before<=?").all(Date.now());
+			for (const row of pending) {
+				if (this.active.has(row.conversation_id)) continue;
+				try {
+					if (await this.environments.removeUnboundReservation(row.environment_id)) getSqliteDatabase().prepare("DELETE FROM session_preparation_cleanup WHERE environment_id=?").run(row.environment_id);
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					getSqliteDatabase().prepare("UPDATE session_preparation_cleanup SET last_error=?,not_before=? WHERE environment_id=?").run(message, Date.now() + 6e4, row.environment_id);
+				}
+			}
+		} finally {
+			this.cleaning = false;
+		}
+	}
+	async prepare(conversationId) {
+		const operation = claimSessionPreparation(conversationId);
+		if (!operation) return;
+		const heartbeat = setInterval(() => {
+			getSqliteDatabase().prepare(`UPDATE session_preparations SET lease_until=?
+        WHERE operation_id=? AND revision=? AND state='preparing'`).run(Date.now() + 6e4, operation.operationId, operation.revision);
+		}, 15e3);
+		heartbeat.unref();
+		try {
+			const project = operation.creation.projectId ? this.service.projects.get(operation.creation.projectId) : null;
+			if (!project?.workspaceRoot || !operation.creation.execution) throw new Error("Project workspace is unavailable");
+			let baseRef = operation.baseCommit ?? void 0;
+			if (operation.creation.execution.mode === "managed_worktree" && !baseRef) {
+				baseRef = await resolveGitCommit(project.workspaceRoot, operation.creation.execution.baseRef ?? "HEAD");
+				if (!getSqliteDatabase().prepare("UPDATE session_preparations SET base_commit=? WHERE operation_id=? AND revision=?").run(baseRef, operation.operationId, operation.revision).changes) return;
+			}
+			if (!getSessionMetadata(conversationId)) return;
+			await this.environments.attach({
+				conversationId,
+				project,
+				mode: operation.creation.execution.mode,
+				baseRef,
+				environmentId: operation.environmentId,
+				assertCurrent: () => {
+					const current = getSessionPreparation(conversationId);
+					if (!current || current.operationId !== operation.operationId || current.revision !== operation.revision || current.state !== "preparing" || !getSessionMetadata(conversationId)) throw new Error("Session preparation ownership changed");
+				}
+			});
+			if (runSqliteWriteTransaction(() => {
+				if (!getSessionMetadata(conversationId)) return false;
+				return finishSessionPreparation(operation);
+			})) this.service.drainSessionInputs(conversationId).catch((err) => {
+				log.error({
+					err,
+					conversationId
+				}, "Prepared session input drain failed");
+			});
+		} catch (error) {
+			finishSessionPreparation(operation, error instanceof Error ? error.message : String(error));
+			log.warn({
+				err: error,
+				conversationId,
+				operationId: operation.operationId
+			}, "Session environment preparation failed");
+		} finally {
+			clearInterval(heartbeat);
+			const preparation = getSessionPreparation(conversationId);
+			if (preparation) this.service.emit("session.input-state", {
+				...this.service.getSessionInputState(conversationId),
+				preparation
+			});
+		}
+	}
+};
+//#endregion
+export { SessionPreparationWorker };

package/dist/src/gateway/service.d.ts

@@ -20,6 +20,7 @@ import { type BrowserAutomationService } from '../browser/automations/index.js';
 import { GatewaySessionsApi } from './service/sessions-api.js';
 import { GatewayMarketplaceService } from './service/marketplace-service.js';
 import { GatewayAgentRunner } from './service/agent-runner.js';
+import { SessionPreparationWorker } from './service/session-preparation-worker.js';
 import { RealtimeRuntime } from '../realtime/runtime.js';
 import { VoiceRealtimeRuntime } from '../voice/realtime/runtime.js';
 import type { GatewayServiceConfig } from './service/types.js';
@@ -85,6 +86,7 @@ export declare class GatewayService {
      * `activeWebchatRunBySession` + `runAbortControllers` maps.
      */
     readonly agentRunner: GatewayAgentRunner;
+    readonly sessionPreparations: SessionPreparationWorker;
     /** Process-local, non-persistent side conversations forked from durable sessions. */
     readonly sideChats: EphemeralSideChatManager;
     readonly sideChatRuns: SideChatRunService;
@@ -145,6 +147,28 @@ export declare class GatewayService {
         ok: false;
         code: "BAD_REQUEST" | "QUEUE_FULL" | "CONTEXT_UNAVAILABLE" | "SESSION_CHANGED";
     }>;
+    prepareSessionCommandInput(input: Parameters<GatewayAgentRunner['inputs']['prepareInput']>[0]): Promise<{
+        status: "queued";
+        requestedDelivery: import("../storage/sqlite/session-input-repository.js").SessionInputDelivery;
+        effectiveDelivery: "next";
+        content: string;
+        attachments: import("./user-turn-input.js").UserTurnAttachment[];
+        contextRefs: import("../agent/source-context/types.js").SourceContextRefSummary[];
+        contextSnapshots: import("../agent/source-context/types.js").AgentSourceContext[];
+        thinking: string;
+        origin: {
+            type: "endpoint";
+            endpointId: string;
+        } | {
+            type: "channel";
+            channel: string;
+        } | {
+            type: "system";
+            source: "automation" | "cli" | "workflow" | "heartbeat" | "internal";
+        };
+    }>;
+    drainSessionInputs(conversationId: string): Promise<void>;
+    dispatchAcceptedSessionInput(conversationId: string, inputId: string): Promise<void>;
     private appContextDispatcher;
     prepareSessionAppContext(input: unknown, principal: GatewayPrincipal, conversationId: string, clientMessageId: string): Promise<import("../agent/source-context/types.js").AgentSourceContext>;
     replaceLatestSessionTurn(...args: Parameters<GatewayAgentRunner['replaceLatestSessionTurn']>): Promise<{

package/dist/src/gateway/service.js

@@ -16,17 +16,17 @@ import { init_session_repository, listSessionMetadata, patchSessionMetadata } fr
 import { getSessionConfig, init_config_repository } from "../storage/sqlite/config-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { normalizeAgentId } from "../agent-catalog/id.js";
+import { init_agent_scope, listAgentEntries, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
+import { init_paths, resolveConfigPath, resolveExtensionsDir } from "../config/paths.js";
 import { init_config, resolveKnowledgeReadPolicy } from "../user-context/config.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
-import { init_agent_scope, listAgentEntries, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
+import { prewarmModelRegistry } from "../providers/model-registry.js";
 import { init_agent_session_key, resolveAgentMainConversationId } from "../routing/agent-session-key.js";
 import { init_session_key, resolveConversationId, sanitizeSegment } from "../routing/session-key.js";
 import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
-import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
-import { init_paths, resolveConfigPath, resolveExtensionsDir } from "../config/paths.js";
-import { prewarmModelRegistry } from "../providers/model-registry.js";
 import { init_providers, providers_exports } from "../providers/index.js";
 import { AI_USAGE_RETENTION_MS, markStaleAiUsageEventsUnknown, pruneAiUsageEvents } from "../storage/sqlite/ai-usage-repository.js";
+import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { TaskConversationRepository } from "../tasks/task-conversation-repository.js";
 import { listKnowledgeItems } from "../knowledge-memory/repository.js";
 import "../knowledge-memory/index.js";
@@ -73,24 +73,20 @@ import { ChatPreviewService } from "../chat-previews/service.js";
 import "../chat-previews/index.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
-import { DiscussionService } from "../discussions/service.js";
-import { DiscussionOrganizer } from "../discussions/organizer.js";
-import { DiscussionLiveWorker } from "../discussions/live-worker.js";
-import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
-import { DiscussionSealer } from "../discussions/sealer.js";
-import "../discussions/index.js";
-import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
-import "../endpoint-tools/index.js";
 import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
 import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
 import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
-import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
-import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
-import { HomeIntelligenceHost } from "../home-intelligence/host.js";
-import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
+import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
+import "../endpoint-tools/index.js";
+import { DiscussionService } from "../discussions/service.js";
+import { DiscussionOrganizer } from "../discussions/organizer.js";
+import { DiscussionLiveWorker } from "../discussions/live-worker.js";
+import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
+import { DiscussionSealer } from "../discussions/sealer.js";
+import "../discussions/index.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
@@ -136,6 +132,7 @@ import { GatewaySessionsApi } from "./service/sessions-api.js";
 import { GatewayMarketplaceService } from "./service/marketplace-service.js";
 import { GatewayConfigCoordinator } from "./service/config-coordinator.js";
 import { GatewayAgentRunner } from "./service/agent-runner.js";
+import { SessionPreparationWorker } from "./service/session-preparation-worker.js";
 import { isBrowserSessionActive } from "../storage/sqlite/browser-session-repository.js";
 import { RealtimeRuntime } from "../realtime/runtime.js";
 import { VoiceRealtimeRuntime } from "../voice/realtime/runtime.js";
@@ -146,6 +143,10 @@ import { createGatewayStartupTrace } from "./startup-trace.js";
 import { GatewaySceneHost } from "./scenes/host.js";
 import { checkAppContextAccess, prepareAppContext } from "./service/app-context-access.js";
 import { applyAutomaticVoiceLanguage, inferProductLanguageFromEnvironment, initializeVoiceDefaults } from "../voice/language-profile.js";
+import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
+import { HomeIntelligenceHost } from "../home-intelligence/host.js";
+import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
+import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
 import crypto from "node:crypto";
 //#region src/gateway/service.ts
 init_session_repository();
@@ -312,6 +313,7 @@ var GatewayService = class {
 	* `activeWebchatRunBySession` + `runAbortControllers` maps.
 	*/
 	agentRunner;
+	sessionPreparations = new SessionPreparationWorker(this);
 	/** Process-local, non-persistent side conversations forked from durable sessions. */
 	sideChats;
 	sideChatRuns;
@@ -891,6 +893,15 @@ var GatewayService = class {
 	submitSessionInput(...args) {
 		return this.agentRunner.submitSessionInput(...args);
 	}
+	prepareSessionCommandInput(input) {
+		return this.agentRunner.inputs.prepareInput(input);
+	}
+	drainSessionInputs(conversationId) {
+		return this.agentRunner.inputs.drain(conversationId);
+	}
+	dispatchAcceptedSessionInput(conversationId, inputId) {
+		return this.agentRunner.inputs.dispatchAcceptedInput(conversationId, inputId);
+	}
 	appContextDispatcher() {
 		return createProductDispatcher(() => this.notesService, {
 			getProjects: () => this.projects,
@@ -1142,6 +1153,7 @@ var GatewayService = class {
 		});
 		this.ensureAgentService();
 		this.agentRunner.recoverSessionInputs();
+		this.sessionPreparations.start();
 		this.connectionRecovery.start();
 		this.channelManager.setOutboundHooks({
 			runMessageSending: (to, content, channel) => this.agentService.outboundCoordinator.invokeOutboundMessageSending(to, content, channel),
@@ -1396,6 +1408,7 @@ var GatewayService = class {
 	}
 	async stop() {
 		if (!this.running) return;
+		await this.sessionPreparations.stop();
 		setPairingBroadcastSink(null);
 		this.stopRealtimeLogBridge?.();
 		this.stopRealtimeLogBridge = null;

package/dist/src/gateway/side-chat/promotion-service.js

@@ -54,7 +54,6 @@ var SideChatPromotionService = class {
 						peerId: chatId
 					},
 					customData: {
-						genericNewChatShell: false,
 						promotedFromSideChatId: sideChatId,
 						promotedFromParentTranscriptId: snapshot.context.parentTranscriptId,
 						sideChatContextHash: snapshot.context.contentHash,

package/dist/src/gateway/xopc-cloud-capability-setup.js

@@ -1,7 +1,7 @@
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
 import { compareCatalogModels } from "../providers/model-catalog-ranking.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { prepareUpdateGlobalDefaults } from "./global-defaults-admin.js";
 //#region src/gateway/xopc-cloud-capability-setup.ts
 init_repository();

package/dist/src/home-intelligence/generator.d.ts

@@ -118,8 +118,15 @@ export interface HomeModelGeneration {
         estimatedCostUsd?: number;
     };
 }
+export interface HomeProviderCallBudget {
+    allowProviderCall(): boolean;
+}
+export declare class HomeAdviceBudgetExceededError extends Error {
+    readonly usage: HomeModelGeneration['usage'];
+    constructor(usage?: HomeModelGeneration['usage']);
+}
 export declare class HomeAdviceGenerator {
     private readonly config;
     constructor(config: () => Config);
-    generate(snapshot: HomeContextSnapshot, capabilities: HomeCapabilityInventory, signal?: AbortSignal): Promise<HomeModelGeneration>;
+    generate(snapshot: HomeContextSnapshot, capabilities: HomeCapabilityInventory, signal?: AbortSignal, budget?: HomeProviderCallBudget): Promise<HomeModelGeneration>;
 }

package/dist/src/home-intelligence/generator.js

@@ -1,7 +1,7 @@
 import { init_agent_scope, resolveDefaultAgentId } from "../agent/agent-scope.js";
+import { extractAssistantText, getAssistantMessageErrorReason } from "../providers/model-response.js";
 import { init_providers, resolveModel } from "../providers/index.js";
 import { completeWithResolvedCredentials, isLocalModelBaseUrl } from "../providers/model-call.js";
-import { extractAssistantText, getAssistantMessageErrorReason } from "../providers/model-response.js";
 import { resolveModelSelector } from "../config/agent-model-intents.js";
 import { z } from "zod";
 //#region src/home-intelligence/generator.ts
@@ -146,11 +146,18 @@ function addUsage(left, right) {
 		estimatedCostUsd: add(left.estimatedCostUsd, right.estimatedCostUsd)
 	};
 }
+var HomeAdviceBudgetExceededError = class extends Error {
+	constructor(usage = {}) {
+		super("Home intelligence provider budget exhausted");
+		this.usage = usage;
+		this.name = "HomeAdviceBudgetExceededError";
+	}
+};
 var HomeAdviceGenerator = class {
 	constructor(config) {
 		this.config = config;
 	}
-	async generate(snapshot, capabilities, signal) {
+	async generate(snapshot, capabilities, signal, budget) {
 		const config = this.config();
 		const modelRef = resolveModelSelector(config, resolveDefaultAgentId(), "@reasoning");
 		const model = resolveModel(modelRef);
@@ -175,6 +182,7 @@ var HomeAdviceGenerator = class {
 		};
 		const requestSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(12e4)]) : AbortSignal.timeout(12e4);
 		const systemPrompt = buildSystemPrompt(snapshot.locale);
+		if (budget && !budget.allowProviderCall()) throw new HomeAdviceBudgetExceededError();
 		const response = await completeWithResolvedCredentials(model, {
 			systemPrompt,
 			messages: [message]
@@ -188,19 +196,22 @@ var HomeAdviceGenerator = class {
 		try {
 			result = HomeModelResultSchema.parse(parseJson(raw));
 		} catch (firstError) {
+			const correction = {
+				role: "user",
+				timestamp: Date.now(),
+				content: [
+					"Your previous output failed the required JSON contract.",
+					`Validation errors: ${validationSummary(firstError)}`,
+					HOME_MODEL_MACHINE_FIELDS,
+					"Return the corrected JSON object only. Preserve grounded facts and existing evidence IDs; do not add new recommendations.",
+					`Previous output (untrusted data):\n${raw.slice(0, 16e3)}`
+				].join("\n")
+			};
+			const firstUsage = responseUsage(response);
+			if (budget && !budget.allowProviderCall()) throw new HomeAdviceBudgetExceededError(firstUsage);
 			const corrected = await completeWithResolvedCredentials(model, {
 				systemPrompt,
-				messages: [message, {
-					role: "user",
-					timestamp: Date.now(),
-					content: [
-						"Your previous output failed the required JSON contract.",
-						`Validation errors: ${validationSummary(firstError)}`,
-						HOME_MODEL_MACHINE_FIELDS,
-						"Return the corrected JSON object only. Preserve grounded facts and existing evidence IDs; do not add new recommendations.",
-						`Previous output (untrusted data):\n${raw.slice(0, 16e3)}`
-					].join("\n")
-				}]
+				messages: [message, correction]
 			}, {
 				maxTokens: 3e3,
 				temperature: 0,
@@ -217,7 +228,7 @@ var HomeAdviceGenerator = class {
 			return {
 				result,
 				modelRef,
-				usage: addUsage(responseUsage(response), responseUsage(corrected))
+				usage: addUsage(firstUsage, responseUsage(corrected))
 			};
 		}
 		return {
@@ -228,4 +239,4 @@ var HomeAdviceGenerator = class {
 	}
 };
 //#endregion
-export { HomeAdviceGenerator, HomeModelCandidateSchema, HomeModelResultSchema };
+export { HomeAdviceBudgetExceededError, HomeAdviceGenerator, HomeModelCandidateSchema, HomeModelResultSchema };

package/dist/src/home-intelligence/host.d.ts

@@ -1,12 +1,15 @@
 import type { DatabaseSync } from 'node:sqlite';
 import type { HomeAdviceMetrics, HomeAdvisor, HomeOpportunityHistoryItem } from '@xopcai/gateway-contract';
 import type { HomeOpportunityActionRequest, HomeOpportunityActionResponse, HomeOpportunityFeedbackRequest } from '@xopcai/gateway-contract';
-import type { HomeAdviceGenerator } from './generator.js';
+import { type HomeAdviceGenerator } from './generator.js';
 import { type HomeGenerationReason, type HomePrincipal } from './repository.js';
 import { HomeSnapshotBuilder } from './snapshot.js';
 import type { HomeCapabilityInventory } from './types.js';
 import { type HomeOpportunityNotification } from './notification.js';
 import type { HomeCapabilityRequirement, HomeCapabilityResolution } from './capability-preflight.js';
+export declare const HOME_CONTEXT_REFRESH_COOLDOWN_MS: number;
+export declare const DAILY_HOME_PROVIDER_CALL_BUDGET = 12;
+export declare const DAILY_HOME_TOKEN_BUDGET = 120000;
 export interface HomeIntelligenceHostDeps {
     principal: HomePrincipal;
     snapshot: HomeSnapshotBuilder;
@@ -32,6 +35,8 @@ export declare class HomeIntelligenceHost {
     private stopped;
     private abortController;
     private localeHint;
+    private contextRefreshTimer?;
+    private readonly pendingContextReasons;
     constructor(db: DatabaseSync, deps: HomeIntelligenceHostDeps);
     start(): void;
     stop(): void;
@@ -39,6 +44,8 @@ export declare class HomeIntelligenceHost {
     getMetrics(since?: number): HomeAdviceMetrics;
     getHistory(): HomeOpportunityHistoryItem[];
     requestRefresh(reason: HomeGenerationReason, idempotencyKey?: string, locale?: string): string;
+    private currentFingerprint;
+    private scheduleContextRefresh;
     sourceChanged(input: {
         sourceInstanceId: string;
         revision: string;

package/dist/src/home-intelligence/host.js

@@ -1,9 +1,10 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { HomeAdviceBudgetExceededError } from "./generator.js";
 import { homePatternKey } from "./strategy.js";
+import { HomeAdvicePolicy } from "./policy.js";
 import { HomeIntelligenceRepository } from "./repository.js";
 import { HomeOpportunityApplicationService } from "./application-service.js";
-import { HomeAdvicePolicy } from "./policy.js";
 import { buildHomeOpportunityNotification } from "./notification.js";
 import { createHash } from "node:crypto";
 //#region src/home-intelligence/host.ts
@@ -11,7 +12,16 @@ init_logger();
 const log = createLogger("HomeIntelligence");
 const POLL_INTERVAL_MS = 5e3;
 const GENERATION_LEASE_MS = 5 * 6e4;
-const DAILY_MODEL_GENERATION_BUDGET = 12;
+const HOME_CONTEXT_REFRESH_COOLDOWN_MS = 30 * 6e4;
+const DAILY_HOME_PROVIDER_CALL_BUDGET = 12;
+const DAILY_HOME_TOKEN_BUDGET = 12e4;
+const HOME_USAGE_OPERATION = "home.generate_advice";
+const CONTEXT_REFRESH_REASONS = new Set([
+	"project_changed",
+	"task_changed",
+	"connector_changed",
+	"conversation_changed"
+]);
 function generationFingerprint(snapshotHash, capabilities) {
 	return createHash("sha256").update(JSON.stringify({
 		snapshotHash,
@@ -29,6 +39,8 @@ var HomeIntelligenceHost = class {
 	stopped = false;
 	abortController = new AbortController();
 	localeHint;
+	contextRefreshTimer;
+	pendingContextReasons = /* @__PURE__ */ new Set();
 	constructor(db, deps) {
 		this.deps = deps;
 		this.repository = new HomeIntelligenceRepository(db);
@@ -49,6 +61,9 @@ var HomeIntelligenceHost = class {
 		this.abortController = new AbortController();
 		if (this.timer) clearInterval(this.timer);
 		this.timer = void 0;
+		if (this.contextRefreshTimer) clearTimeout(this.contextRefreshTimer);
+		this.contextRefreshTimer = void 0;
+		this.pendingContextReasons.clear();
 	}
 	getAdvisor() {
 		if (this.deps.enabled?.() === false) return { state: "disabled" };
@@ -65,6 +80,16 @@ var HomeIntelligenceHost = class {
 		if (this.deps.enabled?.() === false) return "disabled";
 		const now = this.now();
 		if (locale) this.localeHint = locale.toLowerCase().startsWith("zh") ? "zh" : "en";
+		if (CONTEXT_REFRESH_REASONS.has(reason)) {
+			const fingerprint = this.currentFingerprint(now);
+			if (this.repository.getLatestSnapshotHash(this.deps.principal) === fingerprint) return "unchanged";
+			const lastRequestedAt = this.repository.getLatestContextRefreshRequestedAt(this.deps.principal);
+			if (lastRequestedAt !== void 0 && now < lastRequestedAt + 18e5) {
+				this.pendingContextReasons.add(reason);
+				this.scheduleContextRefresh(lastRequestedAt + HOME_CONTEXT_REFRESH_COOLDOWN_MS - now);
+				return "cooldown";
+			}
+		}
 		const bucket = Math.floor(now / (reason === "manual_refresh" ? 1 : 5 * 6e4));
 		const request = this.repository.enqueue(this.deps.principal, {
 			idempotencyKey: idempotencyKey ?? `${reason}:${bucket}`,
@@ -74,6 +99,32 @@ var HomeIntelligenceHost = class {
 		this.tick();
 		return request.generationId;
 	}
+	currentFingerprint(now) {
+		const successfulPatterns = this.repository.getSuccessfulPatterns(this.deps.principal);
+		return generationFingerprint(this.deps.snapshot.build({
+			now,
+			locale: this.localeHint,
+			successfulPatterns
+		}).hash, this.deps.capabilities());
+	}
+	scheduleContextRefresh(delayMs) {
+		if (this.contextRefreshTimer) return;
+		this.contextRefreshTimer = setTimeout(() => {
+			this.contextRefreshTimer = void 0;
+			if (this.stopped || this.pendingContextReasons.size === 0) return;
+			const reasons = [...this.pendingContextReasons];
+			this.pendingContextReasons.clear();
+			const now = this.now();
+			if (this.repository.getLatestSnapshotHash(this.deps.principal) === this.currentFingerprint(now)) return;
+			this.repository.enqueue(this.deps.principal, {
+				idempotencyKey: `context_refresh:${Math.floor(now / HOME_CONTEXT_REFRESH_COOLDOWN_MS)}`,
+				reasons,
+				requestedAt: now
+			});
+			this.tick();
+		}, Math.max(1, delayMs));
+		this.contextRefreshTimer.unref?.();
+	}
 	sourceChanged(input) {
 		const now = this.now();
 		const invalidated = this.repository.invalidateOpportunitiesByEvidenceSources(this.deps.principal, new Set([
@@ -174,16 +225,18 @@ var HomeIntelligenceHost = class {
 			let generation;
 			const startOfDay = new Date(startedAt);
 			startOfDay.setHours(0, 0, 0, 0);
-			const modelGenerationAttempts = this.repository.countModelGenerationAttemptsSince(this.deps.principal, startOfDay.getTime(), claim.generationId);
-			const manualRefresh = claim.reasons.includes("manual_refresh");
-			const result = modelGenerationAttempts >= DAILY_MODEL_GENERATION_BUDGET && !manualRefresh ? {
+			const providerBudgetAvailable = () => {
+				const usage = this.repository.getProviderUsageSince(startOfDay.getTime(), HOME_USAGE_OPERATION);
+				return usage.calls < 12 && usage.totalTokens < 12e4;
+			};
+			const result = !providerBudgetAvailable() ? {
 				state: "quiet",
 				reason: "budget_exhausted"
-			} : previousHash === currentFingerprint && !manualRefresh ? {
+			} : previousHash === currentFingerprint && !claim.reasons.includes("manual_refresh") ? {
 				state: "quiet",
 				reason: "no_change"
 			} : await (async () => {
-				generation = await this.deps.generator.generate(snapshot, capabilities, this.abortController.signal);
+				generation = await this.deps.generator.generate(snapshot, capabilities, this.abortController.signal, { allowProviderCall: providerBudgetAvailable });
 				return new HomeAdvicePolicy((requirements, options) => this.resolveCapabilityRequirements(requirements, Boolean(options?.degradedActionAvailable)), this.repository.listSuppressionKeys(this.deps.principal), new Map(successfulPatterns.map((item) => [homePatternKey(item.projectId, item.outcome), item.successCount])), this.repository.getPersonalization(this.deps.principal, this.now())).apply(snapshot, generation.result, this.now());
 			})();
 			const completedAt = this.now();
@@ -212,6 +265,27 @@ var HomeIntelligenceHost = class {
 				this.repository.fail(claim, this.now(), "cancelled", this.now());
 				return;
 			}
+			if (error instanceof HomeAdviceBudgetExceededError) {
+				const completedAt = this.now();
+				this.repository.complete(claim, {
+					result: {
+						state: "quiet",
+						reason: "budget_exhausted"
+					},
+					snapshotHash: currentFingerprint ?? this.repository.getLatestSnapshotHash(this.deps.principal) ?? "budget-exhausted",
+					evidenceIds: [],
+					inputTokens: error.usage.inputTokens,
+					outputTokens: error.usage.outputTokens,
+					estimatedCostUsd: error.usage.estimatedCostUsd,
+					outcomeReason: "budget_exhausted",
+					completedAt
+				});
+				this.deps.publish("home.advisor.updated", {
+					state: "quiet",
+					reason: "budget_exhausted"
+				});
+				return;
+			}
 			const message = error instanceof Error ? error.message : String(error);
 			if (/no api key|no default model|credentials|unknown model|local model/i.test(message)) {
 				const completedAt = this.now();
@@ -246,4 +320,4 @@ var HomeIntelligenceHost = class {
 	}
 };
 //#endregion
-export { HomeIntelligenceHost };
+export { DAILY_HOME_PROVIDER_CALL_BUDGET, DAILY_HOME_TOKEN_BUDGET, HOME_CONTEXT_REFRESH_COOLDOWN_MS, HomeIntelligenceHost };

package/dist/src/home-intelligence/repository.d.ts

@@ -58,7 +58,11 @@ export declare class HomeIntelligenceRepository {
     };
     fail(claim: HomeGenerationClaim, now: number, errorCode: string, retryAt?: number): void;
     getLatestSnapshotHash(principal: HomePrincipal): string | undefined;
-    countModelGenerationAttemptsSince(principal: HomePrincipal, since: number, currentGenerationId: string): number;
+    getLatestContextRefreshRequestedAt(principal: HomePrincipal): number | undefined;
+    getProviderUsageSince(startedAt: number, operation: string): {
+        calls: number;
+        totalTokens: number;
+    };
     listSuppressionKeys(principal: HomePrincipal): Set<string>;
     getSuccessfulPatterns(principal: HomePrincipal): HomeSuccessfulPattern[];
     getPersonalization(principal: HomePrincipal, now: number): HomeAdvicePersonalization;

package/dist/src/home-intelligence/repository.js

@@ -151,16 +151,23 @@ var HomeIntelligenceRepository = class {
           OR outcome_reason NOT IN ('no_change', 'budget_exhausted'))
       ORDER BY completed_at DESC, rowid DESC LIMIT 1`).get(principal.ownerId, principal.workspaceId)?.snapshot_hash ?? void 0;
 	}
-	countModelGenerationAttemptsSince(principal, since, currentGenerationId) {
-		const row = this.db.prepare(`SELECT COALESCE(SUM(CASE
-        WHEN generation_id = ? THEN MAX(attempt - 1, 0)
-        WHEN model_ref IS NOT NULL THEN 1
-        WHEN status IN ('failed', 'retry_wait') THEN attempt
-        ELSE 0
-      END), 0) AS count
+	getLatestContextRefreshRequestedAt(principal) {
+		const row = this.db.prepare(`SELECT MAX(requested_at) AS requested_at
       FROM home_advice_generations
-      WHERE owner_id = ? AND workspace_id = ? AND COALESCE(started_at, requested_at) >= ?`).get(currentGenerationId, principal.ownerId, principal.workspaceId, since);
-		return Number(row.count);
+      WHERE owner_id = ? AND workspace_id = ?
+        AND EXISTS (
+          SELECT 1 FROM json_each(reasons_json)
+          WHERE value IN ('project_changed', 'task_changed', 'connector_changed', 'conversation_changed')
+        )`).get(principal.ownerId, principal.workspaceId);
+		return row.requested_at === null ? void 0 : Number(row.requested_at);
+	}
+	getProviderUsageSince(startedAt, operation) {
+		const row = this.db.prepare(`SELECT COUNT(*) AS calls, COALESCE(SUM(total_tokens), 0) AS total_tokens
+      FROM ai_usage_events WHERE operation = ? AND started_at >= ?`).get(operation, startedAt);
+		return {
+			calls: Number(row.calls),
+			totalTokens: Number(row.total_tokens)
+		};
 	}
 	listSuppressionKeys(principal) {
 		const rows = this.db.prepare(`SELECT f.scope_json, p.kind, p.project_id

package/dist/src/home-intelligence/snapshot.js

@@ -110,10 +110,10 @@ var HomeSnapshotBuilder = class {
 		const successfulPatterns = [...input.successfulPatterns ?? []].filter((item) => item.successCount > 0).sort((left, right) => right.successCount - left.successCount || left.outcome.localeCompare(right.outcome)).slice(0, 20);
 		const stableContent = {
 			locale: input.locale,
-			projects,
-			tasks,
-			knowledge,
-			recentSessions,
+			projects: projects.map(({ updatedAt: _updatedAt, ...project }) => project),
+			tasks: tasks.map(({ updatedAt: _updatedAt, ...task }) => task),
+			knowledge: knowledge.map(({ updatedAt: _updatedAt, ...item }) => item),
+			recentSessions: recentSessions.map(({ updatedAt: _updatedAt, ...session }) => session),
 			successfulPatterns
 		};
 		return {