@retaw106/mmc-oc 2.1.2 → 2.2.1

package/dist/web/main.js

@@ -1086,7 +1086,7 @@ init_logger();
 init_logger();
 
 // src/shared/pi-executable.ts
-var PI_IMAGE_NAMES = new Set(["pi", "pi.cmd"]);
+var PI_IMAGE_NAMES = new Set(["pi", "pi.cmd", "omp", "oh-my-pi"]);
 
 // src/shared/rpc-utils.ts
 var ownRpcServerInstanceIds = new Set;
@@ -4781,6 +4781,11 @@ var MEMORY_MAINTAINER_MANIFEST_CONTRACT = [
 // src/v2/hooks/hidden-child.ts
 init_tag_content_primitives();
 init_logger();
+
+// src/shared/subagent-runner.ts
+var HISTORIAN_STEP_CAP = 4;
+
+// src/v2/hooks/hidden-child.ts
 var HIDDEN_HISTORIAN_AGENT = "historian";
 var AGENT_TOOL_ALLOWLIST = {
   [HIDDEN_HISTORIAN_AGENT]: [],
@@ -4788,7 +4793,8 @@ var AGENT_TOOL_ALLOWLIST = {
   [MEMORY_MAINTAINER_B_AGENT]: MEMORY_MAINTAINER_B_ALLOWED_TOOLS
 };
 var AGENT_STEP_CAPS = {
-  [MEMORY_MAINTAINER_A_AGENT]: MEMORY_MAINTAINER_A_STEP_CAP
+  [MEMORY_MAINTAINER_A_AGENT]: MEMORY_MAINTAINER_A_STEP_CAP,
+  [HIDDEN_HISTORIAN_AGENT]: HISTORIAN_STEP_CAP
 };
 
 // src/v2/hidden-child-record.ts

package/dist/{wrapup-orchestrator-9spy01n8.js → wrapup-orchestrator-yknks3ad.js}

@@ -21,10 +21,10 @@ import {
   getActiveCompartmentRun,
   markActiveCompartmentRunPublished,
   registerActiveCompartmentRun
-} from "./index-ys43j25b.js";
+} from "./index-5b7x80ec.js";
 import"./index-1j34a56j.js";
 import"./index-x37vg474.js";
-import"./index-cszxqtev.js";
+import"./index-btp5tdc8.js";
 import"./index-ramz5kkm.js";
 import {
   pushNotification2
@@ -37,7 +37,7 @@ import {
 import {
   setRecompStarting2,
   setRecompTerminal2
-} from "./index-pynrjyjy.js";
+} from "./index-g2z2k5m4.js";
 import"./index-33gprt9g.js";
 
 // src/hooks/magic-context/wrapup-orchestrator.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retaw106/mmc-oc",
-  "version": "2.1.2",
+  "version": "2.2.1",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

package/src/agents/memory-maintainer.ts

@@ -40,6 +40,18 @@ export const MEMORY_MAINTAINER_B_ALLOWED_TOOLS = ["read", "grep", "glob"] as con
  */
 export const MEMORY_MAINTAINER_A_STEP_CAP = 4;
 
+/**
+ * The next attempt's physical cap: the budget minus what earlier rounds of
+ * this agent already consumed, floored at 1 — even a fully consumed budget
+ * still owes the child one apply to emit its final manifest.
+ *
+ * Lives here (next to the constants) so the OC2 adapter and the Pi
+ * maintenance runner share one definition (moved from oc2-adapter.ts).
+ */
+export function resolveMaintenanceStepCap(baseSteps: number, consumedSteps: number): number {
+    return Math.max(1, baseSteps - consumedSteps);
+}
+
 /** Stage A system prompt: identity + the hard rules that bound a zero-tool screen. */
 export const MEMORY_MAINTAINER_A_SYSTEM_PROMPT = [
     "You are the memory-maintenance stage A screener: a hidden background agent that",

package/src/config/index.test.ts

@@ -689,12 +689,6 @@ describe("loadPluginConfig — variable expansion scope", () => {
 });
 
 describe("loadPluginConfig — user-only settings", () => {
-    it("allows user config to disable auto_update", () => {
-        const result = loadWithUserConfig(JSON.stringify({ auto_update: false }));
-
-        expect(result.auto_update).toBe(false);
-    });
-
     it("allows user config to opt in to an exact home project", () => {
         const result = loadWithUserConfig(JSON.stringify({ allow_home_project: true }));
 
@@ -711,17 +705,6 @@ describe("loadPluginConfig — user-only settings", () => {
         expect(result.configWarnings?.join("\n")).toContain("Ignoring allow_home_project");
     });
 
-    it("prevents project config from overriding user auto_update", () => {
-        const result = loadWithUserAndProjectConfig(
-            JSON.stringify({ auto_update: true, enabled: true }),
-            JSON.stringify({ auto_update: false, enabled: false }),
-        );
-
-        expect(result.auto_update).toBe(true);
-        expect(result.enabled).toBe(false);
-        expect(result.configWarnings?.join("\n")).toContain("Ignoring auto_update");
-    });
-
     it("keeps historian model selection user-owned when project config tries to override it", () => {
         const result = loadWithUserAndProjectConfig(
             JSON.stringify({

package/src/config/project-security.test.ts

@@ -23,14 +23,6 @@ describe("stripUnsafeProjectConfigFields", () => {
         expect(warnings.join("\n")).toContain("Ignoring profiles from project config");
     });
 
-    it("strips auto_update from project config", () => {
-        const raw: Record<string, unknown> = { auto_update: false, historian: { two_pass: true } };
-        const warnings = stripUnsafeProjectConfigFields(raw);
-        expect("auto_update" in raw).toBe(false);
-        expect(raw.historian).toEqual({ two_pass: true });
-        expect(warnings.some((w) => w.includes("auto_update"))).toBe(true);
-    });
-
     it("strips fail_closed_blocking from project config (user-tier only)", () => {
         const raw: Record<string, unknown> = {
             fail_closed_blocking: false,

package/src/config/project-security.ts

@@ -296,8 +296,6 @@ function makeProjectThresholdWarning(field: string, reason: string): string {
  *  - `profiles` — profile definitions choose hidden-agent models and must stay
  *    in trusted user config; a repository may select a named profile but cannot
  *    supply its contents.
- *  - `auto_update` — a repo must not suppress plugin self-updates (which can
- *    carry security fixes).
  *  - `fail_closed_blocking` — a repo must not un-block (or force-block) the
  *    loud inoperability gate; only the user may restore silent degrade.
  *  - `debug_rpc` — a repo must not enable process heap capture or memory diagnostics.
@@ -341,13 +339,6 @@ export function stripUnsafeProjectConfigFields(projectRaw: Record<string, unknow
         );
     }
 
-    if ("auto_update" in projectRaw) {
-        delete projectRaw.auto_update;
-        warnings.push(
-            "Ignoring auto_update from project config (security: this setting only honors user-level config).",
-        );
-    }
-
     if ("fail_closed_blocking" in projectRaw) {
         delete projectRaw.fail_closed_blocking;
         warnings.push(

package/src/config/protected-tools.test.ts

@@ -0,0 +1,72 @@
+import { expect, it } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { protectedToolTagNumbers } from "../features/magic-context/reclaim-protection";
+import { createTestTempDirFromPath } from "../shared/test-temp-dir";
+import { loadPluginConfigDetailed } from ".";
+import { MagicContextConfigSchema } from "./schema/magic-context";
+
+it("protected_tools defaults, validation, active-only ordinals and zero override", () => {
+    expect(MagicContextConfigSchema.parse({}).protected_tools).toEqual({
+        todowrite: 1,
+        mmc_reduce: 3,
+    });
+    for (const value of [-1, 1.5, "2", null])
+        expect(
+            MagicContextConfigSchema.safeParse({ protected_tools: { custom: value } }).success,
+        ).toBe(false);
+    const tags = [1, 2, 3, 4, 5].map((tagNumber) => ({
+        tagNumber,
+        toolName: tagNumber % 2 ? "MCP_CUSTOM" : "custom",
+        type: "tool",
+        status: tagNumber === 5 ? "compacted" : tagNumber === 4 ? "dropped" : "active",
+    }));
+    expect([...protectedToolTagNumbers(tags, { custom: 2 })]).toEqual([3, 2]);
+    expect([...protectedToolTagNumbers(tags, { custom: 0 })]).toEqual([]);
+});
+
+it("protected_tools does not treat inherited object keys as configured tools", () => {
+    const tags = ["constructor", "__proto__"].map((toolName, i) => ({
+        tagNumber: i + 1,
+        toolName,
+        type: "tool",
+        status: "active",
+    }));
+    expect([...protectedToolTagNumbers(tags)]).toEqual([]);
+    expect([...protectedToolTagNumbers(tags, { constructor: 1 })]).toEqual([1]);
+});
+
+it("protected_tools merges normalized project keys over user and shipped defaults", () => {
+    const dir = createTestTempDirFromPath(join(tmpdir(), "protected-tools-config-"));
+    const old = process.env.XDG_CONFIG_HOME;
+    const oldConfigDir = process.env.OPENCODE_CONFIG_DIR;
+    try {
+        delete process.env.OPENCODE_CONFIG_DIR;
+        const project = join(dir, "project");
+        // Fork layout: user config at <XDG_CONFIG_HOME>/opencode/mmc.jsonc,
+        // project config at <project>/.mmc/mmc.jsonc.
+        mkdirSync(join(dir, "opencode"), { recursive: true });
+        mkdirSync(join(project, ".mmc"), { recursive: true });
+        writeFileSync(
+            join(dir, "opencode/mmc.jsonc"),
+            JSON.stringify({ protected_tools: { MCP_CUSTOM: 3, todowrite: 0 } }),
+        );
+        writeFileSync(
+            join(project, ".mmc/mmc.jsonc"),
+            JSON.stringify({ protected_tools: { custom: 2, CTX_REDUCE: 1 } }),
+        );
+        process.env.XDG_CONFIG_HOME = dir;
+        expect(loadPluginConfigDetailed(project).config.protected_tools).toEqual({
+            custom: 2,
+            todowrite: 0,
+            mmc_reduce: 1,
+        });
+    } finally {
+        if (old === undefined) delete process.env.XDG_CONFIG_HOME;
+        else process.env.XDG_CONFIG_HOME = old;
+        if (oldConfigDir === undefined) delete process.env.OPENCODE_CONFIG_DIR;
+        else process.env.OPENCODE_CONFIG_DIR = oldConfigDir;
+        rmSync(dir, { recursive: true, force: true });
+    }
+});

package/src/config/schema/magic-context.test.ts

@@ -84,7 +84,6 @@ describe("MagicContextConfigSchema", () => {
                 enabled: true,
                 allow_home_project: false,
                 fail_closed_blocking: true,
-                auto_update: false,
                 toast_duration_ms: 5000,
                 cache_ttl: "10m",
                 prompt_surface: { default: "full" },
@@ -181,11 +180,6 @@ describe("MagicContextConfigSchema", () => {
             expect(result.historian?.disable).toBe(true);
         });
 
-        it("accepts optional auto_update user preference", () => {
-            expect(MagicContextConfigSchema.parse({ auto_update: false }).auto_update).toBe(false);
-            expect(MagicContextConfigSchema.parse({ auto_update: true }).auto_update).toBe(true);
-        });
-
         it("accepts an explicitly configured Pi subagent extension allowlist", () => {
             expect(
                 MagicContextConfigSchema.parse({

package/src/config/schema/magic-context.ts

@@ -249,10 +249,6 @@ export interface MagicContextConfig {
     enabled: boolean;
     /** User-level setting that lets a session in the canonical home directory use project memory. */
     allow_home_project: boolean;
-    /** DEPRECATED no-op: the auto-update check was removed (2026-10-05) — the package is
-     *  private-registry-only, so public npm checks always failed. The key is still accepted
-     *  (USER config only; project configs stripped) so existing configs keep parsing. */
-    auto_update?: boolean;
     /** Output language for generated Magic Context prose. USER config only. */
     language?: string;
     /** Active user-owned model profile after user/project resolution. */
@@ -436,12 +432,7 @@ export const MagicContextConfigSchema = z.object({
         .describe(
             "Allow Magic Context sessions launched from the exact canonical home directory. A non-git home uses its deterministic dir: identity; a home repository uses its git: identity. USER-LEVEL ONLY: project config is ignored. The home identity is excluded from registry seed exports, never resolves descendants by containment, and cannot join a workspace.",
         ),
-    auto_update: z
-        .boolean()
-        .optional()
-        .describe(
-            "DEPRECATED no-op: the automatic update check was removed (the package is private-registry-only, so public npm checks always 404). The key is still accepted so existing configs keep parsing; upgrade via the host's own plugin update channel.",
-        ),
+
     language: z
         .string()
         .trim()

package/src/shared/fold-render-lock-fence.test.ts

@@ -0,0 +1,84 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import ts from "typescript";
+
+const root = resolve(import.meta.dir, "../../../../");
+
+for (const [host, path, functions] of [
+    [
+        "OpenCode",
+        "packages/plugin/src/hooks/magic-context/inject-compartments.ts",
+        ["materializeM0", "softRefreshCachedM1"],
+    ],
+    [
+        "Pi",
+        "packages/pi-plugin/src/inject-compartments-pi.ts",
+        ["materializeM0Pi", "softRefreshCachedM1Pi"],
+    ],
+] as const) {
+    test(`${host} fold and refresh render m[1] inside their writer section`, () => {
+        const source = ts.createSourceFile(
+            path,
+            readFileSync(resolve(root, path), "utf8"),
+            ts.ScriptTarget.Latest,
+            true,
+        );
+        const inspected: string[] = [];
+        const violations: string[] = [];
+        function visit(node: ts.Node): void {
+            if (
+                ts.isFunctionDeclaration(node) &&
+                node.name &&
+                functions.some((name) => name === node.name?.text)
+            ) {
+                inspected.push(node.name.text);
+                const calls: ts.CallExpression[] = [];
+                function collect(child: ts.Node): void {
+                    if (ts.isCallExpression(child)) calls.push(child);
+                    ts.forEachChild(child, collect);
+                }
+                collect(node);
+                const admission = calls.find(
+                    (call) =>
+                        call.expression.getText(source).endsWith(".exec") &&
+                        call.arguments[0]?.getText(source) === '"BEGIN IMMEDIATE"',
+                );
+                expect(admission).toBeDefined();
+                const commit = calls.find(
+                    (call) =>
+                        admission &&
+                        call.pos > admission.pos &&
+                        call.expression.getText(source).endsWith(".exec") &&
+                        call.arguments[0]?.getText(source) === '"COMMIT"',
+                );
+                expect(commit).toBeDefined();
+                const renders = calls.filter((call) =>
+                    /^renderM1(?:Pi)?WithMetadata$/.test(call.expression.getText(source)),
+                );
+                expect(renders).toHaveLength(1);
+                for (const render of renders) {
+                    if (
+                        !admission ||
+                        !commit ||
+                        render.pos < admission.pos ||
+                        render.pos > commit.pos
+                    )
+                        violations.push(`${node.name.text}: m[1] render outside writer`);
+                }
+                for (const call of calls) {
+                    if (
+                        call.expression.getText(source).endsWith("onFoldPrepare") &&
+                        admission &&
+                        call.pos > admission.pos
+                    )
+                        violations.push(`${node.name.text}: wire preparation inside writer`);
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(source);
+        expect(inspected.sort()).toEqual([...functions].sort());
+        expect(violations).toEqual([]);
+    });
+}

package/src/shared/fold-render-lock-fixtures.test.ts

@@ -0,0 +1,270 @@
+import { expect, test } from "bun:test";
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { appendCompartments } from "../features/magic-context/compartment-storage";
+import {
+    insertMemory,
+    setMemoryClassification,
+    updateMemorySeenCount,
+    updateMemoryVerification,
+} from "../features/magic-context/memory/storage-memory";
+import {
+    recordIndexedMessageTime,
+    recordMessageFtsRowid,
+} from "../features/magic-context/message-fts-rowid-map";
+import { runMigrations } from "../features/magic-context/migrations";
+import { getOrCreateSessionMeta } from "../features/magic-context/storage";
+import { initializeDatabase } from "../features/magic-context/storage-db";
+import { renderMemoryBlockV2 } from "../hooks/magic-context/inject-compartments";
+import { estimateTokens } from "../hooks/magic-context/read-session-formatting";
+import { Database } from "./sqlite";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+// Fork policy (P2-fold-runtime): upstream's "recovered compartment ranges"
+// template depends on the compartment_history_versions bookkeeping table,
+// which upstream added deliberately and this fork chose NOT to adopt
+// (P4:64 / oc-core correction 24). The template is intentionally not ported
+// and no assertion was weakened to compensate.
+
+export interface LockedDeltaFixture {
+    db: Database;
+    sibling: Database;
+    directory: string;
+    sessionId: string;
+    projectPath: string;
+    close: () => void;
+}
+
+export function createLockedDeltaFixture(
+    label: string,
+    open?: (path: string) => Database,
+): LockedDeltaFixture {
+    const directory = createTestTempDirFromPath(join(tmpdir(), `mc-locked-delta-${label}-`));
+    const path = join(directory, "context.db");
+    const db = open ? open(path) : new Database(path);
+    if (!open) {
+        initializeDatabase(db);
+        runMigrations(db);
+    }
+    db.exec("PRAGMA journal_mode=WAL");
+    const sibling = new Database(path);
+    const sessionId = label;
+    const projectPath = "git:locked-delta";
+    getOrCreateSessionMeta(db, sessionId);
+    return {
+        db,
+        sibling,
+        directory,
+        sessionId,
+        projectPath,
+        close: () => {
+            sibling.close();
+            db.close();
+            rmSync(directory, { recursive: true, force: true });
+        },
+    };
+}
+export interface LockedDeltaOptions {
+    memoryBudget?: number;
+    temporalAwareness?: boolean;
+}
+interface LockedDeltaDriver<Markers> {
+    host: string;
+    create: (label: string) => LockedDeltaFixture;
+    materialize: (fixture: LockedDeltaFixture, options: LockedDeltaOptions) => Markers;
+    refresh: (
+        fixture: LockedDeltaFixture,
+        options: LockedDeltaOptions,
+        beforeAdmission: () => void,
+    ) => void;
+    render: (fixture: LockedDeltaFixture, options: LockedDeltaOptions, markers: Markers) => string;
+    temporalHeadings?: boolean;
+    /**
+     * OpenCode's refresh exposes a production admission callback
+     * (beforeCacheCommitForTest). Pi has no such field and this fork adds none:
+     * when false, the sibling write is interposed by wrapping the routed
+     * db.exec and running it immediately BEFORE the first delegated
+     * "BEGIN IMMEDIATE" of the refresh call.
+     */
+    usesAdmissionCallback?: boolean;
+}
+function compartment() {
+    return {
+        sequence: 0,
+        startMessage: 1,
+        endMessage: 2,
+        startMessageId: "a",
+        endMessageId: "b",
+        title: "locked history",
+        content: "locked history",
+        p1: "locked history",
+        p2: "summary",
+        p3: "outcome",
+        p4: "anchor",
+        legacy: 0,
+    };
+}
+function persistedDelta(f: LockedDeltaFixture): string {
+    return getOrCreateSessionMeta(f.db, f.sessionId).cachedM1Bytes?.toString("utf8") ?? "";
+}
+function refreshAtAdmission<Markers>(
+    driver: LockedDeltaDriver<Markers>,
+    f: LockedDeltaFixture,
+    options: LockedDeltaOptions,
+    write: () => void,
+) {
+    let admissions = 0;
+    let hooks = 0;
+    const usesCallback = driver.usesAdmissionCallback !== false;
+    // Capture the currently routed exec (writer accounting intact); delegate
+    // through the original reference and restore that same reference on exit —
+    // never bypass the routing with a raw native binding.
+    const originalExec = f.db.exec;
+    f.db.exec = (sql) => {
+        if (sql === "BEGIN IMMEDIATE") {
+            admissions++;
+            if (!usesCallback && admissions === 1 && hooks === 0) {
+                hooks++;
+                write();
+            }
+        }
+        return originalExec.call(f.db, sql);
+    };
+    try {
+        driver.refresh(
+            f,
+            options,
+            usesCallback
+                ? () => {
+                      expect(admissions).toBe(0);
+                      hooks++;
+                      write();
+                  }
+                : () => {},
+        );
+        expect(hooks).toBe(1);
+        // Exactly one writer section per refresh for BOTH variants: the
+        // interposed write must hit the refresh's own admission, not an
+        // unrelated earlier transaction.
+        expect(admissions).toBe(1);
+    } finally {
+        f.db.exec = originalExec;
+    }
+}
+
+/** These fixtures use real sibling writes, then compare persisted bytes to an independent live render. */
+export function registerLockedDeltaRegressions<Markers>(driver: LockedDeltaDriver<Markers>): void {
+    for (const change of ["importance", "reinforcement", "verification"] as const) {
+        test(`${driver.host} m[1] reads memory ${change} under its writer`, () => {
+            const f = driver.create(`${driver.host}-${change}`);
+            try {
+                const sample = insertMemory(f.db, {
+                    projectPath: "git:budget-only",
+                    category: "ARCHITECTURE",
+                    content: "candidate A ".repeat(40),
+                });
+                const options = {
+                    memoryBudget:
+                        4 * (estimateTokens(renderMemoryBlockV2([sample], "new-memories")) + 2),
+                };
+                const markers = driver.materialize(f, options);
+                const a = insertMemory(f.db, {
+                    projectPath: f.projectPath,
+                    category: "ARCHITECTURE",
+                    content: "candidate A ".repeat(40),
+                });
+                const b = insertMemory(f.db, {
+                    projectPath: f.projectPath,
+                    category: "ARCHITECTURE",
+                    content: "candidate B ".repeat(40),
+                });
+                setMemoryClassification(f.db, a.id, { importance: 50 });
+                setMemoryClassification(f.db, b.id, { importance: 50 });
+                f.db
+                    .prepare(
+                        "UPDATE memories SET last_seen_at = CASE WHEN id = ? THEN 1000 ELSE 0 END, verified_at = NULL WHERE id IN (?, ?)",
+                    )
+                    .run(a.id, a.id, b.id);
+                const before = driver.render(f, options, markers);
+                expect(before).toContain("candidate A");
+                expect(before).not.toContain("candidate B");
+                refreshAtAdmission(driver, f, options, () => {
+                    if (change === "importance")
+                        setMemoryClassification(f.sibling, b.id, { importance: 100 });
+                    else if (change === "reinforcement") updateMemorySeenCount(f.sibling, b.id);
+                    else updateMemoryVerification(f.sibling, b.id, "verified");
+                });
+                const fresh = driver.render(f, options, markers);
+                expect(fresh).toContain("candidate B");
+                expect(fresh).not.toContain("candidate A");
+                expect(persistedDelta(f)).toBe(fresh);
+                expect(persistedDelta(f)).not.toBe(before);
+            } finally {
+                f.close();
+            }
+        });
+    }
+
+    test(`${driver.host} m[1] uses the baseline cutoff for a newly expired additive memory`, () => {
+        const f = driver.create(`${driver.host}-expiry`);
+        const realNow = Date.now;
+        let now = 1000;
+        Date.now = () => now;
+        try {
+            const options = {};
+            const markers = driver.materialize(f, options);
+            now = 2000;
+            const before = driver.render(f, options, markers);
+            expect(before).not.toContain("eligible at the baseline cutoff");
+            refreshAtAdmission(driver, f, options, () => {
+                insertMemory(f.sibling, {
+                    projectPath: f.projectPath,
+                    category: "ARCHITECTURE",
+                    content: "Memory eligible at the baseline cutoff",
+                    expiresAt: 2500,
+                });
+                now = 3000;
+            });
+            const fresh = driver.render(f, options, markers);
+            expect(fresh).toContain("eligible at the baseline cutoff");
+            expect(persistedDelta(f)).toBe(fresh);
+        } finally {
+            Date.now = realNow;
+            f.close();
+        }
+    });
+
+    if (driver.temporalHeadings) {
+        test(`${driver.host} m[1] reads indexed temporal headings under its writer`, () => {
+            const f = driver.create(`${driver.host}-dates`);
+            const originalXdgDataHome = process.env.XDG_DATA_HOME;
+            process.env.XDG_DATA_HOME = f.directory;
+            try {
+                const options = { temporalAwareness: true };
+                const markers = driver.materialize(f, options);
+                appendCompartments(f.db, f.sessionId, [compartment()]);
+                for (const ordinal of [1, 2])
+                    recordMessageFtsRowid(f.db, f.sessionId, ordinal, ordinal);
+                const before = driver.render(f, options, markers);
+                expect(before).not.toContain("2025-01-01");
+                refreshAtAdmission(driver, f, options, () => {
+                    for (const ordinal of [1, 2])
+                        recordIndexedMessageTime(
+                            f.sibling,
+                            f.sessionId,
+                            ordinal,
+                            Date.UTC(2025, 0, 1),
+                        );
+                });
+                const fresh = driver.render(f, options, markers);
+                expect(fresh).toContain("2025-01-01");
+                expect(persistedDelta(f)).toBe(fresh);
+            } finally {
+                if (originalXdgDataHome === undefined) delete process.env.XDG_DATA_HOME;
+                else process.env.XDG_DATA_HOME = originalXdgDataHome;
+                f.close();
+            }
+        });
+    }
+}

package/src/shared/pi-executable.ts

@@ -1,7 +1,7 @@
-export type PiExecutableHarnessKind = "pi";
+export type PiExecutableHarnessKind = "pi" | "omp";
 
 /** Executable images recognized as Pi-compatible hosts. */
-export const PI_IMAGE_NAMES = new Set(["pi", "pi.cmd"]);
+export const PI_IMAGE_NAMES = new Set(["pi", "pi.cmd", "omp", "oh-my-pi"]);
 
 /** Classify a process title or executable path using the shared Pi image vocabulary. */
 export function piHarnessKindFromExecutable(
@@ -16,5 +16,5 @@ export function piHarnessKindFromExecutable(
         ?.toLowerCase()
         .replace(/\.(?:exe|cmd)$/, "");
     if (!executable || !PI_IMAGE_NAMES.has(executable)) return undefined;
-    return "pi";
+    return executable === "pi" ? "pi" : "omp";
 }