@clinebot/core 0.0.6 → 0.0.10

package/src/session/session-team-coordination.ts

@@ -0,0 +1,198 @@
+import type { AgentResult, TeamEvent } from "@clinebot/agents";
+import { formatUserInputBlock } from "@clinebot/shared";
+import {
+	buildTeamProgressSummary,
+	toTeamProgressLifecycleEvent,
+} from "../team";
+import type { CoreSessionEvent } from "../types/events";
+import type { ActiveSession, TeamRunUpdate } from "./utils/types";
+
+export function trackTeamRunState(
+	session: ActiveSession,
+	event: TeamEvent,
+): void {
+	switch (event.type) {
+		case "run_queued":
+		case "run_started":
+			session.activeTeamRunIds.add(event.run.id);
+			break;
+		case "run_completed":
+		case "run_failed":
+		case "run_cancelled":
+		case "run_interrupted": {
+			let runError: string | undefined;
+			if (event.type === "run_failed") {
+				runError = event.run.error;
+			} else if (
+				event.type === "run_cancelled" ||
+				event.type === "run_interrupted"
+			) {
+				runError = event.run.error ?? event.reason;
+			}
+			session.activeTeamRunIds.delete(event.run.id);
+			session.pendingTeamRunUpdates.push({
+				runId: event.run.id,
+				agentId: event.run.agentId,
+				taskId: event.run.taskId,
+				status: event.type.replace("run_", "") as TeamRunUpdate["status"],
+				error: runError,
+				iterations: event.run.result?.iterations,
+			});
+			notifyTeamRunWaiters(session);
+			break;
+		}
+		default:
+			break;
+	}
+}
+
+export async function dispatchTeamEventToBackend(
+	rootSessionId: string,
+	event: TeamEvent,
+	invokeOptional: (method: string, ...args: unknown[]) => Promise<void>,
+): Promise<void> {
+	switch (event.type) {
+		case "task_start":
+			await invokeOptional(
+				"onTeamTaskStart",
+				rootSessionId,
+				event.agentId,
+				event.message,
+			);
+			break;
+		case "task_end": {
+			if (event.error) {
+				await invokeOptional(
+					"onTeamTaskEnd",
+					rootSessionId,
+					event.agentId,
+					"failed",
+					`[error] ${event.error.message}`,
+					event.messages,
+				);
+			} else if (event.result?.finishReason === "aborted") {
+				await invokeOptional(
+					"onTeamTaskEnd",
+					rootSessionId,
+					event.agentId,
+					"cancelled",
+					"[done] aborted",
+					event.result.messages,
+				);
+			} else {
+				await invokeOptional(
+					"onTeamTaskEnd",
+					rootSessionId,
+					event.agentId,
+					"completed",
+					`[done] ${event.result?.finishReason ?? "completed"}`,
+					event.result?.messages,
+				);
+			}
+			break;
+		}
+		default:
+			break;
+	}
+}
+
+export function emitTeamProgress(
+	session: ActiveSession,
+	rootSessionId: string,
+	event: TeamEvent,
+	emit: (event: CoreSessionEvent) => void,
+): void {
+	if (!session.runtime.teamRuntime) return;
+	const teamName = session.config.teamName?.trim() || "team";
+	emit({
+		type: "team_progress",
+		payload: {
+			sessionId: rootSessionId,
+			teamName,
+			lifecycle: toTeamProgressLifecycleEvent({
+				teamName,
+				sessionId: rootSessionId,
+				event,
+			}),
+			summary: buildTeamProgressSummary(
+				teamName,
+				session.runtime.teamRuntime.exportState(),
+			),
+		},
+	});
+}
+
+export function hasPendingTeamRunWork(session: ActiveSession): boolean {
+	return (
+		session.activeTeamRunIds.size > 0 ||
+		session.pendingTeamRunUpdates.length > 0
+	);
+}
+
+export function shouldAutoContinueTeamRuns(
+	session: ActiveSession,
+	finishReason: AgentResult["finishReason"],
+): boolean {
+	if (
+		session.aborting ||
+		finishReason === "aborted" ||
+		finishReason === "error"
+	) {
+		return false;
+	}
+	return (
+		session.config.enableAgentTeams === true && hasPendingTeamRunWork(session)
+	);
+}
+
+export function notifyTeamRunWaiters(session: ActiveSession): void {
+	const waiters = session.teamRunWaiters.splice(0);
+	for (const resolve of waiters) resolve();
+}
+
+export async function waitForTeamRunUpdates(
+	session: ActiveSession,
+): Promise<TeamRunUpdate[]> {
+	while (true) {
+		if (session.aborting) return [];
+		if (session.pendingTeamRunUpdates.length > 0) {
+			const updates = [...session.pendingTeamRunUpdates];
+			session.pendingTeamRunUpdates.length = 0;
+			return updates;
+		}
+		if (session.activeTeamRunIds.size === 0) return [];
+		await new Promise<void>((resolve) => {
+			session.teamRunWaiters.push(resolve);
+		});
+	}
+}
+
+export function buildTeamRunContinuationPrompt(
+	session: ActiveSession,
+	updates: TeamRunUpdate[],
+): string {
+	const lines = updates.map((u) => {
+		const parts = [`- ${u.runId} (${u.agentId}) -> ${u.status}`];
+		if (u.taskId) parts.push(` task=${u.taskId}`);
+		if (typeof u.iterations === "number")
+			parts.push(` iterations=${u.iterations}`);
+		if (u.error) parts.push(` error=${u.error}`);
+		return parts.join("");
+	});
+	const remaining = session.activeTeamRunIds.size;
+	const instruction =
+		remaining > 0
+			? `There are still ${remaining} teammate run(s) in progress. Continue coordination and decide whether to wait for more updates.`
+			: "No teammate runs are currently in progress. Continue coordination using these updates.";
+	return formatModePrompt(
+		`System-delivered teammate async run updates:\n${lines.join("\n")}\n\n${instruction}`,
+		session.config.mode,
+	);
+}
+
+export function formatModePrompt(
+	prompt: string,
+	mode: "act" | "plan" | undefined,
+): string {
+	return formatUserInputBlock(prompt, mode === "plan" ? "plan" : "act");
+}

package/src/session/session-telemetry.ts

@@ -0,0 +1,95 @@
+import type { ITelemetryService } from "@clinebot/shared";
+import {
+	listHookConfigFiles,
+	resolveDocumentsHooksDirectoryPath,
+} from "../agents/hooks-config-loader";
+import type { enrichPromptWithMentions } from "../input";
+import {
+	captureHookDiscovery,
+	captureMentionFailed,
+	captureMentionSearchResults,
+	captureMentionUsed,
+	captureTaskCreated,
+	captureTaskRestarted,
+} from "../telemetry/core-events";
+import type { SessionSource } from "../types/common";
+import type { CoreSessionConfig } from "../types/config";
+
+export function emitSessionCreationTelemetry(
+	config: CoreSessionConfig,
+	sessionId: string,
+	source: SessionSource,
+	isRestart: boolean,
+	workspacePath: string,
+): void {
+	if (isRestart) {
+		captureTaskRestarted(config.telemetry, {
+			ulid: sessionId,
+			apiProvider: config.providerId,
+		});
+	} else {
+		captureTaskCreated(config.telemetry, {
+			ulid: sessionId,
+			apiProvider: config.providerId,
+		});
+	}
+	captureHookDiscoveryTelemetry(config.telemetry, { workspacePath });
+	config.telemetry?.capture({
+		event: "session.started",
+		properties: {
+			sessionId,
+			source,
+			providerId: config.providerId,
+			modelId: config.modelId,
+			enableTools: config.enableTools,
+			enableSpawnAgent: config.enableSpawnAgent,
+			enableAgentTeams: config.enableAgentTeams,
+		},
+	});
+}
+
+export function captureHookDiscoveryTelemetry(
+	telemetry: ITelemetryService | undefined,
+	options: { workspacePath: string },
+): void {
+	const globalHooksDir = resolveDocumentsHooksDirectoryPath();
+	const entries = listHookConfigFiles(options.workspacePath);
+	const counts = new Map<string, { global: number; workspace: number }>();
+	for (const entry of entries) {
+		const hookName = entry.hookEventName ?? "unknown";
+		const current = counts.get(hookName) ?? { global: 0, workspace: 0 };
+		if (
+			entry.path === globalHooksDir ||
+			entry.path.startsWith(`${globalHooksDir}/`)
+		) {
+			current.global += 1;
+		} else {
+			current.workspace += 1;
+		}
+		counts.set(hookName, current);
+	}
+	for (const [hookName, count] of counts.entries()) {
+		captureHookDiscovery(telemetry, hookName, count.global, count.workspace);
+	}
+}
+
+export function emitMentionTelemetry(
+	telemetry: ITelemetryService | undefined,
+	enriched: Awaited<ReturnType<typeof enrichPromptWithMentions>>,
+): void {
+	for (const mention of enriched.mentions) {
+		captureMentionSearchResults(
+			telemetry,
+			mention,
+			enriched.matchedFiles.includes(mention) ? 1 : 0,
+			"file",
+			!enriched.matchedFiles.includes(mention),
+		);
+	}
+	for (const matched of enriched.matchedFiles) {
+		captureMentionUsed(telemetry, "file", matched.length);
+	}
+	for (const ignored of enriched.ignoredMentions) {
+		captureMentionFailed(telemetry, "file", "not_found", ignored);
+	}
+}

package/src/session/unified-session-persistence-service.test.ts

@@ -0,0 +1,81 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { SqliteSessionStore } from "../storage/sqlite-session-store";
+import { SessionSource } from "../types/common";
+import { CoreSessionService } from "./session-service";
+
+describe("UnifiedSessionPersistenceService", () => {
+	const tempDirs: string[] = [];
+
+	afterEach(() => {
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("reconciles dead running sessions into failed manifests with terminal markers", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "stale-session-reconcile-"));
+		tempDirs.push(sessionsDir);
+
+		const service = new CoreSessionService(
+			new SqliteSessionStore({ sessionsDir }),
+		);
+		const sessionId = "stale-root-session";
+		const artifacts = await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: 999_999_999,
+			interactive: false,
+			provider: "mock-provider",
+			model: "mock-model",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: true,
+			enableTeams: false,
+			prompt: "hello",
+			startedAt: "2026-01-01T00:00:00.000Z",
+		});
+
+		const reconciled = await service.reconcileDeadSessions();
+		expect(reconciled).toBe(1);
+
+		const rows = await service.listSessions(10);
+		expect(rows).toHaveLength(1);
+		expect(rows[0]).toMatchObject({
+			session_id: sessionId,
+			status: "failed",
+			exit_code: 1,
+		});
+		expect(rows[0]?.ended_at).toBeTruthy();
+
+		const manifest = JSON.parse(
+			readFileSync(artifacts.manifestPath, "utf8"),
+		) as Record<string, unknown>;
+		expect(manifest.status).toBe("failed");
+		expect(manifest.exit_code).toBe(1);
+		expect(manifest.ended_at).toBeTruthy();
+		expect(manifest.metadata).toMatchObject({
+			terminal_marker: "failed_external_process_exit",
+			terminal_marker_pid: 999_999_999,
+			terminal_marker_source: "stale_session_reconciler",
+		});
+		expect(
+			(manifest.metadata as Record<string, unknown>).terminal_marker_at,
+		).toBeTruthy();
+
+		expect(existsSync(artifacts.hookPath)).toBe(true);
+		expect(existsSync(artifacts.transcriptPath)).toBe(true);
+		expect(readFileSync(artifacts.hookPath, "utf8")).toContain(
+			'"hookName":"session_shutdown"',
+		);
+		expect(readFileSync(artifacts.hookPath, "utf8")).toContain(
+			'"reason":"failed_external_process_exit"',
+		);
+		expect(readFileSync(artifacts.transcriptPath, "utf8")).toContain(
+			"[shutdown] failed_external_process_exit",
+		);
+	});
+});