pi-posthorse 0.10.16 → 0.10.18

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-posthorse",
-	"version": "0.10.16",
+	"version": "0.10.18",
 	"type": "module",
 	"description": "Posthorse: fresh context, same journey. No-summary context rollover for Pi, with sparse budget reminders, handoffs, notes, and history.",
 	"keywords": [

package/src/budget.ts

@@ -79,7 +79,7 @@ function automaticGuidance(budget: Budget | undefined, enabled: boolean): string
 			? ""
 			: `The rollover line is ${budget.rolloverAt.toLocaleString("en-US")} tokens used. `;
 	return `Pi rolls context over automatically, so the context window is not a deadline. Do not reduce scope, skip steps or verification, or write a final summary because rollover is near, and do not wait for the user to say "continue". Finish when the requested work and its verification are complete, or report a genuine blocker.
-${line}Rollover keeps a recent-message tail without summarizing. One task-note reminder may arrive at the end of a working turn near the line: update the note only if it is stale, then continue with the next step in the same run. new_context is an optional clean reset.`;
+${line}Rollover keeps a recent-message tail without summarizing. One task-note reminder may arrive at the end of a working turn near the line: update the note only if it is stale, or write one if the task has none, then continue with the next step in the same run. new_context is an optional clean reset.`;
 }
 export function buildGuidance(ctx: PolicyContext): string {
 	const budget = budgetFor(ctx);

package/src/note-provenance.ts

@@ -7,6 +7,7 @@ import { parseSessionLine } from "./session-files.ts";
 import { sessionNoteTouches } from "./note-evidence.ts";
 import { mapBatch, readManifest, snapshot, type SnapshotNote } from "./note-snapshots.ts";
 import {
+	addressIn,
 	addressOf,
 	bindingsOf,
 	canonicalPath,
@@ -130,7 +131,7 @@ export async function resolveReference(
 		}
 		visited.add(directory);
 		if (existsSync(notePath(current, path))) {
-			return { ...current, path };
+			return addressIn(current, path);
 		}
 		// A manifest includes later adoptions; the journal includes later writes and deletions.
 		const binding: NoteBinding | undefined =
@@ -204,7 +205,7 @@ function seedCandidates(
 			) {
 				selected.set(seed.path, {
 					...seed,
-					source: { root: binding.root, scope: binding.scope, path: seed.path },
+					source: addressIn(binding, seed.path),
 					cleared: false,
 				});
 			}

package/src/note-scopes.ts

@@ -83,6 +83,13 @@ export function forkScope(owner: NoteOwner): string {
 export function scopeDirectory(scope: NoteScope): string {
 	return join(scope.root, scope.scope);
 }
+/**
+ * An address is stored in the journal, and a scope value is often a whole binding. Build an
+ * address here, never by spreading a scope, so it holds the two location fields and nothing else.
+ */
+export function addressIn(scope: NoteScope, path: string): NoteAddress {
+	return { root: scope.root, scope: scope.scope, path };
+}
 export function sameScope(left: NoteScope, right: NoteScope): boolean {
 	return left.root === right.root && left.scope === right.scope;
 }
@@ -278,7 +285,7 @@ export function addressOf(path: string, scopes: readonly NoteScope[]): NoteAddre
 				? undefined
 				: candidates.find((item) => item.directory === match.directory);
 		if (match !== undefined && candidate !== undefined) {
-			return { ...candidate.scope, path: match.path };
+			return addressIn(candidate.scope, match.path);
 		}
 		if (
 			scopes.some(

package/src/note-snapshots.ts

@@ -18,6 +18,7 @@ import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { isRecord } from "./contracts.ts";
 import { publishFile } from "./files.ts";
 import {
+	addressIn,
 	notePath,
 	parseBinding,
 	sameOwner,
@@ -127,7 +128,19 @@ async function copyNote(note: SnapshotNote, destination: string): Promise<CopyRe
 		}
 		await utimes(destination, before.atimeMs / 1000, before.mtimeMs / 1000);
 		const [digest, destInfo] = await Promise.all([fileDigest(destination), stat(destination)]);
-		return { kind: "verified", seed: { ...note, digest, identity: fileIdentity(destInfo) } };
+		return {
+			kind: "verified",
+			// Journals written by 0.10.4 through 0.10.17 hold whole bindings in seed addresses.
+			// A new seed keeps each location only, so that data is not copied into this fork.
+			seed: {
+				path: note.path,
+				source: addressIn(note.source, note.source.path),
+				lineage: addressIn(note.lineage, note.lineage.path),
+				digest,
+				identity: fileIdentity(destInfo),
+				anchors: note.anchors,
+			},
+		};
 	} catch (error) {
 		return {
 			kind: "unverified",

package/src/note-store.ts

@@ -13,6 +13,7 @@ import {
 import {
 	NOTES_BINDING,
 	NOTES_TOUCH,
+	addressIn,
 	bindingsOf,
 	canonicalPath,
 	inside,
@@ -129,7 +130,7 @@ export class SessionNotes {
 			return manifest;
 		}
 		throw new Error(
-			`Unknown notes scope ${selector}. Copy a scope selector from notes list/search.`,
+			`Unknown notes scope ${JSON.stringify(selector)}. Omit scope for this session's notes, or copy a scope selector from notes list/search.`,
 		);
 	}
 	async #reference(path: string, signal?: AbortSignal): Promise<NoteAddress | undefined> {
@@ -154,7 +155,7 @@ export class SessionNotes {
 		if (options.scope !== undefined) {
 			const scope = await this.selectScope(options.scope);
 			return {
-				address: { ...scope, path: relative },
+				address: addressIn(scope, relative),
 				path: notePath(scope, relative),
 				writable: sameScope(scope, this.binding),
 			};
@@ -162,11 +163,7 @@ export class SessionNotes {
 		const reference = this.owns(relative)
 			? undefined
 			: await this.#reference(relative, options.signal);
-		const address = reference ?? {
-			root: this.binding.root,
-			scope: this.binding.scope,
-			path: relative,
-		};
+		const address = reference ?? addressIn(this.binding, relative);
 		return { address, path: notePath(address, relative), writable: reference === undefined };
 	}
 	async adopt(path: string, call: NoteCall): Promise<Adoption> {

package/src/notes.ts

@@ -278,6 +278,11 @@ async function searchNotes(
 		header: hits.skipped > 0 ? `[Not searched: ${skipped} over 1 MiB.]\n` : "",
 	});
 }
+/** Some models send every optional argument; an empty scope means no scope. */
+function withoutEmptyScope(params: NotesParams): NotesParams {
+	const { scope, ...unscoped } = params;
+	return scope === "" ? unscoped : params;
+}
 export function registerNotes(
 	pi: ExtensionAPI,
 	policy: (ctx: ExtensionContext) => PolicyContext,
@@ -325,7 +330,8 @@ export function registerNotes(
 				}),
 			),
 		}),
-		async execute(...[_id, params, signal, , ctx]) {
+		async execute(...[_id, received, signal, , ctx]) {
+			const params = withoutEmptyScope(received);
 			// Migrate newly returned legacy package notes without changing this session’s binding.
 			notesDir(ctx.cwd);
 			const session = await store.get(ctx);

package/src/recovery-note-touches.ts

@@ -262,8 +262,9 @@ function notesToolTouches(
 	const parsed = resultText === undefined ? undefined : extractNotesResultTarget(resultText);
 	const kind = notesCallKind(args) ?? parsed?.kind;
 	const path = optionalString(args.path);
-	const scopedPath =
-		typeof args.scope === "string" && path !== undefined ? `${args.scope}/${path}` : path;
+	// An empty scope counts as omitted, as it does when the tool runs.
+	const scope = args.scope === "" ? undefined : optionalString(args.scope);
+	const scopedPath = scope !== undefined && path !== undefined ? `${scope}/${path}` : path;
 	const callTarget = resolveNoteTarget(scopedPath, context.knownDirs, true);
 	const resTarget = resolveNoteTarget(parsed?.rawPath, context.knownDirs, true);
 	const merged = mergeNoteTargets(callTarget, resTarget);

package/src/recovery-notes.ts

@@ -77,22 +77,39 @@ function applyTouch(
 		order,
 	};
 }
-function formatNoteLabel(note: TrackedNote): string {
+/** `notes read` resolves a bare name in this session's own notes, so a note elsewhere is named by its path. */
+function pathElsewhere(note: TrackedNote, notesDirectory: string | undefined): string | undefined {
 	if (note.referenceScope !== undefined) {
-		return `${note.notePath} (another notes scope: ${note.absPath ?? `${note.referenceScope}/${note.notePath}`})`;
+		return note.absPath ?? `${note.referenceScope}/${note.notePath}`;
+	}
+	return note.absPath !== undefined &&
+		notesDirectory !== undefined &&
+		note.absPath !== join(notesDirectory, note.notePath)
+		? note.absPath
+		: undefined;
+}
+function formatNoteLabel(note: TrackedNote, elsewhere: string | undefined): string {
+	if (elsewhere !== undefined) {
+		return note.referenceScope === undefined ? elsewhere : `${elsewhere} (another notes scope)`;
 	}
 	return note.absPath !== undefined && note.absPath !== note.notePath
 		? `${note.notePath} (${note.absPath})`
 		: note.notePath;
 }
-function formatWrittenNoteLine(note: WrittenNote, span: RetainedSpan | undefined): string {
-	const label = formatNoteLabel(note);
+function formatWrittenNoteLine(
+	note: WrittenNote,
+	span: RetainedSpan | undefined,
+	notesDirectory: string | undefined,
+): string {
+	const elsewhere = pathElsewhere(note, notesDirectory);
+	const label = formatNoteLabel(note, elsewhere);
+	const how = elsewhere === undefined ? "" : " on its path";
 	const { proof } = note;
 	if (proof.kind === "effect-only") {
-		return `- Active note (written): ${label} [verified effect at entry ${note.entryId}; full content is not retained — read this note now]`;
+		return `- Active note (written): ${label} [verified effect at entry ${note.entryId}; full content is not retained — read this note${how} now]`;
 	}
 	if (span === undefined) {
-		return `- Active note (written): ${label} [compacted at entry ${note.entryId} — read this note now]`;
+		return `- Active note (written): ${label} [compacted at entry ${note.entryId} — read this note${how} now]`;
 	}
 	switch (proof.kind) {
 		case "full": {
@@ -101,13 +118,17 @@ function formatWrittenNoteLine(note: WrittenNote, span: RetainedSpan | undefined
 			return `- Active note (written): ${label} [latest full write is in the retained tail above at entry ${proof.entryId}${updated}]`;
 		}
 		case "partial":
-			return `- Active note (written): ${label} [only partial edits are in the retained tail above at entry ${proof.entryId} — read full note now]`;
+			return `- Active note (written): ${label} [only partial edits are in the retained tail above at entry ${proof.entryId} — read full note${how} now]`;
 		case "compacted":
-			return `- Active note (written): ${label} [compacted before entry ${span.firstId} — read this note now]`;
+			return `- Active note (written): ${label} [compacted before entry ${span.firstId} — read this note${how} now]`;
 	}
 }
-function formatReadNoteLine(note: ReadNote, span: RetainedSpan | undefined): string {
-	const label = formatNoteLabel(note);
+function formatReadNoteLine(
+	note: ReadNote,
+	span: RetainedSpan | undefined,
+	notesDirectory: string | undefined,
+): string {
+	const label = formatNoteLabel(note, pathElsewhere(note, notesDirectory));
 	if (span !== undefined && note.inRetained) {
 		return `- Referenced note (read): ${label} [read in the retained tail above at entry ${note.entryId}]`;
 	}
@@ -123,16 +144,12 @@ function formatNotesAction(
 	if (primaryWritten === undefined) {
 		return "Read the referenced note again if its context is still needed, and keep one current-state note for this task.";
 	}
-	// notes read resolves a bare name in this session's own scope, so a note elsewhere is named by its path.
-	const elsewhere =
-		primaryWritten.absPath !== undefined &&
-		notesDirectory !== undefined &&
-		primaryWritten.absPath !== join(notesDirectory, primaryWritten.notePath);
-	const target = elsewhere ? primaryWritten.absPath : primaryWritten.notePath;
+	const elsewhere = pathElsewhere(primaryWritten, notesDirectory);
+	const target = elsewhere ?? primaryWritten.notePath;
 	if (span !== undefined && primaryWritten.proof.kind === "full") {
 		return `Your latest full write to ${target} is already visible above at entry ${primaryWritten.proof.entryId}; do not rewrite it unless new findings after entry ${span.lastId} require it.`;
 	}
-	const how = elsewhere ? "read on its path" : "notes read or read on its path";
+	const how = elsewhere === undefined ? "notes read or read on its path" : "read on its path";
 	return `Read ${target} (${how}) before continuing to restore the saved goal, progress, decisions, and next steps, then keep that note current as work progresses.`;
 }
 function trackedNotes(
@@ -181,16 +198,14 @@ export function renderSessionNotes(
 	}
 	const written = all.filter((note) => note.kind === "written").slice(0, MAX_WRITTEN_NOTES);
 	const readOnly = all.filter((note) => note.kind === "read").slice(0, MAX_READ_NOTES);
+	const notesDirectory =
+		options.notes === undefined ? defaultDir : scopeDirectory(options.notes.binding);
 	const lines = [
-		...written.map((note) => formatWrittenNoteLine(note, span)),
-		...readOnly.map((note) => formatReadNoteLine(note, span)),
+		...written.map((note) => formatWrittenNoteLine(note, span, notesDirectory)),
+		...readOnly.map((note) => formatReadNoteLine(note, span, notesDirectory)),
 	];
 	const header = "Task notes in this session:";
-	const action = formatNotesAction(
-		written[0],
-		span,
-		options.notes === undefined ? defaultDir : scopeDirectory(options.notes.binding),
-	);
+	const action = formatNotesAction(written[0], span, notesDirectory);
 	const selected: string[] = [];
 	for (const line of lines) {
 		if ([header, ...selected, line, action].join("\n").length <= maxChars) {

package/src/rollover.ts

@@ -445,7 +445,7 @@ export function registerRollover(
 				{
 					customType: REMINDER_TYPE,
 					content:
-						"[posthorse] Routine task-note update. Update the task's current-state note if it is stale, then continue with the next step in this run.",
+						"[posthorse] Routine task-note update. Update the task's current-state note if it is stale, or write one if the task has none, then continue with the next step in this run.",
 					display: true,
 					details: reminder.fingerprint,
 				},