@sayknow-cli/coding-agent 0.4.7 → 0.5.1

package/src/skc-runtime/team-worker-memory-guard.ts

@@ -0,0 +1,363 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { appendJsonl, type StateWriterOptions } from "./state-writer";
+
+export type SkcTeamWorkerMemoryGuardState = "idle" | "advisory" | "retrying" | "checkpointed" | "replaced" | "blocked";
+
+export type SkcTeamWorkerMemoryGuardCheckpointKind =
+	| "clean"
+	| "eligible"
+	| "protected_only"
+	| "conflicted"
+	| "git_error";
+
+export type SkcTeamWorkerMemoryGuardPidProbe =
+	| { kind: "live"; start_time: string }
+	| { kind: "absent" }
+	| { kind: "unverifiable"; reason: string };
+
+export interface SkcTeamWorkerMemoryGuardCheckpoint {
+	kind: SkcTeamWorkerMemoryGuardCheckpointKind;
+	files: string[];
+	head?: string | null;
+	commit?: string | null;
+	recorded_at: string;
+}
+
+export interface SkcTeamWorkerMemoryGuardReplacement {
+	old_pane_id?: string;
+	new_pane_id?: string;
+	recorded_at: string;
+}
+
+export interface SkcTeamWorkerMemoryGuardLedger {
+	schema_version: 1;
+	worker_id: string;
+	platform: string;
+	state: SkcTeamWorkerMemoryGuardState;
+	automatic_action_allowed: boolean;
+	retry_count: number;
+	retry_limit: number;
+	current_task_id?: string;
+	last_incident_id?: string;
+	last_reason?: string;
+	last_pid_probe?: SkcTeamWorkerMemoryGuardPidProbe;
+	last_checkpoint?: SkcTeamWorkerMemoryGuardCheckpoint;
+	last_replacement?: SkcTeamWorkerMemoryGuardReplacement;
+	updated_at: string;
+}
+
+export interface SkcTeamWorkerMemoryGuardSelectionCandidate {
+	worker_id: string;
+	platform: string;
+	excess_bytes: number;
+	retry_count: number;
+	retry_limit: number;
+	blocked?: boolean;
+	current_task_id?: string;
+}
+
+export interface SkcTeamWorkerMemoryGuardSelection {
+	worker_id: string;
+	excess_bytes: number;
+	retry_count: number;
+	current_task_id?: string;
+}
+
+const ledgerKeys = new Set([
+	"schema_version",
+	"worker_id",
+	"platform",
+	"state",
+	"automatic_action_allowed",
+	"retry_count",
+	"retry_limit",
+	"current_task_id",
+	"last_incident_id",
+	"last_reason",
+	"last_pid_probe",
+	"last_checkpoint",
+	"last_replacement",
+	"updated_at",
+]);
+const checkpointKeys = new Set(["kind", "files", "head", "commit", "recorded_at"]);
+const replacementKeys = new Set(["old_pane_id", "new_pane_id", "recorded_at"]);
+const absentPidProbeKeys = new Set(["kind"]);
+const livePidProbeKeys = new Set(["kind", "start_time"]);
+const unverifiablePidProbeKeys = new Set(["kind", "reason"]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function hasExactKeys(value: Record<string, unknown>, keys: Set<string>): boolean {
+	return Object.keys(value).every(key => keys.has(key));
+}
+
+function isNonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.trim().length > 0;
+}
+
+function isTimestamp(value: unknown): value is string {
+	return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+
+function isRetryCount(value: unknown): value is number {
+	return Number.isInteger(value) && (value as number) >= 0;
+}
+
+function isWorkerMemoryGuardState(value: unknown): value is SkcTeamWorkerMemoryGuardState {
+	return ["idle", "advisory", "retrying", "checkpointed", "replaced", "blocked"].includes(String(value));
+}
+
+function isCheckpointKind(value: unknown): value is SkcTeamWorkerMemoryGuardCheckpointKind {
+	return ["clean", "eligible", "protected_only", "conflicted", "git_error"].includes(String(value));
+}
+
+export function workerMemoryGuardLedgerPath(dir: string, workerId: string): string {
+	return path.join(dir, "workers", workerId, "memory-guard.json");
+}
+
+export function normalizeSkcTeamWorkerMemoryGuardPidProbe(
+	value: unknown,
+): SkcTeamWorkerMemoryGuardPidProbe | undefined {
+	if (value === undefined) return undefined;
+	if (!isRecord(value)) throw new Error("invalid_worker_memory_guard_pid_probe");
+	const kind = typeof value.kind === "string" ? value.kind : "";
+	if (kind === "absent") {
+		if (!hasExactKeys(value, absentPidProbeKeys)) throw new Error("invalid_worker_memory_guard_pid_probe:absent");
+		return { kind: "absent" };
+	}
+	if (kind === "live") {
+		if (!hasExactKeys(value, livePidProbeKeys) || !isNonEmptyString(value.start_time))
+			throw new Error("invalid_worker_memory_guard_pid_probe:live");
+		return { kind: "live", start_time: value.start_time.trim() };
+	}
+	if (kind === "unverifiable") {
+		if (!hasExactKeys(value, unverifiablePidProbeKeys) || !isNonEmptyString(value.reason))
+			throw new Error("invalid_worker_memory_guard_pid_probe:unverifiable");
+		return { kind: "unverifiable", reason: value.reason.trim() };
+	}
+	throw new Error("invalid_worker_memory_guard_pid_probe");
+}
+
+export function isCanonicalSkcTeamWorkerMemoryGuardCheckpoint(
+	value: unknown,
+): value is SkcTeamWorkerMemoryGuardCheckpoint {
+	return (
+		isRecord(value) &&
+		hasExactKeys(value, checkpointKeys) &&
+		isCheckpointKind(value.kind) &&
+		Array.isArray(value.files) &&
+		value.files.every(file => isNonEmptyString(file)) &&
+		(value.head === undefined || value.head === null || isNonEmptyString(value.head)) &&
+		(value.commit === undefined || value.commit === null || isNonEmptyString(value.commit)) &&
+		isTimestamp(value.recorded_at)
+	);
+}
+
+export function isCanonicalSkcTeamWorkerMemoryGuardReplacement(
+	value: unknown,
+): value is SkcTeamWorkerMemoryGuardReplacement {
+	return (
+		isRecord(value) &&
+		hasExactKeys(value, replacementKeys) &&
+		(value.old_pane_id === undefined || isNonEmptyString(value.old_pane_id)) &&
+		(value.new_pane_id === undefined || isNonEmptyString(value.new_pane_id)) &&
+		isTimestamp(value.recorded_at)
+	);
+}
+
+export function isCanonicalSkcTeamWorkerMemoryGuardPidProbe(value: unknown): value is SkcTeamWorkerMemoryGuardPidProbe {
+	try {
+		return normalizeSkcTeamWorkerMemoryGuardPidProbe(value) !== undefined;
+	} catch {
+		return false;
+	}
+}
+
+export function isCanonicalSkcTeamWorkerMemoryGuardLedger(value: unknown): value is SkcTeamWorkerMemoryGuardLedger {
+	return (
+		isRecord(value) &&
+		hasExactKeys(value, ledgerKeys) &&
+		value.schema_version === 1 &&
+		isNonEmptyString(value.worker_id) &&
+		isNonEmptyString(value.platform) &&
+		isWorkerMemoryGuardState(value.state) &&
+		typeof value.automatic_action_allowed === "boolean" &&
+		isRetryCount(value.retry_count) &&
+		isRetryCount(value.retry_limit) &&
+		(value.current_task_id === undefined || isNonEmptyString(value.current_task_id)) &&
+		(value.last_incident_id === undefined || isNonEmptyString(value.last_incident_id)) &&
+		(value.last_reason === undefined || isNonEmptyString(value.last_reason)) &&
+		(value.last_pid_probe === undefined || isCanonicalSkcTeamWorkerMemoryGuardPidProbe(value.last_pid_probe)) &&
+		(value.last_checkpoint === undefined || isCanonicalSkcTeamWorkerMemoryGuardCheckpoint(value.last_checkpoint)) &&
+		(value.last_replacement === undefined ||
+			isCanonicalSkcTeamWorkerMemoryGuardReplacement(value.last_replacement)) &&
+		isTimestamp(value.updated_at)
+	);
+}
+
+export function createInitialSkcTeamWorkerMemoryGuardLedger(input: {
+	workerId: string;
+	platform: string;
+	now: string;
+	retryLimit?: number;
+}): SkcTeamWorkerMemoryGuardLedger {
+	const retryLimit = Number.isInteger(input.retryLimit) && (input.retryLimit ?? 0) > 0 ? input.retryLimit! : 2;
+	return {
+		schema_version: 1,
+		worker_id: input.workerId,
+		platform: input.platform.trim() || "unknown",
+		state: "idle",
+		automatic_action_allowed: false,
+		retry_count: 0,
+		retry_limit: retryLimit,
+		updated_at: input.now,
+	};
+}
+
+function workerIndex(workerId: string): number {
+	const match = /(?:^|[^0-9])(\d+)$/.exec(workerId);
+	return match ? Number.parseInt(match[1]!, 10) : Number.MAX_SAFE_INTEGER;
+}
+
+export function selectSkcTeamWorkerMemoryGuardCandidate(
+	candidates: readonly SkcTeamWorkerMemoryGuardSelectionCandidate[],
+): SkcTeamWorkerMemoryGuardSelection | undefined {
+	const eligible = candidates
+		.filter(candidate => candidate.platform === "linux")
+		.filter(candidate => Number.isFinite(candidate.excess_bytes) && candidate.excess_bytes > 0)
+		.filter(candidate => !candidate.blocked)
+		.filter(candidate => candidate.retry_count < candidate.retry_limit)
+		.sort((left, right) => {
+			if (right.excess_bytes !== left.excess_bytes) return right.excess_bytes - left.excess_bytes;
+			if (left.retry_count !== right.retry_count) return left.retry_count - right.retry_count;
+			const leftIndex = workerIndex(left.worker_id);
+			const rightIndex = workerIndex(right.worker_id);
+			if (leftIndex !== rightIndex) return leftIndex - rightIndex;
+			return left.worker_id.localeCompare(right.worker_id);
+		});
+	const first = eligible[0];
+	return first
+		? {
+				worker_id: first.worker_id,
+				excess_bytes: first.excess_bytes,
+				retry_count: first.retry_count,
+				current_task_id: first.current_task_id,
+			}
+		: undefined;
+}
+
+export type TeamWorkerMemoryGuardAction = "advisory" | "replace" | "blocked";
+export type TeamWorkerMemoryGuardResult = "noop" | "scheduled" | "succeeded" | "failed" | "blocked";
+
+export interface TeamWorkerMemoryGuardLedgerEntry {
+	schema_version: 1;
+	recorded_at: string;
+	incident_id: string;
+	team_name: string;
+	worker_id: string;
+	task_id: string;
+	claim_token: string;
+	attempt: number;
+	platform: NodeJS.Platform;
+	action: TeamWorkerMemoryGuardAction;
+	result: TeamWorkerMemoryGuardResult;
+	reason: string;
+}
+
+const teamWorkerMemoryGuardActions = new Set<TeamWorkerMemoryGuardAction>(["advisory", "replace", "blocked"]);
+const teamWorkerMemoryGuardResults = new Set<TeamWorkerMemoryGuardResult>([
+	"noop",
+	"scheduled",
+	"succeeded",
+	"failed",
+	"blocked",
+]);
+
+export function isCanonicalTeamWorkerMemoryGuardLedgerEntry(value: unknown): value is TeamWorkerMemoryGuardLedgerEntry {
+	if (!isRecord(value)) return false;
+	const requiredKeys = [
+		"schema_version",
+		"recorded_at",
+		"incident_id",
+		"team_name",
+		"worker_id",
+		"task_id",
+		"claim_token",
+		"attempt",
+		"platform",
+		"action",
+		"result",
+		"reason",
+	];
+	return (
+		Object.keys(value).length === requiredKeys.length &&
+		requiredKeys.every(key => Object.hasOwn(value, key)) &&
+		value.schema_version === 1 &&
+		isTimestamp(value.recorded_at) &&
+		isNonEmptyString(value.incident_id) &&
+		isNonEmptyString(value.team_name) &&
+		isNonEmptyString(value.worker_id) &&
+		isNonEmptyString(value.task_id) &&
+		isNonEmptyString(value.claim_token) &&
+		Number.isInteger(value.attempt) &&
+		(value.attempt as number) > 0 &&
+		isNonEmptyString(value.platform) &&
+		teamWorkerMemoryGuardActions.has(value.action as TeamWorkerMemoryGuardAction) &&
+		teamWorkerMemoryGuardResults.has(value.result as TeamWorkerMemoryGuardResult) &&
+		isNonEmptyString(value.reason)
+	);
+}
+
+export function teamWorkerMemoryGuardDir(workerDirPath: string): string {
+	return path.join(workerDirPath, "memory-guard");
+}
+
+export function teamWorkerMemoryGuardLedgerPath(workerDirPath: string): string {
+	return path.join(teamWorkerMemoryGuardDir(workerDirPath), "ledger.jsonl");
+}
+
+export function canMutateTeamWorkerMemoryGuard(platform: NodeJS.Platform): boolean {
+	return platform === "linux";
+}
+
+export function advisoryReasonForTeamWorkerMemoryGuard(platform: NodeJS.Platform): string | undefined {
+	return canMutateTeamWorkerMemoryGuard(platform) ? undefined : `unsupported_platform:${platform}`;
+}
+
+export async function appendTeamWorkerMemoryGuardLedgerEntry(
+	workerDirPath: string,
+	entry: TeamWorkerMemoryGuardLedgerEntry,
+	options?: StateWriterOptions,
+): Promise<string> {
+	await fs.mkdir(teamWorkerMemoryGuardDir(workerDirPath), { recursive: true });
+	return appendJsonl(teamWorkerMemoryGuardLedgerPath(workerDirPath), entry, options);
+}
+
+export async function readTeamWorkerMemoryGuardLedger(
+	workerDirPath: string,
+): Promise<TeamWorkerMemoryGuardLedgerEntry[]> {
+	const ledgerPath = teamWorkerMemoryGuardLedgerPath(workerDirPath);
+	if (!(await Bun.file(ledgerPath).exists())) return [];
+	const entries: TeamWorkerMemoryGuardLedgerEntry[] = [];
+	for (const [index, line] of (await Bun.file(ledgerPath).text()).split(/\r?\n/).filter(Boolean).entries()) {
+		const parsed = JSON.parse(line) as unknown;
+		if (!isCanonicalTeamWorkerMemoryGuardLedgerEntry(parsed))
+			throw new Error(`invalid_team_worker_memory_guard_ledger:${ledgerPath}:${index + 1}`);
+		entries.push(parsed);
+	}
+	return entries;
+}
+
+export function nextTeamWorkerMemoryGuardAttempt(
+	entries: readonly TeamWorkerMemoryGuardLedgerEntry[],
+	incidentId: string,
+): number {
+	let attempt = 0;
+	for (const entry of entries) {
+		if (entry.incident_id === incidentId && entry.attempt > attempt) attempt = entry.attempt;
+	}
+	return attempt + 1;
+}

package/src/skc-runtime/team-workers.ts

@@ -352,6 +352,7 @@ export async function writeSkcWorkerStartupAck(
 		pid: typeof input.pid === "number" ? input.pid : undefined,
 		session: typeof input.session === "string" ? input.session : undefined,
 		protocol_version: String(input.protocol_version ?? "1"),
+		replacement_token: typeof input.replacement_token === "string" ? input.replacement_token : undefined,
 		ack_at: runtime.now(),
 	};
 	await runtime.writeJson(path.join(runtime.workerDir(dir, worker), "startup-ack.json"), ack);

package/src/skc-runtime/tmux-common.ts

@@ -246,8 +246,19 @@ export function buildSkcTmuxProfileCommands(
 	commands.push(
 		{ description: "enable tmux clipboard integration", args: ["set-option", "-t", target, "set-clipboard", "on"] },
 		{
-			// Forward DCS passthrough (sixel graphics / Sayknow Pet) to the outer
-			// terminal. `-pq` scopes it to this session's pane (never the global
+			// Hand tmux ownership of sixel. tmux 3.4+ parses sixel into its own screen
+			// model and re-renders it, so scroll / clear / resize / copy-mode all work on
+			// the pet. Without this tmux never records the image, and an erase can only
+			// reach its cell buffer while the pixels sit in the outer terminal's image
+			// plane — which is what leaves residue behind the pet.
+			// `-a` appends so a user's own terminal-features survive; unknown on tmux <
+			// 3.2, hence `-q`.
+			description: "let tmux own sixel graphics",
+			args: ["set-option", "-aq", "-t", target, "terminal-features", ",*:sixel"],
+		},
+		{
+			// Passthrough remains the fallback for terminals/tmux builds that do not
+			// claim sixel. `-pq` scopes it to this session's pane (never the global
 			// server state) and stays quiet on tmux < 3.3 where the option is unknown.
 			description: "allow DCS passthrough for sixel graphics",
 			args: ["set-option", "-pq", "-t", target, "allow-passthrough", "on"],

package/src/skc-runtime/tmux-owner-isolation.ts

@@ -960,6 +960,24 @@ export function lifecyclePaths(stateDir: string, sessionId: string, generation:
 	};
 }
 
+export interface MemoryGuardClaimPaths {
+	root: string;
+	databaseFile: string;
+	walFile: string;
+	shmFile: string;
+}
+
+export function memoryGuardClaimPaths(stateDir: string, sessionId: string): MemoryGuardClaimPaths {
+	const root = path.join(stateDir, "memory-guard-claims", sessionId);
+	const databaseFile = path.join(root, "claims.sqlite");
+	return {
+		root,
+		databaseFile,
+		walFile: `${databaseFile}-wal`,
+		shmFile: `${databaseFile}-shm`,
+	};
+}
+
 export async function replaceOwnerGeneration(
 	stateDir: string,
 	sessionId: string,
@@ -1646,7 +1664,8 @@ export function isValidOwnerIntent(intent: unknown, request?: ObserveTerminalReq
 		intent.generation === request.owner_generation &&
 		intent.session_id === request.session_id &&
 		intent.server_key === request.socket_key &&
-		(request.operator_dispatch_id === undefined || intent.dispatch_id === request.operator_dispatch_id) &&
+		request.operator_dispatch_id !== undefined &&
+		intent.dispatch_id === request.operator_dispatch_id &&
 		request.signal === "SIGTERM"
 	);
 }

package/src/skc-runtime/tmux-sessions.ts

@@ -3,6 +3,7 @@ import * as crypto from "node:crypto";
 import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { Process } from "@sayknow-cli/natives";
 import { readLinuxProcStartTime, readLinuxProcStartTimeSync } from "./linux-proc";
 import { resolveSkcTmuxBinary } from "./psmux-detect";
 import { tmuxRuntimeSessionPath } from "./session-layout";
@@ -43,6 +44,7 @@ import {
 	lifecyclePaths,
 	type OwnerIsolationProbeSync,
 	type OwnerVerdict,
+	observeOwnerTerminal,
 	type PlanResponse,
 	planTmuxOwnerIsolationSync,
 	replaceOwnerGenerationSync,
@@ -963,6 +965,14 @@ async function readProcessStartTime(pid: number): Promise<string | null> {
 	return readLinuxProcStartTime(pid);
 }
 
+function exactManagedOwnerSupervisor(supervisorPid: number, supervisorStartTime: string): Process {
+	const supervisor = Process.fromPid(supervisorPid);
+	if (!supervisor) throw new Error("managed_owner_supervisor_unverifiable");
+	if (process.platform === "linux" && supervisor.incarnation !== `linux:${supervisorStartTime}`)
+		throw new Error("managed_owner_supervisor_incarnation_mismatch");
+	return supervisor;
+}
+
 async function readCurrentGeneration(stateDir: string, sessionId: string): Promise<string | null> {
 	try {
 		const value: unknown = JSON.parse(
@@ -1016,12 +1026,12 @@ async function requireUnchangedOwnerForCompatibilityCleanup(
 	initialServer: { pid: number; startTime: string },
 	listPanePids: (sessionName: string, env: NodeJS.ProcessEnv) => number[],
 	readStartTime: (pid: number) => Promise<string | null>,
-): Promise<void> {
+): Promise<boolean> {
 	try {
 		const currentNativeSessionId = readNativeTmuxSessionId(nativeSessionId, env);
 		if (!currentNativeSessionId) {
 			if (readNativeTmuxSessionId(sessionName, env)) throw new Error(`skc_tmux_owner_changed:${sessionName}`);
-			return;
+			return false;
 		}
 		const currentServer = requireSafeTmuxServerForMutation(resolveSkcTmuxCommand(env), env);
 		const panePids = listPanePids(nativeSessionId, env);
@@ -1054,10 +1064,11 @@ async function requireUnchangedOwnerForCompatibilityCleanup(
 				: null,
 		].filter((value): value is string => value !== null);
 		if (mismatches.length > 0) throw new Error(`skc_tmux_owner_changed:${sessionName}:${mismatches.join(",")}`);
+		return true;
 	} catch (error) {
 		if (!readNativeTmuxSessionId(nativeSessionId, env)) {
 			if (readNativeTmuxSessionId(sessionName, env)) throw new Error(`skc_tmux_owner_changed:${sessionName}`);
-			return;
+			return false;
 		}
 		if (error instanceof Error && error.message.startsWith(`skc_tmux_owner_changed:${sessionName}`))
 			throw new Error(`skc_tmux_owner_changed:${sessionName}`);
@@ -1152,6 +1163,7 @@ export async function forceCloseSkcTmuxSession(
 	const now = deps.now ?? (() => new Date());
 	const sleep = deps.sleep ?? (ms => Bun.sleep(ms));
 	const dispatchId = crypto.randomUUID();
+	let operatorVerdict: Promise<OwnerVerdict> | null = null;
 	await closeExactTmuxOwner(
 		{
 			stateDir: identity.stateDir,
@@ -1169,12 +1181,37 @@ export async function forceCloseSkcTmuxSession(
 			sendSigterm: async pid => {
 				if ((await (deps.readProcessStartTime ?? readProcessStartTime)(pid)) !== identity.startTime)
 					throw new Error("owner_pid_identity_mismatch");
-				(deps.signalTerm ?? (target => process.kill(target, "SIGTERM")))(pid);
+				if (deps.signalTerm) {
+					deps.signalTerm(pid);
+				} else {
+					const supervisor = exactManagedOwnerSupervisor(pid, identity.startTime);
+					if (!supervisor.signalRoot(15)) throw new Error("managed_owner_supervisor_signal_failed");
+					operatorVerdict = supervisor
+						.waitForExit({ timeoutMs: FORCE_CLOSE_VERDICT_TIMEOUT_MS - 500 })
+						.then(async exited => {
+							if (!exited) throw new Error("managed_owner_supervisor_exit_timeout");
+							return await observeOwnerTerminal({
+								schema_version: 1,
+								op: "observe_terminal",
+								session_id: identity.sessionId,
+								owner_generation: identity.generation,
+								state_dir: identity.stateDir,
+								socket_key: identity.socketKey,
+								observer: "raw_monitor",
+								observed_at: now().toISOString(),
+								signal: "SIGTERM",
+								exit_code: null,
+								exit_kind: "exact_owner_exit_observed",
+								reason: "operator_observed_owner_exit",
+								operator_dispatch_id: dispatchId,
+							});
+						});
+				}
 			},
 
-			waitForVerdict: () => waitForExpectedVerdict(identity, sleep, now),
+			waitForVerdict: () => operatorVerdict ?? waitForExpectedVerdict(identity, sleep, now),
 			cleanupSession: async () => {
-				await requireUnchangedOwnerForCompatibilityCleanup(
+				const cleanupRequired = await requireUnchangedOwnerForCompatibilityCleanup(
 					session.name,
 					nativeSessionId,
 					env,
@@ -1184,6 +1221,7 @@ export async function forceCloseSkcTmuxSession(
 					deps.listPanePids ?? readExactSessionPanePids,
 					deps.readProcessStartTime ?? readProcessStartTime,
 				);
+				if (!cleanupRequired) return;
 				if (deps.cleanupSession) deps.cleanupSession(nativeSessionId, env);
 				else
 					runGuardedTmuxSessionCommand(
@@ -1192,6 +1230,7 @@ export async function forceCloseSkcTmuxSession(
 						initialServer.pid,
 						env,
 						`kill-session -t '${nativeSessionId}'`,
+						identity.generation,
 					);
 			},
 		},