@loucompanion/forge-bridge 0.1.3-dev.ba7d36726eda → 0.1.3-dev.bca7d0ccee53

package/dist/session/phase-completion.artifacts.js

@@ -237,12 +237,19 @@ export async function writeQaGateCompletionArtifact(config, gate, input) {
     const status = normalizeQaGateStatus(requiredString(payload, "status"));
     validateQaGatePayloadShape(gate, payload, status);
     validateOptionalWorkItemId(payload, config.workItemId);
-    const redactedPayload = redactSecrets({ ...payload, status }, config.redactionSecrets ?? []);
+    const ownerFields = artifactOwnerFields(config);
+    const validatedSidecars = gate === "qa_manual_web"
+        ? await validateQaSidecarReferences(config.worktreePath, config.workItemId, qaArray(payload, "sidecars", qaEvidenceSource(payload)), ownerFields.owner_type, ownerFields.owner_id)
+        : null;
+    const redactedPayload = redactSecrets({
+        ...payload,
+        status,
+        ...(validatedSidecars ? { sidecars: validatedSidecars } : {})
+    }, config.redactionSecrets ?? []);
     const producedBy = optionalString(redactedPayload, "produced_by")
         ?? optionalString(redactedPayload, "producedBy")
         ?? config.producedBy
         ?? "forge-completion-tool";
-    const ownerFields = artifactOwnerFields(config);
     const artifactRoot = ownerFields.owner_type && ownerFields.owner_id
         ? artifactRootForOwner(config.worktreePath, ownerFields.owner_type, ownerFields.owner_id)
         : artifactRootFor(config.worktreePath, config.workItemId);

package/dist/session/phase-completion.d.ts

@@ -9,7 +9,8 @@ export type DebugCompletionPhase = "debug_repro" | "debug_root_cause" | "debug_f
 export type ArchitectCompletionPhase = "architect";
 export type DraftCompletionPhase = "draft";
 export type DecomposeCompletionPhase = "decompose";
-export type CompletionPhase = DevelopCompletionPhase | "qa" | DebugCompletionPhase | ArchitectCompletionPhase | DraftCompletionPhase | DecomposeCompletionPhase;
+export type CiRepairCompletionPhase = "ci_repair";
+export type CompletionPhase = DevelopCompletionPhase | "qa" | DebugCompletionPhase | ArchitectCompletionPhase | DraftCompletionPhase | DecomposeCompletionPhase | CiRepairCompletionPhase;
 export type QaCompletionGate = "qa_plan" | "qa_regression" | "qa_api" | "qa_manual_web" | "qa_bug_repro" | "qa_findings" | "qa_verdict";
 export type DraftCompletionGate = "draft_intent" | "draft_repo_context" | "draft_graph_context" | "draft_product_scope" | "draft_work_order_plan" | "draft_critic" | "draft_proposal";
 export type DecomposeCompletionGate = "decompose_subject_intake" | "decompose_context_review" | "decompose_breakdown_strategy" | "decompose_child_items" | "decompose_dependency_graph" | "decompose_critic" | "decompose_proposal";
@@ -25,6 +26,7 @@ export interface CompletionToolRuntimeOptions {
     readonly dispatch: RunOnceDispatchPacket;
     readonly worktree: WorktreeHandle;
     readonly phase?: CompletionPhase;
+    readonly runtimeEnvironment?: Readonly<Record<string, string>>;
 }
 export interface CompletionToolServerConfig {
     readonly worktreePath: string;
@@ -47,6 +49,13 @@ export interface CompletionToolCallResult {
         readonly text: string;
     }[];
     readonly structuredContent: CompletionArtifactReference & {
+        readonly artifact_written: true;
+        readonly artifact_receipt: {
+            readonly schema_version: 1;
+            readonly path: string;
+            readonly report_path: string;
+            readonly content_hash: string;
+        };
         readonly gate: {
             readonly phase: CompletionPhase;
             readonly qaGate?: QaCompletionGate;
@@ -56,7 +65,7 @@ export interface CompletionToolCallResult {
             readonly allowed: boolean;
             readonly reason: string;
         };
-        readonly nextPhase: CompletionPhase | "dev_test_ready" | "qa_ready" | "sign_off_ready";
+        readonly nextPhase: CompletionPhase | "dev_test_ready" | "qa_ready" | "sign_off_ready" | "provider_checks_ready";
         readonly nextInstruction: string;
     };
 }

package/dist/session/phase-completion.helpers.d.ts

@@ -33,6 +33,11 @@ export declare function requireField(payload: Record<string, unknown>, key: stri
 export declare function requireNonPassEvidence(payload: Record<string, unknown>): void;
 export declare function requireImplementationEvidence(payload: Record<string, unknown>): void;
 export declare function requirePassingCommands(payload: Record<string, unknown>): void;
+export declare class CompletionPayloadValidationError extends Error {
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+export declare function throwCompletionPayloadIssues(issues: readonly string[]): void;
 export declare function requireArray(payload: Record<string, unknown>, key: string): void;
 export declare function requireNonEmptyArray(payload: Record<string, unknown>, key: string): void;
 export declare function arrayLength(payload: Record<string, unknown>, key: string): number;

package/dist/session/phase-completion.helpers.js

@@ -85,6 +85,9 @@ export function parseStrictCompletionPhase(value) {
     if (normalized === "decompose" || normalized === "decomposition" || normalized === "work_order_decomposition" || normalized === "feature_decomposition") {
         return "decompose";
     }
+    if (normalized === "ci_repair" || normalized === "pr_checks" || normalized === "repair_pr_checks") {
+        return "ci_repair";
+    }
     return null;
 }
 export function normalizeDebugCompletionPhase(value) {
@@ -156,6 +159,9 @@ export function phaseFromToolName(toolName) {
     if (normalized === "forge.complete_architect_plan" || normalized === "complete_architect_plan") {
         return "architect";
     }
+    if (normalized === "forge.complete_ci_repair" || normalized === "complete_ci_repair") {
+        return "ci_repair";
+    }
     if (draftGateFromToolName(toolName)) {
         return "draft";
     }
@@ -256,28 +262,45 @@ export function requirePassingCommands(payload) {
     if (commands.length === 0) {
         throw new Error("commands must include at least one deterministic validation command.");
     }
+    const issues = [];
     for (const [index, command] of commands.entries()) {
         if (!command || typeof command !== "object" || Array.isArray(command)) {
-            throw new Error(`commands[${index}] must be an object.`);
+            issues.push(`commands[${index}] must be an object.`);
+            continue;
         }
         const record = command;
         if (typeof record.command !== "string" || record.command.trim().length === 0) {
-            throw new Error(`commands[${index}].command must be a non-empty string.`);
+            issues.push(`commands[${index}].command must be a non-empty string.`);
         }
         if (typeof record.summary !== "string" || record.summary.trim().length === 0) {
-            throw new Error(`commands[${index}].summary must be a non-empty string.`);
+            issues.push(`commands[${index}].summary must be a non-empty string.`);
         }
         if (typeof record.exit_code !== "number" || !Number.isFinite(record.exit_code)) {
-            throw new Error(`commands[${index}].exit_code must be a finite number.`);
+            issues.push(`commands[${index}].exit_code must be a finite number.`);
         }
-        if (record.exit_code !== 0) {
-            throw new Error(`commands[${index}].exit_code must be 0 when status is pass.`);
+        else if (record.exit_code !== 0) {
+            issues.push(`commands[${index}].exit_code must be 0 when status is pass.`);
         }
         const status = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
         if (status !== "pass") {
-            throw new Error(`commands[${index}].status must be pass.`);
+            issues.push(`commands[${index}].status must be pass.`);
         }
     }
+    throwCompletionPayloadIssues(issues);
+}
+export class CompletionPayloadValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super(`completion_payload_invalid: ${issues.length} correction${issues.length === 1 ? "" : "s"} required; no artifact was written.\n`
+            + issues.map(issue => `- ${issue}`).join("\n")
+            + "\nRepair every listed field and resubmit this gate once.");
+        this.issues = issues;
+        this.name = "CompletionPayloadValidationError";
+    }
+}
+export function throwCompletionPayloadIssues(issues) {
+    if (issues.length > 0)
+        throw new CompletionPayloadValidationError(issues);
 }
 export function requireArray(payload, key) {
     if (!Array.isArray(payload[key])) {
@@ -600,9 +623,22 @@ export async function readOptionalFile(filePath) {
 }
 export async function writeFileAtomic(filePath, content) {
     await fs.mkdir(path.dirname(filePath), { recursive: true });
-    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${crypto.randomUUID()}.tmp`);
     await fs.writeFile(tempPath, content, "utf8");
-    await fs.rename(tempPath, filePath);
+    try {
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        if (process.platform !== "win32" || !isNodeError(error) || (error.code !== "EPERM" && error.code !== "EEXIST")) {
+            await fs.rm(tempPath, { force: true });
+            throw error;
+        }
+        // Windows rename does not reliably replace an existing destination. QA-cycle gates
+        // intentionally refresh canonical bundle files, so remove only the exact destination
+        // after the replacement temp file is durable, then complete the rename.
+        await fs.rm(filePath, { force: true });
+        await fs.rename(tempPath, filePath);
+    }
 }
 export function stableStringify(value) {
     return JSON.stringify(sortJson(value));

package/dist/session/phase-completion.js

@@ -195,6 +195,10 @@ export const phaseFiles = {
     decompose: {
         jsonFileName: "decompose.proposal.json",
         reportFileName: "decompose.report.md"
+    },
+    ci_repair: {
+        jsonFileName: "ci-repair.handoff.json",
+        reportFileName: "ci-repair.report.md"
     }
 };
 export function completionPhaseFromDispatch(dispatch) {
@@ -224,6 +228,9 @@ export function normalizeCompletionPhase(value) {
     if (normalized === "decompose" || normalized === "decomposition" || normalized === "work_order_decomposition" || normalized === "feature_decomposition") {
         return "decompose";
     }
+    if (normalized === "ci_repair" || normalized === "pr_checks" || normalized === "repair_pr_checks") {
+        return "ci_repair";
+    }
     return "implementation";
 }
 export function usesDevelopCycleCompletion(dispatch) {
@@ -275,9 +282,11 @@ export function completionToolNamesForPhase(phase) {
             ? "complete_self_review"
             : phase === "validation"
                 ? "complete_validation"
-                : phase === "architect"
-                    ? "complete_architect_plan"
-                    : "complete_qa";
+                : phase === "ci_repair"
+                    ? "complete_ci_repair"
+                    : phase === "architect"
+                        ? "complete_architect_plan"
+                        : "complete_qa";
     return [`forge.${base}`, base];
 }
 export function completionToolNamesForQaGate(gate) {

package/dist/session/phase-completion.prompts.d.ts

@@ -1,13 +1,13 @@
 import { type CompletionPhase, type DebugCompletionPhase, type DecomposeCompletionGate, type DevelopCompletionPhase, type DraftCompletionGate, type QaCompletionGate } from "./phase-completion.js";
-export declare function completionPromptForPhase(phase: CompletionPhase): string;
+export declare function completionPromptForPhase(phase: CompletionPhase, artifactRoot?: string): string;
 export declare function completionPromptForDevelopCycle(phase: CompletionPhase): string;
-export declare function completionPromptForQaCycle(currentGate?: QaCompletionGate): string;
+export declare function completionPromptForQaCycle(currentGate?: QaCompletionGate, artifactRoot?: string): string;
 export declare function completionPromptForDraftCycle(currentGate?: DraftCompletionGate): string;
 export declare function completionPromptForDecomposeCycle(currentGate?: DecomposeCompletionGate): string;
 export declare function completionPromptForDebugCycle(currentGate?: DebugCompletionPhase): string;
 export declare function nextPhaseAfter(phase: CompletionPhase): DevelopCompletionPhase | null;
 export declare function nextDebugPhaseAfter(phase: DebugCompletionPhase): DebugCompletionPhase | null;
-export declare function completionToolNextInstruction(completedPhase: CompletionPhase, status: string, nextPhase: CompletionPhase | "dev_test_ready" | "qa_ready" | "sign_off_ready"): string;
+export declare function completionToolNextInstruction(completedPhase: CompletionPhase, status: string, nextPhase: CompletionPhase | "dev_test_ready" | "qa_ready" | "sign_off_ready" | "provider_checks_ready"): string;
 export declare function completionToolNextInstructionForDraftGate(completedGate: DraftCompletionGate, status: string, nextGate: DraftCompletionGate | null): string;
 export declare function completionToolNextInstructionForQaGate(completedGate: QaCompletionGate, status: string, nextGate: QaCompletionGate | null): string;
 export declare function completionToolNextInstructionForDecomposeGate(completedGate: DecomposeCompletionGate, status: string, nextGate: DecomposeCompletionGate | null): string;

package/dist/session/phase-completion.prompts.js

@@ -1,13 +1,13 @@
 import { completionPhaseOrder, completionToolNamesForPhase, debugCompletionPhaseOrder, expectedCompletionToolName, expectedDebugCompletionToolName, expectedDecomposeCompletionToolName, phaseFiles, toolServerName } from "./phase-completion.js";
 import { isDebugCompletionPhase, isDevelopCompletionPhase } from "./phase-completion.validation.js";
-export function completionPromptForPhase(phase) {
+export function completionPromptForPhase(phase, artifactRoot = ".forge/work-items/{workItemId}/artifacts") {
     const toolName = expectedCompletionToolName(phase);
     const alias = completionToolNamesForPhase(phase).find((name) => name !== toolName);
     const artifactName = phaseFiles[phase].jsonFileName;
     if (phase === "qa") {
         return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
 Do not write QA artifacts by hand. When QA is complete, call \`${toolName}(...)\`${alias ? ` (or \`${alias}\` if your client shows unqualified MCP tool names)` : ""} with the required structured QA payload.
-That tool writes the durable QA bundle under \`.forge/work-items/{workItemId}/artifacts/\`: \`qa.plan.json\`, \`qa.evidence.json\`, \`qa.findings.json\`, \`${artifactName}\`, and \`qa.report.md\`.
+That tool writes the durable QA bundle under \`${artifactRoot}/\`: \`qa.plan.json\`, \`qa.evidence.json\`, \`qa.findings.json\`, \`${artifactName}\`, and \`qa.report.md\`.
 Use \`status: "pass"\` only when the validated changes satisfy acceptance criteria with concrete evidence. Use \`status: "needs_rework"\` with actionable in-scope findings, or \`status: "blocked"\` with a concrete blocker_reason.
 Include \`policy_warnings\` for non-blocking Forge policy or scope mismatches that should remain visible after QA.
 Forge will mirror only the tool-written QA artifacts; reporting QA completion in prose is not enough.`;
@@ -22,6 +22,14 @@ The payload must put \`phases\`, \`tasks\`, \`dependencies\`, and \`phase_gates\
 Dependency entries use canonical \`before\` and \`after\` task ids, for example \`{ "before": "task-1", "after": "task-2" }\`. Forge accepts \`from\`/\`to\` only as aliases and normalizes them before writing artifacts.
 Use \`status: "pass"\` for a valid pending-approval plan, \`needs_revision\` when story/design input must change, or \`blocked\` with a concrete blocker.
 Forge will mirror only the tool-written Architect artifacts; reporting the plan in prose is not enough.`;
+    }
+    if (phase === "ci_repair") {
+        return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
+Read the generated \`.forge/work-items/{workItemId}/ci-repair.readiness.json\` before running validation.
+Do not write the CI-repair handoff by hand. After the repair and locally equivalent validation are complete, call \`${toolName}(...)\`${alias ? ` (or \`${alias}\` if your client shows unqualified MCP tool names)` : ""}.
+That tool validates failed-check inspection, root cause, scoped changes, narrow proof, every failed-job guard/test/drift step, provider-only classifications, broader validation, remaining risk, provider state, and push readiness.
+It writes \`.forge/work-items/{workItemId}/artifacts/${artifactName}\`. Forge Bridge will not commit, push, or report CI repair success until this gate passes.
+For a step classified \`provider_only\`, include the exact reason and provider check that will supply the missing proof. Do not weaken or delete the provider check.`;
     }
     return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
 Do not write phase artifacts by hand. When the phase is complete, call \`${toolName}(...)\`${alias ? ` (or \`${alias}\` if your client shows unqualified MCP tool names)` : ""} with the required evidence payload.
@@ -38,10 +46,10 @@ Complete the dev cycle in order inside this same provider session:
 Each tool writes the canonical artifact under \`.forge/work-items/{workItemId}/artifacts/\` and returns the next-phase instruction Forge expects you to follow.
 If the current phase cannot pass, call the current phase tool with a non-pass status and explicit blockers instead of reporting completion in prose only.`;
 }
-export function completionPromptForQaCycle(currentGate = "qa_plan") {
+export function completionPromptForQaCycle(currentGate = "qa_plan", artifactRoot = ".forge/work-items/{workItemId}/artifacts") {
     return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
 Do not write QA artifacts by hand. The tool server enforces QA gate order and starts this run at \`${currentGate}\`.
-Complete the QA cycle in order inside this same provider session:
+Complete the QA cycle in order inside this same provider session. Start long, independent regression verification as early as practical, continue API/source/manual review while it runs, and wait for its receipt only when those independent checks are complete:
 1. Call \`forge.complete_qa_plan(...)\` after the QA test plan/checklist is ready.
 2. Follow the returned regression instruction, then call \`forge.complete_qa_regression(...)\`.
 3. Follow the returned API/backend instruction, then call \`forge.complete_qa_api(...)\`.
@@ -50,7 +58,9 @@ Complete the QA cycle in order inside this same provider session:
 6. Follow the returned findings instruction, then call \`forge.complete_qa_findings(...)\`.
 7. Follow the returned verdict instruction, then call \`forge.complete_qa_verdict(...)\`.
 Use \`status: "skipped"\` with a reason for gates that are not applicable. If a gate is blocked, keep moving through later gates as skipped due to the blocker and finish with a blocked verdict.
-The final verdict tool writes the canonical QA bundle under \`.forge/work-items/{workItemId}/artifacts/\`: \`qa.plan.json\`, \`qa.evidence.json\`, \`qa.findings.json\`, \`qa.verdict.json\`, and \`qa.report.md\`.
+On a managed host, use focused checks plus the relevant runner-authored \`forge.start_managed_verification\` profiles for normal Story QA; shard slow tiers when broader evidence is justified. Reserve the \`dotnet_solution\` profile for shared test/runtime infrastructure, Feature/PR integration, or an explicit QA-plan requirement. Use \`forge.start_managed_command\` only for other commands expected to exceed two minutes. Continue independent QA work, then call \`forge.wait_managed_command\` once for the durable terminal receipt; do not poll \`forge.get_managed_command\`. Include the returned \`managed_command_id\` in command evidence. Forge records live progress outside the provider transcript and delivers one terminal result.
+For a negative assertion, make the command itself exit 0 when the forbidden condition is absent. In particular, raw \`rg\` exit 1 means no matches but cannot be submitted as passing evidence; wrap it so no match exits 0, a match fails, and tool errors remain failures. Before every completion call, ensure passing command records have \`exit_code: 0\`, \`status: "pass"\`, and a summary. A rejected call writes no artifact; repair every issue returned by Forge and resubmit the same gate once without probing the filesystem.
+The final verdict tool writes the canonical QA bundle under \`${artifactRoot}/\`: \`qa.plan.json\`, \`qa.evidence.json\`, \`qa.findings.json\`, \`qa.verdict.json\`, and \`qa.report.md\`.
 Include \`policy_warnings\` in the final verdict for non-blocking Forge policy or scope mismatches that should remain visible after QA.
 The legacy \`forge.complete_qa\` one-shot tool is not available in normal QA-cycle mode. Reporting QA completion in prose is not enough.`;
 }
@@ -115,6 +125,11 @@ export function completionToolNextInstruction(completedPhase, status, nextPhase)
         }
         return "QA accepted. Forge has the structured evidence needed to move this work item to Sign-Off.";
     }
+    if (completedPhase === "ci_repair") {
+        return status === "pass"
+            ? "CI repair handoff accepted. Forge Bridge may now commit, push, and return the PR to provider checks."
+            : "Stay in CI repair, address the exact missing evidence returned by this gate, then call forge.complete_ci_repair again.";
+    }
     if (status !== "pass") {
         return `Stay in ${completedPhase}, address the recorded blockers, then call ${expectedCompletionToolName(completedPhase)} again.`;
     }
@@ -203,7 +218,7 @@ export function completionToolNextInstructionForDebugGate(completedGate, status,
 function qaGateInstruction(gate) {
     switch (gate) {
         case "qa_regression":
-            return "Run or explicitly skip applicable regression/build/lint/typecheck/e2e checks, then call forge.complete_qa_regression.";
+            return "Run or explicitly skip applicable regression/build/lint/typecheck/e2e checks, then call forge.complete_qa_regression. For normal Story QA, prefer focused checks and runner-authored forge.start_managed_verification tier profiles; reserve dotnet_solution for shared infrastructure, Feature/PR integration, or an explicit plan requirement. Use forge.start_managed_command only for other commands expected to exceed two minutes, continue independent QA, then call forge.wait_managed_command once and include its terminal managed_command_id in command evidence; do not poll. Normalize negative assertions so an expected no-match exits 0. A reproduced failure outside the current diff and acceptance criteria may remain non-blocking only when the current item has independent passing evidence: preserve it as an out_of_scope_failure with candidate_bug_id, scope_evidence, acceptance_criteria_independent: true, and a failing focused repro command/exit code. Never classify an unexplained, in-scope, or infrastructure failure this way.";
         case "qa_api":
             return "Run or explicitly skip applicable API/backend contract checks, then call forge.complete_qa_api.";
         case "qa_manual_web":

package/dist/session/phase-completion.runtime.d.ts

@@ -1,4 +1,5 @@
 import { type CompletionToolCallResult, type CompletionToolRuntime, type CompletionToolRuntimeOptions, type CompletionToolServerConfig } from "./phase-completion.js";
+import { type ManagedAttemptToolResult } from "./managed-attempt-tools.js";
 export declare function prepareCompletionToolRuntime(options: CompletionToolRuntimeOptions): Promise<CompletionToolRuntime>;
 export declare function buildCompletionToolServerArgs(config: CompletionToolServerConfig): readonly string[];
 export declare function codexMcpConfigArgs(runtime: CompletionToolRuntime): readonly string[];
@@ -10,11 +11,12 @@ export declare class CompletionToolServerSession {
     private currentQaGate;
     private currentDraftGate;
     private currentDecomposeGate;
+    private readonly managedCommandReceipts;
     private completed;
     constructor(config: CompletionToolServerConfig);
     get instructions(): string;
     toolDefinitions(): readonly unknown[];
-    callTool(toolName: string, input: unknown): Promise<CompletionToolCallResult>;
+    callTool(toolName: string, input: unknown): Promise<CompletionToolCallResult | ManagedAttemptToolResult>;
     private callDecomposeGateTool;
     private callDraftGateTool;
     private callDebugGateTool;
@@ -25,6 +27,15 @@ export declare class CompletionToolServerSession {
     private advanceAfterQaGate;
     private advanceAfterDebugGate;
 }
+export declare function completionToolRuntimeEnvironment(runtimeEnvironment?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
+/**
+ * A solution-wide Forge test is long enough that a generic provider shell can
+ * expire while VSTest is still healthy. On managed host attempts, only the
+ * attempt-owned command runner can prove the exact process outcome and clean
+ * up its process tree. Keep this check at the completion gate so prompt drift
+ * cannot turn an arbitrary shell timeout into a QA blocker.
+ */
+export declare function assertManagedQaRegressionEvidence(input: unknown, receipts: readonly Readonly<Record<string, unknown>>[]): void;
 export declare function runCompletionMcpServer(config: CompletionToolServerConfig): Promise<void>;
 export declare function parseCompletionMcpArgs(argv: readonly string[]): {
     readonly ok: true;
@@ -34,3 +45,4 @@ export declare function parseCompletionMcpArgs(argv: readonly string[]): {
     readonly error: string;
 };
 export declare function completionRedactionEnv(secrets: readonly string[]): Readonly<Record<string, string>>;
+export declare function completionToolRejectedResult(toolName: string, error: unknown): Readonly<Record<string, unknown>>;