@selesai/code 0.13.29 → 0.13.30

package/dist/extensions/jev/test-support.ts

@@ -0,0 +1,233 @@
+/**
+ * Test doubles for the Jev advisory routing extension.
+ *
+ * The extension is driven the way Selesai drives it: an `input` event opens a
+ * turn, `before_agent_start` answers it, and telemetry arrives on the shared
+ * event bus. Tests assert observable outcomes — the advisory context the parent
+ * would receive, the request Jev would be sent, and the telemetry shape — never
+ * private helper order.
+ */
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { vi } from "vitest";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@selesai/code";
+import { JEV_ROUTING_EVENT, type JevAdvisoryConfig } from "./decisions.ts";
+import {
+	isMemorySearchRequest,
+	MEMORY_SEARCH_REQUEST_EVENT,
+	type MemorySearchRequestInput,
+	type MemorySearchResponse,
+} from "../pi-hermes-memory/src/memory-search-bridge.ts";
+
+export interface SkillStub {
+	name: string;
+	description: string;
+	filePath: string;
+	scope?: "user" | "project" | "temporary";
+	disableModelInvocation?: boolean;
+}
+
+export interface CommandStub {
+	name: string;
+	description?: string;
+	source: "extension" | "prompt" | "skill";
+}
+
+export interface AdvisoryMessage {
+	customType: string;
+	content: string;
+	display?: boolean;
+	details?: unknown;
+}
+
+type Handler = (event: unknown, ctx: unknown) => unknown;
+
+export interface AdvisoryHarness {
+	pi: Record<string, unknown>;
+	handlers: Map<string, Handler[]>;
+	ctx: Record<string, unknown>;
+	cwd: string;
+	/** Every telemetry payload published on the routing channel, in order. */
+	telemetry: Record<string, unknown>[];
+
+	/** The message the extension would hand the parent, if it recommended anything. */
+	advise(prompt: string, input?: Record<string, unknown>): Promise<AdvisoryMessage | undefined>;
+	fire(event: string, payload?: unknown): Promise<unknown>;
+	/** Fire the same turn's hook again, as a retry or a replayed run would. */
+	replay(prompt: string): Promise<unknown>;
+}
+
+/** A registered model `jevModel` inherits its base URL from. */
+export function providerTemplate() {
+	return {
+		provider: "tokenin",
+		id: "celestial-pro",
+		name: "celestial-pro",
+		api: "openai-completions",
+		baseUrl: "https://lite.andlet.me/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 393216,
+		maxTokens: 64000,
+	};
+}
+
+/** A directory that looks like the working tree of a Git repository. */
+export function makeRepo(prefix: string): { root: string; repo: string } {
+	const root = mkdtempSync(join(tmpdir(), prefix));
+	const repo = join(root, "repo");
+	mkdirSync(join(repo, ".git"), { recursive: true });
+	return { root, repo };
+}
+
+export function writeJevSettings(settingsPath: string, advisory: unknown): void {
+	writeFileSync(settingsPath, JSON.stringify({ jevAdvisory: advisory }), "utf-8");
+}
+
+export function makeHarness(options: {
+	settingsPath: string;
+	extension: (pi: ExtensionAPI) => void;
+	cwd: string;
+	skills?: SkillStub[];
+	commands?: CommandStub[];
+	branch?: unknown[];
+	credential?: boolean;
+	template?: boolean;
+	/** The completion transport the route's registry serves; a failing one by default. */
+	complete?: ReturnType<typeof vi.fn>;
+	/** Local Hermes lookup result; this simulates the bundled memory extension. */
+	memorySearch?: (input: MemorySearchRequestInput) => MemorySearchResponse | undefined;
+}): AdvisoryHarness {
+	const handlers = new Map<string, Handler[]>();
+	const telemetry: Record<string, unknown>[] = [];
+	const busHandlers = new Map<string, Array<(data: unknown) => void>>();
+	const pi = {
+		on: vi.fn((event: string, handler: Handler) => {
+			handlers.set(event, [...(handlers.get(event) ?? []), handler]);
+		}),
+		events: {
+			on: (channel: string, handler: (data: unknown) => void) => {
+				busHandlers.set(channel, [...(busHandlers.get(channel) ?? []), handler]);
+			},
+			emit: (channel: string, data: unknown) => {
+				if (channel === JEV_ROUTING_EVENT) telemetry.push(data as Record<string, unknown>);
+				for (const handler of busHandlers.get(channel) ?? []) handler(data);
+			},
+		},
+		getResolvedSkills: () => options.skills ?? [],
+		getCommands: () => options.commands ?? [],
+	};
+	const ctx = {
+		cwd: options.cwd,
+		hasUI: true,
+		mode: "tui",
+		isIdle: () => true,
+		isProjectTrusted: () => true,
+		getSystemPrompt: () => "system prompt",
+		modelRegistry: {
+			getAll: () => (options.template === false ? [] : [providerTemplate()]),
+			getApiKeyAndHeaders: vi.fn(async () =>
+				options.credential === false ? { ok: false, error: "no key" } : { ok: true, apiKey: "key", headers: {} },
+			),
+			// A route that reaches the provider in a test must fail closed, so the
+			// default answer is an error message rather than a live call.
+			complete: options.complete ?? vi.fn(async () => jevResponse("{}", { stopReason: "error", errorMessage: "no transport" })),
+		},
+		sessionManager: { getBranch: () => options.branch ?? [], getEntries: () => options.branch ?? [] },
+		ui: { notify: vi.fn(), setStatus: vi.fn() },
+	};
+	options.extension(pi as unknown as ExtensionAPI);
+	pi.events.on(MEMORY_SEARCH_REQUEST_EVENT, (request) => {
+		if (!isMemorySearchRequest(request)) return;
+		const result = (options.memorySearch ?? (() => ({ success: true, count: 1, output: "LOCAL_MEMORY_RESULT" })))(request.input);
+		if (result) request.respond(result);
+	});
+
+	const fire = async (event: string, payload?: unknown): Promise<unknown> => {
+		let result: unknown;
+		for (const handler of handlers.get(event) ?? []) {
+			result = (await handler(payload ?? { type: event }, ctx)) ?? result;
+		}
+		return result;
+	};
+
+	const advisory: AdvisoryHarness = {
+		pi,
+		handlers,
+		ctx,
+		cwd: options.cwd,
+		telemetry,
+		fire,
+		async advise(prompt, input = {}) {
+			await fire("input", { type: "input", text: prompt, source: "interactive", ...input });
+			const result = await fire("before_agent_start", { type: "before_agent_start", prompt });
+			return (result as { message?: AdvisoryMessage } | undefined)?.message;
+		},
+		replay(prompt) {
+			return fire("before_agent_start", { type: "before_agent_start", prompt });
+		},
+	};
+	return advisory;
+}
+
+/** The decisions request inside a completion call, or undefined. */
+function callContent(call: unknown[] | undefined): string | undefined {
+	const content = (call?.[1] as { messages?: Array<{ content?: unknown }> } | undefined)?.messages?.[0]?.content;
+	return typeof content === "string" ? content : undefined;
+}
+
+/** The parsed decision request sent to Jev last, or undefined. */
+export function sentPayload(transport: { mock: { calls: unknown[][] } }): Record<string, unknown> | undefined {
+	const content = callContent(transport.mock.calls.at(-1));
+	return content === undefined ? undefined : JSON.parse(content);
+}
+
+/** Every decision request sent to Jev, parsed, oldest first. */
+export function sentPayloads(transport: { mock: { calls: unknown[][] } }): Array<Record<string, unknown>> {
+	return transport.mock.calls
+		.map(callContent)
+		.filter((content): content is string => content !== undefined)
+		.map((content) => JSON.parse(content) as Record<string, unknown>);
+}
+
+/** The answers envelope Jev returns for the given choices. */
+export function jevAnswers(answers: Record<string, { choice: string; confidence?: number }>): string {
+	return JSON.stringify({
+		answers: Object.fromEntries(
+			Object.entries(answers).map(([question, answer]) => [
+				question,
+				{ type: "choice", choice: answer.choice, ...(answer.confidence === undefined ? {} : { confidence: answer.confidence }) },
+			]),
+		),
+	});
+}
+
+/** A decisions answer as pi's completion transport hands it back. */
+export function jevResponse(text: string, overrides: Partial<AssistantMessage> = {}): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [{ type: "text", text }],
+		api: "openai-completions",
+		provider: "tokenin",
+		model: "jev-1.13",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: 1,
+		...overrides,
+	} as AssistantMessage;
+}
+
+/** A route config with everything enabled, for tests that are not about enablement. */
+export function enabledAdvisoryRoutes(routes: Array<"memory" | "recommendations"> = ["memory", "recommendations"]) {
+	return Object.fromEntries(routes.map((route) => [route, { enabled: true }])) as Partial<JevAdvisoryConfig>["routes"];
+}

package/dist/extensions/jev-advisory-lifecycle.test.ts

@@ -0,0 +1,206 @@
+/**
+ * Input lifecycle, idempotency, and telemetry for the advisory routes.
+ *
+ * Only idle, top-level, interactive user input is eligible: extension-injected
+ * turns, slash commands, queued steering/follow-up input, and empty input never
+ * reach Jev. One eligible input produces at most one advisory, however many
+ * times the hook is re-entered, and telemetry never carries content or breaks a
+ * turn.
+ */
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+const state = vi.hoisted(() => ({ settingsPath: "" }));
+
+vi.mock("@selesai/code", () => ({ getSettingsPath: () => state.settingsPath }));
+// The client speaks through pi's completion transport (the Token-In provider
+// layer owns the non-streaming decisions request), so a suite stubs that.
+import jevAdvisoryRoutingExtension from "./jev-advisory-routing.ts";
+import { JEV_ROUTING_EVENT } from "./jev/decisions.ts";
+import {
+	enabledAdvisoryRoutes,
+	jevAnswers,
+	jevResponse,
+	makeHarness,
+	makeRepo,
+	writeJevSettings,
+	type SkillStub,
+} from "./jev/test-support.ts";
+
+const completeMock = vi.fn();
+
+
+
+let root: string;
+let repo: string;
+const skills: SkillStub[] = [{ name: "implanger", description: "Plan a UI change.", filePath: "/tmp/SKILL.md" }];
+
+beforeAll(() => {
+	const created = makeRepo("jev-lifecycle-");
+	root = created.root;
+	repo = created.repo;
+	state.settingsPath = join(root, "agent", "settings.json");
+	mkdirSync(join(root, "agent"), { recursive: true });
+});
+
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+
+/** One answer envelope carrying a decision for every route's questions. */
+function answerEverything(): void {
+	completeMock.mockResolvedValue(
+		jevResponse(
+			jevAnswers({
+				memory_target: { choice: "project", confidence: 0.9 },
+				memory_category: { choice: "convention", confidence: 0.9 },
+				recommendation: { choice: "skill:implanger", confidence: 0.8 },
+				verification: { choice: "targeted", confidence: 0.9 },
+			}),
+		),
+	);
+}
+
+function harness(advisory: unknown = { routes: enabledAdvisoryRoutes() }) {
+	writeJevSettings(state.settingsPath, advisory);
+	return makeHarness({
+		settingsPath: state.settingsPath,
+		extension: jevAdvisoryRoutingExtension,
+		cwd: repo,
+		skills,
+		complete: completeMock,
+	});
+}
+
+beforeEach(() => {
+	vi.clearAllMocks();
+});
+
+describe("enablement", () => {
+	it("does nothing at all while the routes stay disabled", async () => {
+		const session = harness({});
+		await session.fire("session_start");
+		expect(await session.advise("what conventions does this project follow?")).toBeUndefined();
+		expect(completeMock).not.toHaveBeenCalled();
+		expect(session.telemetry).toEqual([]);
+	});
+
+	it("combines every accepted route into one advisory message", async () => {
+		answerEverything();
+		const session = harness();
+		await session.fire("session_start");
+		const message = await session.advise("what conventions does this project follow?");
+		expect(message?.content).toContain('<jev-memory source="local-memory-search"');
+		expect(message?.content).toContain('route="recommendation"');
+		expect(message?.details).toEqual({
+			routes: [
+				{ route: "memory", item: "project" },
+				{ route: "recommendations", item: "skill:implanger" },
+			],
+		});
+		expect(completeMock).toHaveBeenCalledTimes(2);
+	});
+});
+
+describe("eligibility", () => {
+	it("ignores extension-injected, queued, command, and empty input", async () => {
+		answerEverything();
+		const session = harness();
+		await session.fire("session_start");
+
+		expect(await session.advise("do the thing", { source: "extension" })).toBeUndefined();
+		expect(await session.advise("do the thing", { streamingBehavior: "steer" })).toBeUndefined();
+		expect(await session.advise("do the thing", { streamingBehavior: "followUp" })).toBeUndefined();
+		expect(await session.advise("/implement")).toBeUndefined();
+		expect(await session.advise("   ")).toBeUndefined();
+		expect(completeMock).not.toHaveBeenCalled();
+		expect(session.telemetry).toEqual([]);
+	});
+
+	it("ignores a turn with no eligible input before it", async () => {
+		answerEverything();
+		const session = harness();
+		await session.fire("session_start");
+		const result = await session.fire("before_agent_start", {
+			type: "before_agent_start",
+			prompt: "an extension-injected turn",
+		});
+		expect(result).toBeUndefined();
+		expect(completeMock).not.toHaveBeenCalled();
+	});
+
+	it("forgets an eligible window a later input invalidates", async () => {
+		answerEverything();
+		const session = harness();
+		await session.fire("session_start");
+		await session.fire("input", { type: "input", text: "do the thing", source: "interactive" });
+		await session.fire("input", { type: "input", text: "/model", source: "interactive" });
+		const result = await session.fire("before_agent_start", { type: "before_agent_start", prompt: "/model" });
+		expect(result).toBeUndefined();
+		expect(completeMock).not.toHaveBeenCalled();
+	});
+});
+
+describe("idempotency", () => {
+	it("recommends once per turn, however often the hook is re-entered", async () => {
+		answerEverything();
+		const session = harness();
+		await session.fire("session_start");
+		const message = await session.advise("what conventions does this project follow?");
+		expect(message).toBeDefined();
+		expect(await session.replay("what conventions does this project follow?")).toBeUndefined();
+		expect(await session.replay("what conventions does this project follow?")).toBeUndefined();
+		expect(completeMock).toHaveBeenCalledTimes(2);
+	});
+
+	it("recommends again on the next prompt", async () => {
+		answerEverything();
+		const session = harness();
+		await session.fire("session_start");
+		expect(await session.advise("what conventions does this project follow?")).toBeDefined();
+		expect(await session.advise("and what else?")).toBeDefined();
+		expect(completeMock).toHaveBeenCalledTimes(3);
+	});
+
+	it("publishes nothing after the session shuts down", async () => {
+		answerEverything();
+		const session = harness();
+		await session.fire("session_start");
+		await session.fire("session_shutdown", { type: "session_shutdown", reason: "quit" });
+		await session.fire("input", { type: "input", text: "still there?", source: "interactive" });
+		expect(await session.replay("still there?")).toBeUndefined();
+	});
+});
+
+describe("telemetry", () => {
+	it("reports decisions, abstentions, and adoption without any content", async () => {
+		answerEverything();
+		const session = harness();
+		await session.fire("session_start");
+		await session.advise("what conventions does this project follow?");
+		await session.fire("agent_settled");
+
+		const [memory, recommendations, ...adoption] = session.telemetry;
+		expect(memory).toMatchObject({ event: "decision", route: "memory", outcome: "jev", item: "project", confidence: "high" });
+		expect(recommendations).toMatchObject({ event: "decision", route: "recommendations", outcome: "jev" });
+		expect(typeof memory.elapsedMs).toBe("number");
+		expect(adoption).toEqual([{ event: "adoption", route: "recommendations", item: "skill:implanger", adopted: false }]);
+
+		const serialized = JSON.stringify(session.telemetry);
+		expect(serialized).not.toContain("conventions");
+		expect(serialized).not.toContain("Plan a UI change");
+		expect(serialized).not.toContain("answers");
+	});
+
+	it("keeps routing when telemetry itself fails", async () => {
+		answerEverything();
+		const session = harness();
+		await session.fire("session_start");
+		// A subscriber that throws must not change what the parent receives.
+		(session.pi.events as { on(channel: string, handler: () => void): void }).on(JEV_ROUTING_EVENT, () => {
+			throw new Error("telemetry sink down");
+		});
+		const message = await session.advise("what conventions does this project follow?");
+		expect(message?.content).toContain("LOCAL_MEMORY_RESULT");
+	});
+});

package/dist/extensions/jev-advisory-memory.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Jev's memory lane is deliberately narrow: an explicit durable-memory cue
+ * chooses one local read-only scope, then Hermes performs that lookup.
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+const state = vi.hoisted(() => ({ settingsPath: "" }));
+
+vi.mock("@selesai/code", () => ({ getSettingsPath: () => state.settingsPath }));
+
+import jevAdvisoryRoutingExtension, {
+	activeProjectName,
+	hasMemoryCue,
+	MAX_MEMORY_QUERY_CHARS,
+	MAX_MEMORY_RESULT_CHARS,
+	memoryQuery,
+} from "./jev-advisory-routing.ts";
+const completeMock = vi.fn();
+
+import {
+	enabledAdvisoryRoutes,
+	jevAnswers,
+	jevResponse,
+	makeHarness,
+	makeRepo,
+	sentPayload,
+	writeJevSettings,
+	type AdvisoryHarness,
+} from "./jev/test-support.ts";
+
+const MEMORY_SECRETS = ["SECRET_MEMORY_ENTRY", "SECRET_USER_ENTRY", "SECRET_STANDING_RULE"];
+let root: string;
+let agentDir: string;
+let repo: string;
+
+beforeAll(() => {
+	const created = makeRepo("jev-memory-");
+	root = created.root;
+	repo = created.repo;
+	agentDir = join(root, "agent");
+	mkdirSync(agentDir, { recursive: true });
+	state.settingsPath = join(agentDir, "settings.json");
+	writeFileSync(join(agentDir, "MEMORY.md"), `- ${MEMORY_SECRETS[0]}\n`, "utf-8");
+	writeFileSync(join(agentDir, "USER.md"), `- ${MEMORY_SECRETS[1]}\n`, "utf-8");
+	writeFileSync(join(agentDir, "standing.md"), `- ${MEMORY_SECRETS[2]}\n`, "utf-8");
+});
+
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+
+type MemoryAnswer = { target: string; confidence?: number } | "malformed" | "rejected";
+
+function harness(
+	options: {
+		branch?: unknown[];
+		credential?: boolean;
+		answer?: MemoryAnswer;
+		memorySearch?: Parameters<typeof makeHarness>[0]["memorySearch"];
+	} = {},
+): AdvisoryHarness {
+	writeJevSettings(state.settingsPath, { routes: enabledAdvisoryRoutes(["memory"]) });
+	const session = makeHarness({
+		settingsPath: state.settingsPath,
+		extension: jevAdvisoryRoutingExtension,
+		cwd: repo,
+		branch: options.branch,
+		credential: options.credential,
+		complete: completeMock,
+		memorySearch: options.memorySearch,
+	});
+	const answer = options.answer ?? { target: "project" };
+	if (answer === "malformed") completeMock.mockResolvedValue(jevResponse("{ not json"));
+	else if (answer === "rejected") completeMock.mockRejectedValue(new Error("network down"));
+	else completeMock.mockResolvedValue(jevResponse(jevAnswers({ memory_target: { choice: answer.target, confidence: answer.confidence ?? 0.9 } })));
+	return session;
+}
+
+beforeEach(() => vi.clearAllMocks());
+
+describe("memory cues", () => {
+	it("only classifies explicit references to durable context", () => {
+		for (const prompt of ["use the convention we decided", "do it as before", "don't repeat the past failure", "what are my preferences?"]) {
+			expect(hasMemoryCue(prompt), prompt).toBe(true);
+		}
+		for (const prompt of ["fix the login crash", "tell me a joke about databases", "what are we doing lately?"]) {
+			expect(hasMemoryCue(prompt), prompt).toBe(false);
+		}
+	});
+
+	it("does not call Jev or local memory for a normal coding request", async () => {
+		const session = harness();
+		await session.fire("session_start");
+		expect(await session.advise("fix the login crash")).toBeUndefined();
+		expect(completeMock).not.toHaveBeenCalled();
+		expect(session.telemetry).toEqual([]);
+	});
+});
+
+describe("local read-only lookup", () => {
+	it("selects one scope, then injects the bounded local result", async () => {
+		const calls: unknown[] = [];
+		const session = harness({
+			answer: { target: "project" },
+			memorySearch: (input) => {
+				calls.push(input);
+				return { success: true, count: 1, output: "DEPLOYMENT_CONVENTION" };
+			},
+		});
+		await session.fire("session_start");
+		const message = await session.advise("use the deployment convention we decided");
+
+		expect(calls).toEqual([{ query: "use the deployment convention we decided", target: "project", project: "repo", limit: 5 }]);
+		expect(message?.content).toContain('<jev-memory source="local-memory-search" confidence="0.90">');
+		expect(message?.content).toContain("DEPLOYMENT_CONVENTION");
+		expect(message?.content).not.toContain("memory_search {");
+		expect(session.telemetry.at(-1)).toMatchObject({ route: "memory", outcome: "jev", item: "project" });
+	});
+
+	it("does not inject an unavailable, empty, or failed local result", async () => {
+		for (const result of [undefined, { success: true, count: 0 }, { success: false, message: "unavailable" }]) {
+			const session = harness({ answer: { target: "project" }, memorySearch: () => result });
+			await session.fire("session_start");
+			expect(await session.advise("use the convention we decided"), String(result)).toBeUndefined();
+			expect(session.telemetry.at(-1)).toMatchObject({ route: "memory", outcome: "fallback" });
+		}
+	});
+
+	it("bounds long local entries before they reach the turn", async () => {
+		const session = harness({ answer: { target: "memory" }, memorySearch: () => ({ success: true, output: "x".repeat(MAX_MEMORY_RESULT_CHARS + 100) }) });
+		await session.fire("session_start");
+		const message = await session.advise("what do you remember about our convention?");
+		expect(message?.content).toContain(`${"x".repeat(MAX_MEMORY_RESULT_CHARS)}…`);
+		expect(message?.content).not.toContain("x".repeat(MAX_MEMORY_RESULT_CHARS + 1));
+	});
+});
+
+describe("abstention and privacy", () => {
+	it("does not search for none, low confidence, malformed, rejected, or credential-less decisions", async () => {
+		const cases: Array<[string, MemoryAnswer, boolean | undefined]> = [
+			["none", { target: "none" }, undefined],
+			["low confidence", { target: "project", confidence: 0.2 }, undefined],
+			["malformed", "malformed", undefined],
+			["rejected", "rejected", undefined],
+			["no credential", { target: "project" }, false],
+		];
+		for (const [name, answer, credential] of cases) {
+			const memorySearch = vi.fn(() => ({ success: true, output: "SHOULD_NOT_SEARCH" }));
+			const session = harness({ answer, credential, memorySearch });
+			await session.fire("session_start");
+			expect(await session.advise("use the convention we decided"), name).toBeUndefined();
+			expect(memorySearch, name).not.toHaveBeenCalled();
+		}
+	});
+
+	it("sends Jev only the bounded current prompt, never history or memory contents", async () => {
+		const branch = [
+			{ type: "message", message: { role: "user", content: "OLDER_USER_TURN" } },
+			{ type: "message", message: { role: "assistant", content: "ASSISTANT_NARRATION" } },
+			{ type: "message", message: { role: "toolResult", content: "TOOL_OUTPUT" } },
+		];
+		const session = harness({ branch, memorySearch: () => ({ success: true, output: "LOCAL_MEMORY_RESULT" }) });
+		await session.fire("session_start");
+		await session.advise("what do you remember about our convention?");
+
+		const request = JSON.stringify(sentPayload(completeMock));
+		for (const forbidden of [...MEMORY_SECRETS, "OLDER_USER_TURN", "ASSISTANT_NARRATION", "TOOL_OUTPUT"]) {
+			expect(request, forbidden).not.toContain(forbidden);
+		}
+		expect(sentPayload(completeMock)?.state).toEqual({
+			conversation: [{ role: "user", text: "what do you remember about our convention?" }],
+		});
+	});
+});
+
+describe("query and project identity", () => {
+	it("derives a bounded plain-text query", () => {
+		expect(memoryQuery("  what   does\nthe release process look like? ")).toBe("what does the release process look like?");
+		expect(memoryQuery("Fix this\n```ts\nconst a = 1;\n```\nplease")).toBe("Fix this please");
+		expect(memoryQuery("word ".repeat(100))).toHaveLength(MAX_MEMORY_QUERY_CHARS);
+	});
+
+	it("uses the repository root name for project memory", () => {
+		expect(activeProjectName(repo)).toBe("repo");
+		const nested = join(repo, "src", "deep");
+		mkdirSync(nested, { recursive: true });
+		expect(activeProjectName(nested)).toBe("repo");
+		expect(activeProjectName(homedir())).toBeUndefined();
+	});
+});