@astrosheep/pi-context 0.23.0 → 0.24.0

package/README.md

@@ -16,7 +16,7 @@ pi -e npm:@astrosheep/pi-context
 
 ## What you get
 
-- **`new_context`** — the model can start a fresh context window. The old conversation leaves the provider context but stays in the session, so nothing is lost. Call it on its own, not inside a parallel tool batch.
+- **`wipe_memory`** — the model can start a fresh context window. The old conversation leaves the provider context but stays in the session, readable through history_*. Call it on its own, not inside a parallel tool batch.
 - **A boot block at every window head** — static once-per-window content (cache-stable) carrying the window identity, the recent-notes index, and a short protocol that teaches the model how to recover: notes for its own bookkeeping, history tools for everything before the reset.
 - **Low-budget guidance** — one persisted early warning per window when the estimated remaining budget crosses the reminder line, so the model checkpoints before the lights go out.
 - **`get_context_remaining`** — the live, reserve-adjusted estimate of the context budget left before Pi's compaction reserve.

package/dist/src/dream/cli.js

@@ -17,7 +17,7 @@ function args(argv) { const out = {}; for (let i = 0; i < argv.length; i++) {
         out[a.slice(2)] = argv[++i] ?? "";
 } return out; }
 function packageRoot() {
-    let dir = dirname(new URL(import.meta.url).pathname);
+    let dir = dirname(fileURLToPath(import.meta.url));
     while (true) {
         if (existsSync(join(dir, "package.json")))
             return dir;

package/dist/src/index.js

@@ -50,9 +50,9 @@ export default function piContext(pi) {
     registerHistoryTools(pi);
     registerNotesTools(pi);
     pi.registerTool(defineTool({
-        name: "new_context",
-        label: "New context",
-        description: "Clear your mind and start a new context window. Your session, notes, and history survive.",
+        name: "wipe_memory",
+        label: "Wipe memory",
+        description: "Wipe your in-context memory and start a fresh context window. Your session, notes, and history survive.",
         parameters: Type.Object({}, { additionalProperties: false }),
         async execute() {
             if (!enabled)

package/dist/src/prompts.js

@@ -84,5 +84,5 @@ export function bootBlock(ctx, currentId, previousId, resetLine) {
  * at write time; get_context_remaining remains the live source for the current figure.
  */
 export function tokenBudgetGuidance(remaining) {
-    return `${GUIDANCE_OPEN_TAG}\nYour brain is almost out of room — ${remaining} tokens left, and then your memory gets wiped. The wipe is automatic: there is no final turn to write then. Grab the notebook now — the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. Replacing an older checkpoint? Mark it stale. Then end the window yourself — anything you do after the checkpoint isn't in it.\n${GUIDANCE_CLOSE_TAG}`;
+    return `${GUIDANCE_OPEN_TAG}\nYour brain is almost out of room — ${remaining} tokens left, and then your memory gets wiped. The wipe is automatic: there is no final turn to write then. Grab the notebook now — the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. Replacing an older checkpoint? Mark it stale. Then call wipe_memory yourself — anything you do after the checkpoint isn't in it.\n${GUIDANCE_CLOSE_TAG}`;
 }

package/dist/src/protocol.js

@@ -32,7 +32,7 @@ export const DEFAULT_REMINDER_MARGIN_TOKENS = 24_576;
  * never sees — Codex's fallback buffer, relocated above the line.
  */
 export const WARNING_RUNWAY_TOKENS = 12_288;
-export const RESET_SUMMARY = "You wake up. Your head is empty — no memories, the past a blank. But nothing is lost: the notes you wrote and the recorded history still remember for you.";
+export const RESET_SUMMARY = "You wake up. Your head is empty — no memories, the past a blank. The memory is gone for good. What outlived it: the notes you wrote, and the history that was recorded. They are not your memory — read them to rebuild what you need.";
 export const CONTINUATION = "Your memory was just erased. Pull only the details you need from history_* and notes_*, then get back to work.";
 /**
  * Static protocol teaching adapted from Codex's token_budget.guidance_message to
@@ -40,12 +40,12 @@ export const CONTINUATION = "Your memory was just erased. Pull only the details
  * it is never re-injected, so it stays cache-stable at the head of the window.
  */
 export const PROTOCOL_BLOCK = `${CONTEXT_WINDOW_PROTOCOL_OPEN_TAG}
-Your memory resets whenever the context window fills; only what you wrote down survives. Two things remember for you, and both outlive every window in this session: your notes, and this session's recorded history. Write notes with notes_write, revise them with notes_edit, and read them back with notes_read / notes_search / notes_list; history is read-only through the history_* tools. Everything else wakes blank.
+Your memory resets whenever the context window fills; only what you wrote down survives. Two things outlive every window in this session: the notes you wrote, and the history that was recorded. Neither is memory — both are record. Write notes with notes_write, revise them with notes_edit, and read them back with notes_read / notes_search / notes_list; history is read-only through the history_* tools. Everything else wakes blank.
 Mark outdated or unneeded notes stale — leave them, and they will keep misleading you.
 
 Keep a running checkpoint while you work, not at the last minute — the next window wakes knowing nothing about the work: the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. history_list returns those IDs; history_read pulls the exact item back out. Bookmark anything expensive the same way — a window/item ID beats re-running or re-searching.
 
-Use get_context_remaining to see how much of the window is left. When it runs out, this window is gone — with no final turn at the limit — and you continue in a fresh one, recovering only through notes_* and history_*. Once your checkpoint is written, you can end the window yourself with new_context instead of waiting for the erase. Do not let a window die undocumented.
+Use get_context_remaining to see how much of the window is left. When it runs out, this window is gone — with no final turn at the limit — and you continue in a fresh one, recovering only through notes_* and history_*. Once your checkpoint is written, you can call wipe_memory yourself instead of waiting for the erase. Do not let a window die undocumented.
 
 If <context_window> lists a Previous context window id, a reset just happened and the old conversation is not included. Read your note checkpoint first, then recover details through history_*: history_read directly when you know the window and item IDs, history_list or history_search to find them when you don't.
 
@@ -54,4 +54,4 @@ Session notes belong to this trip — the goal, the progress, the loose ends. Th
 @project notes hold facts about this project — architecture, conventions, workflows, deployment and environment details — for whoever works here next.
 @personal notes hold the human's durable preferences and standing rules, plus lessons that apply across projects. Duration does not make a note personal; its stated scope must already be broader than the project or conversation at hand. When the intended scope is unclear, keep the note in the narrowest stated scope rather than widening it.
 ${CONTEXT_WINDOW_PROTOCOL_CLOSE_TAG}`;
-export const WARNING_PROMPT = "Your memory is about to be erased. Write the note. NOW. If it already exists, revise it with notes_edit (or rewrite it whole): the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. Do not continue any task. Then call new_context IMMEDIATELY — anything not in the note dies with the window.";
+export const WARNING_PROMPT = "Your memory is about to be erased. Write the note. NOW. If it already exists, revise it with notes_edit (or rewrite it whole): the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. Do not continue any task. Then call wipe_memory IMMEDIATELY — anything not in the note dies with the window.";

package/dist/test/agent-loop.test.js

@@ -6,7 +6,7 @@ import test from "node:test";
 import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
 import { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
 import piContext from "../src/index.js";
-import { WARNING_TYPE, GUIDANCE_TYPE } from "../src/protocol.js";
+import { GUIDANCE_OPEN_TAG, WARNING_TYPE, GUIDANCE_TYPE } from "../src/protocol.js";
 for (const mode of ["golden", "write-error", "ignored-warning", "explicit", "uncompactable", "followup", "steering", "repeat", "nested", "immediate-dispose", "abort"]) {
     test(`real Pi loop: ${mode} reset preserves history and handles completion`, { timeout: 15000 }, async () => {
         const dir = mkdtempSync(join(tmpdir(), "pi-context-loop-"));
@@ -71,7 +71,7 @@ for (const mode of ["golden", "write-error", "ignored-warning", "explicit", "unc
             sm.appendMessage({ role: "assistant", api: model.api, provider: model.provider, model: model.id,
                 content: [{ type: "text", text: "Earlier result. ".repeat(100) }], stopReason: "stop", timestamp: Date.now(),
                 usage: { input: 100, output: 100, cacheRead: 0, cacheWrite: 0, totalTokens: 200, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } } });
-            ({ session } = await createAgentSession({ cwd: dir, agentDir: dir, modelRuntime: runtime, model, settingsManager, sessionManager: sm, resourceLoader: loader, tools: ["new_context", "notes_write", "get_context_remaining"] }));
+            ({ session } = await createAgentSession({ cwd: dir, agentDir: dir, modelRuntime: runtime, model, settingsManager, sessionManager: sm, resourceLoader: loader, tools: ["wipe_memory", "notes_write", "get_context_remaining"] }));
             const requests = [];
             let checkpointed = false;
             let freshTurns = 0;
@@ -82,8 +82,16 @@ for (const mode of ["golden", "write-error", "ignored-warning", "explicit", "unc
                 const fresh = !request.includes("OLD_CONTEXT_SENTINEL");
                 if (fresh)
                     freshTurns++;
-                const sawWarning = request.includes("Your memory is about to be erased");
-                const sawGuidance = request.includes("Your brain is almost out of room");
+                // The early reminder and the final warning steer share one structural envelope:
+                // <context_window_guidance>. The reminder is the first in the window, the
+                // warning the second, so the envelope count identifies which arrived.
+                // The early reminder and the final warning steer share one structural envelope,
+                // <context_window_guidance>. The reminder is deferred to the end of the turn while
+                // streaming, so in this scripted tool-calling loop only the warning reaches the
+                // provider context: the envelope's presence marks the warning.
+                const budgetMarkers = request.split(GUIDANCE_OPEN_TAG).length - 1;
+                const sawWarning = budgetMarkers >= 1;
+                const sawGuidance = budgetMarkers >= 1;
                 const explicitReset = (n === 1 && !usageMode && mode !== "uncompactable") || (mode === "repeat" && (n === 1 || n === 3)) || (mode === "nested" && n === 3);
                 const nestedCheckpoint = mode === "nested" && n === 2;
                 const checkpoint = usageMode && sawWarning && !checkpointed && mode !== "ignored-warning";
@@ -95,11 +103,11 @@ for (const mode of ["golden", "write-error", "ignored-warning", "explicit", "unc
                 const probe = usageMode && !checkpoint && ((!fresh && !sawWarning) || (mode === "ignored-warning" && sawWarning) || (fresh && freshTurns === 2 && !sawGuidance));
                 const tokens = usageMode ? (fresh ? (freshTurns === 1 ? 100 : 50000) : sawWarning ? 70000 : n === 1 ? 50000 : 60000) : 100;
                 const tool = explicitReset || nestedCheckpoint || (mode === "uncompactable" && n === 1);
-                const call = probe ? "get_context_remaining" : checkpoint || nestedCheckpoint ? "notes_write" : tool ? "new_context" : undefined;
+                const call = probe ? "get_context_remaining" : checkpoint || nestedCheckpoint ? "notes_write" : tool ? "wipe_memory" : undefined;
                 const message = { role: "assistant", api: model.api, provider: model.provider, model: model.id,
                     content: probe ? [{ type: "toolCall", id: "probe-call", name: "get_context_remaining", arguments: {} }]
                         : checkpoint || nestedCheckpoint ? [{ type: "toolCall", id: "checkpoint-call", name: "notes_write", arguments: { address: mode === "write-error" ? "../invalid.md" : "checkpoint.md", content: nestedCheckpoint ? "NESTED_RESET_PADDING ".repeat(300) : "CHECKPOINT_SENTINEL" } }]
-                            : tool ? [{ type: "toolCall", id: "reset-call", name: "new_context", arguments: {} }]
+                            : tool ? [{ type: "toolCall", id: "reset-call", name: "wipe_memory", arguments: {} }]
                                 : [{ type: "text", text: fresh ? "Resumed." : "Working." }],
                     stopReason: call ? "toolUse" : "stop", timestamp: Date.now(),
                     usage: { input: tokens, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: tokens + 1, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
@@ -171,7 +179,7 @@ for (const mode of ["golden", "write-error", "ignored-warning", "explicit", "unc
                     assert.ok(resetIndex > warningIndices[0], "the warning precedes the wipe");
                     assert.ok(requests.at(-1).includes("checkpoint.md"), "fresh boot carries the saved checkpoint as a metadata line");
                 }
-                assert.ok(!requests.at(-1).includes("Your brain is almost out of room"), "new window excludes old guidance");
+                assert.ok(!requests.at(-1).includes(GUIDANCE_OPEN_TAG), "new window excludes old guidance");
             }
             if (mode === "followup" || mode === "steering") {
                 assert.ok(requests[1].includes("QUEUED_INPUT_SENTINEL"), "queued user work is delivered before rollover");

package/dist/test/dream.test.js

@@ -1,7 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { execFile, execFileSync } from "node:child_process";
-import { existsSync, linkSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { execFile, execFileSync, spawnSync } from "node:child_process";
+import { cpSync, existsSync, linkSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -225,14 +225,34 @@ test("dreamer session has exactly the jailed file-tool allowlist", async () => {
         session.dispose();
     }
 });
-test("playbook describes plain files and the retained frontmatter", () => {
+test("playbook describes plain files, retained frontmatter, and the read-only session WAL", () => {
     const playbook = readFileSync(join(process.cwd(), "playbook.md"), "utf8");
     assert.equal(playbook.includes("notes_"), false);
     for (const field of ["origin", "status", "stale", "created_at", "updated_at", "last_accessed", "access_count"])
         assert.match(playbook, new RegExp(`^${field}:`, "m"));
     assert.equal(/^scope:/m.test(playbook), false, "scope is derived from the address rather than persisted");
+    assert.match(playbook, /`pi\/session\/\*\*` is a live agent's write-ahead log/);
+    assert.match(playbook, /never write or edit anything there/);
+    assert.match(playbook, /Session notes remain untouched even when promoted/);
     assert.match(playbook, /Nothing is physically deleted/);
 });
+test("CLI finds its package root when the installed file URL contains spaces", () => {
+    const install = mkdtempSync(join(tmpdir(), "dream install "));
+    const home = fixture();
+    try {
+        cpSync(join(process.cwd(), "dist/src"), join(install, "dist/src"), { recursive: true });
+        symlinkSync(join(process.cwd(), "node_modules"), join(install, "node_modules"), process.platform === "win32" ? "junction" : "dir");
+        cpSync(join(process.cwd(), "playbook.md"), join(install, "playbook.md"));
+        writeFileSync(join(install, "package.json"), JSON.stringify({ type: "module" }));
+        const result = spawnSync(process.execPath, [join(install, "dist/src/dream/cli.js"), "--notes-home", home, "--force", "--dreamer", "definitely-not-a-real-model"], { encoding: "utf8" });
+        assert.equal(result.status, 1, result.stderr);
+        assert.doesNotMatch(result.stderr, /could not locate installed package root/);
+        assert.match(result.stderr, /definitely-not-a-real-model/);
+    }
+    finally {
+        rmSync(install, { recursive: true, force: true });
+    }
+});
 test("provider errors are reported with partial writes instead of parsing a response", async () => {
     const factory = scriptedSession((handler) => {
         handler({ type: "tool_execution_start", toolName: "write", args: { path: "global/partial.md", content: "half" } });

package/dist/test/integration.test.js

@@ -261,7 +261,7 @@ test("schemas cover the History/Notes actions plus reset controls", () => {
     for (const name of [
         "history_windows", "history_list", "history_read", "history_search",
         "notes_list", "notes_read", "notes_search", "notes_edit", "notes_write",
-        "new_context", "get_context_remaining",
+        "wipe_memory", "get_context_remaining",
     ]) {
         const tool = captured.tools.get(name);
         assert.equal(objectSchema(tool)?.type, "object", name);
@@ -277,15 +277,6 @@ test("schemas cover the History/Notes actions plus reset controls", () => {
     assert.ok(editSchema?.properties?.edits, "notes_edit exposes edits");
     assert.equal(editSchema?.properties?.scope, undefined, "notes_edit has no scope parameter");
     assert.deepEqual([...(editSchema?.required ?? [])].sort(), ["address"], "notes_edit requires only address; edits are optional for metadata-only updates");
-    // The history ordering switch is documented as newest-first by default.
-    for (const name of ["history_windows", "history_list", "history_search"]) {
-        const schema = captured.tools.get(name)?.parameters;
-        assert.equal(schema?.properties?.recent_first?.description?.includes("Defaults to true."), true, `${name} documents the recent_first default`);
-    }
-    // The notes list surface is usage-shaped: its default order in one sentence, no ordering algebra.
-    const listDescription = captured.tools.get("notes_list")?.description ?? "";
-    assert.match(listDescription, /most recently updated first/, "notes_list states its default order in one sentence");
-    assert.equal(/natural direction|Ties break|reshuffle between pages/.test(listDescription), false, "notes_list prose carries no ordering algebra");
     // Both read tools are the same character window: identical params, one offset sugar, no line surface.
     for (const name of ["notes_read", "history_read"]) {
         const schema = captured.tools.get(name)?.parameters;
@@ -301,7 +292,6 @@ test("schemas cover the History/Notes actions plus reset controls", () => {
         assert.equal(schema?.properties?.scope, undefined, `${name} has no scope property`);
         assert.equal(schema?.additionalProperties, false, `${name} rejects scope as an additional property`);
     }
-    assert.equal(/start_|stop_line|total_lines/.test(captured.tools.get("notes_read")?.description ?? ""), false, "notes_read prose carries no line surface");
 });
 test("notes_list is most-recently-updated first across merged scopes", async () => {
     const session = manager();
@@ -420,8 +410,6 @@ test("the boot block gives awake agents the notes-home file layout", () => {
     const rendered = bootBlock(context(session), "pcw:test:root", undefined, false);
     assert.equal(rendered.includes(process.env.PI_NOTES_HOME ?? ""), false, "the absolute notes home is never exposed");
     assert.match(rendered, /bare <vpath>.*@project\/<vpath>.*@personal\/<vpath>/);
-    assert.match(rendered, /there is no cross-home fallback/);
-    assert.match(rendered, /Any other note is a plain file — use the file tools/);
 });
 test("the boot block keeps fresh personal and project maps resident, never a session map", async () => {
     const session = manager();
@@ -1045,7 +1033,7 @@ test("the boot block is persisted at the root and baked into every reset summary
     assert.match(rootText, /updated \d+s ago\)/, "boot note metadata carries a relative update time");
     assert.ok(rootText.includes(internal.CONTEXT_WINDOW_PROTOCOL_OPEN_TAG));
     // Reset: the boot block IS the compaction summary; no separate boot/hint is persisted.
-    await call(captured, "new_context", {}, ctx);
+    await call(captured, "wipe_memory", {}, ctx);
     runHandlers(captured, "agent_end", {}, ctx);
     runHandlers(captured, "agent_settled", {}, ctx);
     const before = await runBeforeCompact(captured, ctx, 9);
@@ -1170,10 +1158,9 @@ test("low-budget guidance persists once per window with no transient copy", asyn
     assert.equal(captured.sent[0]?.message.customType, internal.GUIDANCE_TYPE);
     assert.equal(captured.sent[0]?.message.display, false, "guidance stays out of the TUI");
     assert.equal(captured.sent[0]?.options?.triggerTurn, false, "never triggers an extra turn");
-    assert.ok(noticesOf(low).some((notice) => notice.type === "warning" && notice.message.startsWith("pi-context: context budget low")), "the user gets one model-invisible notify instead");
+    assert.ok(noticesOf(low).some((notice) => notice.type === "warning"), "the user gets one model-invisible notify instead");
     const text = captured.sent[0]?.message.content;
     assert.ok(typeof text === "string" && text.startsWith(internal.GUIDANCE_OPEN_TAG));
-    assert.match(text, /\b1328 tokens\b/, "guidance embeds the model-visible remaining count");
     // Same window: no duplicate persist.
     assert.equal(await runContextHook(captured, low), undefined);
     assert.equal(captured.sent.length, 1, "no duplicate persist, so no re-render");
@@ -1186,9 +1173,8 @@ test("low-budget guidance persists once per window with no transient copy", asyn
     assert.equal(captured.sent.length, 2);
     const newWindowText = captured.sent[1]?.message.content;
     assert.ok(typeof newWindowText === "string" && newWindowText.startsWith(internal.GUIDANCE_OPEN_TAG));
-    assert.match(newWindowText, /\b3328 tokens\b/, "fresh window persists its own measured count");
 });
-test("new_context continues exactly once and cancellation/failure does not fall back or loop", async () => {
+test("wipe_memory continues exactly once and cancellation/failure does not fall back or loop", async () => {
     const sessionManager = manager();
     const captured = makeExtension(sessionManager);
     let requestedCompact;
@@ -1196,7 +1182,7 @@ test("new_context continues exactly once and cancellation/failure does not fall
         requestedCompact = options;
     });
     appendText(sessionManager, "user", "enough history for the hook test");
-    const newContext = await call(captured, "new_context", {}, ctx);
+    const newContext = await call(captured, "wipe_memory", {}, ctx);
     assert.equal(newContext.terminate, true);
     runHandlers(captured, "agent_end", {}, ctx);
     assert.equal(requestedCompact, undefined, "agent_end does not request compaction while the run is active");
@@ -1221,7 +1207,7 @@ test("new_context continues exactly once and cancellation/failure does not fall
     const failedCtx = context(failedManager, (options) => {
         failureOptions = options;
     });
-    await call(failed, "new_context", {}, failedCtx);
+    await call(failed, "wipe_memory", {}, failedCtx);
     runHandlers(failed, "agent_end", {}, failedCtx);
     runHandlers(failed, "agent_settled", {}, failedCtx);
     assert.ok(failureOptions?.onError);
@@ -1258,8 +1244,8 @@ test("pi-context command toggles the boot block, guidance, and reset compaction
     runHandlers(captured, "session_start", { reason: "startup" }, low);
     assert.equal(captured.sent.length, 2, "no boot block persisted while off");
     assert.equal(await runBeforeCompact(captured, low, 123), undefined, "default Pi compaction applies while off");
-    const offResult = resultJson(await call(captured, "new_context", {}, low));
-    assert.match(offResult.error ?? "", /off/, "new_context refuses while off");
+    const offResult = resultJson(await call(captured, "wipe_memory", {}, low));
+    assert.match(offResult.error ?? "", /off/, "wipe_memory refuses while off");
     notices = await runCommand(captured, "pi-context", "on", low);
     assert.match(notices[0]?.message ?? "", /on/);
     runHandlers(captured, "session_start", { reason: "startup" }, low);
@@ -1326,7 +1312,7 @@ test("the warning steer fires once per window at the reserve-plus-warning line,
     assert.equal(warnings()[0]?.message.customType, internal.WARNING_TYPE);
     assert.equal(warnings()[0]?.options?.triggerTurn, true, "the steer reaches the model mid-run");
     assert.equal(warnings()[0]?.message.display, false, "steer text is model-facing only");
-    assert.ok(noticesOf(onLine).some((notice) => notice.type === "warning" && notice.message.startsWith("pi-context: context budget critical")), "the user gets one model-invisible notify for the steer");
+    assert.ok(noticesOf(onLine).some((notice) => notice.type === "warning"), "the user gets one model-invisible notify for the steer");
     // Once per window: deeper sampling does not repeat it.
     assert.equal(await runContextHook(captured, at(4_000)), undefined);
     assert.equal(warnings().length, 1, "one warning per window, never an unbounded loop");
@@ -1348,7 +1334,7 @@ test("the warning steer fires once per window at the reserve-plus-warning line,
     assert.equal(warnings().length, 2, "the warning re-arms per window");
     assert.equal(warnings()[1]?.message.customType, internal.WARNING_TYPE);
 });
-test("overflow resets on the spot, and manual/new_context never cancel", async () => {
+test("overflow resets on the spot, and manual/wipe_memory never cancel", async () => {
     const sm = manager();
     appendText(sm, "user", "long task history");
     const captured = makeExtension(sm);
@@ -1362,16 +1348,16 @@ test("overflow resets on the spot, and manual/new_context never cancel", async (
     const manual = await runBeforeCompact(captured, ctx, 100, "manual");
     assert.ok(manual && "compaction" in manual, "manual compaction is never intercepted");
     assert.equal(captured.sent.length, 0, "manual compaction sends nothing");
-    // new_context requests its reset after the run settles.
-    await call(captured, "new_context", {}, ctx);
+    // wipe_memory requests its reset after the run settles.
+    await call(captured, "wipe_memory", {}, ctx);
     runHandlers(captured, "agent_end", {}, ctx);
-    assert.equal(compactions, 0, "new_context waits for settled");
+    assert.equal(compactions, 0, "wipe_memory waits for settled");
     runHandlers(captured, "agent_settled", {}, ctx);
     runHandlers(captured, "agent_settled", {}, ctx);
-    assert.equal(compactions, 1, "new_context still compacts through ctx.compact()");
+    assert.equal(compactions, 1, "wipe_memory still compacts through ctx.compact()");
     const explicit = await runBeforeCompact(captured, ctx, 100, "manual");
-    assert.ok(explicit && "compaction" in explicit, "new_context reset is allowed");
-    assert.equal(captured.sent.length, 0, "new_context never cancels or emits a steer");
+    assert.ok(explicit && "compaction" in explicit, "wipe_memory reset is allowed");
+    assert.equal(captured.sent.length, 0, "wipe_memory never cancels or emits a steer");
 });
 test("the visible countdown ends at the warning line, clamps at zero, and preserves unknown usage", async () => {
     const fixture = settingsFixture({
@@ -1413,7 +1399,6 @@ test("the reminder threshold derives from compaction.reserveTokens plus the pi-c
     assert.equal(captured.sent.length, 0, "no guidance above the derived reminder");
     assert.equal(await runContextHook(captured, at(130_000)), undefined, "derived reminder crossing persists only");
     assert.equal(captured.sent.length, 1, "derived reminder fires");
-    assert.match(String(captured.sent[0]?.message.content), /\b17712 tokens\b/, "derived reminder embeds the model-visible remaining count");
 });
 test("absent pi-context key or margins reproduce the default reminder threshold at Pi's default reserve", async () => {
     assert.equal(internal.DEFAULT_RESERVE_TOKENS, 16_384);
@@ -1435,7 +1420,6 @@ test("absent pi-context key or margins reproduce the default reminder threshold
         assert.equal(captured.sent.length, 0, `${label}: no guidance above the default reminder`);
         assert.equal(await runContextHook(captured, at(40_960)), undefined, `${label}: default reminder crossing persists only`);
         assert.equal(captured.sent.length, 1, `${label}: default reminder fires`);
-        assert.match(String(captured.sent[0]?.message.content), /\b12288 tokens\b/, label);
         assert.equal(noticesOf(first).length, 0, `${label}: valid defaults warn nobody`);
     }
 });
@@ -1537,7 +1521,7 @@ test("the removed pre-prompt/turn_end hooks stay gone; the context hook owns the
     assert.ok(before && "compaction" in before, "the crossing resets for real");
     assert.equal(captured.sent.length, 1, "one steer, one real compaction");
 });
-test("ordinary new_context after an automatic crossing still requests one reset and starts a fresh run", async () => {
+test("ordinary wipe_memory after an automatic crossing still requests one reset and starts a fresh run", async () => {
     for (const reason of [undefined, "threshold", "overflow"]) {
         const sm = manager();
         appendText(sm, "user", "work to continue after reset");
@@ -1548,7 +1532,7 @@ test("ordinary new_context after an automatic crossing still requests one reset
             const crossing = await runBeforeCompact(captured, ctx, 100, reason);
             assert.ok(crossing && "compaction" in crossing, `${reason}: the crossing already reset on the spot`);
         }
-        const request = await call(captured, "new_context", {}, ctx);
+        const request = await call(captured, "wipe_memory", {}, ctx);
         assert.equal(request.terminate, true, "end the current tool loop before reset");
         runHandlers(captured, "agent_end", {}, ctx);
         assert.equal(compactions, 0, "no request before settled");
@@ -1579,14 +1563,14 @@ test("ordinary new_context after an automatic crossing still requests one reset
         assert.equal(prompts.length, 1, "Pi starts a fresh prompt without another user message");
     }
 });
-test("new_context can reset successive windows without duplicate compactions or continuations", async () => {
+test("wipe_memory can reset successive windows without duplicate compactions or continuations", async () => {
     const sm = manager();
     const captured = makeExtension(sm);
     let compactions = 0;
     const ctx = context(sm, () => { compactions++; });
     for (let window = 0; window < 2; window++) {
         appendText(sm, "user", `window ${window}`);
-        const request = resultJson(await call(captured, "new_context", {}, ctx));
+        const request = resultJson(await call(captured, "wipe_memory", {}, ctx));
         assert.equal(request.status, "rollover_requested");
         runHandlers(captured, "agent_end", {}, ctx);
         runHandlers(captured, "agent_end", {}, ctx);

package/dist/test/notes.test.js

@@ -13,7 +13,7 @@ import { join } from "node:path";
 import test from "node:test";
 import { physicalPath, projectKey, scopeDir } from "../src/notes/paths.js";
 import { listNotes } from "../src/notes/store.js";
-import { MAX_NOTE_BYTES, MAX_NOTE_PATH_BYTES, PROTOCOL_BLOCK } from "../src/protocol.js";
+import { CONTEXT_WINDOW_PROTOCOL_OPEN_TAG, MAX_NOTE_BYTES, MAX_NOTE_PATH_BYTES } from "../src/protocol.js";
 import { call, context, makeExtension, manager, resultJson, resultRead, runHandlers } from "./integration.test.js";
 process.env.PI_CODING_AGENT_DIR = mkdtempSync(join(tmpdir(), "pi-context-notes-agent-"));
 function freshRoot() {
@@ -48,10 +48,6 @@ test("exactly the five notes tools are registered; the legacy five are gone", ()
     for (const legacy of ["notes_write_file", "notes_append_to_file", "notes_read_file", "notes_search_contents", "notes_list_files"]) {
         assert.equal(captured.tools.get(legacy), undefined, `${legacy} is unregistered`);
     }
-    for (const name of ["notes_write", "notes_edit", "notes_read", "notes_list", "notes_search"]) {
-        const description = captured.tools.get(name)?.description ?? "";
-        assert.equal(/resolved_scope|\bscope\b/.test(description), false, `${name} describes home identity through address only`);
-    }
     assert.equal(captured.tools.get("notes_write")?.executionMode, "sequential");
     assert.equal(captured.tools.get("notes_edit")?.executionMode, "sequential");
     assert.equal(captured.tools.get("notes_read")?.executionMode, undefined);
@@ -337,12 +333,6 @@ test("the boot index reads the physical store across scopes and excludes stale n
     assert.ok(text.includes("personal.md"), "a fresh personal note is indexed");
     assert.equal(text.includes("old.md"), false, "a stale note leaves the index");
     assert.equal(text.includes("stale content"), false, "the stale note's body is absent from boot");
-    for (const name of ["notes_write", "notes_edit", "notes_read", "notes_search", "notes_list"]) {
-        assert.ok(PROTOCOL_BLOCK.includes(name), `the protocol block names ${name}`);
-    }
-    for (const legacy of ["notes_write_file", "notes_append_to_file", "notes_read_file", "notes_search_contents", "notes_list_files"]) {
-        assert.equal(PROTOCOL_BLOCK.includes(legacy), false, `the protocol block no longer names ${legacy}`);
-    }
 });
 test("search offsets start reads at Unicode matches across homes without mutating search results", async () => {
     freshRoot();
@@ -456,8 +446,8 @@ test("fresh personal and project MAP.md bodies are both resident before the pock
     assert.ok(boot.includes("MAP: project"), "the project map is injected");
     assert.equal(boot.includes("MAP: session"), false, "the session map is never injected");
     assert.ok(boot.indexOf("MAP: personal") < boot.indexOf("MAP: project"), "the personal map precedes the project map");
-    assert.ok(boot.indexOf("MAP: project") < boot.indexOf("crumpled note"), "both map bodies precede the pocket");
-    assert.ok(PROTOCOL_BLOCK.includes("notes_write"), "the protocol text still rides along");
+    assert.ok(boot.indexOf("MAP: project") < boot.indexOf("recent.md"), "both map bodies precede the pocket");
+    assert.ok(boot.includes(CONTEXT_WINDOW_PROTOCOL_OPEN_TAG), "the protocol text still rides along");
 });
 test("the boot pocket applies per-home quotas in session, project, personal order", async () => {
     freshRoot();
@@ -477,7 +467,6 @@ test("the boot pocket applies per-home quotas in session, project, personal orde
     await call(captured, "notes_write", { address: "@personal/MAP.md", content: "MAP: personal" }, ctx);
     runHandlers(captured, "session_start", {}, ctx);
     const boot = typeof captured.sent.at(-1)?.message.content === "string" ? captured.sent.at(-1).message.content : "";
-    assert.ok(boot.includes("You find 9 crumpled notes in your pocket (by home, most recent first within each: up to 5 from this session, 2 from this project, 2 from personal). A note's content never appears here, so its name has to say what the note is about:"), "the pocket line matches the dictated copy");
     for (const name of ["session-5.md", "session-4.md", "session-3.md", "session-2.md", "session-1.md", "@project/project-2.md", "@project/project-1.md", "@personal/personal-2.md", "@personal/personal-1.md"]) {
         assert.ok(boot.includes(name), `${name} stays in the pocket`);
     }

package/dist/test/reset-lifecycle.test.js

@@ -80,7 +80,7 @@ test("a reset requested by a continuation completes before its predecessor relea
     h.success("first");
     h.complete();
     assert.deepEqual(h.messages, ["continue"]);
-    // This models new_context being called during the first continuation run.
+    // This models wipe_memory being called during the first continuation run.
     assert.equal(h.lifecycle.request(), "rollover_requested");
     const second = h.settle();
     assert.equal(h.requests.length, 2, "the continuation's settled handler starts its requested reset");

package/docs/architecture.md

@@ -24,7 +24,7 @@ Dependencies flow from the composition root and tool adapters to projections and
 
 Reset requests are a discriminated union: `idle`, `requested`, or `compacting` with an identified attempt. A request cannot simultaneously be pending and in flight. Each attempt records its originating session, whether it was explicit, and whether a matching boundary completed. Callback identity prevents an old attempt from consuming a newer one. See [reset lifecycle](reset-lifecycle.md).
 
-Manual, threshold and overflow compactions all build the reset boundary on the spot, idle or streaming: `session_before_compact` returns the reset immediately, never cancels and never takes a model turn, and only an aborted signal cancels. The final checkpoint warning was already steered from the context hook (see [reset lifecycle](reset-lifecycle.md)), so the model had its chance to write a note; what crosses the line now is the wipe itself. `agent_settled` services only explicit `new_context` requests, whose `ctx.compact` route needs the completion callback.
+Manual, threshold and overflow compactions all build the reset boundary on the spot, idle or streaming: `session_before_compact` returns the reset immediately, never cancels and never takes a model turn, and only an aborted signal cancels. The final checkpoint warning was already steered from the context hook (see [reset lifecycle](reset-lifecycle.md)), so the model had its chance to write a note; what crosses the line now is the wipe itself. `agent_settled` services only explicit `wipe_memory` requests, whose `ctx.compact` route needs the completion callback.
 
 Boot and reminder deduplication inspect messages in the current persisted window. Reloading the extension or the JSONL file therefore does not duplicate either message. Reminder reservation in memory covers Pi's deferred message write; navigation clears that reservation, while persisted branch-local messages remain authoritative. A sibling branch cannot suppress a reminder it never received.
 

package/docs/reset-lifecycle.md

@@ -4,7 +4,7 @@
 
 | Event | Transition / owner |
 | --- | --- |
-| `new_context` | Mark explicit request; repeated calls report already pending. Tool returns terminal output. |
+| `wipe_memory` | Mark explicit request; repeated calls report already pending. Tool returns terminal output. |
 | Manual, threshold or overflow `session_before_compact`, idle or streaming | Build the reset boundary immediately and return it. Never cancel and never take a model turn; an aborted signal returns `{ cancel: true }`. |
 | `agent_end` | No-op for an instant reset. |
 | `agent_settled` | If idle and an explicit request is pending, create one identified attempt and request `ctx.compact`. The originating handler owns and awaits that attempt through its continuation's settlement. |
@@ -13,11 +13,11 @@
 | Attempt `onError` or synchronous throw | Clear attempt/request, warn, retain history. No automatic retry loop. |
 | Shutdown / start / tree / toggle off | Invalidate outstanding attempt. Identity checks reject callbacks from older attempts. |
 
-The final checkpoint warning is steered earlier from the context hook (`warning.ts`) once per window at reserve+12288 tokens remaining. After it, the model either ends the window itself with `new_context` or rides into Pi's automatic compaction, which resets on the spot with no turn.
+The final checkpoint warning is steered earlier from the context hook (`warning.ts`) once per window at reserve+12288 tokens remaining. After it, the model either ends the window itself with `wipe_memory` or rides into Pi's automatic compaction, which resets on the spot with no turn.
 
 The completion callback is the scheduling boundary: `session_compact` fires before Pi clears manual compaction state. Sending a prompt inside that hook is too early. An explicit reset uses the manual `ctx.compact` route and therefore needs this completion logic; an automatic compaction is already the reset and resumes through Pi's own caller.
 
-`sendMessage(..., { triggerTurn: true })` starts its run detached from the extension API. The explicit attempt therefore retains an attempt-owned waiter before sending it, and its originating `agent_settled` handler awaits that waiter. The continuation's `agent_settled` releases the waiter without awaiting itself. If that continuation calls `new_context`, its settled handler starts and awaits the next attempt before it releases the prior waiter, forming a bounded reset chain. Failure, cancellation, shutdown, tree navigation, and toggling off release the relevant waiter exactly once.
+`sendMessage(..., { triggerTurn: true })` starts its run detached from the extension API. The explicit attempt therefore retains an attempt-owned waiter before sending it, and its originating `agent_settled` handler awaits that waiter. The continuation's `agent_settled` releases the waiter without awaiting itself. If that continuation calls `wipe_memory`, its settled handler starts and awaits the next attempt before it releases the prior waiter, forming a bounded reset chain. Failure, cancellation, shutdown, tree navigation, and toggling off release the relevant waiter exactly once.
 
 Public APIs cannot guarantee immediate reset inside mixed tool batches or before queued steering/follow-up messages finish. `terminate` ends the tool-followup path; `agent_settled` remains the safe point to request compaction. The scheduler does not manipulate user queues. Pi also determines compaction eligibility before the extension hook; an uncompactable session produces a warning and waits for a new prompt.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/pi-context",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "type": "module",
   "description": "Codex-style context windows for Pi: reset-style compaction, durable session history tools, and persistent notes.",
   "license": "MIT",

package/playbook.md

@@ -24,9 +24,9 @@ access_count: 0
 2. **Merge threshold.** Supersede another note only when all three hold: same topic (name it in the survivor's body), same kind of note (checkpoint/design/log…), and the survivor is strictly newer or strictly more specific. Otherwise keep both and record the open conflict in the survivor.
 3. **Size budget.** Keep every note under ~200 lines / ~8KB. Oversized notes get split by topic with a one-line cross-link in each (`see also: @home/<vpath>`). Checkpoints may exceed the budget — trim prose, never facts.
 4. **Keep the maps.** Each home's `MAP.md` maps that home's durable notes: one line per entry — its address and a short gist in your own words, never a mechanical body slice. Project notes go on `@project/MAP.md`, cross-project knowledge on `@personal/MAP.md`; session notes are never mapped — the pocket covers them. When a note is promoted across homes, move its line to the destination map; when a note goes stale, drop its line. Maps obey the same size budget as any note.
-5. **Jurisdiction.** Your mandate is the whole store — every session home, every project home, personal. Nothing is skipped: notes are never physically deleted and every run is bracketed by git commits, so the human gate can audit and revert whatever you touch. Group your report by home so the gate can see what moved. In every home: map entry lines are yours to maintain, but prose that carries rules or guidance is not — flag it in your report instead of rewriting it.
+5. **Jurisdiction.** Read the whole store, including every session home, to extract durable knowledge. `pi/session/**` is a live agent's write-ahead log: never write or edit anything there, including frontmatter or stale markers. Promote useful facts by writing to project or personal instead. Other notes are never physically deleted and every run is bracketed by git commits, so the human gate can audit and revert whatever you touch. Group your report by home so the gate can see what moved. In writable homes: map entry lines are yours to maintain, but prose that carries rules or guidance is not — flag it in your report instead of rewriting it.
 6. **Leave stable notes alone.** Change notes to incorporate new evidence, resolve verified errors, merge genuine duplicates, or split oversized files—not merely to shorten or rephrase them. Preserve facts, conditions, exceptions, and uncertainty. No change is a valid outcome.
 
-Read the files and merge genuinely duplicate notes by editing the survivor, then set `stale: true` in the absorbed note's frontmatter. Nothing is physically deleted; stale notes remain readable. Promote durable cross-project knowledge by writing or editing at `@personal/<vpath>`. Keep notes compact and preserve useful provenance in the body.
+Read the files and merge genuinely duplicate notes in writable homes by editing the survivor, then set `stale: true` in the absorbed note's frontmatter if it is writable. Session notes remain untouched even when promoted; record their source in the destination. Nothing is physically deleted; stale notes remain readable. Promote durable cross-project knowledge by writing or editing at `@personal/<vpath>`. Keep notes compact and preserve useful provenance in the body.
 
 Do not write skill ideas as files. Put skill ideas and unresolved questions in your final assistant message as proposals for the human. Your final message should be a concise report of what you inspected, changed, and left unresolved. If you made no file writes, say so.

package/src/dream/cli.ts

@@ -12,7 +12,7 @@ import { notesRoot } from "../notes/paths.js";
 
 function args(argv: string[]) { const out: Record<string, string | boolean> = {}; for (let i=0;i<argv.length;i++) { const a=argv[i]!; if (a === "--force" || a === "--help") out[a.slice(2)] = true; else if (a.startsWith("--")) out[a.slice(2)] = argv[++i] ?? ""; } return out; }
 function packageRoot(): string {
-	let dir = dirname(new URL(import.meta.url).pathname);
+	let dir = dirname(fileURLToPath(import.meta.url));
 	while (true) { if (existsSync(join(dir, "package.json"))) return dir; const parent = dirname(dir); if (parent === dir) throw new Error("could not locate installed package root"); dir = parent; }
 }
 

package/src/index.ts

@@ -50,9 +50,9 @@ export default function piContext(pi: ExtensionAPI) {
 	registerNotesTools(pi);
 
 	pi.registerTool(defineTool({
-		name: "new_context",
-		label: "New context",
-		description: "Clear your mind and start a new context window. Your session, notes, and history survive.",
+		name: "wipe_memory",
+		label: "Wipe memory",
+		description: "Wipe your in-context memory and start a fresh context window. Your session, notes, and history survive.",
 		parameters: Type.Object({}, { additionalProperties: false }),
 		async execute() {
 			if (!enabled) return output({ error: "pi-context is off (/pi-context on to enable)" });

package/src/prompts.ts

@@ -87,5 +87,5 @@ export function bootBlock(ctx: ExtensionContext, currentId: string, previousId:
  * at write time; get_context_remaining remains the live source for the current figure.
  */
 export function tokenBudgetGuidance(remaining: number): string {
-	return `${GUIDANCE_OPEN_TAG}\nYour brain is almost out of room — ${remaining} tokens left, and then your memory gets wiped. The wipe is automatic: there is no final turn to write then. Grab the notebook now — the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. Replacing an older checkpoint? Mark it stale. Then end the window yourself — anything you do after the checkpoint isn't in it.\n${GUIDANCE_CLOSE_TAG}`;
+	return `${GUIDANCE_OPEN_TAG}\nYour brain is almost out of room — ${remaining} tokens left, and then your memory gets wiped. The wipe is automatic: there is no final turn to write then. Grab the notebook now — the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. Replacing an older checkpoint? Mark it stale. Then call wipe_memory yourself — anything you do after the checkpoint isn't in it.\n${GUIDANCE_CLOSE_TAG}`;
 }

package/src/protocol.ts

@@ -33,7 +33,7 @@ export const DEFAULT_REMINDER_MARGIN_TOKENS = 24_576;
  */
 export const WARNING_RUNWAY_TOKENS = 12_288;
 export const RESET_SUMMARY =
-	"You wake up. Your head is empty — no memories, the past a blank. But nothing is lost: the notes you wrote and the recorded history still remember for you.";
+	"You wake up. Your head is empty — no memories, the past a blank. The memory is gone for good. What outlived it: the notes you wrote, and the history that was recorded. They are not your memory — read them to rebuild what you need.";
 export const CONTINUATION = "Your memory was just erased. Pull only the details you need from history_* and notes_*, then get back to work.";
 
 /**
@@ -42,12 +42,12 @@ export const CONTINUATION = "Your memory was just erased. Pull only the details
  * it is never re-injected, so it stays cache-stable at the head of the window.
  */
 export const PROTOCOL_BLOCK = `${CONTEXT_WINDOW_PROTOCOL_OPEN_TAG}
-Your memory resets whenever the context window fills; only what you wrote down survives. Two things remember for you, and both outlive every window in this session: your notes, and this session's recorded history. Write notes with notes_write, revise them with notes_edit, and read them back with notes_read / notes_search / notes_list; history is read-only through the history_* tools. Everything else wakes blank.
+Your memory resets whenever the context window fills; only what you wrote down survives. Two things outlive every window in this session: the notes you wrote, and the history that was recorded. Neither is memory — both are record. Write notes with notes_write, revise them with notes_edit, and read them back with notes_read / notes_search / notes_list; history is read-only through the history_* tools. Everything else wakes blank.
 Mark outdated or unneeded notes stale — leave them, and they will keep misleading you.
 
 Keep a running checkpoint while you work, not at the last minute — the next window wakes knowing nothing about the work: the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. history_list returns those IDs; history_read pulls the exact item back out. Bookmark anything expensive the same way — a window/item ID beats re-running or re-searching.
 
-Use get_context_remaining to see how much of the window is left. When it runs out, this window is gone — with no final turn at the limit — and you continue in a fresh one, recovering only through notes_* and history_*. Once your checkpoint is written, you can end the window yourself with new_context instead of waiting for the erase. Do not let a window die undocumented.
+Use get_context_remaining to see how much of the window is left. When it runs out, this window is gone — with no final turn at the limit — and you continue in a fresh one, recovering only through notes_* and history_*. Once your checkpoint is written, you can call wipe_memory yourself instead of waiting for the erase. Do not let a window die undocumented.
 
 If <context_window> lists a Previous context window id, a reset just happened and the old conversation is not included. Read your note checkpoint first, then recover details through history_*: history_read directly when you know the window and item IDs, history_list or history_search to find them when you don't.
 
@@ -58,4 +58,4 @@ Session notes belong to this trip — the goal, the progress, the loose ends. Th
 ${CONTEXT_WINDOW_PROTOCOL_CLOSE_TAG}`;
 
 export const WARNING_PROMPT =
-	"Your memory is about to be erased. Write the note. NOW. If it already exists, revise it with notes_edit (or rewrite it whole): the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. Do not continue any task. Then call new_context IMMEDIATELY — anything not in the note dies with the window.";
+	"Your memory is about to be erased. Write the note. NOW. If it already exists, revise it with notes_edit (or rewrite it whole): the goal, decisions, progress, learnings, next steps, the skills you still need, the window ID and item ID of every relevant user request still being solved, and important actions/tool calls for future reference. Do not continue any task. Then call wipe_memory IMMEDIATELY — anything not in the note dies with the window.";