@pixelzx/genesis 2026.5.9-1 → 2026.5.9-2

package/dist/assistant-identity-BJGlR731.js

@@ -1,74 +0,0 @@
-import { c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
-import { c as normalizeAgentId } from "./session-key-EpIbK3Oz.js";
-import { b as resolveAgentWorkspaceDir, x as resolveDefaultAgentId } from "./agent-scope-CDjZLqNk.js";
-import { a as isAvatarImageDataUrl, i as isAvatarHttpUrl, u as looksLikeAvatarPath } from "./avatar-policy-Dj8tpGXm.js";
-import { n as resolveAgentIdentity } from "./identity-CDV_WvtM.js";
-import { i as loadAgentIdentity } from "./agents.config-Bf4IE_jt.js";
-//#region src/shared/assistant-identity-values.ts
-function coerceIdentityValue(value, maxLength) {
-	const trimmed = normalizeOptionalString(value);
-	if (!trimmed) return;
-	if (trimmed.length <= maxLength) return trimmed;
-	return trimmed.slice(0, maxLength);
-}
-//#endregion
-//#region src/gateway/assistant-identity.ts
-const MAX_ASSISTANT_NAME = 50;
-const MAX_ASSISTANT_AVATAR = 200;
-const MAX_ASSISTANT_EMOJI = 16;
-const DEFAULT_ASSISTANT_IDENTITY = {
-	agentId: "main",
-	name: "Assistant",
-	avatar: "A"
-};
-function isAvatarUrl(value) {
-	return isAvatarHttpUrl(value) || isAvatarImageDataUrl(value);
-}
-function normalizeAvatarValue(value) {
-	if (!value) return;
-	const trimmed = value.trim();
-	if (!trimmed) return;
-	if (isAvatarUrl(trimmed)) return trimmed;
-	if (looksLikeAvatarPath(trimmed)) return trimmed;
-	if (!/\s/.test(trimmed) && trimmed.length <= 4) return trimmed;
-}
-function normalizeEmojiValue(value) {
-	if (!value) return;
-	const trimmed = value.trim();
-	if (!trimmed) return;
-	if (trimmed.length > MAX_ASSISTANT_EMOJI) return;
-	let hasNonAscii = false;
-	for (let i = 0; i < trimmed.length; i += 1) if (trimmed.charCodeAt(i) > 127) {
-		hasNonAscii = true;
-		break;
-	}
-	if (!hasNonAscii) return;
-	if (isAvatarUrl(trimmed) || looksLikeAvatarPath(trimmed)) return;
-	return trimmed;
-}
-function resolveAssistantIdentity(params) {
-	const agentId = normalizeAgentId(params.agentId ?? resolveDefaultAgentId(params.cfg));
-	const workspaceDir = params.workspaceDir ?? resolveAgentWorkspaceDir(params.cfg, agentId);
-	const configAssistant = params.cfg.ui?.assistant;
-	const agentIdentity = resolveAgentIdentity(params.cfg, agentId);
-	const fileIdentity = workspaceDir ? loadAgentIdentity(workspaceDir) : null;
-	return {
-		agentId,
-		name: coerceIdentityValue(configAssistant?.name, MAX_ASSISTANT_NAME) ?? coerceIdentityValue(agentIdentity?.name, MAX_ASSISTANT_NAME) ?? coerceIdentityValue(fileIdentity?.name, MAX_ASSISTANT_NAME) ?? DEFAULT_ASSISTANT_IDENTITY.name,
-		avatar: [
-			coerceIdentityValue(configAssistant?.avatar, MAX_ASSISTANT_AVATAR),
-			coerceIdentityValue(agentIdentity?.avatar, MAX_ASSISTANT_AVATAR),
-			coerceIdentityValue(agentIdentity?.emoji, MAX_ASSISTANT_AVATAR),
-			coerceIdentityValue(fileIdentity?.avatar, MAX_ASSISTANT_AVATAR),
-			coerceIdentityValue(fileIdentity?.emoji, MAX_ASSISTANT_AVATAR)
-		].map((candidate) => normalizeAvatarValue(candidate)).find(Boolean) ?? DEFAULT_ASSISTANT_IDENTITY.avatar,
-		emoji: [
-			coerceIdentityValue(agentIdentity?.emoji, MAX_ASSISTANT_EMOJI),
-			coerceIdentityValue(fileIdentity?.emoji, MAX_ASSISTANT_EMOJI),
-			coerceIdentityValue(agentIdentity?.avatar, MAX_ASSISTANT_EMOJI),
-			coerceIdentityValue(fileIdentity?.avatar, MAX_ASSISTANT_EMOJI)
-		].map((candidate) => normalizeEmojiValue(candidate)).find(Boolean)
-	};
-}
-//#endregion
-export { resolveAssistantIdentity as n, DEFAULT_ASSISTANT_IDENTITY as t };

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

@@ -1,509 +0,0 @@
-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-DK8bLOGQ.js";
-import { i as emitAgentEvent } from "./agent-events-C550d2MW.js";
-import { i as buildAgentRuntimeAuthPlan } from "./build-MUrq4SZe.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-XCTsu7bq.js";
-import { a as prepareSessionManagerForRun, n as resolveAgentHarnessPolicy } from "./selection-BLnL3CIA.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-Cbd5cHT-.js";
-import { r as getCliSessionBinding, s as setCliSessionBinding } from "./cli-session-BvpaNkiJ.js";
-import { t as persistSessionEntry } from "./attempt-execution.shared-CrrA0Anh.js";
-import { t as runCliAgent } from "./cli-runner-D87jhfwM.js";
-import { t as clearCliSessionInStore } from "./session-store-DKe1sTca.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.shared-CrrA0Anh.js

@@ -1,22 +0,0 @@
-import { n as mergeSessionEntry } from "./types-Bx9yhV03.js";
-import { o as updateSessionStore } from "./store-t_e6UeQl.js";
-import { i as hasInternalRuntimeContext } from "./internal-runtime-context-BZFUSbCZ.js";
-import { t as formatAgentInternalEventsForPrompt } from "./internal-events-3alBxRdy.js";
-//#region src/agents/command/attempt-execution.shared.ts
-async function persistSessionEntry(params) {
-	const persisted = await updateSessionStore(params.storePath, (store) => {
-		const merged = mergeSessionEntry(store[params.sessionKey], params.entry);
-		for (const field of params.clearedFields ?? []) if (!Object.hasOwn(params.entry, field)) Reflect.deleteProperty(merged, field);
-		store[params.sessionKey] = merged;
-		return merged;
-	});
-	params.sessionStore[params.sessionKey] = persisted;
-}
-function prependInternalEventContext(body, events) {
-	if (hasInternalRuntimeContext(body)) return body;
-	const renderedEvents = formatAgentInternalEventsForPrompt(events);
-	if (!renderedEvents) return body;
-	return [renderedEvents, body].filter(Boolean).join("\n\n");
-}
-//#endregion
-export { prependInternalEventContext as n, persistSessionEntry as t };