pi-tuck 1.0.26 → 1.0.28

package/dist/src/tuck.js

@@ -108,16 +108,17 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
             return { unavailable: "No reducible history before the fresh shell output" };
         cut = cutBefore(cut, freshBash, prefix);
     }
-    // Preserve the actual latest user source, never an inferred task/decision.
-    // Explicit omission of it must not promote an earlier user source instead.
+    // The latest user source still owns first exposure and non-text native floors. An omission never promotes an older source.
     const latestUser = retainCurrentInput ? branch.findLast(entry => entry.type === "message" && entry.message.role === "user") : undefined;
-    const userPosition = entries.findIndex(entry => entry.id === latestUser?.id && entry.type === "message");
-    const current = entries[userPosition];
-    const userContent = current?.type === "message" && current.message.role === "user" ? current.message.content : undefined;
-    const textOnly = isTextOnly(userContent);
-    // Steering can become the latest user source while the run still owns its original prompt.
-    const startingPosition = entries.findIndex(entry => entry.id === input.protectedPromptEntryId && entry.type === "message" && entry.message.role === "user");
-    const starting = entries[startingPosition];
+    const latestPosition = entries.findIndex(entry => entry.id === latestUser?.id && entry.type === "message");
+    const latest = entries[latestPosition];
+    const latestContent = latest?.type === "message" && latest.message.role === "user" ? latest.message.content : undefined;
+    const latestTextOnly = isTextOnly(latestContent);
+    // During a run, current input is the run owner's starting entry, even after steering. Manual cuts use the latest source.
+    const currentId = input.protectedPromptEntryId ?? latestUser?.id;
+    const currentPosition = entries.findIndex(entry => entry.id === currentId &&
+        (entry.type === "custom_message" || entry.type === "message" && entry.message.role === "user"));
+    const current = entries[currentPosition];
     // Anchor the actual first source only; a native omission never promotes a later prompt.
     const firstUser = branch.find(entry => entry.type === "message" && entry.message.role === "user");
     const firstUserPosition = entries.findIndex(entry => entry.id === firstUser?.id && entry.type === "message");
@@ -125,11 +126,11 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
     const selectedBoundary = cut.compactAll ? entries.length : entries.findIndex(entry => entry.id === selectedKeptId);
     // An unobserved input or non-text input stays native. Quoting cannot deliver
     // its pixels/unknown blocks, and must not count as first exposure.
-    if (userPosition >= 0 && userPosition < selectedBoundary && (!textOnly || userPosition > lastResponse)) {
-        const prefix = tuck.buildOwnCut(entries.slice(0, userPosition), 0);
+    if (latestPosition >= 0 && latestPosition < selectedBoundary && (!latestTextOnly || latestPosition > lastResponse)) {
+        const prefix = tuck.buildOwnCut(entries.slice(0, latestPosition), 0);
         if (!prefix.ok)
             return { unavailable: "No reducible history before the current user input" };
-        cut = cutBefore(cut, userPosition, prefix);
+        cut = cutBefore(cut, latestPosition, prefix);
     }
     if (cut.messages.length !== cut.selectedIds.length || (!cut.compactAll && !entries.some((e) => e.id === cut.firstKeptEntryId)))
         throw new Error("pi-tuck returned an invalid source boundary");
@@ -138,8 +139,8 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
     let floorBoundary = freshRound ? lastResponse : entries.length;
     if (freshBash >= 0)
         floorBoundary = Math.min(floorBoundary, freshBash);
-    if (userPosition >= 0 && (!textOnly || userPosition > lastResponse))
-        floorBoundary = Math.min(floorBoundary, userPosition);
+    if (latestPosition >= 0 && (!latestTextOnly || latestPosition > lastResponse))
+        floorBoundary = Math.min(floorBoundary, latestPosition);
     // One fill owns the summary and the contiguous native suffix. Protocol/current-input
     // floors are representation constraints; every other source competes by rank.
     return rankedFill();
@@ -256,10 +257,12 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
             if (cached)
                 return cached;
             const index = indices.get(entry.id);
-            const text = entry.type === "message" && entry.message.role === "user" ? textOf(entry.message.content) : "";
+            const text = entry.type === "custom_message" ? textOf(entry.content) : entry.type === "message" && entry.message.role === "user" ? textOf(entry.message.content) : "";
             const sourceTimes = index === undefined ? undefined : [{ sourceIndex: index, ...resolveSourceTime(entry) }];
-            const records = index === undefined ? [] : take === Infinity
-                ? [{ kind: "excerpt", role: "user", sourceIndex: index, text, sourceTimes }]
+            // Custom entries have a native identity but no global message index.
+            const records = index === undefined && entry.type !== "custom_message" ? [] : take === Infinity
+                ? [{ kind: "excerpt", role: entry.type === "custom_message" ? "custom" : "user", ...(index === undefined ? {} : { sourceIndex: index }), text, sourceTimes,
+                        ...(entry.type === "custom_message" ? { sourceEntryId: entry.id } : {}) }]
                 : userPrefixRecords({ kind: "user", text, originalText: text, startsSource: true, sourceIndex: index }, undefined, take).map(record => ({ ...record, sourceTimes }));
             cached = { records, cost: lineCost(records), whole: take >= text.length };
             quoteCache.set(key, cached);
@@ -278,12 +281,12 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
                         whole.add(index);
                 }
             };
-            if (userPosition >= 0 && userPosition < boundary && textOnly)
+            if (latestPosition >= 0 && latestPosition < boundary && latestTextOnly)
+                add(latest, Infinity);
+            if (currentPosition >= 0 && currentPosition < boundary && current?.id !== latest?.id)
                 add(current, Infinity);
-            if (startingPosition >= 0 && startingPosition < boundary && starting?.id !== current?.id)
-                add(starting, Infinity);
             for (const entry of anchors)
-                if (entry.id !== current?.id && entry.id !== starting?.id && positions.get(entry.id) < boundary)
+                if (entry.id !== latest?.id && entry.id !== current?.id && positions.get(entry.id) < boundary)
                     add(entry, length);
             const omissions = [];
             for (const role of ["user", "assistant", "toolResult"]) {
@@ -399,21 +402,24 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
             if (row.message.role === "user" && Array.isArray(row.message.content))
                 imageLabels.set(row.index, new Set(row.message.content.flatMap(part => part.type === "image" ? [`[image: ${part.mimeType}]`] : [])));
         const compiledBoundary = boundary;
+        // A protected custom prompt uses its native entry ID in the same anchoring/movement path as indexed user prompts.
+        const sourceKey = (record) => current?.type === "custom_message" && record.sourceEntryId === current.id ? current.id : record.sourceIndex;
         const assemble = (compiled, at = compiledBoundary) => {
             const split = compiled ? splitSummary(compiled) : undefined;
             if (compiled && !split)
                 throw new Error("pi-tuck returned an invalid summary");
             const inputRecords = split ? parseRecords(split.body, split.version) : protectedView.omissions;
-            const expanded = new Set(protectedView.kept.filter(record => record.kind === "excerpt" && inputRecords.some(row => row.kind === "excerpt" && row.role === "user" && row.sourceIndex === record.sourceIndex && row.text.startsWith(record.text) && row.text.length >= record.text.length)).map(record => record.sourceIndex));
-            const anchored = new Set(protectedView.kept.map(record => record.sourceIndex));
-            const moved = new Set(rows.filter(row => row.position >= at && row.position < compiledBoundary).map(row => row.index));
+            const expanded = new Set(protectedView.kept.filter(record => record.kind === "excerpt" && inputRecords.some(row => row.kind === "excerpt" && row.role === record.role && sourceKey(row) === sourceKey(record) && row.text.startsWith(record.text) && row.text.length >= record.text.length)).map(sourceKey));
+            const anchored = new Set(protectedView.kept.map(sourceKey));
+            const moved = new Set(rows.filter(row => row.position >= at && row.position < compiledBoundary).map(row => current?.type === "custom_message" && row.id === current.id ? row.id : row.index));
             const records = [...inputRecords.filter(record => {
-                    if (record.sourceIndex !== undefined && moved.has(record.sourceIndex))
+                    const key = sourceKey(record);
+                    if (key !== undefined && moved.has(key))
                         return false;
                     if (record.kind === "excerpt" && record.role === "user" && imageLabels.get(record.sourceIndex)?.has(record.text))
                         return true;
-                    return record.role !== "user" || record.sourceIndex === undefined || !anchored.has(record.sourceIndex) || expanded.has(record.sourceIndex);
-                }), ...protectedView.kept.filter(record => !expanded.has(record.sourceIndex) && !moved.has(record.sourceIndex))];
+                    return record.role !== "user" && record.role !== "custom" || key === undefined || !anchored.has(key) || expanded.has(key);
+                }), ...protectedView.kept.filter(record => !expanded.has(sourceKey(record)) && !moved.has(sourceKey(record)))];
             // Mixed user turns keep their text opening, while their image
             // metadata remains in the ordinary lower-ranked dialogue lane.
             const wholeUser = new Set(records.filter(record => record.kind === "excerpt" && record.role === "user" && record.text === userTexts.get(record.sourceIndex)).map(record => record.sourceIndex));

package/index.ts

@@ -11,7 +11,7 @@ export type { CompactionOptions } from "./src/compaction";
 export { installCompaction } from "./src/compaction";
 export { inspectIncident, readableIncident } from "./src/diagnostic-replay.js";
 export { createSemanticRecall, SemanticRecallController } from "./src/semantic-recall";
-export type { SemanticRecallConfig, PriorResult, SemanticState } from "./src/semantic-recall";
+export type { SemanticRecallConfig, PriorResult, SemanticState, SemanticSetup } from "./src/semantic-recall";
 export { ensureSemanticRuntime } from "./src/setup";
 
 /** pi-tuck as a Pi extension: compaction and history recall always; semantic recall too, unless `pi-tuck.json` in Pi's agent folder
@@ -41,13 +41,19 @@ export default async function (pi: ExtensionAPI) {
 	}
 	const semanticRecall = createSemanticRecall();
 	// `/tuck-semantic off` holds for the rest of the session, including over a setup that finishes later.
-	let off = false;
 	const settings = readSettings(join(getAgentDir(), "pi-tuck.json"));
 	// Semantic recall runs on Metal, so only on Apple silicon; elsewhere the model is not offered tuck_search at all.
 	const appleSilicon = process.platform === "darwin" && process.arch === "arm64";
-	const handle = await installCompaction(pi, { semanticRecall, search: appleSilicon, cutAt: settings.cutAt, onSemanticSetting: async enabled => { off = !enabled; } });
-	if (settings.semanticRecall === false) return;
-	let session = 0, said = "", setup: Promise<unknown> | undefined, announced = false;
+	const handle = await installCompaction(pi, { semanticRecall, search: appleSilicon, cutAt: settings.cutAt, onSemanticSetting: async enabled => {
+		if (!enabled) semanticRecall.setSetup("off-user");
+		else if (semanticRecall.status().setup === "off-user") semanticRecall.setSetup("starting", { installed: existsSync(runtimeConfigPath(defaultRoot())) });
+	} });
+	if (settings.semanticRecall === false) {
+		semanticRecall.setSetup("off-settings");
+		pi.on("session_start", () => { semanticRecall.setSetup("off-settings"); });
+		return;
+	}
+	let session = 0, said = "", announced = false, setup: Promise<unknown> | undefined;
 	// A context outlives its session (a setup can finish after /new); a notice to an ended session is dropped.
 	// With no UI (pi -p), Pi shows no notices, so a settings error or an off or failing semantic recall would go unsaid: write each to stderr
 	// instead, once per session. stderr is the operator's; it never enters the model's context.
@@ -57,41 +63,44 @@ export default async function (pi: ExtensionAPI) {
 		try { ctx.ui.notify(message, level); } catch { /* ended */ }
 	};
 	const once = (ctx: ExtensionContext, message: string, level: "info" | "warning") => { if (said !== message) { said = message; say(ctx, message, level); } };
+	const announce = (ctx: ExtensionContext, state: Parameters<typeof semanticRecall.setSetup>[0], detail?: Parameters<typeof semanticRecall.setSetup>[1]) => {
+		semanticRecall.setSetup(state, detail);
+		const notice = semanticRecall.setupNotice();
+		if (notice) (state === "off-platform" || state === "off-project" ? once : say)(ctx, notice.message, notice.level);
+	};
 	pi.on("session_shutdown", () => { session++; });
 	pi.on("session_start", (_event, ctx) => {
 		const current = ++session;
-		off = false;
 		stderrSaid.clear();
 		if (settings.error) once(ctx, `pi-tuck: ${settings.error}; using the defaults.`, "warning");
 		if (!appleSilicon)
-			return once(ctx, "pi-tuck: semantic recall needs macOS on Apple silicon; compaction and word recall work.", "info");
+			return announce(ctx, "off-platform");
 		// Semantic recall keeps its runtime and indexes outside the project it serves, so not when Pi runs in a folder that holds its
 		// agent folder, such as the home folder.
 		if (within(real(getAgentDir()), real(ctx.cwd)))
-			return once(ctx, "pi-tuck: semantic recall is off here because Pi's agent folder is inside this folder; open Pi in a project folder to use it.", "info");
+			return announce(ctx, "off-project");
 		// A run with no UI (pi -p, RPC, JSON) uses a runtime that is already installed: that needs no download. It does not start a first-time
 		// setup, which would outlast a one-shot run, and it says why, so tuck_search and /tuck name the real state.
 		const installed = existsSync(runtimeConfigPath(defaultRoot()));
-		if (!ctx.hasUI && !installed) {
-			semanticRecall.refuse("Semantic recall is not set up yet; start Pi once in an interactive session to set it up. Word recall works meanwhile");
-			return say(ctx, "pi-tuck: semantic recall is not set up yet; start Pi once in an interactive session to set it up. Word recall works.", "warning");
-		}
-		if (!semanticRecall.status().configured)
-			semanticRecall.refuse(installed ? "Semantic recall is starting; word recall works meanwhile" : "Semantic recall is being set up; word recall works meanwhile");
-		setup ??= ensureSemanticRuntime(defaultRoot(), message => { announced = true; say(ctx, message, "info"); });
+		if (!ctx.hasUI && !installed) return announce(ctx, "not-installed");
+		// The download's announcement outlives the session that made it: a session that starts while the shared setup is still running
+		// owes the "set up" notice once, as before the refactor.
+		semanticRecall.setSetup("starting", { installed, announced });
+		setup ??= ensureSemanticRuntime(defaultRoot(), message => {
+			announced = true;
+			if (current === session && semanticRecall.status().setup !== "off-user") announce(ctx, "starting", { installed, notice: message, announced: true });
+		});
 		setup.then(async () => {
-			if (current !== session || off) return;
+			if (current !== session || semanticRecall.status().setup === "off-user") return;
 			try {
-				await handle.setSemanticEnabled(true, ctx); // reads the runtime's configuration through the outside-project check
-				// The download was announced, so its end is too: once, when semantic recall first starts on it.
-				if (announced && current === session) { announced = false; say(ctx, "pi-tuck: semantic recall is set up. Search by meaning works from the first cut on.", "info"); }
+				await handle.setSemanticEnabled(true, ctx);
+				if (current === session && semanticRecall.status().setup !== "off-user") { announce(ctx, "ready", { announced }); announced = false; }
 			} catch (error) {
-				if (current === session) say(ctx, `pi-tuck: semantic recall could not start (${reason(error)}); it tries again when a session starts.`, "warning");
+				if (current === session && semanticRecall.status().setup !== "off-user") announce(ctx, "failed", { stage: "start", reason: reason(error) });
 			}
 		}, error => {
 			setup = undefined; // the next session start tries again
-			semanticRecall.refuse(`Semantic recall setup failed: ${reason(error)}`);
-			if (current === session) say(ctx, `pi-tuck: semantic recall setup failed (${reason(error)}). Word recall works; setup retries when a session starts.`, "warning");
+			if (current === session && semanticRecall.status().setup !== "off-user") announce(ctx, "failed", { stage: "setup", reason: reason(error) });
 		});
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tuck",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "Deterministic compaction for Pi with no model call, plus exact recall of earlier history. Search by meaning on Apple silicon.",
   "keywords": [
     "pi-package",

package/src/build-id.ts

@@ -1 +1 @@
-export const BUILD_ID = "e95edde95c614d01e1cbf6489134676fac0c1bbf6aa57ef639ffac1e7e105041";
+export const BUILD_ID = "e9c750b757776bf44ad79939b633f178ef9a8f14acfab1c8bb6311d692c79e61";