@cortexkit/opencode-magic-context 0.39.0 → 0.40.0

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

@@ -285,6 +285,134 @@ describe("MagicContextConfigSchema", () => {
         });
     });
 
+    describe("config profiles", () => {
+        it("admits model-selection fields and preserves per-entry harness qualifiers", () => {
+            const result = MagicContextConfigSchema.parse({
+                profile: "work",
+                profiles: {
+                    work: {
+                        historian: {
+                            opencode: {
+                                model: { model: "anthropic/work-historian", variant: "high" },
+                                fallback_models: [
+                                    { model: "openai/work-fallback", variant: "low" },
+                                ],
+                                variant: "high",
+                            },
+                            pi: {
+                                model: {
+                                    model: "github-copilot/work-historian",
+                                    thinking_level: "high",
+                                },
+                                thinking_level: "high",
+                            },
+                        },
+                        dreamer: {
+                            opencode: {
+                                model: { model: "anthropic/work-dreamer", variant: "medium" },
+                                fallback_models: [
+                                    { model: "openai/work-dreamer-fallback", variant: "low" },
+                                ],
+                                variant: "medium",
+                            },
+                            pi: {
+                                model: {
+                                    model: "github-copilot/work-dreamer",
+                                    thinking_level: "high",
+                                },
+                                fallback_models: [
+                                    {
+                                        model: "openai/work-dreamer-fallback",
+                                        thinking_level: "minimal",
+                                    },
+                                ],
+                                thinking_level: "high",
+                            },
+                        },
+                        sidekick: {
+                            model: "anthropic/work-sidekick",
+                            fallback_models: ["openai/work-sidekick-fallback"],
+                        },
+                    },
+                },
+            });
+
+            expect(result.profiles?.work?.historian?.opencode?.fallback_models).toEqual([
+                { model: "openai/work-fallback", variant: "low" },
+            ]);
+            expect(result.profiles?.work?.dreamer?.opencode).toEqual({
+                model: { model: "anthropic/work-dreamer", variant: "medium" },
+                fallback_models: [{ model: "openai/work-dreamer-fallback", variant: "low" }],
+                variant: "medium",
+            });
+            expect(result.profiles?.work?.dreamer?.pi?.fallback_models).toEqual([
+                { model: "openai/work-dreamer-fallback", thinking_level: "minimal" },
+            ]);
+            expect(result.profiles?.work?.sidekick?.model).toBe("anthropic/work-sidekick");
+        });
+
+        it("rejects timeout_minutes in a dreamer profile", () => {
+            const profiles = {
+                work: {
+                    dreamer: {
+                        opencode: {
+                            tasks: { verify: { timeout_minutes: 30 } },
+                        },
+                    },
+                },
+            };
+
+            expect(MagicContextConfigSchema.safeParse({ profiles }).success).toBe(false);
+        });
+
+        it("rejects task execution and every other non-model field class in profiles", () => {
+            const profilesWithExcludedFields = [
+                { work: { embedding: { provider: "off" } } },
+                { work: { historian: { two_pass: true } } },
+                { work: { historian: { opencode: { prompt: "override" } } } },
+                { work: { dreamer: { opencode: { tasks: {} } } } },
+                {
+                    work: {
+                        dreamer: {
+                            opencode: {
+                                tasks: {
+                                    verify: {
+                                        model: "anthropic/task-model",
+                                        fallback_models: ["openai/task-fallback"],
+                                        variant: "high",
+                                        timeout_minutes: 30,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                {
+                    work: {
+                        dreamer: {
+                            pi: {
+                                tasks: {
+                                    verify: {
+                                        model: "github-copilot/task-model",
+                                        fallback_models: ["openai/task-fallback"],
+                                        thinking_level: "high",
+                                        timeout_minutes: 30,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                { work: { dreamer: { tasks: { verify: { schedule: "0 3 * * *" } } } } },
+                { work: { sidekick: { timeout_ms: 60_000 } } },
+            ];
+
+            for (const profiles of profilesWithExcludedFields) {
+                expect(MagicContextConfigSchema.safeParse({ profiles }).success).toBe(false);
+            }
+        });
+    });
+
     describe("per-harness model configuration", () => {
         it("keeps the migration inventory exhaustive and field-specific", () => {
             expect(PER_HARNESS_MIGRATION_INVENTORY).toEqual({

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

@@ -310,6 +310,80 @@ export const DreamerPiHarnessBlockSchema = z
     .describe("Strict Pi dreamer model-resolution block. It accepts no OpenCode vocabulary.");
 export type DreamerPiHarnessBlock = z.infer<typeof DreamerPiHarnessBlockSchema>;
 
+/**
+ * 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
+ * overrides such as timeout_minutes.
+ */
+const ProfileOpenCodeModelBlockSchema = z
+    .object({
+        model: OcEntrySchema.optional().describe("Primary OpenCode model entry."),
+        fallback_models: z
+            .array(OcEntrySchema)
+            .optional()
+            .describe("Ordered fallback OpenCode model entries."),
+        variant: z
+            .string()
+            .optional()
+            .describe("OpenCode reasoning variant for the primary model entry."),
+    })
+    .strict()
+    .describe("Strict profile-only OpenCode model-selection block.");
+const ProfilePiModelBlockSchema = z
+    .object({
+        model: PiEntrySchema.optional().describe("Primary Pi model entry."),
+        fallback_models: z
+            .array(PiEntrySchema)
+            .optional()
+            .describe("Ordered fallback Pi model entries."),
+        thinking_level: PiThinkingLevelSchema.describe(
+            "Pi thinking level for the primary model entry.",
+        ),
+    })
+    .strict()
+    .describe("Strict profile-only Pi model-selection block.");
+const ProfileHistorianSchema = z
+    .object({
+        opencode: ProfileOpenCodeModelBlockSchema.optional(),
+        pi: ProfilePiModelBlockSchema.optional(),
+    })
+    .strict();
+const ProfileDreamerSchema = z
+    .object({
+        opencode: ProfileOpenCodeModelBlockSchema.optional(),
+        pi: ProfilePiModelBlockSchema.optional(),
+    })
+    .strict();
+const ProfileSidekickSchema = AgentOverrideConfigSchema.pick({
+    model: true,
+    fallback_models: true,
+    variant: true,
+})
+    .extend({
+        thinking_level: PiThinkingLevelSchema.describe(
+            "Pi thinking level for the sidekick model selection.",
+        ),
+    })
+    .strict();
+
+export const ConfigProfileSchema = z
+    .object({
+        historian: ProfileHistorianSchema.optional(),
+        dreamer: ProfileDreamerSchema.optional(),
+        sidekick: ProfileSidekickSchema.optional(),
+    })
+    .strict()
+    .describe(
+        "User-owned model-selection overlay. Only historian/dreamer harness model blocks and sidekick model-selection fields are allowed.",
+    );
+export type ConfigProfile = z.infer<typeof ConfigProfileSchema>;
+
+export const ConfigProfilesSchema = z.record(
+    z.string().trim().min(1, "Profile names must not be empty or whitespace-only."),
+    ConfigProfileSchema,
+);
+export type ConfigProfiles = z.infer<typeof ConfigProfilesSchema>;
+
 /** A 5-field cron expression, or "" to disable the task. */
 const CronScheduleSchema = z
     .string()
@@ -672,6 +746,10 @@ export interface MagicContextConfig {
     auto_update?: boolean;
     /** Output language for generated Magic Context prose. USER config only. */
     language?: string;
+    /** Active user-owned model profile after user/project resolution. */
+    profile?: string;
+    /** Named user-owned model profiles. Declarations are consumed during resolution. */
+    profiles?: ConfigProfiles;
     historian?: HistorianConfig;
     dreamer?: DreamerConfig;
     smart_notes: {
@@ -892,6 +970,17 @@ export const MagicContextConfigSchema = z
                     "triggers one cache re-materialization; existing compartments/memories keep their " +
                     "original language until naturally rewritten.",
             ),
+        profile: z
+            .string()
+            .trim()
+            .min(1)
+            .optional()
+            .describe(
+                "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.",
+        ),
         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.",
         ),

package/src/shared/rpc-types.ts

@@ -141,6 +141,8 @@ export interface SidebarSnapshot {
 }
 
 export interface StatusDetail extends SidebarSnapshot {
+    /** User-owned model profile selected for this project, or null for the base config. */
+    activeProfile: string | null;
     tagCounter: number;
     activeTags: number;
     droppedTags: number;

package/src/shared/rpc-utils.test.ts

@@ -3,6 +3,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import type { execFileSync } from "node:child_process";
 import type { readFileSync } from "node:fs";
+
 import {
     __resetRpcIdentityTestHooks,
     __setRpcIdentityTestHooks,
@@ -12,6 +13,7 @@ import {
     isPidAlive,
     isPidIdentityPlausible,
     type RpcPortFileRecord,
+    readProcessProbeEvidence,
 } from "./rpc-utils";
 
 const PID = 1234;
@@ -210,6 +212,36 @@ describe("isPidAlive", () => {
     });
 });
 
+describe("readProcessProbeEvidence", () => {
+    test("captures the same Linux start-time and command probes used by the guard", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            nowMs: () => NOW_MS,
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/stat`]: procStat(10_000),
+                "/proc/uptime": `${UPTIME_SECONDS}.0 0.0`,
+                [`/proc/${PID}/cmdline`]:
+                    "/usr/local/bin/opencode\u0000--directory\u0000/home/alice/project",
+            }),
+        });
+
+        expect(readProcessProbeEvidence(PID)).toEqual({
+            startTime: 1_100_000,
+            commandLine: "/usr/local/bin/opencode\u0000--directory\u0000/home/alice/project",
+        });
+    });
+
+    test("returns unavailable fields instead of throwing when probes fail", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({}),
+        });
+
+        expect(() => readProcessProbeEvidence(PID)).not.toThrow();
+        expect(readProcessProbeEvidence(PID)).toEqual({ startTime: null, commandLine: null });
+    });
+});
+
 describe("isPidIdentityPlausible", () => {
     test("rejects a reused Linux PID when proc start time is substantially newer", () => {
         const readPaths: string[] = [];

package/src/shared/rpc-utils.ts

@@ -5,6 +5,14 @@ import { join } from "node:path";
 
 export type ProcessKind = "OpenCode server" | "OpenCode instance (TUI/CLI)" | "Pi" | "process";
 
+/** Best-effort process details captured while validating a migration blocker. */
+export interface ProcessProbeEvidence {
+    /** Epoch milliseconds, or null when the platform/probe cannot provide it. */
+    startTime: number | null;
+    /** The raw command line, or null when the platform/probe cannot provide it. */
+    commandLine: string | null;
+}
+
 export interface RpcPortFileRecord {
     port: number;
     pid: number;
@@ -143,6 +151,24 @@ function readPsProcessStartTime(pid: number): number | null {
     }
 }
 
+/** Read a process start time without changing the guard's liveness decision. */
+export function readProcessStartTime(pid: number): number | null {
+    if (!Number.isInteger(pid) || pid <= 0) return null;
+    return rpcIdentityPlatform === "linux"
+        ? readLinuxProcessStartTime(pid)
+        : rpcIdentityPlatform === "win32"
+          ? null
+          : readPsProcessStartTime(pid);
+}
+
+/** Capture the command and start-time probes used to explain a blocker. */
+export function readProcessProbeEvidence(pid: number): ProcessProbeEvidence {
+    return {
+        startTime: readProcessStartTime(pid),
+        commandLine: readProcessCommand(pid),
+    };
+}
+
 interface ProcessListEntry {
     pid: number;
     command: string;
@@ -319,28 +345,27 @@ function commandLooksLikeOpenCode(command: string): boolean {
  */
 export type PidIdentityPlausibility = "plausible" | "implausible" | "inconclusive";
 
-export function isPidIdentityPlausible(record: RpcPortFileRecord): PidIdentityPlausibility {
+export function isPidIdentityPlausible(
+    record: RpcPortFileRecord,
+    evidence?: ProcessProbeEvidence,
+): PidIdentityPlausibility {
     if (!Number.isInteger(record.pid) || record.pid <= 0) return "implausible";
 
     if (Number.isFinite(record.started_at) && record.started_at > 0) {
-        const processStartTime =
-            rpcIdentityPlatform === "linux"
-                ? readLinuxProcessStartTime(record.pid)
-                : rpcIdentityPlatform === "win32"
-                  ? null
-                  : readPsProcessStartTime(record.pid);
+        const processStartTime = evidence ? evidence.startTime : readProcessStartTime(record.pid);
         if (processStartTime === null) return "inconclusive";
         return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS
             ? "plausible"
             : "implausible";
     }
 
-    const command =
-        rpcIdentityPlatform === "linux"
-            ? readLinuxProcessCommand(record.pid)
-            : rpcIdentityPlatform === "win32"
-              ? (readWindowsProcess(record.pid).command ?? null)
-              : readPsProcessCommand(record.pid);
+    const command = evidence
+        ? evidence.commandLine
+        : rpcIdentityPlatform === "linux"
+          ? readLinuxProcessCommand(record.pid)
+          : rpcIdentityPlatform === "win32"
+            ? (readWindowsProcess(record.pid).command ?? null)
+            : readPsProcessCommand(record.pid);
     if (command === null) return "inconclusive";
     return commandLooksLikeOpenCode(command) ? "plausible" : "implausible";
 }

package/src/shared/status-detail-text.test.ts

@@ -4,6 +4,7 @@ import { formatStatusDetailMarkdown } from "./status-detail-text";
 
 const STATUS_FIXTURE: StatusDetail = {
     sessionId: "ses_status",
+    activeProfile: "work",
     usagePercentage: 75,
     inputTokens: 96_000,
     contextLimit: 128_000,
@@ -70,6 +71,7 @@ describe("formatStatusDetailMarkdown", () => {
         expect(formatStatusDetailMarkdown(STATUS_FIXTURE)).toBe(`## Magic Context Status
 
 - **Mode:** Magic Context compaction
+- **Active profile:** work
 - **Usage:** 75.0% (96,000 / 128,000 usable tokens)
 - **Cache lane:** live (42s remaining); TTL 5m
 - **Historian:** running; boundary present; coverage 12

package/src/shared/status-detail-text.ts

@@ -35,6 +35,7 @@ export function formatStatusDetailMarkdown(detail: StatusDetail): string {
         "## Magic Context Status",
         "",
         `- **Mode:** ${mode}`,
+        `- **Active profile:** ${detail.activeProfile ?? "none"}`,
         `- **Usage:** ${detail.usagePercentage.toFixed(1)}% (${formatCount(detail.inputTokens)} / ${usableLimit})`,
         `- **Cache lane:** ${formatCacheLane(detail)}`,
         `- **Historian:** ${[historianState, ...historianDetails].join("; ")}`,

package/src/tui/data/context-db.ts

@@ -181,6 +181,7 @@ export async function loadStatusDetail(
     const emptyDetail: StatusDetail = {
         ...EMPTY_SNAPSHOT,
         sessionId,
+        activeProfile: null,
         tagCounter: 0,
         activeTags: 0,
         droppedTags: 0,

package/src/tui-compiled/data/context-db.ts

@@ -181,6 +181,7 @@ export async function loadStatusDetail(
     const emptyDetail: StatusDetail = {
         ...EMPTY_SNAPSHOT,
         sessionId,
+        activeProfile: null,
         tagCounter: 0,
         activeTags: 0,
         droppedTags: 0,