zigmini 0.9.0-beta.3 → 1.0.0-beta.2

package/host/omo-check/patches/omo-5.1.51-runtime-compat.patch

@@ -0,0 +1,31 @@
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js
+@@ -124,6 +124,7 @@ export async function generateSummaryMessage(options) {
+             headers,
+             extraBody: options.auth.extraBody,
+             env: options.auth.env,
++            cwd: options.context.cwd,
+             streamKind: "auxiliary",
+             onPayload: async (payload, model) => {
+                 const sanitized = model.api === "anthropic-messages" ? sanitizeAnthropicPayload(payload) : payload;
+--- a/@code-yeongyu/senpi/dist/modes/rpc/multi-session-host.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/multi-session-host.js
+@@ -235,7 +235,7 @@ async function runSocketHost(options, socketPath) {
+         onHandoffParked: async (ids) => {
+             await Promise.all(ids.map(async (id) => {
+                 await writer.flushConnection(id);
+-                connections.get(id)?.close();
++                await connections.get(id)?.finish();
+             }));
+         },
+     }, hostContext, {
+@@ -374,7 +374,8 @@ async function runSocketHost(options, socketPath) {
+                     process.stderr.write(`senpi rpc connection ${id} release failed: ${errorMessage(cause)}\n`);
+                 });
+             };
+-            connections.set(id, { id, sink, detach, close: () => socket.destroy() });
++            connections.set(id, { id, sink, detach, close: () => socket.destroy(),
++                finish: () => new Promise((resolve) => socket.end(resolve)) });
+             socket.once("close", detach);
+             socket.once("error", () => detach());
+         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigmini",
-  "version": "0.9.0-beta.3",
+  "version": "1.0.0-beta.2",
   "type": "module",
   "bin": {
     "zigmini": "bin/zigmini"
@@ -60,7 +60,8 @@
     "test:contract": "bun test test/contract",
     "test:all": "tsc --noEmit && bun test test/unit && bun test test/contract",
     "test:mutation": "bun scripts/mutation-run.ts",
-    "heavy": "bun host/heavy-slot.ts run"
+    "heavy": "bun host/heavy-slot.ts run",
+    "formal:check": "bun scripts/formal-check.ts"
   },
   "devDependencies": {
     "@types/bun": "^1.4.2",

package/src/agent/api.ts

@@ -0,0 +1,215 @@
+import { existsSync, lstatSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Hub } from "../hub.ts";
+import { MEDIA_MAX_BYTES } from "../media.ts";
+import type { Store } from "../store.ts";
+import { mergeAgentDefinition, parseAgentDefinition, AgentDefinitionError, serializeAgentDefinition, type AgentDefinition } from "./definition.ts";
+import { registryMetadata } from "./fields.ts";
+import { AgentFileError, AgentFileStore, unreadableAgent } from "./files.ts";
+
+class AgentApiError extends Error {
+	constructor(readonly status: number, readonly code: string) {
+		super(code);
+	}
+}
+
+function object(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function source(req: Request): Promise<string> {
+	const value: unknown = await req.json();
+	if (!object(value) || typeof value.source !== "string") throw new AgentApiError(400, "source_required");
+	return value.source;
+}
+
+/** Only metadata leaves list endpoints; definition text is returned by the detail endpoint. */
+export class AgentApi {
+	private readonly deleting = new Set<string>();
+
+	constructor(private readonly files: AgentFileStore, private readonly store: Store, private readonly hub: Hub) {}
+
+	private conversation(id: string, visible = true) {
+		const conv = this.store.listConversations(!visible).find((row) => row.agentId === id);
+		if (!conv) throw new AgentApiError(404, "agent_not_found");
+		return conv;
+	}
+
+	private summary(id: string, definition: AgentDefinition) {
+		const conv = this.conversation(id);
+		const merged = mergeAgentDefinition(definition, this.files.readDefaults());
+		const applied = this.store.eventsAfter(conv.id, this.store.lastSeq(conv.id, "session.rotated"))
+			.filter((event) => event.type === "agent.applied").at(-1)?.data;
+		const appliedSha = object(applied) && typeof applied.sha === "string" ? applied.sha : null;
+		return {
+			id, name: definition.fields.name, description: definition.fields.description, icon: definition.fields.icon ?? null,
+			convId: conv.id, definitionSha: merged.sha, stale: appliedSha !== null && appliedSha !== merged.sha,
+		};
+	}
+
+	/** The definition text, the merged result and the field registry the editor draws its widgets from. */
+	private detail(id: string) {
+		const definition = this.files.read(id);
+		return { ...this.summary(id, definition), source: serializeAgentDefinition(definition),
+			...mergeAgentDefinition(definition, this.files.readDefaults()), registry: registryMetadata() };
+	}
+
+	private defaults() {
+		return { source: this.files.readDefaults()?.source ?? "---\n{}\n---\n", registry: registryMetadata() };
+	}
+
+	private list() {
+		const visible = this.store.listConversations(false);
+		return this.files.list().filter(({ id }) => visible.some((conv) => conv.agentId === id))
+			.map(({ id, definition }) => this.summary(id, definition));
+	}
+
+	/** Reject links at every component, including dangling links and links within another agent. */
+	private path(parts: readonly string[]): string {
+		let path = this.files.root;
+		for (const part of parts) {
+			if (!part || part === "." || part === ".." || /[/\\\0]/.test(part)) throw new AgentApiError(400, "invalid_path");
+			path = join(path, part);
+			try {
+				if (lstatSync(path).isSymbolicLink()) throw new AgentApiError(400, "symlink_not_allowed");
+			} catch (error) {
+				if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+			}
+		}
+		return path;
+	}
+
+	private tree(id: string) {
+		const entries: { path: string; type: "file" | "directory"; size: number }[] = [];
+		const walk = (parts: readonly string[]) => {
+			for (const name of readdirSync(this.path([id, "knowledge", ...parts]))) {
+				const stat = lstatSync(this.path([id, "knowledge", ...parts, name]));
+				if (!stat.isFile() && !stat.isDirectory()) throw new AgentApiError(400, "unsupported_file");
+				entries.push({ path: [...parts, name].join("/"), type: stat.isDirectory() ? "directory" : "file", size: stat.isFile() ? stat.size : 0 });
+				if (stat.isDirectory()) walk([...parts, name]);
+			}
+		};
+		walk([]);
+		return entries;
+	}
+
+	private changed(id: string) {
+		const detail = this.detail(id);
+		this.hub.agentUpdated(this.summary(id, this.files.read(id)));
+		return Response.json(detail);
+	}
+
+	async handle(req: Request, trusted: boolean): Promise<Response> {
+		if (!trusted) return Response.json({ error: "forbidden" }, { status: 403 });
+		try {
+			const path = new URL(req.url).pathname;
+			if (path === "/api/agents") {
+				if (req.method === "GET") return Response.json(this.list());
+				if (req.method !== "POST") throw new AgentApiError(405, "method_not_allowed");
+				const id = this.files.create(await source(req));
+				const definition = this.files.read(id);
+				this.hub.createConversation(String(definition.fields.name), id);
+				return new Response((await this.changed(id)).body, { status: 201, headers: { "Content-Type": "application/json" } });
+			}
+			if (path === "/api/agents/defaults") {
+				if (req.method === "GET") return Response.json(this.defaults());
+				if (req.method !== "PUT") throw new AgentApiError(405, "method_not_allowed");
+				this.files.saveDefaults(await source(req));
+				for (const summary of this.list()) this.hub.agentUpdated(summary);
+				return Response.json(this.defaults());
+			}
+			if (path === "/api/agents/trash") {
+				if (req.method !== "GET") throw new AgentApiError(405, "method_not_allowed");
+				const trash = this.path([".trash"]);
+				return Response.json(!existsSync(trash) ? [] : readdirSync(trash).flatMap((entry) => {
+					try {
+						const definition = parseAgentDefinition(readFileSync(this.path([".trash", entry, "agent.md"]), "utf8"));
+						return [{ entry, name: definition.fields.name, description: definition.fields.description, icon: definition.fields.icon ?? null }];
+					} catch (error) {
+						if (unreadableAgent(error) || (error instanceof AgentApiError && error.code === "symlink_not_allowed")) return [];
+						throw error;
+					}
+				}));
+			}
+			const restore = /^\/api\/agents\/trash\/([^/]+)\/restore$/.exec(path);
+			if (restore?.[1]) {
+				if (req.method !== "POST") throw new AgentApiError(405, "method_not_allowed");
+				const entry = decodeURIComponent(restore[1]);
+				const id = /^([a-f0-9]{8})-/.exec(entry)?.[1];
+				if (!id) throw new AgentApiError(400, "invalid_trash_entry");
+				const conv = this.conversation(id, false);
+				this.files.restore(entry);
+				this.store.setConversationHidden(conv.id, false);
+				return this.changed(id);
+			}
+			const match = /^\/api\/agents\/([a-f0-9]{8})(?:\/(clone|delete|files|source))?$/.exec(path);
+			const id = match?.[1];
+			if (!id) throw new AgentApiError(404, "not_found");
+			this.conversation(id);
+			if (this.deleting.has(id)) throw new AgentApiError(409, "agent_busy");
+			const action = match?.[2];
+			if (!action && req.method === "GET") return Response.json(this.detail(id));
+			if (!action && req.method === "PUT") {
+				const value = await source(req);
+				this.conversation(id);
+				if (this.deleting.has(id)) throw new AgentApiError(409, "agent_busy");
+				this.files.save(id, value);
+				return this.changed(id);
+			}
+			if (action === "files" && req.method === "GET") return Response.json(this.tree(id));
+			if (action === "clone" && req.method === "POST") {
+				const cloned = this.files.clone(id);
+				this.hub.createConversation(String(this.files.read(cloned).fields.name), cloned);
+				return this.changed(cloned);
+			}
+			if (action === "delete" && req.method === "POST") {
+				const body: unknown = await req.json();
+				this.conversation(id);
+				if (!object(body) || body.name !== this.files.read(id).fields.name) throw new AgentApiError(400, "name_mismatch");
+				if (this.deleting.has(id)) throw new AgentApiError(409, "agent_busy");
+				this.deleting.add(id);
+				try {
+					const conv = this.conversation(id);
+					const entry = await this.hub.deleteAgentConversation(conv.id, () => this.files.trash(id));
+					this.hub.agentUpdated({ id, convId: conv.id, hidden: true });
+					return Response.json({ entry });
+				} finally {
+					this.deleting.delete(id);
+				}
+			}
+			if (action === "source" && req.method === "POST") {
+				const length = Number(req.headers.get("content-length"));
+				if (length > MEDIA_MAX_BYTES + 65536) throw new AgentApiError(413, "too_large");
+				const form = await req.formData();
+				const file = form.get("file");
+				if (!(file instanceof File) || file.size === 0) throw new AgentApiError(400, "missing_file");
+				if (file.size > MEDIA_MAX_BYTES) throw new AgentApiError(413, "too_large");
+				// Reject traversal rather than silently turning it into a different name.
+				if (!file.name || file.name.startsWith(".") || /[/\\\0]/.test(file.name)) throw new AgentApiError(400, "invalid_filename");
+				let name = "";
+				for (const character of file.name.replace(/[^\p{L}\p{N}._-]/gu, "_")) {
+					if (Buffer.byteLength(name + character) > 180) break;
+					name += character;
+				}
+				const bytes = new Uint8Array(await file.arrayBuffer());
+				this.conversation(id);
+				if (this.deleting.has(id)) throw new AgentApiError(409, "agent_busy");
+				writeFileSync(this.path([id, "knowledge", "source", name]), bytes, { flag: "wx" });
+				this.hub.agentUpdated(this.summary(id, this.files.read(id)));
+				return Response.json({ name, size: bytes.length }, { status: 201 });
+			}
+			throw new AgentApiError(405, "method_not_allowed");
+		} catch (error) {
+			if (error instanceof AgentApiError) return Response.json({ error: error.code }, { status: error.status });
+			if (error instanceof AgentDefinitionError) return Response.json({ error: "invalid_agent_definition", field: error.field }, { status: 400 });
+			if (error instanceof AgentFileError) return Response.json({ error: error.code }, { status: error.code === "exists" ? 409 : 400 });
+			if (error instanceof SyntaxError || error instanceof URIError || error instanceof TypeError) return Response.json({ error: "invalid_request" }, { status: 400 });
+			if (error instanceof Error && error.message === "agent_busy") return Response.json({ error: "agent_busy" }, { status: 409 });
+			if (error instanceof Error && "code" in error) {
+				if (error.code === "ENOENT") return Response.json({ error: "agent_not_found" }, { status: 404 });
+				if (error.code === "EEXIST") return Response.json({ error: "file_exists" }, { status: 409 });
+			}
+			throw error;
+		}
+	}
+}

package/src/agent/definition.ts

@@ -0,0 +1,177 @@
+import { YAML } from "bun";
+import { createHash } from "node:crypto";
+import { AGENT_FIELDS, type AgentField } from "./fields.ts";
+
+export const AGENT_MAX_BYTES = 32768;
+export const AGENT_SCHEMA = 1;
+export type DefinitionKind = "agent" | "defaults";
+export type FieldOrigin = "package" | "defaults" | "agent";
+export type DefinitionFields = Readonly<Record<string, unknown>>;
+
+export interface AgentDefinition {
+	readonly fields: DefinitionFields;
+	readonly body: string;
+	readonly kind: DefinitionKind;
+	/** Original source allows an untouched definition (including unknown YAML) to save byte for byte. */
+	readonly source?: string;
+}
+
+export interface MergedAgentDefinition {
+	readonly fields: DefinitionFields;
+	readonly body: string;
+	readonly defaultsBody: string;
+	readonly origins: Readonly<Record<string, FieldOrigin>>;
+	readonly sha: string;
+}
+
+export class AgentDefinitionError extends Error {
+	constructor(readonly field: string, message: string) {
+		super(`${field}: ${message}`);
+		this.name = "AgentDefinitionError";
+	}
+}
+
+function object(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function at(fields: DefinitionFields, path: string): unknown {
+	let value: unknown = fields;
+	for (const key of path.split(".")) {
+		if (!object(value) || !Object.hasOwn(value, key)) return undefined;
+		value = value[key];
+	}
+	return value;
+}
+
+function matches(value: unknown, type: AgentField["type"]): boolean {
+	switch (type) {
+		case "string": return typeof value === "string";
+		case "integer": return typeof value === "number" && Number.isSafeInteger(value);
+		case "boolean": return typeof value === "boolean";
+		case "object": return object(value);
+		case "strings": return Array.isArray(value) && value.every((item) => typeof item === "string");
+	}
+}
+
+/** Canonical JSON also rejects recursive YAML aliases and non-JSON scalars at the input boundary. */
+function canonical(value: unknown, ancestors = new Set<object>()): string {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "number" && Number.isFinite(value)) return JSON.stringify(value);
+	if (typeof value !== "object" || value === null || ancestors.has(value)) throw new AgentDefinitionError("frontmatter", "expected acyclic JSON-compatible YAML");
+	ancestors.add(value);
+	const result = Array.isArray(value)
+		? `[${value.map((item) => canonical(item, ancestors)).join(",")}]`
+		: `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(Reflect.get(value, key), ancestors)}`).join(",")}}`;
+	ancestors.delete(value);
+	return result;
+}
+
+export function validateAgentFields(fields: DefinitionFields, kind: DefinitionKind = "agent"): void {
+	canonical(fields);
+	for (const field of AGENT_FIELDS) {
+		const value = at(fields, field.name);
+		const present = value !== undefined;
+		if (field.forbidden && present) throw new AgentDefinitionError(field.name, "forbidden");
+		if (kind === "defaults" && field.required && present) throw new AgentDefinitionError(field.name, "not allowed in defaults");
+		if (kind === "agent" && field.required && !present) throw new AgentDefinitionError(field.name, "required");
+		if (present && !matches(value, field.type)) throw new AgentDefinitionError(field.name, `expected ${field.type}`);
+		if (field.required && typeof value === "string" && !value.trim()) throw new AgentDefinitionError(field.name, "required");
+	}
+	const description = fields.description;
+	if (typeof description === "string" && [...description].length > 120) throw new AgentDefinitionError("description", "maximum 120 characters");
+	const maxBytes = at(fields, "memory.maxBytes");
+	if (typeof maxBytes === "number" && (maxBytes < 0 || maxBytes > 32768)) throw new AgentDefinitionError("memory.maxBytes", "expected 0..32768");
+	const schema = fields.schema;
+	if (schema !== undefined && schema !== AGENT_SCHEMA) throw new AgentDefinitionError("schema", "unsupported version");
+}
+
+/** Read-time migration seam. A missing schema is the original v1 format; never mutates the caller's object. */
+export function migrateAgentFields(fields: DefinitionFields): DefinitionFields {
+	return { ...fields };
+}
+
+export function parseAgentDefinition(source: string, kind: DefinitionKind = "agent"): AgentDefinition {
+	if (Buffer.byteLength(source, "utf8") > AGENT_MAX_BYTES) throw new AgentDefinitionError("file", "maximum 32768 bytes");
+	const match = /^---\r?\n([\s\S]*?)^---[ \t]*(?:\r?\n|$)/m.exec(source);
+	if (!match || match.index !== 0) throw new AgentDefinitionError("frontmatter", "expected --- YAML frontmatter");
+	let parsed: unknown;
+	try {
+		parsed = YAML.parse(match[1] ?? "");
+	} catch (error) {
+		throw new AgentDefinitionError("frontmatter", error instanceof Error ? error.message : String(error));
+	}
+	if (parsed === null) parsed = {};
+	if (!object(parsed)) throw new AgentDefinitionError("frontmatter", "expected an object");
+	validateAgentFields(parsed, kind);
+	return { fields: migrateAgentFields(parsed), body: source.slice(match[0].length), kind, source };
+}
+
+export function serializeAgentDefinition(definition: AgentDefinition): string {
+	validateAgentFields(definition.fields, definition.kind);
+	let header = YAML.stringify(definition.fields, null, 2);
+	if (definition.source !== undefined) {
+		const original = parseAgentDefinition(definition.source, definition.kind);
+		if (canonical(original.fields) === canonical(definition.fields) && original.body === definition.body) return definition.source;
+		// Keep unchanged top-level YAML entries verbatim, including unknown fields, comments and scalar styles.
+		const frontmatter = /^---\r?\n([\s\S]*?)^---[ \t]*(?:\r?\n|$)/m.exec(definition.source)?.[1] ?? "";
+		const starts = [...frontmatter.matchAll(/^[^\s#].*$/gm)];
+		const entries = starts.map((start, index) => frontmatter.slice(start.index, starts[index + 1]?.index));
+		const retained = new Map<string, string>();
+		for (const entry of entries) {
+			const value: unknown = YAML.parse(entry);
+			if (!object(value)) continue;
+			// A flow-style root map can hold several fields in one entry; it cannot be reused per key.
+			if (Object.keys(value).length !== 1) continue;
+			for (const key of Object.keys(value)) {
+				if (Object.hasOwn(definition.fields, key) && canonical(value[key]) === canonical(definition.fields[key])) retained.set(key, entry);
+			}
+		}
+		header = Object.keys(definition.fields).map((key) => retained.get(key) ?? `${YAML.stringify({ [key]: definition.fields[key] }, null, 2).trimEnd()}\n`).join("");
+	}
+	const result = `---\n${header.trimEnd()}\n---\n${definition.body}`;
+	if (Buffer.byteLength(result, "utf8") > AGENT_MAX_BYTES) throw new AgentDefinitionError("file", "maximum 32768 bytes");
+	return result;
+}
+
+function set(fields: Record<string, unknown>, keys: readonly string[], value: unknown): void {
+	let target = fields;
+	for (const key of keys.slice(0, -1)) {
+		const child = target[key];
+		if (object(child)) target = child;
+		else {
+			const next: Record<string, unknown> = {};
+			Object.defineProperty(target, key, { value: next, enumerable: true, writable: true, configurable: true });
+			target = next;
+		}
+	}
+	const last = keys.at(-1);
+	if (last !== undefined) Object.defineProperty(target, last, { value, enumerable: true, writable: true, configurable: true });
+}
+
+export function mergeAgentDefinition(agent: AgentDefinition, defaults?: AgentDefinition): MergedAgentDefinition {
+	validateAgentFields(agent.fields);
+	if (defaults) validateAgentFields(defaults.fields, "defaults");
+	const fields: Record<string, unknown> = {};
+	const origins: Record<string, FieldOrigin> = {};
+	for (const field of AGENT_FIELDS) {
+		if (field.default !== undefined) set(fields, field.name.split("."), structuredClone(field.default));
+	}
+	const apply = (input: DefinitionFields, origin: FieldOrigin, prefix: readonly string[] = []): void => {
+		for (const [key, value] of Object.entries(input)) {
+			const path = [...prefix, key];
+			const name = path.join(".");
+			const field = AGENT_FIELDS.find((row) => row.name === name && row.name.split(".").length === path.length);
+			if (field) origins[name] = origin;
+			if (field?.merge === "keys" && object(value)) apply(value, origin, path);
+			else set(fields, path, structuredClone(value));
+		}
+	};
+	apply(structuredClone(fields), "package");
+	if (defaults) apply(defaults.fields, "defaults");
+	apply(agent.fields, "agent");
+	const defaultsBody = defaults?.body ?? "";
+	const body = [defaultsBody, agent.body].filter(Boolean).join("\n\n");
+	const sha = createHash("sha256").update(canonical({ fields, body })).digest("hex");
+	return { fields, body, defaultsBody, origins, sha };
+}

package/src/agent/fields.ts

@@ -0,0 +1,42 @@
+export interface AgentField {
+	readonly name: string;
+	readonly type: "string" | "integer" | "boolean" | "object" | "strings";
+	readonly default: unknown;
+	readonly required: boolean;
+	readonly merge: "replace" | "keys";
+	readonly applies: "gateway" | "extension";
+	readonly widget: "text" | "textarea" | "number" | "toggle" | "model" | "select" | "skills" | "group";
+	readonly forbidden: boolean;
+}
+
+/** The registry owns defaults, validation types and editor metadata. Undefined means no package override. */
+export const AGENT_FIELDS: readonly AgentField[] = [
+	{ name: "schema", type: "integer", default: 1, required: false, merge: "replace", applies: "gateway", widget: "number", forbidden: false },
+	{ name: "name", type: "string", default: undefined, required: true, merge: "replace", applies: "gateway", widget: "text", forbidden: false },
+	{ name: "description", type: "string", default: undefined, required: true, merge: "replace", applies: "gateway", widget: "textarea", forbidden: false },
+	{ name: "icon", type: "string", default: undefined, required: false, merge: "replace", applies: "gateway", widget: "text", forbidden: false },
+	{ name: "model", type: "object", default: undefined, required: false, merge: "keys", applies: "extension", widget: "model", forbidden: false },
+	{ name: "model.provider", type: "string", default: undefined, required: false, merge: "replace", applies: "extension", widget: "text", forbidden: false },
+	{ name: "model.modelId", type: "string", default: undefined, required: false, merge: "replace", applies: "extension", widget: "text", forbidden: false },
+	{ name: "thinking", type: "string", default: undefined, required: false, merge: "replace", applies: "extension", widget: "select", forbidden: false },
+	{ name: "skills", type: "strings", default: [], required: false, merge: "replace", applies: "extension", widget: "skills", forbidden: false },
+	{ name: "tools", type: "object", default: {}, required: false, merge: "keys", applies: "extension", widget: "group", forbidden: false },
+	{ name: "tools.web", type: "boolean", default: false, required: false, merge: "replace", applies: "extension", widget: "toggle", forbidden: false },
+	{ name: "tools.bash", type: "boolean", default: undefined, required: false, merge: "replace", applies: "extension", widget: "toggle", forbidden: true },
+	{ name: "tools.eval", type: "boolean", default: undefined, required: false, merge: "replace", applies: "extension", widget: "toggle", forbidden: true },
+	{ name: "notify", type: "boolean", default: false, required: false, merge: "replace", applies: "gateway", widget: "toggle", forbidden: false },
+	{ name: "rules", type: "object", default: {}, required: false, merge: "keys", applies: "extension", widget: "group", forbidden: false },
+	{ name: "rules.gateway", type: "boolean", default: true, required: false, merge: "replace", applies: "extension", widget: "toggle", forbidden: false },
+	{ name: "rules.install", type: "boolean", default: true, required: false, merge: "replace", applies: "extension", widget: "toggle", forbidden: false },
+	{ name: "memory", type: "object", default: {}, required: false, merge: "keys", applies: "extension", widget: "group", forbidden: false },
+	{ name: "memory.maxBytes", type: "integer", default: 8192, required: false, merge: "replace", applies: "extension", widget: "number", forbidden: false },
+];
+
+/**
+ * The registry rows as the agent API sends them with every definition answer (`registry` in GET /api/agents/:id and
+ * /api/agents/defaults). The web editor draws its widgets from these rows, so a new registry row needs no web change.
+ * Forbidden rows are sent marked, so the editor can refuse them before the gateway does.
+ */
+export function registryMetadata(rows: readonly AgentField[] = AGENT_FIELDS): AgentField[] {
+	return rows.map(({ name, type, default: value, required, merge, applies, widget, forbidden }) => ({ name, type, default: value, required, merge, applies, widget, forbidden }));
+}