@pixelzx/genesis 2026.6.27 → 2026.6.28

package/dist/system-cli-DyBkQUQb.js

@@ -0,0 +1,43 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { n as defaultRuntime } from "./runtime-DDkDH9fa.js";
+import { t as formatDocsLink } from "./links-C1-jbHJx.js";
+import { r as theme } from "./theme-DD6pQv2_.js";
+import { t as danger } from "./globals-wYf9_gv5.js";
+import { n as callGatewayFromCli, t as addGatewayClientOptions } from "./gateway-rpc-Dk_z0RTG.js";
+//#region src/cli/system-cli.ts
+const normalizeWakeMode = (raw) => {
+	const mode = normalizeOptionalString(raw) ?? "";
+	if (!mode) return "next-heartbeat";
+	if (mode === "now" || mode === "next-heartbeat") return mode;
+	throw new Error("--mode must be now or next-heartbeat");
+};
+async function runSystemGatewayCommand(opts, action, successText) {
+	try {
+		const result = await action();
+		if (opts.json || successText === void 0) defaultRuntime.writeJson(result);
+		else defaultRuntime.log(successText);
+	} catch (err) {
+		defaultRuntime.error(danger(String(err)));
+		defaultRuntime.exit(1);
+	}
+}
+function registerSystemCli(program) {
+	const system = program.command("system").description("System tools (events, heartbeat, presence)").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/system", "genesis.pixelzx.com/docs/cli/system")}\n`);
+	addGatewayClientOptions(system.command("event").description("Enqueue a system event and optionally trigger a heartbeat").requiredOption("--text <text>", "System event text").option("--mode <mode>", "Wake mode (now|next-heartbeat)", "next-heartbeat").option("--json", "Output JSON", false)).action(async (opts) => {
+		await runSystemGatewayCommand(opts, async () => {
+			const text = normalizeOptionalString(opts.text) ?? "";
+			if (!text) throw new Error("--text is required");
+			return await callGatewayFromCli("wake", opts, {
+				mode: normalizeWakeMode(opts.mode),
+				text
+			}, { expectFinal: false });
+		}, "ok");
+	});
+	addGatewayClientOptions(system.command("presence").description("List system presence entries").option("--json", "Output JSON", false)).action(async (opts) => {
+		await runSystemGatewayCommand(opts, async () => {
+			return await callGatewayFromCli("system-presence", opts, void 0, { expectFinal: false });
+		});
+	});
+}
+//#endregion
+export { registerSystemCli };

package/dist/targets-BadrXaG2.js

@@ -0,0 +1,67 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { r as callGateway } from "./call-Dwj7PrNe.js";
+import { t as SESSION_ID_RE } from "./session-id-Ckb23Lzd.js";
+import { t as resolveEffectiveResetTargetSessionKey } from "./acp-reset-target-C8xEMRwo.js";
+import { E as resolveAcpCommandBindingContext } from "./shared-vl8ySAcJ.js";
+import { s as resolveRequesterSessionKey } from "./shared-BY5yIWjE.js";
+//#region src/auto-reply/reply/commands-acp/targets.ts
+async function resolveSessionKeyByToken(token) {
+	const trimmed = token.trim();
+	if (!trimmed) return null;
+	const attempts = [{ key: trimmed }];
+	if (SESSION_ID_RE.test(trimmed)) attempts.push({ sessionId: trimmed });
+	attempts.push({ label: trimmed });
+	for (const params of attempts) try {
+		const key = normalizeOptionalString((await callGateway({
+			method: "sessions.resolve",
+			params,
+			timeoutMs: 8e3
+		}))?.key) ?? "";
+		if (key) return key;
+	} catch {}
+	return null;
+}
+function resolveBoundAcpThreadSessionKey(params) {
+	const activeSessionKey = (normalizeOptionalString(params.ctx.CommandTargetSessionKey) ?? "") || (normalizeOptionalString(params.sessionKey) ?? "");
+	const bindingContext = resolveAcpCommandBindingContext(params);
+	return resolveEffectiveResetTargetSessionKey({
+		cfg: params.cfg,
+		channel: bindingContext.channel,
+		accountId: bindingContext.accountId,
+		conversationId: bindingContext.conversationId,
+		parentConversationId: bindingContext.parentConversationId,
+		activeSessionKey,
+		allowNonAcpBindingSessionKey: true,
+		skipConfiguredFallbackWhenActiveSessionNonAcp: false
+	});
+}
+async function resolveAcpTargetSessionKey(params) {
+	const token = normalizeOptionalString(params.token) ?? "";
+	if (token) {
+		const resolved = await resolveSessionKeyByToken(token);
+		if (!resolved) return {
+			ok: false,
+			error: `Unable to resolve session target: ${token}`
+		};
+		return {
+			ok: true,
+			sessionKey: resolved
+		};
+	}
+	const threadBound = resolveBoundAcpThreadSessionKey(params.commandParams);
+	if (threadBound) return {
+		ok: true,
+		sessionKey: threadBound
+	};
+	const fallback = resolveRequesterSessionKey(params.commandParams, { preferCommandTarget: true });
+	if (!fallback) return {
+		ok: false,
+		error: "Missing session key."
+	};
+	return {
+		ok: true,
+		sessionKey: fallback
+	};
+}
+//#endregion
+export { resolveBoundAcpThreadSessionKey as n, resolveAcpTargetSessionKey as t };

package/dist/task-executor-C7Wi33fD.js

@@ -0,0 +1,360 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { t as createSubsystemLogger } from "./subsystem-CNq69MoE.js";
+import { r as getRegisteredDetachedTaskLifecycleRuntime } from "./detached-task-runtime-state-i8kBSS9G.js";
+import { C as setTaskRunDeliveryStatusByRunId, D as deleteTaskFlowRecordById, E as createTaskFlowForTask, F as requestFlowCancel, P as listTaskFlowsForOwnerKey, b as recordTaskProgressByRunId, c as linkTaskToFlowById, d as listTasksForFlowId, g as markTaskRunningByRunId, j as getTaskFlowById, k as findLatestTaskFlowForOwnerKey, n as createTaskRecord, o as getTaskById, s as isParentFlowLinkError, t as cancelTaskById, v as markTaskTerminalByRunId, z as updateFlowRecordByIdExpectedRevision } from "./task-registry-W5mFPlZX.js";
+import { n as summarizeTaskRecords } from "./task-registry.summary-BpQCSMFI.js";
+import "./runtime-internal-By95Az_F.js";
+//#region src/tasks/task-flow-owner-access.ts
+function getTaskFlowByIdForOwner(params) {
+	const flow = getTaskFlowById(params.flowId);
+	return flow && normalizeOptionalString(flow.ownerKey) === normalizeOptionalString(params.callerOwnerKey) ? flow : void 0;
+}
+function listTaskFlowsForOwner(params) {
+	const ownerKey = normalizeOptionalString(params.callerOwnerKey);
+	return ownerKey ? listTaskFlowsForOwnerKey(ownerKey) : [];
+}
+function findLatestTaskFlowForOwner(params) {
+	const ownerKey = normalizeOptionalString(params.callerOwnerKey);
+	return ownerKey ? findLatestTaskFlowForOwnerKey(ownerKey) : void 0;
+}
+function resolveTaskFlowForLookupTokenForOwner(params) {
+	const direct = getTaskFlowByIdForOwner({
+		flowId: params.token,
+		callerOwnerKey: params.callerOwnerKey
+	});
+	if (direct) return direct;
+	const normalizedToken = normalizeOptionalString(params.token);
+	const normalizedCallerOwnerKey = normalizeOptionalString(params.callerOwnerKey);
+	if (!normalizedToken || normalizedToken !== normalizedCallerOwnerKey) return;
+	return findLatestTaskFlowForOwner({ callerOwnerKey: normalizedCallerOwnerKey });
+}
+//#endregion
+//#region src/tasks/task-executor.ts
+const log = createSubsystemLogger("tasks/executor");
+function isOneTaskFlowEligible(task) {
+	if (task.parentFlowId?.trim() || task.scopeKind !== "session") return false;
+	if (task.deliveryStatus === "not_applicable") return false;
+	return task.runtime === "acp" || task.runtime === "subagent";
+}
+function ensureSingleTaskFlow(params) {
+	if (!isOneTaskFlowEligible(params.task)) return params.task;
+	try {
+		const flow = createTaskFlowForTask({
+			task: params.task,
+			requesterOrigin: params.requesterOrigin
+		});
+		const linked = linkTaskToFlowById({
+			taskId: params.task.taskId,
+			flowId: flow.flowId
+		});
+		if (!linked) {
+			deleteTaskFlowRecordById(flow.flowId);
+			return params.task;
+		}
+		if (linked.parentFlowId !== flow.flowId) {
+			deleteTaskFlowRecordById(flow.flowId);
+			return linked;
+		}
+		return linked;
+	} catch (error) {
+		log.warn("Failed to create one-task flow for detached run", {
+			taskId: params.task.taskId,
+			runId: params.task.runId,
+			error
+		});
+		return params.task;
+	}
+}
+function createQueuedTaskRun(params) {
+	return ensureSingleTaskFlow({
+		task: createTaskRecord({
+			...params,
+			status: "queued"
+		}),
+		requesterOrigin: params.requesterOrigin
+	});
+}
+function getFlowTaskSummary(flowId) {
+	return summarizeTaskRecords(listTasksForFlowId(flowId));
+}
+function createRunningTaskRun(params) {
+	return ensureSingleTaskFlow({
+		task: createTaskRecord({
+			...params,
+			status: "running"
+		}),
+		requesterOrigin: params.requesterOrigin
+	});
+}
+function startTaskRunByRunId(params) {
+	return markTaskRunningByRunId(params);
+}
+function recordTaskRunProgressByRunId(params) {
+	return recordTaskProgressByRunId(params);
+}
+function completeTaskRunByRunId(params) {
+	return markTaskTerminalByRunId({
+		runId: params.runId,
+		runtime: params.runtime,
+		sessionKey: params.sessionKey,
+		status: "succeeded",
+		endedAt: params.endedAt,
+		lastEventAt: params.lastEventAt,
+		progressSummary: params.progressSummary,
+		terminalSummary: params.terminalSummary,
+		terminalOutcome: params.terminalOutcome
+	});
+}
+function failTaskRunByRunId(params) {
+	return markTaskTerminalByRunId({
+		runId: params.runId,
+		runtime: params.runtime,
+		sessionKey: params.sessionKey,
+		status: params.status ?? "failed",
+		endedAt: params.endedAt,
+		lastEventAt: params.lastEventAt,
+		error: params.error,
+		progressSummary: params.progressSummary,
+		terminalSummary: params.terminalSummary
+	});
+}
+function setDetachedTaskDeliveryStatusByRunId(params) {
+	return setTaskRunDeliveryStatusByRunId(params);
+}
+function isActiveTaskStatus(status) {
+	return status === "queued" || status === "running";
+}
+function isTerminalFlowStatus(status) {
+	return status === "succeeded" || status === "failed" || status === "cancelled" || status === "lost";
+}
+function markFlowCancelRequested(flow) {
+	if (flow.cancelRequestedAt != null) return flow;
+	const result = requestFlowCancel({
+		flowId: flow.flowId,
+		expectedRevision: flow.revision
+	});
+	if (result.applied) return result.flow;
+	return {
+		reason: result.reason === "revision_conflict" ? "Flow changed while cancellation was in progress." : "Flow not found.",
+		flow: result.current ?? getTaskFlowById(flow.flowId)
+	};
+}
+function cancelManagedFlowAfterChildrenSettle(flow, endedAt) {
+	const result = updateFlowRecordByIdExpectedRevision({
+		flowId: flow.flowId,
+		expectedRevision: flow.revision,
+		patch: {
+			status: "cancelled",
+			blockedTaskId: null,
+			blockedSummary: null,
+			waitJson: null,
+			endedAt,
+			updatedAt: endedAt
+		}
+	});
+	if (result.applied) return result.flow;
+	return {
+		reason: result.reason === "revision_conflict" ? "Flow changed while cancellation was in progress." : "Flow not found.",
+		flow: result.current ?? getTaskFlowById(flow.flowId)
+	};
+}
+function mapRunTaskInFlowCreateError(params) {
+	const flow = getTaskFlowById(params.flowId);
+	if (isParentFlowLinkError(params.error)) {
+		if (params.error.code === "cancel_requested") return {
+			found: true,
+			created: false,
+			reason: "Flow cancellation has already been requested.",
+			...flow ? { flow } : {}
+		};
+		if (params.error.code === "terminal") return {
+			found: true,
+			created: false,
+			reason: `Flow is already ${flow?.status ?? params.error.details?.status ?? "terminal"}.`,
+			...flow ? { flow } : {}
+		};
+		if (params.error.code === "parent_flow_not_found") return {
+			found: false,
+			created: false,
+			reason: "Flow not found."
+		};
+	}
+	throw params.error;
+}
+function runTaskInFlow(params) {
+	const flow = getTaskFlowById(params.flowId);
+	if (!flow) return {
+		found: false,
+		created: false,
+		reason: "Flow not found."
+	};
+	if (flow.syncMode !== "managed") return {
+		found: true,
+		created: false,
+		reason: "Flow does not accept managed child tasks.",
+		flow
+	};
+	if (flow.cancelRequestedAt != null) return {
+		found: true,
+		created: false,
+		reason: "Flow cancellation has already been requested.",
+		flow
+	};
+	if (isTerminalFlowStatus(flow.status)) return {
+		found: true,
+		created: false,
+		reason: `Flow is already ${flow.status}.`,
+		flow
+	};
+	const common = {
+		runtime: params.runtime,
+		sourceId: params.sourceId,
+		ownerKey: flow.ownerKey,
+		scopeKind: "session",
+		requesterOrigin: flow.requesterOrigin,
+		parentFlowId: flow.flowId,
+		childSessionKey: params.childSessionKey,
+		parentTaskId: params.parentTaskId,
+		agentId: params.agentId,
+		runId: params.runId,
+		label: params.label,
+		task: params.task,
+		preferMetadata: params.preferMetadata,
+		notifyPolicy: params.notifyPolicy,
+		deliveryStatus: params.deliveryStatus ?? "pending"
+	};
+	let task;
+	try {
+		task = params.status === "running" ? createRunningTaskRun({
+			...common,
+			startedAt: params.startedAt,
+			lastEventAt: params.lastEventAt,
+			progressSummary: params.progressSummary
+		}) : createQueuedTaskRun(common);
+	} catch (error) {
+		return mapRunTaskInFlowCreateError({
+			error,
+			flowId: flow.flowId
+		});
+	}
+	return {
+		found: true,
+		created: true,
+		flow: getTaskFlowById(flow.flowId) ?? flow,
+		task
+	};
+}
+function runTaskInFlowForOwner(params) {
+	const flow = getTaskFlowByIdForOwner({
+		flowId: params.flowId,
+		callerOwnerKey: params.callerOwnerKey
+	});
+	if (!flow) return {
+		found: false,
+		created: false,
+		reason: "Flow not found."
+	};
+	return runTaskInFlow({
+		flowId: flow.flowId,
+		runtime: params.runtime,
+		sourceId: params.sourceId,
+		childSessionKey: params.childSessionKey,
+		parentTaskId: params.parentTaskId,
+		agentId: params.agentId,
+		runId: params.runId,
+		label: params.label,
+		task: params.task,
+		preferMetadata: params.preferMetadata,
+		notifyPolicy: params.notifyPolicy,
+		deliveryStatus: params.deliveryStatus,
+		status: params.status,
+		startedAt: params.startedAt,
+		lastEventAt: params.lastEventAt,
+		progressSummary: params.progressSummary
+	});
+}
+async function cancelFlowById(params) {
+	const flow = getTaskFlowById(params.flowId);
+	if (!flow) return {
+		found: false,
+		cancelled: false,
+		reason: "Flow not found."
+	};
+	if (isTerminalFlowStatus(flow.status)) return {
+		found: true,
+		cancelled: false,
+		reason: `Flow is already ${flow.status}.`,
+		flow,
+		tasks: listTasksForFlowId(flow.flowId)
+	};
+	const cancelRequestedFlow = markFlowCancelRequested(flow);
+	if ("reason" in cancelRequestedFlow) return {
+		found: true,
+		cancelled: false,
+		reason: cancelRequestedFlow.reason,
+		flow: cancelRequestedFlow.flow,
+		tasks: listTasksForFlowId(flow.flowId)
+	};
+	const activeTasks = listTasksForFlowId(flow.flowId).filter((task) => isActiveTaskStatus(task.status));
+	for (const task of activeTasks) await cancelDetachedTaskRunById({
+		cfg: params.cfg,
+		taskId: task.taskId
+	});
+	const refreshedTasks = listTasksForFlowId(flow.flowId);
+	if (refreshedTasks.filter((task) => isActiveTaskStatus(task.status)).length > 0) return {
+		found: true,
+		cancelled: false,
+		reason: "One or more child tasks are still active.",
+		flow: getTaskFlowById(flow.flowId) ?? cancelRequestedFlow,
+		tasks: refreshedTasks
+	};
+	const now = Date.now();
+	const refreshedFlow = getTaskFlowById(flow.flowId) ?? cancelRequestedFlow;
+	if (isTerminalFlowStatus(refreshedFlow.status)) return {
+		found: true,
+		cancelled: refreshedFlow.status === "cancelled",
+		reason: refreshedFlow.status === "cancelled" ? void 0 : `Flow is already ${refreshedFlow.status}.`,
+		flow: refreshedFlow,
+		tasks: refreshedTasks
+	};
+	const updatedFlow = cancelManagedFlowAfterChildrenSettle(refreshedFlow, now);
+	if ("reason" in updatedFlow) return {
+		found: true,
+		cancelled: false,
+		reason: updatedFlow.reason,
+		flow: updatedFlow.flow,
+		tasks: refreshedTasks
+	};
+	return {
+		found: true,
+		cancelled: true,
+		flow: updatedFlow,
+		tasks: refreshedTasks
+	};
+}
+async function cancelFlowByIdForOwner(params) {
+	const flow = getTaskFlowByIdForOwner({
+		flowId: params.flowId,
+		callerOwnerKey: params.callerOwnerKey
+	});
+	if (!flow) return {
+		found: false,
+		cancelled: false,
+		reason: "Flow not found."
+	};
+	return cancelFlowById({
+		cfg: params.cfg,
+		flowId: flow.flowId
+	});
+}
+async function cancelDetachedTaskRunById(params) {
+	if (!getTaskById(params.taskId)) return cancelTaskById(params);
+	const registeredRuntime = getRegisteredDetachedTaskLifecycleRuntime();
+	if (registeredRuntime) {
+		const cancelled = await registeredRuntime.cancelDetachedTaskRunById(params);
+		if (cancelled.found) return cancelled;
+	}
+	return cancelTaskById(params);
+}
+//#endregion
+export { createQueuedTaskRun as a, getFlowTaskSummary as c, setDetachedTaskDeliveryStatusByRunId as d, startTaskRunByRunId as f, resolveTaskFlowForLookupTokenForOwner as g, listTaskFlowsForOwner as h, completeTaskRunByRunId as i, recordTaskRunProgressByRunId as l, getTaskFlowByIdForOwner as m, cancelFlowById as n, createRunningTaskRun as o, findLatestTaskFlowForOwner as p, cancelFlowByIdForOwner as r, failTaskRunByRunId as s, cancelDetachedTaskRunById as t, runTaskInFlowForOwner as u };

package/dist/task-owner-access-yQv8xMco.js

@@ -0,0 +1,74 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { t as buildTaskStatusSnapshot } from "./task-status-CQv7hAk3.js";
+import { _ as markTaskTerminalById, a as findTaskByRunId, o as getTaskById, p as listTasksForRelatedSessionKey, w as updateTaskNotifyPolicyById, x as resolveTaskForLookupToken } from "./task-registry-W5mFPlZX.js";
+//#region src/tasks/task-owner-access.ts
+function canOwnerAccessTask(task, callerOwnerKey) {
+	return task.scopeKind === "session" && normalizeOptionalString(task.ownerKey) === normalizeOptionalString(callerOwnerKey);
+}
+function getTaskByIdForOwner(params) {
+	const task = getTaskById(params.taskId);
+	return task && canOwnerAccessTask(task, params.callerOwnerKey) ? task : void 0;
+}
+function findTaskByRunIdForOwner(params) {
+	const task = findTaskByRunId(params.runId);
+	return task && canOwnerAccessTask(task, params.callerOwnerKey) ? task : void 0;
+}
+/** Update an owner-visible task's notification policy. */
+function updateTaskNotifyPolicyForOwner(params) {
+	const task = getTaskByIdForOwner({
+		taskId: params.taskId,
+		callerOwnerKey: params.callerOwnerKey
+	});
+	if (!task) return null;
+	return updateTaskNotifyPolicyById({
+		taskId: task.taskId,
+		notifyPolicy: params.notifyPolicy
+	});
+}
+/** Mark an owner-visible task as cancelled with a caller-provided summary. */
+function cancelTaskByIdForOwner(params) {
+	const task = getTaskByIdForOwner({
+		taskId: params.taskId,
+		callerOwnerKey: params.callerOwnerKey
+	});
+	if (!task) return null;
+	return markTaskTerminalById({
+		taskId: task.taskId,
+		status: "cancelled",
+		endedAt: params.endedAt,
+		terminalSummary: params.terminalSummary
+	});
+}
+function listTasksForRelatedSessionKeyForOwner(params) {
+	return listTasksForRelatedSessionKey(params.relatedSessionKey).filter((task) => canOwnerAccessTask(task, params.callerOwnerKey));
+}
+function buildTaskStatusSnapshotForRelatedSessionKeyForOwner(params) {
+	return buildTaskStatusSnapshot(listTasksForRelatedSessionKeyForOwner({
+		relatedSessionKey: params.relatedSessionKey,
+		callerOwnerKey: params.callerOwnerKey
+	}));
+}
+function findLatestTaskForRelatedSessionKeyForOwner(params) {
+	return listTasksForRelatedSessionKeyForOwner(params)[0];
+}
+function resolveTaskForLookupTokenForOwner(params) {
+	const direct = getTaskByIdForOwner({
+		taskId: params.token,
+		callerOwnerKey: params.callerOwnerKey
+	});
+	if (direct) return direct;
+	const byRun = findTaskByRunIdForOwner({
+		runId: params.token,
+		callerOwnerKey: params.callerOwnerKey
+	});
+	if (byRun) return byRun;
+	const related = findLatestTaskForRelatedSessionKeyForOwner({
+		relatedSessionKey: params.token,
+		callerOwnerKey: params.callerOwnerKey
+	});
+	if (related) return related;
+	const raw = resolveTaskForLookupToken(params.token);
+	return raw && canOwnerAccessTask(raw, params.callerOwnerKey) ? raw : void 0;
+}
+//#endregion
+export { getTaskByIdForOwner as a, updateTaskNotifyPolicyForOwner as c, findTaskByRunIdForOwner as i, cancelTaskByIdForOwner as n, listTasksForRelatedSessionKeyForOwner as o, findLatestTaskForRelatedSessionKeyForOwner as r, resolveTaskForLookupTokenForOwner as s, buildTaskStatusSnapshotForRelatedSessionKeyForOwner as t };