@pixelzx/genesis 2026.5.10-2 → 2026.5.10-3

package/dist/attempt-execution.runtime-BiBQNA9X.js

@@ -0,0 +1,509 @@
+import { t as sanitizeForLog } from "./ansi-BZHMLcUk.js";
+import { t as createSubsystemLogger } from "./subsystem-DTMy5YmO.js";
+import { t as isCliProvider } from "./model-selection-cli-DqxpyoDv.js";
+import "./model-selection-BJS5Z_AY.js";
+import { t as emitSessionTranscriptUpdate } from "./transcript-events-DlllnQhZ.js";
+import { r as resolveSessionTranscriptFile } from "./transcript-5hPdWyEW.js";
+import { i as emitAgentEvent } from "./agent-events-C550d2MW.js";
+import { i as buildAgentRuntimeAuthPlan } from "./build-DLN8Lh14.js";
+import { a as isSilentReplyText, i as isSilentReplyPrefixText, n as SILENT_REPLY_TOKEN, o as startsWithSilentToken, s as stripLeadingSilentToken } from "./tokens-Bq9TB3gs.js";
+import { et as buildUsageWithNoCost } from "./wait-for-idle-before-flush-jA-mGgw_.js";
+import { a as prepareSessionManagerForRun, n as resolveAgentHarnessPolicy } from "./selection-CdRMYsTR.js";
+import { o as resolveBootstrapWarningSignaturesSeen } from "./bootstrap-budget-CpN-YN0m.js";
+import { t as FailoverError } from "./failover-error-BHITafkz.js";
+import { t as normalizeReplyPayload } from "./normalize-reply-Bd5uxzt6.js";
+import { t as runEmbeddedPiAgent } from "./pi-embedded-BDlMkZq9.js";
+import { r as getCliSessionBinding, s as setCliSessionBinding } from "./cli-session-CAHXgKmo.js";
+import { t as persistSessionEntry } from "./attempt-execution.shared-Cbu3Em6n.js";
+import { t as runCliAgent } from "./cli-runner-DCfEJ3Dl.js";
+import { t as clearCliSessionInStore } from "./session-store-wCEWUbxe.js";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs/promises";
+import { SessionManager } from "@mariozechner/pi-coding-agent";
+import readline from "node:readline";
+//#region src/agents/command/attempt-execution.helpers.ts
+/** Maximum number of JSONL records to inspect before giving up. */
+const SESSION_FILE_MAX_RECORDS = 500;
+const CLAUDE_PROJECTS_RELATIVE_DIR = path.join(".claude", "projects");
+function normalizeClaudeCliSessionId(sessionId) {
+	const trimmed = sessionId?.trim();
+	if (!trimmed || trimmed.includes("\0") || trimmed.includes("/") || trimmed.includes("\\")) return;
+	return trimmed;
+}
+async function jsonlFileHasAssistantMessage(filePath) {
+	if (!filePath) return false;
+	try {
+		const stat = await fs.lstat(filePath);
+		if (stat.isSymbolicLink() || !stat.isFile()) return false;
+		const fh = await fs.open(filePath, "r");
+		try {
+			const rl = readline.createInterface({ input: fh.createReadStream({ encoding: "utf-8" }) });
+			let recordCount = 0;
+			for await (const line of rl) {
+				if (!line.trim()) continue;
+				recordCount++;
+				if (recordCount > SESSION_FILE_MAX_RECORDS) break;
+				let obj;
+				try {
+					obj = JSON.parse(line);
+				} catch {
+					continue;
+				}
+				if ((obj?.message)?.role === "assistant") return true;
+			}
+			return false;
+		} finally {
+			await fh.close();
+		}
+	} catch {
+		return false;
+	}
+}
+/**
+* Check whether a session transcript file exists and contains at least one
+* assistant message, indicating that the SessionManager has flushed the
+* initial user+assistant exchange to disk.
+*/
+async function sessionFileHasContent(sessionFile) {
+	return await jsonlFileHasAssistantMessage(sessionFile);
+}
+async function claudeCliSessionTranscriptHasContent(params) {
+	const sessionId = normalizeClaudeCliSessionId(params.sessionId);
+	if (!sessionId) return false;
+	const homeDir = params.homeDir?.trim() || process.env.HOME || os.homedir();
+	const projectsDir = path.join(homeDir, CLAUDE_PROJECTS_RELATIVE_DIR);
+	let projectEntries;
+	try {
+		projectEntries = await fs.readdir(projectsDir, { withFileTypes: true });
+	} catch {
+		return false;
+	}
+	for (const entry of projectEntries) {
+		if (!entry.isDirectory()) continue;
+		if (await jsonlFileHasAssistantMessage(path.join(projectsDir, entry.name, `${sessionId}.jsonl`))) return true;
+	}
+	return false;
+}
+function resolveFallbackRetryPrompt(params) {
+	if (!params.isFallbackRetry) return params.body;
+	if (!params.sessionHasHistory) return params.body;
+	return `[Retry after the previous model attempt failed or timed out]\n\n${params.body}`;
+}
+function createAcpVisibleTextAccumulator() {
+	let pendingSilentPrefix = "";
+	let visibleText = "";
+	let rawVisibleText = "";
+	const startsWithWordChar = (chunk) => /^[\p{L}\p{N}]/u.test(chunk);
+	const resolveNextCandidate = (base, chunk) => {
+		if (!base) return chunk;
+		if (isSilentReplyText(base, "NO_REPLY") && !chunk.startsWith(base) && startsWithWordChar(chunk)) return chunk;
+		if (chunk.startsWith(base) && chunk.length > base.length) return chunk;
+		return `${base}${chunk}`;
+	};
+	const mergeVisibleChunk = (base, chunk) => {
+		if (!base) return {
+			rawText: chunk,
+			delta: chunk
+		};
+		if (chunk.startsWith(base) && chunk.length > base.length) return {
+			rawText: chunk,
+			delta: chunk.slice(base.length)
+		};
+		return {
+			rawText: `${base}${chunk}`,
+			delta: chunk
+		};
+	};
+	return {
+		consume(chunk) {
+			if (!chunk) return null;
+			if (!visibleText) {
+				const leadCandidate = resolveNextCandidate(pendingSilentPrefix, chunk);
+				const trimmedLeadCandidate = leadCandidate.trim();
+				if (isSilentReplyText(trimmedLeadCandidate, "NO_REPLY") || isSilentReplyPrefixText(trimmedLeadCandidate, "NO_REPLY")) {
+					pendingSilentPrefix = leadCandidate;
+					return null;
+				}
+				if (startsWithSilentToken(trimmedLeadCandidate, "NO_REPLY")) {
+					const stripped = stripLeadingSilentToken(leadCandidate, SILENT_REPLY_TOKEN);
+					if (stripped) {
+						pendingSilentPrefix = "";
+						rawVisibleText = leadCandidate;
+						visibleText = stripped;
+						return {
+							text: stripped,
+							delta: stripped
+						};
+					}
+					pendingSilentPrefix = leadCandidate;
+					return null;
+				}
+				if (pendingSilentPrefix) {
+					pendingSilentPrefix = "";
+					rawVisibleText = leadCandidate;
+					visibleText = leadCandidate;
+					return {
+						text: visibleText,
+						delta: leadCandidate
+					};
+				}
+			}
+			const nextVisible = mergeVisibleChunk(rawVisibleText, chunk);
+			rawVisibleText = nextVisible.rawText;
+			if (!nextVisible.delta) return null;
+			visibleText = `${visibleText}${nextVisible.delta}`;
+			return {
+				text: visibleText,
+				delta: nextVisible.delta
+			};
+		},
+		finalize() {
+			return visibleText.trim();
+		},
+		finalizeRaw() {
+			return visibleText;
+		}
+	};
+}
+//#endregion
+//#region src/agents/command/attempt-execution.ts
+const log = createSubsystemLogger("agents/agent-command");
+const ACP_TRANSCRIPT_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		total: 0
+	}
+};
+function resolveTranscriptUsage(usage) {
+	if (!usage) return ACP_TRANSCRIPT_USAGE;
+	return buildUsageWithNoCost({
+		input: usage.input,
+		output: usage.output,
+		cacheRead: usage.cacheRead,
+		cacheWrite: usage.cacheWrite,
+		totalTokens: usage.total
+	});
+}
+async function persistTextTurnTranscript(params) {
+	const promptText = params.transcriptBody ?? params.body;
+	const replyText = params.finalText;
+	if (!promptText && !replyText) return params.sessionEntry;
+	const { sessionFile, sessionEntry } = await resolveSessionTranscriptFile({
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		sessionEntry: params.sessionEntry,
+		sessionStore: params.sessionStore,
+		storePath: params.storePath,
+		agentId: params.sessionAgentId,
+		threadId: params.threadId
+	});
+	const hadSessionFile = await fs.access(sessionFile).then(() => true).catch(() => false);
+	const sessionManager = SessionManager.open(sessionFile);
+	await prepareSessionManagerForRun({
+		sessionManager,
+		sessionFile,
+		hadSessionFile,
+		sessionId: params.sessionId,
+		cwd: params.sessionCwd
+	});
+	if (promptText) sessionManager.appendMessage({
+		role: "user",
+		content: promptText,
+		timestamp: Date.now()
+	});
+	if (replyText) sessionManager.appendMessage({
+		role: "assistant",
+		content: [{
+			type: "text",
+			text: replyText
+		}],
+		api: params.assistant.api,
+		provider: params.assistant.provider,
+		model: params.assistant.model,
+		usage: resolveTranscriptUsage(params.assistant.usage),
+		stopReason: "stop",
+		timestamp: Date.now()
+	});
+	emitSessionTranscriptUpdate(sessionFile);
+	return sessionEntry;
+}
+function resolveCliTranscriptReplyText(result) {
+	const visibleText = result.meta.finalAssistantVisibleText?.trim();
+	if (visibleText) return visibleText;
+	return (result.payloads ?? []).filter((payload) => !payload.isError && !payload.isReasoning).map((payload) => payload.text?.trim() ?? "").filter(Boolean).join("\n\n");
+}
+function isClaudeCliProvider(provider) {
+	return provider.trim().toLowerCase() === "claude-cli";
+}
+async function persistAcpTurnTranscript(params) {
+	return await persistTextTurnTranscript({
+		...params,
+		assistant: {
+			api: "openai-responses",
+			provider: "genesis",
+			model: "acp-runtime"
+		}
+	});
+}
+async function persistCliTurnTranscript(params) {
+	const replyText = resolveCliTranscriptReplyText(params.result);
+	const provider = params.result.meta.agentMeta?.provider?.trim() ?? "cli";
+	const model = params.result.meta.agentMeta?.model?.trim() ?? "default";
+	return await persistTextTurnTranscript({
+		body: params.body,
+		transcriptBody: params.transcriptBody,
+		finalText: replyText,
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		sessionEntry: params.sessionEntry,
+		sessionStore: params.sessionStore,
+		storePath: params.storePath,
+		sessionAgentId: params.sessionAgentId,
+		threadId: params.threadId,
+		sessionCwd: params.sessionCwd,
+		assistant: {
+			api: "cli",
+			provider,
+			model,
+			usage: params.result.meta.agentMeta?.usage
+		}
+	});
+}
+function runAgentAttempt(params) {
+	const effectivePrompt = resolveFallbackRetryPrompt({
+		body: params.body,
+		isFallbackRetry: params.isFallbackRetry,
+		sessionHasHistory: params.sessionHasHistory
+	});
+	const bootstrapPromptWarningSignaturesSeen = resolveBootstrapWarningSignaturesSeen(params.sessionEntry?.systemPromptReport);
+	const bootstrapPromptWarningSignature = bootstrapPromptWarningSignaturesSeen[bootstrapPromptWarningSignaturesSeen.length - 1];
+	const sessionPinnedAgentHarnessId = resolveSessionPinnedAgentHarnessId({
+		cfg: params.cfg,
+		sessionAgentId: params.sessionAgentId,
+		sessionEntry: params.sessionEntry,
+		sessionHasHistory: params.sessionHasHistory,
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey ?? params.sessionId
+	});
+	const agentHarnessPolicy = resolveAgentHarnessPolicy({
+		provider: params.providerOverride,
+		modelId: params.modelOverride,
+		config: params.cfg,
+		agentId: params.sessionAgentId,
+		sessionKey: params.sessionKey ?? params.sessionId
+	});
+	const authProfileId = buildAgentRuntimeAuthPlan({
+		provider: params.providerOverride,
+		authProfileProvider: params.authProfileProvider,
+		sessionAuthProfileId: params.sessionEntry?.authProfileOverride,
+		config: params.cfg,
+		workspaceDir: params.workspaceDir,
+		harnessId: sessionPinnedAgentHarnessId,
+		harnessRuntime: agentHarnessPolicy.runtime,
+		allowHarnessAuthProfileForwarding: !isCliProvider(params.providerOverride, params.cfg)
+	}).forwardedAuthProfileId;
+	if (isCliProvider(params.providerOverride, params.cfg)) {
+		const cliSessionBinding = getCliSessionBinding(params.sessionEntry, params.providerOverride);
+		const resolveReusableCliSessionBinding = async () => {
+			if (!isClaudeCliProvider(params.providerOverride) || !cliSessionBinding?.sessionId || await claudeCliSessionTranscriptHasContent({ sessionId: cliSessionBinding.sessionId })) return cliSessionBinding;
+			log.warn(`cli session reset: provider=${sanitizeForLog(params.providerOverride)} reason=transcript-missing sessionKey=${params.sessionKey ?? params.sessionId}`);
+			if (params.sessionKey && params.sessionStore && params.storePath) params.sessionEntry = await clearCliSessionInStore({
+				provider: params.providerOverride,
+				sessionKey: params.sessionKey,
+				sessionStore: params.sessionStore,
+				storePath: params.storePath
+			}) ?? params.sessionEntry;
+		};
+		const runCliWithSession = (nextCliSessionId, activeCliSessionBinding = cliSessionBinding) => runCliAgent({
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey,
+			agentId: params.sessionAgentId,
+			trigger: "user",
+			sessionFile: params.sessionFile,
+			workspaceDir: params.workspaceDir,
+			config: params.cfg,
+			prompt: effectivePrompt,
+			provider: params.providerOverride,
+			model: params.modelOverride,
+			thinkLevel: params.resolvedThinkLevel,
+			timeoutMs: params.timeoutMs,
+			runId: params.runId,
+			extraSystemPrompt: params.opts.extraSystemPrompt,
+			cliSessionId: nextCliSessionId,
+			cliSessionBinding: nextCliSessionId === activeCliSessionBinding?.sessionId ? activeCliSessionBinding : void 0,
+			authProfileId,
+			bootstrapPromptWarningSignaturesSeen,
+			bootstrapPromptWarningSignature,
+			images: params.isFallbackRetry ? void 0 : params.opts.images,
+			imageOrder: params.isFallbackRetry ? void 0 : params.opts.imageOrder,
+			skillsSnapshot: params.skillsSnapshot,
+			messageChannel: params.messageChannel,
+			streamParams: params.opts.streamParams,
+			messageProvider: params.messageChannel,
+			agentAccountId: params.runContext.accountId,
+			senderIsOwner: params.opts.senderIsOwner
+		});
+		return resolveReusableCliSessionBinding().then(async (activeCliSessionBinding) => {
+			try {
+				return await runCliWithSession(activeCliSessionBinding?.sessionId, activeCliSessionBinding);
+			} catch (err) {
+				if (err instanceof FailoverError && err.reason === "session_expired" && activeCliSessionBinding?.sessionId && params.sessionKey && params.sessionStore && params.storePath) {
+					log.warn(`CLI session expired, clearing from session store: provider=${sanitizeForLog(params.providerOverride)} sessionKey=${params.sessionKey}`);
+					params.sessionEntry = await clearCliSessionInStore({
+						provider: params.providerOverride,
+						sessionKey: params.sessionKey,
+						sessionStore: params.sessionStore,
+						storePath: params.storePath
+					}) ?? params.sessionEntry;
+					return await runCliWithSession(void 0).then(async (result) => {
+						if (result.meta.agentMeta?.cliSessionBinding?.sessionId && params.sessionKey && params.sessionStore && params.storePath) {
+							const entry = params.sessionStore[params.sessionKey];
+							if (entry) {
+								const updatedEntry = { ...entry };
+								setCliSessionBinding(updatedEntry, params.providerOverride, result.meta.agentMeta.cliSessionBinding);
+								updatedEntry.updatedAt = Date.now();
+								await persistSessionEntry({
+									sessionStore: params.sessionStore,
+									sessionKey: params.sessionKey,
+									storePath: params.storePath,
+									entry: updatedEntry
+								});
+							}
+						}
+						return result;
+					});
+				}
+				throw err;
+			}
+		});
+	}
+	return runEmbeddedPiAgent({
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		agentId: params.sessionAgentId,
+		trigger: "user",
+		messageChannel: params.messageChannel,
+		agentAccountId: params.runContext.accountId,
+		messageTo: params.opts.replyTo ?? params.opts.to,
+		messageThreadId: params.opts.threadId,
+		groupId: params.runContext.groupId,
+		groupChannel: params.runContext.groupChannel,
+		groupSpace: params.runContext.groupSpace,
+		spawnedBy: params.spawnedBy,
+		currentChannelId: params.runContext.currentChannelId,
+		currentThreadTs: params.runContext.currentThreadTs,
+		replyToMode: params.runContext.replyToMode,
+		hasRepliedRef: params.runContext.hasRepliedRef,
+		senderIsOwner: params.opts.senderIsOwner,
+		sessionFile: params.sessionFile,
+		workspaceDir: params.workspaceDir,
+		config: params.cfg,
+		agentHarnessId: sessionPinnedAgentHarnessId,
+		skillsSnapshot: params.skillsSnapshot,
+		prompt: effectivePrompt,
+		images: params.isFallbackRetry ? void 0 : params.opts.images,
+		imageOrder: params.isFallbackRetry ? void 0 : params.opts.imageOrder,
+		clientTools: params.opts.clientTools,
+		provider: params.providerOverride,
+		model: params.modelOverride,
+		authProfileId,
+		authProfileIdSource: authProfileId ? params.sessionEntry?.authProfileOverrideSource : void 0,
+		thinkLevel: params.resolvedThinkLevel,
+		verboseLevel: params.resolvedVerboseLevel,
+		timeoutMs: params.timeoutMs,
+		runId: params.runId,
+		lane: params.opts.lane,
+		abortSignal: params.opts.abortSignal,
+		extraSystemPrompt: params.opts.extraSystemPrompt,
+		bootstrapContextMode: params.opts.bootstrapContextMode,
+		bootstrapContextRunKind: params.opts.bootstrapContextRunKind,
+		internalEvents: params.opts.internalEvents,
+		inputProvenance: params.opts.inputProvenance,
+		streamParams: params.opts.streamParams,
+		agentDir: params.agentDir,
+		allowTransientCooldownProbe: params.allowTransientCooldownProbe,
+		cleanupBundleMcpOnRunEnd: params.opts.cleanupBundleMcpOnRunEnd,
+		onAgentEvent: params.onAgentEvent,
+		bootstrapPromptWarningSignaturesSeen,
+		bootstrapPromptWarningSignature
+	});
+}
+function resolveSessionPinnedAgentHarnessId(params) {
+	if (params.sessionEntry?.sessionId !== params.sessionId) return resolveConfiguredAgentHarnessId(params);
+	if (params.sessionEntry.agentHarnessId) return params.sessionEntry.agentHarnessId;
+	const configuredAgentHarnessId = resolveConfiguredAgentHarnessId(params);
+	if (configuredAgentHarnessId) return configuredAgentHarnessId;
+	if (!params.sessionHasHistory) return;
+	return "pi";
+}
+function resolveConfiguredAgentHarnessId(params) {
+	const policy = resolveAgentHarnessPolicy({
+		config: params.cfg,
+		agentId: params.sessionAgentId,
+		sessionKey: params.sessionKey
+	});
+	return policy.runtime === "auto" ? void 0 : policy.runtime;
+}
+function buildAcpResult(params) {
+	const normalizedFinalPayload = normalizeReplyPayload({ text: params.payloadText });
+	return {
+		payloads: normalizedFinalPayload ? [normalizedFinalPayload] : [],
+		meta: {
+			durationMs: Date.now() - params.startedAt,
+			aborted: params.abortSignal?.aborted === true,
+			stopReason: params.stopReason
+		}
+	};
+}
+function emitAcpLifecycleStart(params) {
+	emitAgentEvent({
+		runId: params.runId,
+		stream: "lifecycle",
+		data: {
+			phase: "start",
+			startedAt: params.startedAt
+		}
+	});
+}
+function emitAcpLifecycleEnd(params) {
+	emitAgentEvent({
+		runId: params.runId,
+		stream: "lifecycle",
+		data: {
+			phase: "end",
+			endedAt: Date.now()
+		}
+	});
+}
+function emitAcpLifecycleError(params) {
+	emitAgentEvent({
+		runId: params.runId,
+		stream: "lifecycle",
+		data: {
+			phase: "error",
+			error: params.message,
+			endedAt: Date.now()
+		}
+	});
+}
+function emitAcpAssistantDelta(params) {
+	emitAgentEvent({
+		runId: params.runId,
+		stream: "assistant",
+		data: {
+			text: params.text,
+			delta: params.delta
+		}
+	});
+}
+//#endregion
+export { buildAcpResult, createAcpVisibleTextAccumulator, emitAcpAssistantDelta, emitAcpLifecycleEnd, emitAcpLifecycleError, emitAcpLifecycleStart, persistAcpTurnTranscript, persistCliTurnTranscript, runAgentAttempt, sessionFileHasContent };

package/dist/attempt-execution.runtime.js

@@ -1 +1 @@
-export * from "./attempt-execution.runtime-CszeM4rO.js";
+export * from "./attempt-execution.runtime-BiBQNA9X.js";