@zenera/cli 1.1.23 → 1.1.25

package/dist/projects.d.ts

@@ -87,10 +87,5 @@ export declare function lastUsedAt(projectDir: string): string | undefined;
 export declare function dirSize(dir: string): number;
 /** True when a session's lock names a process that is still alive. */
 export declare function isBusy(sessionDir: string): boolean;
-/**
- * `kill(pid, 0)` sends no signal and only asks whether the process exists.
- * EPERM means it exists and belongs to someone else, which still counts.
- */
-export declare function alive(pid: number): boolean;
 export declare function projectName(dir: string): string;
 //# sourceMappingURL=projects.d.ts.map

package/dist/projects.js

@@ -1,4 +1,4 @@
-import { ASSETS_MOUNT, assetsDir, FILES_DIR, MEMORY_MOUNT, memoryDir, skillDirs, skillMounts, SKILLS_MOUNT, } from '@zenera/neo';
+import { ASSETS_MOUNT, assetsDir, FILES_DIR, MEMORY_MOUNT, memoryDir, pidAlive, skillDirs, skillMounts, SKILLS_MOUNT, } from '@zenera/neo';
 import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { paths, readJson, writeJson } from "./home.js";
@@ -290,26 +290,13 @@ export function isBusy(sessionDir) {
     const path = join(sessionDir, '.lock');
     try {
         const { pid } = JSON.parse(readFileSync(path, 'utf8'));
-        return typeof pid === 'number' && alive(pid);
+        return typeof pid === 'number' && pidAlive(pid);
     }
     catch {
         // Absent, unreadable or malformed: nothing is holding it.
         return false;
     }
 }
-/**
- * `kill(pid, 0)` sends no signal and only asks whether the process exists.
- * EPERM means it exists and belongs to someone else, which still counts.
- */
-export function alive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        return err.code === 'EPERM';
-    }
-}
 export function projectName(dir) {
     return basename(resolve(dir));
 }

package/dist/request.d.ts

@@ -0,0 +1,45 @@
+import { type Input } from '@zenera/neo';
+export interface RunRequest {
+    /** a registered name, or a directory — paths resolved against the file */
+    project?: string;
+    input: Input;
+    /** absolute */
+    workspace?: string;
+    /** absolute */
+    memory?: string;
+}
+export interface BatchItem {
+    /** names this item's directory under the batch dir; defaults to its index */
+    id: string;
+    index: number;
+    input: Input;
+    /** absolute; without one the item gets a directory of its own */
+    workspace?: string;
+}
+export interface BatchRequest {
+    items: BatchItem[];
+}
+/**
+ * `-` is stdin, and then there is no file to resolve paths against, so the cwd
+ * answers instead — the only place a piped request could have meant.
+ */
+export declare function readRequest(file: string, cwd: string, piped?: string): Promise<RunRequest>;
+/**
+ * `base` is the directory every relative path in the request is resolved
+ * against — the file's own, so a case travels with the images beside it.
+ */
+export declare function parseRequest(body: string, base: string, where: string): RunRequest;
+/** The batch file. `-` is stdin, and then the cwd is what paths mean. */
+export declare function readBatch(file: string, cwd: string, piped?: string): Promise<BatchRequest>;
+/**
+ * Everything refusable is refused here, before a single model is called: a
+ * batch that fails on item 80 has already spent seventy-nine runs finding out
+ * something its file could have been read for.
+ */
+export declare function parseBatch(body: string, base: string, where: string): BatchRequest;
+/**
+ * Canonical `ContentPart[]` out, whatever went in: the shorthands exist for
+ * whoever writes the file, and stop existing the moment it is read.
+ */
+export declare function toInput(raw: unknown, base: string, where: string): Input;
+//# sourceMappingURL=request.d.ts.map

package/dist/request.js

@@ -0,0 +1,300 @@
+import { media, text } from '@zenera/neo';
+import { readFileSync, statSync } from 'node:fs';
+import { dirname, extname, isAbsolute, resolve } from 'node:path';
+import { readStdin, usageError, warn } from "./term.js";
+/**
+ * Local media is read and inlined, so the state a run is resumed from carries
+ * the picture rather than a path that meant something on another machine. That
+ * also puts the bytes in `state.json`, rewritten at every checkpoint of every
+ * later turn — hence a ceiling, and a word of warning well before it.
+ */
+const MAX_MEDIA_BYTES = 20 * 1024 * 1024;
+const WARN_MEDIA_BYTES = 2 * 1024 * 1024;
+/** Enough to name what people actually attach; anything else says `mimeType`. */
+const MIME = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.bmp': 'image/bmp',
+    '.svg': 'image/svg+xml',
+    '.heic': 'image/heic',
+    '.avif': 'image/avif',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.m4a': 'audio/mp4',
+    '.flac': 'audio/flac',
+    '.aac': 'audio/aac',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mov': 'video/quicktime',
+    '.mkv': 'video/x-matroska',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.csv': 'text/csv',
+    '.json': 'application/json',
+    '.xml': 'application/xml',
+    '.html': 'text/html',
+    '.yaml': 'application/yaml',
+    '.yml': 'application/yaml',
+};
+const MEDIA_KEYS = ['image', 'audio', 'video', 'file'];
+// ---------------------------------------------------------------------------
+// Reading
+// ---------------------------------------------------------------------------
+/**
+ * `-` is stdin, and then there is no file to resolve paths against, so the cwd
+ * answers instead — the only place a piped request could have meant.
+ */
+export async function readRequest(file, cwd, piped) {
+    if (file === '-') {
+        const body = piped ?? (await readStdin());
+        if (body === undefined) {
+            throw usageError('--input - expects the request on stdin', 'pipe a JSON object in');
+        }
+        return parseRequest(body, cwd, '<stdin>');
+    }
+    const at = resolve(cwd, file);
+    let body;
+    try {
+        body = readFileSync(at, 'utf8');
+    }
+    catch {
+        throw usageError(`cannot read ${at}`);
+    }
+    return parseRequest(body, dirname(at), at);
+}
+/**
+ * `base` is the directory every relative path in the request is resolved
+ * against — the file's own, so a case travels with the images beside it.
+ */
+export function parseRequest(body, base, where) {
+    let raw;
+    try {
+        raw = JSON.parse(body);
+    }
+    catch (err) {
+        throw usageError(`${where}: ${err.message}`, 'the request must be JSON');
+    }
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw usageError(`${where}: expected a JSON object`, 'see: zen run --help');
+    }
+    if (raw.input === undefined) {
+        throw usageError(`${where}: no "input"`, 'a request has to say what to ask');
+    }
+    return {
+        project: project(raw.project, base, where),
+        input: toInput(raw.input, base, where),
+        workspace: path(raw.workspace, base, where, 'workspace'),
+        memory: path(raw.memory, base, where, 'memory'),
+    };
+}
+/** The batch file. `-` is stdin, and then the cwd is what paths mean. */
+export async function readBatch(file, cwd, piped) {
+    if (file === '-') {
+        const body = piped ?? (await readStdin());
+        if (body === undefined) {
+            throw usageError('--input - expects the batch on stdin', 'pipe a JSON object in');
+        }
+        return parseBatch(body, cwd, '<stdin>');
+    }
+    const at = resolve(cwd, file);
+    let body;
+    try {
+        body = readFileSync(at, 'utf8');
+    }
+    catch {
+        throw usageError(`cannot read ${at}`);
+    }
+    return parseBatch(body, dirname(at), at);
+}
+/**
+ * Everything refusable is refused here, before a single model is called: a
+ * batch that fails on item 80 has already spent seventy-nine runs finding out
+ * something its file could have been read for.
+ */
+export function parseBatch(body, base, where) {
+    let raw;
+    try {
+        raw = JSON.parse(body);
+    }
+    catch (err) {
+        throw usageError(`${where}: ${err.message}`, 'the batch must be JSON');
+    }
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw usageError(`${where}: expected a JSON object`, 'see: zen run batch --help');
+    }
+    for (const key of ['memory', 'workspace', 'project']) {
+        if (raw[key] !== undefined) {
+            throw usageError(`${where}: "${key}" is not part of a batch file`, `it applies to every item, so it is a flag: --${key}`);
+        }
+    }
+    if (!Array.isArray(raw.batch)) {
+        throw usageError(`${where}: no "batch" array`, 'a batch is a list of requests');
+    }
+    if (raw.batch.length === 0) {
+        throw usageError(`${where}: "batch" is empty`, 'there is nothing to run');
+    }
+    const items = raw.batch.map((item, index) => toItem(item, index, base, `${where}: batch`));
+    unique(items.map((i) => i.id), 'id', where);
+    unique(items.flatMap((i) => (i.workspace ? [i.workspace] : [])), 'workspace', where);
+    return { items };
+}
+function toItem(raw, index, base, where) {
+    const at = `${where}[${index}]`;
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw usageError(`${at}: expected an object`, 'see: zen run batch --help');
+    }
+    const obj = raw;
+    for (const key of ['memory', 'project']) {
+        if (obj[key] !== undefined) {
+            throw usageError(`${at}: "${key}" is not part of a batch item`, `every item shares one, so it is a flag: --${key}`);
+        }
+    }
+    if (obj.input === undefined) {
+        throw usageError(`${at}: no "input"`, 'an item has to say what to ask');
+    }
+    return {
+        id: id(obj.id, index, at),
+        index,
+        input: toInput(obj.input, base, at),
+        workspace: path(obj.workspace, base, at, 'workspace'),
+    };
+}
+/** An id names a directory, so it has to be one path segment and nothing else. */
+function id(value, index, at) {
+    if (value === undefined) {
+        return String(index);
+    }
+    if (typeof value !== 'string' || !value) {
+        throw usageError(`${at}: "id" must be a non-empty string`);
+    }
+    if (!/^[\w.-]+$/.test(value) || value === '.' || value === '..') {
+        throw usageError(`${at}: "${value}" cannot be an id`, 'it names a directory: letters, digits, dot, dash and underscore');
+    }
+    return value;
+}
+function unique(values, what, where) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            throw usageError(`${where}: two items share the ${what} "${value}"`, 'every item runs at the same time as the others; give each its own');
+        }
+        seen.add(value);
+    }
+}
+/**
+ * A registered name is not a path and must not be resolved into one; a name
+ * that looks like a path is one. `Projects.open` takes either.
+ */
+function project(value, base, where) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string' || !value) {
+        throw usageError(`${where}: "project" must be a name or a directory`);
+    }
+    return value.startsWith('.') || isAbsolute(value) ? resolve(base, value) : value;
+}
+function path(value, base, where, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string' || !value) {
+        throw usageError(`${where}: "${field}" must be a directory`);
+    }
+    return resolve(base, value);
+}
+// ---------------------------------------------------------------------------
+// Input
+// ---------------------------------------------------------------------------
+/**
+ * Canonical `ContentPart[]` out, whatever went in: the shorthands exist for
+ * whoever writes the file, and stop existing the moment it is read.
+ */
+export function toInput(raw, base, where) {
+    if (typeof raw === 'string') {
+        return raw;
+    }
+    if (!Array.isArray(raw)) {
+        throw usageError(`${where}: "input" must be a string or an array of parts`);
+    }
+    return raw.map((part, i) => toPart(part, base, `${where}: input[${i}]`));
+}
+function toPart(part, base, at) {
+    if (typeof part === 'string') {
+        return text(part);
+    }
+    if (part === null || typeof part !== 'object' || Array.isArray(part)) {
+        throw usageError(`${at}: expected a string or an object`);
+    }
+    const obj = part;
+    const mimeType = mime(obj.mimeType, at);
+    if (typeof obj.type === 'string') {
+        if (obj.type === 'text') {
+            return text(str(obj.text, at, 'text'));
+        }
+        if (MEDIA_KEYS.includes(obj.type)) {
+            const kind = obj.type;
+            return url(kind, str(obj.url, at, 'url'), mimeType, base, at);
+        }
+        throw usageError(`${at}: unknown part type "${obj.type}"`, `text, ${MEDIA_KEYS.join(', ')}`);
+    }
+    if (typeof obj.text === 'string') {
+        return text(obj.text);
+    }
+    for (const kind of MEDIA_KEYS) {
+        if (obj[kind] !== undefined) {
+            return url(kind, str(obj[kind], at, kind), mimeType, base, at);
+        }
+    }
+    throw usageError(`${at}: no text, ${MEDIA_KEYS.join(', ')} or type`, 'see: zen run --help');
+}
+/**
+ * A url the model can already fetch is left exactly as it is; anything else is
+ * a path on this machine, and a path is only a url once it carries its bytes.
+ */
+function url(kind, value, mimeType, base, at) {
+    if (/^(https?|data):/.test(value)) {
+        return media(kind, value, mimeType);
+    }
+    const file = resolve(base, value);
+    const type = mimeType ?? MIME[extname(file).toLowerCase()];
+    if (!type) {
+        throw usageError(`${at}: nothing known about "${extname(file) || value}"`, 'name the type with "mimeType"');
+    }
+    let size;
+    try {
+        size = statSync(file).size;
+    }
+    catch {
+        throw usageError(`${at}: cannot read ${file}`);
+    }
+    if (size > MAX_MEDIA_BYTES) {
+        throw usageError(`${at}: ${file} is ${Math.round(size / 1024 / 1024)} MB`, `inlined media lives in the run state — the limit is ${MAX_MEDIA_BYTES / 1024 / 1024} MB`);
+    }
+    if (size > WARN_MEDIA_BYTES) {
+        warn(`${file} is large; it is written into the session state on every later turn`);
+    }
+    const bytes = readFileSync(file);
+    return media(kind, `data:${type};base64,${bytes.toString('base64')}`, type);
+}
+function str(value, at, field) {
+    if (typeof value !== 'string' || !value) {
+        throw usageError(`${at}: "${field}" must be a non-empty string`);
+    }
+    return value;
+}
+function mime(value, at) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string' || !value) {
+        throw usageError(`${at}: "mimeType" must be a string`);
+    }
+    return value;
+}
+//# sourceMappingURL=request.js.map

package/dist/sandbox.d.ts

@@ -39,6 +39,8 @@ export interface SandboxInputs {
      * promise it does not keep.
      */
     env?: readonly string[];
+    /** `false` overrides every `persist:` in the config, the agents' included */
+    persist?: boolean;
 }
 export declare function buildSandbox(opts: SandboxInputs): SandboxSetup;
 /**

package/dist/sandbox.js

@@ -3,7 +3,7 @@ import { mkdirSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { resolveBuild } from "./image.js";
 import { credentials } from "./keys.js";
-import { ensurePodmanReady } from "./podman.js";
+import { assertLocks, ensurePodmanReady } from "./podman.js";
 import { warn } from "./term.js";
 // ---------------------------------------------------------------------------
 // The sandbox, as this CLI wires it
@@ -71,6 +71,7 @@ export function buildSandbox(opts) {
         ...(opts.config.sandbox ?? {}),
         ...((opts.image ?? build?.tag) ? { image: opts.image ?? build?.tag } : {}),
         ...(opts.keys === false ? { keys: false } : {}),
+        ...(opts.persist === false ? { persist: false } : {}),
     };
     const home = join(opts.session.data, 'sandbox', 'home');
     const mounts = [{ host: home, at: HOME }, ...(opts.mounts ?? [])];
@@ -81,18 +82,22 @@ export function buildSandbox(opts) {
     // Skills and assets are mounted read-only, and a python script run from a
     // read-only directory fails on writing its own `__pycache__` — a confusing
     // error about a file nobody asked for.
-    const extra = { HOME, PYTHONDONTWRITEBYTECODE: '1', ...(keys?.env ?? {}) };
+    // `ZENERA_AGENT` tells a `zen` run by `run_command` that no person is there.
+    const extra = { HOME, PYTHONDONTWRITEBYTECODE: '1', ZENERA_AGENT: '1', ...(keys?.env ?? {}) };
     const spec = toSpec(base, extra, secretsOf(keys?.secrets, opts.env));
     const agents = {};
     for (const agent of opts.config.agents) {
         if (agent.sandbox) {
             const merged = merge(base, agent.sandbox);
+            if (opts.persist === false) {
+                merged.persist = false;
+            }
             // An agent that opts out gets neither the variables nor the mount,
             // but the mount is on the pool and cannot be taken back per agent —
             // so the variable is what actually decides, and without it the file
             // sitting there is not a credential anything will look for.
             const own = merged.keys === false ? undefined : keys;
-            agents[agent.name] = toSpec(merged, { HOME, PYTHONDONTWRITEBYTECODE: '1', ...(own?.env ?? {}) }, own && secretsOf(own.secrets, opts.env));
+            agents[agent.name] = toSpec(merged, { HOME, PYTHONDONTWRITEBYTECODE: '1', ZENERA_AGENT: '1', ...(own?.env ?? {}) }, own && secretsOf(own.secrets, opts.env));
         }
     }
     const pool = new SandboxPool({
@@ -178,6 +183,12 @@ function toSpec(config, extra, secrets) {
 export function usesSandbox(project) {
     return project.agents.some((a) => a.tools.some((t) => t.group === SANDBOX_GROUP));
 }
+/**
+ * Images this process has already settled. A batch opens the same project
+ * dozens of times at once, and without this each one shells out to podman and
+ * the concurrent copies race each other to pull the very same image.
+ */
+const READY = new Set();
 /**
  * Asked before the first turn rather than at the first tool call, so a missing
  * container engine costs nothing instead of costing a round trip and half a
@@ -185,6 +196,9 @@ export function usesSandbox(project) {
  */
 export async function preflight(setup, yes) {
     mkdirSync(setup.home, { recursive: true });
+    if (READY.has(setup.image)) {
+        return;
+    }
     await ensurePodmanReady({
         image: setup.image,
         build: setup.build,
@@ -192,6 +206,9 @@ export async function preflight(setup, yes) {
         memory: setup.spec.memory,
         yes,
     });
+    // A resumed session restarts its own stopped container, which needs no lock.
+    await assertLocks(1, { reuses: setup.pool.for().name });
+    READY.add(setup.image);
 }
 /** Best-effort teardown: losing a container must never lose a run. */
 export async function teardown(pool) {

package/dist/scaffold.d.ts

@@ -1,3 +1,6 @@
+export declare const TEMPLATES: string;
+/** How to use the memory graph: a house rules file, landing under `agents/`. */
+export declare const MEMORY_RULES: string;
 /**
  * The project files that are ours rather than the project's.
  *
@@ -19,14 +22,19 @@ export declare const SHARED_RULES: readonly string[];
  * scaffold wrote, rather than a second definition of "this version".
  */
 export declare function ownVersion(): string;
+type Vars = Record<string, string>;
+export interface CopyOptions {
+    /** values for the `{{...}}` in any template under this tree */
+    vars?: Vars;
+    /** leave a file that is already there alone rather than replacing it */
+    keep?: boolean;
+}
 /**
- * Writes the editor's files under `dir`, replacing what is there. They are
- * ours: they say how the editor is to treat a directory the agents write into,
- * and they describe the file formats of the version of `zen` in hand, so the
- * current answer is the only one worth having and a stale one is worse than
- * none. Returns the relative paths written.
+ * Copies one template directory into `dir` at `rel`, depth first, sorted so the
+ * list it returns is the same on every machine. Only a `.tmpl` is read as text;
+ * everything else is copied byte for byte.
  */
-export declare function editorFiles(dir: string): string[];
+export declare function copyTree(from: string, dir: string, rel: string, opts: CopyOptions): string[];
 /**
  * Replaces every file in a project that nobody is meant to be maintaining:
  * `SHARED_RULES` in the project tree, and the editor tree whole. Returns the
@@ -83,4 +91,5 @@ export interface Scaffolded {
  * the first set under twice as many lines about the second.
  */
 export declare function scaffold(opts: ScaffoldOptions): Scaffolded;
+export {};
 //# sourceMappingURL=scaffold.d.ts.map

package/dist/scaffold.js

@@ -1,6 +1,7 @@
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'node:fs';
 import { dirname, join, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { editorFiles } from "./meta/editor.js";
 // ---------------------------------------------------------------------------
 // Scaffolding
 //
@@ -30,13 +31,13 @@ import { fileURLToPath } from 'node:url';
 // standing next to the files that implement it, which is the shape every
 // change to the project is then made in.
 // ---------------------------------------------------------------------------
-const TEMPLATES = fileURLToPath(new URL('../templates', import.meta.url));
+export const TEMPLATES = fileURLToPath(new URL('../templates', import.meta.url));
 /** The suffix on a file with `{{...}}` in it, dropped when the file lands. */
 const TEMPLATE = '.tmpl';
 /** How to use file tools: a house rules file, landing under `agents/`. */
 const FILE_RULES = join('agents', 'files-instructions.md');
 /** How to use the memory graph: a house rules file, landing under `agents/`. */
-const MEMORY_RULES = join('agents', 'memory-instructions.md');
+export const MEMORY_RULES = join('agents', 'memory-instructions.md');
 /** How tools are called: the same, and equally not the project's to maintain. */
 const TOOL_RULES = join('agents', 'tools-instructions.md');
 /** How forking behaves: the same again, reaching only agents that declare `fork:`. */
@@ -54,8 +55,6 @@ const FORK_RULES = join('agents', 'fork-instructions.md');
  * own beside them.
  */
 export const SHARED_RULES = [FILE_RULES, FORK_RULES, MEMORY_RULES, TOOL_RULES];
-/** The same bytes, kept in the `zen-memory` skill to restore or diff against. */
-const MEMORY_REFERENCE = join('.github', 'skills', 'zen-memory', 'references', 'memory-instructions.md');
 /**
  * This `zen`'s own version, which the scaffold pins the sandbox's tools to.
  * The publishable packages move in lockstep, so one number covers them all.
@@ -149,7 +148,7 @@ function target(name) {
  * list it returns is the same on every machine. Only a `.tmpl` is read as text;
  * everything else is copied byte for byte.
  */
-function copyTree(from, dir, rel, opts) {
+export function copyTree(from, dir, rel, opts) {
     const written = [];
     mkdirSync(join(dir, rel), { recursive: true });
     const entries = readdirSync(from, { withFileTypes: true });
@@ -169,67 +168,13 @@ function copyTree(from, dir, rel, opts) {
             : readFileSync(source);
         writeFileSync(join(dir, child), body);
         // The bytes are copied, not the file, so a script arrives unrunnable.
-        if (child.endsWith('.sh')) {
+        if (child.endsWith('.sh') || child.endsWith('.mjs')) {
             chmodSync(join(dir, child), 0o755);
         }
         written.push(child);
     }
     return written;
 }
-// ---------------------------------------------------------------------------
-// Telling the editor which instructions are not for it
-//
-// The project's house rules are `agents/instructions.md`, deliberately not
-// `AGENTS.md`: every coding assistant now reads that name out of an open
-// folder and feeds it to itself as always-on instructions, and `zen open`
-// opens exactly this directory. A name nobody else claims means the two are
-// never confused, and `chat.useAgentsMdFile` no longer has to be switched off
-// to keep them apart.
-//
-// They sit under `agents/` because there is rarely only one of them. Anything
-// named `agents/<topic>-instructions.md` is read too, in filename order, so a
-// subject that is true for every agent but is about one capability — memory,
-// say — gets its own document instead of another section in a file that keeps
-// growing.
-//
-// `chat.useNestedAgentsMdFiles` is still written. It is already false by
-// default, but it is opt-in globally, and this is a directory the agent itself
-// writes into — someone who turned it on would otherwise have the editor pick
-// up whatever `AGENTS.md` a run happened to leave behind. It is a *restricted*
-// setting, so it applies only in a trusted workspace; that is the right way
-// round, since an untrusted folder is not one to run agents in either.
-//
-// `agents/instructions.md` addresses the *project's* agents. The editor's
-// assistant still needs a brief of its own, and what it needs to know is how
-// this kind of project is put together — the file formats, how a prompt is
-// written, when to add a skill rather than an agent. That is what the
-// `.github/` tree is: the standing brief, plus the prompt files and skills the
-// editor picks up from the same place.
-// ---------------------------------------------------------------------------
-/**
- * Writes the editor's files under `dir`, replacing what is there. They are
- * ours: they say how the editor is to treat a directory the agents write into,
- * and they describe the file formats of the version of `zen` in hand, so the
- * current answer is the only one worth having and a stale one is worse than
- * none. Returns the relative paths written.
- */
-export function editorFiles(dir) {
-    const written = copyTree(join(TEMPLATES, 'editor'), dir, '', {});
-    // The one file that belongs to both trees. It is a project file first —
-    // house rules reaching every agent that can see the graph — and it is
-    // written once and edited from then on, like every other project file. But
-    // a project whose copy drifted, or that deleted it and turned memory back
-    // on later, needs somewhere to get the current text from, and the editor
-    // tree is replaced on every `init` and `open`. Copying the same bytes into
-    // the skill's references is what makes `diff` between the two mean
-    // something, and what stops a second copy of these rules existing in the
-    // repository to fall out of step with the first.
-    const reference = join(dir, MEMORY_REFERENCE);
-    mkdirSync(dirname(reference), { recursive: true });
-    copyFileSync(join(TEMPLATES, 'project', MEMORY_RULES), reference);
-    written.push(MEMORY_REFERENCE);
-    return written;
-}
 /**
  * Replaces every file in a project that nobody is meant to be maintaining:
  * `SHARED_RULES` in the project tree, and the editor tree whole. Returns the