veryfront 0.1.337 → 0.1.339

package/src/deps/esm.sh/@types/{react@19.2.14 → react@19.2.3}/index.d.ts

@@ -16,7 +16,6 @@ type NativeKeyboardEvent = KeyboardEvent;
 type NativeMouseEvent = MouseEvent;
 type NativeTouchEvent = TouchEvent;
 type NativePointerEvent = PointerEvent;
-type NativeSubmitEvent = SubmitEvent;
 type NativeToggleEvent = ToggleEvent;
 type NativeTransitionEvent = TransitionEvent;
 type NativeUIEvent = UIEvent;
@@ -226,20 +225,12 @@ declare namespace React {
 
     type ComponentState = any;
 
-    interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES {}
-
     /**
      * A value which uniquely identifies a node among items in an array.
      *
      * @see {@link https://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key React Docs}
      */
-    type Key =
-        | string
-        | number
-        | bigint
-        | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES[
-            keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES
-        ];
+    type Key = string | number | bigint;
 
     /**
      * @internal The props any component can receive.
@@ -1893,7 +1884,7 @@ declare namespace React {
      *
      * @param callback A synchronous, void callback that will execute as a single, complete React commit.
      *
-     * @see {@link https://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks}
+     * @see https://reactjs.org/blog/2019/02/06/react-v16.8.0.html#testing-hooks
      */
     // NOTES
     // - the order of these signatures matters - typescript will check the signatures in source order.
@@ -1935,31 +1926,7 @@ declare namespace React {
         reducer: (state: State, action: Action) => State,
     ): [State, (action: Action) => void];
 
-    interface UntrackedReactPromise<T> extends PromiseLike<T> {
-        status?: void;
-    }
-
-    export interface PendingReactPromise<T> extends PromiseLike<T> {
-        status: "pending";
-    }
-
-    export interface FulfilledReactPromise<T> extends PromiseLike<T> {
-        status: "fulfilled";
-        value: T;
-    }
-
-    export interface RejectedReactPromise<T> extends PromiseLike<T> {
-        status: "rejected";
-        reason: unknown;
-    }
-
-    export type ReactPromise<T> =
-        | UntrackedReactPromise<T>
-        | PendingReactPromise<T>
-        | FulfilledReactPromise<T>
-        | RejectedReactPromise<T>;
-
-    export type Usable<T> = ReactPromise<T> | Context<T>;
+    export type Usable<T> = PromiseLike<T> | Context<T>;
 
     export function use<T>(usable: Usable<T>): T;
 
@@ -2074,28 +2041,15 @@ declare namespace React {
         target: EventTarget & Target;
     }
 
-    /**
-     * @deprecated FormEvent doesn't actually exist.
-     *             You probably meant to use {@link ChangeEvent}, {@link InputEvent}, {@link SubmitEvent}, or just {@link SyntheticEvent} instead
-     *             depending on the event type.
-     */
     interface FormEvent<T = Element> extends SyntheticEvent<T> {
     }
 
     interface InvalidEvent<T = Element> extends SyntheticEvent<T> {
+        target: EventTarget & T;
     }
 
-    /**
-     * change events bubble in React so their target is generally unknown.
-     * Only for form elements we know their target type because form events can't
-     * be nested.
-     * This type exists purely to narrow `target` for form elements. It doesn't
-     * reflect a DOM event. Change events are just fired as standard {@link SyntheticEvent}.
-     */
-    interface ChangeEvent<CurrentTarget = Element, Target = Element> extends SyntheticEvent<CurrentTarget> {
-        // TODO: This is wrong for change event handlers on arbitrary. Should
-        // be EventTarget & Target, but kept for backward compatibility until React 20.
-        target: EventTarget & CurrentTarget;
+    interface ChangeEvent<T = Element> extends SyntheticEvent<T> {
+        target: EventTarget & T;
     }
 
     interface InputEvent<T = Element> extends SyntheticEvent<T, NativeInputEvent> {
@@ -2165,13 +2119,6 @@ declare namespace React {
         shiftKey: boolean;
     }
 
-    interface SubmitEvent<T = Element> extends SyntheticEvent<T, NativeSubmitEvent> {
-        // `submitter` is available in react@canary
-        // submitter: HTMLElement | null;
-        // SubmitEvents are always targetted at HTMLFormElements.
-        target: EventTarget & HTMLFormElement;
-    }
-
     interface TouchEvent<T = Element> extends UIEvent<T, NativeTouchEvent> {
         altKey: boolean;
         changedTouches: TouchList;
@@ -2227,19 +2174,11 @@ declare namespace React {
     type CompositionEventHandler<T = Element> = EventHandler<CompositionEvent<T>>;
     type DragEventHandler<T = Element> = EventHandler<DragEvent<T>>;
     type FocusEventHandler<T = Element> = EventHandler<FocusEvent<T>>;
-    /**
-     * @deprecated FormEventHandler doesn't actually exist.
-     *             You probably meant to use {@link ChangeEventHandler}, {@link InputEventHandler}, {@link SubmitEventHandler}, or just {@link EventHandler} instead
-     *             depending on the event type.
-     */
     type FormEventHandler<T = Element> = EventHandler<FormEvent<T>>;
-    type ChangeEventHandler<CurrentTarget = Element, Target = Element> = EventHandler<
-        ChangeEvent<CurrentTarget, Target>
-    >;
+    type ChangeEventHandler<T = Element> = EventHandler<ChangeEvent<T>>;
     type InputEventHandler<T = Element> = EventHandler<InputEvent<T>>;
     type KeyboardEventHandler<T = Element> = EventHandler<KeyboardEvent<T>>;
     type MouseEventHandler<T = Element> = EventHandler<MouseEvent<T>>;
-    type SubmitEventHandler<T = Element> = EventHandler<SubmitEvent<T>>;
     type TouchEventHandler<T = Element> = EventHandler<TouchEvent<T>>;
     type PointerEventHandler<T = Element> = EventHandler<PointerEvent<T>>;
     type UIEventHandler<T = Element> = EventHandler<UIEvent<T>>;
@@ -2293,19 +2232,19 @@ declare namespace React {
         onBlur?: FocusEventHandler<T> | undefined;
         onBlurCapture?: FocusEventHandler<T> | undefined;
 
-        // form related Events
-        onChange?: ChangeEventHandler<T> | undefined;
-        onChangeCapture?: ChangeEventHandler<T> | undefined;
+        // Form Events
+        onChange?: FormEventHandler<T> | undefined;
+        onChangeCapture?: FormEventHandler<T> | undefined;
         onBeforeInput?: InputEventHandler<T> | undefined;
-        onBeforeInputCapture?: InputEventHandler<T> | undefined;
-        onInput?: InputEventHandler<T> | undefined;
-        onInputCapture?: InputEventHandler<T> | undefined;
-        onReset?: ReactEventHandler<T> | undefined;
-        onResetCapture?: ReactEventHandler<T> | undefined;
-        onSubmit?: SubmitEventHandler<T> | undefined;
-        onSubmitCapture?: SubmitEventHandler<T> | undefined;
-        onInvalid?: ReactEventHandler<T> | undefined;
-        onInvalidCapture?: ReactEventHandler<T> | undefined;
+        onBeforeInputCapture?: FormEventHandler<T> | undefined;
+        onInput?: FormEventHandler<T> | undefined;
+        onInputCapture?: FormEventHandler<T> | undefined;
+        onReset?: FormEventHandler<T> | undefined;
+        onResetCapture?: FormEventHandler<T> | undefined;
+        onSubmit?: FormEventHandler<T> | undefined;
+        onSubmitCapture?: FormEventHandler<T> | undefined;
+        onInvalid?: FormEventHandler<T> | undefined;
+        onInvalidCapture?: FormEventHandler<T> | undefined;
 
         // Image Events
         onLoad?: ReactEventHandler<T> | undefined;
@@ -2849,7 +2788,7 @@ declare namespace React {
 
         // Living Standard
         /**
-         * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert}
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert
          */
         inert?: boolean | undefined;
         /**
@@ -3312,9 +3251,7 @@ declare namespace React {
         value?: string | readonly string[] | number | undefined;
         width?: number | string | undefined;
 
-        // No other element dispatching change events can be nested in a <input>
-        // so we know the target will be a HTMLInputElement.
-        onChange?: ChangeEventHandler<T, HTMLInputElement> | undefined;
+        onChange?: ChangeEventHandler<T> | undefined;
     }
 
     interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3479,9 +3416,7 @@ declare namespace React {
         required?: boolean | undefined;
         size?: number | undefined;
         value?: string | readonly string[] | number | undefined;
-        // No other element dispatching change events can be nested in a <select>
-        // so we know the target will be a HTMLSelectElement.
-        onChange?: ChangeEventHandler<T, HTMLSelectElement> | undefined;
+        onChange?: ChangeEventHandler<T> | undefined;
     }
 
     interface SourceHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3533,9 +3468,7 @@ declare namespace React {
         value?: string | readonly string[] | number | undefined;
         wrap?: string | undefined;
 
-        // No other element dispatching change events can be nested in a <textarea>
-        // so we know the target will be a HTMLTextAreaElement.
-        onChange?: ChangeEventHandler<T, HTMLTextAreaElement> | undefined;
+        onChange?: ChangeEventHandler<T> | undefined;
     }
 
     interface TdHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -3607,9 +3540,6 @@ declare namespace React {
         method?: string | undefined;
         min?: number | string | undefined;
         name?: string | undefined;
-        nonce?: string | undefined;
-        part?: string | undefined;
-        slot?: string | undefined;
         style?: CSSProperties | undefined;
         target?: string | undefined;
         type?: string | undefined;
@@ -4127,6 +4057,7 @@ declare namespace React {
          * Captures which component contained the exception, and its ancestors.
          */
         componentStack?: string | null;
+        digest?: string | null;
     }
 
     // Keep in sync with JSX namespace in ./jsx-runtime.d.ts and ./jsx-dev-runtime.d.ts

package/src/deps/esm.sh/react-dom@19.2.4/client.d.ts

@@ -4,7 +4,7 @@
 
 // See https://github.com/facebook/react/blob/main/packages/react-dom/client.js to see how the exports are declared,
 
-import React = require("https://esm.sh/@types/react@19.2.14/index.d.ts");
+import React = require("https://esm.sh/@types/react@19.2.3/index.d.ts");
 
 export {};
 

package/src/src/agent/default-research-artifact-policy.ts

@@ -0,0 +1,146 @@
+const RESEARCH_TASK_CUE_PATTERN = /\b(research|report|findings|sources|authoritative sources)\b/i;
+const RESEARCH_PROJECT_SAVE_CUE_PATTERN =
+  /\b(?:save|write|persist|store|compile)\b[^\n]{0,120}\b(?:to|into)\b[^\n]{0,40}\b(?:the\s+)?project\b/i;
+
+const PROJECT_ARTIFACT_PATH_PATTERN = /(?:\/|\.{1,2}\/)?(?:[\w.-]+\/)+[\w.-]+\.[\w.-]+/g;
+
+function slugifyArtifactSegment(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/['"]/g, "")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function slugifyRunArtifactSegment(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function hasAnyArtifactPath(prompt: string): boolean {
+  PROJECT_ARTIFACT_PATH_PATTERN.lastIndex = 0;
+  return PROJECT_ARTIFACT_PATH_PATTERN.test(prompt);
+}
+
+function isGenericResearchTopic(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  return normalized.length === 0 ||
+    normalized === "this" ||
+    normalized === "that" ||
+    normalized === "it" ||
+    normalized === "the project" ||
+    normalized === "the topic";
+}
+
+function extractResearchTopic(input: { description: string; prompt: string }): string | null {
+  const quotedPromptTopic = input.prompt.match(/\bresearch(?:\s+on|\s+about)?\s+["“]([^"”]+)["”]/i)
+    ?.[1];
+  if (quotedPromptTopic?.trim() && !isGenericResearchTopic(quotedPromptTopic)) {
+    return quotedPromptTopic.trim();
+  }
+
+  const cleanedDescription = input.description
+    .replace(/^research\s+/i, "")
+    .replace(/\.\s+.*$/s, "")
+    .replace(/\s+and\s+(?:save|write|persist|store|compile)\b.*$/i, "")
+    .replace(/\s+across\b.*$/i, "")
+    .trim();
+  if (cleanedDescription.length > 0) {
+    return cleanedDescription;
+  }
+
+  const promptTopic = input.prompt
+    .match(/\bresearch(?:\s+on|\s+about)?\s+([^\n.,:]+)/i)?.[1]
+    ?.replace(/\s+and\s+save\b.*$/i, "")
+    ?.replace(/\s+and\s+write\b.*$/i, "")
+    ?.trim();
+  if (!promptTopic || isGenericResearchTopic(promptTopic)) {
+    return null;
+  }
+
+  return promptTopic;
+}
+
+export interface DefaultResearchArtifactPaths {
+  topicSlug: string;
+  topicRootPath: string;
+  currentReportPath: string;
+  runReportPath: string;
+  findingsPath: string;
+  sourcesPath: string;
+}
+
+export function shouldInjectDefaultResearchArtifactPath(input: {
+  description: string;
+  prompt: string;
+}): boolean {
+  if (
+    !RESEARCH_TASK_CUE_PATTERN.test(input.description) &&
+    !RESEARCH_TASK_CUE_PATTERN.test(input.prompt)
+  ) {
+    return false;
+  }
+
+  if (!RESEARCH_PROJECT_SAVE_CUE_PATTERN.test(input.prompt)) {
+    return false;
+  }
+
+  return !hasAnyArtifactPath(input.prompt);
+}
+
+export function buildDefaultResearchArtifactPathReminder(input: {
+  description: string;
+  prompt: string;
+  runId?: string;
+}): string | null {
+  if (!shouldInjectDefaultResearchArtifactPath(input)) {
+    return null;
+  }
+
+  const artifactPaths = buildDefaultResearchArtifactPaths(input);
+
+  return [
+    "Default research workspace (because no exact artifact path was provided):",
+    `- Write the run-scoped report to exactly ${artifactPaths.runReportPath}.`,
+    `- Then create or update the current topic report at exactly ${artifactPaths.currentReportPath}.`,
+    `- Supporting artifacts can live at ${artifactPaths.findingsPath} and ${artifactPaths.sourcesPath} when useful.`,
+    `CRITICAL: The task is incomplete until ${artifactPaths.runReportPath} and ${artifactPaths.currentReportPath} both exist with the final report content.`,
+    "Use create_file or update_file yourself before finishing.",
+  ].join("\n");
+}
+
+export function buildDefaultResearchArtifactPaths(input: {
+  description: string;
+  prompt: string;
+  runId?: string;
+}): DefaultResearchArtifactPaths {
+  const topic = extractResearchTopic(input);
+  const topicSlug = topic ? slugifyArtifactSegment(topic) : "research-report";
+  const sanitizedRunId = slugifyRunArtifactSegment(input.runId ?? "");
+  const effectiveRunId = sanitizedRunId.length > 0 ? sanitizedRunId : "latest";
+  const topicRootPath = `/research/${topicSlug}`;
+
+  return {
+    topicSlug,
+    topicRootPath,
+    currentReportPath: `${topicRootPath}/report.md`,
+    runReportPath: `${topicRootPath}/runs/${effectiveRunId}.report.md`,
+    findingsPath: `${topicRootPath}/findings.md`,
+    sourcesPath: `${topicRootPath}/sources.md`,
+  };
+}
+
+export function withDefaultResearchArtifactPath(input: {
+  description: string;
+  prompt: string;
+  runId?: string;
+}): string {
+  const reminder = buildDefaultResearchArtifactPathReminder(input);
+  if (!reminder) {
+    return input.prompt;
+  }
+
+  return [input.prompt, "", reminder].join("\n");
+}

package/src/src/agent/default-research-artifact-support.ts

@@ -0,0 +1,289 @@
+import type { ChatSystemMessage } from "../chat/types.js";
+import { isHostedChildCreateFileAlreadyExistsResult } from "./hosted-child-artifact-support.js";
+import {
+  buildDefaultResearchArtifactPathReminder,
+  buildDefaultResearchArtifactPaths,
+  type DefaultResearchArtifactPaths,
+} from "./default-research-artifact-policy.js";
+
+export type DefaultResearchArtifacts = DefaultResearchArtifactPaths;
+
+export interface DefaultResearchArtifactContext {
+  availableToolNames?: string[];
+  parentRunId?: string;
+  defaultResearchArtifacts?: DefaultResearchArtifacts | null;
+}
+
+export interface DefaultResearchArtifactLogger {
+  debug?: (message: string, metadata?: Record<string, unknown>) => void;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function extractLatestUserText(messages: readonly unknown[]): string | null {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!isRecord(message) || message.role !== "user") {
+      continue;
+    }
+
+    const content = message.content;
+    if (typeof content === "string" && content.trim().length > 0) {
+      return content;
+    }
+
+    if (!Array.isArray(content)) {
+      continue;
+    }
+
+    const text = content
+      .flatMap((part) =>
+        isRecord(part) && part.type === "text" && typeof part.text === "string"
+          ? [part.text.trim()]
+          : []
+      )
+      .filter((value) => value.length > 0)
+      .join("\n");
+
+    if (text.length > 0) {
+      return text;
+    }
+  }
+
+  return null;
+}
+
+function extractLatestUserDescription(text: string): string {
+  const withoutCommandSpan = text.replace(
+    /<span\s+data-command="[^"]+">\s*(\/[a-z0-9_-]+)\s*<\/span>/gi,
+    "$1",
+  );
+  const withoutLeadingSlashCommand = withoutCommandSpan.replace(/^\s*\/[a-z0-9_-]+\s*/i, "");
+
+  return withoutLeadingSlashCommand.trim();
+}
+
+export async function fetchLatestConversationUserText(input: {
+  apiUrl: string;
+  authToken: string;
+  conversationId?: string;
+  logger?: DefaultResearchArtifactLogger;
+}): Promise<string | null> {
+  if (!input.conversationId) {
+    return null;
+  }
+
+  try {
+    const response = await fetch(
+      `${input.apiUrl}/conversations/${input.conversationId}/messages?limit=20`,
+      {
+        headers: {
+          Authorization: `Bearer ${input.authToken}`,
+        },
+      },
+    );
+
+    if (!response.ok) {
+      input.logger?.debug?.(
+        "Could not preload conversation messages for research workspace detection",
+        {
+          conversationId: input.conversationId,
+          status: response.status,
+        },
+      );
+      return null;
+    }
+
+    const payload = await response.json();
+    const data = isRecord(payload) ? payload.data : undefined;
+    const messages = Array.isArray(data)
+      ? data.map((message) => ({
+        role: isRecord(message) ? message.role : undefined,
+        content: isRecord(message) && Array.isArray(message.parts) ? message.parts : [],
+      }))
+      : [];
+
+    return extractLatestUserText(messages);
+  } catch (error) {
+    input.logger?.debug?.(
+      "Failed to preload conversation messages for research workspace detection",
+      {
+        conversationId: input.conversationId,
+        error,
+      },
+    );
+    return null;
+  }
+}
+
+export function updateDefaultResearchArtifacts(input: {
+  taskContext: DefaultResearchArtifactContext;
+  latestUserText: string | null;
+  system: string | ChatSystemMessage[];
+}): string | ChatSystemMessage[] {
+  if (!input.latestUserText) {
+    return input.system;
+  }
+
+  const latestUserDescription = extractLatestUserDescription(input.latestUserText);
+  const defaultResearchWorkspaceReminder = buildDefaultResearchArtifactPathReminder({
+    description: latestUserDescription,
+    prompt: input.latestUserText,
+    runId: input.taskContext.parentRunId,
+  });
+
+  if (!defaultResearchWorkspaceReminder) {
+    input.taskContext.defaultResearchArtifacts = null;
+    return input.system;
+  }
+
+  input.taskContext.defaultResearchArtifacts = buildDefaultResearchArtifactPaths({
+    description: latestUserDescription,
+    prompt: input.latestUserText,
+    runId: input.taskContext.parentRunId,
+  });
+
+  return appendSystemReminder(input.system, defaultResearchWorkspaceReminder);
+}
+
+function appendSystemReminder(
+  instructions: string | ChatSystemMessage[],
+  reminder: string,
+): string | ChatSystemMessage[] {
+  if (typeof instructions === "string") {
+    return instructions.includes(reminder) ? instructions : `${instructions}\n\n${reminder}`;
+  }
+
+  if (instructions.some((message) => message.content.includes(reminder))) {
+    return instructions;
+  }
+
+  return [
+    ...instructions,
+    {
+      role: "system",
+      content: reminder,
+    },
+  ];
+}
+
+export function applyDefaultResearchArtifactPath(
+  toolName: string,
+  toolInput: Record<string, unknown>,
+  taskContext: DefaultResearchArtifactContext,
+): Record<string, unknown> {
+  const defaultArtifacts = taskContext.defaultResearchArtifacts;
+  if (!defaultArtifacts || (toolName !== "create_file" && toolName !== "update_file")) {
+    return toolInput;
+  }
+
+  const path = typeof toolInput.path === "string" ? toolInput.path.replace(/^\/+/, "") : null;
+  if (!path) {
+    return toolInput;
+  }
+
+  const canonicalCurrentPath = defaultArtifacts.currentReportPath.replace(/^\/+/, "");
+  const canonicalRunPath = defaultArtifacts.runReportPath.replace(/^\/+/, "");
+  const canonicalFindingsPath = defaultArtifacts.findingsPath.replace(/^\/+/, "");
+  const canonicalSourcesPath = defaultArtifacts.sourcesPath.replace(/^\/+/, "");
+
+  if (
+    path === canonicalCurrentPath || path === canonicalRunPath || path === canonicalFindingsPath ||
+    path === canonicalSourcesPath
+  ) {
+    return toolInput;
+  }
+
+  if (!path.endsWith("/report.md") && path !== "report.md") {
+    return toolInput;
+  }
+
+  return {
+    ...toolInput,
+    path: canonicalCurrentPath,
+  };
+}
+
+export function shouldRetryCreateResearchArtifactAsUpdate(input: {
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  taskContext: DefaultResearchArtifactContext;
+  error: unknown;
+}): boolean {
+  if (input.toolName !== "create_file") {
+    return false;
+  }
+
+  const defaultArtifacts = input.taskContext.defaultResearchArtifacts;
+  if (!isHostedChildCreateFileAlreadyExistsResult(input.error)) {
+    return false;
+  }
+
+  const path = typeof input.toolInput.path === "string"
+    ? input.toolInput.path.replace(/^\/+/, "")
+    : null;
+  const content = typeof input.toolInput.content === "string" ? input.toolInput.content : null;
+  if (!path || !content) {
+    return false;
+  }
+
+  if (!defaultArtifacts) {
+    return path.startsWith("research/") && path.endsWith(".md");
+  }
+
+  const topicRootPath = defaultArtifacts.currentReportPath.replace(/^\/+/, "").replace(
+    /\/report\.md$/,
+    "",
+  );
+  return path === topicRootPath || path.startsWith(`${topicRootPath}/`);
+}
+
+export async function mirrorDefaultResearchRunArtifact(input: {
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  taskContext: DefaultResearchArtifactContext;
+  activeProjectId: string | null;
+  executeContext: Record<string, unknown> | undefined;
+  executeTool: (
+    toolName: string,
+    args: Record<string, unknown>,
+    context: Record<string, unknown> | undefined,
+  ) => Promise<unknown>;
+}): Promise<void> {
+  const defaultArtifacts = input.taskContext.defaultResearchArtifacts;
+  if (!defaultArtifacts || (input.toolName !== "create_file" && input.toolName !== "update_file")) {
+    return;
+  }
+
+  const content = typeof input.toolInput.content === "string" ? input.toolInput.content : null;
+  const path = typeof input.toolInput.path === "string"
+    ? input.toolInput.path.replace(/^\/+/, "")
+    : null;
+  const canonicalCurrentPath = defaultArtifacts.currentReportPath.replace(/^\/+/, "");
+  const canonicalRunPath = defaultArtifacts.runReportPath.replace(/^\/+/, "");
+
+  if (!content || path !== canonicalCurrentPath) {
+    return;
+  }
+
+  const mirroredInput: Record<string, unknown> = {
+    ...input.toolInput,
+    path: canonicalRunPath,
+  };
+
+  if (input.activeProjectId) {
+    mirroredInput.project_reference = input.activeProjectId;
+  }
+
+  try {
+    await input.executeTool(input.toolName, mirroredInput, input.executeContext);
+  } catch (error) {
+    if (input.toolName === "create_file" && isHostedChildCreateFileAlreadyExistsResult(error)) {
+      await input.executeTool("update_file", mirroredInput, input.executeContext);
+      return;
+    }
+    throw error;
+  }
+}