fix: close 3 P1s from the fix-delta re-audit (merge gate, v36 seed, Pi ownership)

Re-audit of the audit-fix commits surfaced 3 P1s against the zero-P1 ship bar:

P1 #1 — ctx_memory MERGE skipped the workspace category gate. My earlier P0 fix
routed update/archive through memoryVisibleToTool but left merge on the weaker
memoryBelongsToProject / storedPathBelongsToIdentity (the commit comment claimed
parity it didn't have). A primary agent could thus consolidate a foreign member's
memory in a non-shared category — the exact invisible-mutation the P0 closed for
update/archive. Routed merge through memoryVisibleToTool on BOTH harnesses.
+2 plugin regression tests (foreign non-shared merge refused; foreign shared
merge allowed).

P1 #2 — v36 created session_projects empty, so every session chunk-embedded
BEFORE v36 became invisible to the project-scoped backfill/count JOINs. Seed the
table in the migration from compartment_chunk_embeddings (the only pre-existing
source carrying session_id+harness+project_path — compartments has NO project_path
column, so the auditor's proposed SELECT FROM compartments was unrunnable).
Seed only unambiguous sessions (single distinct project_path); ambiguous
pre-scope-bug sessions are left for the idempotent heal path. Guarded on the
source table existing. +1 seed test (single-project seeded per-harness, ambiguous
skipped).

P1 #3 — Pi never recorded session→project ownership (grep-confirmed zero calls),
so Pi-published compartments were invisible to /ctx-embed-history's project scope.
Wired recordSessionProjectIdentity into Pi's updateSessionProjectTracking, fired
only on the once-per-(session,identity) transition it already detects — ctx.cwd
is authoritative in Pi so every observation is host-safe; no per-pass write.

Context the auditors lacked (verified via callgraph): the project-WIDE passive
sweep is test-only now (its dream-timer driver was removed in 9a91ac7); the only
live backfill is /ctx-embed-history, which already self-records ownership. So #2/#3
were latent (half-populated table) rather than a live-path break — fixed anyway so
the v36 table ships complete.

plugin 2029/0, Pi 461/0, biome clean both.

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

Author: ualtinok

packages/pi-plugin/src/context-handler.ts

@@ -52,6 +52,7 @@ import {
 	parseCacheTtl,
 	type Scheduler,
 } from "@magic-context/core/features/magic-context/scheduler";
+import { recordSessionProjectIdentity } from "@magic-context/core/features/magic-context/session-project-storage";
 import {
 	adoptFallbackTagMessageId,
 	type ContextDatabase,
@@ -443,6 +444,7 @@ function isContextHandlerSessionActive(sessionId: string): boolean {
 function updateSessionProjectTracking(
 	sessionId: string,
 	projectIdentity: string,
+	db?: ContextDatabase,
 ): void {
 	const prev = lastSeenProjectIdentityBySession.get(sessionId);
 	if (prev && prev !== projectIdentity) {
@@ -451,6 +453,21 @@ function updateSessionProjectTracking(
 		if (prevSessions?.size === 0) sessionsByProject.delete(prev);
 		clearPiSystemPromptSession(sessionId);
 	}
+	// Persist the session→project ownership binding so the project-scoped
+	// compartment-chunk backfill (/ctx-embed-history) can attribute this
+	// session's compartments to the right project. ctx.cwd is the authoritative
+	// session directory in Pi (no SDK/launch-dir ambiguity), so every observation
+	// is host-safe. Guarded to the once-per-(session,identity) transition — only
+	// on first sight or an actual identity change — so steady-state passes carry
+	// no per-pass DB write. embedSessionCompartmentChunks also self-records, so
+	// this only widens coverage to passively-published sessions.
+	if (db && prev !== projectIdentity) {
+		try {
+			recordSessionProjectIdentity(db, sessionId, projectIdentity);
+		} catch {
+			// best-effort; backfill re-records on demand from the session command
+		}
+	}
 	trackSessionForProject(projectIdentity, sessionId);
 	lastSeenProjectIdentityBySession.set(sessionId, projectIdentity);
 }
@@ -1373,7 +1390,7 @@ export function registerPiContextHandler(
 			const schedulerConfig = options.scheduler ?? DEFAULT_SCHEDULER_CONFIG;
 			const scheduler = schedulerFor(options);
 			const projectIdentity = resolveProjectIdentity(projectDirectory);
-			updateSessionProjectTracking(sessionId, projectIdentity);
+			updateSessionProjectTracking(sessionId, projectIdentity, options.db);
 			logTransformTiming(
 				sessionId,
 				"findSessionId",

packages/pi-plugin/src/tools/ctx-memory.ts

@@ -472,10 +472,7 @@ export function createCtxMemoryTool(
 				// must not reach into ANOTHER project's memories — mirror
 				// update/archive ownership (parity with OpenCode).
 				if (!dreamerAllowed) {
-					const foreign = sourceMemories.find(
-						(memory) =>
-							!storedPathBelongsToIdentity(memory.projectPath, projectIdentity),
-					);
+					const foreign = sourceMemories.find((memory) => !memoryVisibleToTool(memory));
 					if (foreign) {
 						return err(`Error: Memory with ID ${foreign.id} was not found.`);
 					}

packages/plugin/src/features/magic-context/migrations-v36.test.ts

@@ -63,4 +63,48 @@ describe("migration v36 — session project ownership", () => {
             closeQuietly(db);
         }
     });
+
+    test("v36 seeds ownership for already-chunk-embedded sessions, skipping ambiguous ones", () => {
+        const db = new Database(":memory:");
+        try {
+            // A v35 DB whose chunk-embedding table predates the ownership map.
+            db.exec(`
+                CREATE TABLE schema_migrations (version INTEGER PRIMARY KEY, description TEXT NOT NULL, applied_at INTEGER NOT NULL);
+                INSERT INTO schema_migrations (version, description, applied_at) VALUES (35, 'pre-v36 fixture', 1);
+                CREATE TABLE compartment_chunk_embeddings (
+                    compartment_id INTEGER NOT NULL,
+                    session_id TEXT NOT NULL,
+                    harness TEXT NOT NULL DEFAULT 'opencode',
+                    project_path TEXT NOT NULL,
+                    window_index INTEGER NOT NULL,
+                    chunk_hash TEXT NOT NULL,
+                    model_id TEXT NOT NULL,
+                    vector BLOB NOT NULL
+                );
+                -- clean single-project session (two windows, same project): seed it
+                INSERT INTO compartment_chunk_embeddings VALUES (1,'sesA','opencode','git:alpha',0,'h1','m',x'00');
+                INSERT INTO compartment_chunk_embeddings VALUES (1,'sesA','opencode','git:alpha',1,'h2','m',x'00');
+                -- same session id under a DIFFERENT harness: independent ownership row
+                INSERT INTO compartment_chunk_embeddings VALUES (2,'sesA','pi','git:beta',0,'h3','m',x'00');
+                -- ambiguous session (pre-scope bug split across two projects): skip
+                INSERT INTO compartment_chunk_embeddings VALUES (3,'sesB','opencode','git:gamma',0,'h4','m',x'00');
+                INSERT INTO compartment_chunk_embeddings VALUES (3,'sesB','opencode','git:delta',0,'h5','m',x'00');
+            `);
+
+            runMigrations(db);
+
+            const rows = db
+                .prepare(
+                    "SELECT session_id, harness, project_path FROM session_projects ORDER BY session_id, harness",
+                )
+                .all();
+            // sesA/opencode→alpha and sesA/pi→beta seeded; sesB skipped (ambiguous).
+            expect(rows).toEqual([
+                { session_id: "sesA", harness: "opencode", project_path: "git:alpha" },
+                { session_id: "sesA", harness: "pi", project_path: "git:beta" },
+            ]);
+        } finally {
+            closeQuietly(db);
+        }
+    });
 });

packages/plugin/src/features/magic-context/migrations.ts

@@ -1407,6 +1407,32 @@ const MIGRATIONS: Migration[] = [
                 CREATE INDEX IF NOT EXISTS idx_session_projects_project
                     ON session_projects(project_path);
             `);
+            // Seed ownership for sessions that were ALREADY chunk-embedded before
+            // this table existed, so their compartments stay visible to the
+            // project-scoped backfill/count JOINs (a fresh table would otherwise
+            // hide every pre-v36 embedded session until re-observed). The only
+            // trustworthy pre-existing source is compartment_chunk_embeddings
+            // itself, which already carries (session_id, harness, project_path).
+            // NOTE: compartments has no project_path column — do not read from it.
+            // Seed ONLY unambiguous sessions (a single distinct project_path);
+            // skip any session whose chunks are split across projects (the
+            // pre-scope bug) so the heal path, not a coin-flip, decides its owner.
+            // Guarded on the source table existing — it is created at v33, so any
+            // real upgrade has it, but a partial/older fixture might not.
+            const hasChunkTable = db
+                .prepare(
+                    "SELECT 1 FROM sqlite_master WHERE type='table' AND name='compartment_chunk_embeddings'",
+                )
+                .get();
+            if (hasChunkTable) {
+                db.exec(`
+                    INSERT OR IGNORE INTO session_projects (session_id, harness, project_path, updated_at)
+                    SELECT session_id, harness, MIN(project_path), 0
+                    FROM compartment_chunk_embeddings
+                    GROUP BY session_id, harness
+                    HAVING COUNT(DISTINCT project_path) = 1;
+                `);
+            }
         },
     },
 ];

packages/plugin/src/tools/ctx-memory/tools.test.ts

@@ -511,6 +511,77 @@ describe("createCtxMemoryTools", () => {
         expect(getMemoryById(db, own.id)?.status).toBe("archived");
     });
 
+    it("REFUSES a PRIMARY merge that pulls in a foreign memory in a NON-shared category", async () => {
+        // merge MUST gate on the same own/foreign-by-category visibility as
+        // update/archive: a primary agent cannot consolidate a foreign member's
+        // memory it can't even see in its rendered context.
+        db.exec(`
+                INSERT INTO workspaces (id, name, created_at, updated_at, share_categories)
+                VALUES (1, 'ws', 1, 1, '["CONSTRAINTS"]');
+                INSERT INTO workspace_members (workspace_id, project_path, display_name, display_path, added_at)
+                VALUES (1, '/repo/project', 'Own', '/repo/project', 1),
+                       (1, '/repo/foreign', 'Foreign', '/repo/foreign', 1);
+            `);
+        const own = insertMemory(db, {
+            projectPath: "/repo/project",
+            category: "ARCHITECTURE",
+            content: "Own architecture detail A.",
+        });
+        const foreignHidden = insertMemory(db, {
+            projectPath: "/repo/foreign",
+            category: "ARCHITECTURE",
+            content: "Foreign architecture detail not shared with this project.",
+        });
+
+        const result = await tools.ctx_memory.execute(
+            {
+                action: "merge",
+                ids: [own.id, foreignHidden.id],
+                content: "Merged architecture detail.",
+                category: "ARCHITECTURE",
+            },
+            toolContext(),
+        );
+
+        expect(result).toContain(`Memory with ID ${foreignHidden.id} was not found`);
+        expect(getMemoryById(db, own.id)?.status).toBe("active");
+        expect(getMemoryById(db, foreignHidden.id)?.status).toBe("active");
+    });
+
+    it("allows a PRIMARY merge of a foreign memory in a SHARED category", async () => {
+        db.exec(`
+                INSERT INTO workspaces (id, name, created_at, updated_at, share_categories)
+                VALUES (1, 'ws', 1, 1, '["CONSTRAINTS"]');
+                INSERT INTO workspace_members (workspace_id, project_path, display_name, display_path, added_at)
+                VALUES (1, '/repo/project', 'Own', '/repo/project', 1),
+                       (1, '/repo/foreign', 'Foreign', '/repo/foreign', 1);
+            `);
+        const own = insertMemory(db, {
+            projectPath: "/repo/project",
+            category: "CONSTRAINTS",
+            content: "Own constraint A.",
+        });
+        const foreignShared = insertMemory(db, {
+            projectPath: "/repo/foreign",
+            category: "CONSTRAINTS",
+            content: "Foreign constraint shared with this project.",
+        });
+
+        const result = await tools.ctx_memory.execute(
+            {
+                action: "merge",
+                ids: [own.id, foreignShared.id],
+                content: "Merged shared constraint.",
+                category: "CONSTRAINTS",
+            },
+            toolContext(),
+        );
+
+        expect(result).not.toContain("was not found");
+        expect(getMemoryById(db, own.id)?.status).toBe("archived");
+        expect(getMemoryById(db, foreignShared.id)?.status).toBe("archived");
+    });
+
     describe("#given update action", () => {
         it("updates a foreign workspace memory with duplicate checks and mutations under the target identity", async () => {
             db.exec(`

packages/plugin/src/tools/ctx-memory/tools.ts

@@ -493,9 +493,7 @@ function createCtxMemoryTool(deps: CtxMemoryToolDeps): ToolDefinition {
                 // its own resolved project. The dreamer keeps the cross-identity
                 // path (see the "merging across identities" test).
                 if (toolContext.agent !== DREAMER_AGENT) {
-                    const foreign = sourceMemories.find(
-                        (memory) => !memoryBelongsToProject(memory, projectPath),
-                    );
+                    const foreign = sourceMemories.find((memory) => !memoryVisibleToTool(memory));
                     if (foreign) {
                         return `Error: Memory with ID ${foreign.id} was not found.`;
                     }