return [context?.trim(), deliverySection, promptSection].filter(Boolean).join("\n\n");

}

/**

* Maps the surviving user-request portion of an input range after delivery

* metadata has been relocated before the request.

*/

export function resolveCodexDeliveryHintPreservedInputRange(params: {

prompt: string;

promptInputRange: { start: number; end: number } | undefined;

decoratedPrompt: string;

}): { start: number; end: number } | undefined {

const { prompt, promptInputRange, decoratedPrompt } = params;

const { deliveryHint, prompt: promptWithoutDeliveryHint } = splitLeadingCodexDeliveryHint(prompt);

if (

!deliveryHint ||

!promptInputRange ||

promptInputRange.start < 0 ||

promptInputRange.end < promptInputRange.start ||

promptInputRange.end > prompt.length ||

!decoratedPrompt.endsWith(promptWithoutDeliveryHint)

) {

return undefined;

}

const promptWithoutDeliveryHintStart = prompt.length - promptWithoutDeliveryHint.length;

const inputStart = Math.max(promptInputRange.start, promptWithoutDeliveryHintStart);

const inputEnd = Math.max(

inputStart,

Math.min(

promptInputRange.end,

promptWithoutDeliveryHint.length + promptWithoutDeliveryHintStart,

),

);

const decoratedPromptSuffixStart = decoratedPrompt.length - promptWithoutDeliveryHint.length;

const requestHeader = "Current user request:\n";

const requestHeaderStart = decoratedPromptSuffixStart - requestHeader.length;

// Delivery metadata moves outside the request, so retain the remaining input

// span rather than treating the original, now non-contiguous range as valid.

return {

start:

inputStart === promptWithoutDeliveryHintStart &&

decoratedPrompt.slice(requestHeaderStart, decoratedPromptSuffixStart) === requestHeader

? requestHeaderStart

: decoratedPromptSuffixStart + inputStart - promptWithoutDeliveryHintStart,

end: decoratedPromptSuffixStart + inputEnd - promptWithoutDeliveryHintStart,

};

}

function splitLeadingCodexDeliveryHint(prompt: string): {

deliveryHint?: string;

prompt: string;

initializeGlobalHookRunner,

resetGlobalHookRunner,

} from "openclaw/plugin-sdk/hook-runtime";

import { MESSAGE_TOOL_DELIVERY_HINTS } from "openclaw/plugin-sdk/message-tool-delivery-hints";

import { createMockPluginRegistry } from "openclaw/plugin-sdk/plugin-test-runtime";

import { registerSandboxBackend } from "openclaw/plugin-sdk/sandbox";

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

await run;

});

it("bounds hook-appended prompts after delivery metadata is relocated", async () => {

initializeGlobalHookRunner(

createMockPluginRegistry([

{

hookName: "before_prompt_build",

handler: async () => ({ appendContext: `hook context ${"h".repeat(1_100_000)}` }),

},

]),

);

const sessionFile = path.join(tempDir, "session-delivery-hint.jsonl");

const workspaceDir = path.join(tempDir, "workspace-delivery-hint");

const harness = createStartedThreadHarness();

const params = createParams(sessionFile, workspaceDir);

params.prompt = `${MESSAGE_TOOL_DELIVERY_HINTS[0]}\n\ncurrent prompt survives`;

const run = runCodexAppServerAttempt(params);

await harness.waitForMethod("turn/start");

const inputText = getRequestInputText(harness);

expect(inputText.length).toBeLessThanOrEqual(CODEX_TURN_START_TEXT_INPUT_MAX_CHARS);

expect(inputText).toContain("Current user request:\ncurrent prompt survives");

expect(inputText).not.toContain("hook context");

await harness.completeTurn();

await run;

});

it("bounds hook-appended output for an empty prompt without an active context engine", async () => {

initializeGlobalHookRunner(

createMockPluginRegistry([

readContextEngineThreadBootstrapProjection,

readMirroredSessionHistoryMessages,

renderCodexSkillsCollaborationInstructions,

resolveCodexDeliveryHintPreservedInputRange,

resolveContextEngineBootstrapProjectionDecision,

} from "./attempt-context.js";

import {

promptBuild.promptInputRange,

turnPromptText,

);

const preservedRange = resolveShiftedPromptInputRange(

promptBuild.prompt,

promptBuild.promptInputRange,

turnPromptText,

);

const preservedRange =

resolveShiftedPromptInputRange(

promptBuild.prompt,

promptBuild.promptInputRange,

turnPromptText,

) ??

resolveCodexDeliveryHintPreservedInputRange({

prompt: promptBuild.prompt,

promptInputRange: promptBuild.promptInputRange,

decoratedPrompt: turnPromptText,

});

return fitCodexProjectedContextForTurnStart({

promptText: turnPromptText,

contextRange: projectedRanges?.contextRange,