@cortexkit/opencode-magic-context 0.33.1 → 0.34.1

package/src/shared/rpc-types.ts

@@ -3,13 +3,31 @@
  * Both sides import these — no SQLite dependency.
  */
 
+import type {
+    DreamTaskBacklogMap,
+    DreamTaskProgress,
+} from "../features/magic-context/dreamer/task-registry";
+
 export interface SidebarSnapshot {
     sessionId: string;
     usagePercentage: number;
     inputTokens: number;
     contextLimit: number;
+    /**
+     * Raw wire-input pressure against the resolved model window. This is separate
+     * from Magic Context's execute threshold so native-compaction UI never shows
+     * a threshold-relative fill percentage.
+     */
+    native_context_usage_percentage?: number;
+    /**
+     * Magic Context compaction mode is resolved at startup and sent in the
+     * status-detail wire payload; snake_case matches that payload's field naming.
+     */
+    compaction_enabled?: boolean;
     systemPromptTokens: number;
     compartmentCount: number;
+    /** Historical compartment rows retained while native compaction owns the window. */
+    archivedCompartmentCount?: number;
     memoryCount: number;
     memoryBlockCount: number;
     pendingOpsCount: number;
@@ -18,6 +36,8 @@ export interface SidebarSnapshot {
     sessionNoteCount: number;
     readySmartNoteCount: number;
     cacheTtl: string;
+    /** Persistent runtime failure shown directly in the sidebar when non-null. */
+    lastTransformError: string | null;
     lastDreamerRunAt: number | null;
     projectIdentity: string | null;
     compartmentTokens: number;
@@ -69,7 +89,7 @@ export interface SidebarSnapshot {
     executeThreshold: number;
     /**
      * True when `executeThreshold` was clamped down from a higher configured value
-     * (tokens config above 80% × contextLimit, or a percentage above the 80% cap).
+     * (tokens config above 90% × contextLimit, or a percentage above the 90% cap).
      * The sidebar/status dialog append a small marker so the user knows their
      * configured value was reduced rather than applied verbatim (issue #241).
      * Absent when no clamp occurred.
@@ -86,6 +106,10 @@ export interface SidebarSnapshot {
      * sidebar "Recomp"/"Upgrade" progress bar and the /ctx-status dialog. Mirrors
      * the runtime `RecompProgress` shape from compartment-runner-types.ts.
      */
+    /** Read-only per-task candidate counts; populated by the server RPC. */
+    dreamerBacklog?: DreamTaskBacklogMap;
+    /** Process-local task progress; absent when no Dreamer task is running. */
+    dreamerProgress?: DreamTaskProgress | null;
     recompProgress?: {
         /** "recomp" → "Recomp" labels; "upgrade" → "Upgrade" labels. */
         kind?: "recomp" | "upgrade" | "embed" | "wrapup";
@@ -111,9 +135,20 @@ export interface StatusDetail extends SidebarSnapshot {
     isSubagent: boolean;
     pendingOps: Array<{ tagId: number; operation: string }>;
     contextLimit: number;
+    /**
+     * Parsed cache TTL in ms. -1 = never expires (cacheTtl "never"; Infinity
+     * cannot ride JSON-RPC and 0 would be indistinguishable from unset). The
+     * values discriminate without the cacheNeverExpires flag: -1 never /
+     * N live. Falsy-value contract: see storage_versions for the precedent.
+     */
     cacheTtlMs: number;
+    /** Remaining ms in the idle-TTL window. -1 = never expires; 0 = expired
+     *  (only meaningful when lastResponseTime > 0); N = live countdown. */
     cacheRemainingMs: number;
     cacheExpired: boolean;
+    /** True when cacheTtl is "never" — the idle-TTL heuristic is disabled on
+     *  this lane. Redundant with cacheTtlMs === -1; kept as the readable form. */
+    cacheNeverExpires?: boolean;
     executeThreshold: number;
     /**
      * Which config source produced `executeThreshold`. "tokens" means
@@ -135,6 +170,25 @@ export interface StatusDetail extends SidebarSnapshot {
     toastDurationMs: number;
     /** One-line status data for the experimental memory mural. */
     mural?: { present: boolean; ageMs: number | null };
+    /**
+     * Stable storage-version probe: "which schema is the DB at, which fence does
+     * this binary carry". Field names are deliberately snake_case, mirroring the
+     * `storage_versions` block of the mc-module status envelope, so fleet probes
+     * parse one shape across both surfaces. The module cannot read context.db
+     * (the plugin owns it), so this surface supplies the live DB value; the module
+     * surface supplies the module-store value instead.
+     */
+    storage_versions: {
+        /**
+         * Persisted schema version of context.db (MAX of schema_migrations).
+         * null = the version probe FAILED (read threw — broken/unreachable store);
+         * 0 = probe succeeded on a fresh DB without a migrations table. Distinct so
+         * readers never conflate broken-with-empty (fleet status-surface contract).
+         */
+        context_db_schema_version: number | null;
+        /** Highest context.db schema version this plugin build supports. */
+        plugin_supported_version: number;
+    };
 }
 
 /** Embedding coverage for `/ctx-embed` status (mirrors getEmbeddingCoverageStatus). */

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

@@ -0,0 +1,157 @@
+/// <reference types="bun-types" />
+
+import { afterEach, describe, expect, test } from "bun:test";
+import type { execFileSync } from "node:child_process";
+import type { readFileSync } from "node:fs";
+import {
+    __resetRpcIdentityTestHooks,
+    __setRpcIdentityTestHooks,
+    isPidIdentityPlausible,
+    type RpcPortFileRecord,
+} from "./rpc-utils";
+
+const PID = 1234;
+const NOW_MS = 2_000_000;
+const UPTIME_SECONDS = 1_000;
+
+function record(startedAt: number): RpcPortFileRecord {
+    return { port: 43123, pid: PID, started_at: startedAt };
+}
+
+function procStat(startTimeTicks: number): string {
+    // After the closing command-name parenthesis, field 3 is `state` and field
+    // 22 is the twentieth value in the suffix.
+    return `${PID} (opencode) S ${Array.from({ length: 18 }, () => "0").join(" ")} ${startTimeTicks}`;
+}
+
+function linuxFiles(files: Record<string, string | Error>): typeof readFileSync {
+    return ((path: string | URL) => {
+        const value = files[String(path)];
+        if (value instanceof Error) throw value;
+        if (value === undefined) throw new Error(`unexpected read: ${String(path)}`);
+        return value;
+    }) as typeof readFileSync;
+}
+
+function psOutput(output: string | Error): typeof execFileSync {
+    return (() => {
+        if (output instanceof Error) throw output;
+        return output;
+    }) as typeof execFileSync;
+}
+
+afterEach(() => {
+    __resetRpcIdentityTestHooks();
+});
+
+describe("isPidIdentityPlausible", () => {
+    test("rejects a reused Linux PID when proc start time is substantially newer", () => {
+        const readPaths: string[] = [];
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            nowMs: () => NOW_MS,
+            readFileSync: ((path: string | URL) => {
+                readPaths.push(String(path));
+                const files = {
+                    [`/proc/${PID}/stat`]: procStat(10_000),
+                    "/proc/uptime": `${UPTIME_SECONDS}.0 0.0`,
+                };
+                return files[String(path) as keyof typeof files];
+            }) as typeof readFileSync,
+            execFileSync: (() => {
+                throw new Error("ps must not run on Linux");
+            }) as typeof execFileSync,
+        });
+
+        expect(isPidIdentityPlausible(record(500_000))).toBe(false);
+        expect(readPaths).toEqual([`/proc/${PID}/stat`, "/proc/uptime"]);
+    });
+
+    test("accepts a genuine Linux record when the process started no later than the record", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            nowMs: () => NOW_MS,
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/stat`]: procStat(10_000),
+                "/proc/uptime": `${UPTIME_SECONDS}.0 0.0`,
+            }),
+        });
+
+        // The mocked process start is 1,100,000ms. The 120s tolerance is part of
+        // the contract because port-file creation follows process startup.
+        expect(isPidIdentityPlausible(record(1_000_000))).toBe(true);
+    });
+
+    test("treats an unreadable Linux start-time probe as live", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/stat`]: new Error("procfs unavailable"),
+            }),
+        });
+
+        expect(isPidIdentityPlausible(record(500_000))).toBe(true);
+    });
+
+    test("uses the legacy Linux command fallback and fails closed on probe errors", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/cmdline`]: "/usr/sbin/opendkim --config /etc/opendkim.conf",
+            }),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(false);
+
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/cmdline`]: "/usr/local/bin/opencode serve",
+            }),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(true);
+
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/cmdline`]: new Error("procfs unavailable"),
+            }),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(true);
+    });
+
+    test("uses ps start time and command probes on non-Linux platforms", () => {
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput("Mon Aug  7 00:00:00 1970"),
+        });
+        expect(
+            isPidIdentityPlausible(record(Date.parse("Mon Aug  7 00:00:00 1970") - 121_000)),
+        ).toBe(false);
+
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput("Mon Aug  7 00:00:00 1970"),
+        });
+        expect(
+            isPidIdentityPlausible(record(Date.parse("Mon Aug  7 00:00:00 1970") - 120_000)),
+        ).toBe(true);
+
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput("/usr/sbin/opendkim -f"),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(false);
+
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput("/Applications/OpenCode.app/Contents/MacOS/opencode"),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(true);
+
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput(new Error("ps unavailable")),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(true);
+    });
+});

package/src/shared/rpc-utils.ts

@@ -1,4 +1,6 @@
+import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 export interface RpcPortFileRecord {
@@ -58,6 +60,141 @@ export function isPidAlive(pid: number): boolean {
     }
 }
 
+const RPC_IDENTITY_SKEW_TOLERANCE_MS = 120_000;
+const LINUX_CLOCK_TICKS_PER_SECOND = 100;
+const PS_PROBE_TIMEOUT_MS = 1_000;
+const OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
+
+let rpcIdentityReadFileSync: typeof readFileSync = readFileSync;
+let rpcIdentityExecFileSync: typeof execFileSync = execFileSync;
+let rpcIdentityPlatform: NodeJS.Platform = process.platform;
+let rpcIdentityNowMs: () => number = () => Date.now();
+
+function parseLinuxProcessStartTime(statContent: string, uptimeContent: string): number | null {
+    const closingCommandName = statContent.lastIndexOf(")");
+    if (closingCommandName < 0) return null;
+
+    // The fields after the command name begin at field 3 (`state`), so field 22
+    // (`starttime`) is index 19 in this suffix. The command name can contain ')',
+    // hence the last closing parenthesis rather than the first one is significant.
+    const statFields = statContent
+        .slice(closingCommandName + 1)
+        .trim()
+        .split(/\s+/);
+    const startTimeTicks = Number(statFields[19]);
+    const uptimeSeconds = Number(uptimeContent.trim().split(/\s+/)[0]);
+    if (
+        !Number.isFinite(startTimeTicks) ||
+        startTimeTicks < 0 ||
+        !Number.isFinite(uptimeSeconds) ||
+        uptimeSeconds < 0
+    ) {
+        return null;
+    }
+
+    const processStartTime =
+        rpcIdentityNowMs() -
+        uptimeSeconds * 1_000 +
+        (startTimeTicks / LINUX_CLOCK_TICKS_PER_SECOND) * 1_000;
+    return Number.isFinite(processStartTime) ? processStartTime : null;
+}
+
+function readLinuxProcessStartTime(pid: number): number | null {
+    try {
+        const statContent = String(rpcIdentityReadFileSync(`/proc/${pid}/stat`, "utf8"));
+        const uptimeContent = String(rpcIdentityReadFileSync("/proc/uptime", "utf8"));
+        return parseLinuxProcessStartTime(statContent, uptimeContent);
+    } catch {
+        return null;
+    }
+}
+
+function readPsProcessStartTime(pid: number): number | null {
+    try {
+        const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+            encoding: "utf8",
+            timeout: PS_PROBE_TIMEOUT_MS,
+        });
+        const processStartTime = Date.parse(String(output).trim());
+        return Number.isFinite(processStartTime) ? processStartTime : null;
+    } catch {
+        return null;
+    }
+}
+
+function readLinuxProcessCommand(pid: number): string | null {
+    try {
+        return String(rpcIdentityReadFileSync(`/proc/${pid}/cmdline`, "utf8"));
+    } catch {
+        return null;
+    }
+}
+
+function readPsProcessCommand(pid: number): string | null {
+    try {
+        const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "command="], {
+            encoding: "utf8",
+            timeout: PS_PROBE_TIMEOUT_MS,
+        });
+        return String(output);
+    } catch {
+        return null;
+    }
+}
+
+function commandLooksLikeOpenCode(command: string): boolean {
+    const normalized = command.toLowerCase();
+    return OPEN_CODE_COMMAND_MARKERS.some((marker) => normalized.includes(marker));
+}
+
+/**
+ * Verify that a live PID still belongs to the process that wrote a port record.
+ *
+ * A PID can be reused after its original process exits. On Linux, procfs gives
+ * us a process start time without spawning a helper; other platforms use `ps`
+ * only on this cold database-open guard path. Legacy records without a start
+ * time use a weaker command-name check, and every probe failure stays live so
+ * this identity check cannot weaken the migration guard on uncertainty.
+ */
+export function isPidIdentityPlausible(record: RpcPortFileRecord): boolean {
+    if (!Number.isInteger(record.pid) || record.pid <= 0) return false;
+
+    if (Number.isFinite(record.started_at) && record.started_at > 0) {
+        const processStartTime =
+            rpcIdentityPlatform === "linux"
+                ? readLinuxProcessStartTime(record.pid)
+                : readPsProcessStartTime(record.pid);
+        if (processStartTime === null) return true;
+        return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS;
+    }
+
+    const command =
+        rpcIdentityPlatform === "linux"
+            ? readLinuxProcessCommand(record.pid)
+            : readPsProcessCommand(record.pid);
+    if (command === null) return true;
+    return commandLooksLikeOpenCode(command);
+}
+
+export function __setRpcIdentityTestHooks(hooks: {
+    readFileSync?: typeof readFileSync;
+    execFileSync?: typeof execFileSync;
+    platform?: NodeJS.Platform;
+    nowMs?: () => number;
+}): void {
+    rpcIdentityReadFileSync = hooks.readFileSync ?? readFileSync;
+    rpcIdentityExecFileSync = hooks.execFileSync ?? execFileSync;
+    rpcIdentityPlatform = hooks.platform ?? process.platform;
+    rpcIdentityNowMs = hooks.nowMs ?? (() => Date.now());
+}
+
+export function __resetRpcIdentityTestHooks(): void {
+    rpcIdentityReadFileSync = readFileSync;
+    rpcIdentityExecFileSync = execFileSync;
+    rpcIdentityPlatform = process.platform;
+    rpcIdentityNowMs = () => Date.now();
+}
+
 export function parseRpcPortFile(content: string, fallbackPid = 0): RpcPortFileRecord | null {
     const trimmed = content.trim();
     if (!trimmed) return null;

package/src/shared/storage-permissions.ts

@@ -0,0 +1,20 @@
+/**
+ * Process-wide storage permission policy resolved from trusted user config.
+ *
+ * Storage is shared by OpenCode and Pi, so all writers consult one setting before
+ * applying POSIX modes. The default preserves the historical owner-only policy.
+ */
+let enforcePrivateStoragePermissions = true;
+
+export function setStoragePrivatePermissionEnforcement(enforce: boolean): void {
+    enforcePrivateStoragePermissions = enforce;
+}
+
+export function shouldEnforcePrivateStoragePermissions(): boolean {
+    return enforcePrivateStoragePermissions;
+}
+
+/** Test-only reset for suites that exercise both permission policies in one process. */
+export function __resetStoragePrivatePermissionEnforcementForTests(): void {
+    enforcePrivateStoragePermissions = true;
+}

package/src/shared/tui-runtime-specifiers.ts

@@ -0,0 +1,32 @@
+/**
+ * The module specifiers the compiled TUI is allowed to resolve through OpenCode's
+ * process-wide OpenTUI runtime registry (`opentui:runtime-module:<encoded>`).
+ *
+ * Single source of truth, shared by `scripts/build-tui.ts` (which rewrites these
+ * specifiers during the Solid transform) and
+ * `src/tui/tui-compiled-runtime-imports.test.ts` (which verifies every emitted
+ * specifier names a real export). Keeping one list means the guard test cannot
+ * drift into skipping a specifier the build actually rewrites — a skipped
+ * specifier is exactly the silent hole the test exists to close.
+ *
+ * Lives in `src/shared/` rather than `src/tui/` on purpose: `build-tui.ts` copies
+ * every file under `src/tui/` into the shipped `src/tui-compiled/` bundle, and
+ * this list is build/test tooling that the runtime bundle must not carry.
+ */
+export const TUI_RUNTIME_SPECIFIERS = [
+    "@opentui/core",
+    "@opentui/core/testing",
+    "@opentui/solid",
+    "@opentui/solid/components",
+    "@opentui/solid/jsx-runtime",
+    "@opentui/solid/jsx-dev-runtime",
+    "solid-js",
+    "solid-js/store",
+] as const;
+
+export type TuiRuntimeSpecifier = (typeof TUI_RUNTIME_SPECIFIERS)[number];
+
+/** Virtual module id OpenCode registers for a runtime specifier. */
+export function runtimeModuleId(specifier: string): string {
+    return `opentui:runtime-module:${encodeURIComponent(specifier)}`;
+}

package/src/tui/compaction-off.test.ts

@@ -0,0 +1,56 @@
+import { expect, test } from "bun:test";
+import type { SidebarSnapshot } from "../shared/rpc-types";
+import { compactionOffSidebarRows, nativeCompactionContextLabel } from "./compaction-off";
+
+function snapshot(overrides: Partial<SidebarSnapshot> = {}): SidebarSnapshot {
+    return {
+        sessionId: "ses-native-ui",
+        usagePercentage: 63.1,
+        inputTokens: 41_000,
+        contextLimit: 100_000,
+        native_context_usage_percentage: 41,
+        compaction_enabled: false,
+        systemPromptTokens: 0,
+        compartmentCount: 12,
+        archivedCompartmentCount: 3,
+        memoryCount: 5,
+        memoryBlockCount: 2,
+        pendingOpsCount: 4,
+        historianRunning: true,
+        compartmentInProgress: true,
+        sessionNoteCount: 2,
+        readySmartNoteCount: 1,
+        cacheTtl: "5m",
+        lastDreamerRunAt: null,
+        projectIdentity: null,
+        compartmentTokens: 0,
+        factTokens: 0,
+        memoryTokens: 0,
+        docsTokens: 0,
+        profileTokens: 0,
+        conversationTokens: 0,
+        toolCallTokens: 0,
+        toolDefinitionTokens: 0,
+        executeThreshold: 65,
+        ...overrides,
+    };
+}
+
+test("renders raw input-versus-model usage rather than threshold-relative fill", () => {
+    const value = nativeCompactionContextLabel(snapshot());
+
+    expect(value).toBe("Context: 41.0% · native compaction");
+    expect(value).not.toBe("Context: 63.1% · native compaction");
+});
+
+test("keeps historical compartments as a static archived row", () => {
+    const initialRows = compactionOffSidebarRows(snapshot());
+    const activeCountChangedRows = compactionOffSidebarRows(snapshot({ compartmentCount: 99 }));
+
+    expect(initialRows).toEqual([
+        { label: "Memories", value: "5" },
+        { label: "Notes", value: "2" },
+        { label: "Archived compartments", value: "3" },
+    ]);
+    expect(activeCountChangedRows).toEqual(initialRows);
+});

package/src/tui/compaction-off.ts

@@ -0,0 +1,29 @@
+import type { SidebarSnapshot } from "../shared/rpc-types";
+
+export interface CompactionOffSidebarRow {
+    label: "Memories" | "Notes" | "Archived compartments";
+    value: string;
+}
+
+/**
+ * Formats context pressure from the current wire input and the model context
+ * limit. It deliberately does not use the stored Magic Context threshold
+ * percentage, because native compaction acts on the model window instead.
+ */
+export function nativeCompactionContextLabel(snapshot: SidebarSnapshot): string {
+    if (snapshot.contextLimit <= 0) return "Context: unknown · native compaction";
+    const percentage = (snapshot.inputTokens / snapshot.contextLimit) * 100;
+    return `Context: ${percentage.toFixed(1)}% · native compaction`;
+}
+
+export function compactionOffSidebarRows(snapshot: SidebarSnapshot): CompactionOffSidebarRow[] {
+    const rows: CompactionOffSidebarRow[] = [
+        { label: "Memories", value: String(snapshot.memoryCount) },
+        { label: "Notes", value: String(snapshot.sessionNoteCount) },
+    ];
+    const archivedCount = snapshot.archivedCompartmentCount ?? 0;
+    if (archivedCount > 0) {
+        rows.push({ label: "Archived compartments", value: String(archivedCount) });
+    }
+    return rows;
+}

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

@@ -65,6 +65,7 @@ const EMPTY_SNAPSHOT: SidebarSnapshot = {
     sessionNoteCount: 0,
     readySmartNoteCount: 0,
     cacheTtl: "5m",
+    lastTransformError: null,
     lastDreamerRunAt: null,
     projectIdentity: null,
     compartmentTokens: 0,
@@ -194,6 +195,7 @@ export async function loadStatusDetail(
         cacheTtlMs: 0,
         cacheRemainingMs: 0,
         cacheExpired: false,
+        cacheNeverExpires: false,
         executeThreshold: 65,
         executeThresholdMode: "percentage",
         protectedTagCount: 20,
@@ -202,6 +204,10 @@ export async function loadStatusDetail(
         compressionBudget: null,
         compressionUsage: null,
         toastDurationMs: 5000,
+        storage_versions: {
+            context_db_schema_version: null,
+            plugin_supported_version: 0,
+        },
     };
 
     if (!rpcClient) return emptyDetail;