@cortexkit/opencode-magic-context 0.42.5 → 0.43.0

package/src/shared/assistant-message-extractor.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test";
+import { hasLengthCappedOutput } from "./assistant-message-extractor";
+
+describe("hasLengthCappedOutput", () => {
+    test("detects OpenCode assistant info.finish", () => {
+        expect(hasLengthCappedOutput([{ info: { role: "assistant", finish: "length" } }])).toBe(
+            true,
+        );
+    });
+
+    test("detects OpenCode step-finish reason", () => {
+        expect(
+            hasLengthCappedOutput([{ parts: [{ type: "step-finish", reason: "length" }] }]),
+        ).toBe(true);
+        expect(hasLengthCappedOutput({ type: "text", reason: "length" })).toBe(false);
+    });
+
+    test("detects Pi stopReason length", () => {
+        expect(hasLengthCappedOutput({ role: "assistant", stopReason: "length" })).toBe(true);
+    });
+});

package/src/shared/assistant-message-extractor.ts

@@ -3,6 +3,8 @@ type MessageTime = { created?: number };
 type MessageInfo = {
     role?: string;
     time?: MessageTime;
+    error?: unknown;
+    finish?: string;
 };
 
 type MessagePart = {
@@ -15,6 +17,11 @@ type SessionMessage = {
     parts?: unknown;
 };
 
+export interface AssistantFailure {
+    error: unknown;
+    finish: string | null;
+}
+
 import { isRecord } from "./record-type-guard";
 
 function asSessionMessage(value: unknown): SessionMessage | null {
@@ -33,6 +40,15 @@ function asSessionMessage(value: unknown): SessionMessage | null {
                                     : undefined,
                         }
                       : undefined,
+                  error: info.error,
+                  finish:
+                      typeof info.finish === "string"
+                          ? info.finish
+                          : typeof info.finish_reason === "string"
+                            ? info.finish_reason
+                            : typeof info.finishReason === "string"
+                              ? info.finishReason
+                              : undefined,
               }
             : undefined,
         parts,
@@ -54,16 +70,20 @@ function getTextParts(message: SessionMessage): MessagePart[] {
         .filter((part) => part.type === "text" && Boolean(part.text));
 }
 
-export function extractLatestAssistantText(messages: unknown): string | null {
+function getLatestAssistantMessage(messages: unknown): SessionMessage | null {
     if (!Array.isArray(messages) || messages.length === 0) return null;
 
-    const assistantMessages = messages
-        .map(asSessionMessage)
-        .filter((message): message is SessionMessage => message !== null)
-        .filter((message) => message.info?.role === "assistant")
-        .sort((a, b) => getCreatedTime(b) - getCreatedTime(a));
+    return (
+        messages
+            .map(asSessionMessage)
+            .filter((message): message is SessionMessage => message !== null)
+            .filter((message) => message.info?.role === "assistant")
+            .sort((a, b) => getCreatedTime(b) - getCreatedTime(a))[0] ?? null
+    );
+}
 
-    const latest = assistantMessages[0];
+export function extractLatestAssistantText(messages: unknown): string | null {
+    const latest = getLatestAssistantMessage(messages);
     if (!latest) return null;
 
     return (
@@ -73,12 +93,27 @@ export function extractLatestAssistantText(messages: unknown): string | null {
     );
 }
 
+/** Return an error persisted on the newest assistant row, including its settlement reason. */
+export function extractLatestAssistantFailure(messages: unknown): AssistantFailure | null {
+    const latest = getLatestAssistantMessage(messages);
+    if (!latest || latest.info?.error === undefined || latest.info.error === null) return null;
+    return {
+        error: latest.info.error,
+        finish: latest.info.finish ?? null,
+    };
+}
+
 export function hasLengthCappedOutput(value: unknown): boolean {
     if (Array.isArray(value)) return value.some((item) => hasLengthCappedOutput(item));
     if (!isRecord(value)) return false;
 
     if (value.length_capped === true || value.lengthCapped === true) return true;
-    const finishReason = value.finish_reason ?? value.finishReason;
+    const finishReason =
+        value.finish_reason ??
+        value.finishReason ??
+        value.finish ??
+        (value.type === "step-finish" ? value.reason : undefined) ??
+        value.stopReason;
     if (typeof finishReason === "string") {
         const normalized = finishReason.toLowerCase();
         if (

package/src/shared/auto-update-provenance.ts

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from "node:fs";
+
+export const AUTO_UPDATE_CHECK_STATE_FILENAME = "last-update-check.json";
+
+export interface AutoUpdateCheckState {
+    lastCheckedMs?: number;
+    updaterPinnedSpec?: string;
+    updaterPinnedAt?: number;
+}
+
+export function readAutoUpdateCheckState(path: string): AutoUpdateCheckState | null {
+    if (!existsSync(path)) return null;
+    try {
+        const value = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+        if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+        const raw = value as Record<string, unknown>;
+        const state: AutoUpdateCheckState = {};
+        if (typeof raw.lastCheckedMs === "number" && Number.isFinite(raw.lastCheckedMs)) {
+            state.lastCheckedMs = raw.lastCheckedMs;
+        }
+        if (typeof raw.updaterPinnedSpec === "string" && raw.updaterPinnedSpec.length > 0) {
+            state.updaterPinnedSpec = raw.updaterPinnedSpec;
+        }
+        if (typeof raw.updaterPinnedAt === "number" && Number.isFinite(raw.updaterPinnedAt)) {
+            state.updaterPinnedAt = raw.updaterPinnedAt;
+        }
+        return state;
+    } catch {
+        return null;
+    }
+}
+
+export function isUpdaterPinnedSpec(
+    state: AutoUpdateCheckState | null,
+    configuredSpec: string,
+): boolean {
+    return (
+        state?.updaterPinnedSpec === configuredSpec &&
+        typeof state.updaterPinnedAt === "number" &&
+        Number.isFinite(state.updaterPinnedAt)
+    );
+}

package/src/shared/child-session-teardown.test.ts

@@ -73,7 +73,22 @@ describe("teardownChildSession", () => {
         expect(fixture.archived).toEqual([]);
     });
 
-    test("keeps a settled ordinary child but deletes a settled privacy child under keep_subagents", async () => {
+    test("deletes a settled privacy child when keep_subagents is false", async () => {
+        const fixture = teardownFixture();
+        await teardownChildSession({
+            client: fixture.client,
+            sessionId: "settled-private",
+            promptSettled: true,
+            privacySensitive: true,
+            context: "private",
+            log: (message) => fixture.messages.push(message),
+        });
+
+        expect(fixture.deleted).toEqual(["settled-private"]);
+        expect(fixture.archived).toEqual([]);
+    });
+
+    test("keeps both settled ordinary and privacy children under keep_subagents", async () => {
         setKeepSubagents(true);
         const ordinary = teardownFixture();
         await teardownChildSession({
@@ -89,13 +104,33 @@ describe("teardownChildSession", () => {
         const privacy = teardownFixture();
         await teardownChildSession({
             client: privacy.client,
-            sessionId: "deleted-private",
+            sessionId: "kept-private",
             promptSettled: true,
             privacySensitive: true,
             context: "private",
             log: (message) => privacy.messages.push(message),
         });
-        expect(privacy.deleted).toEqual(["deleted-private"]);
+        expect(privacy.deleted).toEqual([]);
+    });
+
+    test("leaves an unsettled privacy child to the sweep regardless of keep_subagents", async () => {
+        for (const keepSubagents of [false, true]) {
+            setKeepSubagents(keepSubagents);
+            const fixture = teardownFixture();
+            const sessionId = `unsettled-private-${keepSubagents}`;
+            await teardownChildSession({
+                client: fixture.client,
+                sessionId,
+                sessionDirectory: "/repo",
+                promptSettled: false,
+                privacySensitive: true,
+                context: "private",
+                log: (message) => fixture.messages.push(message),
+            });
+
+            expect(fixture.deleted).toEqual([]);
+            expect(fixture.archived).toEqual([sessionId]);
+        }
     });
 
     test("archives an unsettled child before logging, leaves it intact, then the age gate reaps it", async () => {

package/src/shared/child-session-teardown.ts

@@ -35,8 +35,7 @@ export interface TeardownChildSessionArgs {
  * endpoint, although its generated TypeScript body type does not yet expose time.
  */
 export async function teardownChildSession(args: TeardownChildSessionArgs): Promise<void> {
-    const { client, sessionId, sessionDirectory, promptSettled, privacySensitive, context, log } =
-        args;
+    const { client, sessionId, sessionDirectory, promptSettled, context, log } = args;
     if (!sessionId) return;
 
     const request: ChildSessionRequest = {
@@ -44,7 +43,8 @@ export async function teardownChildSession(args: TeardownChildSessionArgs): Prom
         ...(sessionDirectory ? { query: { directory: sessionDirectory } } : {}),
     };
 
-    if (promptSettled && (privacySensitive || !shouldKeepSubagents())) {
+    // Retention keeps every settled child; only unsettled children go to the age-gated sweep.
+    if (promptSettled && !shouldKeepSubagents()) {
         await client.session.delete(request).catch((error: unknown) => {
             log(`${context}: session cleanup failed: ${String(error)}`);
         });

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

@@ -480,6 +480,59 @@ describe("detectConflicts", () => {
         });
     });
 
+    describe("OpenCode 2 compaction ownership", () => {
+        it("keeps MC enabled when host auto-compaction is on and never reads v1 prune", () => {
+            const previous = process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            const resolved = {
+                auto: true,
+                get prune(): boolean {
+                    throw new Error("v2 must not read compaction.prune");
+                },
+                keepTokens: 4_096,
+                buffer: 1_024,
+            };
+            const result = detectConflicts(projectDir, {
+                compactionEnabled: true,
+                hostGeneration: "v2",
+                resolvedCompaction: resolved,
+            });
+            expect(result.hasConflict).toBe(false);
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.conflicts.compactionPrune).toBe(false);
+            expect(result.nativeCompaction).toEqual({ auto: true, prune: false });
+            if (previous === undefined) delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            else process.env.OPENCODE_DISABLE_AUTOCOMPACT = previous;
+        });
+
+        it("reads the GA v2 auto, keep.tokens, and buffer shape", async () => {
+            const result = await resolveCompactionForBoot(
+                {
+                    config: {
+                        get: async () => ({
+                            data: {
+                                compaction: {
+                                    auto: true,
+                                    keep: { tokens: 4_096 },
+                                    buffer: 1_024,
+                                    prune: true,
+                                },
+                            },
+                        }),
+                    },
+                },
+                2_000,
+                "v2",
+            );
+            expect(result).toEqual({
+                auto: true,
+                prune: false,
+                keepTokens: 4_096,
+                buffer: 1_024,
+            });
+        });
+    });
+
     // --- Resolved-config arm (issue #309) ---
     // The plugin boot now consumes the host's RESOLVED config
     // (ctx.client.config.get()) instead of re-deriving compaction from files.
@@ -499,10 +552,14 @@ describe("detectConflicts", () => {
             }
         }
 
-        it("resolved auto=false + file layer that would default true → NO conflict (#309)", () => {
-            // No compaction block in any file + no env override → the file-based
-            // arm would default to auto=true and wrongly disable the plugin.
-            // The resolved arm says auto=false, which must win.
+        it("resolved auto=false outranks a file layer that says auto=true (#309)", () => {
+            // The file layer says auto=true, which on its own disables the
+            // plugin. The host's resolved config says auto=false, and the host
+            // is the authority — it can see layers the file reader cannot.
+            writeFileSync(
+                join(projectDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
             withoutAutoCompactEnv(() => {
                 const result = detectConflicts(projectDir, {
                     compactionEnabled: true,
@@ -539,8 +596,17 @@ describe("detectConflicts", () => {
         });
 
         it("resolved arm is skipped when resolvedCompaction is absent (file-based fallback unchanged)", () => {
-            // No resolvedCompaction → the file-based check runs. With no
-            // compaction block and no env override, it defaults to auto=true.
+            // No resolvedCompaction → the file-based check runs and owns the
+            // verdict. The written block is what makes the file arm say
+            // auto=true; it used to be an absent block relying on the file
+            // arm's default-on, which issue #484 removed because an absent
+            // block cannot tell "the user wrote nothing" apart from "we read
+            // the wrong directory". The claim under test is unchanged: with no
+            // resolved value the file arm decides, and its reason is unlabeled.
+            writeFileSync(
+                join(projectDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
             withoutAutoCompactEnv(() => {
                 const result = detectConflicts(projectDir, { compactionEnabled: true });
                 expect(result.conflicts.compactionAuto).toBe(true);
@@ -582,6 +648,166 @@ describe("detectConflicts", () => {
         });
     });
 
+    // --- OPENCODE_CONFIG_DIR is an ADDITION, not a replacement (issue #484) ---
+    //
+    // A launcher (Orca) exported OPENCODE_CONFIG_DIR to a directory holding
+    // only plugin scaffolding. OpenCode kept reading the user's real global
+    // config — `opencode debug config` showed compaction.auto=false — but the
+    // detector resolved the env directory INSTEAD of the global one, found no
+    // file, fell through to its default-on, and disabled the plugin.
+    //
+    // Verified against the opencode 1.18.30 binary and on a live host:
+    // `$XDG_CONFIG_HOME/opencode` is always read; `~/.opencode` is always
+    // scanned; `$OPENCODE_CONFIG_DIR` is appended LAST, so it wins ties but
+    // never hides the layers below it.
+    describe("OPENCODE_CONFIG_DIR is additive, not a replacement (issue #484)", () => {
+        let globalDir: string;
+        let launcherDir: string;
+
+        beforeEach(() => {
+            // These cases exercise compaction detection itself, so the suite's
+            // isolation env var has to go.
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            // HOME is the temp dir and XDG_CONFIG_HOME is cleared by the suite
+            // beforeEach, so this is the same path OpenCode would compute.
+            globalDir = join(homeDir, ".config", "opencode");
+            mkdirSync(globalDir, { recursive: true });
+            // The reporter's launcher directory: plugin scaffolding, no config.
+            launcherDir = join(root, "launcher-config-dir");
+            mkdirSync(launcherDir, { recursive: true });
+            writeFileSync(
+                join(launcherDir, "package.json"),
+                JSON.stringify({ name: "launcher-scaffold", version: "1.0.0" }),
+            );
+            process.env.OPENCODE_CONFIG_DIR = launcherDir;
+        });
+
+        afterEach(() => {
+            delete process.env.OPENCODE_CONFIG;
+        });
+
+        function writeCompaction(dir: string, file: string, compaction: unknown): void {
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, file), JSON.stringify({ compaction }));
+        }
+
+        it("reporter repro: global auto=false + config-less OPENCODE_CONFIG_DIR → no conflict", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.hasConflict).toBe(false);
+            expect(result.nativeCompaction.auto).toBe(false);
+        });
+
+        it("positive control: global auto=true still reports the conflict", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+            expect(result.hasConflict).toBe(true);
+            expect(result.reasons.join("; ")).toContain("compaction.auto=true");
+        });
+
+        it("an OPENCODE_CONFIG_DIR that DOES carry auto=true outranks a global auto=false", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            writeCompaction(launcherDir, "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+            expect(result.hasConflict).toBe(true);
+        });
+
+        it("an OPENCODE_CONFIG_DIR auto=false outranks a global auto=true", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: true });
+            writeCompaction(launcherDir, "opencode.jsonc", { auto: false });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("v1 keeps global supplementary config above the project .opencode overlay", () => {
+            writeCompaction(launcherDir, "opencode.json", { auto: false });
+            writeCompaction(join(projectDir, ".opencode"), "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, {
+                compactionEnabled: true,
+                hostGeneration: "v1",
+            });
+            expect(result.nativeCompaction.auto).toBe(false);
+            expect(result.conflicts.compactionAuto).toBe(false);
+        });
+
+        it("v2 ranks the project .opencode overlay above global supplementary config", () => {
+            writeCompaction(launcherDir, "opencode.json", { auto: false });
+            writeCompaction(join(projectDir, ".opencode"), "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, {
+                compactionEnabled: true,
+                hostGeneration: "v2",
+            });
+            expect(result.nativeCompaction.auto).toBe(true);
+            expect(result.conflicts.compactionAuto).toBe(false);
+        });
+
+        it("reads the global directory's legacy config.json layer", () => {
+            writeCompaction(globalDir, "config.json", { auto: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+        });
+
+        it("global opencode.jsonc overrides global opencode.json", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: true });
+            writeCompaction(globalDir, "opencode.jsonc", { auto: false });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("~/.opencode outranks the global config directory", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            writeCompaction(join(homeDir, ".opencode"), "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+        });
+
+        it("reads the $OPENCODE_CONFIG single-file override", () => {
+            const explicit = join(root, "explicit-opencode.json");
+            writeFileSync(explicit, JSON.stringify({ compaction: { auto: true } }));
+            process.env.OPENCODE_CONFIG = explicit;
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+        });
+
+        it("merges keys across layers instead of letting one file erase the other", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            writeCompaction(projectDir, "opencode.json", { prune: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.nativeCompaction.auto).toBe(false);
+            expect(result.nativeCompaction.prune).toBe(true);
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.conflicts.compactionPrune).toBe(true);
+        });
+
+        it("no compaction key in any readable layer is inconclusive, never a disable", () => {
+            // Nothing anywhere. OpenCode's own default is auto=true, but we
+            // cannot tell "the user wrote nothing" from "the value lives in a
+            // layer we cannot read" (managed/enterprise config, an org layer,
+            // a file we failed to parse). Guessing the disabling direction
+            // leaves NOTHING managing the window — the unrecoverable failure
+            // issue #309 established for the resolved arm.
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.conflicts.compactionPrune).toBe(false);
+            expect(result.hasConflict).toBe(false);
+            expect(result.nativeCompaction.auto).toBe(false);
+        });
+
+        it("still finds a conflicting plugin declared in the global config", () => {
+            writeFileSync(
+                join(globalDir, "opencode.json"),
+                JSON.stringify({ plugin: ["@tarquinen/opencode-dcp"] }),
+            );
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.dcpPlugin).toBe(true);
+        });
+    });
+
     // --- resolveCompactionForBoot (the resolved-config fetch helper) ---
     describe("resolveCompactionForBoot", () => {
         it("returns the resolved compaction block from the client", async () => {
@@ -596,6 +822,40 @@ describe("detectConflicts", () => {
             expect(result).toEqual({ auto: false, prune: true });
         });
 
+        it("resolves a host block that carries only compaction.auto (issue #484)", async () => {
+            // The shape opencode 1.18.30 actually serves for the ordinary
+            // `"compaction": { "auto": false }` config: OpenCode merges only
+            // the keys the user wrote and never materialises schema defaults,
+            // so `prune` is simply absent. Requiring it here used to reject
+            // this block and hand the decision to the file arm.
+            const client = {
+                config: {
+                    get: async () => ({ data: { compaction: { auto: false } } }),
+                },
+            };
+            const result = await resolveCompactionForBoot(client);
+            expect(result).toEqual({ auto: false, prune: false });
+        });
+
+        it("resolves auto=true without prune and keeps it a conflict", async () => {
+            const client = {
+                config: {
+                    get: async () => ({ data: { compaction: { auto: true } } }),
+                },
+            };
+            const resolved = await resolveCompactionForBoot(client);
+            expect(resolved).toEqual({ auto: true, prune: false });
+            // The suite beforeEach sets OPENCODE_DISABLE_AUTOCOMPACT, which
+            // short-circuits both arms; this case is about the verdict.
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            const result = detectConflicts(projectDir, {
+                compactionEnabled: true,
+                resolvedCompaction: resolved ?? undefined,
+            });
+            expect(result.conflicts.compactionAuto).toBe(true);
+            expect(result.reasons.join("; ")).toContain("(resolved config)");
+        });
+
         it("returns null when the compaction block is absent (file-based fallback, not host defaults)", async () => {
             // An absent block means the response shape did not carry the resolved
             // state (server version drift, a fetch racing boot) — NOT that the
@@ -612,7 +872,7 @@ describe("detectConflicts", () => {
             expect(result).toBeNull();
         });
 
-        it("returns null when compaction values are not explicit booleans", async () => {
+        it("returns null when compaction.auto is not an explicit boolean", async () => {
             const client = {
                 config: {
                     get: async () => ({ data: { compaction: { auto: "true", prune: null } } }),
@@ -622,6 +882,16 @@ describe("detectConflicts", () => {
             expect(result).toBeNull();
         });
 
+        it("treats a non-boolean prune as false rather than discarding an explicit auto", async () => {
+            const client = {
+                config: {
+                    get: async () => ({ data: { compaction: { auto: true, prune: "yes" } } }),
+                },
+            };
+            const result = await resolveCompactionForBoot(client);
+            expect(result).toEqual({ auto: true, prune: false });
+        });
+
         it("returns null when the response data is missing entirely", async () => {
             const client = {
                 config: {