agent-lyceum 0.22.0 → 0.24.0

package/dist/prompt.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
-import { readFileCapped } from "./fs-util.js";
+import { cutUtf8, readFileCapped } from "./fs-util.js";
 import path from "node:path";
 import { REQUIRED_SECTIONS } from "./format.js";
-import { archiveFile, commonFile, decisionsFile, lessonsFile, memoryDirs, outboxDir, repoDirFor, sharedDir, sharedIndex } from "./policy.js";
+import { buildRecordsView, RECORDS_BUDGET } from "./records.js";
+import { commonFile, memoryDirs, outboxDir, recordsKindDir, repoDirFor, sharedDir, sharedIndex } from "./policy.js";
 function memoryLabel(agent, dir) {
     if (dir === agent.memory.task)
         return "task (this task only, isolated)";
@@ -11,8 +12,11 @@ function memoryLabel(agent, dir) {
 export const COMMON_LIMIT = 8 * 1024;
 export const MEMORY_INDEX_LIMIT = 4 * 1024;
 export const HANDOFF_LIMIT = COMMON_LIMIT;
-/** Cap of each of DECISIONS.md and LESSONS.md in a prompt. */
-export const CONTEXT_LIMIT = 6 * 1024;
+/** Cap of each kind of project record (decisions, lessons) in a prompt. */
+export const CONTEXT_LIMIT = RECORDS_BUDGET;
+/** Largest mail body put in a prompt (the inline task limit), and the total for the mails handled in one wake-up. */
+export const MAIL_BODY_LIMIT = 16 * 1024;
+export const MAIL_BATCH_LIMIT = 64 * 1024;
 export const LEAD_BATCH_LIMIT = 5;
 const BATCHABLE = new Set(["reply", "failure"]);
 const readCapped = readFileCapped;
@@ -134,7 +138,7 @@ export function buildSystemPrompt(project, agent) {
     lines.push("- Never edit any `AGENT.md`, `COMMON.md`, or the repository's own `CLAUDE.md`/`AGENTS.md`" +
         (isLead || agent.canEditAgentMd ? " unless you need to as lead (changes are logged)." : "."), "- Never touch another agent's memory, inbox or outbox, or the team's config files.", `- The shared team context is in \`${commonFile(project)}\`${isLead ? " (you maintain it; keep it short)" : " (read-only)"}.`, ...(isLead
         ? [
-            `- You also keep two durable records for every future run of this project: \`${decisionsFile(project)}\` (what was decided and why; a new decision replaces the one it contradicts) and \`${lessonsFile(project)}\` (heuristics and pitfalls that stay true). Update them before you send \`done\`. Each is shown in prompts only up to ${CONTEXT_LIMIT / 1024} KB: move the oldest entries into \`${archiveFile(decisionsFile(project))}\` / \`${archiveFile(lessonsFile(project))}\` (read on demand) to keep them under it.`,
+            `- You also keep two kinds of durable records for every future run of this project, one Markdown file per entry: decisions in \`${recordsKindDir(project, "decisions")}/\` (what was decided and why) and lessons in \`${recordsKindDir(project, "lessons")}/\` (heuristics and pitfalls that stay true). The file name without \`.md\` is the entry id (lowercase letters, digits, \`-\`). Each file starts with YAML frontmatter between \`---\` lines: \`status: active|superseded\`, \`date: YYYY-MM-DD\`, \`title: <one line>\`, optionally \`run: <run id>\` and \`supersedes: [<ids of entries of the same kind>]\`; the body is the decision or lesson and its reason. Prompts show only effective-active entries (\`status: active\` and not named in another entry's \`supersedes\`), newest first, up to ${CONTEXT_LIMIT / 1024} KB per kind, and list what does not fit as one line each. When an entry becomes outdated, mark it \`status: superseded\` or name it in a new entry's \`supersedes\`. Add or update entries before you send \`done\`.`,
         ]
         : []), PR_ATTRIBUTION_RULE, NO_DAEMONS_RULE);
     return lines.join("\n");
@@ -168,16 +172,13 @@ export function buildUserPrompt(project, agent, unread, handleCount = 1, handoff
             parts.push(`\n[COMMON.md was truncated at ${COMMON_LIMIT} bytes — the lead should condense it.]`);
         }
     }
-    for (const [title, file] of [
-        ["Project decisions (DECISIONS.md)", decisionsFile(project)],
-        ["Project lessons (LESSONS.md)", lessonsFile(project)],
+    for (const [title, kind] of [
+        ["Project decisions", "decisions"],
+        ["Project lessons", "lessons"],
     ]) {
-        const rec = readCapped(file, CONTEXT_LIMIT);
-        if (!rec?.text.trim())
-            continue; // nothing recorded yet: no heading, no tokens
-        parts.push("", `# ${title}`, rec.text.trim());
-        if (rec.truncated)
-            parts.push(`\n[${path.basename(file)} was truncated at ${CONTEXT_LIMIT} bytes — the lead should move the oldest entries to ${path.basename(archiveFile(file))}.]`);
+        const view = buildRecordsView(project, kind, CONTEXT_LIMIT);
+        if (view)
+            parts.push("", `# ${title}`, view); // nothing recorded yet: no heading, no tokens
     }
     const handoffFile = handoff ? sharedIndex(project) : undefined;
     const notes = handoffFile ? readCapped(handoffFile, HANDOFF_LIMIT) : undefined;
@@ -205,10 +206,17 @@ export function buildUserPrompt(project, agent, unread, handleCount = 1, handoff
     parts.push("", current.length > 1 ? `# Messages to handle now (${current.length}, oldest first — decide on them together)` : "# Message to handle now");
     if (current.length === 0)
         parts.push("(no message)");
+    let remaining = MAIL_BATCH_LIMIT;
     current.forEach((m, i) => {
         if (current.length > 1)
             parts.push("", `## Message ${i + 1} of ${current.length}`);
-        parts.push(`id: ${m.meta.id}`, `from: ${m.meta.from}`, `type: ${m.meta.type}`, `thread: ${m.meta.thread}`, `subject: ${m.meta.subject}`, "", m.body);
+        const raw = Buffer.from(m.body, "utf8");
+        const shown = cutUtf8(raw, Math.min(MAIL_BODY_LIMIT, remaining));
+        remaining -= shown.length;
+        const body = shown.length === raw.length
+            ? m.body
+            : `${shown.toString("utf8")}\n[agent-lyceum: this message was cut at ${shown.length} of ${raw.length} bytes; read the whole message in \`${m.file}\` (it moves to \`read/\` in the same folder after this wake-up)]`;
+        parts.push(`id: ${m.meta.id}`, `from: ${m.meta.from}`, `type: ${m.meta.type}`, `thread: ${m.meta.thread}`, `subject: ${m.meta.subject}`, "", body);
     });
     if (queued.length) {
         parts.push("", "# Queued messages (not handled in this wake-up; each gets its own wake-up later, titles only)");
@@ -219,6 +227,8 @@ export function buildUserPrompt(project, agent, unread, handleCount = 1, handoff
 }
 /** The prompts of a memory-tidy wake-up: a maintenance job, not a task, so it has none of the mail protocol. */
 export function buildTidyPrompts(agent, ctx) {
+    const { dir, archiveDir, records } = ctx;
+    const touch = [dir ? `your ${ctx.layer} memory (\`${dir}\`)` : "", records ? `the project records (\`${records.dir}\`)` : ""].filter(Boolean).join(" and ");
     const systemPrompt = [
         readPersona(agent),
         "",
@@ -226,35 +236,46 @@ export function buildTidyPrompts(agent, ctx) {
         "",
         "# Memory tidy (injected by agent-lyceum)",
         "",
-        `You are **${agent.name}**. This wake-up is a maintenance job, not a task: there is no mail to send or read, and nothing to do in the repository. Your only job is to tidy your own ${ctx.layer} memory so it stays small, accurate and useful.`,
+        `You are **${agent.name}**. This wake-up is a maintenance job, not a task: there is no mail to send or read, and nothing to do in the repository. Your only job is to tidy ${records ? touch : `your own ${ctx.layer} memory`} so it stays small, accurate and useful.`,
         "",
         "## What you may touch",
-        `Only files inside \`${ctx.dir}\`. Everything else is read-only. Do not touch your other memory directories, \`${ctx.dir}/.tidy-state.json\` or the archive folders of earlier tidies.`,
-        "",
-        "## What to do",
-        "- Merge entries that say the same thing; keep one file with the combined, current content.",
-        "- Rewrite entries that are stale (see the project changes and the missing paths below); correct them if you can tell what is true now, otherwise keep them and say so in the report.",
-        "- Keep `MEMORY.md` as the index: one line per entry, each pointing at an existing file, and nothing for files that were archived.",
-        "- **When unsure, keep it.** Prefer leaving an entry alone over losing information.",
-        "",
-        "## Never delete",
-        `To retire a file, move it into the archive folder, keeping its relative path (\`${ctx.dir}/x/y.md\` goes to \`${ctx.archiveDir}/x/y.md\`). Never delete a file. \`MEMORY.md\` itself is never archived. A file whose content you merged into another one is archived too.`,
-        "",
-        "## Before you finish",
-        `Write \`${ctx.archiveDir}/tidy-report.md\` — even when you changed nothing — with these headings: \`## Merged\` (what was combined into what), \`## Archived\` (each archived file and why), \`## Unsure\` (things you kept but doubt). Write \`None\` under a heading with nothing to say. The tidy is rolled back if the report is missing or any file went missing.`,
+        `Only files inside ${[dir ? `\`${dir}\`` : "", records ? `\`${records.dir}\`` : ""].filter(Boolean).join(" and ")}. Everything else is read-only. Do not touch your other memory directories, \`${dir ? `${dir}/` : ""}.tidy-state.json\` or the archive folders of earlier tidies.`,
+        ...(dir && archiveDir
+            ? [
+                "",
+                records ? "## What to do with your memory" : "## What to do",
+                "- Merge entries that say the same thing; keep one file with the combined, current content.",
+                "- Rewrite entries that are stale (see the project changes and the missing paths below); correct them if you can tell what is true now, otherwise keep them and say so in the report.",
+                "- Keep `MEMORY.md` as the index: one line per entry, each pointing at an existing file, and nothing for files that were archived.",
+                "- **When unsure, keep it.** Prefer leaving an entry alone over losing information.",
+                "",
+                "## Never delete",
+                `To retire a file, move it into the archive folder, keeping its relative path (\`${dir}/x/y.md\` goes to \`${archiveDir}/x/y.md\`). Never delete a file. \`MEMORY.md\` itself is never archived. A file whose content you merged into another one is archived too.`,
+                "",
+                records ? "## Before you finish (memory)" : "## Before you finish",
+                `Write \`${archiveDir}/tidy-report.md\` — even when you changed nothing — with these headings: \`## Merged\` (what was combined into what), \`## Archived\` (each archived file and why), \`## Unsure\` (things you kept but doubt). Write \`None\` under a heading with nothing to say. The tidy is rolled back if the report is missing or any file went missing.`,
+            ]
+            : []),
+        ...(records
+            ? [
+                "",
+                "## What to do with the project records",
+                `The records are the project's durable decisions and lessons, one file per entry (\`${records.dir}/decisions/<id>.md\`, \`${records.dir}/lessons/<id>.md\`). Every entry has frontmatter with \`status\` (\`active\` or \`superseded\`), \`date\` (YYYY-MM-DD) and \`title\` (one line), optionally \`run\` and \`supersedes\` (a list of ids).`,
+                "- Merge entries that say the same thing into one entry (write the merged content, then archive the entries that were merged).",
+                "- When a newer entry replaces an older one, list the old id under `supersedes` in the newer entry, or set the old entry to `status: superseded`.",
+                "- Archive entries that are obsolete.",
+                "- Keep the frontmatter valid: `status`, `date` and `title` are required; the id is the file name without `.md` and uses only lowercase letters, digits and `-`.",
+                "- **When unsure, keep it.** Never delete a file.",
+                `To archive a record, move it into \`${records.archiveDir}\`, keeping its relative path (\`${records.dir}/lessons/x.md\` goes to \`${records.archiveDir}/lessons/x.md\`).`,
+                `Write \`${records.archiveDir}/tidy-report.md\` — even when you changed nothing — with the headings \`## Merged\`, \`## Archived\`, \`## Unsure\` (\`None\` when empty). The tidy of both folders is rolled back if the report is missing or any file went missing.`,
+            ]
+            : []),
     ].join("\n");
-    const parts = [
-        `Archive directory: ${ctx.archiveDir}`,
-        `Layer: ${ctx.layer}${ctx.layer === "global" ? " (shared by every project; do not judge entries by one project's code)" : ""}`,
-        `Memory directory: ${ctx.dir}`,
-        "",
-        "# Files",
-        ...(ctx.files.length ? ctx.files.map((f) => `${f.rel}  ${f.bytes} B  modified ${f.mtime.slice(0, 10)}`) : ["(none)"]),
-        "",
-        `# MEMORY.md (${ctx.dir}/MEMORY.md)`,
-        ctx.index.trim() ? ctx.index.trim() : "(no MEMORY.md)",
-    ];
-    if (ctx.layer === "project") {
+    const parts = [];
+    if (dir && archiveDir) {
+        parts.push(`Archive directory: ${archiveDir}`, `Layer: ${ctx.layer}${ctx.layer === "global" ? " (shared by every project; do not judge entries by one project's code)" : ""}`, `Memory directory: ${dir}`, "", "# Files", ...(ctx.files.length ? ctx.files.map((f) => `${f.rel}  ${f.bytes} B  modified ${f.mtime.slice(0, 10)}`) : ["(none)"]), "", `# MEMORY.md (${dir}/MEMORY.md)`, ctx.index.trim() ? ctx.index.trim() : "(no MEMORY.md)");
+    }
+    if (ctx.layer === "project" && dir) {
         const c = ctx.changes;
         parts.push("", "# Changes in the project since the last tidy");
         if (!c)
@@ -268,7 +289,14 @@ export function buildTidyPrompts(agent, ctx) {
                 parts.push("", "Files changed:", ...c.stat);
         }
     }
-    parts.push("", "# Paths named in the memory that no longer exist");
-    parts.push(...(ctx.missing.length ? ctx.missing.map((m) => `- \`${m.path}\` (mentioned in ${m.file})`) : ["(none found)"]));
+    if (dir) {
+        parts.push("", "# Paths named in the memory that no longer exist");
+        parts.push(...(ctx.missing.length ? ctx.missing.map((m) => `- \`${m.path}\` (mentioned in ${m.file})`) : ["(none found)"]));
+    }
+    if (records) {
+        parts.push(...(parts.length ? [""] : []), "# Project records", `Records archive directory: ${records.archiveDir}`, `Records directory: ${records.dir}`, "", "Entries (kind/id  status  date  size  title):", ...(records.entries.length
+            ? records.entries.map((e) => `${e.rel}  ${e.status}  ${e.date || "no date"}  ${e.bytes} B  ${e.title}${e.invalid ? `  [INVALID: ${e.invalid}]` : ""}`)
+            : ["(none)"]), ...(records.otherFiles.length ? ["", "Other files (leave them alone):", ...records.otherFiles.map((f) => `${f.rel}  ${f.bytes} B`)] : []));
+    }
     return { systemPrompt, userPrompt: parts.join("\n") };
 }

package/dist/records.d.ts

@@ -0,0 +1,30 @@
+import type { ResolvedProject } from "./config.js";
+export type RecordKind = "decisions" | "lessons";
+export declare const RECORD_KINDS: readonly RecordKind[];
+/** Cap of one kind's effective-active entries in a prompt (and, for `done`, the most they may add up to). */
+export declare const RECORDS_BUDGET: number;
+export interface ProjectRecord {
+    kind: RecordKind;
+    id: string;
+    file: string;
+    status: "active" | "superseded";
+    /** `YYYY-MM-DD`; empty when the frontmatter is invalid. */
+    date: string;
+    run?: string;
+    supersedes: string[];
+    title: string;
+    body: string;
+    /** Why the entry could not be read as a record; set entries still count as active so nothing silently disappears. */
+    invalid?: string;
+}
+/** Every `*.md` entry of one kind, sorted by id. Entries that cannot be parsed are listed with `invalid` set; a missing folder is an empty list. */
+export declare function listRecords(project: ResolvedProject, kind: RecordKind): ProjectRecord[];
+/** Entries shown in prompts: `status: active` and not named in another entry's `supersedes`. */
+export declare function effectiveActive(records: ProjectRecord[]): ProjectRecord[];
+/** Bytes the effective-active entries of a kind take in a prompt (each rendered whole, as `buildRecordsView` does). */
+export declare function activeRecordsBytes(project: ResolvedProject, kind: RecordKind): number;
+/**
+ * The text of one kind for a prompt: effective-active entries, newest first, whole entries only until the budget is
+ * used (never cut inside one); the rest are one line each, to read on demand. Undefined when there is nothing to show.
+ */
+export declare function buildRecordsView(project: ResolvedProject, kind: RecordKind, budgetBytes?: number): string | undefined;

package/dist/records.js

@@ -0,0 +1,130 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { readRegularFileNoFollow } from "./fs-util.js";
+import { recordsDir, recordsKindDir } from "./policy.js";
+export const RECORD_KINDS = ["decisions", "lessons"];
+/** Cap of one kind's effective-active entries in a prompt (and, for `done`, the most they may add up to). */
+export const RECORDS_BUDGET = 6 * 1024;
+const ID_RE = /^[a-z0-9-]+$/;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function parseEntry(kind, file) {
+    const id = path.basename(file, ".md");
+    const fallback = { kind, id, file, status: "active", date: "", supersedes: [], title: path.basename(file), body: "" };
+    // Never open a symlink (it could point into .archive/ or outside the tree) or a FIFO/device (it blocks the reader).
+    const buf = readRegularFileNoFollow(file);
+    if (!buf)
+        return { ...fallback, invalid: "not a readable regular file (symlinks and special files are never read)" };
+    const text = buf.toString("utf8");
+    const m = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n([\s\S]*))?$/.exec(text);
+    if (!m)
+        return { ...fallback, body: text.trim(), invalid: "missing frontmatter" };
+    const body = (m[2] ?? "").trim();
+    let fm;
+    try {
+        fm = parseYaml(m[1]);
+    }
+    catch (e) {
+        return { ...fallback, body, invalid: `frontmatter is not valid YAML: ${e.message.split("\n")[0]}` };
+    }
+    if (!fm || typeof fm !== "object" || Array.isArray(fm))
+        return { ...fallback, body, invalid: "frontmatter is not a mapping" };
+    const f = fm;
+    const problems = [];
+    if (!ID_RE.test(id))
+        problems.push("file name must be lowercase letters, digits and -");
+    if (f.status !== "active" && f.status !== "superseded")
+        problems.push("status must be active or superseded");
+    // YAML parses an unquoted 2026-01-02 as a Date.
+    const date = f.date instanceof Date ? f.date.toISOString().slice(0, 10) : f.date;
+    if (typeof date !== "string" || !DATE_RE.test(date))
+        problems.push("date must be YYYY-MM-DD");
+    if (typeof f.title !== "string" || !f.title.trim() || /[\r\n]/.test(f.title.trim()))
+        problems.push("title must be one non-empty line");
+    let supersedes = [];
+    if (f.supersedes !== undefined) {
+        if (Array.isArray(f.supersedes) && f.supersedes.every((x) => typeof x === "string"))
+            supersedes = f.supersedes;
+        else
+            problems.push("supersedes must be a list of ids");
+    }
+    if (f.run !== undefined && typeof f.run !== "string")
+        problems.push("run must be a string");
+    if (problems.length)
+        return { ...fallback, body, invalid: problems.join("; ") };
+    return {
+        kind,
+        id,
+        file,
+        status: f.status,
+        date: date,
+        run: f.run,
+        supersedes,
+        title: f.title.trim(),
+        body,
+    };
+}
+/** Every `*.md` entry of one kind, sorted by id. Entries that cannot be parsed are listed with `invalid` set; a missing folder is an empty list. */
+export function listRecords(project, kind) {
+    const dir = recordsKindDir(project, kind);
+    let names;
+    try {
+        // A symlinked records/ or kind folder could point at archived or outside entries: list nothing, never descend.
+        for (const d of [recordsDir(project), dir])
+            if (!fs.lstatSync(d).isDirectory())
+                return [];
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return names
+        .filter((n) => n.endsWith(".md"))
+        .sort()
+        .map((n) => parseEntry(kind, path.join(dir, n)));
+}
+/** Entries shown in prompts: `status: active` and not named in another entry's `supersedes`. */
+export function effectiveActive(records) {
+    const replaced = new Set();
+    for (const r of records)
+        for (const id of r.supersedes)
+            if (id !== r.id)
+                replaced.add(id);
+    return records.filter((r) => r.status === "active" && !replaced.has(r.id));
+}
+function newestFirst(records) {
+    return [...records].sort((a, b) => b.date.localeCompare(a.date) || b.id.localeCompare(a.id));
+}
+function renderEntry(r) {
+    return `## ${r.title} [${r.id}]${r.body ? `\n${r.body}` : ""}`;
+}
+/** Bytes the effective-active entries of a kind take in a prompt (each rendered whole, as `buildRecordsView` does). */
+export function activeRecordsBytes(project, kind) {
+    return Buffer.byteLength(effectiveActive(listRecords(project, kind)).map(renderEntry).join("\n\n"));
+}
+/**
+ * The text of one kind for a prompt: effective-active entries, newest first, whole entries only until the budget is
+ * used (never cut inside one); the rest are one line each, to read on demand. Undefined when there is nothing to show.
+ */
+export function buildRecordsView(project, kind, budgetBytes = RECORDS_BUDGET) {
+    const entries = newestFirst(effectiveActive(listRecords(project, kind)));
+    if (entries.length === 0)
+        return undefined;
+    const shown = [];
+    let used = 0;
+    let i = 0;
+    for (; i < entries.length; i++) {
+        const text = renderEntry(entries[i]);
+        const size = Buffer.byteLength(text) + (shown.length ? 2 : 0);
+        if (used + size > budgetBytes)
+            break;
+        shown.push(text);
+        used += size;
+    }
+    const rest = entries.slice(i);
+    const parts = [...shown];
+    if (rest.length) {
+        parts.push(`${shown.length ? "More" : "These"} active entries did not fit in ${budgetBytes} bytes; read the file on demand:`, rest.map((r) => `- [${r.id}] ${r.title} (read: ${r.file})`).join("\n"));
+    }
+    return parts.join("\n\n");
+}

package/dist/redo.d.ts

@@ -0,0 +1,57 @@
+/** An earlier attempt of the same agent at the same message that failed: what a redo starts from. */
+export interface PriorAttempt {
+    /** `<claim id>-a<n>` */
+    id: string;
+    claimId: string;
+    n: number;
+    /** The attempt's error; "unknown (attempt record unreadable)" when its record cannot be read. */
+    error: string;
+    /** For sorting: finished_at ?? started_at ?? the folder's mtime (epoch ms). */
+    at: number;
+    /** Files the record says were set aside; absent when the record is unreadable. */
+    parked?: string[];
+}
+/** Something left out; `path` is relative to the run folder. */
+export interface Skip {
+    path: string;
+    reason: string;
+}
+export interface PriorResult {
+    /** Valid candidates, newest first. */
+    prior: PriorAttempt[];
+    /** Records or folders that were passed over; they never affect the other candidates. */
+    skipped: Skip[];
+}
+export interface DraftsResult {
+    /** The whole drafts block; "" when there is nothing usable. */
+    text: string;
+    injected: {
+        path: string;
+        bytes: number;
+        truncated: boolean;
+    }[];
+    skipped: Skip[];
+    /** Attempts whose folder and record disagree on what was set aside. */
+    reconciled: {
+        attempt: string;
+        onlyOnDisk: string[];
+        onlyInRecord: string[];
+    }[];
+}
+/** Attempts of `agent` that failed before this invoke, on a claim for one of `messageIds`. Never throws. */
+export declare function priorFailedAttempts(runDir: string, agent: string, messageIds: string[], exclude: string): PriorResult;
+/** The drafts block for the attempts in `prior` (newest first), read from their folders, at most `budget` bytes and `maxFiles` files. */
+export declare function collectDrafts(runDir: string, prior: PriorAttempt[], budget?: number, maxFiles?: number): DraftsResult;
+/** Prompt for a repeat attempt in the same wake-up: the earlier one failed and may have changed things already. */
+export declare function retryPrompt(prompt: string, error: string | undefined, o: {
+    drafts: boolean;
+    taskMemory?: string;
+}): string;
+/** The user prompt for this invoke: `base`, a Retry or Redo notice when there is something to redo, then the drafts. No IO. */
+export declare function redoUserPrompt(base: string, o: {
+    attempt: number;
+    error?: string;
+    prior: PriorAttempt[];
+    drafts: string;
+    taskMemory?: string;
+}): string;