@astrosheep/pi-context 0.20.0 → 0.21.0

package/src/prompts.ts

@@ -1,8 +1,8 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { historyFromSession } from "./history.js";
-import { localIso } from "./notes.js";
-import { listNotes, peekNote, resolveNoteScope } from "./memory/store.js";
-import { CONTEXT_WINDOW_OPEN_TAG, CONTEXT_WINDOW_CLOSE_TAG, NOTE_PREVIEW_CHARS, NOTE_PREVIEW_HEAD_CHARS, NOTE_PREVIEW_TAIL_CHARS, RESET_SUMMARY, PROTOCOL_BLOCK, GUIDANCE_OPEN_TAG, GUIDANCE_CLOSE_TAG } from "./protocol.js";
+import { localIso } from "./notes/model.js";
+import { listNotes } from "./notes/store.js";
+import { CONTEXT_WINDOW_OPEN_TAG, CONTEXT_WINDOW_CLOSE_TAG, POCKET_GLOBAL_LIMIT, POCKET_PROJECT_LIMIT, POCKET_SESSION_LIMIT, RESET_SUMMARY, PROTOCOL_BLOCK, GUIDANCE_OPEN_TAG, GUIDANCE_CLOSE_TAG } from "./protocol.js";
 
 /** Codex-style <context_window> identity block: agent name and first/current/previous window ids only. */
 function identityBlock(agentName: string, firstWindowId: string, currentWindowId: string, previousWindowId?: string): string {
@@ -16,43 +16,45 @@ function identityBlock(agentName: string, firstWindowId: string, currentWindowId
 }
 
 /**
- * Recent-notes index: up to three most-recent fresh (non-stale) notes. Each note shows its
- * path, line count, UTF-8 byte count and local ISO update time, followed by an indented inline
- * preview: the whole text when it fits in NOTE_PREVIEW_CHARS, otherwise its first
- * NOTE_PREVIEW_HEAD_CHARS and last NOTE_PREVIEW_TAIL_CHARS Unicode characters joined by an
- * explicit ellipsis. The two slices never overlap, so the preview never duplicates head content
- * as tail content. Stale notes are excluded entirely; empty when no fresh notes remain.
+ * Boot notes index. Map residency ("地图在场"): fresh MAP.md bodies from the global and
+ * project homes are both injected, broadest first; stale maps are skipped per home, and the
+ * session home is never peeked — a session MAP.md is an ordinary note. The pocket then lists
+ * recent fresh notes under per-home quotas (POCKET_SESSION_LIMIT / POCKET_PROJECT_LIMIT /
+ * POCKET_GLOBAL_LIMIT), most-recently-updated first within each home, one metadata line
+ * each: address, line count, UTF-8 byte count, local ISO update time. Bodies never render
+ * in the pocket; stale notes are excluded; MAP.md itself never takes a pocket seat.
  */
 function notesIndex(ctx: ExtensionContext): string {
 	const sections: string[] = [];
-	// TOC residency ("地图在场"): the map, when present, is injected whole ahead of the list.
-	const toc = resolveNoteScope(ctx, "TOC.md");
-	if (toc) {
-		const body = peekNote(ctx, toc.scope, "TOC.md").body;
-		if (body.length > 0) sections.push(body);
+	// Map residency ("地图在场"): scope-native maps, both fresh ones injected broadest-first.
+	// A session MAP.md is an ordinary note, never resident; stale maps skip independently.
+	for (const scope of ["global", "project"] as const) {
+		const toc = listNotes(ctx, { scope }).find((row) => row.path === "MAP.md");
+		if (toc && !toc.meta.stale) {
+			if (toc.body.length > 0) sections.push(toc.body);
+		}
 	}
-	// listNotes is already most-recently-updated first; stale notes never reach the index.
-	const recentNotes = listNotes(ctx, {})
-		.filter((row) => !row.meta.stale)
-		.slice(0, 5);
+	// listNotes is most-recently-updated first within each home. Per-home quotas keep session
+	// churn from evicting project or global notes; maps never take pocket seats.
+	const recentNotes = [
+		...listNotes(ctx, { scope: "session" }).filter((row) => !row.meta.stale && row.path !== "MAP.md").slice(0, POCKET_SESSION_LIMIT),
+		...listNotes(ctx, { scope: "project" }).filter((row) => !row.meta.stale && row.path !== "MAP.md").slice(0, POCKET_PROJECT_LIMIT),
+		...listNotes(ctx, { scope: "global" }).filter((row) => !row.meta.stale && row.path !== "MAP.md").slice(0, POCKET_GLOBAL_LIMIT),
+	];
 	if (recentNotes.length > 0) {
-		const lines = [`You find ${recentNotes.length} crumpled note${recentNotes.length === 1 ? "" : "s"} in your pocket (up to 5, most recent first):`];
+		const lines = [`You find ${recentNotes.length} crumpled note${recentNotes.length === 1 ? "" : "s"} in your pocket (by home, most recent first within each: up to ${POCKET_SESSION_LIMIT} from this session, ${POCKET_PROJECT_LIMIT} from this project, ${POCKET_GLOBAL_LIMIT} from global). A note's content never appears here, so its name has to say what the note is about:`];
 		for (const row of recentNotes) {
-			const body = peekNote(ctx, row.meta.scope, row.path).body;
-			lines.push(`- ${row.path} (${body.split("\n").length} lines, ${row.sizeBytes} UTF-8 bytes, updated ${localIso(row.meta.updated_at)})`);
-			const chars = Array.from(body);
-			// Short notes stay whole; long notes keep both ends. head + tail <= NOTE_PREVIEW_CHARS < chars.length,
-			// so the slices are disjoint and no character is shown twice.
-			const preview = chars.length <= NOTE_PREVIEW_CHARS
-				? body
-				: `${chars.slice(0, NOTE_PREVIEW_HEAD_CHARS).join("")}…${chars.slice(chars.length - NOTE_PREVIEW_TAIL_CHARS).join("")}`;
-			lines.push(preview.split("\n").map((line) => `  ${line}`).join("\n"));
+			lines.push(`- ${row.address} (${row.body.split("\n").length} lines, ${row.sizeBytes} UTF-8 bytes, updated ${localIso(row.meta.updated_at)})`);
 		}
 		sections.push(lines.join("\n"));
 	}
 	return sections.join("\n\n");
 }
 
+function notesHomeBlock(): string {
+	return "Notes_* addresses have three homes: bare <vpath> is this session, @project/<vpath> is this project, and @global/<vpath> is global. @ means leaving home; there is no cross-home fallback. Any other note is a plain file — use the file tools.";
+}
+
 /**
  * Assemble the static, once-per-window boot block: the reset line for resets, the
  * <context_window> identity block, the recent-notes index at window-open time, and
@@ -64,6 +66,7 @@ export function bootBlock(ctx: ExtensionContext, currentId: string, previousId:
 	const parts: string[] = [];
 	if (resetLine) parts.push(RESET_SUMMARY);
 	parts.push(identityBlock(ctx.sessionManager.getSessionName() ?? "root", firstId, currentId, previousId));
+	parts.push(notesHomeBlock());
 	const index = notesIndex(ctx);
 	if (index) parts.push(index);
 	parts.push(PROTOCOL_BLOCK);
@@ -78,4 +81,3 @@ export function bootBlock(ctx: ExtensionContext, currentId: string, previousId:
 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}`;
 }
-

package/src/protocol.ts

@@ -7,6 +7,9 @@ export const RESET_MARKER_TYPE = "pi-context/reset-marker";
 export const CONTINUATION_TYPE = "pi-context/continuation";
 export const RESET_V2 = "reset-v2";
 export const MAX_NOTE_BYTES = 1_000_000;
+export const POCKET_SESSION_LIMIT = 5;
+export const POCKET_PROJECT_LIMIT = 2;
+export const POCKET_GLOBAL_LIMIT = 2;
 // Write-time cap on a virtual note path. Deliberately NOT enforced by assertVirtualPath:
 // notesFromSession replays already-persisted operations, which must keep loading sessions
 // that contain a longer legacy path. Reads and replay stay un-capped.
@@ -29,9 +32,6 @@ 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.";
-export const NOTE_PREVIEW_HEAD_CHARS = 80;
-export const NOTE_PREVIEW_TAIL_CHARS = 240;
-export const NOTE_PREVIEW_CHARS = NOTE_PREVIEW_HEAD_CHARS + NOTE_PREVIEW_TAIL_CHARS;
 export const CONTINUATION = "Your memory was just erased. Pull only the details you need from history_* and notes_*, then get back to work.";
 
 /**
@@ -49,7 +49,11 @@ Use get_context_remaining to see how much of the window is left. When it runs ou
 
 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.
 
-Notes are real markdown files scoped session, project, or global — pick scope by reach: session dies with the session, project follows the repo, global follows you. Treat notes and history as internal bookkeeping; never mention them in user-facing messages.
+Your notes live in three homes: this session (bare names), this repo (@project/<vpath>), everywhere you go (@global/<vpath>). @ means leaving home — and homes don't visit each other: there is no cross-home fallback.
+Notes carry what exists nowhere else — what the human told you, what you discovered, where you stand.
+Session notes belong to this trip — the goal, the progress, the loose ends, packed for the road. The next window of THIS trip wakes to them; once the trip is over, nobody does.
+@project notes hold what you learned by working here — the things you only know because you were here — for whoever works here next.
+@global notes travel with you. Every window. Every conversation. Every trip. So before you drop anything in there, ask yourself: does this deserve to stare you in the face every single time you talk to the human? No? Then keep your weird junk OUT.
 ${CONTEXT_WINDOW_PROTOCOL_CLOSE_TAG}`;
 
 export const WARNING_PROMPT =

package/src/thresholds.ts

@@ -60,8 +60,11 @@ export function thresholdsFor(ctx: ExtensionContext): ResolvedThresholds {
 	if (cached) return cached;
 	try {
 		const settingsManager = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() });
+		// Pass the active model so per-model compaction.modelOverrides resolve (SDK 0.86);
+		// on older runtimes the extra argument is ignored and the ordinary setting wins.
+		const model = ctx.model;
 		const derived = deriveThresholds(
-			settingsManager.getCompactionSettings().reserveTokens,
+			settingsManager.getCompactionSettings(model ? { provider: model.provider, id: model.id } : undefined).reserveTokens,
 			mergePiContextSettings(settingsManager.getGlobalSettings(), settingsManager.getProjectSettings()),
 		);
 		for (const warning of derived.warnings) ctx.ui.notify(warning, "warning");

package/src/tool-output.ts

@@ -1,4 +1,7 @@
 export const TOOL_OUTPUT_MAX_BYTES = 32 * 1024;
+export const DEFAULT_READ_WINDOW_CHARS = 12000;
+export const MAX_READ_WINDOW_CHARS = 50000;
+export const HISTORY_PREVIEW_CHARS = 1200;
 
 function json(value: unknown): string {
 	return JSON.stringify(value, null, 2);
@@ -102,7 +105,7 @@ export function readCharacterWindow<T>(text: string, offsetChars: number | undef
 	const chars = Array.from(text);
 	const requested = offsetChars ?? 0;
 	const resolved = requested < 0 ? Math.max(0, chars.length + requested) : Math.max(0, requested);
-	const windowChars = chars.slice(resolved, resolved + Math.min(limitChars ?? 12000, 50000));
+	const windowChars = chars.slice(resolved, resolved + Math.min(limitChars ?? DEFAULT_READ_WINDOW_CHARS, MAX_READ_WINDOW_CHARS));
 	const build = (content: string): CharacterWindow => {
 		const next = resolved + Array.from(content).length;
 		return { offset_chars: resolved, content, total_chars: chars.length, next_offset_chars: next < chars.length ? next : null };

package/src/warning.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { WARNING_TYPE, GUIDANCE_OPEN_TAG, GUIDANCE_CLOSE_TAG, WARNING_PROMPT } from "./protocol.js";
 import { thresholdsFor, resetThresholds, type ResolvedThresholds } from "./thresholds.js";
 import { hasWindowMessage, currentWindowId } from "./history.js";
+import { remainingTokens } from "./budget.js";
 
 /**
  * The final checkpoint warning, steered to the model once per window. Like the early
@@ -30,9 +31,8 @@ export function registerWarning(pi: ExtensionAPI, isEnabled: () => boolean): voi
 	pi.on("context", (_event, ctx) => {
 		const windowId = currentWindowId(ctx);
 		if (!isEnabled() || firedInWindow === windowId || hasWindowMessage(ctx, WARNING_TYPE)) return undefined;
-		const usage = ctx.getContextUsage();
-		if (!usage || usage.tokens === null) return undefined;
-		const remaining = Math.max(0, usage.contextWindow - usage.tokens);
+		const remaining = remainingTokens(ctx);
+		if (remaining === null) return undefined;
 		const thresholds = thresholdsFor(ctx);
 		if (!warningDue(remaining, thresholds)) return undefined;
 		firedInWindow = windowId;

package/dist/src/dream/apply.js

@@ -1,87 +0,0 @@
-import { mkdirSync, renameSync, existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { editNote, peekNote, resolveNoteScope, updateNoteMeta, writeNote } from "../memory/store.js";
-import { physicalPath } from "../memory/paths.js";
-function target(ctx, value, required = true) {
-    const m = /^(session|project|global):(.*)$/.exec(value);
-    if (m) {
-        const scope = m[1];
-        const path = m[2];
-        const physical = physicalPath(scope, path, ctx);
-        if (!existsSync(physical)) {
-            if (required)
-                throw new Error(`unknown path: ${value}`);
-            return undefined;
-        }
-        return { scope, path };
-    }
-    const found = resolveNoteScope(ctx, value);
-    if (!found && required)
-        throw new Error(`unknown path: ${value}`);
-    return found ? { scope: found.scope, path: value } : undefined;
-}
-function body(ctx, t) { return peekNote(ctx, t.scope, t.path); }
-export function applyManifest(ctx, home, stamp, manifest) {
-    const actions = [];
-    // Resolve every referenced note and promotion destination before the first mutation.
-    for (const m of manifest.merge ?? []) {
-        target(ctx, m.into);
-        for (const p of m.from)
-            target(ctx, p);
-    }
-    for (const p of manifest.promote ?? []) {
-        const from = target(ctx, p.path);
-        if (p.to !== "global") {
-            if (!["session", "project"].includes(p.to))
-                throw new Error(`invalid promotion scope: ${p.to}`);
-            if (existsSync(physicalPath(p.to, p.path, ctx)))
-                throw new Error(`promotion collision: ${p.path}`);
-        }
-        void from;
-    }
-    for (const p of manifest.trash ?? [])
-        target(ctx, p.path);
-    for (const merge of manifest.merge ?? []) {
-        const into = target(ctx, merge.into);
-        const sources = merge.from.map((p) => target(ctx, p));
-        const base = body(ctx, into);
-        const chunks = [base.body, ...sources.map((s) => body(ctx, s).body)].filter(Boolean);
-        const dedup = [...new Set(chunks)].join("\n\n");
-        writeNote(ctx, into.path, dedup, { scope: into.scope, origin: base.meta.origin });
-        updateNoteMeta(ctx, into.path, into.scope, (meta) => { meta.recurrence_count = (meta.recurrence_count ?? 0) + sources.length; meta.recurrence_windows = [...new Set([...(meta.recurrence_windows ?? []), ...sources.map((s) => body(ctx, s).meta.source_window).filter((x) => typeof x === "string")])]; });
-        for (const source of sources)
-            updateNoteMeta(ctx, source.path, source.scope, (meta) => { meta.status = "superseded"; meta.supersedes = merge.into; });
-        actions.push(`merged ${merge.from.join(", ")} into ${merge.into}`);
-    }
-    for (const p of manifest.promote ?? []) {
-        const from = target(ctx, p.path);
-        const m = body(ctx, from);
-        const scope = p.to;
-        if (!["session", "project", "global"].includes(scope))
-            throw new Error(`invalid promotion scope: ${p.to}`);
-        if (scope === "global") {
-            actions.push(`proposal: promote ${p.path} to global (${p.reason})`);
-            continue;
-        }
-        const dest = physicalPath(scope, p.path, ctx);
-        if (existsSync(dest))
-            throw new Error(`promotion collision: ${p.path}`);
-        editNote(ctx, from.path, undefined, { scope });
-        actions.push(`promoted ${p.path} to ${scope}`);
-    }
-    const trashRoot = join(home, "trash", stamp);
-    mkdirSync(trashRoot, { recursive: true });
-    for (const item of manifest.trash ?? []) {
-        const t = target(ctx, item.path);
-        const source = physicalPath(t.scope, t.path, ctx);
-        const dest = join(trashRoot, t.scope, t.path.endsWith(".md") ? t.path : `${t.path}.md`);
-        mkdirSync(dirname(dest), { recursive: true });
-        renameSync(source, dest);
-        actions.push(`trashed ${item.path}: ${item.reason}`);
-    }
-    for (const p of manifest.pending ?? [])
-        actions.push(`pending ${p.path}: ${p.reason}`);
-    for (const p of manifest.skillCandidates ?? [])
-        actions.push(`skill proposal ${p.title}: ${p.rationale}`);
-    return actions;
-}

package/dist/src/dream/manifest.js

@@ -1,16 +0,0 @@
-export function parseManifest(output) {
-    const starts = [...output.matchAll(/[\{[]/g)].map((m) => m.index ?? 0).reverse();
-    for (const start of starts) {
-        try {
-            const value = JSON.parse(output.slice(start));
-            if (!value || typeof value !== "object" || typeof value.report !== "string")
-                continue;
-            for (const key of ["merge", "promote", "trash", "pending", "skillCandidates"])
-                if (value[key] !== undefined && !Array.isArray(value[key]))
-                    throw new Error("invalid array");
-            return value;
-        }
-        catch { /* try an earlier JSON start */ }
-    }
-    throw new Error("dreamer did not return a valid JSON manifest");
-}

package/dist/src/memory/tools.js

@@ -1,175 +0,0 @@
-import { Type } from "@earendil-works/pi-ai";
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { localIso } from "../notes.js";
-import { characterWindowHeader, middleTruncate, output, outputRaw, page, prefixFit, readCharacterWindow, withinTextBudget } from "../tool-output.js";
-import { cursor, nullableString, positiveInteger, searchQueries, searchQuery } from "../tool-schema.js";
-import { serializeNote, stripLeadingFrontmatter } from "./frontmatter.js";
-import { NoteError, editNote, listNotes, readNote, searchNotes, writeNote } from "./store.js";
-const SCOPE = Type.Optional(Type.Union([Type.Literal("session"), Type.Literal("project"), Type.Literal("global")], {
-    description: "The note's reach — which root it lives under. session: only this session needs it (checkpoints, scratch state, worker rosters); dies with the session. project: tied to the current working directory — design decisions and repo facts that future sessions here still need. global: follows you everywhere — user laws, preferences, cross-project maps. On write, picks the destination root (default: session). Omit on read/list/search to cover all three; a read resolves session → project → global and returns the first existing file.",
-}));
-const ORIGIN = Type.Optional(Type.Union([Type.Literal("user"), Type.Literal("self"), Type.Literal("external")], {
-    description: "Where the note's content came from. user: written or dictated by the human. self: written by you, the agent (default). external: anything else — third-party text, tool output, fetched material.",
-}));
-/** Render epoch-ms metadata as the same local ISO timestamps the frontmatter carries. */
-function wireMeta(meta) {
-    return { ...meta, created_at: localIso(meta.created_at), updated_at: localIso(meta.updated_at), last_accessed: localIso(meta.last_accessed) };
-}
-/** Turn a typed store refusal into the pinned error arm; unknown errors stay thrown. */
-function failure(error) {
-    if (error instanceof NoteError) {
-        const payload = { error: error.message };
-        if (error.line_numbers)
-            payload.line_numbers = error.line_numbers;
-        if (error.edit_index !== undefined)
-            payload.edit_index = error.edit_index;
-        return output(payload);
-    }
-    throw error;
-}
-export function registerMemoryTools(pi) {
-    pi.registerTool(defineTool({
-        name: "notes_write",
-        label: "Notes write",
-        description: "Create or replace a note as a real markdown file under the session, project, or global note root. Keep notes small and split by topic — by what the note is about, never by who said it (authorship is origin's job); a rewrite replaces the body whole while preserving created_at and every other frontmatter key. stale: true marks the note closed so it leaves the boot index but stays readable and searchable.",
-        parameters: Type.Object({ path: Type.String(), content: Type.String(), scope: SCOPE, origin: ORIGIN, stale: Type.Optional(Type.Boolean()) }, { additionalProperties: false }),
-        // A batch containing write or edit runs one call at a time, so note read-modify-write cannot race.
-        executionMode: "sequential",
-        async execute(_id, params, _signal, _update, ctx) {
-            const content = params.content;
-            try {
-                const { meta } = writeNote(ctx, params.path, content, { scope: (params.scope ?? "session"), origin: (params.origin ?? "self"), stale: params.stale });
-                return output({ path: params.path, scope: meta.scope, size_bytes: Buffer.byteLength(stripLeadingFrontmatter(content), "utf8"), meta: wireMeta(meta) });
-            }
-            catch (error) {
-                return failure(error);
-            }
-        },
-    }));
-    pi.registerTool(defineTool({
-        name: "notes_edit",
-        label: "Notes edit",
-        description: "Edit a note body by exact-text replacement; frontmatter is never editable this way. Each oldText must occur exactly once unless replace_all is set; a multi-match anchor fails with its match line numbers and a zero-match anchor names the failing edit index. edits may be omitted (or empty) for a metadata-only update, which requires at least one of scope/origin/stale. scope/origin/stale are setters: scope moves the file, refusing when the target already exists. The success return carries resolved_scope and a diff of what changed.",
-        parameters: Type.Object({ path: Type.String(), edits: Type.Optional(Type.Array(Type.Object({ oldText: Type.String(), newText: Type.String() }, { additionalProperties: false }))), scope: SCOPE, origin: ORIGIN, stale: Type.Optional(Type.Boolean()), replace_all: Type.Optional(Type.Boolean()) }, { additionalProperties: false }),
-        executionMode: "sequential",
-        async execute(_id, params, _signal, _update, ctx) {
-            try {
-                const { meta, applied, resolved_scope, diff } = editNote(ctx, params.path, params.edits, { scope: params.scope, origin: params.origin, stale: params.stale, replaceAll: params.replace_all });
-                return output({ path: params.path, applied, resolved_scope, diff, meta: wireMeta(meta) });
-            }
-            catch (error) {
-                return failure(error);
-            }
-        },
-    }));
-    pi.registerTool(defineTool({
-        name: "notes_read",
-        label: "Notes read",
-        description: "Read a character window of a note file, frontmatter included: offset_chars is the code-point offset to start from (default 0) — a negative value counts back from the end — and limit_chars caps the window (default 12000, max 50000). Each response delivers the longest fitting prefix of that window: concatenate pages in order to reconstruct the note. The response is the raw frontmatter + body behind a one-line [bracketed] header naming the file, the resolved offset, the delivered char range, and the resume cursor.",
-        parameters: Type.Object({ path: Type.String(), scope: SCOPE, offset_chars: Type.Optional(Type.Integer({ description: "Code-point offset to start from (default 0). A negative value counts back from the end; the response echoes the resolved absolute offset. Pass the previous next_offset_chars back unchanged to continue." })), limit_chars: Type.Optional(Type.Integer({ minimum: 1, maximum: 50000, description: "Largest requested window in code points (default 12000). A window too large for the wire budget is cut short; next_offset_chars names where the next read resumes." })) }, { additionalProperties: false }),
-        async execute(_id, params, _signal, _update, ctx) {
-            let note;
-            try {
-                note = readNote(ctx, params.path, { scope: params.scope });
-            }
-            catch (error) {
-                return failure(error);
-            }
-            if (!note)
-                return output({ error: "note not found", path: params.path });
-            const text = serializeNote(note.meta, note.body);
-            const totalChars = Array.from(text).length;
-            // A positive offset past the end is an addressing error, not an empty page.
-            if (typeof params.offset_chars === "number" && params.offset_chars > totalChars) {
-                return output({ error: `offset_chars ${params.offset_chars} is past the end: the note has ${totalChars} chars; the largest legal offset is ${totalChars} (an empty end-read)`, path: params.path, offset_chars: params.offset_chars, total_chars: totalChars });
-            }
-            const created_at = localIso(note.meta.created_at);
-            const updated_at = localIso(note.meta.updated_at);
-            const limit_chars = Math.min(params.limit_chars ?? 12000, 50000);
-            return readCharacterWindow(text, params.offset_chars, params.limit_chars, (window) => {
-                const { content, ...rest } = window;
-                return outputRaw(characterWindowHeader(params.path, window, ` · ${note.resolvedScope} · created ${created_at} · updated ${updated_at}`), content, { path: params.path, scope: note.resolvedScope, ...rest, limit_chars, created_at, updated_at });
-            }, (result) => withinTextBudget(result.content[0].text));
-        },
-    }));
-    pi.registerTool(defineTool({
-        name: "notes_list",
-        label: "Notes list",
-        description: "List note files as rows carrying path, scope, origin, status, stale, size_bytes, created_at, and updated_at, most recently updated first. Without scope, all three scopes are merged; a glob pattern (* within a path segment, ** across segments) filters the virtual paths.",
-        parameters: Type.Object({ scope: SCOPE, pattern: nullableString(), cursor: cursor(), max_results: positiveInteger() }, { additionalProperties: false }),
-        async execute(_id, params, _signal, _update, ctx) {
-            let rows;
-            try {
-                rows = listNotes(ctx, { scope: params.scope, pattern: params.pattern ?? undefined });
-            }
-            catch (error) {
-                return failure(error);
-            }
-            const files = rows.map((row) => ({
-                path: row.path,
-                scope: row.meta.scope,
-                origin: row.meta.origin,
-                status: row.meta.status,
-                stale: row.meta.stale,
-                size_bytes: row.sizeBytes,
-                created_at: localIso(row.meta.created_at),
-                updated_at: localIso(row.meta.updated_at),
-            }));
-            return output(page(files, params.cursor ?? 0, "files", params.max_results, (file, fits) => {
-                if (fits(file))
-                    return file;
-                const path = middleTruncate(file.path, (candidate) => fits({ ...file, path: candidate, path_truncated: true }));
-                return { ...file, path, path_truncated: true };
-            }));
-        },
-    }));
-    pi.registerTool(defineTool({
-        name: "notes_search",
-        label: "Notes search",
-        description: "Case-sensitive literal substring search over note bodies; query is one string or several (OR), each matched line appears once. Without scope, all three scopes are merged and every entry carries its scope. Each file entry carries matches_total, its full match count before capping. Each match carries line, text, offset_chars (the body-absolute code-point offset of the earliest match).",
-        parameters: Type.Object({ query: searchQuery(), scope: SCOPE, pattern: nullableString(), cursor: cursor(), max_matches_per_file: positiveInteger(), max_files: positiveInteger() }, { additionalProperties: false }),
-        async execute(_id, params, _signal, _update, ctx) {
-            const queries = searchQueries(params.query);
-            let rows;
-            try {
-                rows = searchNotes(ctx, queries, { scope: params.scope, pattern: params.pattern ?? undefined });
-            }
-            catch (error) {
-                return failure(error);
-            }
-            const maxPerFile = params.max_matches_per_file ?? Number.POSITIVE_INFINITY;
-            const result = rows.map((row) => {
-                const matches = row.matches.map((match) => ({ line: match.line, text: match.text, truncated: false, total_chars: Array.from(match.text).length, offset_chars: match.offsetChars }));
-                return { path: row.path, scope: row.scope, created_at: localIso(row.meta.created_at), updated_at: localIso(row.meta.updated_at), matches_total: matches.length, matches: matches.slice(0, maxPerFile) };
-            });
-            // Trailing matches are dropped to fit the budget, named by matches_total; a single
-            // over-budget line is delivered as a flagged prefix; only a pathological path is
-            // middle-truncated, and then only with a visible path_truncated flag.
-            const fitFile = (file, fits) => {
-                if (fits(file))
-                    return file;
-                const matches = file.matches;
-                let low = 0;
-                let high = matches.length;
-                while (low < high) {
-                    const mid = Math.ceil((low + high) / 2);
-                    if (mid >= 1 && fits({ ...file, matches: matches.slice(0, mid) }))
-                        low = mid;
-                    else
-                        high = mid - 1;
-                }
-                if (low >= 1)
-                    return { ...file, matches: matches.slice(0, low) };
-                const first = matches[0];
-                const fitted = (text) => ({ ...file, matches: [{ ...first, text, truncated: true }] });
-                const text = prefixFit(first.text, (candidate) => fits(fitted(candidate)));
-                const prefix = fitted(text);
-                if (fits(prefix))
-                    return prefix;
-                const path = middleTruncate(prefix.path, (candidate) => fits({ ...prefix, path: candidate, path_truncated: true }));
-                return { ...prefix, path, path_truncated: true };
-            };
-            return output(page(result, params.cursor ?? 0, "files", params.max_files, fitFile));
-        },
-    }));
-}

package/src/dream/apply.ts

@@ -1,47 +0,0 @@
-import { mkdirSync, renameSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve, relative } from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { editNote, peekNote, resolveNoteScope, updateNoteMeta, writeNote, type Scope } from "../memory/store.js";
-import { physicalPath, scopeDir } from "../memory/paths.js";
-import { parseNote } from "../memory/frontmatter.js";
-import type { Manifest } from "./manifest.js";
-
-type Target = { scope: Scope; path: string };
-function target(ctx: ExtensionContext, value: string, required = true): Target | undefined {
-	const m = /^(session|project|global):(.*)$/.exec(value);
-	if (m) { const scope = m[1] as Scope; const path = m[2]!; const physical = physicalPath(scope, path, ctx); if (!existsSync(physical)) { if (required) throw new Error(`unknown path: ${value}`); return undefined; } return { scope, path }; }
-	const found = resolveNoteScope(ctx, value);
-	if (!found && required) throw new Error(`unknown path: ${value}`);
-	return found ? { scope: found.scope, path: value } : undefined;
-}
-function body(ctx: ExtensionContext, t: Target) { return peekNote(ctx, t.scope, t.path); }
-export function applyManifest(ctx: ExtensionContext, home: string, stamp: string, manifest: Manifest): string[] {
-	const actions: string[] = [];
-	// Resolve every referenced note and promotion destination before the first mutation.
-	for (const m of manifest.merge ?? []) { target(ctx, m.into); for (const p of m.from) target(ctx, p); }
-	for (const p of manifest.promote ?? []) { const from = target(ctx, p.path)!; if (p.to !== "global") { if (!["session", "project"].includes(p.to)) throw new Error(`invalid promotion scope: ${p.to}`); if (existsSync(physicalPath(p.to as Scope, p.path, ctx))) throw new Error(`promotion collision: ${p.path}`); } void from; }
-	for (const p of manifest.trash ?? []) target(ctx, p.path);
-	for (const merge of manifest.merge ?? []) {
-		const into = target(ctx, merge.into)!;
-		const sources = merge.from.map((p) => target(ctx, p)!);
-		const base = body(ctx, into); const chunks = [base.body, ...sources.map((s) => body(ctx, s).body)].filter(Boolean);
-		const dedup = [...new Set(chunks)].join("\n\n");
-		writeNote(ctx, into.path, dedup, { scope: into.scope, origin: base.meta.origin });
-		updateNoteMeta(ctx, into.path, into.scope, (meta) => { meta.recurrence_count = (meta.recurrence_count ?? 0) as number + sources.length; meta.recurrence_windows = [...new Set([...(meta.recurrence_windows ?? []), ...sources.map((s) => body(ctx, s).meta.source_window).filter((x): x is string => typeof x === "string")])]; });
-		for (const source of sources) updateNoteMeta(ctx, source.path, source.scope, (meta) => { meta.status = "superseded"; meta.supersedes = merge.into; });
-		actions.push(`merged ${merge.from.join(", ")} into ${merge.into}`);
-	}
-	for (const p of manifest.promote ?? []) {
-		const from = target(ctx, p.path)!; const m = body(ctx, from); const scope = p.to as Scope;
-		if (!["session", "project", "global"].includes(scope)) throw new Error(`invalid promotion scope: ${p.to}`);
-		if (scope === "global") { actions.push(`proposal: promote ${p.path} to global (${p.reason})`); continue; }
-		const dest = physicalPath(scope, p.path, ctx); if (existsSync(dest)) throw new Error(`promotion collision: ${p.path}`);
-		editNote(ctx, from.path, undefined, { scope });
-		actions.push(`promoted ${p.path} to ${scope}`);
-	}
-	const trashRoot = join(home, "trash", stamp); mkdirSync(trashRoot, { recursive: true });
-	for (const item of manifest.trash ?? []) { const t = target(ctx, item.path)!; const source = physicalPath(t.scope, t.path, ctx); const dest = join(trashRoot, t.scope, t.path.endsWith(".md") ? t.path : `${t.path}.md`); mkdirSync(dirname(dest), { recursive: true }); renameSync(source, dest); actions.push(`trashed ${item.path}: ${item.reason}`); }
-	for (const p of manifest.pending ?? []) actions.push(`pending ${p.path}: ${p.reason}`);
-	for (const p of manifest.skillCandidates ?? []) actions.push(`skill proposal ${p.title}: ${p.rationale}`);
-	return actions;
-}

package/src/dream/manifest.ts

@@ -1,21 +0,0 @@
-export type Manifest = {
-	merge?: { into: string; from: string[]; summary?: string }[];
-	promote?: { path: string; to: string; reason: string }[];
-	trash?: { path: string; reason: string }[];
-	pending?: { path: string; reason: string }[];
-	skillCandidates?: { title: string; rationale: string }[];
-	report: string;
-};
-
-export function parseManifest(output: string): Manifest {
-	const starts = [...output.matchAll(/[\{[]/g)].map((m) => m.index ?? 0).reverse();
-	for (const start of starts) {
-		try {
-			const value = JSON.parse(output.slice(start)) as Manifest;
-			if (!value || typeof value !== "object" || typeof value.report !== "string") continue;
-			for (const key of ["merge", "promote", "trash", "pending", "skillCandidates"]) if (value[key as keyof Manifest] !== undefined && !Array.isArray(value[key as keyof Manifest])) throw new Error("invalid array");
-			return value;
-		} catch { /* try an earlier JSON start */ }
-	}
-	throw new Error("dreamer did not return a valid JSON manifest");
-}