pi-tuck 1.0.27 → 1.0.28

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.27",
+  "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 = "480a4cbd70d99cf72adcc93f282c17434d1997e54d3f38fe2f26b3c642f50b2f";
+export const BUILD_ID = "e9c750b757776bf44ad79939b633f178ef9a8f14acfab1c8bb6311d692c79e61";