@cortexkit/opencode-magic-context 0.43.1 → 0.44.0

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

@@ -217,6 +217,29 @@ describe("status detail text", () => {
         );
     });
 
+    test("says which runner ran the session's completions and why", () => {
+        const status = formatStatusDetailMarkdown({
+            ...STATUS_FIXTURE,
+            historianRunner: {
+                runner: "host",
+                source: "default_for_harness",
+                harness: "opencode",
+                observed: "last_completion",
+            },
+            dreamerRunner: {
+                runner: "broca",
+                source: "configured",
+                harness: "opencode",
+                observed: "resolved_for_route",
+            },
+        });
+
+        expect(status).toMatch(
+            /^- \*\*Historian runner:\*\* host \(default for harness opencode\)$/m,
+        );
+        expect(status).toContain("- **Dreamer runner:** broca (configured) · no completion yet");
+    });
+
     test("does not expose module routing in the summary", () => {
         const rustStatus = formatStatusDetailMarkdown({
             ...STATUS_FIXTURE,

package/src/shared/status-summary.ts

@@ -1,5 +1,5 @@
 import { formatCacheTtlDisplay } from "./cache-ttl-display";
-import type { StatusDetail } from "./rpc-types";
+import type { RunnerStatus, StatusDetail } from "./rpc-types";
 import { renderUserFacingFailure, type UserFacingFailureKey } from "./user-facing-codes";
 
 export type StatusCompressionState = "off" | "compressing" | "ready" | "waiting";
@@ -32,6 +32,8 @@ export interface UserStatusSummary {
         detail: string;
     };
     compactionMarker?: StatusDetail["compactionMarker"];
+    historianRunner?: RunnerStatus;
+    dreamerRunner?: RunnerStatus;
     warnings: UserFacingFailureKey[];
     hiddenVariantWarnings?: string[];
 }
@@ -96,6 +98,8 @@ export function statusSummaryFromDetail(detail: StatusDetail): UserStatusSummary
             total: 0,
         },
         historianRefusal: detail.historianRefusal,
+        historianRunner: detail.historianRunner,
+        dreamerRunner: detail.dreamerRunner,
         compactionMarker: detail.compactionMarker,
         warnings: [...new Set(warnings)],
         hiddenVariantWarnings: detail.hiddenVariantWarnings ?? [],
@@ -122,6 +126,20 @@ function compressionText(summary: UserStatusSummary): string {
     }
 }
 
+/**
+ * `host (default for harness opencode)` or `broca (configured)`, plus a note when
+ * no completion has run yet in the module's current process and the value is
+ * only what the session's route resolves to.
+ */
+export function runnerText(status: RunnerStatus): string {
+    const why =
+        status.source === "configured"
+            ? "configured"
+            : `default for harness ${status.harness || "unknown"}`;
+    const observed = status.observed === "last_completion" ? "" : " · no completion yet";
+    return `${status.runner} (${why})${observed}`;
+}
+
 function reclaimableText(summary: UserStatusSummary): string {
     const count = Math.max(0, Math.floor(summary.reclaimable.toolOutputCount));
     if (count === 0) return "none";
@@ -170,6 +188,12 @@ export function renderUserStatusSummary(
         ],
         ["Search indexing", embeddingText(summary)],
     ];
+    if (summary.historianRunner) {
+        values.push(["Historian runner", runnerText(summary.historianRunner)]);
+    }
+    if (summary.dreamerRunner) {
+        values.push(["Dreamer runner", runnerText(summary.dreamerRunner)]);
+    }
     if (summary.historianRefusal) {
         values.push([
             "Historian refusal",

package/src/shared/tag-transcript.ts

@@ -66,6 +66,7 @@ import {
     stripWellFormedLeadingTagPrefix,
 } from "../hooks/magic-context/tag-content-primitives";
 import type { TagTarget } from "../hooks/magic-context/tag-messages";
+import { toolInputStringBytes } from "../hooks/magic-context/tool-input-size";
 import type { Transcript, TranscriptMessage, TranscriptPart } from "./transcript";
 
 export const TEXT_TAG_IDENTITY_MARKER = ":mc-text-v1:";
@@ -161,6 +162,12 @@ interface ToolOccurrence {
     message: { info: { id?: string; role: string } };
     part: TranscriptPart;
     kind: "tool_use" | "tool_result";
+    /**
+     * The call's real input, captured the first time this pass overwrote it
+     * with the legacy marker, so a later real-argument render in the same pass
+     * can put it back.
+     */
+    originalInput?: Record<string, unknown>;
 }
 
 interface TagTranscriptTiming {
@@ -1093,10 +1100,13 @@ function buildAggregateTarget(
     const truncate = (): "truncated" | "absent" => {
         // Keep the tool call and its result, but replace the call arguments with
         // a non-executable marker and the result content with the dropped marker.
+        // Legacy render, replayed only for `drop_mode = 'truncated'` tags until a
+        // HARD fold converts them; new drops use skeletonReal().
         const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
         let any = false;
         for (const occ of occurrences) {
             if (occ.kind === "tool_use" && occ.part.setToolInput) {
+                occ.originalInput ??= occ.part.getToolInput?.() ?? undefined;
                 if (occ.part.setToolInput(droppedInputMarker(tagId))) any = true;
             } else if (setToolContentOrText(occ.part, sentinel)) {
                 any = true;
@@ -1105,6 +1115,38 @@ function buildAggregateTarget(
         return any ? "truncated" : "absent";
     };
 
+    const complete = (): boolean =>
+        occurrences.some((occ) => occ.kind === "tool_use") &&
+        occurrences.some((occ) => occ.kind === "tool_result");
+
+    const skeletonReal = (): "truncated" | "absent" | "incomplete" => {
+        // Keep the tool call with the arguments the host gave it and replace
+        // only the result content with the dropped marker. Nothing is written
+        // into the argument position unless an earlier render this pass did,
+        // in which case the real input goes back.
+        if (!complete()) return "incomplete";
+        const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
+        let any = false;
+        for (const occ of occurrences) {
+            if (occ.kind === "tool_use") {
+                if (occ.originalInput && occ.part.setToolInput?.(occ.originalInput)) any = true;
+            } else if (setToolContentOrText(occ.part, sentinel)) {
+                any = true;
+            }
+        }
+        return any ? "truncated" : "absent";
+    };
+
+    // Adapters without structural removal (or arcs that must keep their pair
+    // beside native reasoning) cannot remove the call; drop() would keep it.
+    const cannotRemove = (): boolean => {
+        if (requiresToolArcSkeleton) return true;
+        const authorization = occurrences.map((occ) => occ.part.canRemove?.());
+        return !occurrences.every(
+            (occ, index) => occ.part.remove && authorization[index] !== false,
+        );
+    };
+
     return {
         measureReclaim(skeleton) {
             let beforeTools = 0;
@@ -1125,10 +1167,8 @@ function buildAggregateTarget(
                         : (occ.part.getText() ?? "");
                 beforeTools += estimateTokens(before);
                 if (skeleton || !removable) {
-                    const after =
-                        occ.kind === "tool_use"
-                            ? JSON.stringify(droppedInputMarker(tagId))
-                            : `[dropped §${tagId}§]`;
+                    // A kept call keeps its real arguments; only the result shrinks.
+                    const after = occ.kind === "tool_use" ? before : `[dropped §${tagId}§]`;
                     afterTools += estimateTokens(after);
                 }
             }
@@ -1163,10 +1203,7 @@ function buildAggregateTarget(
             return occurrences[0]?.part.getText() ?? null;
         },
         drop(): "removed" | "truncated" | "absent" | "incomplete" {
-            const complete =
-                occurrences.some((occ) => occ.kind === "tool_use") &&
-                occurrences.some((occ) => occ.kind === "tool_result");
-            if (!complete) return "incomplete";
+            if (!complete()) return "incomplete";
             if (!requiresToolArcSkeleton) {
                 const authorization = occurrences.map((occ) => occ.part.canRemove?.());
                 // A failed durable marker is not permission to substitute a new
@@ -1178,19 +1215,23 @@ function buildAggregateTarget(
                     )
                 ) {
                     // If removing this call's result would leave the provider
-                    // request ending on an assistant turn, keep a call skeleton
-                    // plus placeholder result instead. "truncated" tells callers
-                    // to persist that mode, so later passes serve the same bytes.
+                    // request ending on an assistant turn, keep the call with its
+                    // REAL arguments plus the placeholder result instead.
+                    // "truncated" tells callers to persist that mode
+                    // (`skeleton_real`), so later passes serve the same bytes.
                     // (The sentinel fallback below keeps call and result in place,
                     // so it needs no exception.)
-                    if (conversationEnd?.wouldStrand(occurrences)) return truncate();
+                    if (conversationEnd?.wouldStrand(occurrences)) return skeletonReal();
                     let removed = false;
                     for (const occ of occurrences) removed = occ.part.remove?.() || removed;
                     if (removed) conversationEnd?.noteRemoved(occurrences);
                     return removed ? "removed" : "absent";
                 }
             }
-            // Adapters without structural removal retain paired sentinels.
+            // Adapters without structural removal retain paired sentinels. This
+            // writes a marker into the call's arguments, so only replays of
+            // existing `full` tags reach it: new drops check cannotRemove() and
+            // use skeletonReal(), and a HARD fold converts the existing ones.
             const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
             let any = false;
             for (const occ of occurrences) {
@@ -1199,6 +1240,18 @@ function buildAggregateTarget(
             return any ? "removed" : "absent";
         },
         truncate,
+        skeletonReal,
+        cannotRemove,
+        inputStringBytes(): number | null {
+            for (const occ of occurrences) {
+                if (occ.kind !== "tool_use") continue;
+                return toolInputStringBytes(occ.originalInput ?? occ.part.getToolInput?.() ?? null);
+            }
+            return null;
+        },
+        wouldStrandConversationEnd(): boolean {
+            return conversationEnd?.wouldStrand(occurrences) ?? false;
+        },
         editMarker(): "truncated" | "absent" {
             // Edit-marker: preserve the tool_use input's filePath + a region
             // hint of the diff, sentinelize the result half. Separate from
@@ -1222,12 +1275,7 @@ function buildAggregateTarget(
             return any ? "truncated" : "absent";
         },
         // Open invocations still belong to the current turn; only complete arcs reclaim.
-        canDrop(): boolean {
-            return (
-                occurrences.some((occ) => occ.kind === "tool_use") &&
-                occurrences.some((occ) => occ.kind === "tool_result")
-            );
-        },
+        canDrop: complete,
         requiresToolArcSkeleton,
         // Non-mutating read of the invocation input (the tool_use occurrence
         // carries the arguments). Used by smart-drops supersession selection.
@@ -1310,11 +1358,26 @@ function buildToolTarget(
             return replaced ? "removed" : "absent";
         },
         truncate(): "truncated" | "absent" {
+            // Legacy render, replayed only for unconverted `truncated` tags.
             const changed = part.setToolInput
                 ? part.setToolInput(droppedInputMarker(tagId))
                 : setToolContentOrText(part, `[dropped \u00a7${tagId}\u00a7]`);
             return changed ? "truncated" : "absent";
         },
+        skeletonReal(): "truncated" | "absent" {
+            // An invocation part keeps its real arguments untouched; a result
+            // part's content becomes the dropped marker.
+            if (part.setToolInput) return "truncated";
+            return setToolContentOrText(part, `[dropped \u00a7${tagId}\u00a7]`)
+                ? "truncated"
+                : "absent";
+        },
+        // drop() replaces an invocation part's arguments with a marker, so a
+        // new drop of one keeps its real arguments instead.
+        cannotRemove: () => part.setToolInput !== undefined,
+        inputStringBytes(): number | null {
+            return part.setToolInput ? toolInputStringBytes(part.getToolInput?.() ?? null) : 0;
+        },
         message: {
             info: { id: message.info.id, role: message.info.role },
             parts: [],

package/src/shared/test-fake-executable.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "bun:test";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname } from "node:path";
+import { testExecutableRoot, writeTestExecutable } from "./test-fake-executable";
+
+// Fixed contents on purpose: a random body would create a new executable on
+// every run, which is exactly what the helper exists to avoid.
+const STUB = "#!/bin/sh\necho test-fake-executable-helper\n";
+
+describe("writeTestExecutable", () => {
+    it("places the stub at a content-addressed path under the shared root", () => {
+        const path = writeTestExecutable("helper-stub", STUB);
+
+        expect(basename(path)).toBe("helper-stub");
+        expect(dirname(dirname(path))).toBe(testExecutableRoot());
+        expect(basename(dirname(path))).toMatch(/^[0-9a-f]{16}$/);
+        expect(readFileSync(path, "utf8")).toBe(STUB);
+        if (process.platform !== "win32") expect(statSync(path).mode & 0o111).not.toBe(0);
+        expect(readdirSync(dirname(path))).toEqual(["helper-stub"]);
+    });
+
+    it("reuses the existing file instead of rewriting it", () => {
+        const first = writeTestExecutable("helper-stub", STUB);
+        const before = statSync(first);
+        const second = writeTestExecutable("helper-stub", STUB);
+        const after = statSync(second);
+
+        expect(second).toBe(first);
+        expect(after.ino).toBe(before.ino);
+        expect(after.mtimeMs).toBe(before.mtimeMs);
+    });
+
+    it("gives different content or a different name a different directory", () => {
+        const base = writeTestExecutable("helper-stub", STUB);
+        const otherContent = writeTestExecutable("helper-stub", `${STUB}exit 0\n`);
+        const otherName = writeTestExecutable("helper-stub-2", STUB);
+
+        expect(new Set([dirname(base), dirname(otherContent), dirname(otherName)]).size).toBe(3);
+    });
+
+    it("keeps a directory-name prefix verbatim before the hash", () => {
+        const prefix = "mc %MC_TEST% & shim ";
+        const path = writeTestExecutable("helper-stub", STUB, { dirPrefix: prefix });
+        const dirName = basename(dirname(path));
+
+        expect(dirName.startsWith(prefix)).toBe(true);
+        expect(dirName.slice(prefix.length)).toMatch(/^[0-9a-f]{16}$/);
+    });
+
+    it("rejects names that would escape the stub directory", () => {
+        expect(() => writeTestExecutable("../escape", STUB)).toThrow();
+        expect(() => writeTestExecutable("stub", STUB, { dirPrefix: "a/b" })).toThrow();
+    });
+});

package/src/shared/test-fake-executable.ts

@@ -0,0 +1,110 @@
+import { createHash, randomBytes } from "node:crypto";
+import {
+    chmodSync,
+    mkdirSync,
+    readFileSync,
+    renameSync,
+    rmSync,
+    statSync,
+    writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Test-only helper for fake executables (shell stubs standing in for opencode,
+ * sqlite3, bun, ...).
+ *
+ * macOS runs a malware assessment the first time any new executable file is
+ * launched. Writing a fresh stub into a fresh temp directory for every test
+ * case therefore triggers one assessment per case per run. Instead, each
+ * distinct stub lives at a fixed, content-addressed path and is written only
+ * once; later tests and later runs reuse the same file.
+ *
+ * Callers must never delete these files in per-test cleanup, and must never
+ * modify one in place: a test that needs a stub to "change" between steps asks
+ * for a second stub with different content, which lands at a different path.
+ */
+
+/** Directory name under the OS temp dir that holds every shared fake executable. */
+export const TEST_EXECUTABLE_ROOT_NAME = "magic-context-test-bin";
+
+export function testExecutableRoot(): string {
+    return join(tmpdir(), TEST_EXECUTABLE_ROOT_NAME);
+}
+
+export interface WriteTestExecutableOptions {
+    /**
+     * Kept verbatim in front of the hash in the directory name. Use it only when
+     * the test depends on the directory name itself, for example to exercise
+     * quoting of spaces or shell metacharacters in the executable's path.
+     */
+    dirPrefix?: string;
+}
+
+function assertSinglePathSegment(label: string, value: string, allowEmpty: boolean): void {
+    if ((!allowEmpty && value.length === 0) || value === "." || value === "..") {
+        throw new Error(`writeTestExecutable: invalid ${label} ${JSON.stringify(value)}`);
+    }
+    if (value.includes("/") || value.includes("\\") || value.includes("\0")) {
+        throw new Error(`writeTestExecutable: ${label} must be a single path segment`);
+    }
+}
+
+function hasExpectedContent(path: string, content: string): boolean {
+    try {
+        if (readFileSync(path, "utf8") !== content) return false;
+        // Windows has no executable bit, so content alone decides there.
+        return process.platform === "win32" || (statSync(path).mode & 0o111) !== 0;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Returns the path of an executable named `name` whose bytes are `content`,
+ * creating it only when no identical file exists yet. The path is
+ * `<tmpdir>/magic-context-test-bin/<dirPrefix><first 16 hex of sha256(name, content)>/<name>`,
+ * so each directory holds exactly one executable and pointing PATH at it
+ * exposes nothing else.
+ *
+ * The file is written to a unique temporary name in the same directory and
+ * then renamed into place, so concurrent test processes never observe a
+ * half-written stub.
+ */
+export function writeTestExecutable(
+    name: string,
+    content: string,
+    options: WriteTestExecutableOptions = {},
+): string {
+    const dirPrefix = options.dirPrefix ?? "";
+    assertSinglePathSegment("name", name, false);
+    assertSinglePathSegment("dirPrefix", dirPrefix, true);
+
+    // The NUL separator keeps ("ab", "c") and ("a", "bc") from sharing a hash.
+    const hash = createHash("sha256")
+        .update(name)
+        .update("\0")
+        .update(content)
+        .digest("hex")
+        .slice(0, 16);
+    const dir = join(testExecutableRoot(), `${dirPrefix}${hash}`);
+    const target = join(dir, name);
+    if (hasExpectedContent(target, content)) return target;
+
+    mkdirSync(dir, { recursive: true });
+    const staging = join(dir, `.${name}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+    try {
+        writeFileSync(staging, content, { mode: 0o755 });
+        // The process umask can strip bits from the create mode; set them explicitly.
+        chmodSync(staging, 0o755);
+        renameSync(staging, target);
+    } catch (error) {
+        rmSync(staging, { force: true });
+        // Another process may have won the race with identical bytes (Windows
+        // refuses to rename over a file that is currently open).
+        if (hasExpectedContent(target, content)) return target;
+        throw error;
+    }
+    return target;
+}

package/src/shared/user-facing-codes.ts

@@ -12,6 +12,12 @@ export const USER_FACING_FAILURES = {
         sentence: "Some finished background sessions could not be removed from this host.",
         action: "They are removed automatically the next time Magic Context runs inside a registered OpenCode service.",
     },
+    historian_saved_history_misaligned: {
+        code: "MC-H03",
+        sentence:
+            "History compression is paused because this session's saved summaries no longer line up with its messages.",
+        action: "Run /ctx-recomp to rebuild them.",
+    },
     recomp_unavailable: {
         code: "MC-R01",
         sentence: "History compression could not be rebuilt.",
@@ -27,6 +33,11 @@ export const USER_FACING_FAILURES = {
         sentence: "Memory maintenance could not reach its model.",
         action: "Check the model connection, then run /ctx-dream again.",
     },
+    dream_step_limit: {
+        code: "MC-D10",
+        sentence: "Memory maintenance stopped at its hidden agent step limit.",
+        action: "This task needs less work per run; changing the model connection will not help.",
+    },
     dream_empty_completion: {
         code: "MC-D03",
         sentence: "Memory maintenance received no usable response.",
@@ -183,11 +194,22 @@ export const USER_FACING_FAILURES = {
         sentence: "History compression is paused while the engine syncs.",
         action: "Retry in a moment.",
     },
+    history_compression_needs_message: {
+        code: "MC-C12",
+        sentence: "History compression has not seen this session since Magic Context reconnected.",
+        action: "Send a message in this session first, then run /ctx-wrapup again.",
+    },
     context_service_unavailable: {
         code: "MC-C10",
         sentence: "Magic Context is temporarily unavailable.",
         action: "Retry in a moment.",
     },
+    store_ahead_of_binary: {
+        code: "MC-C13",
+        sentence:
+            "Magic Context refused to start: its store (store.db) was migrated by a newer ck-mc build than the one running.",
+        action: "Update ck-mc, or roll back by restoring ck-mc together with context.db and store.db from the same backup.",
+    },
     compaction_marker_missing: {
         code: "MC-C11",
         sentence:
@@ -204,11 +226,6 @@ export const USER_FACING_FAILURES = {
         sentence: "Memory authority is inconsistent between the host and module.",
         action: "Run `ck doctor drain-authority` before changing Rust mode.",
     },
-    rust_mode_unsupported: {
-        code: "MC-S06",
-        sentence: "Experimental Rust transform mode is not available on this OpenCode host.",
-        action: 'Magic Context is running its TypeScript mode instead; set `transform_mode` to "ts" to stop requesting Rust.',
-    },
     dreamer_task_failing: {
         code: "MC-S05",
         sentence: "A background maintenance task keeps failing on its schedule.",
@@ -267,6 +284,7 @@ export function capabilityRefusalCode(capability: CapabilityRefusal): string {
 const DREAM_FAILURE_KEYS = {
     provider_timeout: "dream_provider_timeout",
     provider_error: "dream_provider_error",
+    step_limit: "dream_step_limit",
     empty_completion: "dream_empty_completion",
     no_models: "dream_no_models",
     child_aborted: "dream_child_aborted",

package/src/shared/window-geometry.ts

@@ -645,9 +645,12 @@ export function hasTrustedAbsoluteWall(geometry: WindowGeometryResult): boolean
 }
 
 /**
- * Successful requests can disprove static catalog metadata, but cannot
- * disprove a provider, overlay, or observed-overflow wall. A reading beyond
- * that wall is malformed usage accounting and must not enlarge the geometry.
+ * Successful requests can disprove static catalog metadata, but do not widen a
+ * provider, overlay, or observed-overflow wall here. A provider or overlay wall
+ * is the configured limit: a reading beyond it is real pressure against that
+ * limit (the usage handlers count it in full), not proof that the geometry
+ * should grow. An observed-overflow wall that a larger accepted request
+ * disproves is cleared by the usage handlers instead.
  */
 export function applyProvenInputFloor(
     geometry: WindowGeometryResult,

package/dist/v2/hooks/provider-admission.d.ts

@@ -1,22 +0,0 @@
-export interface ProviderAdmissionInput {
-    /** Input + cached-read + cached-write tokens of the newest assistant reply. */
-    inputTokens: number;
-    /** The provider's own context window for the outgoing model, when the catalog knows it. */
-    rawContextLimit: number | undefined;
-    /** True when the host wrote a compaction after the reply the tokens were read from. */
-    hostCompactionReducedUsage: boolean;
-}
-/**
- * Whether the OpenCode 2 context hook must stop a request before it reaches the
- * provider.
- *
- * The provider's own context window is the only admission boundary here. Every
- * other kind of pressure — in particular usage that fits the window but not the
- * room reserved for the reply — has to be admitted, because the work that
- * relieves it (compacting history into a compartment, and the high-pressure
- * handling around it) all happens further down this same pass. A request stopped
- * here runs none of it, so a session refused for pressure Magic Context could
- * have removed is refused again on every following turn.
- */
-export declare function refusesBeforeProvider(input: ProviderAdmissionInput): boolean;
-//# sourceMappingURL=provider-admission.d.ts.map

package/dist/v2/hooks/provider-admission.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider-admission.d.ts","sourceRoot":"","sources":["../../../src/v2/hooks/provider-admission.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACnC,+EAA+E;IAC/E,WAAW,EAAE,MAAM,CAAC;IACpB,2FAA2F;IAC3F,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,uFAAuF;IACvF,0BAA0B,EAAE,OAAO,CAAC;CACvC;AAKD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAkB5E"}

package/dist/wrapup-orchestrator-y0bs7t5a.js

@@ -1,18 +0,0 @@
-import {
-  runManagedWrapup2
-} from "./index-1gtwrdc4.js";
-import"./index-7wpwr2e2.js";
-import"./index-sd3egckz.js";
-import"./index-0ccmyzbj.js";
-import"./index-yc81txp4.js";
-import"./index-j7cnyvq1.js";
-import"./index-y5145x8k.js";
-import"./index-v8qr6tt2.js";
-import"./index-9r1cbh9e.js";
-import"./index-jdxxq8cz.js";
-import"./index-febg06dy.js";
-import"./index-wgzyeyf5.js";
-import"./index-6z9g64js.js";
-export {
-  runManagedWrapup2 as runManagedWrapup
-};