@pixelzx/genesis 2026.5.10-6 → 2026.5.14

package/dist/daemon-cli-CU4aPfqj.js

@@ -0,0 +1,12 @@
+import { t as formatDocsLink } from "./links-DmsJCU7L.js";
+import { r as theme } from "./theme-BrRleVfL.js";
+import { t as addGatewayServiceCommands } from "./register-service-commands-DG8RhR0h.js";
+import "./install-Cs2wzHs8.js";
+import "./lifecycle-UVNzY9hW.js";
+import "./status-Cdur_Eon.js";
+//#region src/cli/daemon-cli/register.ts
+function registerDaemonCli(program) {
+	addGatewayServiceCommands(program.command("daemon").description("Manage the Gateway service (launchd/systemd/schtasks)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/gateway", "docs.genesis.ai/cli/gateway")}\n`), { statusDescription: "Show service install status + probe connectivity/capability" });
+}
+//#endregion
+export { registerDaemonCli as t };

package/dist/dashboard-CMgYveXv.js

@@ -0,0 +1,2 @@
+import { t as dashboardCommand } from "./dashboard-iIYTjC3l.js";
+export { dashboardCommand };

package/dist/dashboard-iIYTjC3l.js

@@ -0,0 +1,81 @@
+import { n as defaultRuntime } from "./runtime-CQ7eH0le.js";
+import { u as resolveGatewayPort } from "./paths-DmR9mjUX.js";
+import { r as runCommandWithTimeout } from "./exec-CKo0c2Rj.js";
+import { t as resolveGatewayAuthToken } from "./auth-token-resolution-B0f5W3e0.js";
+import { u as readConfigFileSnapshot } from "./io-DK8qz7fQ.js";
+import "./config-978YFBb1.js";
+import { t as resolveControlUiLinks } from "./control-ui-links-BvGEIgO7.js";
+import { n as openUrl, t as detectBrowserOpenSupport } from "./browser-open-Deu6w4qr.js";
+import { i as formatControlUiSshHint } from "./onboard-helpers-CaHkv2LW.js";
+//#region src/infra/clipboard.ts
+async function copyToClipboard(value) {
+	for (const attempt of [
+		{ argv: ["pbcopy"] },
+		{ argv: [
+			"xclip",
+			"-selection",
+			"clipboard"
+		] },
+		{ argv: ["wl-copy"] },
+		{ argv: ["clip.exe"] },
+		{ argv: [
+			"powershell",
+			"-NoProfile",
+			"-Command",
+			"Set-Clipboard"
+		] }
+	]) try {
+		const result = await runCommandWithTimeout(attempt.argv, {
+			timeoutMs: 3e3,
+			input: value
+		});
+		if (result.code === 0 && !result.killed) return true;
+	} catch {}
+	return false;
+}
+//#endregion
+//#region src/commands/dashboard.ts
+async function dashboardCommand(runtime = defaultRuntime, options = {}) {
+	const snapshot = await readConfigFileSnapshot();
+	const cfg = snapshot.valid ? snapshot.sourceConfig ?? snapshot.config : {};
+	const port = resolveGatewayPort(cfg);
+	const bind = cfg.gateway?.bind ?? "loopback";
+	const basePath = cfg.gateway?.controlUi?.basePath;
+	const customBindHost = cfg.gateway?.customBindHost;
+	const resolvedToken = await resolveGatewayAuthToken({
+		cfg,
+		env: process.env,
+		envFallback: "always"
+	});
+	const token = resolvedToken.token ?? "";
+	const links = resolveControlUiLinks({
+		port,
+		bind: bind === "lan" ? "loopback" : bind,
+		customBindHost,
+		basePath
+	});
+	const includeTokenInUrl = token.length > 0 && !resolvedToken.secretRefConfigured;
+	const dashboardUrl = includeTokenInUrl ? `${links.httpUrl}#token=${encodeURIComponent(token)}` : links.httpUrl;
+	runtime.log(`Dashboard URL: ${links.httpUrl}`);
+	if (includeTokenInUrl) runtime.log("Token auto-auth included in browser/clipboard URL.");
+	if (resolvedToken.secretRefConfigured && token) runtime.log("Token auto-auth is disabled for SecretRef-managed gateway.auth.token; use your external token source if prompted.");
+	if (resolvedToken.unresolvedRefReason) {
+		runtime.log(`Token auto-auth unavailable: ${resolvedToken.unresolvedRefReason}`);
+		runtime.log("Set GENESIS_GATEWAY_TOKEN in this shell or resolve your secret provider, then rerun `genesis dashboard`.");
+	}
+	const copied = await copyToClipboard(dashboardUrl).catch(() => false);
+	runtime.log(copied ? "Copied to clipboard." : "Copy to clipboard unavailable.");
+	let opened = false;
+	let hint;
+	if (!options.noOpen) {
+		if ((await detectBrowserOpenSupport()).ok) opened = await openUrl(dashboardUrl);
+		if (!opened) hint = formatControlUiSshHint({
+			port,
+			basePath
+		});
+	} else hint = copied && includeTokenInUrl ? "Browser launch disabled (--no-open). Token-authenticated URL copied to clipboard." : "Browser launch disabled (--no-open). Use the URL above.";
+	if (opened) runtime.log("Opened in your browser. Keep that tab to control Genesis.");
+	else if (hint) runtime.log(hint);
+}
+//#endregion
+export { dashboardCommand as t };

package/dist/delegate-DXPsB5ax.js

@@ -0,0 +1,64 @@
+import { t as buildMemoryPromptSection } from "./memory-state-CwHzq3a2.js";
+import { n as normalizeStructuredPromptSection } from "./prompt-cache-stability-UVrbE60n.js";
+//#region src/context-engine/delegate.ts
+let compactRuntimePromise = null;
+function loadCompactRuntime() {
+	compactRuntimePromise ??= import("./compact.runtime-DgjjAE5U.js");
+	return compactRuntimePromise;
+}
+/**
+* Delegate a context-engine compaction request to Genesis's built-in runtime compaction path.
+*
+* This is the same bridge used by the legacy context engine. Third-party
+* engines can call it from their own `compact()` implementations when they do
+* not own the compaction algorithm but still need `/compact` and overflow
+* recovery to use the stock runtime behavior.
+*
+* Note: `compactionTarget` is part of the public `compact()` contract, but the
+* built-in runtime compaction path does not expose that knob. This helper
+* ignores it to preserve legacy behavior; engines that need target-specific
+* compaction should implement their own `compact()` algorithm.
+*/
+async function delegateCompactionToRuntime(params) {
+	const { compactEmbeddedPiSessionDirect } = await loadCompactRuntime();
+	const runtimeContext = params.runtimeContext ?? {};
+	const currentTokenCount = params.currentTokenCount ?? (typeof runtimeContext.currentTokenCount === "number" && Number.isFinite(runtimeContext.currentTokenCount) && runtimeContext.currentTokenCount > 0 ? Math.floor(runtimeContext.currentTokenCount) : void 0);
+	const result = await compactEmbeddedPiSessionDirect({
+		...runtimeContext,
+		sessionId: params.sessionId,
+		sessionFile: params.sessionFile,
+		tokenBudget: params.tokenBudget,
+		...currentTokenCount !== void 0 ? { currentTokenCount } : {},
+		force: params.force,
+		customInstructions: params.customInstructions,
+		workspaceDir: typeof runtimeContext.workspaceDir === "string" ? runtimeContext.workspaceDir : process.cwd()
+	});
+	return {
+		ok: result.ok,
+		compacted: result.compacted,
+		reason: result.reason,
+		result: result.result ? {
+			summary: result.result.summary,
+			firstKeptEntryId: result.result.firstKeptEntryId,
+			tokensBefore: result.result.tokensBefore,
+			tokensAfter: result.result.tokensAfter,
+			details: result.result.details
+		} : void 0
+	};
+}
+/**
+* Build a context-engine-ready systemPromptAddition from the active memory
+* plugin prompt path. This lets non-legacy engines explicitly opt into the
+* same memory/wiki guidance that the legacy engine gets via system prompt
+* assembly, without reimplementing memory prompt formatting.
+*/
+function buildMemorySystemPromptAddition(params) {
+	const lines = buildMemoryPromptSection({
+		availableTools: params.availableTools,
+		citationsMode: params.citationsMode
+	});
+	if (lines.length === 0) return;
+	return normalizeStructuredPromptSection(lines.join("\n")) || void 0;
+}
+//#endregion
+export { delegateCompactionToRuntime as n, buildMemorySystemPromptAddition as t };

package/dist/detached-task-runtime-BCoJPrqs.js

@@ -0,0 +1,73 @@
+import { t as createSubsystemLogger } from "./subsystem-DTMy5YmO.js";
+import { r as getRegisteredDetachedTaskLifecycleRuntime } from "./detached-task-runtime-state-D9Kb676J.js";
+import { t as cancelTaskById } from "./task-registry-ChDYRLl7.js";
+import "./runtime-internal-CC7f86-l.js";
+import { a as createQueuedTaskRun$1, d as setDetachedTaskDeliveryStatusByRunId$1, f as startTaskRunByRunId$1, i as completeTaskRunByRunId$1, l as recordTaskRunProgressByRunId$1, o as createRunningTaskRun$1, s as failTaskRunByRunId$1 } from "./task-executor-BE-vjvwg.js";
+//#region src/tasks/detached-task-runtime.ts
+const log = createSubsystemLogger("tasks/detached-runtime");
+const DETACHED_TASK_RECOVERY_WARN_MS = 5e3;
+const DEFAULT_DETACHED_TASK_LIFECYCLE_RUNTIME = {
+	createQueuedTaskRun: createQueuedTaskRun$1,
+	createRunningTaskRun: createRunningTaskRun$1,
+	startTaskRunByRunId: startTaskRunByRunId$1,
+	recordTaskRunProgressByRunId: recordTaskRunProgressByRunId$1,
+	completeTaskRunByRunId: completeTaskRunByRunId$1,
+	failTaskRunByRunId: failTaskRunByRunId$1,
+	setDetachedTaskDeliveryStatusByRunId: setDetachedTaskDeliveryStatusByRunId$1,
+	cancelDetachedTaskRunById: cancelTaskById
+};
+function getDetachedTaskLifecycleRuntime() {
+	return getRegisteredDetachedTaskLifecycleRuntime() ?? DEFAULT_DETACHED_TASK_LIFECYCLE_RUNTIME;
+}
+function createQueuedTaskRun(...args) {
+	return getDetachedTaskLifecycleRuntime().createQueuedTaskRun(...args);
+}
+function createRunningTaskRun(...args) {
+	return getDetachedTaskLifecycleRuntime().createRunningTaskRun(...args);
+}
+function startTaskRunByRunId(...args) {
+	return getDetachedTaskLifecycleRuntime().startTaskRunByRunId(...args);
+}
+function recordTaskRunProgressByRunId(...args) {
+	return getDetachedTaskLifecycleRuntime().recordTaskRunProgressByRunId(...args);
+}
+function completeTaskRunByRunId(...args) {
+	return getDetachedTaskLifecycleRuntime().completeTaskRunByRunId(...args);
+}
+function failTaskRunByRunId(...args) {
+	return getDetachedTaskLifecycleRuntime().failTaskRunByRunId(...args);
+}
+function setDetachedTaskDeliveryStatusByRunId(...args) {
+	return getDetachedTaskLifecycleRuntime().setDetachedTaskDeliveryStatusByRunId(...args);
+}
+async function tryRecoverTaskBeforeMarkLost(params) {
+	const hook = getDetachedTaskLifecycleRuntime().tryRecoverTaskBeforeMarkLost;
+	if (!hook) return { recovered: false };
+	const startedAt = Date.now();
+	try {
+		const result = await hook(params);
+		const elapsedMs = Date.now() - startedAt;
+		if (elapsedMs >= DETACHED_TASK_RECOVERY_WARN_MS) log.warn("Detached task recovery hook was slow", {
+			taskId: params.taskId,
+			runtime: params.runtime,
+			elapsedMs
+		});
+		if (result && typeof result.recovered === "boolean") return result;
+		log.warn("Detached task recovery hook returned invalid result, proceeding with markTaskLost", {
+			taskId: params.taskId,
+			runtime: params.runtime,
+			result
+		});
+		return { recovered: false };
+	} catch (err) {
+		log.warn("Detached task recovery hook threw, proceeding with markTaskLost", {
+			taskId: params.taskId,
+			runtime: params.runtime,
+			elapsedMs: Date.now() - startedAt,
+			error: err
+		});
+		return { recovered: false };
+	}
+}
+//#endregion
+export { recordTaskRunProgressByRunId as a, tryRecoverTaskBeforeMarkLost as c, failTaskRunByRunId as i, createQueuedTaskRun as n, setDetachedTaskDeliveryStatusByRunId as o, createRunningTaskRun as r, startTaskRunByRunId as s, completeTaskRunByRunId as t };