@mjasnikovs/pi-task 0.38.2 → 0.38.4

package/dist/task/final-gate.js

@@ -57,6 +57,7 @@ import { readEnvNotes, parseEnvNotes, isExcuseNote } from './env-notes.js';
 import { runRenderCheck } from './render-check.js';
 import { collectProjectEnv, pinnedLocalPort, runDeepRenderCheck } from './deep-render-check.js';
 import { resolveRunner, runnerEnv, isCommandNotFound } from './runner-resolve.js';
+import { classifyCommandRun, spawnCommand, outputTail, INFRA_GAP_OUTPUT_RE } from './command-run.js';
 import { findLaunchConfigGap, probeEnv, configGapUnobservedNote } from './launch-config-gap.js';
 import { taskThatIntroduced } from './task-provenance.js';
 import { findDanglingArtifacts, danglingGateFailureText } from './artifact-closure.js';
@@ -978,30 +979,6 @@ function resolveCommandBody(bin, args, scripts, makefile) {
     }
     return null;
 }
-/** Last ~`limit` chars of the command's combined output, one line, for the reason. */
-function outputTail(stdout, stderr, limit = 400) {
-    const combined = `${stdout}\n${stderr}`.trim();
-    if (combined.length === 0)
-        return '';
-    const tail = combined.slice(-limit).replace(/\s+/g, ' ').trim();
-    return combined.length > limit ? `…${tail}` : tail;
-}
-/**
- * A non-zero exit whose output shows an EXTERNAL runtime dependency is missing, not
- * a code fault: a browser suite (Playwright/Cypress) whose browser binaries or system
- * libraries were never installed here (mx5 run 10 item 2: `test:ct` must run in the
- * gate, but on a box with no Playwright browsers it is an environment gap, not a FAIL).
- * These exit non-zero (not 127), so they need output-shape recognition to skip.
- */
-const ENV_GAP_OUTPUT_RE = /Executable doesn't exist|playwright install|browserType\.\w+: Executable|(?:wasn't|weren't) installed|Host system is missing dependencies|No usable sandbox|Cypress verification|Cypress executable (?:not found|was not found)|browser(?:s)? (?:is|are)? ?not installed/i;
-/**
- * A non-zero exit whose output shows the EXTERNAL INFRASTRUCTURE a launch script
- * talks to is absent HERE — a database/daemon that is not running or not
- * installed — rather than a fault in the script itself. Applied ONLY to
- * launch-contract scripts (a migrate/seed against no DB is an environment gap on
- * this box; the same wording in a `test` run is a real failure the suite must own).
- */
-export const INFRA_GAP_OUTPUT_RE = /ECONNREFUSED|connection refused|ENOTFOUND|EAI_AGAIN|is the server running|could not connect|cannot connect to the docker daemon|connect: connection|no such host/i;
 /**
  * Run one gate command with the env-gap contract: tool missing, timeout, or
  * command-not-found inside the script chain (127) → environment gap, not a code
@@ -1013,36 +990,20 @@ export const INFRA_GAP_OUTPUT_RE = /ECONNREFUSED|connection refused|ENOTFOUND|EA
 function runGateCommand(cwd, [bin, args], timeoutMs, extraGapRe, 
 /** Replaces the child's environment wholesale (config-gap probe re-run only —
  *  see launch-config-gap.ts). Absent ⇒ `runnerEnv(runner)`, i.e. unchanged. */
-envOverride) {
+envOverride, 
+/** The spawner. Injected so the gate's own tests can script a verdict. */
+run = spawnCommand) {
     // Runner resolution (mx5 run 16): a login-shell-stripped PATH left `bun`
     // unspawnable, so every dynamic check skipped and the gate went blind. The
     // resolved binary is spawned, and its directory rides on the child's PATH so
     // the SCRIPT CHAIN can re-invoke the runner (`bun run test` runs `bun test`
     // inside — a bare 127 there is the same blindness one level down).
-    // env passed explicitly: bun's spawnSync resolves the binary against a
-    // startup snapshot of the environment, not the live process.env.
     const runner = resolveRunner(bin);
-    const r = spawnSync(runner.bin, args, {
-        cwd,
-        encoding: 'utf8',
-        timeout: timeoutMs,
-        env: envOverride ?? runnerEnv(runner)
-    });
-    if (r.error)
-        return { outcome: 'skip', spawnFailed: true };
-    if (r.status === null)
-        return { outcome: 'skip', spawnFailed: false };
-    if (r.status !== 0) {
-        const output = `${r.stdout ?? ''}\n${r.stderr ?? ''}`;
-        if (isCommandNotFound(r.status, output))
-            return { outcome: 'skip', spawnFailed: false };
-        if (ENV_GAP_OUTPUT_RE.test(output))
-            return { outcome: 'skip', spawnFailed: false };
-        if (extraGapRe?.test(output))
-            return { outcome: 'skip', spawnFailed: false };
-        return { outcome: 'fail', status: r.status, tail: outputTail(r.stdout ?? '', r.stderr ?? '') };
+    const verdict = classifyCommandRun(run({ cwd, bin: runner.bin, args, timeoutMs, env: envOverride ?? runnerEnv(runner) }), extraGapRe ? [extraGapRe] : []);
+    if (verdict.outcome === 'gap') {
+        return { outcome: 'skip', spawnFailed: verdict.gap === 'spawn-failed' };
     }
-    return { outcome: 'pass' };
+    return verdict;
 }
 /** The command word of a shell line, past any leading `VAR=value` assignments. */
 function leadingBin(line) {
@@ -1068,31 +1029,28 @@ function leadingBin(line) {
  * failure, missing tool, unreachable database, timeout, no POSIX shell — leaves the
  * debt exactly as open as it was.
  */
-export function runVerifyCommandLine(cwd, line, timeoutMs, extraGapRe) {
+export function runVerifyCommandLine(cwd, line, timeoutMs, extraGapRe, 
+/** The spawner. Injected so a re-run's outcome can be tested without one. */
+run = spawnCommand) {
     const bin = leadingBin(line);
     const runner = bin === null ? null : resolveRunner(bin);
-    const r = spawnSync('sh', ['-c', line], {
+    // A VERIFY line is a SHELL line, not an argv — env prefixes, `&&` and
+    // redirects are all ordinary there — so the runner spawns `sh -c`.
+    const verdict = classifyCommandRun(run({
         cwd,
-        encoding: 'utf8',
-        timeout: timeoutMs,
+        bin: 'sh',
+        args: ['-c', line],
+        timeoutMs,
         env: runner ? runnerEnv(runner) : { ...process.env }
-    });
-    if (r.error)
-        return { outcome: 'gap', detail: `shell did not spawn (${r.error.message})` };
-    if (r.status === null)
-        return { outcome: 'gap', detail: 'killed (timeout or signal)' };
-    const output = `${r.stdout ?? ''}\n${r.stderr ?? ''}`;
-    if (r.status === 0)
-        return { outcome: 'pass' };
-    if (isCommandNotFound(r.status, output)) {
-        return { outcome: 'gap', detail: 'command not found (127)' };
-    }
-    if (ENV_GAP_OUTPUT_RE.test(output))
-        return { outcome: 'gap', detail: 'missing browser/runtime' };
-    if (INFRA_GAP_OUTPUT_RE.test(output) || extraGapRe?.test(output) === true) {
-        return { outcome: 'gap', detail: 'external infrastructure unreachable' };
-    }
-    return { outcome: 'fail', status: r.status, tail: outputTail(r.stdout ?? '', r.stderr ?? '') };
+    }), 
+    // Infrastructure counts as a gap on EVERY debt re-run, not only on
+    // request: an unreachable database cannot tell us whether the code is
+    // fixed, and the asymmetry below means an inconclusive re-run simply
+    // leaves the debt as open as it was.
+    extraGapRe ? [INFRA_GAP_OUTPUT_RE, extraGapRe] : [INFRA_GAP_OUTPUT_RE]);
+    if (verdict.outcome === 'gap')
+        return { outcome: 'gap', detail: verdict.detail };
+    return verdict;
 }
 /**
  * The full-skip blindness guard (mx5 run 16, validated): dynamic commands were
@@ -1312,17 +1270,21 @@ const DEBT_INFRA_GAP_RE = /ERR_POSTGRES_CONNECTION_CLOSED|ERR_MYSQL_CONNECTION|E
  * the guard: the re-run is INCONCLUSIVE there, because "nothing changed" would be an
  * assumption rather than an observation.
  */
-export function rerunDebtVerifyCommand(cwd, command) {
+export function rerunDebtVerifyCommand(cwd, command, 
+/** The spawner, for BOTH the command and the tracked-state reads. Injected so
+ *  the guard's four outcomes are testable without a repo or a real command. */
+run = spawnCommand) {
     const tracked = () => {
-        const r = spawnSync('git', ['status', '--porcelain', '--untracked-files=no'], {
+        const r = run({
             cwd,
-            encoding: 'utf8',
-            timeout: 60_000
+            bin: 'git',
+            args: ['status', '--porcelain', '--untracked-files=no'],
+            timeoutMs: 60_000
         });
-        return r.error || r.status !== 0 ? null : (r.stdout ?? '');
+        return r.failedToStart || r.status !== 0 ? null : r.stdout;
     };
     const before = tracked();
-    const r = runVerifyCommandLine(cwd, command, DEBT_RERUN_TIMEOUT_MS, DEBT_INFRA_GAP_RE);
+    const r = runVerifyCommandLine(cwd, command, DEBT_RERUN_TIMEOUT_MS, DEBT_INFRA_GAP_RE, run);
     if (r.outcome === 'fail')
         return { outcome: 'fail', detail: `exit ${r.status} — ${r.tail}` };
     if (r.outcome === 'gap')

package/dist/task/gate-child.d.ts

@@ -0,0 +1,104 @@
+/**
+ * gate-child — running ONE gate child pi, and the table of what each kind of gate
+ * child is allowed to do.
+ *
+ * Five children run under the gates: `verify`, `recommend`, `lint-fix`,
+ * `final-fix` and `enforce`. All five share one ritual — reset the widget state,
+ * stamp the start, open a per-gate debug log, write a start marker, raise a
+ * status loader, call `runWorker` unguarded (no wall clock, exact-match loop
+ * guard only), warn on a surviving loop, classify the failure, write an end
+ * marker, throw on failure, and stop the loader in a `finally`. That was ~85
+ * lines, and it was written TWICE: once as `makeGateChild` and once as an inline
+ * closure for `enforce`, whose comments repeated the originals verbatim.
+ *
+ * The enforce copy differed in exactly four things — no git-state guard, no
+ * tool-result logging, no tree-change capture, and a different end marker — which
+ * is why they are row data here rather than a forked body. Apply the deletion
+ * test to that copy and it passes: routing enforce through this concentrates the
+ * differences into a table instead of moving them.
+ *
+ * The second reason for the module is that all of it used to live inside
+ * `buildGateDeps`'s closure, so nothing about it was reachable from a test:
+ * `buildGateDeps` is ~700 lines and is never called by the suite. The
+ * git-state-guard wiring in particular — snapshot, restore-in-`finally`,
+ * `verdictTainted` — is the mechanism that discards a verify verdict computed on
+ * a tree the child mutated (mx5 run 6, where the verify child `git stash`ed the
+ * task's uncommitted work and never popped it), and it could only be checked
+ * indirectly through a fake `mutationCheck` one layer up. Here `runWorker` and
+ * the git helpers are injected, so the ordering, the trail lines and the
+ * throwing-child path are all directly assertable.
+ */
+import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import type { RunWorkerInput, RunWorkerResult } from '../workers/pi-worker-core.js';
+import type { GitStateSnapshot, ReconcileResult } from './git-state-guard.js';
+import type { ContextSnapshot } from '../shared/child-process.js';
+import type { AutoLoaderState } from './widget.js';
+/** Which gate child this is. */
+export type GateChildKind = 'verify' | 'recommend' | 'lint-fix' | 'final-fix' | 'enforce';
+export interface GateChildRow {
+    /**
+     * Snapshot the tree before and restore after. These children are read-only BY
+     * CONTRACT, but the contract is prompt-level and the live model breaks it.
+     * `lint-fix` and `final-fix` are excluded because editing is their job (they
+     * carry their own revert guards), and `enforce` because it edits too.
+     */
+    guarded: boolean;
+    /**
+     * Log tool OUTPUTS, not just the calls (mx5 run 10 item 6): without the result,
+     * "verify claimed curl PASS on a server that cannot serve" is undecidable from
+     * the log. Off for `enforce`, whose log is a per-pass verdict trail.
+     */
+    logToolResults: boolean;
+    /** The loader's step label. */
+    step: string;
+    /** The end-marker written on success. */
+    okMarker: string;
+}
+/**
+ * What each kind may do. Adding a child is a row; it cannot be added without
+ * deciding all four questions, which is the point.
+ */
+export declare const GATE_CHILD_KINDS: Record<GateChildKind, GateChildRow>;
+/** Everything the runner needs that is not a property of the KIND. */
+export interface GateChildDeps {
+    ctx: ExtensionCommandContext;
+    cwd: string;
+    taskTitle: string;
+    kind: GateChildKind;
+    /** Absolute path of the debug log for this gate. */
+    logPath: string;
+    /**
+     * `false` when the CALLER already renders a loader spanning this child (the
+     * verify gate does). Two loaders on one widget key only fight each other.
+     */
+    loader?: boolean;
+    /** Per-command ceiling; pi's bash tool has no default timeout. */
+    commandTimeoutMs: number;
+    /** Hung-stream bound; the probe-based stall guard cannot supply it. */
+    streamInactivityMs: number;
+    parentContextWindow: number;
+    runWorker: (input: RunWorkerInput) => Promise<RunWorkerResult>;
+    makeDebugAppender: (path: string) => (line: string, level?: 'event' | 'stream') => void;
+    startAutoLoader: (ctx: ExtensionCommandContext, getState: () => AutoLoaderState | null) => () => void;
+    captureGitState: (cwd: string, signal?: AbortSignal) => Promise<GitStateSnapshot>;
+    reconcileGitState: (cwd: string, snapshot: GitStateSnapshot, signal?: AbortSignal) => Promise<ReconcileResult>;
+    /** Tree changes for a WRITE-capable child, already formatted. */
+    describeTreeChanges: (cwd: string, signal?: AbortSignal) => Promise<string>;
+    resolveContextUsage: (snapshot: ContextSnapshot, prev: ContextSnapshot | undefined, parentContextWindow: number) => ContextSnapshot;
+    truncateToolResult: (text: string) => string;
+    /** Where the live widget reads `lastLine` / `contextUsage` from. */
+    widget: {
+        lastLine?: string;
+        contextUsage?: ContextSnapshot;
+    };
+    /** Set to the last reconcile so the caller can discard a tainted verdict. */
+    onReconcile?: (rec: ReconcileResult) => void;
+}
+/**
+ * Build the `runChild` closure the gate steps expect.
+ *
+ * The `finally` ordering is load-bearing: the git-state restore runs BEFORE any
+ * verdict or failure is acted on, and it runs even when the child THREW — a
+ * crashed child must not skip the restore.
+ */
+export declare function makeGateChild(deps: GateChildDeps): (tools: string, prompt: string, sig?: AbortSignal) => Promise<string>;

package/dist/task/gate-child.js

@@ -0,0 +1,177 @@
+/**
+ * gate-child — running ONE gate child pi, and the table of what each kind of gate
+ * child is allowed to do.
+ *
+ * Five children run under the gates: `verify`, `recommend`, `lint-fix`,
+ * `final-fix` and `enforce`. All five share one ritual — reset the widget state,
+ * stamp the start, open a per-gate debug log, write a start marker, raise a
+ * status loader, call `runWorker` unguarded (no wall clock, exact-match loop
+ * guard only), warn on a surviving loop, classify the failure, write an end
+ * marker, throw on failure, and stop the loader in a `finally`. That was ~85
+ * lines, and it was written TWICE: once as `makeGateChild` and once as an inline
+ * closure for `enforce`, whose comments repeated the originals verbatim.
+ *
+ * The enforce copy differed in exactly four things — no git-state guard, no
+ * tool-result logging, no tree-change capture, and a different end marker — which
+ * is why they are row data here rather than a forked body. Apply the deletion
+ * test to that copy and it passes: routing enforce through this concentrates the
+ * differences into a table instead of moving them.
+ *
+ * The second reason for the module is that all of it used to live inside
+ * `buildGateDeps`'s closure, so nothing about it was reachable from a test:
+ * `buildGateDeps` is ~700 lines and is never called by the suite. The
+ * git-state-guard wiring in particular — snapshot, restore-in-`finally`,
+ * `verdictTainted` — is the mechanism that discards a verify verdict computed on
+ * a tree the child mutated (mx5 run 6, where the verify child `git stash`ed the
+ * task's uncommitted work and never popped it), and it could only be checked
+ * indirectly through a fake `mutationCheck` one layer up. Here `runWorker` and
+ * the git helpers are injected, so the ordering, the trail lines and the
+ * throwing-child path are all directly assertable.
+ */
+import { formatLoopHint } from './child-runner.js';
+import { classifyEnforceChildFailure } from './enforce-guidelines.js';
+/**
+ * What each kind may do. Adding a child is a row; it cannot be added without
+ * deciding all four questions, which is the point.
+ */
+export const GATE_CHILD_KINDS = {
+    verify: { guarded: true, logToolResults: true, step: 'verify', okMarker: 'ok' },
+    recommend: { guarded: true, logToolResults: true, step: 'recommend', okMarker: 'ok' },
+    // Editing is lint-fix's job, so the guard would revert its work.
+    'lint-fix': { guarded: false, logToolResults: true, step: 'lint-fix', okMarker: 'ok' },
+    'final-fix': { guarded: false, logToolResults: true, step: 'final-fix', okMarker: 'ok' },
+    enforce: {
+        guarded: false,
+        logToolResults: false,
+        step: 'guidelines',
+        okMarker: 'verdict captured'
+    }
+};
+/**
+ * Build the `runChild` closure the gate steps expect.
+ *
+ * The `finally` ordering is load-bearing: the git-state restore runs BEFORE any
+ * verdict or failure is acted on, and it runs even when the child THREW — a
+ * crashed child must not skip the restore.
+ */
+export function makeGateChild(deps) {
+    const row = GATE_CHILD_KINDS[deps.kind];
+    return async (tools, prompt, sig) => {
+        deps.widget.lastLine = undefined;
+        deps.widget.contextUsage = undefined;
+        const startedAt = Date.now();
+        // Every marker below (start/end, the guard's restore, the loop warning, a
+        // write-capable child's tree changes) is a guard record that survives at
+        // the default level. Only the child's own stdout and its tool results
+        // pass 'stream'.
+        const log = deps.makeDebugAppender(deps.logPath);
+        log(`=== ${deps.kind} start: ${deps.taskTitle} ===`);
+        const guardSnapshot = row.guarded ? await deps.captureGitState(deps.cwd, sig) : null;
+        const stopLoader = deps.loader === false ?
+            () => { }
+            : deps.startAutoLoader(deps.ctx, () => ({
+                title: deps.taskTitle,
+                kind: deps.kind,
+                step: row.step,
+                stepNum: 1,
+                stepTotal: 1,
+                startedAt,
+                lastLine: deps.widget.lastLine,
+                contextUsage: deps.widget.contextUsage
+            }));
+        try {
+            let r;
+            try {
+                r = await deps.runWorker({
+                    prompt,
+                    cwd: deps.cwd,
+                    ...(sig ? { signal: sig } : {}),
+                    tools,
+                    // Run to completion: these passes legitimately read and edit the
+                    // same file many times, and the research-worker guards mislabel
+                    // that as a runaway and kill good work (mx5 TASK_0002).
+                    timeoutMs: 0,
+                    commandTimeoutMs: deps.commandTimeoutMs,
+                    streamInactivityMs: deps.streamInactivityMs,
+                    // Exact-match loop guard only: pathThreshold Infinity disables
+                    // the path-revisit heuristic, so revisiting one file (which IS
+                    // the job) never trips — only a literally-identical call
+                    // repeated past threshold does.
+                    loop: { pathThreshold: Number.POSITIVE_INFINITY },
+                    // A discarded attempt is otherwise invisible: the returned
+                    // exitCode/text describe the FINAL attempt, so a child that
+                    // burned two attempts reads exactly like one that ran clean.
+                    onRestart: rs => log(`=== ${deps.kind} RESTART (attempt ${rs.attempt} discarded)`
+                        + ` reason=${rs.reason} wall=${rs.wallMs}ms`
+                        + (rs.detail ? ` — ${rs.detail}` : '')
+                        + ' ==='),
+                    onLine: line => {
+                        // `lastLine` feeds the LIVE widget and is not logging — it
+                        // stays outside the gate, or a quiet trail would also blank
+                        // the progress display.
+                        deps.widget.lastLine = line;
+                        log(line, 'stream');
+                    },
+                    ...(row.logToolResults ?
+                        {
+                            onToolResult: ({ name, isError, text }) => log(`↳ ${name} [${isError ? 'ERR' : 'ok'}]: `
+                                + deps.truncateToolResult(text), 'stream')
+                        }
+                        : {}),
+                    onContextUsage: snapshot => {
+                        deps.widget.contextUsage = deps.resolveContextUsage(snapshot, deps.widget.contextUsage, deps.parentContextWindow);
+                    }
+                });
+            }
+            finally {
+                // Restore whatever the child moved BEFORE any verdict or failure is
+                // acted on — a crashed child must not skip the restore either.
+                if (guardSnapshot) {
+                    const rec = await deps.reconcileGitState(deps.cwd, guardSnapshot, sig);
+                    deps.onReconcile?.(rec);
+                    if (rec.mutated) {
+                        // Distinguish the two outcomes in the trail: a tainting
+                        // mutation (graded work altered → verdict discarded) vs
+                        // benign cleanup (test-runner output the child left behind
+                        // → verdict stands).
+                        const label = rec.verdictTainted ?
+                            'child mutated graded state (verdict discarded)'
+                            : 'cleaned child test-runner artifacts (verdict kept)';
+                        log(`=== ${deps.kind} GIT-STATE GUARD — ${label}; `
+                            + `restored: ${rec.actions.join('; ')} ===`);
+                        if (rec.verdictTainted) {
+                            deps.ctx.ui.notify(`${deps.taskTitle}: ${deps.kind} child mutated repo state — `
+                                + `restored (${rec.actions.join('; ').slice(0, 140)}).`, 'warning');
+                        }
+                    }
+                }
+            }
+            // A loop that survived the restart-with-hint nudges is a WARNING, not a
+            // failure: log it and tell the user, but let the verdict gate be the
+            // only thing that can block.
+            if (r.loopHit) {
+                log(`=== ${deps.kind} LOOP WARNING — ${formatLoopHint(r.loopHit)} ===`);
+                deps.ctx.ui.notify(`${deps.taskTitle}: ${deps.kind} worker looped past the nudges — `
+                    + 'continuing (not blocked).', 'warning');
+            }
+            const failure = classifyEnforceChildFailure(r);
+            log(failure ?
+                `=== ${deps.kind} end: FAIL — ${failure} ===`
+                : `=== ${deps.kind} end: ${row.okMarker} ===`);
+            if (failure)
+                throw new Error(failure);
+            // CAPABILITY-LEVEL diff capture (mx5 run 11): any WRITE-capable child —
+            // decided by its TOOLS, not by which phase spawned it — gets its tree
+            // changes logged, so a future write-capable kind cannot run invisibly
+            // the way the final-fix child's `rm` did.
+            if (/\b(?:edit|bash|write)\b/.test(tools)) {
+                log(`=== ${deps.kind} tree changes: `
+                    + `${await deps.describeTreeChanges(deps.cwd, sig)} ===`);
+            }
+            return r.text;
+        }
+        finally {
+            stopLoader();
+        }
+    };
+}

package/dist/task/gate-deps.d.ts

@@ -38,6 +38,19 @@ export declare function collectChangedFiles(cwd: string, signal?: AbortSignal):
  * never a blocker. The `.pi-tasks/` bookkeeping is excluded from every git command.
  */
 export declare function collectAddedLines(cwd: string, signal?: AbortSignal): Promise<AddedLine[]>;
+/**
+ * Deterministic sandbox-path-leak pass (see foreign-path.ts, mx5 run 13 PROMPT 4
+ * item 1): find absolute paths the task committed that resolve nowhere on this
+ * machine while the real file sits in the repo, REPAIR the ones whose relative
+ * form provably resolves, and return verify findings for whatever is left.
+ *
+ * The repair runs here, before the verify child, for the same reason lint-fix
+ * does: the defect is mechanical and the correct target is already known, so
+ * spending an AUTOFIX round (or a human) on a path substitution is waste. What it
+ * cannot repair still reaches the child under rule 4e. Failures degrade to no
+ * findings — a sharpener, never a blocker.
+ */
+export declare function collectForeignPathFindings(cwd: string, signal?: AbortSignal, logDebug?: (m: string) => void): Promise<string[]>;
 /**
  * Deterministic neutered-check-script pass (see script-escape.ts, mx5 run 13 PROMPT
  * 4 item 4): check-class scripts that cannot report failure, in a manifest THIS