@qwen-code/arena-agent 0.0.10-dev.1 → 0.0.10-dev.11

package/dist/code-tools.js

@@ -12,10 +12,14 @@ import iconv from "iconv-lite";
 import mime from "mime/lite";
 import { executeBraveWebSearch } from "./brave-search.js";
 import { FetchPageReader } from "./fetch-page.js";
-import { generatedImageBytesForExtension } from "./image.js";
+import { replaceFirstText, replaceUniqueText } from "./file-edit.js";
+import { detectedImageMimeType, generatedImageBytesForExtension } from "./image.js";
+import { supportsImageInput } from "./model-capabilities.js";
 import { generateImageWithModelRouter, } from "./model-router-media.js";
 import { executeRoutifyWebFetch, routifyWebFetchEnabled, } from "./routify-web-fetch.js";
+import { replayResponseFor } from "./replay-responses.js";
 import { toolDefinitions } from "./spec.js";
+import { boundedWebFetchResult, truncateCodeArenaText } from "./web-fetch-output.js";
 const knownTextApplicationMimeTypes = new Set([
     "application/ecmascript",
     "application/javascript",
@@ -184,6 +188,42 @@ const visibleImageExtensions = new Set([
     ".png",
     ".webp",
 ]);
+const readableImageExtensions = new Set([".jpeg", ".jpg", ".png"]);
+const maximumReadableImageBytes = 10 * 1024 * 1024;
+function readableImageMimeType(data) {
+    if (data.length >= 8 &&
+        data.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return "image/png";
+    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+        return "image/jpeg";
+    return undefined;
+}
+function hasReadableImageStructure(data, mediaType) {
+    if (detectedImageMimeType(data) !== mediaType)
+        return false;
+    if (mediaType === "image/jpeg") {
+        return data.length >= 4 && data[data.length - 2] === 0xff && data[data.length - 1] === 0xd9;
+    }
+    if (data.readUInt32BE(16) === 0 || data.readUInt32BE(20) === 0)
+        return false;
+    let offset = 8;
+    let hasImageData = false;
+    while (offset + 12 <= data.length) {
+        const length = data.readUInt32BE(offset);
+        const end = offset + 12 + length;
+        if (end > data.length)
+            return false;
+        const type = data.toString("ascii", offset + 4, offset + 8);
+        if (offset === 8 && (type !== "IHDR" || length !== 13))
+            return false;
+        if (type === "IDAT")
+            hasImageData = true;
+        if (type === "IEND")
+            return length === 0 && hasImageData;
+        offset = end;
+    }
+    return false;
+}
 // All 39 successful, unmutated list_files captures use this exact order,
 // independently of whether the requested path is the project root or src/.
 // It is the seed manifest order, not an alphabetical/filesystem order.
@@ -229,6 +269,7 @@ const visualIntroText = "<code-harness-system-message>\n" +
     "</code-harness-system-message>";
 const bashOutputLimit = 20_000;
 const lintOutputLimit = 10_000;
+const grepLineCharacterLimit = 2_000;
 // 中段截断，逐字反推自 3 个 truncated:true 参考样本：头尾各 9987 字符 +
 // 26 字符标记，总长恰 20000（由 T1(b) 执行回放发现，非首段截断）。
 const bashTruncationMarker = "\n... output truncated ...\n";
@@ -379,6 +420,14 @@ function workspaceFileKind(filePath, sample) {
 function json(value) {
     return JSON.stringify(value);
 }
+function capGrepLine(value) {
+    // Production captures cap every returned grep line independently. This is
+    // intentionally a prefix without a marker, including for the matching line.
+    return value.slice(0, grepLineCharacterLimit);
+}
+function capGrepLines(values) {
+    return values.map(capGrepLine);
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -392,6 +441,17 @@ function stringValue(value) {
 }
 function contentTypeForFile(filePath) {
     const extension = path.extname(filePath).toLowerCase();
+    const capturedTypes = {
+        ".py": "text/x-python",
+        ".sh": "text/x-shellscript",
+        ".sql": "application/sql",
+        ".yaml": "application/x-yaml",
+        ".yml": "application/x-yaml",
+        ".mjs": "text/plain",
+        ".c": "text/plain",
+    };
+    if (capturedTypes[extension])
+        return capturedTypes[extension];
     if ([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"].includes(extension)) {
         return "text/javascript";
     }
@@ -450,9 +510,14 @@ function matchesGlob(filePath, pattern) {
                 matcher.test(path.posix.basename(normalized))));
     });
 }
-function packageNameIsSafe(value) {
+function packageNameIsSafe(value, mode) {
     if (!value || value.startsWith("-") || /\s/.test(value))
         return false;
+    if (mode === "react") {
+        // React captures reject version ranges before invoking npm, while accepting
+        // exact versions and tags such as latest. Keep other modes' validator intact.
+        return /^(?:@[\w.-]+\/)?[\w.-]+(?:@[\w.+-]+)?$/.test(value);
+    }
     return /^(?:@[\w.-]+\/)?[\w.-]+(?:@(?:[\w*^<>=|.+-]+))?$/.test(value);
 }
 function valueAtPath(value, instancePath) {
@@ -524,6 +589,17 @@ function validationIssues(toolName, value, errors, definitions) {
             continue;
         }
         const actual = missing ? undefined : valueAtPath(value, error.instancePath);
+        if (error.keyword === "enum") {
+            const options = record(error.params).allowedValues;
+            issues.push({
+                received: actual,
+                code: "invalid_enum_value",
+                options,
+                path: pathParts,
+                message: `Invalid enum value. Expected ${options.map((option) => `'${option}'`).join(" | ")}, received '${actual}'`,
+            });
+            continue;
+        }
         const expected = error.keyword === "type"
             ? String(record(error.params).type || "string")
             : requiredPropertyType(toolName, key, definitions);
@@ -638,6 +714,57 @@ function interleaveMedia(left, right) {
 function normalizeMediaQuery(value) {
     return value.trim().replace(/\s+/g, " ").toLowerCase();
 }
+// Captured sessions call apply_patch even though no recorded request ever
+// advertised it: six react calls (s05/s17/s33) and 260+ html calls executed
+// successfully against the untouched 13-tool/7-tool contracts, while one h19
+// call was rejected by a turn whose runtime lacked it. The canonical schemas
+// stay untouched; the executor accepts the call the way the recording
+// environment's runtime did.
+const APPLY_PATCH_PARAMETERS = {
+    type: "object",
+    properties: {
+        input: { type: "string" },
+    },
+    required: ["input"],
+    additionalProperties: false,
+};
+const APPLY_PATCH_DESCRIPTION = "Apply a patch to files in the project. The patch uses the codex patch format: " +
+    "'*** Begin Patch' ... '*** End Patch', with '*** Add File: <path>' (content as " +
+    "'+'-prefixed lines), '*** Update File: <path>' ('@@'-separated hunks with ' ' " +
+    "context, '-' removed and '+' added lines), and '*** Delete File: <path>'.";
+// CODE_HARNESS_APPLY_PATCH_TOOL opts into advertising the tool to the model.
+// It stays out of the tool list by default while the executor still accepts
+// the call, matching the recorded runtime.
+function applyPatchToolAdvertised() {
+    const value = process.env.CODE_HARNESS_APPLY_PATCH_TOOL;
+    return (value !== undefined && !["0", "false", "no"].includes(value.toLowerCase()));
+}
+function locateHunkContext(lines, findLines, fromIndex) {
+    const limit = lines.length - findLines.length;
+    for (let start = Math.max(0, fromIndex); start <= limit; start += 1) {
+        let matched = true;
+        for (let offset = 0; offset < findLines.length; offset += 1) {
+            if (lines[start + offset] !== findLines[offset]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched)
+            return start;
+    }
+    for (let start = Math.max(0, fromIndex); start <= limit; start += 1) {
+        let matched = true;
+        for (let offset = 0; offset < findLines.length; offset += 1) {
+            if (lines[start + offset].trim() !== findLines[offset].trim()) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched)
+            return start;
+    }
+    return undefined;
+}
 export class CodeToolExecutor {
     config;
     workspace;
@@ -671,15 +798,38 @@ export class CodeToolExecutor {
         this.workspaceContext = options.workspaceContext;
         this.pageReader = new FetchPageReader({ signal: options.signal });
         const disallowed = new Set(config.disallowedTools || []);
-        this.definitions = toolDefinitions(this.workspaceContext, config.mode).filter((definition) => !disallowed.has(definition.function.name));
+        const canonical = toolDefinitions(this.workspaceContext, config.mode).filter((definition) => !disallowed.has(definition.function.name));
+        const advertiseApplyPatch = applyPatchToolAdvertised() && !disallowed.has("apply_patch");
+        this.definitions = advertiseApplyPatch
+            ? [
+                ...canonical,
+                {
+                    type: "function",
+                    function: {
+                        name: "apply_patch",
+                        description: APPLY_PATCH_DESCRIPTION,
+                        parameters: APPLY_PATCH_PARAMETERS,
+                    },
+                },
+            ]
+            : canonical;
         this.seedFileRank = capturedSeedFileRank(config.mode);
         addFormats(this.ajv);
         for (const definition of this.definitions) {
             this.validators.set(definition.function.name, this.ajv.compile(definition.function.parameters));
         }
+        // Hidden mode: advertise nothing, but keep the call executable.
+        if (!advertiseApplyPatch && !disallowed.has("apply_patch")) {
+            this.validators.set("apply_patch", this.ajv.compile(APPLY_PATCH_PARAMETERS));
+        }
+        // Captured React/HTML histories call this hidden tool. No public schema was
+        // captured: accept its object payload without adding model-visible tools.
+        if (config.mode !== "full-stack" && !disallowed.has("update_plan")) {
+            this.validators.set("update_plan", this.ajv.compile({ type: "object" }));
+        }
     }
-    // The tool schemas offered to the model for this session. Identical to the
-    // canonical trace set, adjusted for the selected workspace runtime.
+    // The tools offered to the model for this session, with captured schemas
+    // and descriptions adjusted for current capabilities and workspace runtime.
     availableTools() {
         return structuredClone(this.definitions);
     }
@@ -687,6 +837,128 @@ export class CodeToolExecutor {
         const names = this.definitions.map((tool) => tool.function.name);
         return `Model tried to call unavailable tool '${name}'. Available tools: ${names.join(", ")}.`;
     }
+    rawArguments(call) {
+        return typeof call.function?.arguments === "string"
+            ? call.function.arguments
+            : "{}";
+    }
+    normalizeArguments(name, parsedArguments) {
+        // Keep the parsed value available to checkpoint hooks while applying the
+        // same captured runtime defaults to the independent dispatch value.
+        const argumentsValue = (this.config.mode === "react" && typeof parsedArguments === "string"
+            ? {}
+            : structuredClone(parsedArguments));
+        // The captured provider advertises these fields as required, but its
+        // runtime still applies the documented defaults when a model omits
+        // them. Preserve the byte-identical outgoing schema while matching the
+        // observed execution behavior.
+        if (name === "read_file") {
+            argumentsValue.offset ??= 1;
+            argumentsValue.limit ??= 2000;
+        }
+        else if (name === "list_files" || name === "glob_files") {
+            argumentsValue.path ??= "";
+        }
+        else if (name === "bash" &&
+            argumentsValue && typeof argumentsValue === "object" &&
+            !Array.isArray(argumentsValue)) {
+            if (argumentsValue.workdir === undefined)
+                argumentsValue.workdir = "";
+            if (argumentsValue.description === undefined)
+                argumentsValue.description = "";
+        }
+        else if (name === "grep_files") {
+            argumentsValue.path ??= "";
+            argumentsValue.glob ??= "";
+            argumentsValue.output_mode ??= "content";
+            argumentsValue["-i"] ??= false;
+            argumentsValue["-B"] ??= 0;
+            argumentsValue["-A"] ??= 0;
+            argumentsValue["-C"] ??= 0;
+            argumentsValue.context ??= 0;
+        }
+        return argumentsValue;
+    }
+    validationMessage(name, value, validate) {
+        if (validate(value))
+            return undefined;
+        const issues = validationIssues(name, value, validate.errors || [], this.definitions);
+        return (`Invalid input for tool ${name}: Type validation failed: ` +
+            `Value: ${JSON.stringify(value)}.\n` +
+            `Error message: ${JSON.stringify(issues, null, 2)}`);
+    }
+    inspect(call) {
+        const id = String(call.id || "");
+        const name = String(call.function?.name || "");
+        const rawArguments = this.rawArguments(call);
+        const validate = this.validators.get(name);
+        if (!validate) {
+            let parsedArguments = undefined;
+            let parsed = false;
+            try {
+                parsedArguments = JSON.parse(rawArguments);
+                parsed = true;
+            }
+            catch {
+                // Tool-name validation takes precedence. Parsing is best-effort here
+                // only so a valid argument payload remains available to the hook.
+            }
+            return {
+                id,
+                name,
+                rawArguments,
+                ...(parsed ? { arguments: parsedArguments } : {}),
+                validation: "unknown_tool",
+                validationMessage: this.unavailableToolMessage(name),
+            };
+        }
+        let parsedArguments;
+        try {
+            parsedArguments = JSON.parse(rawArguments);
+        }
+        catch (error) {
+            return {
+                id,
+                name,
+                rawArguments,
+                validation: "invalid_json",
+                validationMessage: `Invalid input for tool ${name}: JSON parsing failed: Text: ` +
+                    `${rawArguments}.\nError message: ${errorMessage(error)}`,
+            };
+        }
+        let argumentsValue;
+        try {
+            argumentsValue = this.normalizeArguments(name, parsedArguments);
+        }
+        catch (error) {
+            return {
+                id,
+                name,
+                rawArguments,
+                arguments: parsedArguments,
+                validation: "invalid_arguments",
+                validationMessage: errorMessage(error),
+            };
+        }
+        const validationMessage = this.validationMessage(name, argumentsValue, validate);
+        if (validationMessage !== undefined) {
+            return {
+                id,
+                name,
+                rawArguments,
+                arguments: parsedArguments,
+                validation: "invalid_arguments",
+                validationMessage,
+            };
+        }
+        return {
+            id,
+            name,
+            rawArguments,
+            arguments: parsedArguments,
+            validation: "valid",
+        };
+    }
     async execute(call, _context) {
         const callId = String(call.id || "");
         const name = String(call.function?.name || "");
@@ -695,27 +967,8 @@ export class CodeToolExecutor {
             // 监听器不会补发已发生的 abort：已取消的 signal 必须在产生任何副作用
             // 之前短路，否则命令会照常 spawn 直到自然结束。
             this.signal?.throwIfAborted();
-            const argumentsValue = JSON.parse(typeof call.function?.arguments === "string"
-                ? call.function.arguments
-                : "{}");
-            // The captured provider advertises these fields as required, but its
-            // runtime still applies the documented defaults when a model omits
-            // them. Preserve the byte-identical outgoing schema while matching the
-            // observed execution behavior.
-            if (name === "read_file") {
-                argumentsValue.offset ??= 1;
-                argumentsValue.limit ??= 2000;
-            }
-            else if (name === "grep_files") {
-                argumentsValue.path ??= "";
-                argumentsValue.glob ??= "";
-                argumentsValue.output_mode ??= "content";
-                argumentsValue["-i"] ??= false;
-                argumentsValue["-B"] ??= 0;
-                argumentsValue["-A"] ??= 0;
-                argumentsValue["-C"] ??= 0;
-                argumentsValue.context ??= 0;
-            }
+            const parsedArguments = JSON.parse(this.rawArguments(call));
+            const argumentsValue = this.normalizeArguments(name, parsedArguments);
             const validate = this.validators.get(name);
             if (!validate) {
                 return {
@@ -724,14 +977,12 @@ export class CodeToolExecutor {
                     content: this.unavailableToolMessage(name),
                 };
             }
-            if (!validate(argumentsValue)) {
-                const issues = validationIssues(name, argumentsValue, validate.errors || [], this.definitions);
+            const validationMessage = this.validationMessage(name, argumentsValue, validate);
+            if (validationMessage !== undefined) {
                 return {
                     role: "tool",
                     tool_call_id: callId,
-                    content: `Invalid input for tool ${name}: Type validation failed: ` +
-                        `Value: ${JSON.stringify(argumentsValue)}.\n` +
-                        `Error message: ${JSON.stringify(issues, null, 2)}`,
+                    content: validationMessage,
                 };
             }
             const result = await this.dispatch(name, argumentsValue, callId);
@@ -770,13 +1021,24 @@ export class CodeToolExecutor {
         };
     }
     async dispatch(name, values, _toolCallId) {
+        // Replay mode (CODE_HARNESS_REPLAY_RESPONSES set): serve recorded outputs
+        // verbatim for nondeterministic tools (web_search/web_fetch/fetch_media/…)
+        // so replayed sessions stay offline and deterministic. Unlisted calls fall
+        // through to real execution.
+        const replayed = replayResponseFor(name, values);
+        if (replayed)
+            return replayed.output;
         switch (name) {
             case "read_file":
-                return this.readCodeFile(String(values.path), Number(values.offset), Number(values.limit));
+                return this.readCodeFile(String(values.path), Number(values.offset), Number(values.limit), _toolCallId);
             case "create_file":
                 return this.createCodeFile(String(values.path), String(values.content));
             case "edit_file":
                 return this.editCodeFile(String(values.path), String(values.context), String(values.replacement));
+            case "apply_patch":
+                return this.applyCodePatch(String(values.input));
+            case "update_plan":
+                return { status: "success" };
             case "delete_file":
                 return this.deleteCodeFile(String(values.path));
             case "list_files":
@@ -790,7 +1052,7 @@ export class CodeToolExecutor {
             case "build_project":
                 return this.buildProject();
             case "bash":
-                return this.fullStackBash(String(values.command), String(values.workdir));
+                return this.codeBash(String(values.command), String(values.workdir));
             case "build_and_start":
                 return this.buildAndStart();
             case "web_search":
@@ -806,8 +1068,9 @@ export class CodeToolExecutor {
         }
     }
     lexicalPath(raw) {
-        if (!raw)
-            throw new Error("path must not be empty");
+        if (!raw || path.isAbsolute(raw) || raw.includes("..")) {
+            throw new Error("Path cannot be empty, start with '/', or contain '..'");
+        }
         let candidate;
         if (!this.workspaceContext && (raw === "/home/user" || raw === "~")) {
             candidate = this.workspace;
@@ -852,8 +1115,7 @@ export class CodeToolExecutor {
         return path.relative(this.workspaceReal, target).split(path.sep).join("/");
     }
     rememberListedFile(filePath) {
-        if (this.seedFileRank.has(filePath) ||
-            this.listedFileOrder.has(filePath)) {
+        if (this.seedFileRank.has(filePath) || this.listedFileOrder.has(filePath)) {
             return;
         }
         this.listedFileOrder.set(filePath, this.nextListedFileOrder);
@@ -888,7 +1150,7 @@ export class CodeToolExecutor {
                 return -1;
             if (rightSeedRank !== undefined)
                 return 1;
-            return (this.listedFileOrder.get(left) - this.listedFileOrder.get(right));
+            return this.listedFileOrder.get(left) - this.listedFileOrder.get(right);
         });
     }
     async existsWithExactCase(rawPath) {
@@ -944,7 +1206,7 @@ export class CodeToolExecutor {
         await visit(searchRoot);
         return files;
     }
-    async readCodeFile(rawPath, offset, limit) {
+    async readCodeFile(rawPath, offset, limit, toolCallId) {
         const target = await this.confinedPath(rawPath);
         let data;
         try {
@@ -958,29 +1220,80 @@ export class CodeToolExecutor {
                 message: `File "${rawPath}" does not exist`,
             };
         }
+        if (readableImageExtensions.has(path.extname(target).toLowerCase())) {
+            const mediaType = readableImageMimeType(data);
+            if (!mediaType) {
+                return {
+                    status: "error",
+                    message: `"${rawPath}" is not a valid image — the file contents are not PNG or JPEG. Re-download or regenerate the file, then read it again.`,
+                };
+            }
+            if (!supportsImageInput(this.config)) {
+                return {
+                    status: "error",
+                    message: `This model cannot view images. Reference "${rawPath}" by its path instead.`,
+                };
+            }
+            if (data.length > maximumReadableImageBytes) {
+                return {
+                    status: "error",
+                    message: `Image "${rawPath}" is too large to view (${Math.round(data.length / 1024)} KB, max 10240 KB).`,
+                };
+            }
+            if (!hasReadableImageStructure(data, mediaType)) {
+                return {
+                    status: "error",
+                    message: `"${rawPath}" is not a valid image — the file contents are not PNG or JPEG. Re-download or regenerate the file, then read it again.`,
+                };
+            }
+            const relativePath = this.relativePath(target);
+            this.pendingVisualContent.set(toolCallId, [
+                { image: `data:${mediaType};base64,${data.toString("base64")}` },
+            ]);
+            return {
+                file: {
+                    content: `[Image file ${relativePath} (${Math.round(data.length / 1024)} KB, ${mediaType})]`,
+                    contentType: "text/plain",
+                    path: relativePath,
+                },
+                image: { mediaType, sizeBytes: data.length },
+                status: "success",
+            };
+        }
         if (workspaceFileKind(target, data.subarray(0, 4096)) !== "text") {
             return {
                 status: "error",
-                message: `File "${rawPath}" is not a supported text file`,
+                message: `Cannot read binary file "${rawPath}". Only text files and PNG/JPEG images are supported.`,
             };
         }
         const lines = decodeText(data).split("\n");
         const start = Math.max(1, Math.trunc(offset));
+        if (start > lines.length) {
+            return {
+                status: "success",
+                file: {
+                    path: this.relativePath(target),
+                    content: `Offset ${start} is out of range for this file (${lines.length} lines)`,
+                    contentType: contentTypeForFile(target),
+                },
+                totalLines: lines.length,
+            };
+        }
         const end = Math.min(lines.length, start + Math.max(1, Math.trunc(limit)) - 1);
-        const numbered = start > lines.length
-            ? ""
-            : lines
-                .slice(start - 1, end)
-                .map((line, index) => `${start + index}: ${line}`)
-                .join("\n");
-        const footer = start === 1 && end === lines.length
+        const numbered = lines
+            .slice(start - 1, end)
+            .map((line, index) => `${start + index}: ${line}`)
+            .join("\n");
+        const footer = end === lines.length
             ? `(End of file - ${lines.length} lines)`
             : `(Showing lines ${start}-${end} of ${lines.length}. Use offset=${end + 1} to continue.)`;
         return {
             status: "success",
             file: {
                 path: this.relativePath(target),
-                content: `${numbered}\n\n${footer}`,
+                content: this.config.mode === "react"
+                    ? truncateCodeArenaText(`${numbered}\n\n${footer}`)
+                    : `${numbered}\n\n${footer}`,
                 contentType: contentTypeForFile(target),
             },
             totalLines: lines.length,
@@ -1063,49 +1376,272 @@ export class CodeToolExecutor {
                 message: `File "${rawPath}" does not exist`,
             };
         }
-        if (!source.includes(context)) {
+        // React replaces the first exact occurrence, including when an indented
+        // context also occurs on a later, more deeply indented line. Keep the
+        // existing uniqueness check for fuzzy fallback and the other modes.
+        const replace = this.config.mode === "react" && context.length > 0 && source.includes(context)
+            ? replaceFirstText : replaceUniqueText;
+        const edited = replace(source, context, replacement, {
+            whitespaceInsensitiveMultiline: true,
+            whitespaceInsensitiveSingleLine: this.config.mode === "react",
+            preserveNewlines: this.config.mode === "react",
+        });
+        if (edited === undefined) {
+            // Captured sessions re-issue an edit after compaction or a retry. The
+            // provider reports success without touching the file when the context
+            // is already gone and the replacement is in place (f39 re-issues four
+            // dashboard edits this way).
+            // That retry behavior comes from Full Stack captures. React still
+            // reports Context not found even when the replacement is present.
+            if (this.config.mode !== "react" && replacement && source.includes(replacement)) {
+                return this.mutationResult("Edited", rawPath);
+            }
             return {
                 status: "error",
                 message: "Context not found. Read the file to verify the text exists.",
             };
         }
-        await writeFile(target, source.replace(context, replacement), "utf8");
+        await writeFile(target, edited, "utf8");
         return this.mutationResult("Edited", rawPath);
     }
+    // Some recorded sessions exposed a codex-style apply_patch tool (*** Begin
+    // Patch / Add|Update|Delete File / @@ hunks) that the provider executed
+    // without ever advertising it. Its observable contract: "Patch applied[.
+    // Type errors found.]" on success, "Invalid Context <anchor>:\n<context>"
+    // when a hunk context cannot be located — the anchor is the line where the
+    // previous hunk's match ended and the failed search started (h17 reports
+    // 666 after a four-line context hunk matching lines 663-666).
+    async applyCodePatch(patchText) {
+        const kindByMarker = {
+            Add: "add",
+            Update: "update",
+            Delete: "delete",
+        };
+        const operations = [];
+        let current;
+        for (const line of patchText.split("\n")) {
+            const marker = /^\*\*\* (Add|Update|Delete) File: (.+)$/.exec(line);
+            if (marker) {
+                current = {
+                    kind: kindByMarker[marker[1]],
+                    path: marker[2].trim(),
+                    lines: [],
+                };
+                operations.push(current);
+                continue;
+            }
+            if (line.startsWith("*** ")) {
+                current = undefined;
+                continue;
+            }
+            current?.lines.push(line);
+        }
+        if (this.config.mode === "react") {
+            // React parses duplicate operation paths before applying any writes.
+            // In particular, Delete + Add of the same file is an Add duplicate.
+            const seen = new Set();
+            for (const operation of operations) {
+                const target = await this.confinedPath(operation.path);
+                if (seen.has(target)) {
+                    const label = operation.kind[0].toUpperCase() + operation.kind.slice(1);
+                    return { status: "error", message: `${label} File Error: Duplicate Path: ${operation.path}` };
+                }
+                seen.add(target);
+            }
+        }
+        for (const operation of operations) {
+            const target = await this.confinedPath(operation.path);
+            if (operation.kind === "add") {
+                if (await this.existsWithExactCase(operation.path)) {
+                    return {
+                        status: "error",
+                        message: `Add File Error: Duplicate Path: ${operation.path}`,
+                    };
+                }
+                // The recorded provider writes exactly the "+" lines joined by
+                // newlines without appending a trailing one (h17's 27-line
+                // manifest.json reads back as totalLines 27, not 28).
+                const content = operation.lines
+                    .filter((line) => line.startsWith("+"))
+                    .map((line) => line.slice(1))
+                    .join("\n");
+                mkdirSync(path.dirname(target), { recursive: true });
+                await writeFile(target, content, "utf8");
+                this.rememberListedFile(this.relativePath(target));
+                continue;
+            }
+            if (operation.kind === "delete") {
+                if (!(await this.existsWithExactCase(operation.path))) {
+                    return {
+                        status: "error",
+                        message: `Delete File Error: File Not Found: ${operation.path}`,
+                    };
+                }
+                await rm(target, { force: true });
+                this.forgetListedPath(this.relativePath(target));
+                continue;
+            }
+            let source;
+            try {
+                if (!(await this.existsWithExactCase(operation.path)))
+                    throw new Error("missing");
+                source = await readFile(target, "utf8");
+            }
+            catch {
+                return {
+                    status: "error",
+                    message: `Update File Error: File Not Found: ${operation.path}`,
+                };
+            }
+            // Hunks are separated by @@ lines; within a hunk, " " context and "-"
+            // removed lines form the find pattern, " " context and "+" added lines
+            // form the replacement. Hunks stream over the original file: each
+            // context is searched forward from where the previous hunk ended, and a
+            // miss reports the search anchor over the find text the way the
+            // recorded provider does (h17: "Invalid Context 666:"). Whitespace
+            // drifted contexts match by trimmed lines.
+            const hunks = [];
+            let hunk = [];
+            for (const line of operation.lines) {
+                if (line.startsWith("@@")) {
+                    if (hunk.length)
+                        hunks.push(hunk);
+                    hunk = [];
+                    continue;
+                }
+                hunk.push(line);
+            }
+            if (hunk.length)
+                hunks.push(hunk);
+            const originalLines = source.split("\n");
+            const output = [];
+            let position = 0;
+            for (const hunkLines of hunks) {
+                const findLines = [];
+                const replaceLines = [];
+                for (const line of hunkLines) {
+                    if (line.startsWith("-")) {
+                        findLines.push(line.slice(1));
+                    }
+                    else if (line.startsWith("+")) {
+                        replaceLines.push(line.slice(1));
+                    }
+                    else {
+                        findLines.push(line.slice(1));
+                        replaceLines.push(line.slice(1));
+                    }
+                }
+                if (!findLines.length)
+                    continue;
+                const start = locateHunkContext(originalLines, findLines, position);
+                if (start === undefined) {
+                    return {
+                        status: "error",
+                        message: `Invalid Context ${position}:\n${findLines.join("\n")}`,
+                    };
+                }
+                output.push(...originalLines.slice(position, start));
+                output.push(...replaceLines);
+                position = start + findLines.length;
+            }
+            output.push(...originalLines.slice(position));
+            await writeFile(target, output.join("\n"), "utf8");
+        }
+        const lintError = await this.typeErrors();
+        if (lintError) {
+            return {
+                status: "success",
+                message: "Patch applied. Type errors found.",
+                lint_error: lintError,
+            };
+        }
+        return { status: "success", message: "Patch applied." };
+    }
     async deleteCodeFile(rawPath) {
         const target = await this.confinedPath(rawPath);
         await rm(target, { force: true, recursive: true });
         this.forgetListedPath(this.relativePath(target));
         return { status: "success" };
     }
+    discoverableFile(filePath) {
+        // Full Stack captures expose the lock to shell/read_file, but omit it
+        // from both project discovery tools, even before any package installation.
+        return this.config.mode !== "full-stack" || this.relativePath(filePath) !== "package-lock.json";
+    }
     async listCodeFiles(rawPath) {
+        if (this.config.mode === "react" && rawPath === "/")
+            rawPath = ".";
+        if (this.config.mode === "react" && (path.isAbsolute(rawPath) || rawPath.includes(".."))) {
+            return { status: "error", message: "Path must be relative to project root (no absolute paths or '..' traversal)" };
+        }
         const target = await this.confinedPath(rawPath || ".");
         if (!(await this.existsWithExactCase(rawPath || ".")) ||
             !existsSync(target)) {
             return { status: "success", files: [] };
         }
-        const files = this.orderListedFiles(await this.walkFiles(target));
+        const files = this.orderListedFiles((await this.walkFiles(target)).filter(file => this.discoverableFile(file)));
         return {
             status: "success",
-            files: files.map((filePath) => ({ path: filePath })),
+            files: (this.config.mode === "react" ? files.slice(0, 500) : files)
+                .map((filePath) => ({ path: filePath })),
         };
     }
     async grepCodeFiles(values) {
+        const pattern = String(values.pattern);
+        if (pattern.length > 200) {
+            return {
+                status: "error",
+                message: "Pattern too long (max 200 characters)",
+            };
+        }
         const target = await this.confinedPath(String(values.path || "."));
-        const targetInfo = await stat(target);
-        const files = await this.walkFiles(target);
         const glob = String(values.glob || "");
+        const mode = String(values.output_mode || "content");
         const flags = Boolean(values["-i"]) ? "i" : "";
         let expression;
         try {
-            expression = new RegExp(String(values.pattern), flags);
+            expression = new RegExp(pattern, flags);
         }
         catch (error) {
             throw new Error(`Invalid regular expression: ${errorMessage(error)}`);
         }
-        const symmetric = Math.max(Number(values.context || 0), Number(values["-C"] || 0));
+        let targetInfo;
+        try {
+            targetInfo = await stat(target);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            if (mode === "files_with_matches") {
+                return { status: "success", mode, files: [], truncated: false };
+            }
+            if (mode === "count") {
+                return {
+                    status: "success",
+                    mode,
+                    counts: [],
+                    totalMatches: 0,
+                    truncated: false,
+                };
+            }
+            return {
+                status: "success",
+                mode: "content",
+                matches: [],
+                truncated: false,
+            };
+        }
+        const files = await this.walkFiles(target);
+        // Full Stack captures expose a different context-grouping adapter from
+        // HTML/React: -C/context are ignored, the trailing group spans B+A lines,
+        // and a later match reuses the prior trailing group as contextBefore.
+        const groupedContext = this.config.mode === "full-stack";
+        const symmetric = groupedContext
+            ? 0
+            : Math.max(Number(values.context || 0), Number(values["-C"] || 0));
         const before = symmetric || Number(values["-B"] || 0);
         const after = symmetric || Number(values["-A"] || 0);
+        const contextSpan = groupedContext ? before + after : after;
         const matches = [];
         const matchedFiles = [];
         const counts = [];
@@ -1115,6 +1651,11 @@ export class CodeToolExecutor {
             const relativeToSearch = targetInfo.isFile()
                 ? path.basename(filePath)
                 : path.relative(target, filePath).split(path.sep).join("/");
+            if (relativeToSearch
+                .split("/")
+                .some((component) => component.startsWith("."))) {
+                continue;
+            }
             if (glob && !matchesGlob(relativeToSearch, glob))
                 continue;
             let content;
@@ -1129,23 +1670,69 @@ export class CodeToolExecutor {
                 continue;
             }
             const lines = content.split("\n");
-            let fileCount = 0;
-            for (let index = 0; index < lines.length; index += 1) {
-                if (!expression.test(lines[index]))
-                    continue;
-                fileCount += 1;
+            const searchLineCount = this.config.mode === "react" && lines.at(-1) === ""
+                ? lines.length - 1 : lines.length;
+            const matchingLines = [];
+            for (let index = 0; index < searchLineCount; index += 1) {
+                if (expression.test(lines[index]))
+                    matchingLines.push(index);
+            }
+            const fileCount = matchingLines.length;
+            let previousAfter = [];
+            for (let position = 0; position < matchingLines.length; position += 1) {
+                const index = matchingLines[position];
                 totalMatches += 1;
                 if (matches.length < maximumSearchResults) {
                     const match = {
                         path: relative,
                         lineNumber: index + 1,
-                        lineContent: lines[index],
+                        lineContent: capGrepLine(lines[index]),
                     };
-                    if (before > 0) {
-                        match.contextBefore = lines.slice(Math.max(0, index - before), index);
+                    if (groupedContext) {
+                        const contextBefore = position === 0
+                            ? lines.slice(Math.max(0, index - before), index)
+                            : previousAfter;
+                        if (contextBefore.length > 0) {
+                            match.contextBefore = capGrepLines(contextBefore);
+                        }
+                        const nextMatch = matchingLines[position + 1] ?? lines.length;
+                        previousAfter = lines.slice(index + 1, Math.min(index + 1 + contextSpan, nextMatch));
+                        if (nextMatch === lines.length &&
+                            previousAfter.at(-1) === "" &&
+                            index + 1 + contextSpan >= lines.length) {
+                            previousAfter = previousAfter.slice(0, -1);
+                        }
+                        if (previousAfter.length > 0) {
+                            match.contextAfter = capGrepLines(previousAfter);
+                        }
                     }
-                    if (after > 0) {
-                        match.contextAfter = lines.slice(index + 1, index + 1 + after);
+                    else if (this.config.mode === "react") {
+                        // The captured adapter attaches context lines to the preceding
+                        // match, even across ripgrep group separators. Only a file's first
+                        // match receives contextBefore. Do not duplicate overlapping groups.
+                        if (position === 0 && before > 0) {
+                            const contextBefore = lines.slice(Math.max(0, index - before), index);
+                            if (contextBefore.length) {
+                                match.contextBefore = capGrepLines(contextBefore);
+                            }
+                        }
+                        const nextMatch = matchingLines[position + 1];
+                        const end = Math.min(index + 1 + after, nextMatch ?? searchLineCount);
+                        const contextAfter = lines.slice(index + 1, end);
+                        if (nextMatch !== undefined && before > 0) {
+                            contextAfter.push(...lines.slice(Math.max(end, index + 1, nextMatch - before), nextMatch));
+                        }
+                        if (contextAfter.length) {
+                            match.contextAfter = capGrepLines(contextAfter);
+                        }
+                    }
+                    else {
+                        if (before > 0) {
+                            match.contextBefore = capGrepLines(lines.slice(Math.max(0, index - before), index));
+                        }
+                        if (after > 0) {
+                            match.contextAfter = capGrepLines(lines.slice(index + 1, index + 1 + after));
+                        }
                     }
                     matches.push(match);
                 }
@@ -1158,7 +1745,6 @@ export class CodeToolExecutor {
                 }
             }
         }
-        const mode = String(values.output_mode || "content");
         if (mode === "files_with_matches") {
             return {
                 status: "success",
@@ -1185,9 +1771,18 @@ export class CodeToolExecutor {
     }
     async globCodeFiles(pattern, rawPath) {
         const target = await this.confinedPath(rawPath || ".");
-        const files = await this.walkFiles(target);
+        let files;
+        try {
+            files = await this.walkFiles(target);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            return { status: "success", paths: [], truncated: false };
+        }
         const allPaths = files
-            .filter((filePath) => matchesGlob(path.relative(target, filePath).split(path.sep).join("/"), pattern))
+            .filter(file => this.discoverableFile(file))
+            .filter((filePath) => matchesGlob(path.relative(target, filePath).split(path.sep).join("/"), pattern) || (this.config.mode === "react" && matchesGlob(this.relativePath(filePath), pattern)))
             .map((filePath) => this.relativePath(filePath));
         return {
             status: "success",
@@ -1260,11 +1855,11 @@ export class CodeToolExecutor {
         });
     }
     async installNpmPackages(packages) {
-        const invalid = packages.find((packageName) => !packageNameIsSafe(packageName));
+        const invalid = packages.find((packageName) => !packageNameIsSafe(packageName, this.config.mode));
         if (invalid) {
             return {
                 status: "error",
-                message: `Invalid package name: ${invalid}`,
+                message: `Invalid package name: ${this.config.mode === "react" ? JSON.stringify(invalid) : invalid}`,
             };
         }
         const args = ["install", "-S"];
@@ -1302,24 +1897,18 @@ export class CodeToolExecutor {
             stderr: this.virtualizeCodeOutput(result.stderr),
         };
     }
-    virtualizeBashOutput(value) {
-        if (this.workspaceContext || this.config.mode === "full-stack")
-            return value;
-        let virtualized = value;
-        const workspaceRoots = [...new Set([this.workspace, this.workspaceReal])]
-            .filter((root) => root !== path.parse(root).root)
-            .sort((left, right) => right.length - left.length);
-        for (const root of workspaceRoots) {
-            virtualized = virtualized.replaceAll(root, "/home/user");
+    async codeBash(command, workdir) {
+        const cwd = workdir.trim() || ".";
+        if (path.isAbsolute(cwd) || cwd.includes("..")) {
+            throw new Error(`Invalid workdir: ${cwd}. Commands run from the project root by default. Only use workdir for relative subdirectories, never absolute paths.`);
         }
-        return virtualized;
-    }
-    async fullStackBash(command, workdir) {
         const configuredTimeout = Number(process.env.CODE_HARNESS_BASH_TIMEOUT_SECONDS || 300);
         const timeoutSeconds = Number.isFinite(configuredTimeout) && configuredTimeout > 0
             ? configuredTimeout
             : 300;
-        const result = await this.bash(command, workdir.trim() || ".", timeoutSeconds);
+        const result = await this.bash(command, cwd, timeoutSeconds);
+        if (result.timed_out)
+            return { status: "error", message: "Command timed out" };
         const exitCode = result.exit_code;
         const stdout = String(result.stdout || "");
         const stderr = String(result.stderr || "");
@@ -1454,12 +2043,6 @@ export class CodeToolExecutor {
         if (!(await stat(workdir)).isDirectory()) {
             throw new Error(`cwd is not a directory: ${cwd}`);
         }
-        // Runtime-aware callers execute commands exactly as written and report
-        // real local paths. The legacy /home/user translation is limited to the
-        // older non-Full-Stack replay contract.
-        const translatedCommand = this.workspaceContext || this.config.mode === "full-stack"
-            ? command
-            : command.replaceAll("/home/user", '"$ARENA_WORKSPACE"');
         return new Promise((resolve, reject) => {
             const env = {
                 ...process.env,
@@ -1477,7 +2060,7 @@ export class CodeToolExecutor {
             // detached：管道成员（npm、tail…）与 bash 同进程组。只杀 bash 会留下
             // 孤儿持有 stdout/stderr 管道，close 永不触发，整个 turn 挂死；
             // 必须杀整组，并在宽限期后强制结算兜底。
-            const child = spawn("/bin/bash", ["-c", translatedCommand], {
+            const child = spawn("/bin/bash", ["-c", command], {
                 cwd: workdir,
                 env,
                 stdio: ["ignore", "pipe", "pipe"],
@@ -1525,19 +2108,14 @@ export class CodeToolExecutor {
                     reject(this.signal.reason || new Error("operation cancelled"));
                     return;
                 }
-                // 生产契约：status 恒为 "completed"（包括非零退出码），超时无参考样本，
-                // 按最小猜测同样返回 completed + exit_code null，stderr 附超时说明。
-                if (timedOut && this.config.mode !== "full-stack") {
-                    stderr +=
-                        (stderr ? "\n" : "") + `command exceeded ${timeoutSeconds}s`;
-                }
-                const out = capBashOutput(this.virtualizeBashOutput(stdout));
-                const err = capBashOutput(this.virtualizeBashOutput(stderr));
+                const out = capBashOutput(stdout);
+                const err = capBashOutput(stderr);
                 resolve({
                     status: "completed",
                     stderr: err.text,
                     stdout: out.text,
                     exit_code: timedOut ? null : code,
+                    timed_out: timedOut,
                     duration_ms: Date.now() - startedAt,
                     stderr_truncated: err.truncated,
                     stdout_truncated: out.truncated,
@@ -1596,11 +2174,7 @@ export class CodeToolExecutor {
         const result = routifyWebFetchEnabled()
             ? await executeRoutifyWebFetch(url, format, { signal: this.signal })
             : await this.pageReader.readFormatted(url, format);
-        return {
-            status: "success",
-            title: String(result.title || "No Title Found"),
-            content: String(result.content || ""),
-        };
+        return boundedWebFetchResult(result);
     }
     async pexelsRequest(pathname, parameters) {
         const apiKey = process.env.PEXELS_API_KEY;
@@ -1639,7 +2213,7 @@ export class CodeToolExecutor {
             },
         });
     }
-    mapPexelsPhotos(payload) {
+    mapPexelsPhotos(payload, orientation) {
         const photos = Array.isArray(payload.photos) ? payload.photos : [];
         return photos.map((value) => {
             const photo = record(value);
@@ -1648,12 +2222,14 @@ export class CodeToolExecutor {
                 type: "image",
                 id: Number(photo.id),
                 pexelsUrl: stringValue(photo.url),
-                recommendedUrl: stringValue(source.large2x) ||
+                recommendedUrl: (orientation === "landscape" || orientation === "portrait"
+                    ? stringValue(source[orientation]) : "") ||
+                    stringValue(source.large2x) ||
                     stringValue(source.large) ||
                     stringValue(source.original),
-                thumbnailUrl: stringValue(source.medium) ||
-                    stringValue(source.small) ||
-                    stringValue(source.tiny),
+                thumbnailUrl: stringValue(source.tiny) ||
+                    stringValue(source.medium) ||
+                    stringValue(source.small),
                 width: Number(photo.width),
                 height: Number(photo.height),
                 creatorName: stringValue(photo.photographer),
@@ -1673,20 +2249,29 @@ export class CodeToolExecutor {
             const files = Array.isArray(video.video_files)
                 ? video.video_files.map(record)
                 : [];
-            const preferred = files.find((item) => stringValue(item.quality) === "hd") ||
-                files[0] ||
-                {};
+            // Captures contain full-resolution HD/UHD files. A quality label alone
+            // does not order renditions; compare their actual pixel dimensions.
+            const playable = files.filter((item) => stringValue(item.file_type) === "video/mp4" && stringValue(item.link));
+            const preferred = playable.sort((left, right) => (Number(right.width) || 0) * (Number(right.height) || 0) -
+                (Number(left.width) || 0) * (Number(left.height) || 0))[0] || files[0] || {};
             return {
                 type: "video",
                 id: Number(video.id),
                 pexelsUrl: stringValue(video.url),
                 recommendedUrl: stringValue(preferred.link),
-                thumbnailUrl: stringValue(pictures[0]?.picture),
+                thumbnailUrl: stringValue(video.image) || stringValue(pictures[0]?.picture),
                 width: Number(video.width),
                 height: Number(video.height),
                 duration: Number(video.duration),
                 creatorName: stringValue(user.name),
                 creatorUrl: stringValue(user.url),
+                videoFile: {
+                    url: stringValue(preferred.link),
+                    width: Number(preferred.width),
+                    height: Number(preferred.height),
+                    ...(preferred.quality !== undefined ? { quality: preferred.quality } : {}),
+                    fileType: stringValue(preferred.file_type),
+                },
             };
         });
     }
@@ -1704,7 +2289,7 @@ export class CodeToolExecutor {
         if (mediaType === "image" || mediaType === "both") {
             const photos = await this.pexelsRequest("/v1/search", common);
             totalResults += Number(photos.total_results || 0);
-            photoResults = this.mapPexelsPhotos(photos);
+            photoResults = this.mapPexelsPhotos(photos, orientation);
         }
         if (mediaType === "video" || mediaType === "both") {
             const videos = await this.pexelsRequest("/v1/videos/search", common);
@@ -1726,13 +2311,20 @@ export class CodeToolExecutor {
     }
     async fetchMedia(query, mediaType, count, orientation, size, locale) {
         const requestedCount = Math.min(10, Math.max(1, Math.trunc(count)));
-        return this.fetchMediaFromPexels(query, mediaType, requestedCount, orientation, size, locale);
+        try {
+            return await this.fetchMediaFromPexels(query, mediaType, requestedCount, orientation, size, locale);
+        }
+        catch (error) {
+            throw new Error(`Media fetch failed: ${errorMessage(error)}`);
+        }
     }
     async generateImage(rawPath, prompt, images) {
         if (this.generatedImageCount >= 10) {
             return {
                 status: "error",
-                message: "generate_image can be used at most 10 times per session",
+                message: this.config.mode === "react"
+                    ? "Failed to generate image: Image generation limit of 10 reached for this session. Use CSS gradients, SVG, or placeholder images for remaining visuals."
+                    : "generate_image can be used at most 10 times per session",
             };
         }
         this.generatedImageCount += 1;
@@ -1744,7 +2336,7 @@ export class CodeToolExecutor {
         mkdirSync(path.dirname(target), { recursive: true });
         const model = process.env.CODE_HARNESS_IMAGE_MODEL ||
             process.env.ARENA_IMAGE_MODEL ||
-            "gemini-2.5-flash-image";
+            "gpt-image-2.5-sunburst";
         const references = [];
         for (const imagePath of images || []) {
             const source = await this.confinedPath(imagePath);