@xopcai/xopc 0.0.195 → 0.0.197

package/dist/src/agent/embedded/session-runner.js

@@ -2,7 +2,6 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { guardSessionManager } from "./session-tool-result-guard.js";
 import { transformUserMessageForPersistence } from "../inbound/attachment-pipeline.js";
-import { openSqliteHydratingSessionManager } from "./sqlite-hydrating-session-manager.js";
 import { createEmbeddedModelRuntime, resolveEmbeddedProviderApiKeySync } from "./model-runtime.js";
 import { wrapStreamFnForXopcExtensions } from "./xopc-stream-bridge.js";
 import { xopcToolsToDefinitions } from "./xopc-tools-bridge.js";
@@ -46,9 +45,7 @@ function createEmbeddedSettingsManager(cwd) {
 	return sm;
 }
 /**
-* Owns the per-session pool of pi `AgentSession` runners. The class is the supported,
-* injectable owner; {@link defaultEmbeddedSessionRunnerPool} keeps the historic
-* module-level free functions working until every caller is migrated to DI.
+* Owns the per-runtime pool of pi `AgentSession` runners.
 */
 var EmbeddedSessionRunnerPool = class {
 	pool = /* @__PURE__ */ new Map();
@@ -80,13 +77,13 @@ var EmbeddedSessionRunnerPool = class {
 			evictions: 0
 		};
 	}
-	evict(sessionKey, reason = "explicit") {
-		const entry = this.pool.get(sessionKey);
+	evict(runtimeId, reason = "explicit") {
+		const entry = this.pool.get(runtimeId);
 		if (!entry) return;
-		this.disposePooledRunner(sessionKey, entry, reason);
+		this.disposePooledRunner(runtimeId, entry, reason);
 	}
 	evictAll(reason = "dispose_all") {
-		for (const sessionKey of [...this.pool.keys()]) this.evict(sessionKey, reason);
+		for (const runtimeId of [...this.pool.keys()]) this.evict(runtimeId, reason);
 	}
 	async acquire(params) {
 		this.stats.acquires += 1;
@@ -100,7 +97,7 @@ var EmbeddedSessionRunnerPool = class {
 			credentialRevision: providerCredentialRevision(params.model.provider)
 		});
 		const reuseEnabled = this.isEnabledFn();
-		const existing = this.pool.get(params.sessionKey);
+		const existing = this.pool.get(params.runtimeId);
 		let entry;
 		let reused = false;
 		if (reuseEnabled && existing && existing.fingerprint === fingerprint) {
@@ -111,13 +108,13 @@ var EmbeddedSessionRunnerPool = class {
 			this.stats.reuses += 1;
 			applySystemPromptOverrideToSession(entry.session, params.systemPrompt);
 			entry.session.agent.streamFunction = entry.baseStreamFn;
-			log.debug({ sessionKey: params.sessionKey }, "Reusing pooled embedded session runner");
+			log.debug({ runtimeId: params.runtimeId }, "Reusing pooled embedded session runner");
 		} else {
-			if (existing) this.disposePooledRunner(params.sessionKey, existing, "fingerprint_mismatch");
+			if (existing) this.disposePooledRunner(params.runtimeId, existing, "fingerprint_mismatch");
 			entry = await this.createPooledRunner(params);
-			this.pool.set(params.sessionKey, entry);
+			this.pool.set(params.runtimeId, entry);
 			this.stats.creates += 1;
-			log.debug({ sessionKey: params.sessionKey }, "Created embedded session runner");
+			log.debug({ runtimeId: params.runtimeId }, "Created embedded session runner");
 		}
 		return {
 			session: entry.session,
@@ -125,11 +122,11 @@ var EmbeddedSessionRunnerPool = class {
 			reused,
 			release: () => {
 				if (!this.isEnabledFn()) {
-					this.disposePooledRunner(params.sessionKey, entry, "runner_disabled");
+					this.disposePooledRunner(params.runtimeId, entry, "runner_disabled");
 					return;
 				}
 				entry.lastUsedAt = Date.now();
-				this.scheduleIdleEviction(params.sessionKey, entry);
+				this.scheduleIdleEviction(params.runtimeId, entry);
 			}
 		};
 	}
@@ -139,37 +136,33 @@ var EmbeddedSessionRunnerPool = class {
 			entry.idleTimer = null;
 		}
 	}
-	scheduleIdleEviction(sessionKey, entry) {
+	scheduleIdleEviction(runtimeId, entry) {
 		this.clearIdleTimer(entry);
 		const ttlMs = this.getIdleTtlMsFn();
 		entry.idleTimer = setTimeout(() => {
-			if (this.pool.get(sessionKey) === entry) this.disposePooledRunner(sessionKey, entry, "idle_ttl");
+			if (this.pool.get(runtimeId) === entry) this.disposePooledRunner(runtimeId, entry, "idle_ttl");
 		}, ttlMs);
 		entry.idleTimer.unref?.();
 	}
-	disposePooledRunner(sessionKey, entry, reason) {
+	disposePooledRunner(runtimeId, entry, reason) {
 		this.clearIdleTimer(entry);
-		this.pool.delete(sessionKey);
+		this.pool.delete(runtimeId);
 		this.stats.evictions += 1;
 		try {
 			entry.piSm.flushPendingToolResults?.();
 		} catch {}
 		log.debug({
-			sessionKey,
+			runtimeId,
 			reason
 		}, "Embedded session runner evicted");
 	}
 	async createPooledRunner(params) {
-		const { sessionKey, sessionId, workspaceDir, model, thinkingLevel, tools, systemPrompt } = params;
+		const { runtimeId, sessionId, workspaceDir, model, thinkingLevel, tools, systemPrompt } = params;
 		const settingsManager = createEmbeddedSettingsManager(workspaceDir);
-		const piSm = guardSessionManager(openSqliteHydratingSessionManager({
-			sessionKey,
-			sessionId,
-			cwd: workspaceDir
-		}), {
-			sessionKey,
+		const piSm = guardSessionManager(params.transcriptRuntime.openSessionManager(workspaceDir), {
+			sessionKey: params.transcriptRuntime.persistent ? runtimeId : void 0,
 			contextWindowTokens: model.contextWindow ?? 128e3,
-			transformMessageForPersistence: (message) => transformUserMessageForPersistence(sessionKey, message)
+			transformMessageForPersistence: params.transcriptRuntime.persistent ? (message) => transformUserMessageForPersistence(runtimeId, message) : void 0
 		});
 		const toolDefs = xopcToolsToDefinitions(tools);
 		const toolNames = tools.map((t) => t.name);
@@ -197,7 +190,7 @@ var EmbeddedSessionRunnerPool = class {
 		const baseStreamFn = wrapStreamFnForXopcExtensions(session.agent.streamFunction);
 		session.agent.streamFunction = baseStreamFn;
 		return {
-			sessionKey,
+			runtimeId,
 			fingerprint: buildEmbeddedRunnerFingerprint({
 				sessionId,
 				workspaceDir,
@@ -223,8 +216,8 @@ function getEmbeddedSessionRunnerStats() {
 function resetEmbeddedSessionRunnerForTest() {
 	defaultEmbeddedSessionRunnerPool.resetForTest();
 }
-function evictEmbeddedSessionRunner(sessionKey, reason = "explicit") {
-	defaultEmbeddedSessionRunnerPool.evict(sessionKey, reason);
+function evictEmbeddedSessionRunner(runtimeId, reason = "explicit") {
+	defaultEmbeddedSessionRunnerPool.evict(runtimeId, reason);
 }
 function evictAllEmbeddedSessionRunners(reason = "dispose_all") {
 	defaultEmbeddedSessionRunnerPool.evictAll(reason);
@@ -232,9 +225,5 @@ function evictAllEmbeddedSessionRunners(reason = "dispose_all") {
 function acquireEmbeddedSessionRunner(params) {
 	return defaultEmbeddedSessionRunnerPool.acquire(params);
 }
-/** Resolve session identity used by embedded runner acquire and turn execution. */
-async function resolveEmbeddedTranscriptInputs(sessionStore, sessionKey) {
-	return sessionStore.resolveTranscriptPath(sessionKey);
-}
 //#endregion
-export { EmbeddedSessionRunnerPool, acquireEmbeddedSessionRunner, buildEmbeddedRunnerFingerprint, defaultEmbeddedSessionRunnerPool, evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner, getEmbeddedSessionRunnerIdleTtlMs, getEmbeddedSessionRunnerStats, isEmbeddedSessionRunnerEnabled, resetEmbeddedSessionRunnerForTest, resolveEmbeddedTranscriptInputs };
+export { EmbeddedSessionRunnerPool, acquireEmbeddedSessionRunner, buildEmbeddedRunnerFingerprint, defaultEmbeddedSessionRunnerPool, evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner, getEmbeddedSessionRunnerIdleTtlMs, getEmbeddedSessionRunnerStats, isEmbeddedSessionRunnerEnabled, resetEmbeddedSessionRunnerForTest };

package/dist/src/agent/embedded/transcript-runtime.d.ts

@@ -0,0 +1,35 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import { SessionManager } from '@earendil-works/pi-coding-agent';
+import type { Api, Model } from '@earendil-works/pi-ai';
+import { type CompactionExecutionOptions, type CompactionResult } from '../memory/compaction.js';
+import type { SessionStore } from '../../session/store.js';
+export interface EmbeddedTranscriptRuntime {
+    readonly runtimeId: string;
+    readonly sessionId: string;
+    readonly persistent: boolean;
+    openSessionManager(cwd: string): SessionManager;
+    loadMessages(): Promise<AgentMessage[]>;
+    compact(messages: AgentMessage[], model: Model<Api>, instructions?: string, force?: boolean, options?: CompactionExecutionOptions): Promise<CompactionResult>;
+}
+export declare function createSqliteTranscriptRuntime(params: {
+    sessionKey: string;
+    sessionStore: SessionStore;
+}): Promise<EmbeddedTranscriptRuntime>;
+export declare class InMemoryTranscriptRuntime implements EmbeddedTranscriptRuntime {
+    readonly persistent = false;
+    readonly runtimeId: string;
+    readonly sessionId: string;
+    private readonly sessionManager;
+    private readonly compactor;
+    private baselineEntryCount;
+    constructor(params: {
+        runtimeId: string;
+        cwd: string;
+        initialMessages?: readonly AgentMessage[];
+    });
+    openSessionManager(_cwd: string): SessionManager;
+    loadMessages(): Promise<AgentMessage[]>;
+    captureBaseline(): void;
+    loadConversationMessages(): AgentMessage[];
+    compact(messages: AgentMessage[], model: Model<Api>, instructions?: string, force?: boolean, options?: CompactionExecutionOptions): Promise<CompactionResult>;
+}

package/dist/src/agent/embedded/transcript-runtime.js

@@ -0,0 +1,66 @@
+import { SessionCompactor } from "../memory/compaction.js";
+import { openSqliteHydratingSessionManager } from "./sqlite-hydrating-session-manager.js";
+import crypto from "node:crypto";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+//#region src/agent/embedded/transcript-runtime.ts
+async function createSqliteTranscriptRuntime(params) {
+	const identity = await params.sessionStore.resolveTranscriptPath(params.sessionKey);
+	return {
+		runtimeId: params.sessionKey,
+		sessionId: identity.sessionId,
+		persistent: true,
+		openSessionManager: (cwd) => openSqliteHydratingSessionManager({
+			sessionKey: params.sessionKey,
+			sessionId: identity.sessionId,
+			cwd
+		}),
+		loadMessages: () => params.sessionStore.load(params.sessionKey),
+		compact: (messages, model, instructions, force, options) => params.sessionStore.compact(params.sessionKey, messages, model, instructions, force, options)
+	};
+}
+var InMemoryTranscriptRuntime = class {
+	persistent = false;
+	runtimeId;
+	sessionId;
+	sessionManager;
+	compactor = new SessionCompactor();
+	baselineEntryCount = 0;
+	constructor(params) {
+		this.runtimeId = params.runtimeId;
+		this.sessionId = crypto.randomUUID();
+		this.sessionManager = SessionManager.inMemory(params.cwd, { id: this.sessionId });
+		for (const message of params.initialMessages ?? []) if (message.role === "compactionSummary") this.sessionManager.appendCustomMessageEntry("side-chat-parent-compaction", `The parent conversation was compacted into this summary:\n\n${message.summary}`, false);
+		else if (message.role === "branchSummary") this.sessionManager.appendCustomMessageEntry("side-chat-parent-branch", `The parent conversation includes this branch summary:\n\n${message.summary}`, false);
+		else this.sessionManager.appendMessage(message);
+		this.captureBaseline();
+	}
+	openSessionManager(_cwd) {
+		return this.sessionManager;
+	}
+	async loadMessages() {
+		return [...this.sessionManager.buildSessionContext().messages];
+	}
+	captureBaseline() {
+		this.baselineEntryCount = this.sessionManager.getBranch().length;
+	}
+	loadConversationMessages() {
+		return this.sessionManager.getBranch().slice(this.baselineEntryCount).flatMap((entry) => entry.type === "message" ? [entry.message] : []);
+	}
+	async compact(messages, model, instructions, force, options) {
+		const result = await this.compactor.compact(messages, model, instructions, force, options);
+		if (!result.compacted) return result;
+		const firstKept = this.sessionManager.getBranch().filter((entry) => entry.type === "message")[result.firstKeptIndex];
+		if (!firstKept) return {
+			...result,
+			compacted: false
+		};
+		this.sessionManager.appendCompaction(result.summary, firstKept.id, result.tokensBefore, {
+			plannerVersion: result.plannerVersion,
+			summaryModelRef: result.summaryModelRef,
+			qualityAudit: result.qualityAudit
+		});
+		return result;
+	}
+};
+//#endregion
+export { InMemoryTranscriptRuntime, createSqliteTranscriptRuntime };

package/dist/src/agent/embedded/types.d.ts

@@ -1,6 +1,7 @@
 import type { AgentMessage, AgentToolResult, ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { AssistantMessageEvent, Model, Api, CacheRetention, ImageContent } from '@earendil-works/pi-ai';
 import type { SessionStore } from '../../session/store.js';
+import type { EmbeddedTranscriptRuntime } from './transcript-runtime.js';
 export type EmbeddedStreamEvent = {
     type: 'agent_start';
     runId?: string;
@@ -93,7 +94,8 @@ export type RunXopcEmbeddedTurnParams = {
     thinkingLevel?: ThinkingLevel;
     cacheRetention?: CacheRetention;
     workspaceDir: string;
-    sessionStore: SessionStore;
+    sessionStore?: SessionStore;
+    transcriptRuntime?: EmbeddedTranscriptRuntime;
     timeoutMs: number;
     abortSignal?: AbortSignal;
     onEvent?: (event: EmbeddedStreamEvent) => void;

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

@@ -1,7 +1,10 @@
+import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { MessageBus } from '../infra/bus/index.js';
 import { type Config } from '../config/schema.js';
 import type { ChannelManager } from '../channels/manager.js';
 import { SessionStore } from '../session/index.js';
+import type { EmbeddedStreamEvent, RunXopcEmbeddedTurnResult } from './embedded/types.js';
+import type { EmbeddedTranscriptRuntime } from './embedded/transcript-runtime.js';
 import { OutboundCoordinator } from './messaging/index.js';
 import { TurnDispatcher } from './inbound/turn-dispatcher.js';
 import { SessionConfigService, SessionHydrator, SessionInspector } from './session/index.js';
@@ -114,6 +117,18 @@ export declare class AgentService {
     refreshUserProfileContext(): void;
     getMemoryManager(): import("./memory/manager.js").MemoryManager;
     getModelForSession(sessionKey: string): string;
+    /** Run a full tool-capable turn against a caller-owned, non-persistent transcript. */
+    runEphemeralTurn(params: {
+        executionSessionKey: string;
+        parentSessionKey: string;
+        runId: string;
+        content: string;
+        modelRef: string;
+        thinkingLevel?: ThinkingLevel;
+        transcriptRuntime: EmbeddedTranscriptRuntime;
+        abortSignal?: AbortSignal;
+        onEvent?: (event: EmbeddedStreamEvent) => void;
+    }): Promise<RunXopcEmbeddedTurnResult>;
     switchModelForSession(sessionKey: string, modelId: string): Promise<boolean>;
     /**
      * Clears per-session model override so the next turn uses the configured agent default

package/dist/src/agent/service.js

@@ -6,9 +6,11 @@ import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { applyConfigOverrides } from "../config/runtime-overrides.js";
 import { init_agent_scope, resolveAgentHomeDir, resolveDefaultAgentId } from "./agent-scope.js";
 import { extractProfileAgentId } from "../config/agent-profile.js";
+import { init_providers, resolveModel } from "../providers/index.js";
 import { extractTextContent } from "./context/workspace.js";
 import { effectiveWorkspacePathForSession } from "../session/session-workspace.js";
 import { getProjectForSession } from "../projects/workspace.js";
+import { resolveAgentTurnTimeoutMs } from "./orchestration/run-agent-turn-with-timeout.js";
 import { resolveResponseLanguageForSession } from "./prompt/response-language.js";
 import { resolveWorkspaceSkillsDir, resolveWorkspaceSkillsLockPath } from "./skills/workspace-skills-dir.js";
 import { removeSkillsLockEntry } from "./skills/hub-lock.js";
@@ -42,6 +44,8 @@ import "./middleware/index.js";
 import { TurnDiffTracker } from "./coding/turn-diff-tracker.js";
 import { LifecycleManager } from "./lifecycle/manager.js";
 import "./lifecycle/index.js";
+import { runXopcEmbeddedTurn } from "./embedded/run-turn.js";
+import { runWithEmbeddedExecutionSession } from "./embedded/execution-context.js";
 import { MessageRouter } from "./messaging/message-router.js";
 import { CommandHandler } from "./messaging/command-handler.js";
 import { StreamManager } from "./messaging/stream-manager.js";
@@ -68,6 +72,7 @@ import { readFile } from "node:fs/promises";
 init_schema();
 init_logger();
 init_agent_scope();
+init_providers();
 const log = createLogger("AgentService");
 function assistantMessageText(message) {
 	const content = message.content;
@@ -563,6 +568,31 @@ var AgentService = class {
 	getModelForSession(sessionKey) {
 		return this.modelManager.getModelForSession(sessionKey);
 	}
+	/** Run a full tool-capable turn against a caller-owned, non-persistent transcript. */
+	async runEphemeralTurn(params) {
+		const agent = this.agentManager.getOrCreateAgent(params.parentSessionKey);
+		const workspaceDir = this.agentManager.getResolvedWorkspaceForSession(params.parentSessionKey);
+		const model = resolveModel(params.modelRef);
+		return runWithEmbeddedExecutionSession(params.executionSessionKey, () => runXopcEmbeddedTurn({
+			sessionKey: params.executionSessionKey,
+			runId: params.runId,
+			userMessage: {
+				role: "user",
+				content: params.content,
+				timestamp: Date.now()
+			},
+			model,
+			modelRef: params.modelRef,
+			tools: agent.state.tools,
+			systemPrompt: agent.state.systemPrompt ?? "",
+			thinkingLevel: params.thinkingLevel ?? agent.state.thinkingLevel,
+			workspaceDir,
+			transcriptRuntime: params.transcriptRuntime,
+			timeoutMs: resolveAgentTurnTimeoutMs(this.effectiveAppConfig(), params.parentSessionKey),
+			abortSignal: params.abortSignal,
+			onEvent: params.onEvent
+		}));
+	}
 	async switchModelForSession(sessionKey, modelId) {
 		if (!await this.modelManager.switchModelForSession(sessionKey, modelId)) return false;
 		await this.sessionConfigStore.update(sessionKey, { modelOverride: modelId });

package/dist/src/config/agent-profile.js

@@ -1,6 +1,6 @@
-import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import "../agent-manifest/index.js";
+import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
 import { init_session_key, parseSessionKey } from "../routing/session-key.js";
 import { agentExists, getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 //#region src/config/agent-profile.ts

package/dist/src/gateway/agents-admin.js

@@ -1,5 +1,5 @@
-import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
 import { resolveCapabilityPresetLayer, resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
+import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentProfile } from "../config/agent-profile.js";
 import { WORKSPACE_FILES, init_paths } from "../config/paths.js";
 import { AGENT_PROFILE_MARKDOWN_SYSTEM_FILES, REQUIRED_AGENT_PROFILE_MARKDOWN_FILE_SET } from "../agent/context/workspace.js";

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";

package/dist/src/gateway/hono/routes/home.d.ts

@@ -1,5 +1,5 @@
 import type { Hono } from 'hono';
 import type { AuthenticatedRouteDeps } from './deps.js';
-export { buildHomeBriefing } from '../../../tasks/home-query-service.js';
+export { buildHomeBriefing, buildHomeFocusItems } from '../../../tasks/home-query-service.js';
 /** Register the unified work-home read model and its decision actions. */
 export declare function registerHomeRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/home.js

@@ -2,7 +2,7 @@ import { acknowledgeHomeAttention } from "../../../storage/sqlite/home-attention
 import { decideConnectorApproval } from "../../../storage/sqlite/connector-repository.js";
 import "../../../storage/sqlite/index.js";
 import { listGatewayAgents } from "../../agents-admin.js";
-import { HomeQueryService, buildHomeBriefing } from "../../../tasks/home-query-service.js";
+import { HomeQueryService, buildHomeBriefing, buildHomeFocusItems } from "../../../tasks/home-query-service.js";
 //#region src/gateway/hono/routes/home.ts
 /** Register the unified work-home read model and its decision actions. */
 function registerHomeRoutes(authenticated, deps) {
@@ -90,4 +90,4 @@ function registerHomeRoutes(authenticated, deps) {
 	});
 }
 //#endregion
-export { buildHomeBriefing, registerHomeRoutes };
+export { buildHomeBriefing, buildHomeFocusItems, registerHomeRoutes };

package/dist/src/gateway/hono/routes/index.js

@@ -2,6 +2,7 @@ import { registerActivityRoutes } from "./activity.js";
 import { registerAgentStreamRoutes } from "./agent-stream.js";
 import { registerDiscussionRoutes } from "./discussions.js";
 import { registerSessionsRoutes } from "./sessions.js";
+import { registerSideChatRoutes } from "./side-chats.js";
 import { registerStatusRoutes } from "./status.js";
 import { registerProjectsRoutes } from "./projects.js";
 import { registerProjectSkillRoutes } from "./project-skills.js";
@@ -22,6 +23,7 @@ function registerCoreAuthenticatedRoutes(authenticated, deps) {
 	registerStatusRoutes(authenticated, deps);
 	registerAgentStreamRoutes(authenticated, deps);
 	registerSessionsRoutes(authenticated, deps);
+	registerSideChatRoutes(authenticated, deps);
 	registerActivityRoutes(authenticated, deps);
 	registerDiscussionRoutes(authenticated, deps);
 	registerProjectsRoutes(authenticated, deps);

package/dist/src/gateway/hono/routes/projects.js

@@ -16,6 +16,7 @@ import { buildProjectLoopOverview } from "../../../projects/project-loop.js";
 import "../../../projects/index.js";
 import { TaskApplicationService } from "../../../tasks/task-application-service.js";
 import { defineTaskContract } from "../../../tasks/task-contract-definition.js";
+import { ProjectOperatingViewService, summarizeProjectOperatingView } from "../../../tasks/project-operating-view-service.js";
 import "../../../tasks/index.js";
 import { classifyFileReferenceFsError } from "../../file-reference-errors.js";
 import { createGatewayRouteLogger } from "../lib/route-logger.js";
@@ -313,6 +314,7 @@ function projectDigestMemoryRecordId(projectId) {
 function registerProjectsRoutes(authenticated, deps) {
 	const { service } = deps;
 	const activity = new ActivityService();
+	const operatingViews = new ProjectOperatingViewService(service.projects);
 	authenticated.post("/api/projects", async (c) => {
 		const body = await c.req.json().catch(() => ({}));
 		const name = textField(body, "name")?.trim();
@@ -385,10 +387,19 @@ function registerProjectsRoutes(authenticated, deps) {
 			limit: parseLimit(c.req.query("limit")),
 			offset: c.req.query("offset") ? Math.max(0, Number.parseInt(c.req.query("offset"), 10) || 0) : void 0
 		});
+		const includeOperating = c.req.query("includeOperating") === "true";
 		return c.json({
 			ok: true,
 			...result,
-			items: result.items.map((project) => enrichProjectWorkspace(service, project))
+			items: result.items.map((project) => {
+				const enriched = enrichProjectWorkspace(service, project);
+				if (!includeOperating) return enriched;
+				const view = operatingViews.get(project.id);
+				return {
+					...enriched,
+					operating: view ? summarizeProjectOperatingView(view) : void 0
+				};
+			})
 		});
 	});
 	authenticated.get("/api/projects/suggestions", async (c) => {

package/dist/src/gateway/hono/routes/side-chats.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerSideChatRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/side-chats.js

@@ -0,0 +1,173 @@
+import { validateWebchatContent } from "../../chat-limits.js";
+import { validateSideChatSelections } from "../../side-chat/context-snapshot.js";
+import { SideChatError, parseThinkingLevel } from "../../side-chat/manager.js";
+import "../../side-chat/index.js";
+import { createGatewayRouteLogger, logRouteError } from "../lib/route-logger.js";
+//#region src/gateway/hono/routes/side-chats.ts
+const CLIENT_HEADER = "x-xopc-client-instance-id";
+const log = createGatewayRouteLogger("SideChats");
+function registerSideChatRoutes(authenticated, deps) {
+	const { service } = deps;
+	authenticated.post("/api/sessions/:parentSessionKey/side-chats", deps.chatRateLimitMiddleware, async (c) => {
+		try {
+			const body = await c.req.json().catch(() => ({}));
+			const clientInstanceId = readClientInstanceId(c, body.clientInstanceId);
+			if (body.modelRef !== void 0 && typeof body.modelRef !== "string") throw new SideChatError("modelRef must be a string", "INVALID_REQUEST");
+			const modelRef = typeof body.modelRef === "string" ? body.modelRef : void 0;
+			let selections;
+			try {
+				selections = validateSideChatSelections(body.selections);
+			} catch (error) {
+				throw new SideChatError(error instanceof Error ? error.message : "Invalid selections", "INVALID_REQUEST");
+			}
+			const sideChat = await service.sideChats.create({
+				parentSessionKey: c.req.param("parentSessionKey"),
+				clientInstanceId,
+				selections,
+				config: {
+					modelRef,
+					thinkingLevel: parseThinkingLevel(body.thinkingLevel)
+				}
+			});
+			return c.json({
+				ok: true,
+				sideChat
+			}, 201);
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+	authenticated.get("/api/side-chats/:sideChatId", (c) => {
+		try {
+			const sideChat = service.sideChats.get(c.req.param("sideChatId"), readClientInstanceId(c));
+			return c.json({
+				ok: true,
+				sideChat
+			});
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+	authenticated.get("/api/side-chats/:sideChatId/messages", (c) => {
+		try {
+			const messages = service.sideChats.getMessages(c.req.param("sideChatId"), readClientInstanceId(c));
+			return c.json({
+				ok: true,
+				messages
+			});
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+	authenticated.patch("/api/side-chats/:sideChatId/config", async (c) => {
+		try {
+			const body = await c.req.json().catch(() => ({}));
+			if (body.modelRef !== void 0 && typeof body.modelRef !== "string") throw new SideChatError("modelRef must be a string", "INVALID_REQUEST");
+			const modelRef = typeof body.modelRef === "string" ? body.modelRef : void 0;
+			const sideChat = service.sideChats.updateConfig(c.req.param("sideChatId"), readClientInstanceId(c, body.clientInstanceId), {
+				modelRef,
+				thinkingLevel: parseThinkingLevel(body.thinkingLevel)
+			});
+			return c.json({
+				ok: true,
+				sideChat
+			});
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+	authenticated.post("/api/side-chats/:sideChatId/heartbeat", (c) => {
+		try {
+			const sideChat = service.sideChats.heartbeat(c.req.param("sideChatId"), readClientInstanceId(c));
+			return c.json({
+				ok: true,
+				sideChat
+			});
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+	authenticated.post("/api/side-chats/:sideChatId/inputs", deps.chatRateLimitMiddleware, async (c) => {
+		try {
+			const body = await c.req.json().catch(() => ({}));
+			const content = typeof body.content === "string" ? body.content : "";
+			const contentError = validateWebchatContent(content);
+			if (contentError) throw new SideChatError(contentError, "INVALID_REQUEST");
+			const result = service.sideChatRuns.submit(c.req.param("sideChatId"), readClientInstanceId(c, body.clientInstanceId), content);
+			return c.json({
+				ok: true,
+				payload: result
+			}, 202);
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+	authenticated.post("/api/side-chats/:sideChatId/abort", deps.chatRateLimitMiddleware, async (c) => {
+		try {
+			const body = await c.req.json().catch(() => ({}));
+			const aborted = await service.sideChatRuns.abort(c.req.param("sideChatId"), readClientInstanceId(c, body.clientInstanceId), typeof body.runId === "string" ? body.runId : void 0);
+			return c.json({
+				ok: true,
+				payload: { aborted }
+			});
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+	authenticated.post("/api/side-chats/:sideChatId/clarify/:requestId", deps.chatRateLimitMiddleware, async (c) => {
+		try {
+			const body = await c.req.json().catch(() => ({}));
+			const answer = body.skip === true ? "" : typeof body.answer === "string" ? body.answer.trim() : "";
+			if (body.skip !== true && !answer) throw new SideChatError("answer is required", "INVALID_REQUEST");
+			if (!service.sideChatRuns.submitClarification(c.req.param("sideChatId"), readClientInstanceId(c, body.clientInstanceId), c.req.param("requestId"), answer)) throw new SideChatError("Clarification request not found", "NOT_FOUND");
+			return c.json({ ok: true });
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+	authenticated.delete("/api/side-chats/:sideChatId", async (c) => {
+		try {
+			return await service.sideChatRuns.dispose(c.req.param("sideChatId"), readClientInstanceId(c)) ? c.json({ ok: true }) : c.json({
+				ok: false,
+				error: "Side chat not found",
+				code: "NOT_FOUND"
+			}, 404);
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+	authenticated.delete("/api/side-chats", async (c) => {
+		try {
+			const removed = await service.sideChats.disposeClient(readClientInstanceId(c, c.req.query("clientInstanceId")));
+			return c.json({
+				ok: true,
+				removed
+			});
+		} catch (error) {
+			return respondSideChatError(c, error);
+		}
+	});
+}
+function readClientInstanceId(c, fallback) {
+	const value = c.req.header(CLIENT_HEADER) || (typeof fallback === "string" ? fallback : "");
+	if (!value.trim()) throw new SideChatError("clientInstanceId is required", "INVALID_REQUEST");
+	return value.trim();
+}
+function respondSideChatError(c, error) {
+	if (!(error instanceof SideChatError)) {
+		logRouteError(log, c, error, "Side chat request failed");
+		return c.json({
+			ok: false,
+			error: "Side chat request failed",
+			code: "INTERNAL_ERROR"
+		}, 500);
+	}
+	const status = error.code === "NOT_FOUND" ? 404 : error.code === "CONFLICT" ? 409 : error.code === "LIMIT_REACHED" ? 429 : 400;
+	return c.json({
+		ok: false,
+		error: error.message,
+		code: error.code
+	}, status);
+}
+//#endregion
+export { registerSideChatRoutes };