feat(harness): re-anchor after session compaction

Author: pablontiv

extensions/gentle-ai.ts

@@ -1917,11 +1917,24 @@ Active discipline (el Gentleman harness):
 - Never fabricate persistent memory or capabilities; report failures honestly.
 </gentle-harness-reminder>`;
 
+const POST_COMPACTION_REMINDER_CONTENT = `Context was just compacted: earlier conversation details now exist only as a summary.
+Re-check current SDD/OpenSpec state on disk before continuing multi-step work, and restate scope and acceptance criteria for the active task before further changes.`;
+
+let compactionPending = false;
+
 function buildContextReminder(): ReturnType<typeof buildContextReminder> {
+	const baseContent = GENTLE_HARNESS_REMINDER_CONTENT;
+	let fullContent = baseContent;
+
+	if (compactionPending) {
+		fullContent = `${baseContent}\n\n${POST_COMPACTION_REMINDER_CONTENT}`;
+		compactionPending = false;
+	}
+
 	return {
 		role: "custom" as const,
 		customType: "gentle-harness-reminder",
-		content: GENTLE_HARNESS_REMINDER_CONTENT,
+		content: fullContent,
 		display: false,
 		timestamp: Date.now(),
 	};
@@ -1931,7 +1944,7 @@ function applyHarnessReminder(
 	messages: Array<{ customType?: string; role?: string } | unknown>,
 ): unknown[] {
 	// Strip all existing reminders and append fresh one
-	// This ensures exactly one reminder per context event
+	// This ensures exactly one reminder per context event and resets compactionPending flag
 	const filtered = messages.filter((msg) => {
 		if (!isRecord(msg)) return true;
 		return (msg as Record<string, unknown>).customType !== "gentle-harness-reminder";
@@ -1953,6 +1966,10 @@ export const __testing = {
 		getOrchestratorPromptImpl(pathOverride),
 	buildContextReminder,
 	applyHarnessReminder,
+	setCompactionPending: (value: boolean) => {
+		compactionPending = value;
+	},
+	getCompactionPending: () => compactionPending,
 };
 
 export default function gentleAi(pi: ExtensionAPI): void {
@@ -1966,6 +1983,8 @@ export default function gentleAi(pi: ExtensionAPI): void {
 
 	pi.on("session_start", async (_event, ctx) => {
 		try {
+			// Reset compaction state at session start to prevent reminder leakage across sessions
+			compactionPending = false;
 			const installResult = installSddAssets(ctx.cwd, true);
 			const modelResult = await applySavedModelConfig(ctx);
 			if (ctx.hasUI && modelResult.invalidPath) {
@@ -1993,6 +2012,10 @@ export default function gentleAi(pi: ExtensionAPI): void {
 		}
 	});
 
+	pi.on("session_compact", (_event, _ctx) => {
+		compactionPending = true;
+	});
+
 	pi.on("context", (event) => {
 		return { messages: applyHarnessReminder(event.messages) };
 	});

tests/gentle-ai.test.ts

@@ -137,3 +137,77 @@ test("applyHarnessReminder appends reminder as last message", async () => {
 	assert.equal(result[result.length - 1].customType, "gentle-harness-reminder");
 	assert.equal(result.length, 3);
 });
+
+test("buildContextReminder with compaction pending includes post-compaction block", async () => {
+	__testing.setCompactionPending(true);
+	const reminder = __testing.buildContextReminder();
+	assert.equal(reminder.role, "custom");
+	assert.equal(reminder.customType, "gentle-harness-reminder");
+	assert(
+		reminder.content.includes("Context was just compacted"),
+		"should include post-compaction block when pending"
+	);
+	assert(
+		reminder.content.includes("Re-check current SDD/OpenSpec state on disk"),
+		"should include re-check instruction"
+	);
+	assert(
+		reminder.content.includes("restate scope and acceptance criteria"),
+		"should include restate instruction"
+	);
+	// Verify flag is cleared after building
+	assert.equal(
+		__testing.getCompactionPending(),
+		false,
+		"flag should be cleared after one-shot use"
+	);
+});
+
+test("buildContextReminder without compaction pending returns standard reminder", async () => {
+	__testing.setCompactionPending(false);
+	const reminder = __testing.buildContextReminder();
+	const content = reminder.content;
+	assert(!content.includes("Context was just compacted"), "should not include post-compaction block when not pending");
+	assert(content.includes("Active discipline"), "should include standard discipline content");
+});
+
+test("setCompactionPending and getCompactionPending control flag", async () => {
+	__testing.setCompactionPending(true);
+	assert.equal(__testing.getCompactionPending(), true);
+	__testing.setCompactionPending(false);
+	assert.equal(__testing.getCompactionPending(), false);
+});
+
+test("applyHarnessReminder multi-turn scenario: reminder persists and refreshes correctly", async () => {
+	// Simulate first context event
+	__testing.setCompactionPending(false);
+	let messages: any[] = [{ role: "user", content: "first message" }];
+	let result = __testing.applyHarnessReminder(messages);
+	assert.equal(result[result.length - 1].customType, "gentle-harness-reminder", "first turn should have reminder");
+	const firstReminder = result[result.length - 1];
+
+	// Simulate second context event with new message appended (tool result)
+	messages = result;
+	messages.push({ role: "tool", content: "tool result" });
+	result = __testing.applyHarnessReminder(messages);
+
+	// Should have exactly one reminder and it should be fresh (not the old one)
+	const reminderCount = result.filter((m: any) => m.customType === "gentle-harness-reminder").length;
+	assert.equal(reminderCount, 1, "should still have exactly one reminder after multi-turn");
+	assert.equal(result[result.length - 1].customType, "gentle-harness-reminder", "reminder should be last");
+	// Verify it's a fresh reminder (timestamp should be different)
+	const secondReminder = result[result.length - 1];
+	assert(secondReminder.timestamp >= firstReminder.timestamp, "fresh reminder should have equal or newer timestamp");
+});
+
+test("compaction flag resets when applyHarnessReminder builds fresh reminder", async () => {
+	__testing.setCompactionPending(true);
+	assert.equal(__testing.getCompactionPending(), true, "flag should be set");
+
+	const messages: any[] = [];
+	const result = __testing.applyHarnessReminder(messages);
+
+	// Flag should now be reset by buildContextReminder call
+	assert.equal(__testing.getCompactionPending(), false, "flag should be reset after applyHarnessReminder");
+	assert(result[0].content.includes("Context was just compacted"), "reminder should include compaction content");
+});