@zenera/neo 1.1.19 → 1.1.21

package/dist/memory/instructions.js

@@ -1,103 +0,0 @@
-import { MEMORY_COMMIT_TOOL, MEMORY_FORGET_TOOL, MEMORY_LOAD_TOOL, MEMORY_SEARCH_TOOL, } from "../types.js";
-import { RECOLLECTION_TAG } from "./render.js";
-import { canForget, canWrite } from "./types.js";
-// ---------------------------------------------------------------------------
-// Teaching the model to read and write memory
-//
-// The tool schemas say what the arguments are; none of them says when a thing
-// is worth remembering, or that a recollection is a subgraph rather than a
-// ranked list. That is policy, it is the same for every agent, and it belongs
-// in the system prompt — which is also the only place it can be stated once
-// per run instead of once per call.
-//
-// Both halves go in through `composePrompt`'s `derived` array, so they sit in
-// the cacheable prefix and are recorded in the `system_prompt` node like every
-// other part of what the model read.
-//
-// The text is gated on the binding, not on the project: an agent that cannot
-// write is never told how to commit. A rule it cannot act on is a rule it can
-// only be confused by, and an unusable tool name in the prompt invites a call
-// that will be refused.
-// ---------------------------------------------------------------------------
-export const PREFERENCES_TAG = 'memory-preferences';
-/**
- * Deliberately not a function of `sees`: those labels come from the run's
- * context, and naming them here would rewrite the prompt whenever the context
- * moved. It also tells an agent the shape of a slice it was not given.
- */
-export function memoryInstructions(binding) {
-    const parts = [READING];
-    if (canWrite(binding)) {
-        parts.push(WRITING);
-    }
-    if (canForget(binding)) {
-        parts.push(FORGETTING);
-    }
-    return parts.join('\n\n');
-}
-const READING = `Memory is a graph shared with other agents, and it outlives this run.
-
-A <${RECOLLECTION_TAG}> block is a subgraph, not a ranked list — the links are
-as much of the answer as the nodes. It is an outline, and the indentation is
-the graph. A line at the left margin reads \`score kind id\` and is something
-the search matched. A line indented under it reads \`<arrow>relation kind id\`
-and is a neighbour: \`\u2192produced\` means the line above produced this one,
-\`\u2190informed\` means this one informed the line above. A neighbour the
-search matched in its own right carries a score too, after the arrow. Under
-each header, indented further, is that node's text — and for a \`file\`, the
-path under /memory you can open or run, its size and how often it has been read.
-
-A line beginning \`+\` is a link to an id already shown above, for an edge the
-outline could not nest. Text is clipped: copy an id into \`${MEMORY_LOAD_TOOL}\`
-to read a node whole. \`${MEMORY_SEARCH_TOOL}\` finds ids, it does not return
-contents.
-
-You see part of the graph, not all of it. Finding nothing means nothing you can
-see, not that it never happened.`;
-const WRITING = `Commit when a run produced something a later run would otherwise have to work
-out again: a script that ran, an interface that behaved differently from its
-documentation, a call sequence that turned out to be necessary. Commit it in
-one \`${MEMORY_COMMIT_TOOL}\` call — the artifact and what explains it are one
-memory, and splitting them leaves a later run holding a script with no idea why
-it exists.
-
-Do not commit the request restated, progress notes, anything you have not
-verified, or anything a search already returned. A node that says what one
-already in memory says is folded into it and its existing id comes back under
-your ref, so the links you asked for still land — on the memory that was
-already there.
-
-Never edit a memory to correct it. Add the new one and link it to the old with
-SUPERSEDES; the wrong answer is evidence too, and the link is what hides it
-from later recalls without destroying the history.
-
-Commit a preference only when the user's own words generalise — "always", "from
-now on", "I prefer", "never". A single request being fulfilled is not a
-standing instruction.`;
-const FORGETTING = `Forget only what is wrong and has no successor. A superseded memory is already
-hidden from recall and should stay for the history, so \`${MEMORY_FORGET_TOOL}\`
-is for what should never have been written, not for what has been replaced.`;
-/**
- * The id on each line is what makes a preference revisable rather than merely
- * readable: without it the model can read the instruction but cannot name the
- * thing it would supersede.
- */
-export function renderPreferences(nodes) {
-    if (!nodes.length) {
-        return '';
-    }
-    const lines = nodes.map((n) => `- ${oneLine(n.text)} [${n.id}]`);
-    return [
-        `<${PREFERENCES_TAG}>`,
-        "Standing instructions from earlier runs. They apply unless this run's",
-        'request contradicts them; to change one, commit the replacement and link',
-        'it to the id here with SUPERSEDES.',
-        ...lines,
-        `</${PREFERENCES_TAG}>`,
-    ].join('\n');
-}
-/** Never clipped: half an instruction is a different instruction. */
-function oneLine(text) {
-    return text.replace(/\s+/g, ' ').trim();
-}
-//# sourceMappingURL=instructions.js.map