@cortexkit/opencode-magic-context 0.49.28 → 0.49.30

package/src/config/commit-retention-recovery.ts

@@ -0,0 +1,34 @@
+import type { MagicContextConfig } from "./schema/magic-context";
+
+type CommitIndexing = MagicContextConfig["memory"]["git_commit_indexing"];
+const pausedRetention = new WeakSet<CommitIndexing>();
+const RETENTION_FIELD = "memory.git_commit_indexing.max_commits";
+
+/** Keep a defaulted cap useful for bounded reads without letting it delete stored history. */
+export function applyCommitRetentionRecovery(
+    config: MagicContextConfig,
+    recoveredFieldPaths: readonly string[],
+    warnings: string[],
+): void {
+    if (
+        !recoveredFieldPaths.some(
+            (path) => RETENTION_FIELD === path || RETENTION_FIELD.startsWith(`${path}.`),
+        )
+    )
+        return;
+    pausedRetention.add(config.memory.git_commit_indexing);
+    const message = `${RETENTION_FIELD}: retention eviction is paused until the invalid value is fixed.`;
+    const index = warnings.findIndex((warning) => warning.includes(RETENTION_FIELD));
+    if (index >= 0) warnings[index] = `${warnings[index]} ${message}`;
+    else warnings.push(message);
+}
+
+export function isCommitRetentionPaused(settings: CommitIndexing): boolean {
+    return pausedRetention.has(settings);
+}
+
+/** Live sampling copies settings objects; recovery state must follow the sampled cap. */
+export function copyCommitRetentionRecovery(from: CommitIndexing, to: CommitIndexing): void {
+    if (pausedRetention.has(from)) pausedRetention.add(to);
+    else pausedRetention.delete(to);
+}

package/src/config/index.ts

@@ -15,6 +15,7 @@ import { log } from "../shared/logger";
 import { setOutputReserveConfig } from "../shared/models-dev-cache";
 import type { PromptSurfaceConfig } from "../shared/prompt-surface";
 import { isCompactionEnabled, migrateLegacyAgentEnabledInMemory } from "./agent-disable";
+import { applyCommitRetentionRecovery } from "./commit-retention-recovery";
 import { warnDeprecatedMuralModel, warnDeprecatedWindowOverlayPath } from "./deprecated-config";
 import {
     cortexKitProjectConfigBasePath,
@@ -121,6 +122,7 @@ export interface LoadResultDetailed {
     };
     substitutionFailures: Array<{ keyPath: string; source: "user" | "project"; message: string }>;
     recoveredTopLevelKeys: string[];
+    recoveredFieldPaths: string[];
     configParseFailures: ConfigParseFailure[];
     warningDetails: ConfigWarningDetail[];
     cacheTtlConfigured: boolean;
@@ -410,6 +412,7 @@ export function warnProtectedTagsDeprecationOnce(): void {
 export function parsePluginConfig(
     rawConfig: Record<string, unknown>,
     recoveredTopLevelKeys: string[] = [],
+    recoveredFieldPaths: string[] = [],
 ): MagicContextPluginConfig & { configWarnings?: string[] } {
     // Pre-Zod shim: reshape legacy experimental.* graduated keys so the user's
     // opt-in/out state survives upgrades even when they never run `doctor`.
@@ -543,6 +546,7 @@ export function parsePluginConfig(
             }
             if (prunedLeaves.length === issuePaths.length) {
                 patched[key] = prunedBlock;
+                recoveredFieldPaths.push(...prunedLeaves.map((leaf) => `${key}.${leaf}`));
                 const reason = customMessagesByKey.get(key);
                 warnings.push(
                     `"${key}": invalid nested field(s) ${prunedLeaves.map((leaf) => `"${key}.${leaf}"`).join(", ")}, using defaults for those.${reason ? ` ${reason}` : ""}`,
@@ -553,6 +557,7 @@ export function parsePluginConfig(
 
         // Root-level or unreachable agent errors cannot be repaired safely because
         // guessing a model configuration could select an expensive unintended model.
+        recoveredFieldPaths.push(key);
         if (isAgentConfig) {
             delete patched[key];
             warnings.push(
@@ -609,6 +614,13 @@ export function parsePluginConfig(
     // If even the patched version fails (shouldn't happen), fall back to full defaults
     // but keep enabled:true — the user intended to use the plugin.
     warnings.push("Config recovery failed, using all defaults.");
+    recoveredFieldPaths.push(
+        "embedding",
+        "memory",
+        "subc",
+        "shadow_embedding",
+        "allow_home_project",
+    );
     return {
         ...defaults,
         disabled_hooks: disabledHooks,
@@ -819,6 +831,7 @@ export function loadPluginConfigDetailed(
     // way that forces extra historian work on the user's account.
     const trustedBaseConfig = parsePluginConfig(trustedProfiledRaw);
     let projectRestoredTopLevelKeys: string[] = [];
+    let projectRestoredFieldPaths: string[] = [];
 
     if (projectLoaded) {
         mergedRaw = deepMergeRawConfig(mergedRaw, profileResolution.projectBase);
@@ -846,6 +859,7 @@ export function loadPluginConfigDetailed(
             allWarnings.push(`[project config] ${warning}`);
         }
         projectRestoredTopLevelKeys = restoredOverProject.restoredTopLevelKeys;
+        projectRestoredFieldPaths = restoredOverProject.restoredFieldPaths;
         for (const warning of constrainProjectCommands({
             mergedRaw,
             trustedRaw: trustedProfiledRaw,
@@ -857,8 +871,10 @@ export function loadPluginConfigDetailed(
     }
 
     const recoveredTopLevelKeys: string[] = [];
+    const recoveredFieldPaths: string[] = [];
     const cacheTtlConfigured = Object.hasOwn(mergedRaw, "cache_ttl");
-    const config = parsePluginConfig(mergedRaw, recoveredTopLevelKeys);
+    const config = parsePluginConfig(mergedRaw, recoveredTopLevelKeys, recoveredFieldPaths);
+    recoveredFieldPaths.push(...projectRestoredFieldPaths);
     // An ignored invalid project value is still a config the user must fix, so
     // keep reporting it as schema recovery (live reload keeps the last good
     // config on that outcome, as it did before the user's value was restored).
@@ -873,7 +889,10 @@ export function loadPluginConfigDetailed(
     if (applyRuntimeGlobals) {
         setOutputReserveConfig(config.output_reserve);
     }
-    const leafValidationWarnings = [...(config.configWarnings ?? [])];
+    const recoveryWarnings = config.configWarnings ?? [];
+    applyCommitRetentionRecovery(config, recoveredFieldPaths, recoveryWarnings);
+    if (recoveryWarnings.length > 0) config.configWarnings = recoveryWarnings;
+    const leafValidationWarnings = [...recoveryWarnings];
     if (config.configWarnings?.length) {
         allWarnings.push(
             ...config.configWarnings.map((w) => {
@@ -933,6 +952,7 @@ export function loadPluginConfigDetailed(
         sources,
         substitutionFailures,
         recoveredTopLevelKeys,
+        recoveredFieldPaths,
         configParseFailures,
         warningDetails,
         cacheTtlConfigured,

package/src/config/live-child-output-cap.test.ts

@@ -1,4 +1,5 @@
 import { expect, test } from "bun:test";
+import type { HiddenCompletionExecutor } from "../hooks/magic-context/compartment-runner-types";
 
 import { producerInputTokenLimit } from "../hooks/magic-context/producer-window-guard";
 import {
@@ -53,6 +54,33 @@ test("OpenCode 2 dreamer passes a fresh output cap to each hidden child", async
     expect(received).toEqual([4096, 8192]);
 });
 
+test("OpenCode 2 dreamer output-cap wrapper forwards partial output reads", async () => {
+    const boot = MagicContextConfigSchema.parse({});
+    const reads: Array<{ id: string; limit: number }> = [];
+    const executor: HiddenCompletionExecutor = {
+        capabilities: { tools: true, harness: "opencode2" },
+        open: async () => ({ id: "child" }),
+        attempt: async () => {},
+        collect: async () => {
+            throw new Error("no settled completion");
+        },
+        collectPartial: async (handle, limit) => {
+            reads.push({ id: handle.id, limit });
+            return {
+                text: "unfinished manifest",
+                usage: { input: 101, output: 11, cacheRead: 7, cacheWrite: 5 },
+                lengthCapped: false,
+            };
+        },
+        close: async () => {},
+    };
+    const wrapped = withLiveDreamerOutputCap(executor, boot, () => boot);
+    expect((await wrapped.collectPartial?.({ id: "child" }, 200))?.text).toBe(
+        "unfinished manifest",
+    );
+    expect(reads).toEqual([{ id: "child", limit: 200 }]);
+});
+
 test("OpenCode 1 historian keeps the sampled reserve and child output cap", () => {
     const boot = MagicContextConfigSchema.parse({ historian: { maxTokens: 2048 } });
     let current = MagicContextConfigSchema.parse({ historian: { maxTokens: 4096 } });

package/src/config/live-child-output-cap.ts

@@ -29,6 +29,8 @@ export function withLiveDreamerOutputCap<T extends MagicContextConfig>(
             }),
         attempt: (handle, request) => executor.attempt(handle, request),
         collect: (handle, limit) => executor.collect(handle, limit),
+        collectPartial: (handle, limit) =>
+            executor.collectPartial?.(handle, limit) ?? executor.collect(handle, limit),
         close: (handle, settlement) => executor.close(handle, settlement),
     };
 }

package/src/config/live-run-config.test.ts

@@ -9,10 +9,53 @@ import {
 import { producerInputTokenLimit } from "../hooks/magic-context/producer-window-guard";
 import { resolveDreamerTaskModel, resolveHistorianModel } from "../shared/model-resolution";
 import { createTestTempDirFromPath } from "../shared/test-temp-dir";
+import { isCommitRetentionPaused } from "./commit-retention-recovery";
 import { loadPluginConfigDetailed } from "./index";
-import { dreamerRunConfig, historianRunConfig } from "./live-run-config";
+import { changedLiveKeys, dreamerRunConfig, historianRunConfig } from "./live-run-config";
 import { LiveConfigReader } from "./live-snapshot";
 
+test("dreamer retains the recovered-cap pause through live copies and clears it when the same cap is fixed", () => {
+    const root = createTestTempDirFromPath(join(tmpdir(), "mc-live-retention-"));
+    const previous = process.env.XDG_CONFIG_HOME;
+    process.env.XDG_CONFIG_HOME = root;
+    const directory = join(root, "project");
+    const file = join(root, "cortexkit", "magic-context.jsonc");
+    mkdirSync(join(root, "cortexkit"), { recursive: true });
+    mkdirSync(directory, { recursive: true });
+    const writeCap = (max_commits: number) =>
+        writeFileSync(
+            file,
+            JSON.stringify({ memory: { git_commit_indexing: { enabled: true, max_commits } } }),
+        );
+    try {
+        writeCap(0);
+        const boot = loadPluginConfigDetailed(directory, false).config;
+        const reader = new LiveConfigReader(
+            directory,
+            boot,
+            () => {
+                const loaded = loadPluginConfigDetailed(directory, false);
+                if (loaded.loadOutcome === "schema-recovery") throw new Error("invalid config");
+                return loaded.config;
+            },
+            () => {},
+            changedLiveKeys,
+        );
+        const initial = dreamerRunConfig(boot, reader.poll().effective);
+        expect(initial.memory.git_commit_indexing.max_commits).toBe(2000);
+        expect(isCommitRetentionPaused(initial.memory.git_commit_indexing)).toBe(true);
+        writeCap(2000);
+        const fixed = dreamerRunConfig(boot, reader.poll().effective);
+        expect(fixed.memory.git_commit_indexing.max_commits).toBe(2000);
+        expect(isCommitRetentionPaused(fixed.memory.git_commit_indexing)).toBe(false);
+        expect(isCommitRetentionPaused(initial.memory.git_commit_indexing)).toBe(true);
+    } finally {
+        if (previous === undefined) delete process.env.XDG_CONFIG_HOME;
+        else process.env.XDG_CONFIG_HOME = previous;
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
 for (const host of ["OC1", "OC2", "Pi", "OMP"] as const) {
     test(`${host} historian samples the next generation while an existing run keeps its model and fallback`, () => {
         const root = createTestTempDirFromPath(join(tmpdir(), "mc-live-historian-"));

package/src/config/live-run-config.ts

@@ -1,4 +1,5 @@
 import { log } from "../shared/logger";
+import { copyCommitRetentionRecovery } from "./commit-retention-recovery";
 import { loadPluginConfigDetailed, type MagicContextPluginConfig } from "./index";
 import { LiveConfigReader } from "./live-snapshot";
 import { LIVE_RELOAD_CONFIG_PATHS, type MagicContextConfig } from "./schema/magic-context";
@@ -32,7 +33,13 @@ export function sampleLiveConfig<T extends MagicContextConfig>(boot: T, fresh: T
         const leaf = parts.at(-1);
         if (leaf !== undefined) target[leaf] = value;
     }
-    return result as T;
+    const sampled = result as T;
+    const freshCommitIndexing = fresh.memory?.git_commit_indexing;
+    const sampledCommitIndexing = sampled.memory?.git_commit_indexing;
+    if (freshCommitIndexing && sampledCommitIndexing) {
+        copyCommitRetentionRecovery(freshCommitIndexing, sampledCommitIndexing);
+    }
+    return sampled;
 }
 
 function removeLeaf(root: Record<string, unknown>, parts: string[]): void {

package/src/config/project-config-trust-boundary.test.ts

@@ -2,7 +2,9 @@ import { describe, expect, it } from "bun:test";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { isConfigLoadUntrusted } from "../plugin/embedding-bootstrap-helpers";
 import { createTestTempDirFromPath } from "../shared/test-temp-dir";
+import { isCommitRetentionPaused } from "./commit-retention-recovery";
 import { loadPluginConfigDetailed } from "./index";
 
 /**
@@ -38,6 +40,61 @@ function loadUserAndProject(user: unknown, project: unknown) {
 }
 
 describe("project config cannot reset user settings with a wrong-typed parent block", () => {
+    it("pauses retention eviction for a recovered commit cap without making memory untrusted", () => {
+        const loaded = loadUserAndProject(
+            { memory: { git_commit_indexing: { enabled: true, max_commits: 0 } } },
+            {},
+        );
+        expect(loaded.config.memory.git_commit_indexing.max_commits).toBe(2000);
+        expect(isCommitRetentionPaused(loaded.config.memory.git_commit_indexing)).toBe(true);
+        expect(isConfigLoadUntrusted(loaded)).toBe(false);
+        expect(
+            loaded.config.configWarnings?.filter((warning) =>
+                warning.includes("retention eviction is paused"),
+            ),
+        ).toHaveLength(1);
+        expect(loaded.config.configWarnings?.join("\n")).toContain(
+            "memory.git_commit_indexing.max_commits",
+        );
+        expect(
+            loaded.warningDetails.filter((warning) =>
+                warning.message.includes("retention eviction is paused"),
+            ),
+        ).toHaveLength(1);
+        const valid = loadUserAndProject(
+            { memory: { git_commit_indexing: { enabled: true, max_commits: 100 } } },
+            {},
+        );
+        expect(isCommitRetentionPaused(valid.config.memory.git_commit_indexing)).toBe(false);
+    });
+
+    it("recovers an out-of-range injection budget without making memory untrusted", () => {
+        const loaded = loadUserAndProject({}, { memory: { injection_budget_tokens: 20001 } });
+        expect(loaded.config.memory.enabled).toBe(true);
+        expect(loaded.config.memory.injection_budget_tokens).toBe(4000);
+        expect(loaded.recoveredFieldPaths).toEqual(["memory.injection_budget_tokens"]);
+        expect(loaded.config.configWarnings?.join("\n")).toContain(
+            "memory.injection_budget_tokens",
+        );
+        expect(isConfigLoadUntrusted(loaded)).toBe(false);
+    });
+
+    it("records the exact restored project leaf without distrusting a plain threshold", () => {
+        const loaded = loadUserAndProject(
+            { memory: { auto_search: { score_threshold: 0.7 } } },
+            { memory: { auto_search: { score_threshold: "invalid" } } },
+        );
+        expect(loaded.config.memory.auto_search.score_threshold).toBe(0.7);
+        expect(loaded.recoveredFieldPaths).toEqual(["memory.auto_search.score_threshold"]);
+        expect(isConfigLoadUntrusted(loaded)).toBe(false);
+    });
+
+    it("keeps an invalid embedding model untrusted after field recovery", () => {
+        const loaded = loadUserAndProject({ embedding: { model: 123 } }, {});
+        expect(loaded.recoveredFieldPaths).toEqual(["embedding.model"]);
+        expect(isConfigLoadUntrusted(loaded)).toBe(true);
+    });
+
     it("keeps the user's compaction block when the project sets compaction:false", () => {
         const loaded = loadUserAndProject(
             { compaction: { enabled: false } },

package/src/config/project-security.ts

@@ -973,7 +973,7 @@ export function restoreTrustedValuesOverInvalidProjectValues(args: {
     trustedRaw: Record<string, unknown>;
     projectRaw: Record<string, unknown>;
     collectIssuePaths: (raw: Record<string, unknown>) => readonly ConfigIssuePath[];
-}): { warnings: string[]; restoredTopLevelKeys: string[] } {
+}): { warnings: string[]; restoredTopLevelKeys: string[]; restoredFieldPaths: string[] } {
     const warnings: string[] = [];
     const restoredTopLevelKeys = new Set<string>();
     const restored = new Set<string>();
@@ -1000,7 +1000,11 @@ export function restoreTrustedValuesOverInvalidProjectValues(args: {
         if (!changed) break;
     }
 
-    return { warnings, restoredTopLevelKeys: [...restoredTopLevelKeys] };
+    return {
+        warnings,
+        restoredTopLevelKeys: [...restoredTopLevelKeys],
+        restoredFieldPaths: [...restored],
+    };
 }
 
 const PROJECT_COMMAND_STRING_FIELDS = ["description", "agent", "model"] as const;

package/src/shared/marker-only-text.ts

@@ -0,0 +1,8 @@
+// Models sometimes imitate dropped placeholders with a blank or bare numeric tag.
+// Match only complete marker-only text, never prose that mentions a placeholder.
+const MARKER_ONLY_PATTERN = /^(?:(?:§\d+§|\[dropped\s*(?:\d+|§\d*§)?\]|\[cleared\])\s*)+$/;
+
+export function isMarkerOnlyText(text: string): boolean {
+    const trimmed = text.trim();
+    return trimmed.length > 0 && MARKER_ONLY_PATTERN.test(trimmed);
+}

package/src/shared/windows-hidden-spawns.test.ts

@@ -30,21 +30,28 @@ function sourceFiles(dir: string): string[] {
 function missingHiddenOptions(path: string, text = readFileSync(path, "utf8")): string[] {
     if (!/node:child_process|Bun\.spawn/.test(text)) return [];
     const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
-    const imports = new Set<string>();
+    const imports = new Map<string, string>();
+    const promisifyImports = new Set<string>();
+    const utilImports = new Set<string>();
     const variables = new Map<string, ts.Expression>();
     for (const statement of source.statements) {
-        if (
-            ts.isImportDeclaration(statement) &&
-            statement.moduleSpecifier.getText(source).includes("node:child_process")
-        ) {
-            const bindings = statement.importClause?.namedBindings;
-            if (bindings && ts.isNamedImports(bindings)) {
-                for (const element of bindings.elements) {
-                    if (subprocessNames.has(element.propertyName?.text ?? element.name.text))
-                        imports.add(element.name.text);
-                }
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const module = statement.moduleSpecifier.text;
+        const bindings = statement.importClause?.namedBindings;
+        if (bindings && ts.isNamedImports(bindings)) {
+            for (const element of bindings.elements) {
+                const imported = element.propertyName?.text ?? element.name.text;
+                if (module === "node:child_process" && subprocessNames.has(imported))
+                    imports.set(element.name.text, imported);
+                if ((module === "node:util" || module === "util") && imported === "promisify")
+                    promisifyImports.add(element.name.text);
             }
         }
+        if (module === "node:util" || module === "util") {
+            if (bindings && ts.isNamespaceImport(bindings)) utilImports.add(bindings.name.text);
+            if (statement.importClause?.name) utilImports.add(statement.importClause.name.text);
+        }
     }
     function collect(node: ts.Node): void {
         if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer)
@@ -52,6 +59,44 @@ function missingHiddenOptions(path: string, text = readFileSync(path, "utf8")):
         ts.forEachChild(node, collect);
     }
     collect(source);
+    function isUtil(node: ts.Expression, seen = new Set<string>()): boolean {
+        if (ts.isParenthesizedExpression(node)) return isUtil(node.expression, seen);
+        if (!ts.isIdentifier(node)) return false;
+        if (utilImports.has(node.text)) return true;
+        if (seen.has(node.text)) return false;
+        seen.add(node.text);
+        const initializer = variables.get(node.text);
+        return initializer ? isUtil(initializer, seen) : false;
+    }
+    function isPromisify(node: ts.Expression, seen = new Set<string>()): boolean {
+        if (ts.isParenthesizedExpression(node)) return isPromisify(node.expression, seen);
+        if (ts.isIdentifier(node)) {
+            if (promisifyImports.has(node.text)) return true;
+            if (seen.has(node.text)) return false;
+            seen.add(node.text);
+            const initializer = variables.get(node.text);
+            return initializer ? isPromisify(initializer, seen) : false;
+        }
+        return (
+            ts.isPropertyAccessExpression(node) &&
+            isUtil(node.expression) &&
+            node.name.text === "promisify"
+        );
+    }
+    function subprocess(node: ts.Expression, seen = new Set<string>()): string | undefined {
+        if (ts.isParenthesizedExpression(node)) return subprocess(node.expression, seen);
+        if (ts.isIdentifier(node)) {
+            const imported = imports.get(node.text);
+            if (imported) return imported;
+            if (seen.has(node.text)) return undefined;
+            seen.add(node.text);
+            const initializer = variables.get(node.text);
+            return initializer ? subprocess(initializer, seen) : undefined;
+        }
+        if (ts.isCallExpression(node) && isPromisify(node.expression) && node.arguments[0])
+            return subprocess(node.arguments[0], seen);
+        return undefined;
+    }
     function hidden(node: ts.Expression | undefined, seen = new Set<string>()): boolean {
         if (!node) return false;
         if (ts.isIdentifier(node)) {
@@ -90,39 +135,49 @@ function missingHiddenOptions(path: string, text = readFileSync(path, "utf8")):
         if (ts.isCallExpression(node)) {
             const expression = node.expression;
             let name: string | undefined;
+            // Track the original API, not the alias name: exec takes options at index 1,
+            // while execFile and spawn take them at index 2, even after promisify.
+            let kind = subprocess(expression);
+            if (kind) name = expression.getText(source);
             if (
+                !kind &&
                 ts.isIdentifier(expression) &&
-                (imports.has(expression.text) ||
-                    [
-                        "execFileAsync",
-                        "execFileSyncForIdentity",
-                        "rpcIdentityExecFileSync",
-                        "execFileForVerificationPaths",
-                    ].includes(expression.text) ||
+                ([
+                    "execFileAsync",
+                    "execFileSyncForIdentity",
+                    "rpcIdentityExecFileSync",
+                    "execFileForVerificationPaths",
+                ].includes(expression.text) ||
                     (expression.text === "exec" && path.endsWith("rpc-utils.ts")))
-            )
+            ) {
                 name = expression.text;
+                kind = "execFile";
+            }
             if (ts.isPropertyAccessExpression(expression)) {
                 const owner = expression.expression.getText(source);
                 if (
                     owner === "Bun" &&
                     (expression.name.text === "spawn" || expression.name.text === "spawnSync")
-                )
+                ) {
                     name = "Bun.spawn";
+                    kind = "Bun.spawn";
+                }
                 if (
                     (owner === "deps" || owner === "this") &&
                     (subprocessNames.has(expression.name.text) ||
                         expression.name.text === "spawnImpl")
-                )
+                ) {
                     name = expression.name.text;
+                    kind = expression.name.text;
+                }
             }
             if (name) {
                 const index =
-                    name === "Bun.spawn"
+                    kind === "Bun.spawn"
                         ? node.arguments.length === 1
                             ? 0
                             : 1
-                        : name === "execSync" || (name === "exec" && !path.endsWith("rpc-utils.ts"))
+                        : kind === "execSync" || kind === "exec"
                           ? 1
                           : 2;
                 // A single-argument Bun.spawnSync({cmd, ...}) passes options as its first argument.
@@ -158,6 +213,61 @@ describe("Windows child processes", () => {
         expect(failures).toEqual([]);
     });
 
+    test.each([
+        ["execFile", "[],"],
+        ["exec", ""],
+        ["spawn", "[],"],
+    ])("follows promisified %s aliases and checks the original options position", (api, args) => {
+        const path = join(root, "packages/plugin/src/shared/promisified-fixture.ts");
+        const text = `import { ${api} as childProcess } from "node:child_process";
+            import { promisify as toPromise } from "node:util";
+            const rawAlias = childProcess;
+            const promiseAlias = toPromise;
+            const exec = promiseAlias(rawAlias);
+            const run = exec;
+            run("git", ${args} { windowsHide: true });
+            run("git", ${args} { windowsHide: false });
+            run("git", ${args} {});`;
+        expect(missingHiddenOptions(path, text)).toEqual([
+            "packages/plugin/src/shared/promisified-fixture.ts:8 run",
+            "packages/plugin/src/shared/promisified-fixture.ts:9 run",
+        ]);
+    });
+
+    test.each([
+        'import { promisify } from "node:util";',
+        'import * as util from "node:util"; const promisify = util.promisify;',
+        'import util from "util"; const promisify = util.promisify;',
+        'import * as util from "node:util"; const u = util; const promisify = u.promisify;',
+    ])("recognizes promisify bindings: %s", (utilImport) => {
+        const path = join(root, "packages/plugin/src/shared/promisified-fixture.ts");
+        const text = `import { execFile } from "node:child_process";
+            ${utilImport}
+            const exec = promisify(execFile);
+            exec("git", [], { windowsHide: true });
+            exec("git", [], {});`;
+        expect(missingHiddenOptions(path, text)).toEqual([
+            "packages/plugin/src/shared/promisified-fixture.ts:5 exec",
+        ]);
+    });
+
+    test("recognizes direct util.promisify calls and does not trust options in the wrong slot", () => {
+        const path = join(root, "packages/plugin/src/shared/promisified-fixture.ts");
+        const text = `import { execFile, exec, spawn } from "node:child_process";
+            import * as util from "node:util";
+            const file = util.promisify(execFile);
+            const shell = util.promisify(exec);
+            const child = util.promisify(spawn);
+            file("git", { windowsHide: true }, {});
+            shell("git", {}, { windowsHide: true });
+            child("git", { windowsHide: true }, {});`;
+        expect(missingHiddenOptions(path, text)).toEqual([
+            "packages/plugin/src/shared/promisified-fixture.ts:6 file",
+            "packages/plugin/src/shared/promisified-fixture.ts:7 shell",
+            "packages/plugin/src/shared/promisified-fixture.ts:8 child",
+        ]);
+    });
+
     test("another dashboard subprocess still requires windowsHide true", () => {
         const path = join(root, "packages/cli/src/lib/dashboard-install.ts");
         const text = `import { execFile } from "node:child_process";