@sigrun/ext-curator 0.0.0-stage → 0.2.0

package/dist/loop2.js

@@ -0,0 +1,323 @@
+/**
+ * Loop 2 — the scheduled idle maintenance pass (`src/loop2.ts`, Task
+ * B3, spec §6.2).
+ *
+ * Clocked by the `curator-tick` job (the only time-based scheduler);
+ * each fired task runs {@link tick} once, and a tick does AT MOST one
+ * pass-fragment: every user's pass is a small resumable queue of
+ * steps with a durable cursor (`pass.json` under the user's state
+ * dir), so a tick interrupted at its self-imposed 5-minute deadline
+ * leaves the cursor pointing at the next step and the NEXT tick
+ * resumes exactly there. Nothing depends on finishing in one go.
+ *
+ * The eligibility gate ({@link eligibleUsers}, spec): a user is due
+ * when they are QUIET — the newest `lastActivityAt` across their
+ * conversations is older than the idle threshold. "No live run" rides
+ * the same clock: activity is stamped at submission admission AND at
+ * run settlement (core's activity seam), so a user with a live run is
+ * never past the idle threshold — the recency check observes it. A
+ * user with no activity at all (never used, or quiet since before the
+ * seam existed) is quiet too. Plus: settings enabled and not paused,
+ * no full pass in the last 24h, and past the install's first-run
+ * grace (the FIRST tick instant + 24h, recorded once in the
+ * extension's own state — the grace is install-wide, per spec: "no
+ * pass until one full interval after install").
+ *
+ * The cursor (`PassCursor`): `steps` is the pass's queue, `done` how
+ * many steps finished (persisted after EVERY step — that is the
+ * resume point), `dailyRunsUsed`/`day` the per-user model-run budget
+ * Task B4's model steps spend (a calendar day rollover re-arms it).
+ *
+ * The step table: B3 owns the two deterministic steps (`archive`,
+ * `overlay-detect`); the five model steps are declared in the queue
+ * and run as no-ops here — Task B4 fills them in.
+ */
+import { join } from "node:path";
+import { readStateJson, writeStateJson } from "./queue.js";
+import { readSettings } from "./settings.js";
+import { archiveUnused } from "./steps/archive.js";
+import { detectOverlayDrift, recheckOverlays } from "./steps/overlays.js";
+import { digestsStep } from "./steps/digests.js";
+import { dietStep } from "./steps/diet.js";
+import { mergeStep } from "./steps/merge.js";
+import { maintainTargets } from "./steps/targets.js";
+/**
+ * The idle threshold (spec §5 pins SIGRUN_IDLE_THRESHOLD's default at
+ * 10 minutes; the extension reads the semantics, not the env — the
+ * host's activity seam already carries it).
+ */
+export const IDLE_THRESHOLD_MS = 600_000;
+/**
+ * The tick's self-imposed deadline: 5 minutes, well under the worker/
+ * job deadline, so a pass fragment always outlives its own tick.
+ */
+export const LOOP2_TICK_DEADLINE_MS = 300_000;
+/** The first-run grace: no pass until 24h after the first tick ever. */
+export const FIRST_RUN_GRACE_MS = 24 * 60 * 60 * 1000;
+/** How long a completed pass keeps its user ineligible. */
+export const FULL_PASS_INTERVAL_MS = 24 * 60 * 60 * 1000;
+/** The per-user pass-cursor file name (under the user's state dir). */
+export const PASS_FILE = "pass.json";
+/**
+ * The extension-scope state file holding the install-wide first-tick
+ * instant (the grace anchor). Chosen name; recorded here as the seam.
+ */
+export const FIRST_TICK_FILE = "loop2-first-tick.json";
+/** One pass's step kinds, in run order (deterministic steps first). */
+export const PASS_STEPS = [
+    "archive",
+    "overlay-detect",
+    "overlay-recheck",
+    "digests",
+    "diet",
+    "merge",
+    "targets",
+];
+/** The step-queue kinds Task B4 owns (the five model steps). */
+const MODEL_STEPS = new Set([
+    "overlay-recheck",
+    "digests",
+    "diet",
+    "merge",
+    "targets",
+]);
+/** The UTC calendar day of `at` (budget days are UTC). */
+function dayOf(at) {
+    return at.toISOString().slice(0, 10);
+}
+/** Read the install-wide first-tick instant; absent/malformed → none. */
+async function readFirstTick(host) {
+    const parsed = await readStateJson(join(host.stores.paths.state, FIRST_TICK_FILE), {});
+    if (typeof parsed.firstTickAt !== "string")
+        return undefined;
+    const at = Date.parse(parsed.firstTickAt);
+    return Number.isFinite(at) ? new Date(at) : undefined;
+}
+/** Record the install's first-tick instant (once — the grace anchor). */
+async function writeFirstTick(host, at) {
+    await writeStateJson(host.stores.paths.state, FIRST_TICK_FILE, {
+        firstTickAt: at.toISOString(),
+    });
+}
+/** Read one user's pass cursor; absent/malformed → none (a fresh pass). */
+async function readPass(host, user) {
+    const parsed = await readStateJson(join(host.stores.user(user).paths.state, PASS_FILE), {});
+    const known = new Set(PASS_STEPS);
+    if (typeof parsed.startedAt !== "string")
+        return undefined;
+    if (!Array.isArray(parsed.steps) || parsed.steps.length === 0)
+        return undefined;
+    if (!parsed.steps.every((step) => typeof step === "string" && known.has(step))) {
+        return undefined;
+    }
+    if (typeof parsed.done !== "number" ||
+        !Number.isInteger(parsed.done) ||
+        parsed.done < 0 ||
+        parsed.done > parsed.steps.length) {
+        return undefined;
+    }
+    if (typeof parsed.dailyRunsUsed !== "number" ||
+        !Number.isInteger(parsed.dailyRunsUsed) ||
+        parsed.dailyRunsUsed < 0) {
+        return undefined;
+    }
+    if (typeof parsed.day !== "string")
+        return undefined;
+    return {
+        startedAt: parsed.startedAt,
+        steps: parsed.steps,
+        done: parsed.done,
+        dailyRunsUsed: parsed.dailyRunsUsed,
+        day: parsed.day,
+    };
+}
+/** Persist one user's pass cursor (after every step — the resume point). */
+async function writePass(host, user, cursor) {
+    await writeStateJson(host.stores.user(user).paths.state, PASS_FILE, cursor);
+}
+/**
+ * Whether the user is QUIET: their newest conversation activity is
+ * older than the idle threshold. No activity at all is quiet. A live
+ * run stamps activity at admission, so it is never quiet mid-run.
+ */
+async function isQuiet(host, user, now) {
+    const conversations = await host.conversations.list({ owner: user });
+    let newest;
+    for (const conversation of conversations) {
+        if (conversation.lastActivityAt === undefined)
+            continue;
+        const at = Date.parse(conversation.lastActivityAt);
+        if (Number.isFinite(at) && (newest === undefined || at > newest)) {
+            newest = at;
+        }
+    }
+    return newest === undefined || now.getTime() - newest >= IDLE_THRESHOLD_MS;
+}
+/**
+ * The users due for a pass (spec §6.2): quiet, settings on, past the
+ * first-run grace, and without a completed pass in the last 24h. An
+ * INCOMPLETE pass does not block — the next tick resumes it.
+ */
+export async function eligibleUsers(host, now) {
+    const firstTick = await readFirstTick(host);
+    if (firstTick === undefined)
+        return []; // the grace never started
+    const at = now();
+    if (at.getTime() - firstTick.getTime() < FIRST_RUN_GRACE_MS)
+        return [];
+    const due = [];
+    for (const row of await host.users.list()) {
+        const settings = await readSettings(host, row.user);
+        if (!settings.enabled || settings.paused)
+            continue;
+        if (!(await isQuiet(host, row.user, at)))
+            continue;
+        const pass = await readPass(host, row.user);
+        if (pass !== undefined && pass.done >= pass.steps.length) {
+            // A completed pass: due again only past its 24h window.
+            if (at.getTime() - Date.parse(pass.startedAt) < FULL_PASS_INTERVAL_MS) {
+                continue;
+            }
+        }
+        due.push(row.user);
+    }
+    return due;
+}
+/**
+ * Create loop 2: the tick the factory's task calls (a thin binding of
+ * {@link tick} to its deps). The durable cadence stays the job's —
+ * this creates no timers.
+ */
+export function createLoop2(deps) {
+    const now = deps.now ?? (() => new Date());
+    return {
+        tick: () => tick(deps.host, now, { log: deps.log }),
+    };
+}
+/**
+ * One tick: as many pass fragments as fit before the 5-minute
+ * self-deadline. Per-user failures are logged and never break the
+ * tick — the cursor makes every user resumable.
+ */
+export async function tick(host, now, opts = {}) {
+    const log = opts.log ?? ((message) => console.error(`curator: ${message}`));
+    const startedAt = now();
+    const firstTick = await readFirstTick(host);
+    if (firstTick === undefined) {
+        // The install instant: the grace window opens now, and no pass
+        // runs before it ends (24h of quiet install first).
+        await writeFirstTick(host, startedAt);
+        return;
+    }
+    if (startedAt.getTime() - firstTick.getTime() < FIRST_RUN_GRACE_MS)
+        return;
+    const deadlineAt = startedAt.getTime() + LOOP2_TICK_DEADLINE_MS;
+    for (const user of await eligibleUsers(host, now)) {
+        if (now().getTime() >= deadlineAt)
+            break;
+        await runPass(host, user, now, deadlineAt, log).catch((error) => {
+            log(`loop 2: pass for ${user} failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+}
+/** The step table: B3's deterministic steps and B4's model steps. */
+const STEP_RUNNERS = {
+    archive: archiveUnused,
+    "overlay-detect": detectOverlayDrift,
+    "overlay-recheck": recheckOverlays,
+    digests: digestsStep,
+    diet: dietStep,
+    merge: mergeStep,
+    targets: maintainTargets,
+};
+/**
+ * Walk one user's pass from its cursor: run steps while the tick's
+ * deadline holds, persisting `done` after every step. A MODEL step that
+ * answers false (the daily budget is spent) STOPS the pass for the day:
+ * the cursor keeps pointing at that step, and the next tick — or the
+ * next day's re-armed budget — resumes exactly there.
+ */
+async function runPass(host, user, now, deadlineAt, log) {
+    const today = dayOf(now());
+    const read = await readPass(host, user);
+    let fresh;
+    if (read === undefined || read.done >= read.steps.length) {
+        // No pass yet, or the previous pass completed (its 24h window is
+        // why the user is eligible again): a fresh cursor from step one.
+        fresh = {
+            startedAt: now().toISOString(),
+            steps: [...PASS_STEPS],
+            done: 0,
+            dailyRunsUsed: 0,
+            day: today,
+        };
+    }
+    else if (read.day !== today) {
+        // A new day re-arms the model-run budget mid-pass.
+        fresh = { ...read, day: today, dailyRunsUsed: 0 };
+    }
+    else {
+        fresh = read;
+    }
+    // The cursor holder — one mutable slot every writer goes through, so
+    // the budget closure always sees the live cursor.
+    const state = { cursor: fresh };
+    await writePass(host, user, state.cursor);
+    // The daily model-run budget (Task B4): `dailyRuns` minus what today
+    // already spent. Every spend persists the cursor BEFORE its run —
+    // a crash may waste a run, it never overspends the day.
+    const settings = await readSettings(host, user);
+    const budget = {
+        left: () => Math.max(0, settings.dailyRuns - state.cursor.dailyRunsUsed),
+        spend: async () => {
+            if (state.cursor.dailyRunsUsed >= settings.dailyRuns)
+                return false;
+            state.cursor = {
+                ...state.cursor,
+                dailyRunsUsed: state.cursor.dailyRunsUsed + 1,
+            };
+            await writePass(host, user, state.cursor);
+            return true;
+        },
+    };
+    while (state.cursor.done < state.cursor.steps.length) {
+        const cursor = state.cursor;
+        // Out of tick budget: stop BEFORE the next step — the cursor is
+        // the resume point the next tick picks up.
+        if (now().getTime() >= deadlineAt)
+            return;
+        const step = cursor.steps[cursor.done];
+        const runner = STEP_RUNNERS[step];
+        const deps = {
+            host,
+            user,
+            now,
+            deadlineAt,
+            budget,
+            log,
+        };
+        try {
+            if (MODEL_STEPS.has(step)) {
+                const proceed = await runner(deps);
+                if (!proceed) {
+                    // The daily cap (or the tick deadline) stopped the pass: the
+                    // cursor stays at this step — the next tick resumes it, and a
+                    // new day re-arms the budget.
+                    log(`loop 2: ${user} stopped at step "${step}" for the day`);
+                    return;
+                }
+            }
+            else {
+                await runner(host, user, now);
+            }
+        }
+        catch (error) {
+            // The step failed; the pass moves on — a deterministic step
+            // wedging the cursor forever would be worse than skipping it
+            // this pass (idempotent steps make a later pass safe).
+            log(`loop 2: ${user} step "${step}" failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        state.cursor = { ...state.cursor, done: state.cursor.done + 1 };
+        await writePass(host, user, state.cursor);
+    }
+}

package/dist/notices.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The post-review notice (`src/notices.ts`, Task B5): what the user
+ * sees when a review changed something — ONE ambient record on the
+ * originating conversation (`curator.notice`, place `status`), one
+ * line per change (`Learned: <summary>`), with a `navigate` action to
+ * the curator view anchored at the review.
+ *
+ * The ambient seam is the ONLY carrier (the brief): a notice is never
+ * a transcript entry (a fork would replay it) and never a notifier or
+ * channel delivery (gateway channels get no notice by default, spec
+ * P8). Ambient records are display-only — no action route reaches
+ * them — so Undo lives on the curator VIEW; the notice's button just
+ * navigates there.
+ *
+ * The body must pass the server's own ambient validation (a `status`
+ * slot allows ONE line-level block, literal content only — ambient
+ * bodies carry no data document, so bindings are rejected): a single
+ * `callout` whose title joins the change lines and whose actions
+ * carry the navigate button. One line-level block per seam rule.
+ *
+ * DURABILITY: each notice is remembered in `notices.json` under the
+ * user's state dir (`readNotices` is the view's lookup) — an Undo
+ * after a restart still knows which conversation's ambient record to
+ * clear. The file is bounded: recording a notice replaces the entry
+ * of the SAME review id (a re-run of one review id is one notice) and
+ * the file keeps the newest 50 (matching the feed window the view
+ * shows — older notices have nothing left to undo once the feed rolls
+ * past them).
+ */
+import type { ConversationId } from "@earendil-works/pi-durable";
+import type { CurationRunResult, SigrunHost } from "@sigrun/sigrun/extension";
+import { CURATOR_NOTICE_KIND } from "./index.js";
+export { CURATOR_NOTICE_KIND };
+/** What one recorded notice remembers (the view's undo lookup). */
+export interface NoticeRecord {
+    /** The review the notice announced (the undo key). */
+    readonly reviewId: string;
+    /** The conversation whose ambient slot carries the notice. */
+    readonly conversationId: ConversationId;
+    /** When the notice was set (ISO). */
+    readonly at: string;
+}
+/**
+ * Announce one completed review: when the result carries changes, set
+ * the `curator.notice` ambient record on the conversation and record
+ * the notice durably. No changes → nothing (an unchanged conversation
+ * stays untouched). Answers the notice record (undefined when no
+ * notice was set).
+ */
+export declare function notify(host: SigrunHost, conversationId: ConversationId, user: string, result: CurationRunResult & {
+    readonly reviewId?: string;
+}): Promise<NoticeRecord | undefined>;
+/** Read the user's recorded notices (newest first); absent/malformed → []. */
+export declare function readNotices(host: SigrunHost, user: string): Promise<readonly NoticeRecord[]>;

package/dist/notices.js

@@ -0,0 +1,127 @@
+/**
+ * The post-review notice (`src/notices.ts`, Task B5): what the user
+ * sees when a review changed something — ONE ambient record on the
+ * originating conversation (`curator.notice`, place `status`), one
+ * line per change (`Learned: <summary>`), with a `navigate` action to
+ * the curator view anchored at the review.
+ *
+ * The ambient seam is the ONLY carrier (the brief): a notice is never
+ * a transcript entry (a fork would replay it) and never a notifier or
+ * channel delivery (gateway channels get no notice by default, spec
+ * P8). Ambient records are display-only — no action route reaches
+ * them — so Undo lives on the curator VIEW; the notice's button just
+ * navigates there.
+ *
+ * The body must pass the server's own ambient validation (a `status`
+ * slot allows ONE line-level block, literal content only — ambient
+ * bodies carry no data document, so bindings are rejected): a single
+ * `callout` whose title joins the change lines and whose actions
+ * carry the navigate button. One line-level block per seam rule.
+ *
+ * DURABILITY: each notice is remembered in `notices.json` under the
+ * user's state dir (`readNotices` is the view's lookup) — an Undo
+ * after a restart still knows which conversation's ambient record to
+ * clear. The file is bounded: recording a notice replaces the entry
+ * of the SAME review id (a re-run of one review id is one notice) and
+ * the file keeps the newest 50 (matching the feed window the view
+ * shows — older notices have nothing left to undo once the feed rolls
+ * past them).
+ */
+import { join } from "node:path";
+import { CURATOR_NOTICE_KIND } from "./index.js";
+export { CURATOR_NOTICE_KIND };
+/** The notice ledger's file name under the user's state dir. */
+const NOTICES_FILE = "notices.json";
+/** How many notices the ledger keeps (the view's feed window). */
+const NOTICE_LEDGER_MAX = 50;
+/** The zero-signal context the ambient write runs under (the review
+ *  body has no caller signal of its own — the run's deadline bound it). */
+const CONTEXT = { abortSignal: undefined };
+/**
+ * Announce one completed review: when the result carries changes, set
+ * the `curator.notice` ambient record on the conversation and record
+ * the notice durably. No changes → nothing (an unchanged conversation
+ * stays untouched). Answers the notice record (undefined when no
+ * notice was set).
+ */
+export async function notify(host, conversationId, user, result) {
+    if (result.status !== "completed")
+        return undefined;
+    if (result.changes.length === 0)
+        return undefined;
+    const reviewId = result.reviewId;
+    if (reviewId === undefined || reviewId === "")
+        return undefined;
+    const at = new Date().toISOString();
+    await host.setAmbient(conversationId, {
+        key: CURATOR_NOTICE_KIND,
+        place: "status",
+        body: noticeBody(result.changes.map((change) => change.summary), reviewId),
+    }, CONTEXT);
+    const record = { reviewId, conversationId, at };
+    await recordNotice(host, user, record);
+    return record;
+}
+/**
+ * The notice body: ONE line-level `callout` (the `status` slot's
+ * one-line rule) whose title joins the change summaries and whose
+ * actions navigate to the curator view anchored at the review.
+ */
+function noticeBody(summaries, reviewId) {
+    const lines = summaries.map((summary) => `Learned: ${summary}`);
+    return {
+        v: 1,
+        root: {
+            type: "callout",
+            id: "curator-notice",
+            tone: "neutral",
+            // The one-line rule makes the title the line the channels show;
+            // multiple changes join on the same line (a statusline slot).
+            title: lines.join(" · "),
+            body: "Open the curator view to review or undo.",
+            actions: [
+                {
+                    id: "open",
+                    label: "Curator",
+                    icon: "book",
+                    action: {
+                        type: "navigate",
+                        target: {
+                            view: {
+                                extension: "curator",
+                                id: "curator",
+                                params: { review: reviewId },
+                            },
+                        },
+                    },
+                },
+            ],
+        },
+    };
+}
+/** The ledger file path for one user. */
+function noticesFile(host, user) {
+    return join(host.stores.user(user).paths.state, NOTICES_FILE);
+}
+/** Read the user's recorded notices (newest first); absent/malformed → []. */
+export async function readNotices(host, user) {
+    const { readStateJson } = await import("./queue.js");
+    const parsed = await readStateJson(noticesFile(host, user), []);
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.filter((entry) => typeof entry === "object" &&
+        entry !== null &&
+        typeof entry.reviewId === "string" &&
+        typeof entry.conversationId === "number" &&
+        typeof entry.at === "string");
+}
+/** Record one notice: replace the same review's entry, keep the newest 50. */
+async function recordNotice(host, user, record) {
+    const { writeStateJson } = await import("./queue.js");
+    const current = await readNotices(host, user);
+    const next = [
+        record,
+        ...current.filter((entry) => entry.reviewId !== record.reviewId),
+    ].slice(0, NOTICE_LEDGER_MAX);
+    await writeStateJson(host.stores.user(user).paths.state, NOTICES_FILE, next);
+}

package/dist/prompts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The review prompt (`src/prompts.ts`, Task B2): what a fork review or
+ * digest review submits as its only input. The fork carries the
+ * parent's transcript, so the instruction is the reviewer's brief, not
+ * the material.
+ *
+ * The CONTENT is spec §6.2's review-prompt requirements (the wording is
+ * ours; the snapshot test pins it once written):
+ *
+ * - what a skill is — a procedure for a repeatable class of task, for
+ *   this user; pitfalls as a rule plus one clause of why; no incident
+ *   narration, dates, PR numbers or quoted chatter;
+ * - the do-not-capture list — environment failures, negative claims
+ *   about tools, transient errors, unresolved failures presented as
+ *   workflows, one-off tasks, codebase facts (the repo's AGENTS.md),
+ *   secrets, and personal facts (a memory target when one is offered);
+ * - the routing rule — each lesson goes in exactly one place: one
+ *   skill, one overlay, or one target;
+ * - update the skill in play before creating one; class-level names;
+ * - "Nothing to save" is a valid outcome;
+ * - never store another participant's words;
+ * - the hint arguments and exactly the allowed tools.
+ *
+ * Loop 2's digest reviews reuse this instruction verbatim (Task B4).
+ */
+import type { CurationHint } from "@sigrun/sigrun/extension";
+/** What `reviewInstruction` needs (the brief's exact shape). */
+export interface ReviewInstructionOpts {
+    /** Owner write attempts the review folds in (empty: none pending). */
+    readonly hints: readonly CurationHint[];
+    /** Curation targets offered to this run, with their guidance. */
+    readonly targets: readonly {
+        readonly id: string;
+        readonly guidance: readonly string[];
+    }[];
+    /** The run's allow list — the instruction names these and no others. */
+    readonly allow: readonly string[];
+    /** `/learn`'s optional focus, riding along when given. */
+    readonly focus?: string;
+}
+/**
+ * Build the review instruction (the run's only input). Deterministic:
+ * fixed inputs produce the fixed text the snapshot pins.
+ */
+export declare function reviewInstruction(opts: ReviewInstructionOpts): string;

package/dist/prompts.js

@@ -0,0 +1,57 @@
+/**
+ * The review prompt (`src/prompts.ts`, Task B2): what a fork review or
+ * digest review submits as its only input. The fork carries the
+ * parent's transcript, so the instruction is the reviewer's brief, not
+ * the material.
+ *
+ * The CONTENT is spec §6.2's review-prompt requirements (the wording is
+ * ours; the snapshot test pins it once written):
+ *
+ * - what a skill is — a procedure for a repeatable class of task, for
+ *   this user; pitfalls as a rule plus one clause of why; no incident
+ *   narration, dates, PR numbers or quoted chatter;
+ * - the do-not-capture list — environment failures, negative claims
+ *   about tools, transient errors, unresolved failures presented as
+ *   workflows, one-off tasks, codebase facts (the repo's AGENTS.md),
+ *   secrets, and personal facts (a memory target when one is offered);
+ * - the routing rule — each lesson goes in exactly one place: one
+ *   skill, one overlay, or one target;
+ * - update the skill in play before creating one; class-level names;
+ * - "Nothing to save" is a valid outcome;
+ * - never store another participant's words;
+ * - the hint arguments and exactly the allowed tools.
+ *
+ * Loop 2's digest reviews reuse this instruction verbatim (Task B4).
+ */
+/**
+ * Build the review instruction (the run's only input). Deterministic:
+ * fixed inputs produce the fixed text the snapshot pins.
+ */
+export function reviewInstruction(opts) {
+    const lines = [
+        "You are the curator. Review the conversation above and distill durable lessons for this user.",
+    ];
+    if (opts.focus !== undefined) {
+        lines.push(`Focus: ${opts.focus}.`);
+    }
+    lines.push("", "A skill is a procedure for a repeatable class of task, for this user. State pitfalls as a rule plus one clause of why. No incident narration, no dates, no PR numbers, no quoted chatter.", "", "Do NOT capture: environment failures; negative claims about tools; transient errors; unresolved failures presented as workflows; one-off tasks; codebase facts (those belong in the repo's AGENTS.md); secrets; personal facts (those go to the memory target when one is offered). Never store another participant's words.", "", "Each lesson goes in exactly one place: one skill, one overlay, or one target. Update the skill in play before creating one; pick class-level names.", "", '"Nothing to save" is a valid outcome — when nothing qualifies, finish with that sentence and change nothing.');
+    if (opts.targets.length > 0) {
+        lines.push("", "Targets:");
+        for (const target of opts.targets) {
+            for (const line of target.guidance) {
+                lines.push(`- ${target.id}: ${line}`);
+            }
+            if (target.guidance.length === 0) {
+                lines.push(`- ${target.id}.`);
+            }
+        }
+    }
+    if (opts.hints.length > 0) {
+        lines.push("", "The user made these write attempts between reviews — fold their intent in:");
+        for (const [index, hint] of opts.hints.entries()) {
+            lines.push(`${index + 1}. ${hint.tool} ${JSON.stringify(hint.args)} at ${hint.at}`);
+        }
+    }
+    lines.push("", `Your tools: ${opts.allow.join(", ")}. Nothing else.`);
+    return `${lines.join("\n")}\n`;
+}