agent-lyceum 0.21.2 → 0.23.0

package/dist/adapters/claude.d.ts

@@ -1,7 +1,12 @@
+import { type WritePolicy } from "../policy.js";
 import type { ResolvedAgent, ResolvedProject } from "../config.js";
 import type { ErrorKind } from "../schema.js";
 import type { Invocation, WakeInput } from "./types.js";
-export declare function buildClaudeSettings(project: ResolvedProject, agent: ResolvedAgent): Record<string, unknown>;
+/** `override`: a policy that replaces the agent's own; `cwd` is then the (scratch) directory the runtime starts in, in place of the repo. */
+export declare function buildClaudeSettings(project: ResolvedProject, agent: ResolvedAgent, override?: {
+    policy: WritePolicy;
+    cwd: string;
+}): Record<string, unknown>;
 export declare function buildClaudeInvocation(input: WakeInput): Invocation;
 /**
  * The text the rules read: the result message (only when it is an error message: pass `result` for an `is_error` run), stderr, and the HTTP status
@@ -19,6 +24,8 @@ interface ClaudeResult {
     session_id?: string;
     usage?: {
         output_tokens?: number;
+        cache_read_input_tokens?: number;
+        cache_creation_input_tokens?: number;
     };
     is_error?: boolean;
 }

package/dist/adapters/claude.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { repoDirFor, writePolicy } from "../policy.js";
+import { repoDirFor, scratchCwd, writePolicy } from "../policy.js";
 /** Claude Code path rules: `//abs/path` — a leading "/" plus the absolute path. */
 const rule = (tool, p) => `${tool}(/${p})`;
 function denyRules(p) {
@@ -17,10 +17,11 @@ function denyRules(p) {
         out.push(rule("Edit", `${p}/**`));
     return out;
 }
-export function buildClaudeSettings(project, agent) {
-    const pol = writePolicy(project, agent);
-    const ws = project.workspaces?.[agent.name];
-    const repo = repoDirFor(project, agent.name);
+/** `override`: a policy that replaces the agent's own; `cwd` is then the (scratch) directory the runtime starts in, in place of the repo. */
+export function buildClaudeSettings(project, agent, override) {
+    const pol = override?.policy ?? writePolicy(project, agent);
+    const ws = override ? undefined : project.workspaces?.[agent.name];
+    const repo = override?.cwd ?? repoDirFor(project, agent.name);
     const allow = ["Bash", "Read", "Glob", "Grep"];
     // Web tools are opt-in: `search` is the lighter one (snippets only), `fetch` also pulls whole pages into the agent's context.
     if (agent.allowWeb === "search" || agent.allowWeb === "fetch")
@@ -41,7 +42,7 @@ export function buildClaudeSettings(project, agent) {
             enabled: true,
             allowUnsandboxedCommands: false,
             filesystem: {
-                allowWrite: [ws?.root ?? project.dir, ...pol.allowDirs, ...pol.allowFiles],
+                allowWrite: [override?.cwd ?? ws?.root ?? project.dir, ...pol.allowDirs, ...pol.allowFiles],
                 denyWrite: pol.deny,
             },
         },
@@ -52,10 +53,13 @@ export function buildClaudeInvocation(input) {
     fs.mkdirSync(workDir, { recursive: true });
     const settingsFile = path.join(workDir, "claude-settings.json");
     const systemFile = path.join(workDir, "system-prompt.md");
-    fs.writeFileSync(settingsFile, JSON.stringify(buildClaudeSettings(project, agent), null, 2));
+    const repo = input.policy ? scratchCwd(workDir) : repoDirFor(project, agent.name);
+    const scope = input.policy ? { policy: input.policy, cwd: repo } : undefined;
+    if (scope)
+        fs.mkdirSync(repo, { recursive: true });
+    fs.writeFileSync(settingsFile, JSON.stringify(buildClaudeSettings(project, agent, scope), null, 2));
     fs.writeFileSync(systemFile, input.systemPrompt);
-    const pol = writePolicy(project, agent);
-    const repo = repoDirFor(project, agent.name);
+    const pol = input.policy ?? writePolicy(project, agent);
     const addDirs = [...pol.allowDirs, ...pol.readDirs, ...pol.allowFiles.map((f) => path.dirname(f))].filter((d) => !(d === repo || d.startsWith(repo + path.sep)));
     const args = [
         "-p",
@@ -133,6 +137,8 @@ function interpretClaude(j, stdout, stderr, code) {
         text: String(j.result ?? ""),
         sessionId: j.session_id,
         outputTokens: j.usage?.output_tokens,
+        cacheReadTokens: j.usage?.cache_read_input_tokens,
+        cacheWriteTokens: j.usage?.cache_creation_input_tokens,
         error: ok ? undefined : String(j.result ?? stderr).slice(0, 500),
         kind: ok ? undefined : classifyClaudeError({ code, stdout, stderr, result: j.is_error && j.result !== undefined ? String(j.result) : undefined }),
     };

package/dist/adapters/codex.js

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import { repoDirFor, writePolicy } from "../policy.js";
+import { repoDirFor, scratchCwd, writePolicy } from "../policy.js";
 export function codexWritableRoots(input) {
-    const pol = writePolicy(input.project, input.agent);
-    const work = repoDirFor(input.project, input.agent.name);
+    const pol = input.policy ?? writePolicy(input.project, input.agent);
+    const work = input.policy ? scratchCwd(input.workDir) : repoDirFor(input.project, input.agent.name);
     const roots = [...pol.allowDirs, ...pol.allowFiles.map((f) => path.dirname(f))].filter((d) => !(d === work || d.startsWith(work + path.sep)));
     return [...new Set(roots)];
 }
@@ -52,8 +52,10 @@ export function codexOutputTokens(jsonl) {
 const CODEX_WEB_SEARCH = { none: "disabled", search: "cached", fetch: "live" };
 export function buildCodexInvocation(input) {
     const { project, agent, workDir } = input;
-    const repo = repoDirFor(project, agent.name);
+    const repo = input.policy ? scratchCwd(workDir) : repoDirFor(project, agent.name);
     fs.mkdirSync(workDir, { recursive: true });
+    if (input.policy)
+        fs.mkdirSync(repo, { recursive: true });
     const lastFile = path.join(workDir, "codex-last-message.txt");
     const roots = codexWritableRoots(input);
     const common = [

package/dist/adapters/types.d.ts

@@ -1,5 +1,6 @@
 import type { ErrorKind } from "../schema.js";
 import type { ResolvedAgent, ResolvedProject } from "../config.js";
+import type { WritePolicy } from "../policy.js";
 import type { AgentWorkspace } from "../worktree.js";
 export interface WakeInput {
     project: ResolvedProject;
@@ -16,12 +17,20 @@ export interface WakeInput {
     signal?: AbortSignal;
     /** Where the full stdout/stderr of this invocation are written. */
     logDir?: string;
+    /**
+     * Replaces the agent's normal write policy (memory tidy: only the dirs being tidied). The repo is then not writable
+     * either: the runtime starts in an empty scratch dir inside `workDir` and may only read the repo.
+     */
+    policy?: WritePolicy;
 }
 export interface WakeResult {
     ok: boolean;
     text: string;
     sessionId?: string;
     outputTokens?: number;
+    /** Prompt-cache usage (claude only): input tokens read from / written to the cache. */
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
     exitCode: number | null;
     timedOut: boolean;
     error?: string;
@@ -35,6 +44,8 @@ export type Parsed = {
     text: string;
     sessionId?: string;
     outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
     error?: string;
     /** Set on failure only; `unknown` when no rule recognizes the output. */
     kind?: ErrorKind;

package/dist/cli.js

@@ -693,7 +693,11 @@ program
                     console.log(`  restored  ${f}`);
                 for (const s of r.skipped)
                     console.log(`  skipped   ${s.rel}: ${s.reason}`);
-                if (!r.restored.length && !r.skipped.length)
+                for (const f of r.records?.restored ?? [])
+                    console.log(`  restored  records/${f}`);
+                for (const k of r.records?.skipped ?? [])
+                    console.log(`  skipped   records/${k.rel}: ${k.reason}`);
+                if (!r.restored.length && !r.skipped.length && !r.records?.restored.length && !r.records?.skipped.length)
                     console.log(`Archive ${opts.undo} holds no files to restore.`);
             }
             finally {
@@ -728,11 +732,11 @@ program
             console.log(`No agent has ${layer} memory configured. ${layer === "project" ? "The template gives agents global memory only: set `memory.project` for an agent in project.yaml (or tidy global memory with --layer global)." : "Set `memory.global` for an agent."}`);
         for (const r of results) {
             if (r.status === "tidied")
-                console.log(`  ${r.agent} (${r.layer}): tidied. Archive: ${path.join(r.dir, ".archive", r.archive ?? "")} — undo with: agent-lyceum tidy --undo ${r.archive} -p ${pr.name} --agent ${r.agent}${r.layer === "global" ? " --layer global" : ""}`);
+                console.log(`  ${r.agent} (${r.layer}): tidied. Archive: ${path.join(r.dir, ".archive", r.archive ?? "")}${r.recordsDir && r.recordsDir !== r.dir ? `, records: ${path.join(r.recordsDir, ".archive", r.archive ?? "")}` : ""} — undo with: agent-lyceum tidy --undo ${r.archive} -p ${pr.name} --agent ${r.agent}${r.layer === "global" ? " --layer global" : ""}`);
             else if (r.status === "skipped")
                 console.log(`  ${r.agent} (${r.layer}): skipped — ${r.problems.join("; ")}`);
             else if (r.status === "failed") {
-                console.error(`  ${r.agent} (${r.layer}): FAILED, memory restored to how it was`);
+                console.error(`  ${r.agent} (${r.layer}): FAILED, ${r.recordsDir === r.dir ? "project records" : r.recordsDir ? "memory and project records" : "memory"} restored to how it was`);
                 for (const p of r.problems)
                     console.error(`    - ${p}`);
             }

package/dist/doctor.js

@@ -3,6 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { findOnPath } from "./fs-util.js";
 import { tidyAdvice } from "./memory-tidy.js";
+import { listRecords, RECORD_KINDS } from "./records.js";
 import { listRunLocks, listUnreadableRunLocks, lockHolderAlive } from "./project-lock.js";
 import { runInvocation } from "./process-runner.js";
 import { validateProject } from "./validate.js";
@@ -169,6 +170,17 @@ export async function diagnoseProject(project, opts = {}) {
     }
     for (const a of tidyAdvice(project))
         checks.push({ level: "info", subject: "memory", message: `${a.agent}: ${a.reason}. Consider: agent-lyceum tidy -p ${project.name} --agent ${a.agent} (doctor only suggests; it never tidies).` });
+    for (const kind of RECORD_KINDS) {
+        const recs = listRecords(project, kind);
+        const ids = new Set(recs.map((r) => r.id));
+        for (const r of recs) {
+            if (r.invalid)
+                checks.push({ level: "warn", subject: "records", message: `${r.file}: ${r.invalid}` });
+            for (const s of r.supersedes)
+                if (!ids.has(s))
+                    checks.push({ level: "warn", subject: "records", message: `${r.file}: supersedes "${s}", but no ${kind} entry has that id.` });
+        }
+    }
     const runtimes = await probeProjectRuntimes(project, opts, true);
     checks.push(...judgeRuntimes(project, runtimes));
     checks.push({ level: "info", subject: "login", message: "Login status is unknown: agent-lyceum does not read credentials, and the CLIs offer no read-only login check it can rely on." });

package/dist/format-rejections.d.ts

@@ -0,0 +1,6 @@
+/** How many times one sender's mail (same type and subject) is sent back for missing sections before it is delivered with a warning instead. */
+export declare const MAX_FORMAT_REJECTIONS = 2;
+export declare function formatRejectionKey(from: string, type: string, subject: string): string;
+export declare function formatRejections(runDir: string, key: string): number;
+/** Record one more rejection for `key` and return the new count. */
+export declare function countFormatRejection(runDir: string, key: string): number;

package/dist/format-rejections.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import path from "node:path";
+import { atomicWrite } from "./fs-util.js";
+/** How many times one sender's mail (same type and subject) is sent back for missing sections before it is delivered with a warning instead. */
+export const MAX_FORMAT_REJECTIONS = 2;
+const FILE = "format-rejections.json";
+export function formatRejectionKey(from, type, subject) {
+    return `${from}|${type}|${subject.trim().toLowerCase()}`;
+}
+function load(runDir) {
+    try {
+        const data = JSON.parse(fs.readFileSync(path.join(runDir, FILE), "utf8"));
+        return data && typeof data === "object" && !Array.isArray(data) ? data : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function formatRejections(runDir, key) {
+    return load(runDir)[key] ?? 0;
+}
+/** Record one more rejection for `key` and return the new count. */
+export function countFormatRejection(runDir, key) {
+    const all = load(runDir);
+    const n = (all[key] ?? 0) + 1;
+    all[key] = n;
+    atomicWrite(path.join(runDir, FILE), `${JSON.stringify(all, null, 2)}\n`);
+    return n;
+}

package/dist/fs-util.d.ts

@@ -10,3 +10,8 @@ export declare function readFileCapped(file: string, limit: number): {
     text: string;
     truncated: boolean;
 } | undefined;
+/**
+ * The bytes of a regular file, opened without following a symlink and without blocking (a FIFO opens at once and fails the
+ * fstat check). undefined for anything else or on any error: never throws, never hangs.
+ */
+export declare function readRegularFileNoFollow(file: string): Buffer | undefined;

package/dist/fs-util.js

@@ -58,3 +58,27 @@ export function readFileCapped(file, limit) {
         }
     }
 }
+/**
+ * The bytes of a regular file, opened without following a symlink and without blocking (a FIFO opens at once and fails the
+ * fstat check). undefined for anything else or on any error: never throws, never hangs.
+ */
+export function readRegularFileNoFollow(file) {
+    let fd;
+    try {
+        fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0) | (fs.constants.O_NONBLOCK ?? 0));
+        if (!fs.fstatSync(fd).isFile())
+            return undefined;
+        return fs.readFileSync(fd);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+        }
+    }
+}

package/dist/guard.d.ts

@@ -17,6 +17,8 @@ export declare const MAX_KEEP_BYTES: number;
 export declare class ProtectedGuard {
     private project;
     private baseline;
+    /** Regular files of the records tree (including `.archive/`); only the lead may change them. */
+    private records;
     constructor(project: ResolvedProject);
     /**
      * Take the current files as the baseline. Called right before a batch is woken, so only what changes while it runs is
@@ -30,4 +32,10 @@ export declare class ProtectedGuard {
     private keep;
     /** Compare against the baseline after `running` agents finished; revert unauthorized changes. */
     check(running: ResolvedAgent[]): Violation[];
+    private checkRecords;
+    /**
+     * Make every directory from the records root down to `dir` a real directory. A symlink or file standing in for one is an
+     * unauthorized change: unlink it (never follow it), recreate the directory and report it. False when `dir` is not safe to write into.
+     */
+    private realDirs;
 }

package/dist/guard.js

@@ -1,7 +1,8 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { commonFile, mayEditProtected, repoInstructionFiles, sharedIndex } from "./policy.js";
+import { readRegularFileNoFollow } from "./fs-util.js";
+import { mayEditProtected, recordsDir, repoInstructionFiles, sharedContextFiles, sharedIndex } from "./policy.js";
 export const MAX_KEEP_BYTES = 1024 * 1024;
 function safeName(file) {
     return file.replace(/[\\/:]/g, "_").replace(/^_+/, "");
@@ -13,6 +14,8 @@ function safeName(file) {
 export class ProtectedGuard {
     project;
     baseline = new Map();
+    /** Regular files of the records tree (including `.archive/`); only the lead may change them. */
+    records = new Map();
     constructor(project) {
         this.project = project;
         this.rebase();
@@ -24,12 +27,14 @@ export class ProtectedGuard {
     rebase() {
         for (const f of ProtectedGuard.protectedFiles(this.project))
             this.baseline.set(f, read(f));
+        this.records = readTree(recordsDir(this.project));
     }
     static protectedFiles(project) {
         const files = new Set();
         for (const a of Object.values(project.agents))
             files.add(a.agentMd);
-        files.add(commonFile(project));
+        for (const f of sharedContextFiles(project))
+            files.add(f);
         for (const f of repoInstructionFiles(project))
             files.add(f);
         const handoff = sharedIndex(project);
@@ -85,8 +90,126 @@ export class ProtectedGuard {
                 violations.push({ file, action: "restored", suspects: running.map((a) => a.name), ...kept });
             }
         }
+        this.checkRecords(running, violations);
         return violations;
     }
+    checkRecords(running, violations) {
+        const root = recordsDir(this.project);
+        // Never write through a symlinked parent of the records tree: skip its protection for this batch.
+        if (isLink(path.dirname(root)) || isLink(path.dirname(path.dirname(root))))
+            return;
+        const now = readTree(root);
+        const lead = running.some((a) => a.name === this.project.lead);
+        const suspects = running.map((a) => a.name);
+        const fixedDirs = new Set();
+        for (const file of new Set([...this.records.keys(), ...now.keys()])) {
+            const before = this.records.get(file) ?? null;
+            const cur = now.get(file) ?? null;
+            if (same(before, cur))
+                continue;
+            if (lead)
+                continue;
+            const kept = this.keep(file, cur);
+            if (before === null) {
+                if (!insideRoot(root, path.dirname(file)))
+                    continue;
+                fs.rmSync(file, { force: true });
+                violations.push({ file, action: "removed", suspects, ...kept });
+            }
+            else {
+                if (!this.realDirs(root, path.dirname(file), fixedDirs, suspects, violations))
+                    continue;
+                fs.rmSync(file, { recursive: true, force: true });
+                fs.writeFileSync(file, before);
+                violations.push({ file, action: "restored", suspects, ...kept });
+            }
+        }
+        if (lead)
+            this.records = now;
+    }
+    /**
+     * Make every directory from the records root down to `dir` a real directory. A symlink or file standing in for one is an
+     * unauthorized change: unlink it (never follow it), recreate the directory and report it. False when `dir` is not safe to write into.
+     */
+    realDirs(root, dir, done, suspects, violations) {
+        const rel = path.relative(root, dir);
+        if (rel.startsWith("..") || path.isAbsolute(rel))
+            return false;
+        let cur = root;
+        for (const part of ["", ...(rel ? rel.split(path.sep) : [])]) {
+            cur = part ? path.join(cur, part) : cur;
+            let st;
+            try {
+                st = fs.lstatSync(cur);
+            }
+            catch { }
+            if (st?.isDirectory())
+                continue;
+            if (st) {
+                fs.rmSync(cur, { force: true });
+                if (!done.has(cur))
+                    violations.push({ file: cur, action: "removed", suspects, ...this.keep(cur, null) });
+                done.add(cur);
+            }
+            fs.mkdirSync(cur, { recursive: true });
+        }
+        return insideRoot(root, dir);
+    }
+}
+function isLink(p) {
+    try {
+        return fs.lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function insideRoot(root, dir) {
+    try {
+        const r = path.relative(fs.realpathSync(root), fs.realpathSync(dir));
+        return !r.startsWith("..") && !path.isAbsolute(r);
+    }
+    catch {
+        return false;
+    }
+}
+/** Regular files under `dir`, recursively; symlinks and special files are not followed or read. */
+function readTree(dir) {
+    const out = new Map();
+    try {
+        if (!fs.lstatSync(dir).isDirectory())
+            return out; // a symlinked root is never walked
+    }
+    catch {
+        return out;
+    }
+    const walk = (d) => {
+        let names;
+        try {
+            names = fs.readdirSync(d);
+        }
+        catch {
+            return;
+        }
+        for (const n of names) {
+            const f = path.join(d, n);
+            try {
+                const st = fs.lstatSync(f);
+                if (st.isDirectory())
+                    walk(f);
+                else if (st.isFile()) {
+                    const buf = readRegularFileNoFollow(f);
+                    if (buf)
+                        out.set(f, buf);
+                }
+            }
+            catch {
+                // vanished while scanning
+            }
+        }
+    };
+    walk(dir);
+    return out;
 }
 function read(file) {
     try {

package/dist/mailbox.js

@@ -4,8 +4,10 @@ import path from "node:path";
 import YAML from "yaml";
 import { formatWarning, missingSections, parseSteps } from "./format.js";
 import { atomicWrite } from "./fs-util.js";
+import { countFormatRejection, formatRejectionKey, formatRejections, MAX_FORMAT_REJECTIONS } from "./format-rejections.js";
 import { deterministicId, fault, RouteJournal, sourceIdOf } from "./message-store.js";
 import { inboxDir, outboxDir, sharedDir } from "./policy.js";
+import { activeRecordsBytes, RECORD_KINDS, RECORDS_BUDGET } from "./records.js";
 import { must } from "./assert.js";
 export { atomicWrite };
 export const MESSAGE_TYPES = ["task", "reply", "failure", "done", "ask"];
@@ -258,6 +260,11 @@ export function routeOutboxes(project) {
                     reject(`only the lead ("${project.lead}") may send a "done" message.`);
                     continue;
                 }
+                const over = RECORD_KINDS.map((k) => ({ k, n: activeRecordsBytes(project, k) })).filter((x) => x.n > RECORDS_BUDGET);
+                if (over.length) {
+                    reject(`${over.map((x) => `records/${x.k} hold ${x.n} bytes of active entries`).join(" and ")}; the budget is ${RECORDS_BUDGET} bytes (6 KB) per kind. Merge entries, or mark obsolete ones "status: superseded" (or name them in a newer entry's "supersedes"), then send "done" again.`);
+                    continue;
+                }
                 res.done = { from: sender.name, subject, body: parsed.body, file, meta: d };
                 const ds = parseSteps(parsed.body);
                 if (ds.length)
@@ -279,6 +286,15 @@ export function routeOutboxes(project) {
                 reject(why + ".");
                 continue;
             }
+            const missing = missingSections(type, parsed.body);
+            if (missing.length && project.run?.layout === "run") {
+                const key = formatRejectionKey(sender.name, type, subject);
+                if (formatRejections(project.run.dir, key) < MAX_FORMAT_REJECTIONS) {
+                    const n = countFormatRejection(project.run.dir, key);
+                    reject(`this ${type} is missing required section(s): ${missing.map((s) => `\`## ${s}\``).join(", ")}. Add them (write \`None\` where a section is empty) and send it again. (Attempt ${n} of ${MAX_FORMAT_REJECTIONS}; after that it is delivered with a warning.)`);
+                    continue;
+                }
+            }
             const replyTo = d.reply_to ? String(d.reply_to) : undefined;
             const thread = d.thread ? String(d.thread) : undefined;
             // Mail whose delivery was already planned (a replay after a crash) is not a repeat of itself.
@@ -308,7 +324,6 @@ export function routeOutboxes(project) {
                 });
                 res.rejected.push({ from: sender.name, file, reason: `duplicate: ${repeatNote()}` });
             }
-            const missing = missingSections(type, parsed.body);
             const body = missing.length ? `${formatWarning(type, missing)}\n\n${parsed.body}` : parsed.body;
             if (sender.name === project.lead) {
                 const st = parseSteps(parsed.body);

package/dist/memory-tidy.d.ts

@@ -84,6 +84,8 @@ export interface TidyResult {
     status: "tidied" | "skipped" | "failed" | "dry-run";
     /** The archive stamp of a finished tidy. */
     archive?: string;
+    /** Set when the project records were tidied too: their folder (its archive is `<recordsDir>/.archive/<archive>`). */
+    recordsDir?: string;
     problems: string[];
 }
 /** Scratch space of one tidy (snapshot and the invocation's logs); outside every memory dir and every run. */
@@ -96,8 +98,19 @@ export interface RestoreResult {
         rel: string;
         reason: string;
     }[];
+    /** The same for the project records archive of that stamp, when the lead's undo found one. */
+    records?: {
+        restored: string[];
+        skipped: {
+            rel: string;
+            reason: string;
+        }[];
+    };
 }
-/** Move the files of one tidy's archive back to where they were. Nothing that exists now is overwritten. */
+/**
+ * Move the files of one tidy's archive back to where they were. Nothing that exists now is overwritten.
+ * For the lead on the project layer this covers the project records archive of the same stamp too; either archive may be the only one.
+ */
 export declare function restoreMemory(o: {
     project: ResolvedProject;
     agent: string;