opencode-swarm 7.139.2 → 7.139.4

package/dist/prm/escalation.d.ts

@@ -3,6 +3,30 @@
  * Implements a 3-strike protocol for pattern detection escalation
  */
 import type { CourseCorrection, EscalationState, PatternMatch } from './types';
+/**
+ * Resolves the LADDER key for a match — the identity whose 1→2→3 strike count
+ * this detection belongs to (issue #2134 follow-up).
+ *
+ * The ladder used to be keyed by pattern TYPE alone, so unrelated occurrences
+ * accumulated into one count: a coder that read-then-re-read three different
+ * files produced three `repetition_loop` strikes on three different targets and
+ * hit the hard stop, even though it had not repeated itself even twice on any
+ * one of them. "Three strikes" has to mean "the same behaviour three times".
+ *
+ * A pattern reporting exactly ONE affected target gets a per-target ladder —
+ * `repetition_loop`, `ping_pong` and `stuck_on_test` all name the single file or
+ * target they are about, so that target IS the behaviour's identity.
+ *
+ * A pattern reporting a SET of targets keeps the per-pattern-type ladder.
+ * `context_thrash` and `expansion_drift` describe one ongoing episode over a
+ * growing collection of targets; keying those by target would mint a fresh
+ * ladder on every tool call and they could never escalate at all — the exact
+ * fail-open shape that the per-detector containment review caught the first time.
+ *
+ * Agents are deliberately not in the key. Escalation is about the work, not who
+ * did it, and `ping_pong` names two agents by construction.
+ */
+export declare function resolveLadderKey(match: PatternMatch): string;
 /**
  * Creates a default EscalationState with all counters reset and flags cleared.
  * Exported for testing purposes.
@@ -48,6 +72,16 @@ export declare class EscalationTracker {
      * @returns The current EscalationState copy
      */
     getState(): EscalationState;
+    /**
+     * Returns a defensive copy of just the ladder counts (issue #2134 follow-up).
+     *
+     * `src/prm/index.ts` mirrors these onto the session after every strike so a
+     * tracker rebuilt mid-session restores the same keyspace it counts in. Using
+     * `getState()` there deep-cloned the whole state — including `stepRange`,
+     * `affectedAgents` and `affectedTargets` of the last match — on the
+     * per-tool-call hot path, for one field.
+     */
+    getLadderCounts(): Map<string, number>;
     /**
      * Resets all escalation counts and flags to their default values.
      * Clears pattern counts and all flags.

package/dist/prm/index.d.ts

@@ -13,8 +13,8 @@
  * while PRM provides deeper multi-pattern detection and escalation.
  */
 export { formatCourseCorrectionForInjection, generateCourseCorrection, } from './course-correction';
-export { createDefaultEscalationState, EscalationTracker } from './escalation';
-export { detectContextThrash, detectExpansionDrift, detectPatterns, detectPingPong, detectRepetitionLoop, detectStuckOnTest, } from './pattern-detector';
+export { createDefaultEscalationState, EscalationTracker, resolveLadderKey, } from './escalation';
+export { detectContextThrash, detectExpansionDrift, detectPatterns, detectPingPong, detectRepetitionLoop, detectStuckOnTest, resolvePatternThreshold, } from './pattern-detector';
 export type { CourseCorrection, EscalationState, PatternDetectionResult, PatternMatch, PatternSeverity, PatternType, PrmConfig, TaxonomyCategory, TrajectoryEntry, } from './types';
 import type { LearningConfig } from '../config/schema.js';
 import { appendInsightCandidates } from '../hooks/micro-reflector.js';
@@ -78,6 +78,10 @@ interface ResettablePrmSessionState {
     prmHardStopInjectPending?: boolean;
     prmTrajectoryStep?: number;
     prmInjectedAdvisoryKeys?: Set<string>;
+    /** Issue #2134 — episode ledger; reset with the trajectory cursor it indexes. */
+    prmStruckEpisodes?: Map<string, number>;
+    /** Issue #2134 follow-up — ladder counts; reset with the ledger. */
+    prmLadderCounts?: Map<string, number>;
     replayArtifactPath?: string | null;
 }
 export declare function resetPrmSessionState(session: ResettablePrmSessionState, sessionId?: string): void;

package/dist/prm/pattern-detector.d.ts

@@ -2,7 +2,7 @@
  * PRM Pattern Detector
  * Rule-based pattern detection for trajectory analysis
  */
-import type { PatternDetectionResult, PatternMatch, PrmConfig, TrajectoryEntry } from './types';
+import type { PatternDetectionResult, PatternMatch, PatternType, PrmConfig, TrajectoryEntry } from './types';
 /**
  * Sanitize a string to prevent prompt injection attacks.
  * Removes newlines, carriage returns, backticks, and common injection patterns.
@@ -12,6 +12,27 @@ import type { PatternDetectionResult, PatternMatch, PrmConfig, TrajectoryEntry }
  * @returns Sanitized string safe for embedding in prompts
  */
 export declare function sanitizeString(input: string): string;
+/**
+ * Resolves the configured occurrence threshold for a pattern type, falling back
+ * to the built-in default.
+ *
+ * Exported for the escalation ladder (issue #2134): the ladder re-strikes a
+ * still-running episode once it has grown by another threshold's worth of
+ * occurrences, so it must resolve the threshold exactly the way the detectors do
+ * or the two layers disagree about what "another occurrence" means.
+ *
+ * The threshold is NOT in a single unit across detectors, and the ladder does not
+ * pretend otherwise — it is repeats for `repetition_loop`, run length for
+ * `context_thrash`, cycle count for `stuck_on_test`, alternating-entry count for
+ * `ping_pong` (whose `occurrenceCount` is ROUND TRIPS, i.e. half that unit, so it
+ * re-strikes at twice the nominal spacing), and a growth RATIO for
+ * `expansion_drift` (whose `occurrenceCount` is a float near 1.5–3.0, so the
+ * growth ground is effectively inert for it and its re-strikes come from the
+ * new-episode ground instead — its comparison window steps by `windowSize`, so
+ * its episode start step genuinely advances). Every one of the five is verified
+ * to still reach a hard stop; see `src/prm/__tests__/issue-2134-episode-gate.test.ts`.
+ */
+export declare function resolvePatternThreshold(config: PrmConfig, pattern: PatternType): number;
 /**
  * Detect repetition_loop pattern
  * Same agent targets same file with same action within N steps

package/dist/prm/types.d.ts

@@ -107,8 +107,18 @@ export interface PrmConfig {
  * Per-session escalation tracking state
  */
 export interface EscalationState {
-    /** Pattern type to detection count mapping */
-    patternCounts: Map<PatternType, number>;
+    /**
+     * Ladder identity to strike-count mapping.
+     *
+     * Keyed by `resolveLadderKey(match)` (issue #2134 follow-up), NOT by pattern
+     * type: `pattern|target` for a single-target pattern, bare `pattern` for one
+     * reporting a growing target set. Keying the ladder by pattern type alone let
+     * unrelated occurrences on different files accumulate into a hard stop.
+     *
+     * Distinct from `AgentSessionState.prmPatternCounts`, which stays keyed by
+     * pattern type as the observable per-pattern tally.
+     */
+    patternCounts: Map<string, number>;
     /** Current escalation level (0=none, 1=guidance, 2=strong guidance, 3=hard stop) */
     escalationLevel: number;
     /** Last pattern detected (if any) */

package/dist/sast/semgrep.d.ts

@@ -2,6 +2,7 @@
  * Semgrep Integration for Tier B SAST Enhancement
  * Provides optional Semgrep detection and invocation for advanced static analysis
  */
+import { resolveExecutableFromPath, runExternalTool } from '../utils/external-tool-runner';
 import type { SastFinding } from './rules/index.js';
 /**
  * Semgrep CLI options
@@ -19,6 +20,8 @@ export interface SemgrepOptions {
     lang?: string;
     /** When true, use --config auto instead of local rulesDir (for profile-driven languages) */
     useAutoConfig?: boolean;
+    /** Host/tool cancellation propagated to the shared subprocess runner. */
+    abortSignal?: AbortSignal;
 }
 /**
  * Result from Semgrep execution
@@ -33,6 +36,8 @@ export interface SemgrepResult {
     /** Engine label for the findings */
     engine: 'tier_a' | 'tier_a+tier_b';
 }
+declare function resolveSemgrepBinary(): string | null;
+declare function getAvailabilityProbeCwd(): string;
 export declare const _internals: {
     isSemgrepAvailable: typeof isSemgrepAvailable;
     checkSemgrepAvailable: typeof checkSemgrepAvailable;
@@ -40,48 +45,26 @@ export declare const _internals: {
     runSemgrep: typeof runSemgrep;
     getRulesDirectory: typeof getRulesDirectory;
     hasBundledRules: typeof hasBundledRules;
-    executeWithTimeout: typeof executeWithTimeout;
+    resolveExecutableFromPath: typeof resolveExecutableFromPath;
+    resolveSemgrepBinary: typeof resolveSemgrepBinary;
+    runExternalTool: typeof runExternalTool;
+    getAvailabilityProbeCwd: typeof getAvailabilityProbeCwd;
 };
 /**
- * Check if Semgrep CLI is available on the system
- * Uses caching to avoid shelling out on every check
- * @returns true if Semgrep is available, false otherwise
+ * Synchronous compatibility surface.
+ * Returns the last confirmed async availability result when cached; otherwise
+ * falls back to a pure PATH-resolution heuristic without spawning.
  */
 export declare function isSemgrepAvailable(): boolean;
 /**
- * Check if Semgrep is available (async version for consistency)
- * @returns Promise resolving to availability status
+ * Bounded async availability probe used by the live batch path.
+ * Caches only the result of the real shared-runner probe.
  */
-export declare function checkSemgrepAvailable(): Promise<boolean>;
+export declare function checkSemgrepAvailable(cwd?: string, abortSignal?: AbortSignal): Promise<boolean>;
 /**
  * Reset the Semgrep availability cache (useful for testing)
  */
 export declare function resetSemgrepCache(): void;
-/**
- * Execute a command with timeout
- * @param command - Command to execute
- * @param args - Command arguments (safe array, no shell injection)
- * @param options - Execution options including timeout
- * @returns Promise resolving to command output
- */
-declare function executeWithTimeout(command: string, args: string[], options: {
-    cwd?: string;
-    timeoutMs: number;
-    maxOutputBytes?: number;
-    /**
-     * Test-only hook invoked once with the spawned child's pid, immediately
-     * after `spawn()` returns. Lets tests assert the child is actually
-     * reaped (not just that a placeholder exit code was set) without
-     * mocking `node:child_process` (which would leak across test files —
-     * AGENTS.md invariant 7). No production caller passes this.
-     */
-    onSpawn?: (pid: number | undefined) => void;
-}): Promise<{
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-    truncated: boolean;
-}>;
 /**
  * Run Semgrep on specified files
  * @param options - Semgrep options

package/dist/services/compaction-service.d.ts

@@ -7,11 +7,13 @@
  *  - Reflection  (default 60%): re-summarise into tighter format
  *  - Emergency   (default 80%): hard truncation to system + current task + last N turns
  *
- * Consumes `swarmState.lastBudgetPct` (set by system-enhancer.ts after each budget calc).
+ * Consumes the per-session budget pct recorded by system-enhancer.ts after
+ * each budget calc (`getSessionBudgetPct`).
  * Never throws. Advisory system message injection via callback.
  */
 import type { CompactionConfig } from '../config/schema';
 export type { CompactionConfig };
+export declare const MAX_TRACKED_COMPACTION_SESSIONS = 500;
 export interface CompactionServiceHook {
     toolAfter: (input: {
         tool: string;

package/dist/session/snapshot-writer.d.ts

@@ -30,6 +30,7 @@ export interface SerializedAgentSession {
         tool: string;
         taskId: string;
         timestamp: number;
+        code?: string;
     } | null;
     partialGateWarningsIssuedForTask: string[];
     completionGateWarnedForTask: string[];

package/dist/state.d.ts

@@ -166,6 +166,7 @@ export interface AgentSessionState {
         tool: string;
         taskId: string;
         timestamp: number;
+        code?: string;
     } | null;
     /** Task IDs for which partial gate warning has already been issued (prevents per-task spam) */
     partialGateWarningsIssuedForTask: Set<string>;
@@ -413,6 +414,55 @@ export interface AgentSessionState {
      * fields, and this one is additive.
      */
     prmHardStopInjectPending?: boolean;
+    /**
+     * Issue #2134 — episode ledger for the escalation ladder.
+     *
+     * Maps an episode key (`patternType|startStep`) to the occurrence count that
+     * episode had when it last recorded a strike. A detector re-emits the SAME
+     * ongoing episode on every tool call with a growing `stepRange[1]` (a coder
+     * reading more files extends one `context_thrash` run), and the trajectory
+     * cursor cannot suppress that because the episode's end step always advances
+     * past it. Counting each re-emission as a fresh strike walked ONE ordinary
+     * episode from level 1 to level 3 in three tool calls and wedged healthy coder
+     * sessions behind a hard stop.
+     *
+     * A match strikes when its episode is new, or when that episode has gained
+     * another full threshold's worth of occurrences since it last struck. Both
+     * rungs are needed: three of the five detectors never advance an episode's
+     * start step while it runs, so without the growth rung they would strike
+     * exactly once and could never reach level 2 or 3. See the EPISODE GATE
+     * comment in `src/prm/index.ts` for the per-detector derivation.
+     *
+     * Optional for the same reason as `prmHardStopInjectPending`: ~25 existing
+     * test/session literals enumerate the required PRM fields, and this is additive.
+     */
+    prmStruckEpisodes?: Map<string, number>;
+    /**
+     * Issue #2134 follow-up — mirror of the escalation tracker's LADDER counts,
+     * keyed by `resolveLadderKey(match)` (`pattern|target`, or bare `pattern` for
+     * a pattern reporting a growing target set).
+     *
+     * Deliberately separate from `prmPatternCounts`, which stays keyed by pattern
+     * type as the observable per-pattern tally that telemetry and tests read. The
+     * two are different keyspaces and must not be conflated: the tracker-rebuild
+     * path below used to seed itself from `prmPatternCounts`, which would now
+     * hand pattern-type keys to a ladder that counts by target and silently
+     * mis-restore every count.
+     */
+    prmLadderCounts?: Map<string, number>;
+    /**
+     * Issue #2134 — dispatch identity of the delegation whose start already reset
+     * this session's PRM state. Holds the Task tool `callID`, which is unique per
+     * dispatch.
+     *
+     * The reset hook (`delegationGateHooks.taskMetadata`) is driven by
+     * `message.part.updated`, which fires repeatedly for the SAME Task part as the
+     * child runs. An unguarded reset there would clear the escalation ladder on
+     * every part update and disarm PRM permanently — a fail-open far worse than
+     * the wedge it is meant to prevent. Comparing against this field makes the
+     * reset exactly once per dispatch.
+     */
+    prmDelegationCallId?: string;
     /** Per-session escalation tracker instance (set lazily by PRM hook) */
     prmEscalationTracker?: EscalationTracker;
     /** Cross-turn set of already-injected PRM advisory dedupe keys
@@ -596,26 +646,44 @@ export declare const swarmState: {
      * matching). Populated by `src/index.ts` after `createAgents`.
      */
     generatedAgentNames: string[];
-    /** Last known context budget percentage (0-100), updated by system-enhancer */
-    lastBudgetPct: number;
     /**
-     * The DENOMINATOR `lastBudgetPct` was computed against, in tokens. Written
-     * by system-enhancer at the same two statements that write `lastBudgetPct`,
-     * because a percentage without its denominator cannot be turned back into a
-     * token estimate. `/swarm status` used to reconstruct the estimate from a
-     * hardcoded constant, so a user whose real denominator differed saw a token
-     * figure that did not match the percentage next to it. 0 means "no budget
-     * report has run yet".
+     * Last known context budget per session — keyed by sessionID.
+     *
+     * `pct` is the budget percentage (0-100); `tokens` is the DENOMINATOR it was
+     * computed against. They are stored together because a percentage without
+     * its denominator cannot be turned back into a token estimate, and
+     * `/swarm status` renders both — reading them from different sources would
+     * show a token figure that does not match the percentage beside it.
+     *
+     * Keyed rather than global (AGENTS.md invariant 8). These were two bare
+     * module-level scalars, which was harmless only while the budget check threw
+     * on every call and left them pinned at 0. Now that the check runs, a bare
+     * global leaks across sessions: a busy session reporting 85% would trip the
+     * default-on compaction service's emergency tier — and the `>= 50%` CONTEXT
+     * PRESSURE advisory — inside an unrelated small session. compaction-service
+     * keys its *hysteresis* per session, so the wrong session's state machine
+     * would advance on another session's number.
+     *
+     * Write via `setSessionBudget`, read via `getSessionBudgetPct` /
+     * `getSessionBudgetTokens`; `/swarm status` uses `getDisplayBudget`.
      */
-    lastBudgetTokens: number;
+    lastBudgetBySession: Map<string, {
+        pct: number;
+        tokens: number;
+    }>;
     /**
-     * Live `model.limit.context` per session — keyed by sessionID, recorded by
-     * the `experimental.chat.system.transform` hook (the only hook the host
+     * Live `model.limit.context` per session — keyed by sessionID and bound to
+     * the reporting model/provider identity. Recorded by the
+     * `experimental.chat.system.transform` hook (the only hook the host
      * gives a `Model` to) and read by the `experimental.chat.messages.transform`
      * consumers, which receive messages but no model object. Bounded via
      * {@link setLiveContextWindow} (AGENTS.md invariant 8).
      */
-    liveContextWindows: Map<string, number>;
+    liveContextWindows: Map<string, {
+        tokens?: number;
+        modelID?: string;
+        providerID?: string;
+    }>;
     /** Per-session guardrail state — keyed by sessionID */
     agentSessions: Map<string, AgentSessionState>;
     /** In-flight rehydration promises — awaited by rehydrateState before clearing agentSessions */
@@ -1157,13 +1225,15 @@ export declare function getResolvedAutoProceed(session: AgentSessionState, planA
 export declare function setSessionEnvironment(sessionId: string, profile: EnvironmentProfile): void;
 export declare function getSessionEnvironment(sessionId: string): EnvironmentProfile | undefined;
 export declare function ensureSessionEnvironment(sessionId: string): EnvironmentProfile;
+export declare const MAX_TRACKED_BUDGET_SESSIONS = 500;
 export declare const MAX_TRACKED_CRITICAL_SHOWN = 500;
 export declare const MAX_TRACKED_KNOWLEDGE_ACKS = 5000;
 export declare const MAX_TRACKED_GATE_DENIALS = 500;
 export declare const MAX_TRACKED_CONTEXT_WINDOWS = 500;
 /**
  * Record the live `model.limit.context` the host reported for `sessionID`,
- * FIFO-evicting the oldest entry past {@link MAX_TRACKED_CONTEXT_WINDOWS}.
+ * bound to the reporting model/provider identity and FIFO-evicting the oldest
+ * entry past {@link MAX_TRACKED_CONTEXT_WINDOWS}.
  *
  * Only accepts a finite number ≥ 1 — the caller (`src/config/context-window.ts`
  * `isUsableContextWindow`) applies the real plausibility floor, and storing a
@@ -1171,14 +1241,44 @@ export declare const MAX_TRACKED_CONTEXT_WINDOWS = 500;
  * rejected value leaves any previously recorded window in place rather than
  * clobbering it, so one malformed turn does not blank a good reading.
  */
-export declare function setLiveContextWindow(sessionID: string | undefined, tokens: unknown): void;
+export declare function setLiveContextWindow(sessionID: string | undefined, tokens: unknown, identity?: {
+    modelID?: string;
+    providerID?: string;
+}): void;
 /**
  * Read the live context window recorded for `sessionID`, or `undefined` when
- * no `system.transform` has run for it yet (first turn of a session, or a
- * consumer that never sees a sessionID). Callers must degrade to the static
- * resolution rungs rather than assume a value.
+ * no `system.transform` has run for it yet or the requested model/provider
+ * identity does not exactly match the reporter. Callers must degrade to the
+ * static resolution rungs rather than reuse a stale handoff denominator.
  */
-export declare function getLiveContextWindow(sessionID: string | undefined): number | undefined;
+export declare function getLiveContextWindow(sessionID: string | undefined, identity?: {
+    modelID?: string;
+    providerID?: string;
+}): number | undefined;
+export declare function getLiveContextModelIdentity(sessionID: string | undefined): {
+    modelID?: string;
+    providerID?: string;
+} | undefined;
+/** Record this session's budget percentage and the denominator it was computed
+ *  against, FIFO-evicting the oldest entry if the cap is exceeded. The two are
+ *  written together so `/swarm status` can never pair a pct from one report
+ *  with a denominator from another. */
+export declare function setSessionBudget(sessionID: string, pct: number, tokens: number): void;
+/** This session's last budget percentage, or 0 if it has not been measured.
+ *  Consumers that ACT on a session (compaction, the context-pressure advisory)
+ *  MUST use this rather than any cross-session aggregate. */
+export declare function getSessionBudgetPct(sessionID: string | undefined): number;
+/** The denominator this session's percentage was computed against, or 0. */
+export declare function getSessionBudgetTokens(sessionID: string | undefined): number;
+/** The most-pressured session's budget snapshot, for process-wide DISPLAY only
+ *  (`/swarm status` has no single session in scope). Returns the pct and its
+ *  OWN denominator as a pair, so the two figures shown side by side always come
+ *  from the same report. Null when nothing has been measured yet. Never use
+ *  this to decide whether to act on a particular session. */
+export declare function getDisplayBudget(): {
+    pct: number;
+    tokens: number;
+} | null;
 /** Set the critical shown ids for a session, FIFO-evicting the oldest entry
  * if the cap is exceeded. Re-setting an existing key keeps insertion order
  * fresh for that key (delete-then-set). */

package/dist/summaries/schema.d.ts

@@ -22,8 +22,8 @@ export declare const MAX_LIST_ITEMS = 5;
 /** Verdict vocabulary — mirrors the phase-council gate (APPROVE | CONCERNS | REJECT). */
 export declare const SupervisorVerdictSchema: z.ZodEnum<{
     APPROVE: "APPROVE";
-    CONCERNS: "CONCERNS";
     REJECT: "REJECT";
+    CONCERNS: "CONCERNS";
 }>;
 export type SupervisorVerdict = z.infer<typeof SupervisorVerdictSchema>;
 /** Count whitespace-delimited words in a string. */
@@ -130,8 +130,8 @@ export declare const ArchitectureSupervisorReportSchema: z.ZodObject<{
     phase: z.ZodNumber;
     verdict: z.ZodEnum<{
         APPROVE: "APPROVE";
-        CONCERNS: "CONCERNS";
         REJECT: "REJECT";
+        CONCERNS: "CONCERNS";
     }>;
     findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
         severity: z.ZodEnum<{

package/dist/tools/context-status.d.ts

@@ -83,7 +83,10 @@ export declare const _internals: {
  *   by the system.transform hook; `undefined` when none has been seen yet
  * @returns Context status with token usage, limit, and threshold state
  */
-declare function computeContextHeadroom(messages: ContextMessage[], warnThreshold?: number, criticalThreshold?: number, modelLimitsConfig?: Record<string, number>, liveContextLimit?: unknown): ContextStatusResult;
+declare function computeContextHeadroom(messages: ContextMessage[], warnThreshold?: number, criticalThreshold?: number, modelLimitsConfig?: Record<string, number>, liveContextLimit?: unknown, modelIdentity?: {
+    modelID?: string;
+    providerID?: string;
+}): ContextStatusResult;
 /**
  * context_status tool — read-only context window headroom report.
  *

package/dist/tools/convene-council.d.ts

@@ -15,8 +15,8 @@ export declare const ArgsSchema: z.ZodObject<{
         }>;
         verdict: z.ZodEnum<{
             APPROVE: "APPROVE";
-            CONCERNS: "CONCERNS";
             REJECT: "REJECT";
+            CONCERNS: "CONCERNS";
         }>;
         confidence: z.ZodNumber;
         findings: z.ZodArray<z.ZodObject<{

package/dist/tools/lint.d.ts

@@ -1,8 +1,19 @@
+import * as fs from 'node:fs';
 import type { tool } from '@opencode-ai/plugin';
+import { isCommandAvailable } from '../build/discovery';
+import { type ExternalToolRunOptions, type ExternalToolRunResult } from '../utils/external-tool-runner';
 export declare const MAX_OUTPUT_BYTES = 512000;
 export declare const MAX_COMMAND_LENGTH = 500;
 export declare const SUPPORTED_LINTERS: readonly ["biome", "eslint"];
 export type SupportedLinter = (typeof SUPPORTED_LINTERS)[number];
+type ResolvedLinterSource = 'local-native' | 'local-shim' | 'safe-package-bin' | 'path-native' | 'path-shim' | 'legacy-test-probe';
+export interface ResolvedLinterCommand {
+    linter: SupportedLinter;
+    executable: string;
+    argsPrefix: string[];
+    displayPrefix: string[];
+    source: ResolvedLinterSource;
+}
 export type AdditionalLinter = 'ruff' | 'clippy' | 'golangci-lint' | 'checkstyle' | 'ktlint' | 'dotnet-format' | 'cppcheck' | 'swiftlint' | 'dart-analyze' | 'rubocop' | 'phpstan' | 'pint' | 'php-cs-fixer' | 'phpcs';
 export interface LintSuccessResult {
     success: true;
@@ -28,46 +39,61 @@ export { containsControlChars, containsPathTraversal, } from '../utils/path-secu
 export declare function validateArgs(args: unknown): args is {
     mode: 'fix' | 'check';
 };
+export declare function getBiomeBinPath(directory: string): string;
+export declare function getEslintBinPath(directory: string): string;
 export declare function getLinterCommand(linter: SupportedLinter, mode: 'fix' | 'check', projectDir: string): string[];
-/**
- * Build the shell command for an additional (non-JS/TS) linter.
- * cppcheck has no --fix mode; csharp and some others behave differently.
- */
-export declare function getAdditionalLinterCommand(linter: AdditionalLinter, mode: 'fix' | 'check', cwd: string): string[];
+export declare function resolveLinterBinPath(linter: SupportedLinter, projectDir: string): string;
+export declare function resolveLinterCommand(linter: SupportedLinter, directory: string): Promise<ResolvedLinterCommand | null>;
+export declare function detectResolvedLinter(directory?: string, abortSignal?: AbortSignal): Promise<ResolvedLinterCommand | null>;
 /**
  * Detect the first available additional (non-JS/TS) linter for the current project.
  * Returns null when no additional linter is detected or its binary is unavailable.
  */
 export declare function detectAdditionalLinter(cwd: string): 'ruff' | 'clippy' | 'golangci-lint' | 'checkstyle' | 'ktlint' | 'dotnet-format' | 'cppcheck' | 'swiftlint' | 'dart-analyze' | 'rubocop' | 'phpstan' | 'pint' | 'php-cs-fixer' | 'phpcs' | null;
-/** Compute the local biome binary path for a given project directory. */
-export declare function getBiomeBinPath(directory: string): string;
-/**
- * Resolve the binary path for a linter, using the same hierarchy as detectAvailableLinter:
- * 1. Local node_modules/.bin
- * 2. Ancestor node_modules/.bin (monorepo)
- * 3. process.env.PATH scan
- * 4. Local path as fallback (may not exist)
- */
-export declare function resolveLinterBinPath(linter: SupportedLinter, projectDir: string): string;
-/** Compute the local eslint binary path for a given project directory. */
-export declare function getEslintBinPath(directory: string): string;
 export declare function detectAvailableLinter(directory?: string): Promise<SupportedLinter | null>;
 /** Internal implementation — accepts pre-computed binary paths for testability. */
-export declare function _detectAvailableLinter(_projectDir: string, biomeBin: string, eslintBin: string): Promise<SupportedLinter | null>;
-export declare function runLint(linter: SupportedLinter, mode: 'fix' | 'check', directory: string): Promise<LintResult>;
+export declare function _detectAvailableLinter(projectDir: string, biomeBin: string, eslintBin: string): Promise<SupportedLinter | null>;
+declare function runResolvedLint(command: ResolvedLinterCommand, mode: 'fix' | 'check', directory: string, abortSignal?: AbortSignal): Promise<LintResult>;
+/**
+ * Build the shell command for an additional (non-JS/TS) linter.
+ * cppcheck has no --fix mode; csharp and some others behave differently.
+ */
+export declare function getAdditionalLinterCommand(linter: AdditionalLinter, mode: 'fix' | 'check', cwd: string): string[] | null;
+export declare function runLint(linter: SupportedLinter, mode: 'fix' | 'check', directory: string, abortSignal?: AbortSignal): Promise<LintResult>;
 /**
  * Run an additional (non-JS/TS) linter.
  * Follows the same structure as runLint() but uses getAdditionalLinterCommand().
  */
-export declare function runAdditionalLint(linter: AdditionalLinter, mode: 'fix' | 'check', cwd: string): Promise<LintResult>;
+export declare function runAdditionalLint(linter: AdditionalLinter, mode: 'fix' | 'check', cwd: string, abortSignal?: AbortSignal): Promise<LintResult>;
 export declare const lint: ReturnType<typeof tool>;
 /**
  * DI seam for testability. Contains all test-mocked exports.
  * Internal calls should use _internals.fn() instead of fn() directly.
  */
 export declare const _internals: {
-    detectAvailableLinter: typeof detectAvailableLinter;
-    runLint: typeof runLint;
+    MAX_PACKAGE_MANIFEST_BYTES: number;
+    MAX_PATH_SHIM_BYTES: number;
+    arch: () => string;
+    closeSync: typeof fs.closeSync;
+    comSpec: () => string | undefined;
     detectAdditionalLinter: typeof detectAdditionalLinter;
+    detectAvailableLinter: typeof detectAvailableLinter;
+    detectResolvedLinter: typeof detectResolvedLinter;
+    execPath: () => string;
+    existsSync: typeof fs.existsSync;
+    fstatSync: typeof fs.fstatSync;
+    isCommandAvailable: typeof isCommandAvailable;
+    openSync: typeof fs.openSync;
+    pathEnv: () => string;
+    platform: () => NodeJS.Platform;
+    readFileSync: typeof fs.readFileSync;
+    readSync: typeof fs.readSync;
+    readdirSync: typeof fs.readdirSync;
+    realpathSync: typeof fs.realpathSync;
+    resolveLinterCommand: typeof resolveLinterCommand;
     runAdditionalLint: typeof runAdditionalLint;
+    runExternalTool: (options: ExternalToolRunOptions) => Promise<ExternalToolRunResult>;
+    runLint: typeof runLint;
+    runResolvedLint: typeof runResolvedLint;
+    statSync: typeof fs.statSync;
 };