@voybio/ace-swarm 2.4.0 → 2.4.1

package/dist/astgrep-index.js

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { isAbsolute, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { appendStatusEventSafe } from "./status-events.js";
@@ -14,6 +15,130 @@ export function runAstgrepQuery(pattern, lang, roots, _contextLines) {
         context_lines: [],
     }));
 }
+function hashTextContent(content) {
+    return `sha256:${createHash("sha256").update(content, "utf8").digest("hex")}`;
+}
+function textPreview(text, maxChars = 160) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxChars)
+        return normalized;
+    return `${normalized.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
+function nodeKindForMatch(match) {
+    if (typeof match.nodeKind === "string" && match.nodeKind.length > 0)
+        return match.nodeKind;
+    if (typeof match.kind === "string" && match.kind.length > 0)
+        return match.kind;
+    return undefined;
+}
+function captureMapForMatch(match) {
+    if (!match.metaVariables)
+        return undefined;
+    const captures = Object.entries(match.metaVariables).reduce((acc, [key]) => {
+        const text = extractMetaVarText(match, key);
+        if (typeof text === "string" && text.length > 0)
+            acc[key] = text;
+        return acc;
+    }, {});
+    return Object.keys(captures).length > 0 ? captures : undefined;
+}
+function computeMatchId(input) {
+    const encoded = [
+        input.file,
+        input.range.start?.line ?? 0,
+        input.range.start?.column ?? 0,
+        input.range.end?.line ?? 0,
+        input.range.end?.column ?? 0,
+        input.file_hash,
+        input.pattern,
+        input.lang,
+        input.matched_text,
+    ].join("|");
+    return `match_${createHash("sha256").update(encoded, "utf8").digest("hex").slice(0, 16)}`;
+}
+function matchUsesSymbolHint(match, symbolHint) {
+    if ((match.text ?? "").includes(symbolHint))
+        return true;
+    if (!match.metaVariables)
+        return false;
+    return Object.keys(match.metaVariables).some((key) => {
+        const text = extractMetaVarText(match, key);
+        return typeof text === "string" && text.includes(symbolHint);
+    });
+}
+export function locateAstgrepMatches(input) {
+    const scope = resolveScope(input.scope ?? "src");
+    const astgrepCmd = detectAstgrepCommand();
+    if (!astgrepCmd) {
+        return {
+            ok: false,
+            pattern: input.pattern,
+            lang: input.lang,
+            scope: scope.rel,
+            symbol_hint: input.symbol_hint,
+            astgrep_command: null,
+            total_matches: 0,
+            matches: [],
+            error: "ast-grep command not available",
+        };
+    }
+    const rawMatches = runAstgrep(astgrepCmd, input.pattern, input.lang, [scope.abs]);
+    const effectiveMatches = input.symbol_hint && input.symbol_hint.trim().length > 0
+        ? (() => {
+            const hinted = rawMatches.filter((match) => matchUsesSymbolHint(match, input.symbol_hint));
+            return hinted.length > 0 ? hinted : rawMatches;
+        })()
+        : rawMatches;
+    const limit = input.max_results ?? 50;
+    const matches = effectiveMatches.slice(0, limit).flatMap((match) => {
+        const absFile = typeof match.file === "string" && match.file.length > 0
+            ? (isAbsolute(match.file) ? match.file : resolve(WORKSPACE_ROOT, match.file))
+            : undefined;
+        if (!absFile || !isInside(WORKSPACE_ROOT, absFile) || !match.range)
+            return [];
+        const matchedText = match.text ?? "";
+        const fileContent = safeReadText(absFile);
+        const fileHash = hashTextContent(fileContent);
+        const file = normalizeHitPath(relative(WORKSPACE_ROOT, absFile));
+        const range = {
+            start: {
+                line: match.range.start?.line ?? 0,
+                column: match.range.start?.column ?? 0,
+            },
+            end: {
+                line: match.range.end?.line ?? 0,
+                column: match.range.end?.column ?? 0,
+            },
+        };
+        return [{
+                match_id: computeMatchId({
+                    file,
+                    range,
+                    matched_text: matchedText,
+                    file_hash: fileHash,
+                    pattern: input.pattern,
+                    lang: input.lang,
+                }),
+                file,
+                range,
+                text_preview: textPreview(matchedText),
+                matched_text: matchedText,
+                captures: captureMapForMatch(match),
+                node_kind: nodeKindForMatch(match),
+                file_hash: fileHash,
+            }];
+    });
+    return {
+        ok: true,
+        pattern: input.pattern,
+        lang: input.lang,
+        scope: scope.rel,
+        symbol_hint: input.symbol_hint,
+        astgrep_command: astgrepCmd,
+        total_matches: effectiveMatches.length,
+        matches,
+    };
+}
 const CODE_EXTENSIONS = new Set(["ts", "tsx", "js", "mjs", "cjs", "py", "rs", "go"]);
 const EXCLUDE_DIRS = new Set([
     ".git",
@@ -39,7 +164,7 @@ function resolveScope(scope) {
     }
     return { abs, rel: rel || "." };
 }
-function detectAstgrepCommand() {
+export function detectAstgrepCommand() {
     for (const cmd of ["ast-grep", "sg"]) {
         const probe = spawnSync(cmd, ["--version"], { encoding: "utf8" });
         if (probe.status === 0)

package/dist/cli.js

@@ -4,7 +4,7 @@ import { refreshAstgrepIndex } from "./astgrep-index.js";
 import { scanWorkspaceDelta } from "./index-store.js";
 import { startStdioServer } from "./server.js";
 import { appendRunLedgerEntrySafe } from "./run-ledger.js";
-import { waitForPendingStatusEventMirrors } from "./status-events.js";
+import { appendStatusEventSafe, waitForPendingStatusEventMirrors } from "./status-events.js";
 import { bootstrapStoreWorkspace } from "./store/bootstrap-store.js";
 import { HostFileMaterializer } from "./store/materializers/host-file-materializer.js";
 import { openStore } from "./store/ace-packed-store.js";
@@ -14,8 +14,9 @@ import { getWorkspaceStorePath, readStoreBlobSync, readStoreJsonSync, } from "./
 import { ensureCanonicalWorkspaceStore } from "./store/workspace-store-paths.js";
 import { readFileSync } from "node:fs";
 import { runTui } from "./tui/index.js";
-import { buildOpenAiCompatibleBaseUrl, buildProviderDoctorCommands, defaultModelForProvider, discoverProviderContext, isLocalLlmProvider, normalizeLocalBaseUrl, normalizeProvider, scanLocalModelRuntimes, } from "./tui/provider-discovery.js";
+import { buildOpenAiCompatibleBaseUrl, buildProviderDoctorCommands, defaultModelForProvider, discoverProviderContext, isLocalLlmProvider, normalizeLocalBaseUrl, normalizeLlamaCppHfModelName, normalizeProvider, scanLocalModelRuntimes, } from "./tui/provider-discovery.js";
 import { diagnoseChatRuntimeConfig, OpenAICompatibleClient, } from "./tui/openai-compatible.js";
+import { runShellCommand } from "./runtime-command.js";
 function printHelp() {
     console.log(`ACE Swarm CLI
 
@@ -24,6 +25,7 @@ Usage:
   ace serve                    Alias for mcp
   ace tui [options]            Launch interactive TUI dashboard
   ace init [options]           Bootstrap the ACE store into current workspace
+  ace connect [provider]       Register a live local runtime or hosted provider in the store
   ace turnkey [options]        Project minimal workspace bootstrap stubs from the ACE store
   ace doctor [options]         Validate ACE runtime + MCP readiness
   ace cache [options]          Cache ACE artifacts into ace-state.ace and optionally clean projections
@@ -48,12 +50,20 @@ Options for init:
   --base-url <url>             Runtime base URL override (local or OpenAI-compatible)
   --ollama-url <url>           Legacy alias for --base-url
 
+Options for connect:
+  llama-server|llama-cli       Optional launcher name for llama.cpp HF runtimes
+  --hf <repo>                  Hugging Face model repo or local model identifier
+  --model <name>               Alias for --hf when you already know the model name
+  --base-url <url>             OpenAI-compatible endpoint for the live runtime
+  --provider <name>            Explicit provider override when not using a launcher alias
+
 Options for doctor:
   --llm <provider>             ollama|llama.cpp|codex|claude|gemini|copilot|... (default: auto from agent-state/ace-state.ace)
   --model <name>               Model name override
   --base-url <url>             Runtime base URL override
   --ollama-url <url>           Legacy alias for --base-url
   --scan                       Probe common local Ollama + llama.cpp endpoints when URL is unset
+  --repair-ollama              Opt-in: run ollama pull <model> when doctor finds a missing Ollama model
 
 Options for cache:
   --dry-run                    Preview what would be cached and cleaned (no writes/deletes)
@@ -98,6 +108,29 @@ function readLlmProfile() {
 function readBaseUrlFlag(args) {
     return normalizeLocalBaseUrl(readFlagValue(args, "--base-url") ?? readFlagValue(args, "--ollama-url"));
 }
+function readConnectModelFlag(args) {
+    return (readFlagValue(args, "--hf") ??
+        readFlagValue(args, "-hf") ??
+        readFlagValue(args, "--model"))?.trim();
+}
+function parseConnectArgs(args) {
+    const firstToken = args[0];
+    const hasLauncher = Boolean(firstToken && !firstToken.startsWith("-"));
+    const launcher = hasLauncher ? firstToken?.trim().toLowerCase() : undefined;
+    const providerOverride = normalizeProvider(readFlagValue(args, "--provider")?.trim());
+    const provider = providerOverride ??
+        (launcher === "llama-server" || launcher === "llama-cli" ? "llama.cpp" : providerOverride);
+    const rawModel = readConnectModelFlag(args);
+    const model = provider === "llama.cpp" ? normalizeLlamaCppHfModelName(rawModel) ?? rawModel : rawModel;
+    const baseUrl = readBaseUrlFlag(args);
+    const launcherCommand = hasLauncher ? args.join(" ").trim() : undefined;
+    return {
+        provider: provider,
+        model,
+        baseUrl,
+        launcherCommand,
+    };
+}
 function parseLlmOptions(args) {
     const profile = readLlmProfile();
     const selected = normalizeProvider(readFlagValue(args, "--llm")?.trim() ?? profile?.provider?.trim());
@@ -107,8 +140,11 @@ function parseLlmOptions(args) {
         throw new Error(`Unsupported LLM provider: ${selected}`);
     }
     const provider = selected;
-    const defaultModel = defaultModelForProvider(provider);
-    const llmModel = readFlagValue(args, "--model")?.trim() || profile?.model || defaultModel;
+    const explicitModel = readFlagValue(args, "--model")?.trim();
+    const profileModel = profile?.model?.trim();
+    const llmModel = explicitModel ||
+        profileModel ||
+        (provider === "ollama" ? defaultModelForProvider(provider) : undefined);
     const llmBaseUrl = readBaseUrlFlag(args) ?? normalizeLocalBaseUrl(profile?.base_url);
     return {
         llmProvider: provider,
@@ -121,9 +157,11 @@ async function writeLlmProfile(profile) {
     await withStoreWriteCoordinator(storePath, async () => {
         const payload = {
             provider: profile.provider,
-            model: profile.model,
             generated_at: new Date().toISOString(),
         };
+        if (profile.model) {
+            payload.model = profile.model;
+        }
         if (profile.baseUrl) {
             payload.base_url = profile.baseUrl;
             if (profile.provider === "ollama") {
@@ -131,6 +169,9 @@ async function writeLlmProfile(profile) {
                 payload.default_api_key = "ollama";
             }
         }
+        if (profile.launcherCommand) {
+            payload.launch_command = profile.launcherCommand;
+        }
         const doctorCommands = buildProviderDoctorCommands(profile.provider, profile.model, profile.baseUrl);
         const store = await openStore(storePath);
         try {
@@ -153,6 +194,40 @@ async function writeLlmProfile(profile) {
     }, { operation_label: "writeLlmProfile" });
     return `${storePath}#state/runtime/llm_profile`;
 }
+async function runConnect(args) {
+    const parsed = parseConnectArgs(args);
+    if (!parsed.provider) {
+        throw new Error("ace connect expects a provider or launcher command. Try `ace connect llama-server -hf <model> --base-url http://127.0.0.1:8080`.");
+    }
+    if (!ALL_LLM_PROVIDERS.includes(parsed.provider)) {
+        throw new Error(`Unsupported LLM provider: ${parsed.provider}`);
+    }
+    if (isLocalLlmProvider(parsed.provider) && !parsed.model) {
+        throw new Error("ace connect for local runtimes requires an explicit model. Pass `--hf <repo>` or `--model <name>`.");
+    }
+    const storeResult = await bootstrapStoreWorkspace({
+        workspaceRoot: WORKSPACE_ROOT,
+        llm: parsed.provider,
+        model: parsed.model,
+        baseUrl: parsed.baseUrl,
+        includeMcpConfig: false,
+        includeClientConfigBundle: false,
+        launcherCommand: parsed.launcherCommand,
+    });
+    console.log("ACE connect complete");
+    console.log(`Workspace: ${WORKSPACE_ROOT}`);
+    console.log(`Store: ${storeResult.storePath}`);
+    console.log(`Provider: ${parsed.provider}`);
+    console.log(`Model: ${parsed.model ?? "(not set)"}`);
+    console.log(`Base URL: ${parsed.baseUrl ?? "(not set)"}`);
+    if (parsed.launcherCommand) {
+        console.log(`Launcher: ${parsed.launcherCommand}`);
+    }
+    console.log(`Profile path: ${storeResult.storePath}#state/runtime/llm_profile`);
+    for (const warning of storeResult.warnings) {
+        console.warn(`  [store] ${warning}`);
+    }
+}
 async function recordDiscoveryProfile(input) {
     const storePath = getWorkspaceStorePath(WORKSPACE_ROOT);
     await withStoreWriteCoordinator(storePath, async () => {
@@ -296,6 +371,13 @@ async function listLocalRuntimeModels(provider, baseUrl) {
             headers: { Accept: "application/json" },
         });
         if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            if (response.status >= 500 && /unable to load model/i.test(text)) {
+                const error = new Error(`${response.status} ${response.statusText}: ollama_model_load_error. ` +
+                    `Suggested remediation: run ollama pull <model> or ace doctor --repair-ollama.`);
+                error.reason_code = "ollama_model_load_error";
+                throw error;
+            }
             throw new Error(`${response.status} ${response.statusText}`);
         }
         const payload = (await response.json().catch(() => ({})));
@@ -321,6 +403,7 @@ async function listLocalRuntimeModels(provider, baseUrl) {
 }
 async function runDoctor(args) {
     const llm = parseLlmOptions(args);
+    const repairOllama = args.includes("--repair-ollama");
     const checks = [];
     const mcpConfigPaths = [wsPath(".vscode", "mcp.json")];
     const hasWorkspaceMcpConfig = mcpConfigPaths.some((path) => fileExists(path));
@@ -347,7 +430,9 @@ async function runDoctor(args) {
     let provider = llm.llmProvider;
     let model = llm.llmModel;
     let baseUrl = llm.llmBaseUrl;
-    const shouldScan = args.includes("--scan") || (!provider && !baseUrl) || (isLocalLlmProvider(provider) && !baseUrl);
+    const shouldScan = args.includes("--scan") ||
+        (!provider && !baseUrl) ||
+        (isLocalLlmProvider(provider) && (!baseUrl || !model));
     if (shouldScan) {
         const scanned = await scanLocalModelRuntimes({
             workspaceRoot: WORKSPACE_ROOT,
@@ -359,7 +444,7 @@ async function runDoctor(args) {
         if (chosen) {
             provider = chosen.provider ?? provider;
             baseUrl = baseUrl ?? chosen.baseUrl;
-            model = model || chosen.models[0] || defaultModelForProvider(provider);
+            model = model || chosen.models[0];
             checks.push({
                 name: "Runtime endpoint discovered",
                 ok: true,
@@ -367,7 +452,7 @@ async function runDoctor(args) {
             });
             const writtenProfilePath = await writeLlmProfile({
                 provider: provider ?? chosen.provider,
-                model: model ?? defaultModelForProvider(provider ?? chosen.provider),
+                model,
                 baseUrl,
             });
             checks.push({
@@ -388,6 +473,30 @@ async function runDoctor(args) {
         throw new Error(`No runtime provider configured. Use --llm <provider>, bootstrap one into agent-state/ace-state.ace#state/runtime/llm_profile, or run \`ace doctor --scan\` for a local runtime.`);
     }
     if (!model) {
+        if (isLocalLlmProvider(provider)) {
+            checks.push({
+                name: "Runtime model configured",
+                ok: false,
+                detail: "No local runtime model is configured yet. Run `ace connect` with a user-supplied HF model or run `ace doctor --scan` after the runtime is up.",
+            });
+            const failed = checks.filter((check) => !check.ok);
+            console.log("ACE Doctor Report");
+            console.log(`Workspace: ${WORKSPACE_ROOT}`);
+            console.log(`Provider: ${provider}`);
+            console.log("Model: (not set)");
+            if (baseUrl) {
+                console.log(`Base URL: ${baseUrl}`);
+            }
+            console.log("");
+            for (const check of checks) {
+                const status = check.ok ? "PASS" : "FAIL";
+                console.log(`- [${status}] ${check.name}: ${check.detail}`);
+            }
+            if (failed.length > 0) {
+                process.exitCode = 1;
+            }
+            return;
+        }
         model = defaultModelForProvider(provider);
     }
     if (isLocalLlmProvider(provider) && !baseUrl) {
@@ -425,6 +534,23 @@ async function runDoctor(args) {
             });
         }
         catch (error) {
+            const reasonCode = typeof error === "object" && error !== null && "reason_code" in error
+                ? String(error.reason_code)
+                : undefined;
+            if (reasonCode === "ollama_model_load_error") {
+                await appendStatusEventSafe({
+                    source_module: "capability-ops",
+                    event_type: "OLLAMA_MODEL_LOAD_ERROR",
+                    status: "blocked",
+                    summary: `Ollama model-load error for ${model}: ${error instanceof Error ? error.message : String(error)}`,
+                    objective_id: "ollama-doctor",
+                    payload: {
+                        reason_code: "ollama_model_load_error",
+                        model,
+                        base_url: baseUrl,
+                    },
+                }).catch(() => undefined);
+            }
             checks.push({
                 name: "Runtime endpoint reachable",
                 ok: false,
@@ -450,6 +576,44 @@ async function runDoctor(args) {
                     ? `${model} found`
                     : `${model} not reported by llama.cpp (available: ${modelNames.join(", ") || "none"})`,
         });
+        if (provider === "ollama" && !hasModel && repairOllama) {
+            const repair = await runShellCommand(`ollama pull ${model}`, {
+                cwd: WORKSPACE_ROOT,
+                timeout_ms: 10 * 60_000,
+            });
+            await appendRunLedgerEntrySafe({
+                tool: "doctor",
+                category: repair.exit_code === 0 ? "info" : "regression",
+                message: `Opt-in Ollama repair attempted for ${model}`,
+                artifacts: [],
+                metadata: {
+                    reason_code: "ollama_model_load_error",
+                    model,
+                    exit_code: repair.exit_code,
+                    timed_out: repair.timed_out,
+                },
+            }).catch(() => undefined);
+            await appendStatusEventSafe({
+                source_module: "capability-ops",
+                event_type: "OLLAMA_REPAIR_ATTEMPTED",
+                status: repair.exit_code === 0 ? "done" : "fail",
+                summary: `Opt-in Ollama repair attempted for ${model}`,
+                objective_id: "ollama-doctor",
+                payload: {
+                    reason_code: "ollama_model_load_error",
+                    model,
+                    exit_code: repair.exit_code,
+                    timed_out: repair.timed_out,
+                },
+            }).catch(() => undefined);
+            checks.push({
+                name: "Ollama model repair attempted",
+                ok: repair.exit_code === 0,
+                detail: repair.exit_code === 0
+                    ? `ollama pull ${model} completed`
+                    : `ollama pull ${model} failed with exit ${repair.exit_code}: ${repair.stderr || repair.stdout || "no output"}`,
+            });
+        }
     }
     else {
         const diagnosis = diagnoseChatRuntimeConfig(provider, model, baseUrl ? { baseUrl } : undefined);
@@ -588,14 +752,36 @@ async function main() {
             cliModel,
             cliBaseUrl,
         });
+        const needsLocalScan = isLocalLlmProvider(discovered.provider) &&
+            (!discovered.baseUrl || !discovered.model || discovered.model === defaultModelForProvider(discovered.provider));
+        const runtime = needsLocalScan
+            ? await scanLocalModelRuntimes({
+                workspaceRoot: WORKSPACE_ROOT,
+                preferredProvider: discovered.provider,
+                explicitBaseUrl: discovered.baseUrl,
+            })
+            : undefined;
+        const scanned = runtime?.candidates.find((candidate) => candidate.provider === discovered.provider) ??
+            runtime?.candidates[0];
+        const resolvedTui = scanned?.models[0]
+            ? {
+                ...discovered,
+                model: scanned.models[0],
+                baseUrl: discovered.baseUrl ?? scanned.baseUrl,
+                providerBaseUrls: {
+                    ...discovered.providerBaseUrls,
+                    [scanned.provider]: discovered.baseUrl ?? scanned.baseUrl,
+                },
+            }
+            : discovered;
         await runTui({
-            provider: discovered.provider,
-            model: discovered.model,
-            providers: discovered.providers,
-            modelsByProvider: discovered.modelsByProvider,
-            baseUrl: discovered.baseUrl,
-            ollamaUrl: discovered.ollamaUrl,
-            providerBaseUrls: discovered.providerBaseUrls,
+            provider: resolvedTui.provider,
+            model: resolvedTui.model,
+            providers: resolvedTui.providers,
+            modelsByProvider: resolvedTui.modelsByProvider,
+            baseUrl: resolvedTui.baseUrl,
+            ollamaUrl: resolvedTui.ollamaUrl,
+            providerBaseUrls: resolvedTui.providerBaseUrls,
             workspaceRoot: WORKSPACE_ROOT,
         });
         return;
@@ -604,6 +790,10 @@ async function main() {
         await runInit(args.slice(1), "init");
         return;
     }
+    if (command === "connect") {
+        await runConnect(args.slice(1));
+        return;
+    }
     if (command === "turnkey") {
         await runInit(args.slice(1), "turnkey");
         return;

package/dist/discovery-runtime-wrappers.d.ts

@@ -0,0 +1,108 @@
+import { type RunShellCommandOptions, type ShellCommandResult } from "./runtime-command.js";
+import { persistRuntimeToolInvocationArtifacts, type RuntimeToolExecutionContext, type RuntimeToolExecutionResult, type RuntimeToolSpecRegistryResult } from "./runtime-tool-specs.js";
+import { type RefreshAstgrepIndexResult } from "./astgrep-index.js";
+export interface WebResearchPacketInput extends RuntimeToolExecutionContext {
+    query: string;
+    sources_required: number;
+    fetch_urls?: string[];
+}
+export interface WebResearchCitation {
+    title: string;
+    url: string;
+    snippet?: string;
+    fetched_path?: string;
+}
+export interface WebResearchPacketResult {
+    ok: boolean;
+    summary: string;
+    tool_name: string;
+    packet_path?: string;
+    search_results_path?: string;
+    fetched_paths?: string[];
+    request_path?: string;
+    response_path?: string;
+    citations?: WebResearchCitation[];
+    error?: string;
+}
+export interface CodemunchSnapshotInput extends RuntimeToolExecutionContext {
+    repo_url: string;
+    branch?: string;
+    max_bytes?: number;
+}
+export interface CodemunchSnapshotResult {
+    ok: boolean;
+    summary: string;
+    mode: "runtime_tool" | "external_cli";
+    snapshot_path?: string;
+    checksum?: string;
+    provenance_path?: string;
+    request_path?: string;
+    response_path?: string;
+    error?: string;
+}
+export interface CodemunchIndexInput {
+    cxml_path: string;
+    append_evidence?: boolean;
+    emit_event?: boolean;
+}
+export interface CodemunchIndexResult {
+    ok: boolean;
+    summary: string;
+    source_cxml_path?: string;
+    checksum?: string;
+    rep_corpus_path?: string;
+    structural_summary_json_path?: string;
+    structural_summary_md_path?: string;
+    provenance_path?: string;
+    routing_hints?: string[];
+    error?: string;
+}
+export interface McpIngestionProbeInput {
+    name: string;
+    transport: "stdio" | "http";
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+    declared_tools?: Array<{
+        name: string;
+        description?: string;
+        input_schema?: unknown;
+    }>;
+}
+export interface McpIngestionProbeResult {
+    ok: boolean;
+    summary: string;
+    server_name: string;
+    transport: "stdio" | "http";
+    health: "configured" | "blocked";
+    tools: Array<{
+        name: string;
+        description?: string;
+        input_schema?: unknown;
+    }>;
+    request_path?: string;
+    response_path?: string;
+    error?: string;
+    reason_code?: string;
+}
+interface WrapperDeps {
+    executeRuntimeTool: (name: string, input: unknown, context?: RuntimeToolExecutionContext) => Promise<RuntimeToolExecutionResult>;
+    loadRuntimeToolRegistry: (explicitPath?: string) => RuntimeToolSpecRegistryResult;
+    persistRuntimeToolInvocationArtifacts: typeof persistRuntimeToolInvocationArtifacts;
+    runShellCommand: (command: string, options: RunShellCommandOptions) => Promise<ShellCommandResult>;
+    refreshAstgrepIndex: (input?: {
+        scope?: string;
+        append_evidence?: boolean;
+        emit_event?: boolean;
+        include_rep_corpus?: boolean;
+    }) => Promise<RefreshAstgrepIndexResult>;
+    now: () => Date;
+    randomId: () => string;
+}
+export declare function createWebResearchPacket(input: WebResearchPacketInput, deps?: Partial<WrapperDeps>): Promise<WebResearchPacketResult>;
+export declare function createCodemunchSnapshot(input: CodemunchSnapshotInput, deps?: Partial<WrapperDeps>): Promise<CodemunchSnapshotResult>;
+export declare function createMcpIngestionProbe(input: McpIngestionProbeInput, deps?: Partial<WrapperDeps>): Promise<McpIngestionProbeResult>;
+export declare function createCodemunchIndex(input: CodemunchIndexInput, deps?: Partial<WrapperDeps>): Promise<CodemunchIndexResult>;
+export {};
+//# sourceMappingURL=discovery-runtime-wrappers.d.ts.map