@gajae-code/coding-agent 0.12.19 → 0.12.20

package/src/sdk/broker/lifecycle.ts

@@ -13,7 +13,7 @@ function nativeLifecycle(): typeof import("@gajae-code/natives") {
 	return nativeLifecycleBindings;
 }
 
-import { $credentialEnv, resolveEquivalentPath } from "@gajae-code/utils";
+import { $credentialEnv, logger, resolveEquivalentPath } from "@gajae-code/utils";
 
 import {
 	isModelProfileError,
@@ -51,7 +51,11 @@ import {
 	type ManagedSessionScope,
 	resolveManagedSessionScope,
 } from "../session-directory";
-import type { SdkStartupFailure, SdkStartupRollbackResult } from "../startup-capability";
+import {
+	normalizeSdkStartupFailure,
+	type SdkStartupFailure,
+	type SdkStartupRollbackResult,
+} from "../startup-capability";
 import type { Broker, BrokerCleanupEvidence, BrokerCleanupIdentity, BrokerResponse } from "./broker";
 import { decodeLifecycleUtf8, parseLifecycleJson } from "./lifecycle-codec";
 import type {
@@ -68,6 +72,13 @@ import {
 	processIncarnation,
 } from "./process-incarnation";
 import { resolveSdkInternalSpawnCommand, type SdkInternalSpawnCommand } from "./runtime";
+import {
+	cancellableSleep,
+	DEFAULT_READINESS_TIMEOUT_MS,
+	isValidReadinessTimeoutMs,
+	READINESS_TIMEOUT_INVALID_MESSAGE,
+	startupQueueWaitMs,
+} from "./startup-budget";
 
 export {
 	type ProcessIncarnationCommandRunner,
@@ -76,9 +87,6 @@ export {
 	processIncarnation,
 };
 
-const READY_TIMEOUT_MS = 10_000;
-const MIN_READY_TIMEOUT_MS = 4_000;
-const MAX_READY_TIMEOUT_MS = 60_000;
 const POLL_MS = 50;
 const CLOSE_TIMEOUT_MS = 2_000;
 const MAX_RECEIVED_AT_SKEW_MS = 5_000;
@@ -95,12 +103,7 @@ export interface LifecycleDeadlines {
 }
 
 export function deriveLifecycleDeadlines(receivedAt: number, requestedReadinessTimeoutMs: number): LifecycleDeadlines {
-	if (
-		!Number.isSafeInteger(receivedAt) ||
-		!Number.isSafeInteger(requestedReadinessTimeoutMs) ||
-		requestedReadinessTimeoutMs < MIN_READY_TIMEOUT_MS ||
-		requestedReadinessTimeoutMs > MAX_READY_TIMEOUT_MS
-	)
+	if (!Number.isSafeInteger(receivedAt) || !isValidReadinessTimeoutMs(requestedReadinessTimeoutMs))
 		throw new Error("Lifecycle timing values must be safe integers in the approved readiness range.");
 	const phaseWindowMs = Math.min(1_000, Math.max(500, Math.floor(requestedReadinessTimeoutMs / 4)));
 	const lifecycleCleanupDeadlineAt = receivedAt + requestedReadinessTimeoutMs;
@@ -124,18 +127,17 @@ export function deriveLifecycleDeadlines(receivedAt: number, requestedReadinessT
 
 export interface LifecycleTiming {
 	now(): number;
-	sleep(ms: number): Promise<void>;
+	sleep(ms: number, signal?: AbortSignal): Promise<void>;
 }
 
-const defaultLifecycleTiming: LifecycleTiming = {
-	now: Date.now,
-	sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
-};
+const defaultLifecycleTiming: LifecycleTiming = { now: Date.now, sleep: cancellableSleep };
 const lifecycleTimingsForTest = new WeakMap<Broker, LifecycleTiming>();
 type LifecycleCommand = SdkInternalSpawnCommand | { file: string; args: string[] };
 type LifecycleCommandResolver = () => LifecycleCommand;
 const lifecycleCommandResolversForTest = new WeakMap<Broker, LifecycleCommandResolver>();
 const lifecycleCleanupHooksForTest = new WeakMap<Broker, () => void>();
+const startupAdmittedInputs = new WeakSet<Input>();
+const startupLaunchInputs = new WeakMap<Input, SessionLaunch>();
 
 /** Test-only hook for simulating a crash immediately after one exact lifecycle detach. */
 export function setLifecycleCleanupHookForTest(broker: Broker, hook: (() => void) | undefined): void {
@@ -486,17 +488,8 @@ export function validateBrokerModelPresetForTest(agentDir: string, requestedProf
 
 function readinessTimeout(input: Input): number | BrokerResponse {
 	const value = input.readinessTimeoutMs;
-	if (value === undefined) return READY_TIMEOUT_MS;
-	if (
-		typeof value !== "number" ||
-		!Number.isSafeInteger(value) ||
-		value < MIN_READY_TIMEOUT_MS ||
-		value > MAX_READY_TIMEOUT_MS
-	)
-		return fail(
-			"invalid_input",
-			`readinessTimeoutMs must be an integer between ${MIN_READY_TIMEOUT_MS} and ${MAX_READY_TIMEOUT_MS}.`,
-		);
+	if (value === undefined) return DEFAULT_READINESS_TIMEOUT_MS;
+	if (!isValidReadinessTimeoutMs(value)) return fail("invalid_input", READINESS_TIMEOUT_INVALID_MESSAGE);
 	return value;
 }
 
@@ -976,6 +969,7 @@ function isSdkStartupFailure(value: unknown): value is SdkStartupFailure {
 			failure.reason !== "ineligible" &&
 			failure.reason !== "factory_absent" &&
 			failure.reason !== "runner_absent" &&
+			failure.reason !== "admission_timeout" &&
 			failure.reason !== "pending" &&
 			failure.reason !== "failed") ||
 		typeof failure.message !== "string" ||
@@ -3109,15 +3103,57 @@ async function executeLifecycleResponse(
 			}
 		}
 		const timing = lifecycleTiming(broker);
+		const admissionGranted = startupAdmittedInputs.has(input);
+		if (!admissionGranted) {
+			const suppliedDeadlineFields = [
+				input.receivedAt,
+				input.requestedReadinessTimeoutMs,
+				input.semanticReadyDeadlineAt,
+				input.terminationStartDeadlineAt,
+				input.lifecycleCleanupDeadlineAt,
+			];
+			let requestedReadinessTimeoutMs: number;
+			if (suppliedDeadlineFields.some(value => value !== undefined)) {
+				const supplied = lifecycleDeadlines(input, timing.now());
+				if ("ok" in supplied) return supplied;
+				requestedReadinessTimeoutMs = supplied.requestedReadinessTimeoutMs;
+			} else {
+				const timeout = readinessTimeout(input);
+				if (typeof timeout !== "number") return timeout;
+				requestedReadinessTimeoutMs = timeout;
+			}
+			const queueWaitMs = startupQueueWaitMs(requestedReadinessTimeoutMs);
+			const launch = await launchInput(broker, operation, input);
+			if ("ok" in launch) return launch;
+			const admitted = await broker.runStartup(queueWaitMs, timing, async admittedAt => {
+				const admittedInput = { ...input, ...deriveLifecycleDeadlines(admittedAt, requestedReadinessTimeoutMs) };
+				startupAdmittedInputs.add(admittedInput);
+				startupLaunchInputs.set(admittedInput, launch);
+				try {
+					return await executeLifecycleResponse(broker, operation, admittedInput, identity, cleanup);
+				} finally {
+					startupLaunchInputs.delete(admittedInput);
+					startupAdmittedInputs.delete(admittedInput);
+				}
+			});
+			if (admitted.status === "completed") return admitted.value;
+			if (admitted.status === "admission_refused")
+				return fail(
+					"startup_admission_refused",
+					"SDK host startup was refused because the broker no longer owns the session root.",
+				);
+			const failure = normalizeSdkStartupFailure("startup", admitted.reason);
+			return fail("startup_admission_timeout", failure.message);
+		}
 
-		const deadlines = lifecycleDeadlines(input, timing.now());
+		const deadlines = lifecycleDeadlines(input, input.receivedAt as number);
 
 		if ("ok" in deadlines) return deadlines;
 		const lifecycleDeadline = deadlines.lifecycleCleanupDeadlineAt;
 		const readinessDeadline = deadlines.semanticReadyDeadlineAt;
 		const terminationStartDeadline = deadlines.terminationStartDeadlineAt;
 
-		const launch = await launchInput(broker, operation, input);
+		const launch = startupLaunchInputs.get(input) ?? (await launchInput(broker, operation, input));
 		if ("ok" in launch) return launch;
 		if (!hasProcessIncarnationAuthority())
 			return fail(
@@ -3207,41 +3243,49 @@ async function executeLifecycleResponse(
 		let child: ChildProcess | undefined;
 		let spawnedAuthority: EffectMarker | undefined;
 		try {
-			const cmd = command(broker);
-			const spawned = spawn(cmd.file, cmd.args, {
-				cwd: launch.cwd,
-				detached: true,
-				stdio: "ignore",
-				env: {
-					...("kind" in cmd ? cmd.env : process.env),
-					GJC_AGENT_DIR: broker.settings.agentDir,
-					GJC_CODING_AGENT_DIR: broker.settings.agentDir,
-					GJC_SESSION_ID: launch.id,
-					GJC_STATE_ROOT: launch.root,
-					GJC_LIFECYCLE_REQUEST_ID: effectMarker,
-					GJC_SDK_LIFECYCLE_REQUEST: JSON.stringify(request),
-					// Coordinator-correlation env scoped to this designated launch only (#2549).
-					// The runtime sidecar reads these to write terminal state to the
-					// coordinator-shared file instead of an unread session-local fallback.
-					// The broker computes the file path from coordinatorStateDir + launch.id
-					// because the session ID is generated at spawn time.
-					...(launch.coordinatorStateDir
-						? {
-								[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]: path.join(
-									launch.coordinatorStateDir,
-									"session-states",
-									`${launch.id}.json`,
-								),
-							}
-						: {}),
-					...(launch.coordinatorSessionId
-						? { [GJC_COORDINATOR_SESSION_ID_ENV]: launch.coordinatorSessionId }
-						: {}),
-					...(launch.coordinatorSessionBranch
-						? { [GJC_COORDINATOR_SESSION_BRANCH_ENV]: launch.coordinatorSessionBranch }
-						: {}),
-				},
+			const authorizedSpawn = broker.runSynchronousEffectWithFreshPublicationAuthority(() => {
+				const cmd = command(broker);
+				return spawn(cmd.file, cmd.args, {
+					cwd: launch.cwd,
+					detached: true,
+					stdio: "ignore",
+					env: {
+						...("kind" in cmd ? cmd.env : process.env),
+						GJC_AGENT_DIR: broker.settings.agentDir,
+						GJC_CODING_AGENT_DIR: broker.settings.agentDir,
+						GJC_SESSION_ID: launch.id,
+						GJC_STATE_ROOT: launch.root,
+						GJC_LIFECYCLE_REQUEST_ID: effectMarker,
+						GJC_SDK_LIFECYCLE_REQUEST: JSON.stringify(request),
+						// Coordinator-correlation env scoped to this designated launch only (#2549).
+						// The runtime sidecar reads these to write terminal state to the
+						// coordinator-shared file instead of an unread session-local fallback.
+						// The broker computes the file path from coordinatorStateDir + launch.id
+						// because the session ID is generated at spawn time.
+						...(launch.coordinatorStateDir
+							? {
+									[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]: path.join(
+										launch.coordinatorStateDir,
+										"session-states",
+										`${launch.id}.json`,
+									),
+								}
+							: {}),
+						...(launch.coordinatorSessionId
+							? { [GJC_COORDINATOR_SESSION_ID_ENV]: launch.coordinatorSessionId }
+							: {}),
+						...(launch.coordinatorSessionBranch
+							? { [GJC_COORDINATOR_SESSION_BRANCH_ENV]: launch.coordinatorSessionBranch }
+							: {}),
+					},
+				});
 			});
+			if (!authorizedSpawn.authorized)
+				return fail(
+					"startup_admission_refused",
+					"SDK host startup was refused because the broker no longer owns the session root.",
+				);
+			const spawned = authorizedSpawn.value;
 			child = spawned;
 			const pid = spawned.pid;
 			if (!pid) throw new Error("spawned session has no pid");
@@ -4382,3 +4426,174 @@ export async function executeLifecycle(
 		...(startupFailure ? { startupFailure } : {}),
 	};
 }
+
+/**
+ * The live client/socket subscription count of the SDK session endpoint this
+ * process serves, or `undefined` while this process serves no endpoint.
+ *
+ * Only the SDK session runtime owns the real socket table, so it publishes a
+ * reader here instead of every consumer re-deriving attachment from the OS.
+ * Consumers must treat `undefined` as "no evidence" and never as "detached".
+ */
+export type SessionHostAttachmentReader = () => number;
+
+/** What one serving runtime reports about itself while its transport is up. */
+export interface SessionHostRuntimeEvidence {
+	/** This runtime's own live SDK client/socket subscription count. */
+	attachedClients: SessionHostAttachmentReader;
+	/** Whether this runtime currently has agent work in flight. */
+	workInFlight: () => boolean;
+}
+
+/** One runtime's live publication, retractable only by its owner. */
+export interface SessionHostRuntimePublication {
+	/**
+	 * Withdraws the evidence this handle published. Idempotent, and never able
+	 * to touch a sibling runtime's evidence.
+	 */
+	retract(): void;
+}
+
+/**
+ * Every runtime in this process that currently serves an SDK endpoint.
+ *
+ * A process can serve more than one at a time: an identity-rotating control op
+ * starts the successor before the predecessor's deferred stop runs. A single
+ * global slot let that predecessor's teardown retract the live successor's
+ * reader and manufacture "no evidence" for a host with clients attached, so
+ * publications are held per runtime and retracted only through their own handle.
+ */
+const sessionHostRuntimes = new Set<SessionHostRuntimeEvidence>();
+
+/**
+ * Publishes this runtime's own liveness evidence for the lifetime of its
+ * transport. Retraction goes through the returned handle, so a runtime can only
+ * ever withdraw evidence it owns.
+ */
+export function publishSessionHostRuntimeEvidence(evidence: SessionHostRuntimeEvidence): SessionHostRuntimePublication {
+	const published: SessionHostRuntimeEvidence = { ...evidence };
+	sessionHostRuntimes.add(published);
+	return {
+		retract(): void {
+			sessionHostRuntimes.delete(published);
+		},
+	};
+}
+
+/**
+ * This process's currently attached SDK client count, summed across every
+ * serving runtime, or `undefined` when no runtime publishes a readable count
+ * (before startup, after teardown, or when every reader itself fails). Never
+ * guesses: absence of a reader is absence of evidence.
+ */
+export function sessionHostAttachedClients(): number | undefined {
+	let total: number | undefined;
+	for (const { attachedClients } of sessionHostRuntimes) {
+		let count: number;
+		try {
+			count = attachedClients();
+		} catch {
+			continue;
+		}
+		if (!Number.isSafeInteger(count) || count < 0) continue;
+		total = (total ?? 0) + count;
+	}
+	return total;
+}
+
+/**
+ * Whether any runtime in this process has agent work in flight right now.
+ *
+ * Positive evidence only: a runtime that publishes nothing, or whose reader
+ * fails, reports no work, so this can never keep an abandoned host alive.
+ */
+export function sessionHostWorkInFlight(): boolean {
+	for (const { workInFlight } of sessionHostRuntimes) {
+		try {
+			if (workInFlight()) return true;
+		} catch {}
+	}
+	return false;
+}
+
+/**
+ * How often a live broker re-checks its own session registrations against OS
+ * process liveness.
+ *
+ * This sweep can never disturb healthy work: a registration is only dropped
+ * when `process.kill(pid, 0)` proves the exact published pid is gone, and a
+ * working host answers that probe for its entire life no matter how long a turn
+ * runs. One minute keeps `gjc_sessions`/`session.get_endpoint` from advertising
+ * a corpse for longer than a single poll while costing one index refresh per
+ * minute on an otherwise idle broker.
+ */
+export const BROKER_DEAD_REGISTRATION_SWEEP_MS = 60_000;
+
+/** One reaped registration, as recorded by {@link reapDeadSessionRegistrations}. */
+export interface ReapedSessionRegistration {
+	sessionId: string;
+	pid: number;
+	endpointGeneration: number;
+}
+
+/**
+ * Drops every indexed session registration whose host process is provably gone.
+ *
+ * Liveness is the session index's own `alive(pid)` probe (`listSessions().live`),
+ * which reports live for both a running pid and an EPERM pid, so an alien or
+ * unreadable process is never mistaken for a dead one. Registrations already
+ * marked `terminalUncertain` are left alone: their disposition belongs to the
+ * terminal-uncertainty reconciliation path, and silently dropping them would
+ * turn a fail-closed `session.close`/`session.delete` refusal into `not_found`.
+ */
+export async function reapDeadSessionRegistrations(
+	broker: Pick<Broker, "index">,
+): Promise<ReapedSessionRegistration[]> {
+	await broker.index.refresh();
+	const dead = broker.index.listSessions().sessions.filter(session => !session.live && !session.terminalUncertain);
+	const reaped: ReapedSessionRegistration[] = [];
+	for (const session of dead) {
+		await broker.index.append({
+			type: "host_unregistered",
+			sessionId: session.sessionId,
+			locator: session.locator,
+			endpointGeneration: session.endpointGeneration,
+			pid: session.pid,
+			...(session.endpointMtimeMs === undefined ? {} : { endpointMtimeMs: session.endpointMtimeMs }),
+			...(session.lifecycleRequestId ? { lifecycleRequestId: session.lifecycleRequestId } : {}),
+		});
+		const record = {
+			sessionId: session.sessionId,
+			pid: session.pid,
+			endpointGeneration: session.endpointGeneration,
+		};
+		reaped.push(record);
+		logger.warn("sdk broker reaped a session registration whose host process is gone", record);
+	}
+	return reaped;
+}
+
+/**
+ * Runs {@link reapDeadSessionRegistrations} on {@link BROKER_DEAD_REGISTRATION_SWEEP_MS}.
+ * The timer is unref'd, so it never keeps an otherwise idle broker process alive.
+ * Returns a disposer.
+ */
+export function startBrokerDeadRegistrationSweep(
+	broker: Pick<Broker, "index">,
+	intervalMs = BROKER_DEAD_REGISTRATION_SWEEP_MS,
+): () => void {
+	let running = false;
+	const timer = setInterval(() => {
+		if (running) return;
+		running = true;
+		void reapDeadSessionRegistrations(broker)
+			.catch(error => {
+				logger.warn("sdk broker dead-registration sweep failed", { error: String(error) });
+			})
+			.finally(() => {
+				running = false;
+			});
+	}, intervalMs);
+	timer.unref();
+	return () => clearInterval(timer);
+}

package/src/sdk/broker/startup-budget.ts

@@ -0,0 +1,103 @@
+/** Readiness budget the broker grants a lifecycle request that does not size one itself. */
+export const DEFAULT_READINESS_TIMEOUT_MS = 10_000;
+export const MIN_READINESS_TIMEOUT_MS = 4_000;
+export const MAX_READINESS_TIMEOUT_MS = 60_000;
+
+export function isValidReadinessTimeoutMs(value: unknown): value is number {
+	return (
+		typeof value === "number" &&
+		Number.isSafeInteger(value) &&
+		value >= MIN_READINESS_TIMEOUT_MS &&
+		value <= MAX_READINESS_TIMEOUT_MS
+	);
+}
+
+export const READINESS_TIMEOUT_INVALID_MESSAGE = `readinessTimeoutMs must be an integer between ${MIN_READINESS_TIMEOUT_MS} and ${MAX_READINESS_TIMEOUT_MS}.`;
+/**
+ * Sleep until the duration elapses or the caller cancels the wait. Queue admission
+ * uses this so a granted or refused waiter does not retain its cutoff timer for the
+ * rest of the readiness budget.
+ */
+export function cancellableSleep(ms: number, signal?: AbortSignal): Promise<void> {
+	if (signal?.aborted || ms <= 0) return Promise.resolve();
+	const settled = Promise.withResolvers<void>();
+	const cancel = (): void => {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", cancel);
+		settled.resolve();
+	};
+	const timer = setTimeout(cancel, ms);
+	signal?.addEventListener("abort", cancel, { once: true });
+	return settled.promise;
+}
+
+/**
+ * Slack a caller adds over the broker-side budget so that a startup which runs to the
+ * very edge of its window is reported as the broker's own terminal result rather than
+ * as the caller's timeout.
+ */
+const CALLER_DEADLINE_SLACK_MS = 1_000;
+
+/**
+ * Whether a broker operation waits in the host-startup admission queue before it runs.
+ * Only these spawn a host, so only these can be parked behind a full queue; the other
+ * lifecycle operations start their readiness clock as soon as they are received.
+ */
+export function isStartupLifecycleOperation(operation: string): boolean {
+	return operation === "session.create" || operation === "session.fork" || operation === "session.resume";
+}
+
+/**
+ * Bounded time a lifecycle startup may wait for a host-startup admission slot. It
+ * is the readiness budget itself: a startup still queued after that long has spent
+ * the whole window the request was sized for, so refusing it beats launching a host
+ * that is already late.
+ */
+export function startupQueueWaitMs(requestedReadinessTimeoutMs: number): number {
+	return requestedReadinessTimeoutMs;
+}
+
+/**
+ * Broker-side wall clock a lifecycle startup may consume: the admission wait plus
+ * the readiness budget, which is granted fresh at admission and so is never shortened
+ * by queueing. Callers MUST size their own request deadline against this rather than
+ * `readinessTimeoutMs` alone, or a request admitted late fails client-side while the
+ * broker keeps running it to a durably persisted terminal result.
+ */
+export function lifecycleStartupBudgetMs(requestedReadinessTimeoutMs: number): number {
+	return startupQueueWaitMs(requestedReadinessTimeoutMs) + requestedReadinessTimeoutMs;
+}
+
+/**
+ * Request deadline a caller MUST grant a broker operation, or `undefined` when the
+ * operation carries no readiness budget of its own and the client default already
+ * covers it.
+ *
+ * A request that omits `readinessTimeoutMs` is sized against the broker's default
+ * rather than left unextended: the broker queues it for exactly as long as one that
+ * asked, so the common path would otherwise fail client-side while the broker runs
+ * the startup to a durably persisted terminal result.
+ */
+export function lifecycleRequestTimeoutMs(operation: string, input: Record<string, unknown>): number | undefined {
+	const deadlineFields = [
+		input.receivedAt,
+		input.requestedReadinessTimeoutMs,
+		input.semanticReadyDeadlineAt,
+		input.terminationStartDeadlineAt,
+		input.lifecycleCleanupDeadlineAt,
+	];
+	const hasDeadlineTuple = deadlineFields.some(value => value !== undefined);
+	let supplied: number | undefined;
+	if (hasDeadlineTuple) {
+		if (!deadlineFields.every(value => typeof value === "number" && Number.isSafeInteger(value))) return undefined;
+		if (!isValidReadinessTimeoutMs(input.requestedReadinessTimeoutMs)) return undefined;
+		supplied = input.requestedReadinessTimeoutMs;
+	} else {
+		const requested = input.readinessTimeoutMs;
+		if (requested !== undefined && !isValidReadinessTimeoutMs(requested)) return undefined;
+		supplied = requested as number | undefined;
+	}
+	if (isStartupLifecycleOperation(operation))
+		return lifecycleStartupBudgetMs(supplied ?? DEFAULT_READINESS_TIMEOUT_MS) + CALLER_DEADLINE_SLACK_MS;
+	return supplied === undefined ? undefined : supplied + CALLER_DEADLINE_SLACK_MS;
+}

package/src/sdk/bus/chat-daemon-control.ts

@@ -66,11 +66,17 @@ export type ChatDaemonAction = "stop" | "reload";
  * them against an exact owner tuple, so an owner at an earlier generation may
  * not serve or answer a request captured against this contract. Discord
  * generation 27 / slack generation 26 move shared exact unlink and process-
- * incarnation authority behind lazy native bindings.
+ * incarnation authority behind lazy native bindings. Discord generation 28 /
+ * slack generation 27 dial attached-session clients on the long-lived session
+ * reconnect budget, so an owner at an earlier generation gives up reconnecting
+ * before the host heartbeat TTL expires and permanently loses its attachment. Discord
+ * generation 29 / slack generation 28 advance the replay cursor only after a frame is
+ * published, so an owner at an earlier generation acknowledges an event before delivering
+ * it and loses that event for good the first time a surface refuses it.
  */
 export const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>> = {
-	discord: 27,
-	slack: 26,
+	discord: 29,
+	slack: 28,
 };
 
 export function chatDaemonGeneration(kind: ChatDaemonKind): number {