@astrosheep/pi-context 0.20.0 → 0.22.0

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");
-}

package/src/memory/tools.ts

@@ -1,175 +0,0 @@
-import { Type } from "@earendil-works/pi-ai";
-import { defineTool, type ExtensionAPI } 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, type NoteMeta, type Origin } from "./frontmatter.js";
-import { NoteError, editNote, listNotes, readNote, searchNotes, writeNote } from "./store.js";
-import type { Scope } from "./paths.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: NoteMeta): Record<string, unknown> {
-	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: unknown) {
-	if (error instanceof NoteError) {
-		const payload: Record<string, unknown> = { 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: ExtensionAPI) {
-	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") as Scope, origin: (params.origin ?? "self") as Origin, 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 as Scope | undefined, origin: params.origin as Origin | undefined, 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: ReturnType<typeof readNote>;
-			try {
-				note = readNote(ctx, params.path, { scope: params.scope as Scope | undefined });
-			} 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: ReturnType<typeof listNotes>;
-			try {
-				rows = listNotes(ctx, { scope: params.scope as Scope | undefined, pattern: params.pattern ?? undefined });
-			} catch (error) {
-				return failure(error);
-			}
-			const files: Array<{ path: string; scope: Scope; origin: Origin; status: string; stale: boolean; size_bytes: number; created_at: string; updated_at: string; path_truncated?: boolean }> = 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: ReturnType<typeof searchNotes>;
-			try {
-				rows = searchNotes(ctx, queries, { scope: params.scope as Scope | undefined, pattern: params.pattern ?? undefined });
-			} catch (error) {
-				return failure(error);
-			}
-			const maxPerFile = params.max_matches_per_file ?? Number.POSITIVE_INFINITY;
-			const result: Array<{ path: string; scope: Scope; created_at: string; updated_at: string; matches_total: number; matches: Array<{ line: number; text: string; truncated: boolean; total_chars: number; offset_chars: number }>; path_truncated?: boolean }> = 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: (typeof result)[number], fits: (candidate: (typeof result)[number]) => boolean) => {
-				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: string): (typeof result)[number] => ({ ...file, matches: [{ ...first, text, truncated: true }] });
-				const text = prefixFit(first.text, (candidate) => fits(fitted(candidate)));
-				const prefix: (typeof result)[number] = 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));
-		},
-	}));
-}