@cortexkit/opencode-magic-context 0.44.2 → 0.44.4

package/src/shared/user-answer.test.ts

@@ -0,0 +1,40 @@
+import { expect, it } from "bun:test";
+import cases from "../../../../tests/fixtures/user-answer-metadata.json";
+import { hasUserAnswerMetadata, toolPartHasUserAnswer } from "./user-answer";
+
+it("TS/Rust parity recognizes structural host answer metadata", () => {
+    for (const test of cases) {
+        expect(hasUserAnswerMetadata(test.metadata)).toBe(test.protected);
+        expect(toolPartHasUserAnswer({ state: { metadata: test.metadata } })).toBe(test.protected);
+        expect(toolPartHasUserAnswer({ details: test.metadata })).toBe(test.protected);
+    }
+    expect(toolPartHasUserAnswer({ tool: "question", state: { output: "no marker" } })).toBe(false);
+});
+
+it("OpenCode CK sidecars preserve answer provenance without changing block identities", async () => {
+    const { encodeOpenCodeMessagesToCk } = await import("../hooks/magic-context/module-wire");
+    const message = {
+        info: { id: "m", role: "assistant" },
+        parts: [
+            {
+                type: "tool",
+                tool: "renamed-question",
+                callID: "q",
+                state: {
+                    status: "completed",
+                    input: {},
+                    output: "answer",
+                    metadata: { answers: [["yes"]] },
+                },
+            },
+        ],
+    };
+    const answered = encodeOpenCodeMessagesToCk([message]);
+    const plain = structuredClone(message);
+    Reflect.deleteProperty(plain.parts[0].state, "metadata");
+    const ordinary = encodeOpenCodeMessagesToCk([plain]);
+    expect(answered[0].ck.content).toEqual(ordinary[0].ck.content);
+    expect(answered[0].ck.provider_extras).toEqual({
+        opencode: { user_answer_block_indices: [1] },
+    });
+});

package/src/shared/user-answer.ts

@@ -0,0 +1,17 @@
+import { isRecord } from "./record-type-guard";
+
+/** Host-owned answer metadata, independent of the tool's registered name. */
+export function hasUserAnswerMetadata(value: unknown): boolean {
+    if (!isRecord(value)) return false;
+    if (value.userAnswer === true) return true;
+    if (Array.isArray(value.answers)) return true;
+    if (typeof value.answer === "string") return true;
+    if (Array.isArray(value.selectedOptions) || typeof value.customInput === "string") return true;
+    return Array.isArray(value.results) && value.results.some(hasUserAnswerMetadata);
+}
+
+export function toolPartHasUserAnswer(part: unknown): boolean {
+    if (!isRecord(part)) return false;
+    const state = isRecord(part.state) ? part.state : undefined;
+    return hasUserAnswerMetadata(state?.metadata) || hasUserAnswerMetadata(part.details);
+}

package/src/shared/write-transaction-attribution.test.ts

@@ -6,7 +6,7 @@ import { join, resolve } from "node:path";
 const repoRoot = resolve(import.meta.dir, "../../../../");
 const beginImmediate = /\b(?:[A-Za-z_$][\w$]*\.)?exec\("BEGIN IMMEDIATE"\)/g;
 
-const fencedSources: Array<{ path: string; sites: string[] }> = [
+const fencedSources: Array<{ path: string; sites: string[]; reporterCalls?: string[] }> = [
     {
         path: "packages/plugin/src/features/magic-context/smart-notes/storage.ts",
         sites: ["smart_note_commit"],
@@ -52,8 +52,8 @@ const fencedSources: Array<{ path: string; sites: string[] }> = [
         // The chokepoint cannot import the logging chain (Node executes it
         // directly), so it reports through the injected reporter instead.
         path: "packages/plugin/src/shared/sqlite.ts",
-        sites: ["privileged_writer"],
-        reporterCall: "reportSlowPrivilegedWrite?.(",
+        sites: ["async_acquisition_dynamic_site", "privileged_writer"],
+        reporterCalls: ["console.warn(", "reportSlowPrivilegedWrite?.("],
     },
     {
         path: "packages/plugin/src/features/magic-context/git-commits/sweep-coordinator.ts",
@@ -75,10 +75,6 @@ const fencedSources: Array<{ path: string; sites: string[] }> = [
         path: "packages/plugin/src/hooks/magic-context/compartment-runner-recomp.ts",
         sites: ["historian-publish:recomp"],
     },
-    {
-        path: "packages/plugin/src/hooks/magic-context/compartment-runner-incremental.ts",
-        sites: ["historian-publish"],
-    },
     {
         path: "packages/plugin/src/features/magic-context/dreamer/lease.ts",
         sites: ["lease_dynamic_site"],
@@ -98,6 +94,10 @@ const fencedSources: Array<{ path: string; sites: string[] }> = [
 ];
 
 const nonBeginCoveredSites: Array<{ path: string; site: string }> = [
+    {
+        path: "packages/plugin/src/hooks/magic-context/compartment-runner-incremental.ts",
+        site: "historian-publish",
+    },
     {
         path: "packages/plugin/src/features/magic-context/message-index.ts",
         site: "message_index_clear",
@@ -159,7 +159,7 @@ function sourceFor(relativePath: string): string {
 function assertCoveredBeginImmediate(
     source: string,
     sites: string[],
-    reporterCall = "logSlowWriteTransaction(",
+    reporterCalls: string[] = [],
 ): void {
     const matches = [...source.matchAll(beginImmediate)];
     expect(matches).toHaveLength(sites.length);
@@ -167,8 +167,10 @@ function assertCoveredBeginImmediate(
         const match = matches[index];
         const nextBegin = matches[index + 1]?.index ?? source.length;
         const transactionRegion = source.slice(match.index, nextBegin);
-        expect(transactionRegion).toContain(reporterCall);
-        if (sites[index] === "lease_dynamic_site") {
+        expect(transactionRegion).toContain(reporterCalls[index] ?? "logSlowWriteTransaction(");
+        if (sites[index] === "async_acquisition_dynamic_site") {
+            expect(transactionRegion).toContain("site=${site}");
+        } else if (sites[index] === "lease_dynamic_site") {
             expect(transactionRegion).toContain("logSlowWriteTransaction(site");
         } else {
             expect(transactionRegion).toContain(`"${sites[index]}"`);
@@ -219,7 +221,7 @@ describe("write transaction attribution fences", () => {
             assertCoveredBeginImmediate(
                 sourceFor(fencedSource.path),
                 fencedSource.sites,
-                "reporterCall" in fencedSource ? fencedSource.reporterCall : undefined,
+                fencedSource.reporterCalls,
             );
         }
         for (const coveredSite of nonBeginCoveredSites) {