@cortexkit/opencode-magic-context 0.41.2 → 0.41.3

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

@@ -307,6 +307,19 @@ describe("MagicContextConfigSchema", () => {
                                 },
                                 thinking_level: "high",
                             },
+                            omp: {
+                                model: {
+                                    model: "opencode/work-historian",
+                                    thinking_level: "auto",
+                                },
+                                fallback_models: [
+                                    {
+                                        model: "opencode/work-historian-fallback",
+                                        thinking_level: "inherit",
+                                    },
+                                ],
+                                thinking_level: "max",
+                            },
                         },
                         dreamer: {
                             opencode: {
@@ -329,6 +342,16 @@ describe("MagicContextConfigSchema", () => {
                                 ],
                                 thinking_level: "high",
                             },
+                            omp: {
+                                model: "opencode/work-dreamer",
+                                fallback_models: [
+                                    {
+                                        model: "opencode/work-dreamer-fallback",
+                                        thinking_level: "auto",
+                                    },
+                                ],
+                                thinking_level: "inherit",
+                            },
                         },
                         sidekick: {
                             model: "anthropic/work-sidekick",
@@ -349,6 +372,10 @@ describe("MagicContextConfigSchema", () => {
             expect(result.profiles?.work?.dreamer?.pi?.fallback_models).toEqual([
                 { model: "openai/work-dreamer-fallback", thinking_level: "minimal" },
             ]);
+            expect(result.profiles?.work?.historian?.omp?.fallback_models).toEqual([
+                { model: "opencode/work-historian-fallback", thinking_level: "inherit" },
+            ]);
+            expect(result.profiles?.work?.dreamer?.omp?.thinking_level).toBe("inherit");
             expect(result.profiles?.work?.sidekick?.model).toBe("anthropic/work-sidekick");
         });
 
@@ -484,6 +511,14 @@ describe("MagicContextConfigSchema", () => {
                         fallback_models: ["openai/gpt-5.4"],
                         thinking_level: "medium",
                     },
+                    omp: {
+                        model: {
+                            model: "opencode/gpt-5.4",
+                            thinking_level: "auto",
+                        },
+                        fallback_models: [{ model: "openai/gpt-5.4", thinking_level: "inherit" }],
+                        thinking_level: "max",
+                    },
                 },
                 dreamer: {
                     disable: false,
@@ -518,6 +553,29 @@ describe("MagicContextConfigSchema", () => {
                             },
                         },
                     },
+                    omp: {
+                        model: "opencode/gpt-5.4",
+                        fallback_models: [
+                            { model: "opencode/gpt-5.4-mini", thinking_level: "auto" },
+                        ],
+                        thinking_level: "inherit",
+                        tasks: {
+                            verify: {
+                                model: {
+                                    model: "opencode/gpt-5.4",
+                                    thinking_level: "max",
+                                },
+                                fallback_models: [
+                                    {
+                                        model: "opencode/gpt-5.4-mini",
+                                        thinking_level: "off",
+                                    },
+                                ],
+                                thinking_level: "auto",
+                                timeout_minutes: 30,
+                            },
+                        },
+                    },
                 },
             });
 
@@ -527,12 +585,18 @@ describe("MagicContextConfigSchema", () => {
                 promotion_threshold: 4,
             });
             expect(result.dreamer?.opencode?.tasks?.verify?.timeout_minutes).toBe(30);
+            expect(result.historian?.omp?.model).toEqual({
+                model: "opencode/gpt-5.4",
+                thinking_level: "auto",
+            });
+            expect(result.dreamer?.omp?.tasks?.verify?.thinking_level).toBe("auto");
         });
 
         it("rejects cross-harness vocabulary, non-array fallbacks, and execution fields at metadata depth", () => {
             const invalidConfigs = [
                 { historian: { opencode: { thinking_level: "high" } } },
                 { historian: { pi: { variant: "high" } } },
+                { historian: { omp: { variant: "high" } } },
                 {
                     dreamer: {
                         opencode: { tasks: { verify: { thinking_level: "high" } } },

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

@@ -36,6 +36,12 @@ export const PiThinkingLevelSchema = z
     .optional();
 export type PiThinkingLevel = z.infer<typeof PiThinkingLevelSchema>;
 
+/** OMP accepts Pi's thinking levels plus host-managed inheritance and automatic selection. */
+export const OmpThinkingLevelSchema = z
+    .enum(["off", "minimal", "low", "medium", "high", "xhigh", "max", "inherit", "auto"])
+    .optional();
+export type OmpThinkingLevel = z.infer<typeof OmpThinkingLevelSchema>;
+
 /** Pi-only child-process controls. This block is intentionally optional so an
  * absent allowlist preserves Pi's normal extension discovery behavior. */
 export const PiConfigSchema = z
@@ -157,6 +163,9 @@ export const PER_HARNESS_MIGRATION_INVENTORY = {
     },
 } as const;
 
+/** Harness keys that own independent hidden-agent model-selection blocks. */
+export const PER_HARNESS_MODEL_KEYS = ["opencode", "pi", "omp"] as const;
+
 /** OpenCode entry objects permit `variant` and reject Pi-only `thinking_level`. */
 const OcEntryObjectSchema = z
     .object({
@@ -177,6 +186,16 @@ const PiEntryObjectSchema = z
 export const PiEntrySchema = z.union([z.string(), PiEntryObjectSchema]);
 export type PiEntry = z.infer<typeof PiEntrySchema>;
 
+/** OMP entry objects use Pi's qualifier vocabulary, including OMP-only auto/inherit. */
+const OmpEntryObjectSchema = z
+    .object({
+        model: z.string().describe("OMP model ID (for example, provider/model)."),
+        thinking_level: OmpThinkingLevelSchema.describe("OMP thinking level for this entry."),
+    })
+    .strict();
+export const OmpEntrySchema = z.union([z.string(), OmpEntryObjectSchema]);
+export type OmpEntry = z.infer<typeof OmpEntrySchema>;
+
 /** Strict model-resolution block used by historian.opencode. */
 export const OpenCodeHarnessBlockSchema = z
     .object({
@@ -216,6 +235,22 @@ export const PiHarnessBlockSchema = z
     .describe("Strict Pi model-resolution block. It accepts no OpenCode vocabulary.");
 export type PiHarnessBlock = z.infer<typeof PiHarnessBlockSchema>;
 
+/** Strict model-resolution block used by historian.omp. */
+export const OmpHarnessBlockSchema = z
+    .object({
+        model: OmpEntrySchema.optional().describe("Primary OMP model entry."),
+        fallback_models: z
+            .array(OmpEntrySchema)
+            .optional()
+            .describe("Ordered fallback OMP entries."),
+        thinking_level: OmpThinkingLevelSchema.describe(
+            "OMP thinking level for the primary entry when it declares none. Fallback entries declare thinking levels per-entry.",
+        ),
+    })
+    .strict()
+    .describe("Strict OMP model-resolution block. It accepts no OpenCode vocabulary.");
+export type OmpHarnessBlock = z.infer<typeof OmpHarnessBlockSchema>;
+
 /** Strict OpenCode-only execution override for one dreamer task. */
 export const OpenCodeTaskExecutionSchema = z
     .object({
@@ -259,6 +294,26 @@ export const PiTaskExecutionSchema = z
     .strict();
 export type PiTaskExecution = z.infer<typeof PiTaskExecutionSchema>;
 
+/** Strict OMP-only execution override for one dreamer task. */
+export const OmpTaskExecutionSchema = z
+    .object({
+        model: OmpEntrySchema.optional().describe("OMP model entry for this task."),
+        fallback_models: z
+            .array(OmpEntrySchema)
+            .optional()
+            .describe("Ordered OMP fallback entries for this task."),
+        thinking_level: OmpThinkingLevelSchema.describe(
+            "OMP thinking level for this task's primary entry when it declares none. Fallback entries declare thinking levels per-entry.",
+        ),
+        timeout_minutes: z
+            .number()
+            .min(5)
+            .optional()
+            .describe("Minutes allowed for this task before it is aborted."),
+    })
+    .strict();
+export type OmpTaskExecution = z.infer<typeof OmpTaskExecutionSchema>;
+
 /** Strict OpenCode harness block for dreamer execution and task overrides. */
 export const DreamerOpenCodeHarnessBlockSchema = z
     .object({
@@ -310,6 +365,28 @@ export const DreamerPiHarnessBlockSchema = z
     .describe("Strict Pi dreamer model-resolution block. It accepts no OpenCode vocabulary.");
 export type DreamerPiHarnessBlock = z.infer<typeof DreamerPiHarnessBlockSchema>;
 
+/** Strict OMP harness block for dreamer execution and task overrides. */
+export const DreamerOmpHarnessBlockSchema = z
+    .object({
+        model: OmpEntrySchema.optional().describe("Primary OMP model entry."),
+        fallback_models: z
+            .array(OmpEntrySchema)
+            .optional()
+            .describe("Ordered fallback OMP entries."),
+        thinking_level: OmpThinkingLevelSchema.describe(
+            "OMP thinking level for the primary entry when it declares none. Fallback entries declare thinking levels per-entry.",
+        ),
+        tasks: z
+            .record(z.string(), OmpTaskExecutionSchema)
+            .optional()
+            .describe(
+                "OMP task execution overrides. Each named task accepts only model, fallback_models, thinking_level, and timeout_minutes.",
+            ),
+    })
+    .strict()
+    .describe("Strict OMP dreamer model-resolution block. It accepts no OpenCode vocabulary.");
+export type DreamerOmpHarnessBlock = z.infer<typeof DreamerOmpHarnessBlockSchema>;
+
 /**
  * A profile may select models but must not alter execution policy. Keep this
  * separate from the full harness schemas, whose dreamer blocks also admit task
@@ -342,16 +419,31 @@ const ProfilePiModelBlockSchema = z
     })
     .strict()
     .describe("Strict profile-only Pi model-selection block.");
+const ProfileOmpModelBlockSchema = z
+    .object({
+        model: OmpEntrySchema.optional().describe("Primary OMP model entry."),
+        fallback_models: z
+            .array(OmpEntrySchema)
+            .optional()
+            .describe("Ordered fallback OMP model entries."),
+        thinking_level: OmpThinkingLevelSchema.describe(
+            "OMP thinking level for the primary model entry.",
+        ),
+    })
+    .strict()
+    .describe("Strict profile-only OMP model-selection block.");
 const ProfileHistorianSchema = z
     .object({
         opencode: ProfileOpenCodeModelBlockSchema.optional(),
         pi: ProfilePiModelBlockSchema.optional(),
+        omp: ProfileOmpModelBlockSchema.optional(),
     })
     .strict();
 const ProfileDreamerSchema = z
     .object({
         opencode: ProfileOpenCodeModelBlockSchema.optional(),
         pi: ProfilePiModelBlockSchema.optional(),
+        omp: ProfileOmpModelBlockSchema.optional(),
     })
     .strict();
 const ProfileSidekickSchema = AgentOverrideConfigSchema.pick({
@@ -502,7 +594,7 @@ export const DreamTasksSchema = z
         ),
     })
     .describe(
-        "Harness-independent task metadata. schedule, promotion_threshold, and other task metadata remain here; execution settings live under dreamer.opencode.tasks or dreamer.pi.tasks.",
+        "Harness-independent task metadata. schedule, promotion_threshold, and other task metadata remain here; execution settings live under dreamer.opencode.tasks, dreamer.pi.tasks, or dreamer.omp.tasks.",
     );
 
 const AgentMetadataSchema = AgentOverrideConfigSchema.pick({
@@ -519,10 +611,11 @@ const AgentMetadataSchema = AgentOverrideConfigSchema.pick({
     maxTokens: true,
 });
 
-/** Combined dreamer metadata plus two independent strict execution blocks. */
+/** Combined dreamer metadata plus independent strict execution blocks. */
 export const DreamerConfigSchema = AgentMetadataSchema.extend({
     opencode: DreamerOpenCodeHarnessBlockSchema.optional(),
     pi: DreamerPiHarnessBlockSchema.optional(),
+    omp: DreamerOmpHarnessBlockSchema.optional(),
     tasks: DreamTasksSchema.default(() => DreamTasksSchema.parse({})),
     inject_docs: z
         .boolean()
@@ -544,11 +637,12 @@ export type SidekickConfig = NonNullable<z.infer<typeof SidekickConfigSchema>>;
 
 /**
  * Historian metadata remains harness-independent. Only model resolution moves to
- * the strict opencode and pi blocks; two_pass and disallowed_tools stay here.
+ * the strict opencode, pi, and omp blocks; two_pass and disallowed_tools stay here.
  */
 export const HistorianConfigSchema = AgentMetadataSchema.extend({
     opencode: OpenCodeHarnessBlockSchema.optional(),
     pi: PiHarnessBlockSchema.optional(),
+    omp: OmpHarnessBlockSchema.optional(),
     two_pass: z
         .boolean()
         .default(false)
@@ -986,13 +1080,13 @@ export const MagicContextConfigSchema = z
                 "Select a named user-owned model profile. A valid project name overrides this user default; an empty string, null, or other non-string project value is ignored with a warning so the user selection still applies. Unknown names warn and use the base configuration.",
             ),
         profiles: ConfigProfilesSchema.optional().describe(
-            "User-level named model profiles. A profile may contain only historian/dreamer model, fallback_models, OpenCode variant, and Pi thinking_level fields plus sidekick model-selection fields; task execution policy (including timeout_minutes) is excluded. Project configs may select a name but cannot define profiles.",
+            "User-level named model profiles. A profile may contain only historian/dreamer model, fallback_models, OpenCode variant, and Pi/OMP thinking_level fields plus sidekick model-selection fields; task execution policy (including timeout_minutes) is excluded. Project configs may select a name but cannot define profiles.",
         ),
         historian: HistorianConfigSchema.describe(
-            "Historian metadata plus independent strict OpenCode and Pi execution blocks. Retained metadata stays at historian; model, fallback_models, variant, and thinking_level belong only in historian.opencode or historian.pi.",
+            "Historian metadata plus independent strict OpenCode, Pi, and OMP execution blocks. Retained metadata stays at historian; model, fallback_models, variant, and thinking_level belong only in historian.opencode, historian.pi, or historian.omp.",
         ),
         dreamer: DreamerConfigSchema.optional().describe(
-            "Dreamer metadata and scheduling plus independent strict OpenCode and Pi execution blocks. schedule and promotion_threshold stay at dreamer.tasks; model, fallback_models, variant, thinking_level, and timeout_minutes belong only in the matching harness block.",
+            "Dreamer metadata and scheduling plus independent strict OpenCode, Pi, and OMP execution blocks. schedule and promotion_threshold stay at dreamer.tasks; model, fallback_models, variant, thinking_level, and timeout_minutes belong only in the matching harness block.",
         ),
         smart_notes: z
             .object({

package/src/shared/conflict-detector.test.ts

@@ -653,5 +653,29 @@ describe("detectConflicts", () => {
             const result = await resolveCompactionForBoot(client, 20);
             expect(result).toBeNull();
         });
+
+        it("aborts the host request when its boot timeout expires", async () => {
+            let requestSignal: AbortSignal | undefined;
+            const client = {
+                config: {
+                    get: (options?: { signal?: AbortSignal }) => {
+                        requestSignal = options?.signal;
+                        return new Promise<{ data?: unknown }>((_resolve, reject) => {
+                            options?.signal?.addEventListener(
+                                "abort",
+                                () => reject(options.signal?.reason ?? new Error("aborted")),
+                                { once: true },
+                            );
+                        });
+                    },
+                },
+            };
+
+            const result = await resolveCompactionForBoot(client, 20);
+
+            expect(result).toBeNull();
+            expect(requestSignal).toBeDefined();
+            expect(requestSignal?.aborted).toBe(true);
+        });
     });
 });

package/src/shared/conflict-detector.ts

@@ -209,7 +209,7 @@ export function detectConflicts(
  */
 export interface OpencodeConfigClientLike {
     config: {
-        get: () => Promise<{ data?: unknown }>;
+        get: (options?: { signal?: AbortSignal }) => Promise<{ data?: unknown }>;
     };
 }
 
@@ -250,13 +250,29 @@ export async function resolveCompactionForBoot(
     client: OpencodeConfigClientLike,
     timeoutMs = 2_000,
 ): Promise<ResolvedCompaction | null> {
+    const controller = new AbortController();
+    let timer: ReturnType<typeof setTimeout> | undefined;
     try {
-        const result = await Promise.race([
-            client.config.get(),
-            new Promise<never>((_, reject) =>
-                setTimeout(() => reject(new Error("config.get() timed out")), timeoutMs),
-            ),
-        ]);
+        // Install the deadline before invoking the generated SDK method. During
+        // OpenCode bootstrap, /config can recursively wait for the same project
+        // instance that is currently loading this plugin. Deferring invocation
+        // ensures the deadline exists before any synchronous SDK/fetch prefix runs.
+        const timeout = new Promise<null>((resolve) => {
+            timer = setTimeout(
+                () => {
+                    controller.abort(new Error("config.get() timed out"));
+                    resolve(null);
+                },
+                Math.max(0, timeoutMs),
+            );
+            (timer as { unref?: () => void }).unref?.();
+        });
+        const request = Promise.resolve().then(() =>
+            client.config.get({ signal: controller.signal }),
+        );
+        const result = await Promise.race([request, timeout]);
+        if (result === null) return null;
+
         // The SDK's generated `Config` type has no `compaction` key, so read it
         // defensively from the runtime response.
         const compaction = (result?.data as ResolvedCompactionBlock | undefined)?.compaction;
@@ -272,6 +288,8 @@ export async function resolveCompactionForBoot(
         return { auto: compaction.auto, prune: compaction.prune };
     } catch {
         return null;
+    } finally {
+        if (timer) clearTimeout(timer);
     }
 }
 

package/src/shared/harness.ts

@@ -2,7 +2,7 @@
  * Identifier for the host harness this plugin is running inside.
  *
  * Magic Context's SQLite database lives at a vendor-scoped path
- * (`~/.local/share/cortexkit/magic-context/`) so OpenCode and Pi can share
+ * (`~/.local/share/cortexkit/magic-context/`) so OpenCode, Pi, and OMP can share
  * project memories, embedding cache, dreamer runs, and other project-scoped
  * state. Session-scoped tables carry a `harness` column populated from this
  * module so we can disambiguate which harness wrote each session row,
@@ -13,13 +13,13 @@
  * happens:
  * - OpenCode plugin: relies on the default ("opencode") — no setHarness call
  *   needed
- * - Pi plugin: calls `setHarness("pi")` before opening the database
+ * - Pi-compatible plugin: resolves the host and calls `setHarness("pi" | "omp")` before opening the database
  *
  * NEVER read this from configuration or session state — it is a
  * boot-time constant per plugin instance. Cross-harness leakage is a
  * correctness bug, not a feature.
  */
-export type HarnessId = "opencode" | "pi";
+export type HarnessId = "opencode" | "pi" | "omp";
 
 let currentHarness: HarnessId = "opencode";
 let harnessLocked = false;

package/src/shared/model-resolution.test.ts

@@ -130,6 +130,67 @@ describe("model-resolution", () => {
         });
     });
 
+    test("uses OMP blocks first, falls back to Pi blocks, then preserves existing defaults", () => {
+        const configured = {
+            historian: {
+                pi: {
+                    model: { model: "pi/historian", thinking_level: "high" },
+                    fallback_models: ["pi/historian-fallback"],
+                },
+                omp: {
+                    model: { model: "omp/historian", thinking_level: "auto" },
+                    fallback_models: [{ model: "omp/historian-fallback", thinking_level: "max" }],
+                },
+            },
+            dreamer: {
+                tasks: { verify: { schedule: "0 3 * * *" } },
+                pi: {
+                    model: "pi/dreamer",
+                    tasks: { verify: { model: "pi/verify" } },
+                },
+                omp: {
+                    model: "omp/dreamer",
+                    tasks: {
+                        verify: {
+                            model: { model: "omp/verify", thinking_level: "inherit" },
+                        },
+                    },
+                },
+            },
+        };
+
+        expect(resolveHistorianModel(configured, "omp")).toEqual({
+            primary: { model: "omp/historian", qualifier: "auto" },
+            fallbacks: [{ model: "omp/historian-fallback", qualifier: "max" }],
+        });
+        expect(
+            resolveDreamerTaskModel({ config: configured, harness: "omp", task: "verify" }),
+        ).toMatchObject({ primary: { model: "omp/verify", qualifier: "inherit" } });
+
+        const piFallback = {
+            historian: configured.historian,
+            dreamer: { ...configured.dreamer, omp: undefined },
+        };
+        delete (piFallback.historian as { omp?: unknown }).omp;
+        expect(resolveHistorianModel(piFallback, "omp")?.primary).toEqual({
+            model: "pi/historian",
+            qualifier: "high",
+        });
+        expect(
+            resolveDreamerTaskModel({ config: piFallback, harness: "omp", task: "verify" }),
+        ).toMatchObject({ primary: { model: "pi/verify" } });
+
+        expect(resolveHistorianModel({}, "omp")).toEqual({ fallbacks: [] });
+        const existingDefaults = resolveDreamerTaskModel({
+            config: { dreamer: { tasks: { verify: { schedule: "0 3 * * *" } } } },
+            harness: "omp",
+            task: "verify",
+        });
+        expect(existingDefaults.primary).toBeUndefined();
+        expect(existingDefaults.fallbacks).toEqual([]);
+        expect(existingDefaults.schedule).toBe("0 3 * * *");
+    });
+
     test("resolves ordinary task model and scheduling without crossing harnesses", () => {
         const config = {
             dreamer: {

package/src/shared/model-resolution.ts

@@ -1,4 +1,4 @@
-export type ModelHarness = "opencode" | "pi";
+export type ModelHarness = "opencode" | "pi" | "omp";
 
 export interface ResolvedModelEntry {
     /** Canonical provider/model reference used for identity and model selection. */
@@ -27,6 +27,14 @@ function hasOwn(record: ConfigRecord, key: string): boolean {
     return Object.hasOwn(record, key);
 }
 
+function resolveHarnessBlock(
+    container: ConfigRecord | undefined,
+    harness: ModelHarness,
+): ConfigRecord | undefined {
+    const selected = harness === "omp" ? (container?.omp ?? container?.pi) : container?.[harness];
+    return asRecord(selected);
+}
+
 /**
  * Collapses the string and object spellings of a harness model entry into the
  * same model identity. Qualifiers stay separate because they alter an attempt,
@@ -98,15 +106,15 @@ export interface ResolvedHistorianModel {
 }
 
 /**
- * Resolve historian model attempts from exactly one harness block. Flat keys
- * and the other harness are deliberately never consulted after cutover.
+ * Resolve historian model attempts from the selected harness block. OMP uses
+ * its own block when present and falls back to Pi when it is absent.
  */
 export function resolveHistorianModel(
     config: unknown,
     harness: ModelHarness,
 ): ResolvedHistorianModel {
     const historian = asRecord(asRecord(config)?.historian);
-    const block = asRecord(historian?.[harness]);
+    const block = resolveHarnessBlock(historian, harness);
     if (!block) return { fallbacks: [] };
 
     return {
@@ -139,7 +147,7 @@ export function resolveDreamerTaskModel(args: {
     muralModel?: unknown;
 }): ResolvedDreamerTaskModel {
     const dreamer = asRecord(asRecord(args.config)?.dreamer);
-    const harnessBlock = asRecord(dreamer?.[args.harness]);
+    const harnessBlock = resolveHarnessBlock(dreamer, args.harness);
     const taskBlock = asRecord(asRecord(harnessBlock?.tasks)?.[args.task]);
     const schedulingTask = asRecord(asRecord(dreamer?.tasks)?.[args.task]);
     if (!harnessBlock) {
@@ -211,6 +219,7 @@ export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, un
         thinking_level: _thinking,
         opencode,
         pi,
+        omp,
         tasks,
         ...rest
     } = source;

package/src/shared/prompt-surface-runtime.ts

@@ -2,7 +2,6 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 
 import {
-    type ConfigHarness,
     cortexKitUserConfigBasePath,
     resolveLegacyConfigSourcesForHarness,
 } from "../config/migrate-config-location";
@@ -13,6 +12,7 @@ import {
     CTX_REDUCE_LIGHT_DESCRIPTION,
     CTX_SEARCH_LIGHT_DESCRIPTION,
 } from "../tools/light-descriptions";
+import type { HarnessId } from "./harness";
 import { piModelRefToCanonical } from "./harness-provider-map";
 import { detectConfigFile } from "./jsonc-parser";
 import {
@@ -88,7 +88,7 @@ export interface PromptSurfaceRuntime {
 }
 
 export interface CreatePromptSurfaceRuntimeOptions {
-    harness?: ConfigHarness;
+    harness?: HarnessId;
     directory?: string;
     /** Explicit test/integration seam; production derives the USER config directory. */
     userConfigDirectory?: string;
@@ -105,7 +105,7 @@ function resolveUserConfigDirectory(options: CreatePromptSurfaceRuntimeOptions):
     if (options.harness) {
         const legacy = resolveLegacyConfigSourcesForHarness(
             options.directory ?? process.cwd(),
-            options.harness,
+            options.harness === "omp" ? "pi" : options.harness,
         ).user.find((source) => existsSync(source.path));
         if (legacy) return dirname(legacy.path);
     }

package/src/shared/tag-transcript.ts

@@ -62,6 +62,7 @@ import {
     byteSize,
     prependTag,
     stripTagPrefix,
+    stripWellFormedLeadingTagPrefix,
 } from "../hooks/magic-context/tag-content-primitives";
 import type { TagTarget } from "../hooks/magic-context/tag-messages";
 import type { Transcript, TranscriptPart } from "./transcript";
@@ -814,6 +815,16 @@ interface TagTextPartArgs {
 function tagTextPart(args: TagTextPartArgs): void {
     const identityStart = args.timing ? performance.now() : 0;
     const text = args.part.getText() ?? "";
+    // Pi and OMP can expose provider framing as assistant text blocks. Treat a
+    // previously prefixed blank as blank too, so MC never turns inert framing
+    // into a tag-bearing part that later strip logic could mistake for content.
+    if (
+        args.message.info.role === "assistant" &&
+        stripWellFormedLeadingTagPrefix(text).trim().length === 0
+    ) {
+        if (args.timing) args.timing.identity += performance.now() - identityStart;
+        return;
+    }
     const contentId = args.contentId;
     const reusableTagId = args.reuseIdentity
         ? args.tagger.getTag(args.sessionId, contentId, "message")

package/src/shared/transcript.ts

@@ -1,3 +1,5 @@
+import type { HarnessId } from "./harness";
+
 /**
  * Harness-agnostic transcript interface.
  *
@@ -229,7 +231,7 @@ export interface Transcript {
      *   compaction marker injection).
      * - Test assertions confirming the right adapter ran.
      */
-    readonly harness: "opencode" | "pi";
+    readonly harness: HarnessId;
 
     /**
      * Commit accumulated mutations to the underlying source array.

package/dist/announcement-3g9xg433.js

@@ -1,18 +0,0 @@
-import {
-  ANNOUNCEMENT_FEATURES,
-  ANNOUNCEMENT_FOOTER,
-  ANNOUNCEMENT_VERSION,
-  markAnnouncementSeen,
-  readLastAnnouncedVersion,
-  shouldShowAnnouncement
-} from "./index-dmvy29z0.js";
-import"./index-37yzyeca.js";
-import"./index-1yh8g550.js";
-export {
-  ANNOUNCEMENT_FEATURES,
-  ANNOUNCEMENT_FOOTER,
-  ANNOUNCEMENT_VERSION,
-  markAnnouncementSeen,
-  readLastAnnouncedVersion,
-  shouldShowAnnouncement
-};

package/dist/conflict-warning-hook-rf17b6et.js

@@ -1,17 +0,0 @@
-import {
-  cleanupConflictWarnings,
-  sendConflictWarning,
-  sendSchemaFenceWarning,
-  sendStartupAnnouncement
-} from "./index-eq9wr75c.js";
-import"./index-8mtsfhyg.js";
-import"./index-vnz6jvdc.js";
-import"./index-4x691bz5.js";
-import"./index-37yzyeca.js";
-import"./index-1yh8g550.js";
-export {
-  cleanupConflictWarnings,
-  sendConflictWarning,
-  sendSchemaFenceWarning,
-  sendStartupAnnouncement
-};