mason: fix mid-turn release and redaction

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/cli/src/lib/diagnostics-pi.test.ts

@@ -3,7 +3,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { projectPathToPiDirSlug } from "../commands/migrate";
-import { collectDiagnostics } from "./diagnostics-pi";
+import { collectDiagnostics, sanitizeValue } from "./diagnostics-pi";
 
 const tempRoots: string[] = [];
 const originalHome = process.env.HOME;
@@ -35,6 +35,20 @@ afterEach(() => {
     }
 });
 
+describe("sanitizeValue Pi diagnostics redaction", () => {
+    it("preserves numeric thresholds while redacting string secrets", () => {
+        expect(
+            sanitizeValue({
+                execute_threshold_tokens: 200000,
+                api_key: "sk-x",
+            }),
+        ).toEqual({
+            execute_threshold_tokens: 200000,
+            api_key: "<REDACTED>",
+        });
+    });
+});
+
 describe("collectDiagnostics Pi path resolution", () => {
     it("reads recent sessions from PI_CODING_AGENT_DIR instead of HOME/.pi/agent", async () => {
         const root = makeTempRoot();

packages/cli/src/lib/diagnostics-pi.ts

@@ -206,6 +206,7 @@ function shouldRedactKey(key: string): boolean {
 }
 
 export function sanitizeValue(value: unknown, key = ""): unknown {
+    if (value === null || typeof value === "number" || typeof value === "boolean") return value;
     if (shouldRedactKey(key)) return "<REDACTED>";
     if (typeof value === "string") return sanitizeString(value);
     if (Array.isArray(value)) return value.map((entry) => sanitizeValue(entry));

packages/cli/src/lib/redaction.test.ts

@@ -142,6 +142,24 @@ describe("sanitizeConfigValue — preserves benign config keys", () => {
         expect(sanitized.execute_threshold_tokens.default).toBe(80000);
         expect(sanitized.execute_threshold_tokens["openai/gpt-5.5"]).toBe(200000);
     });
+
+    it("preserves non-string scalars under secret-looking keys", () => {
+        const sanitized = sanitizeConfigValue({
+            execute_threshold_tokens: 200000,
+            api_key: "sk-x",
+            access_token: 12345,
+            has_token: true,
+            refresh_token: null,
+        }) as Record<string, unknown>;
+
+        expect(sanitized).toEqual({
+            execute_threshold_tokens: 200000,
+            api_key: "<REDACTED:api_key>",
+            access_token: 12345,
+            has_token: true,
+            refresh_token: null,
+        });
+    });
 });
 
 describe("hasShareabilitySensitiveText", () => {

packages/pi-plugin/src/boundary-execution-pi.test.ts

@@ -73,7 +73,36 @@ describe("boundary execution Pi integration", () => {
 		expect(peekDeferredExecutePending(db, "s1")?.id).toBe("flag-1");
 	});
 
-	it("13. Pi boundary execute drains prior flag when work executes", () => {
+	it("13. Pi stale-tail release executes and drains prior flag on a fresh user turn", () => {
+		const db = createDb();
+		ensureSessionMetaRow(db, "s1");
+		setDeferredExecutePendingIfAbsent(db, "s1", flag());
+		const midTurn = isMidTurnPi(
+			{
+				messages: [
+					{ role: "assistant", stopReason: "toolUse", content: [] },
+					{ role: "user", content: "new turn" },
+				],
+			},
+			"s1",
+		);
+		const result = applyMidTurnDeferral({
+			base: "execute",
+			bypassReason: "none",
+			midTurn,
+		});
+
+		expect(midTurn).toBe(false);
+		expect(result.midTurnAdjustedSchedulerDecision).toBe("execute");
+		const current = peekDeferredExecutePending(db, "s1");
+		expect(current).not.toBeNull();
+		if (current !== null) {
+			clearDeferredExecutePendingIfMatches(db, "s1", current);
+		}
+		expect(peekDeferredExecutePending(db, "s1")).toBeNull();
+	});
+
+	it("14. Pi boundary execute drains prior flag when work executes", () => {
 		const db = createDb();
 		setDeferredExecutePendingIfAbsent(db, "s1", flag());
 		const current = peekDeferredExecutePending(db, "s1");
@@ -84,7 +113,7 @@ describe("boundary execution Pi integration", () => {
 		expect(peekDeferredExecutePending(db, "s1")).toBeNull();
 	});
 
-	it("14. Pi preserves flag when execute-gated work fails", () => {
+	it("15. Pi preserves flag when execute-gated work fails", () => {
 		const db = createDb();
 		ensureSessionMetaRow(db, "s1");
 		setDeferredExecutePendingIfAbsent(db, "s1", flag());
@@ -96,7 +125,7 @@ describe("boundary execution Pi integration", () => {
 		expect(peekDeferredExecutePending(db, "s1")?.id).toBe("flag-1");
 	});
 
-	it("15. a prior deferred flag does NOT promote a defer decision to execute (parity with OpenCode contract #4)", () => {
+	it("16. a prior deferred flag does NOT promote a defer decision to execute (parity with OpenCode contract #4)", () => {
 		// Regression: Pi previously force-promoted schedulerDecision defer→execute
 		// whenever a deferred-execute flag existed and the pass wasn't mid-turn,
 		// diverging from OpenCode (which treats the flag as drain-on-success ONLY

packages/pi-plugin/src/read-session-pi.test.ts

@@ -20,6 +20,34 @@ describe("isMidTurnPi", () => {
 		).toBe(true);
 	});
 
+	it("is not mid-turn when a newer real user message ends a stale toolUse tail", () => {
+		expect(
+			isMidTurnPi(
+				{
+					messages: [
+						{ role: "assistant", stopReason: "toolUse", content: [] },
+						{ role: "user", content: "new turn" },
+					],
+				},
+				"session-1",
+			),
+		).toBe(false);
+	});
+
+	it("does not release mid-turn for custom-role nudges after a stale toolUse tail", () => {
+		expect(
+			isMidTurnPi(
+				{
+					messages: [
+						{ role: "assistant", stopReason: "toolUse", content: [] },
+						{ role: "custom", content: "agent nudge" },
+					],
+				},
+				"session-1",
+			),
+		).toBe(true);
+	});
+
 	it("is mid-turn when the latest assistant has an unpaired toolCall", () => {
 		expect(
 			isMidTurnPi(
@@ -36,6 +64,23 @@ describe("isMidTurnPi", () => {
 		).toBe(true);
 	});
 
+	it("is not mid-turn when a newer real user message ends an unpaired toolCall tail", () => {
+		expect(
+			isMidTurnPi(
+				{
+					messages: [
+						{
+							role: "assistant",
+							content: [{ type: "toolCall", id: "call-1", name: "bash" }],
+						},
+						{ role: "user", content: "new turn" },
+					],
+				},
+				"session-1",
+			),
+		).toBe(false);
+	});
+
 	it("is not mid-turn when toolCall content is paired or absent", () => {
 		expect(
 			isMidTurnPi(

packages/pi-plugin/src/read-session-pi.ts

@@ -163,6 +163,7 @@ export function isMidTurnPi(event: unknown, _sessionId: string): boolean {
 	}
 
 	if (latestAssistant === null) return false;
+	if (hasRealUserAfter(messages, latestAssistantIndex)) return false;
 	if (latestAssistant.stopReason === "toolUse") return true;
 
 	const toolCallIds = getToolCallIds(latestAssistant.content);
@@ -184,6 +185,21 @@ export function isMidTurnPi(event: unknown, _sessionId: string): boolean {
 	return false;
 }
 
+function hasRealUserAfter(
+	messages: readonly unknown[],
+	latestAssistantIndex: number,
+): boolean {
+	// If an interrupted assistant tool-use sequence is followed by a real user
+	// message, treat that user message as the turn boundary so the next pass can
+	// finish any work held back during tool-use. Custom-role nudge messages are
+	// not real user turns, so they should not trigger the boundary.
+	for (const msg of messages.slice(latestAssistantIndex + 1)) {
+		if (msg === null || typeof msg !== "object") continue;
+		if ((msg as Record<string, unknown>).role === "user") return true;
+	}
+	return false;
+}
+
 function getToolCallIds(content: unknown): Set<string> {
 	const ids = new Set<string>();
 	if (!Array.isArray(content)) return ids;

packages/plugin/src/hooks/magic-context/read-session-db.test.ts

@@ -46,10 +46,23 @@ function insertAssistant(
     sessionId: string,
     id: string,
     data: Record<string, unknown>,
+    timeCreated = Date.now(),
 ): void {
     db.prepare(
         "INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)",
-    ).run(id, sessionId, Date.now(), Date.now(), JSON.stringify({ role: "assistant", ...data }));
+    ).run(id, sessionId, timeCreated, timeCreated, JSON.stringify({ role: "assistant", ...data }));
+}
+
+function insertUser(
+    db: Database,
+    sessionId: string,
+    id: string,
+    data: Record<string, unknown>,
+    timeCreated: number,
+): void {
+    db.prepare(
+        "INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)",
+    ).run(id, sessionId, timeCreated, timeCreated, JSON.stringify({ role: "user", ...data }));
 }
 
 function insertPart(
@@ -67,14 +80,30 @@ function insertPart(
 describe("isMidTurnFromOpenCodeDb", () => {
     it("is mid-turn when the latest assistant finished with tool-calls", () => {
         const db = createMidTurnDb();
-        insertAssistant(db, "session-1", "assistant-1", { finish: "tool-calls" });
+        insertAssistant(db, "session-1", "assistant-1", { finish: "tool-calls" }, 100);
+
+        expect(isMidTurnFromOpenCodeDb(db, "session-1")).toBe(true);
+    });
+
+    it("is not mid-turn when a newer real user message ends a stale tool-calls tail", () => {
+        const db = createMidTurnDb();
+        insertAssistant(db, "session-1", "assistant-1", { finish: "tool-calls" }, 100);
+        insertUser(db, "session-1", "user-1", { content: "new turn" }, 200);
+
+        expect(isMidTurnFromOpenCodeDb(db, "session-1")).toBe(false);
+    });
+
+    it("does not release mid-turn for synthetic user messages after a stale tool-calls tail", () => {
+        const db = createMidTurnDb();
+        insertAssistant(db, "session-1", "assistant-1", { finish: "tool-calls" }, 100);
+        insertUser(db, "session-1", "user-1", { content: "agent nudge", synthetic: true }, 200);
 
         expect(isMidTurnFromOpenCodeDb(db, "session-1")).toBe(true);
     });
 
     it("is mid-turn when the latest assistant has a non-provider-executed tool part", () => {
         const db = createMidTurnDb();
-        insertAssistant(db, "session-1", "assistant-1", { finish: "stop" });
+        insertAssistant(db, "session-1", "assistant-1", { finish: "stop" }, 100);
         insertPart(db, "session-1", "assistant-1", "part-1", {
             type: "tool",
             providerExecuted: false,
@@ -83,6 +112,18 @@ describe("isMidTurnFromOpenCodeDb", () => {
         expect(isMidTurnFromOpenCodeDb(db, "session-1")).toBe(true);
     });
 
+    it("is not mid-turn when a newer real user message ends an unexecuted tool tail", () => {
+        const db = createMidTurnDb();
+        insertAssistant(db, "session-1", "assistant-1", { finish: "stop" }, 100);
+        insertPart(db, "session-1", "assistant-1", "part-1", {
+            type: "tool",
+            providerExecuted: false,
+        });
+        insertUser(db, "session-1", "user-1", { content: "new turn" }, 200);
+
+        expect(isMidTurnFromOpenCodeDb(db, "session-1")).toBe(false);
+    });
+
     it("is not mid-turn for provider-executed tool parts", () => {
         const db = createMidTurnDb();
         insertAssistant(db, "session-1", "assistant-1", { finish: "stop" });

packages/plugin/src/hooks/magic-context/read-session-db.ts

@@ -12,6 +12,11 @@ interface RawCountRow {
 interface AssistantMidTurnRow {
     id?: string;
     finish?: string | null;
+    timeCreated?: number;
+}
+
+interface ExistenceRow {
+    one?: number;
 }
 
 interface PartDataRow {
@@ -96,7 +101,8 @@ export function isMidTurnFromOpenCodeDb(db: Database, sessionId: string): boolea
     const latestAssistant = db
         .prepare(
             `SELECT id,
-                    json_extract(data, '$.finish') as finish
+                    json_extract(data, '$.finish') as finish,
+                    time_created as timeCreated
              FROM message
              WHERE session_id = ?
                AND json_extract(data, '$.role') = 'assistant'
@@ -106,6 +112,7 @@ export function isMidTurnFromOpenCodeDb(db: Database, sessionId: string): boolea
         .get(sessionId) as AssistantMidTurnRow | null;
 
     if (typeof latestAssistant?.id !== "string") return false;
+    if (hasNewerRealUserMessage(db, sessionId, latestAssistant.timeCreated)) return false;
     if (latestAssistant.finish === "tool-calls") return true;
 
     const partRows = db
@@ -123,6 +130,30 @@ export function isMidTurnFromOpenCodeDb(db: Database, sessionId: string): boolea
     });
 }
 
+function hasNewerRealUserMessage(
+    db: Database,
+    sessionId: string,
+    latestAssistantTimeCreated: unknown,
+): boolean {
+    if (typeof latestAssistantTimeCreated !== "number") return false;
+    const row = db
+        .prepare(
+            `SELECT 1 as one
+             FROM message
+             WHERE session_id = ?
+               AND time_created > ?
+               AND json_extract(data, '$.role') = 'user'
+               AND COALESCE(json_extract(data, '$.synthetic'), 0) NOT IN (1, 'true')
+             LIMIT 1`,
+        )
+        .get(sessionId, latestAssistantTimeCreated) as ExistenceRow | null;
+    // OpenCode persists promptAsync/channel-2 synthetic prompts as
+    // message.info.synthetic, which is the top-level $.synthetic field in the
+    // message table's data JSON. Those agent-directed nudges should not end a
+    // still-accumulating tool-use turn, but a later real user message does.
+    return row?.one === 1;
+}
+
 interface AssistantModelRow {
     providerID?: string;
     modelID?: string;

packages/plugin/src/shared/redaction.ts

@@ -244,6 +244,7 @@ export function hasShareabilitySensitiveText(text: string): boolean {
 }
 
 export function sanitizeConfigValue(value: unknown, keyPath: string[] = []): unknown {
+    if (value === null || typeof value === "number" || typeof value === "boolean") return value;
     const key = keyPath.at(-1) ?? "";
     if (key && isSecretKey(key)) {
         return `<REDACTED:${redactionTypeForKey(key)}>`;