@sayknow-cli/coding-agent 0.2.2

package/src/rlm/preset.ts

@@ -0,0 +1,76 @@
+/**
+ * RLM research preset: the static research system prompt, the exact tool
+ * allowlist, and a hard boundary assertion that fails launch if any
+ * non-allowlisted tool is active.
+ */
+import rlmResearchPrompt from "../prompts/system/rlm-research.md" with { type: "text" };
+import type { RlmDataContext } from "./data-context";
+
+/**
+ * tool; `read` and `web_search` are the existing built-ins. `bash` is exposed
+ * through the read-only restriction profile below for inspection commands only,
+ * and `goal` is required so RLM sessions cannot finish without explicit goal
+ * completion. Everything else (edit, write, task, skill, browser, eval-js, ...) is excluded.
+ */
+export const RLM_READ_ONLY_BASH_PREFIXES: readonly string[] = [
+	"grep",
+	"rg",
+	"tree",
+	"ls",
+	"pwd",
+	"wc",
+	"du",
+	"file",
+	"stat",
+];
+export const RLM_TOOL_ALLOWLIST: readonly string[] = [
+	"python",
+	"read",
+	"web_search",
+	"search_tool_bm25",
+	"bash",
+	"goal",
+	"complete_research",
+];
+
+export function isRlmToolAllowed(name: string): boolean {
+	return RLM_TOOL_ALLOWLIST.includes(name.toLowerCase());
+}
+
+/**
+ * Hard boundary: throws if any active tool is outside the allowlist. Call this
+ * after the session's tool registry is fully assembled and before running, so a
+ * tool leaked in by defaults/discovery/extensions fails the launch loudly.
+ */
+export function assertRlmToolAllowlist(activeToolNames: readonly string[]): void {
+	const leaked = activeToolNames.filter(name => !isRlmToolAllowed(name));
+	if (leaked.length > 0) {
+		throw new Error(
+			`RLM tool boundary violation: non-allowlisted active tool(s) [${leaked.join(", ")}]. ` +
+				`RLM mode allows only: ${RLM_TOOL_ALLOWLIST.join(", ")}.`,
+		);
+	}
+}
+
+/** The research prompt text (exported for testing / prompt assembly). */
+export const RLM_RESEARCH_PROMPT: string = rlmResearchPrompt;
+
+/**
+ * Build the systemPrompt transform for createAgentSession: appends the research
+ * prompt, data context, and prior-notebook replay context to the default blocks.
+ */
+export function buildRlmSystemPrompt(
+	dataContext: RlmDataContext | null,
+	resumeContext?: string,
+): (defaultPrompt: string[]) => string[] {
+	return (defaultPrompt: string[]): string[] => {
+		const blocks = [...defaultPrompt, rlmResearchPrompt];
+		if (dataContext) {
+			blocks.push(`# Data context (from ${dataContext.path})\n\n${dataContext.content}`);
+		}
+		if (resumeContext && resumeContext.trim().length > 0) {
+			blocks.push(`# Prior notebook replay context\n\n${resumeContext}`);
+		}
+		return blocks;
+	};
+}

package/src/rlm/python-tool.ts

@@ -0,0 +1,68 @@
+/**
+ * RLM `python` tool: the model-facing research execution tool. Wraps the shared
+ * persistent Python kernel executor and records every call as a notebook cell.
+ */
+import type { AgentToolResult } from "@sayknow-cli/agent-core";
+import { type Static, z } from "@sayknow-cli/ai";
+import { executePython } from "../eval/py/executor";
+import { RLM_MANAGED_PYTHON_PACKAGES } from "../eval/py/runtime";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import type { RlmNotebookWriter } from "./notebook";
+import type { RlmCellResult } from "./types";
+
+export const RLM_PYTHON_TOOL_NAME = "python";
+
+export interface RlmPythonToolContext {
+	cwd: string;
+	sessionId: string;
+	artifactsDir: string;
+	notebook: RlmNotebookWriter;
+	managedWorkspaceVenv?: boolean;
+}
+
+const paramsSchema = z.object({
+	code: z
+		.string()
+		.describe("Python source to execute in the persistent research kernel. State persists across calls."),
+});
+
+export function createRlmPythonTool(rlm: RlmPythonToolContext): CustomTool<typeof paramsSchema> {
+	return {
+		name: RLM_PYTHON_TOOL_NAME,
+		label: "Python",
+		description:
+			"Execute Python in the persistent research kernel. Variables, imports, and loaded data persist across calls like notebook cells. Every call is recorded as a cell in the session notebook.",
+		parameters: paramsSchema,
+		strict: true,
+		concurrency: "exclusive",
+		async execute(
+			_toolCallId: string,
+			params: Static<typeof paramsSchema>,
+			_onUpdate,
+			_ctx,
+			signal?: AbortSignal,
+		): Promise<AgentToolResult> {
+			const result = await executePython(params.code, {
+				cwd: rlm.cwd,
+				kernelMode: "session",
+				sessionId: `rlm:${rlm.sessionId}`,
+				kernelOwnerId: `rlm:${rlm.sessionId}`,
+				artifactsDir: rlm.artifactsDir,
+				runtimeOptions: rlm.managedWorkspaceVenv
+					? { managedWorkspaceVenv: true, seedPackages: RLM_MANAGED_PYTHON_PACKAGES }
+					: undefined,
+				signal,
+			});
+			const cell: RlmCellResult = {
+				output: result.output,
+				exitCode: result.exitCode,
+				cancelled: result.cancelled,
+				truncated: result.truncated,
+				displayOutputs: result.displayOutputs,
+			};
+			await rlm.notebook.appendCode(params.code, cell);
+			const text = result.output.length > 0 ? result.output : "(no output)";
+			return { content: [{ type: "text", text }] };
+		},
+	};
+}

package/src/rlm/report.ts

@@ -0,0 +1,70 @@
+/**
+ * Deterministic RLM report synthesis: turns the accumulated notebook (plus an
+ * optional model-provided summary) into a Markdown research report.
+ */
+import type { NotebookCell, NotebookDocument } from "../edit/notebook";
+
+export interface RlmReportInput {
+	title: string;
+	summary?: string;
+	notebook: NotebookDocument;
+	dataPath?: string | null;
+	generatedAt?: string;
+	maxOutputChars?: number;
+}
+
+function cellText(value: string | string[] | undefined): string {
+	if (value === undefined) return "";
+	return Array.isArray(value) ? value.join("") : value;
+}
+
+function streamOutputText(cell: NotebookCell): string {
+	const outputs = Array.isArray(cell.outputs) ? cell.outputs : [];
+	const parts: string[] = [];
+	for (const out of outputs) {
+		if (out && typeof out === "object" && (out as Record<string, unknown>).output_type === "stream") {
+			parts.push(cellText((out as Record<string, unknown>).text as string | string[] | undefined));
+		}
+	}
+	return parts.join("");
+}
+
+export function synthesizeRlmReport(input: RlmReportInput): string {
+	const generatedAt = input.generatedAt ?? new Date().toISOString();
+	const maxOutput = input.maxOutputChars ?? 4000;
+	const codeCells = input.notebook.cells.filter(cell => cell.cell_type === "code");
+
+	const lines: string[] = [];
+	lines.push(`# ${input.title}`, "");
+	lines.push(`- Generated: ${generatedAt}`);
+	lines.push(`- Cells executed: ${codeCells.length}`);
+	if (input.dataPath) {
+		lines.push(`- Data context: ${input.dataPath}`);
+	}
+	lines.push("");
+
+	if (input.summary && input.summary.trim().length > 0) {
+		lines.push("## Summary", "", input.summary.trim(), "");
+	}
+
+	lines.push("## Notebook", "");
+	let codeIndex = 0;
+	for (const cell of input.notebook.cells) {
+		if (cell.cell_type === "markdown") {
+			const text = cellText(cell.source).trim();
+			if (text.length > 0) {
+				lines.push(text, "");
+			}
+		} else if (cell.cell_type === "code") {
+			codeIndex += 1;
+			lines.push(`### Cell ${codeIndex}`, "", "```python", cellText(cell.source).trimEnd(), "```", "");
+			const output = streamOutputText(cell).trimEnd();
+			if (output.length > 0) {
+				const shown = output.length > maxOutput ? `${output.slice(0, maxOutput)}\n... [truncated]` : output;
+				lines.push("```", shown, "```", "");
+			}
+		}
+	}
+
+	return `${lines.join("\n").trimEnd()}\n`;
+}

package/src/rlm/types.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared types for RLM (research) mode.
+ */
+import type { KernelDisplayOutput } from "../eval/py/kernel";
+
+export interface RlmArtifactPaths {
+	/** Absolute session directory: <cwd>/.skc/rlm/<sessionId>/ */
+	dir: string;
+	/** Absolute path to the live notebook.ipynb */
+	notebookPath: string;
+	/** Absolute path to the synthesized report.md */
+	reportPath: string;
+	/** Absolute path to the session metadata.json */
+	metadataPath: string;
+	/** Directory for the underlying SKC conversation session files. */
+	agentSessionDir: string;
+}
+
+/** Outcome of a single RLM python cell execution. */
+export interface RlmCellResult {
+	output: string;
+	exitCode: number | undefined;
+	cancelled: boolean;
+	truncated: boolean;
+	displayOutputs: KernelDisplayOutput[];
+}
+
+export interface RlmSessionMetadata {
+	sessionId: string;
+	createdAt: string;
+	cwd: string;
+	dataPath: string | null;
+	cellCount: number;
+	mode?: "interactive" | "autonomous";
+	resumedFrom?: string | null;
+	completedAt?: string | null;
+	finalSummary?: string | null;
+	minSuccessfulRuns?: number;
+	successfulRuns?: number;
+}

package/src/runtime/process-lifecycle.ts

@@ -0,0 +1,400 @@
+/**
+ * Shared runtime lifecycle foundation.
+ *
+ * Two minimal, deliberately small primitives that subsystem runtimes
+ * (DAP/LSP/MCP stdio, eval workers, etc.) adopt so spawned children and
+ * non-process resources cannot outlive their owner:
+ *
+ *   F1(a) `spawnOwnedProcess` — wraps `ptree.spawn` with explicit
+ *         process-group ownership, escalating (SIGTERM -> grace -> SIGKILL)
+ *         tree termination, bounded `awaitExit`, abort-listener cleanup on
+ *         settle, idempotent `dispose`, and a single postmortem hook that
+ *         reaps every still-live owned process group on fatal/normal shutdown.
+ *
+ *   F1(b) `registerResourceOwner` — a generic, idempotent postmortem adapter
+ *         for non-process resources (Bun Workers, VM contexts, timers,
+ *         sockets) built on the existing `postmortem.register` facility.
+ *
+ * Ownership is keyed to the *process group*, not the root process. A root that
+ * exits after backgrounding descendants (`sh -c "worker & exit 0"`) keeps the
+ * owner registered until the group is actually gone, so the descendant tree is
+ * still reaped by `dispose()`/postmortem.
+ *
+ * This module intentionally owns only these primitives. It does not migrate
+ * existing call sites; subsystem PRs adopt it incrementally.
+ *
+ * Note: `ptree.spawn` always pipes stdout/stderr. Adopters that expect output
+ * (DAP/LSP/MCP protocol servers) must consume `owner.child.stdout`; F1 does not
+ * drain it, so a chatty child whose stdout is never read can still block on a
+ * full pipe. That draining is the adopter's responsibility.
+ */
+import { logger, postmortem, ptree } from "@sayknow-cli/utils";
+
+const DEFAULT_GRACEFUL_MS = 2_000;
+// Hard cap for how long `dispose()` waits after SIGKILL before giving up so a
+// wedged, unkillable child can never block shutdown forever.
+const SIGKILL_REAP_CAP_MS = 2_000;
+// After the root process exits on its own, how long to wait for the process
+// group to drain before deregistering. Clean servers drain immediately; a root
+// that backgrounded descendants stays registered past this window.
+const ROOT_EXIT_DRAIN_MS = 250;
+
+const isPosix = process.platform !== "win32";
+
+const delay = (ms: number): Promise<void> =>
+	new Promise(resolve => {
+		const timer = setTimeout(resolve, Math.max(0, ms));
+		timer.unref?.();
+	});
+
+/** Poll `predicate` until it is true or `timeoutMs` elapses. Returns the final value. */
+async function pollUntil(predicate: () => boolean, timeoutMs: number, intervalMs = 20): Promise<boolean> {
+	if (predicate()) return true;
+	const deadline = Date.now() + Math.max(0, timeoutMs);
+	while (Date.now() < deadline) {
+		await delay(Math.min(intervalMs, Math.max(0, deadline - Date.now())));
+		if (predicate()) return true;
+	}
+	return predicate();
+}
+
+/** Whether a POSIX process group still has any member (zombies count as alive). */
+function groupAlive(pgid: number): boolean {
+	try {
+		process.kill(-pgid, 0);
+		return true;
+	} catch (err) {
+		// EPERM => the group exists but we cannot signal it; treat as alive.
+		return (err as NodeJS.ErrnoException).code === "EPERM";
+	}
+}
+
+/** Options for {@link spawnOwnedProcess}. */
+export interface SpawnOwnedOptions {
+	cwd?: string;
+	env?: Record<string, string | undefined>;
+	/** stdin mode passed through to the child. Defaults to `"ignore"`. */
+	stdin?: "pipe" | "ignore";
+	/** When aborted, the owned process tree is disposed (escalating kill). */
+	signal?: AbortSignal;
+	/** Grace period (ms) between SIGTERM and SIGKILL on dispose. Default 2000. */
+	gracefulMs?: number;
+	/**
+	 * Spawn the child as its own process-group leader so the whole descendant
+	 * tree can be signalled on dispose. Defaults to `true` on POSIX. Has no
+	 * effect on Windows, where teardown falls back to single-process kill.
+	 */
+	processGroup?: boolean;
+	/** Label used in diagnostics. */
+	name?: string;
+}
+
+/** Result of a bounded {@link OwnedProcess.awaitExit}. */
+export interface AwaitExitResult {
+	/** `true` when the process has exited; `false` when the timeout fired first. */
+	exited: boolean;
+	/** Exit code if known, else `null`. */
+	code: number | null;
+}
+
+/** A spawned child process owned by the runtime with guaranteed teardown. */
+export interface OwnedProcess {
+	readonly child: ptree.ChildProcess;
+	readonly pid: number | undefined;
+	/** Resolves/rejects when the root child exits (mirrors ptree's `exited`). */
+	readonly exited: Promise<number>;
+	/** `true` once `dispose()` has started. */
+	readonly disposed: boolean;
+	/**
+	 * Wait for the root child to exit, optionally bounded by `timeoutMs`. With no
+	 * timeout it resolves only when the child exits. Never rejects.
+	 */
+	awaitExit(opts?: { timeoutMs?: number }): Promise<AwaitExitResult>;
+	/**
+	 * Idempotently terminate the owned process *group*: SIGTERM the group, wait
+	 * `gracefulMs`, then SIGKILL, polling group liveness throughout. Removes the
+	 * abort listener and deregisters from the live-owner set only after teardown
+	 * has completed. Repeated/concurrent calls return the same in-flight promise.
+	 */
+	dispose(): Promise<void>;
+}
+
+const liveOwners = new Set<OwnedProcess>();
+let ownedPostmortemRegistered = false;
+
+function ensureOwnedPostmortem(): void {
+	if (ownedPostmortemRegistered) return;
+	ownedPostmortemRegistered = true;
+	postmortem.register("runtime:owned-processes", async () => {
+		await Promise.all([...liveOwners].map(owner => owner.dispose().catch(() => undefined)));
+	});
+}
+
+/**
+ * Spawn a child process owned by the runtime. The returned {@link OwnedProcess}
+ * is registered for postmortem cleanup and tears down its whole process group
+ * on dispose/abort.
+ */
+export function spawnOwnedProcess(cmd: string[], opts: SpawnOwnedOptions = {}): OwnedProcess {
+	const gracefulMs = opts.gracefulMs ?? DEFAULT_GRACEFUL_MS;
+	const useGroup = (opts.processGroup ?? true) && isPosix;
+
+	ensureOwnedPostmortem();
+
+	// We deliberately do NOT forward `opts.signal` to `ptree.spawn`: ptree's
+	// `attachSignal` only kills the single process, whereas owned teardown must
+	// signal the whole group. We wire our own abort listener below and remove it
+	// on settle so long-lived signals never accumulate listeners.
+	const child = ptree.spawn(cmd, {
+		cwd: opts.cwd,
+		env: opts.env,
+		stdin: opts.stdin ?? "ignore",
+		detached: useGroup,
+	});
+
+	// On POSIX with `detached`, the child is its own process-group leader, so the
+	// group id equals its pid. `undefined` => single-process (Windows/opt-out).
+	const pgid = useGroup ? child.pid : undefined;
+
+	let disposed = false;
+	let disposePromise: Promise<void> | undefined;
+	let deregistered = false;
+	// Terminal once teardown/reconciliation has confirmed the group is gone. A
+	// late dispose() must then be a true no-op and never re-probe a pgid the OS
+	// may have recycled into an unrelated group.
+	let terminated = false;
+	let onAbort: (() => void) | undefined;
+
+	const removeAbort = (): void => {
+		if (onAbort && opts.signal) {
+			opts.signal.removeEventListener("abort", onAbort);
+			onAbort = undefined;
+		}
+	};
+
+	const deregister = (): void => {
+		if (deregistered) return;
+		deregistered = true;
+		terminated = true;
+		liveOwners.delete(owner);
+		removeAbort();
+	};
+
+	const signalTree = (signal: NodeJS.Signals): void => {
+		const pid = child.pid;
+		if (pid === undefined) return;
+		if (pgid !== undefined) {
+			try {
+				// Negative pid signals the entire process group (child is leader).
+				process.kill(-pgid, signal);
+				return;
+			} catch {
+				// Group already gone; nothing to do.
+			}
+			return;
+		}
+		if (signal === "SIGKILL") {
+			try {
+				process.kill(pid, "SIGKILL");
+			} catch {
+				/* already gone */
+			}
+		} else {
+			// ptree's kill terminates the single process via the native handle.
+			child.kill();
+		}
+	};
+
+	const owner: OwnedProcess = {
+		child,
+		get pid() {
+			return child.pid;
+		},
+		get exited() {
+			return child.exited;
+		},
+		get disposed() {
+			return disposed;
+		},
+		async awaitExit({ timeoutMs }: { timeoutMs?: number } = {}): Promise<AwaitExitResult> {
+			const exitedResult = child.exited
+				.then(code => ({ exited: true as const, code: code as number | null }))
+				.catch(() => ({ exited: true as const, code: child.exitCode }));
+			if (timeoutMs === undefined) return exitedResult;
+			let timer: ReturnType<typeof setTimeout> | undefined;
+			const timeout = new Promise<AwaitExitResult>(resolve => {
+				timer = setTimeout(() => resolve({ exited: false, code: child.exitCode }), Math.max(0, timeoutMs));
+				timer.unref?.();
+			});
+			try {
+				return await Promise.race([exitedResult, timeout]);
+			} finally {
+				if (timer) clearTimeout(timer);
+			}
+		},
+		dispose(): Promise<void> {
+			// Already terminal (e.g. clean drain reconciled and deregistered):
+			// never re-probe the pgid; treat dispose as a settled no-op.
+			if (terminated) {
+				disposed = true;
+				if (!disposePromise) disposePromise = Promise.resolve();
+				return disposePromise;
+			}
+			if (disposePromise) return disposePromise;
+			disposed = true;
+			removeAbort();
+			disposePromise = (async () => {
+				try {
+					if (pgid !== undefined) {
+						// Group ownership: reap until the whole group is gone, even if
+						// the root has already exited (it may have backgrounded children).
+						if (!groupAlive(pgid)) return;
+						signalTree("SIGTERM");
+						if (await pollUntil(() => !groupAlive(pgid), gracefulMs)) return;
+						signalTree("SIGKILL");
+						if (!(await pollUntil(() => !groupAlive(pgid), SIGKILL_REAP_CAP_MS))) {
+							logger.warn("owned process group still alive after SIGKILL", {
+								name: opts.name,
+								pgid,
+							});
+						}
+						return;
+					}
+					// Single-process fallback (Windows / processGroup:false).
+					if (child.exitCode !== null) return;
+					signalTree("SIGTERM");
+					if ((await owner.awaitExit({ timeoutMs: gracefulMs })).exited) return;
+					signalTree("SIGKILL");
+					await owner.awaitExit({ timeoutMs: SIGKILL_REAP_CAP_MS });
+				} catch (err) {
+					logger.warn("owned process dispose failed", {
+						name: opts.name,
+						error: err instanceof Error ? err.message : String(err),
+					});
+				} finally {
+					// FIX: deregister only after teardown has completed so a postmortem
+					// firing mid-grace still sees the owner and awaits this dispose.
+					deregister();
+				}
+			})();
+			return disposePromise;
+		},
+	};
+
+	liveOwners.add(owner);
+
+	// When the root exits on its own (not via dispose), reconcile ownership by
+	// the *group*. After a short drain window: if the group is empty, deregister;
+	// if descendants are still alive, reap the owned group (no child outlives its
+	// owner). Either way the owner never lingers holding a stale pgid that the OS
+	// could later recycle and a stray dispose could mis-signal.
+	void child.exited
+		.catch(() => undefined)
+		.finally(() => {
+			if (disposed) return; // dispose() owns deregistration
+			if (pgid === undefined) {
+				deregister();
+				return;
+			}
+			void (async () => {
+				const drained = await pollUntil(() => !groupAlive(pgid), ROOT_EXIT_DRAIN_MS);
+				if (disposed) return;
+				if (drained) {
+					deregister();
+					return;
+				}
+				// Root exited but the owned group still has descendants: reap them.
+				// dispose() escalates SIGTERM->SIGKILL and deregisters in its finally.
+				await owner.dispose();
+			})();
+		});
+
+	if (opts.signal) {
+		if (opts.signal.aborted) {
+			void owner.dispose();
+		} else {
+			onAbort = () => void owner.dispose();
+			opts.signal.addEventListener("abort", onAbort, { once: true });
+		}
+	}
+
+	return owner;
+}
+
+/** Number of currently live owned processes. Exposed for leak assertions/tests. */
+export function liveOwnedProcessCount(): number {
+	return liveOwners.size;
+}
+
+/** Dispose every live owned process. For owner-scoped teardown and tests. */
+export async function disposeAllOwnedProcesses(): Promise<void> {
+	await Promise.all([...liveOwners].map(owner => owner.dispose().catch(() => undefined)));
+}
+
+// ── F1(b) generic resource owners ────────────────────────────────────────────
+
+type ResourceDisposer = () => void | Promise<void>;
+
+const resourceOwners = new Map<string, ResourceDisposer>();
+let resourcePostmortemRegistered = false;
+
+function ensureResourcePostmortem(): void {
+	if (resourcePostmortemRegistered) return;
+	resourcePostmortemRegistered = true;
+	// Postmortem isolates per-callback failures; swallow the aggregate here so
+	// shutdown continues, while direct callers of disposeAllResourceOwners still
+	// observe the AggregateError.
+	postmortem.register("runtime:resource-owners", () =>
+		disposeAllResourceOwners().catch(err => {
+			logger.warn("resource owner postmortem cleanup had failures", {
+				error: err instanceof Error ? err.message : String(err),
+			});
+		}),
+	);
+}
+
+/**
+ * Register a non-process resource for postmortem/fatal-exit cleanup.
+ *
+ * Idempotent by `name`: re-registering the same name replaces the prior
+ * disposer (last wins). Returns an unregister function that removes the owner
+ * only while it is still the active registration for that name.
+ */
+export function registerResourceOwner(name: string, disposer: ResourceDisposer): () => void {
+	resourceOwners.set(name, disposer);
+	ensureResourcePostmortem();
+	let unregistered = false;
+	return () => {
+		if (unregistered) return;
+		unregistered = true;
+		if (resourceOwners.get(name) === disposer) {
+			resourceOwners.delete(name);
+		}
+	};
+}
+
+/** Number of registered resource owners. Exposed for leak assertions/tests. */
+export function resourceOwnerCount(): number {
+	return resourceOwners.size;
+}
+
+/**
+ * Run and clear every registered resource disposer. Attempts all disposers even
+ * if some throw, then surfaces the failures as an `AggregateError` so callers
+ * can distinguish "all closed" from "a resource may still be alive".
+ */
+export async function disposeAllResourceOwners(): Promise<void> {
+	const disposers = [...resourceOwners.values()];
+	resourceOwners.clear();
+	const errors: unknown[] = [];
+	for (const disposer of disposers) {
+		try {
+			await disposer();
+		} catch (err) {
+			errors.push(err);
+		}
+	}
+	if (errors.length > 0) {
+		throw new AggregateError(errors, `${errors.length} resource disposer(s) failed during teardown`);
+	}
+}