@cydm/pie 1.0.7 → 1.0.9

package/dist/chunks/{chunk-BHNULR7U.js → chunk-EJGQAAKS.js}

@@ -259,7 +259,7 @@ function appendFileOperationsToSummary(summary, messages) {
 }
 function isSyntheticUserEnvelope(text) {
   const trimmed = text.trimStart();
-  return trimmed.startsWith("<environment_context>") || trimmed.startsWith("<turn_aborted>") || trimmed.startsWith("# AGENTS.md instructions");
+  return trimmed.startsWith("<environment_context>") || trimmed.startsWith("<turn_aborted>") || trimmed.startsWith("# AGENTS.md instructions") || trimmed.startsWith("## Project Context\nProject-specific instructions from AGENTS.md");
 }
 function isCompactionCompatibleMessage(message) {
   if (message.role === "user") return true;
@@ -1791,6 +1791,11 @@ var AgentSessionController = class {
       }
       return;
     }
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage?.role === "assistant" && (lastMessage.stopReason === "error" || lastMessage.stopReason === "aborted")) {
+      this.emit({ type: "auto_continue_skipped", reason: "last_turn_failed" });
+      return;
+    }
     const result = await this.getAutoContinueMessage({
       agent: this.agent,
       sessionManager: this.sessionManager,
@@ -1935,133 +1940,41 @@ async function requestInteraction(request) {
   return await currentInteractionHandler(request);
 }
 
-// ../../packages/agent-framework/src/knowledge-index.ts
-function parseFrontmatterBlock(yaml) {
-  const result = {};
-  const lines = yaml.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const colonIndex = trimmed.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = trimmed.slice(0, colonIndex).trim();
-    let value = trimmed.slice(colonIndex + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    switch (key) {
-      case "title":
-        result.title = value;
-        break;
-      case "desc":
-      case "description":
-        result.description = value;
-        break;
-    }
-  }
-  return result;
+// ../../packages/agent-framework/src/context-files.ts
+var AGENTS_CONTEXT_FILE_NAME = "AGENTS.md";
+function normalizeContextPath(path3) {
+  return String(path3 || "").replace(/\\/g, "/").replace(/^\/+/, "").trim() || AGENTS_CONTEXT_FILE_NAME;
 }
-function stripFrontmatter(content) {
-  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
-  if (!match) {
-    return { metadata: {}, body: content };
-  }
-  return {
-    metadata: parseFrontmatterBlock(match[1]),
-    body: content.slice(match[0].length)
-  };
+function normalizeContextContent(content) {
+  return String(content || "").replace(/\r\n/g, "\n").trim();
 }
-function extractHeadings(body, maxLevel = 3) {
-  const headings = [];
-  const lines = body.split("\n");
-  for (const rawLine of lines) {
-    const line = rawLine.trim();
-    const match = line.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
-    if (!match) continue;
-    const level = match[1].length;
-    if (level > maxLevel) continue;
-    headings.push({ level, text: match[2].trim() });
-  }
-  return headings;
-}
-function extractTitle(metadata, headings) {
-  if (metadata.title && metadata.title.trim()) return metadata.title.trim();
-  const firstHeading = headings.find((heading) => heading.level === 1) || headings[0];
-  return firstHeading?.text?.trim() || "";
-}
-function extractDescription(metadata, body) {
-  const explicit = metadata.description;
-  if (explicit && explicit.trim()) {
-    return explicit.trim();
-  }
-  const lines = body.split("\n");
-  for (const rawLine of lines.slice(0, 24)) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    const descriptionMatch = line.match(/^description:\s*(.+)$/i);
-    if (descriptionMatch) {
-      return descriptionMatch[1].trim();
-    }
-  }
-  let seenHeading = false;
-  let paragraphLines = [];
-  for (const rawLine of body.split("\n")) {
-    const line = rawLine.trim();
-    if (!line) {
-      if (seenHeading && paragraphLines.length > 0) {
-        break;
-      }
-      continue;
-    }
-    if (/^#{1,6}\s+/.test(line)) {
-      if (seenHeading && paragraphLines.length > 0) {
-        break;
-      }
-      seenHeading = true;
-      continue;
-    }
-    if (!seenHeading) {
-      continue;
-    }
-    if (/^description:\s*/i.test(line)) {
+function dedupeProjectContextFiles(files) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const file of files) {
+    const path3 = normalizeContextPath(file.path);
+    const key = path3.toLowerCase();
+    const content = normalizeContextContent(file.content);
+    if (!content || seen.has(key)) {
       continue;
     }
-    paragraphLines.push(line);
-  }
-  if (paragraphLines.length > 0) {
-    return paragraphLines.join(" ").trim();
+    seen.add(key);
+    result.push({ path: path3, content });
   }
-  return "";
-}
-function buildKnowledgeIndexEntry(path3, content) {
-  const trimmed = String(content || "").trim();
-  if (!trimmed) return null;
-  const { metadata, body } = stripFrontmatter(trimmed);
-  const headings = extractHeadings(body, 3);
-  const title = extractTitle(metadata, headings);
-  const description = extractDescription(metadata, body);
-  return {
-    path: path3,
-    title,
-    description,
-    headings
-  };
-}
-function formatHeadings(headings) {
-  if (headings.length === 0) return "(none)";
-  return headings.map((heading) => `${"#".repeat(heading.level)} ${heading.text}`).join(" | ");
+  return result;
 }
-function buildKnowledgeIndexSection(entries, heading = "Project Knowledge Index") {
-  const filtered = entries.filter((entry) => entry && (entry.title || entry.description || entry.headings.length > 0));
-  if (filtered.length === 0) return "";
-  const lines = [`[${heading}]`];
-  for (const entry of filtered) {
-    lines.push(`- path: ${entry.path}`);
-    if (entry.title) lines.push(`  title: ${entry.title}`);
-    if (entry.description) lines.push(`  description: ${entry.description}`);
-    lines.push(`  headings: ${formatHeadings(entry.headings)}`);
+function buildProjectContextSection(files, options = {}) {
+  const contextFiles = dedupeProjectContextFiles(files);
+  if (contextFiles.length === 0) {
+    return "";
   }
-  return lines.join("\n");
+  const heading = options.heading?.trim() || "Project Context";
+  const intro = options.intro?.trim() || "Project-specific instructions from AGENTS.md files. Apply them in order; later files may add narrower instructions.";
+  const lines = [`## ${heading}`, intro, ""];
+  for (const file of contextFiles) {
+    lines.push(`### ${file.path}`, file.content, "");
+  }
+  return lines.join("\n").trimEnd();
 }
 
 // ../../packages/shared-headless-capabilities/src/loop.ts
@@ -2124,7 +2037,7 @@ function restoreLoopState(raw) {
   if (!raw || typeof raw !== "object") return null;
   const value = raw;
   if (value.mode !== "todo_closure") return null;
-  const status = value.status === "active" || value.status === "completed" || value.status === "aborted" || value.status === "failed" || value.status === "stalled" ? value.status : "active";
+  const status = value.status === "active" || value.status === "paused" || value.status === "completed" || value.status === "aborted" || value.status === "failed" || value.status === "stalled" ? value.status : "active";
   return {
     goal: typeof value.goal === "string" && value.goal.trim().length > 0 ? value.goal : "Drive the active todo list to a terminal cleared state.",
     mode: "todo_closure",
@@ -2196,8 +2109,8 @@ function evaluateTodoClosureAfterFailedTurn(loop) {
     return { loop, action: "none", reason: "already_terminal" };
   }
   return {
-    loop: { ...loop, status: "failed", updatedAt: nowIso() },
-    action: "clear_failed",
+    loop: { ...loop, status: "paused", updatedAt: nowIso() },
+    action: "pause_failed",
     reason: "failed_turn"
   };
 }
@@ -2256,6 +2169,16 @@ function inferLastCompletedStepId(steps) {
   const completed = [...steps].reverse().find((step) => step.status === "completed");
   return completed?.id ?? null;
 }
+function createRestoredTodoLoop(state, lifecycle, restoredLoop) {
+  if (state.mode !== "todo" || lifecycle !== "active" && lifecycle !== "paused" || state.steps.length === 0) {
+    return null;
+  }
+  if (restoredLoop) {
+    return restoredLoop;
+  }
+  const loop = createTodoClosureLoop({ ...state, lifecycle: "active" });
+  return lifecycle === "paused" && loop ? { ...loop, status: "paused" } : loop;
+}
 function createEmptyExecutionState() {
   return {
     mode: "idle",
@@ -2282,7 +2205,7 @@ function restoreExecutionState(raw) {
   }
   const state = raw;
   const steps = normalizeSteps(state.steps || []);
-  const lifecycle = steps.length === 0 ? "stale" : state.lifecycle === "active" || state.lifecycle === "aborted" || state.lifecycle === "completed" || state.lifecycle === "stale" || state.lifecycle === "stalled" ? state.lifecycle : "active";
+  const lifecycle = steps.length === 0 ? "stale" : state.lifecycle === "active" || state.lifecycle === "paused" || state.lifecycle === "aborted" || state.lifecycle === "completed" || state.lifecycle === "stale" || state.lifecycle === "stalled" ? state.lifecycle : "active";
   const mode = state.mode === "todo" || state.mode === "plan" || state.mode === "idle" ? state.mode : steps.length > 0 ? "todo" : "idle";
   const loop = restoreLoopState(state.loop);
   return {
@@ -2292,7 +2215,7 @@ function restoreExecutionState(raw) {
     currentStepId: typeof state.currentStepId === "number" ? state.currentStepId : inferCurrentStepId(steps),
     lastCompletedStepId: typeof state.lastCompletedStepId === "number" ? state.lastCompletedStepId : inferLastCompletedStepId(steps),
     source: state.source === "user_todo" || state.source === "plan_mode" || state.source === "system_auto" ? state.source : "system_auto",
-    loop: mode === "todo" && lifecycle === "active" && steps.length > 0 ? loop ?? createTodoClosureLoop({
+    loop: createRestoredTodoLoop({
       mode,
       lifecycle,
       steps,
@@ -2303,7 +2226,7 @@ function restoreExecutionState(raw) {
       awaitingContinuation: Boolean(state.awaitingContinuation),
       failureSummary: typeof state.failureSummary === "string" ? state.failureSummary : null,
       updatedAt: typeof state.updatedAt === "string" && state.updatedAt.length > 0 ? state.updatedAt : nowIso2()
-    }) : null,
+    }, lifecycle, loop),
     awaitingContinuation: Boolean(state.awaitingContinuation),
     failureSummary: typeof state.failureSummary === "string" ? state.failureSummary : null,
     updatedAt: typeof state.updatedAt === "string" && state.updatedAt.length > 0 ? state.updatedAt : nowIso2()
@@ -2379,7 +2302,7 @@ function executionStateToTodos(state) {
   }));
 }
 function createTodoWidgetView(state) {
-  if (state.lifecycle !== "active" && state.lifecycle !== "aborted" && state.lifecycle !== "stalled") {
+  if (state.lifecycle !== "active" && state.lifecycle !== "paused" && state.lifecycle !== "aborted" && state.lifecycle !== "stalled") {
     return [];
   }
   return state.steps.map((step) => ({ ...step }));
@@ -2420,16 +2343,36 @@ function continueExecutionState(state) {
   if (state.steps.length === 0) {
     return createEmptyExecutionState();
   }
-  return restoreExecutionState({
+  const activeState = restoreExecutionState({
     ...state,
     lifecycle: "active",
     currentStepId: inferCurrentStepId(state.steps),
-    loop: state.mode === "todo" ? createTodoClosureLoop(state) : null,
+    loop: null,
+    awaitingContinuation: false,
+    failureSummary: null,
+    updatedAt: nowIso2()
+  });
+  return restoreExecutionState({
+    ...activeState,
+    loop: activeState.mode === "todo" ? createTodoClosureLoop(activeState) : null,
     awaitingContinuation: false,
     failureSummary: null,
     updatedAt: nowIso2()
   });
 }
+function pauseExecutionState(state, summary = null) {
+  if (state.steps.length === 0) {
+    return createEmptyExecutionState();
+  }
+  return restoreExecutionState({
+    ...state,
+    lifecycle: "paused",
+    loop: state.loop ? { ...state.loop, status: "paused" } : null,
+    awaitingContinuation: false,
+    failureSummary: summary,
+    updatedAt: nowIso2()
+  });
+}
 function supersedeExecutionState() {
   return createEmptyExecutionState();
 }
@@ -2453,13 +2396,11 @@ var BUILTIN_TOOL_CAPABILITY_METADATA = {
   write_file: { riskClass: "write", concurrencySafe: false, requiresPermission: true, permissionScope: "filesystem", writesFile: true, highRisk: true },
   edit_file: { riskClass: "write", concurrencySafe: false, requiresPermission: true, permissionScope: "filesystem", writesFile: true, highRisk: true },
   bash: { riskClass: "shell", concurrencySafe: false, requiresPermission: true, permissionScope: "shell", executesShell: true, availableInPlanMode: true, allowedForSubagentByDefault: true, highRisk: true, maxOutputChars: 1e5 },
+  web_research: { riskClass: "network", concurrencySafe: true, permissionScope: "network", readsNetwork: true, availableInPlanMode: true, allowedForSubagentByDefault: true, maxOutputChars: 1e5 },
   web_search: { riskClass: "network", concurrencySafe: true, permissionScope: "network", readsNetwork: true, availableInPlanMode: true, allowedForSubagentByDefault: true, maxOutputChars: 1e5 },
   web_fetch: { riskClass: "network", concurrencySafe: true, permissionScope: "network", readsNetwork: true, availableInPlanMode: true, allowedForSubagentByDefault: true, maxOutputChars: 1e5 },
   code_intel: { riskClass: "read_only", concurrencySafe: true, permissionScope: "filesystem", readsFile: true, availableInPlanMode: true, allowedForSubagentByDefault: true, maxOutputChars: 1e5 },
   spawn_subagents_parallel: { riskClass: "read_only", concurrencySafe: false, permissionScope: "host", readsHostResource: true, availableInPlanMode: true, maxOutputChars: 1e5 },
-  read_skill: { riskClass: "read_only", concurrencySafe: true, permissionScope: "host", readsHostResource: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
-  read_resource: { riskClass: "read_only", concurrencySafe: true, permissionScope: "host", readsHostResource: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
-  resolve_resource: { riskClass: "read_only", concurrencySafe: true, permissionScope: "host", readsHostResource: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
   ask_user_multi: { riskClass: "user_interaction", concurrencySafe: false, permissionScope: "user", asksUser: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
   manage_todo_list: { riskClass: "session_mutation", concurrencySafe: false, permissionScope: "session", mutatesSession: true, availableInPlanMode: true },
   unity_project_inspect: { riskClass: "read_only", concurrencySafe: true, permissionScope: "unity", readsHostResource: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
@@ -2468,9 +2409,7 @@ var BUILTIN_TOOL_CAPABILITY_METADATA = {
   unity_log_read: { riskClass: "read_only", concurrencySafe: true, permissionScope: "unity", readsHostResource: true, availableInPlanMode: true, allowedForSubagentByDefault: true, maxOutputChars: 1e5 },
   unity_scene_object_edit: { riskClass: "external_side_effect", concurrencySafe: false, requiresPermission: true, permissionScope: "unity", externalSideEffect: true, highRisk: true },
   unity_refresh: { riskClass: "external_side_effect", concurrencySafe: false, permissionScope: "unity", externalSideEffect: true },
-  unity_script_run: { riskClass: "external_side_effect", concurrencySafe: false, requiresPermission: true, permissionScope: "unity", externalSideEffect: true, highRisk: true },
-  read_project_memory: { riskClass: "read_only", concurrencySafe: true, permissionScope: "host", readsHostResource: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
-  write_project_memory: { riskClass: "write", concurrencySafe: false, requiresPermission: true, permissionScope: "host", writesHostResource: true, externalSideEffect: true, highRisk: true }
+  unity_script_run: { riskClass: "external_side_effect", concurrencySafe: false, requiresPermission: true, permissionScope: "unity", externalSideEffect: true, highRisk: true }
 };
 function getToolCapabilityMetadata(tool) {
   return tool.capabilityMetadata ?? tool.risk ?? BUILTIN_TOOL_CAPABILITY_METADATA[tool.name];
@@ -2622,268 +2561,6 @@ function createPlanCapability() {
   });
 }
 
-// ../../packages/shared-headless-capabilities/src/read-skill.ts
-var ReadSkillParamsSchema = Type.Object({
-  name: Type.String({ description: "Exact skill name from the available_skills list." })
-});
-function validateSkillNameArgument(name) {
-  if (name.includes("<|tool")) {
-    return "The skill name must be only an exact name from the available_skills list, not tool-call markup.";
-  }
-  if (name.includes("\n")) {
-    return "The skill name must be a single exact name from the available_skills list, not multi-line text.";
-  }
-  return null;
-}
-function formatSkillResources(resources) {
-  if (!Array.isArray(resources) || resources.length === 0) return "";
-  const lines = resources.map((resource) => {
-    const path3 = String(resource.path || "").trim();
-    const kind = String(resource.kind || "").trim();
-    return kind ? `- ${path3} (${kind})` : `- ${path3}`;
-  });
-  return `
-
-## Skill Resources
-${lines.join("\n")}`;
-}
-function createReadSkillCapability(deps) {
-  async function resolveSkill(name) {
-    if (deps.resolveSkill) {
-      return deps.resolveSkill(name);
-    }
-    const skill = deps.skillLoader?.getSkill?.(name) ?? deps.skillLoader?.loadSkill?.(name);
-    if (!skill) {
-      return null;
-    }
-    return {
-      name: skill.name,
-      content: skill.prompt,
-      resources: skill.resourceRefs
-    };
-  }
-  const tool = {
-    name: "read_skill",
-    label: "read_skill",
-    description: "Load the full contents of a skill by exact name from the available_skills list only. Do not pass tool names.",
-    parameters: ReadSkillParamsSchema,
-    async execute(toolCallIdOrArgs, maybeArgs) {
-      const args = typeof toolCallIdOrArgs === "string" ? maybeArgs : toolCallIdOrArgs;
-      const skillName = String(args?.name || "").trim();
-      const validationError = validateSkillNameArgument(skillName);
-      if (validationError) {
-        return {
-          content: [{ type: "text", text: `Invalid skill name: ${validationError}` }],
-          details: { found: false, name: skillName || void 0 },
-          isError: true
-        };
-      }
-      const skill = await resolveSkill(skillName);
-      if (!skill?.content) {
-        return {
-          content: [{ type: "text", text: `Skill not found: ${skillName || "(empty)"}` }],
-          details: { found: false, name: skillName || void 0 },
-          isError: true
-        };
-      }
-      return {
-        content: [{
-          type: "text",
-          text: `# ${skill.name}
-
-${skill.content}${formatSkillResources(skill.resources)}`
-        }],
-        details: {
-          found: true,
-          name: skill.name,
-          ...Array.isArray(skill.resources) ? { resources: skill.resources } : {}
-        }
-      };
-    }
-  };
-  return {
-    ...defineSharedCapability({
-      id: "read-skill",
-      description: "Shared capability for loading full skill contents through a host-provided skill resolver.",
-      tools: [tool]
-    }),
-    tool
-  };
-}
-
-// ../../packages/shared-headless-capabilities/src/read-resource.ts
-var ReadResourceParamsSchema = Type.Object({
-  owner: Type.String({ description: "Exact skill name that owns the resource." }),
-  path: Type.String({ description: "Relative path inside the skill package." })
-});
-function inferKind(path3) {
-  const lower = path3.toLowerCase();
-  if (lower.endsWith(".md")) return "document";
-  if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".sh") || lower.endsWith(".py")) return "script";
-  return void 0;
-}
-function inferMimeType(path3) {
-  const lower = path3.toLowerCase();
-  if (lower.endsWith(".md")) return "text/markdown";
-  if (lower.endsWith(".js") || lower.endsWith(".mjs")) return "application/javascript";
-  if (lower.endsWith(".sh")) return "text/x-shellscript";
-  if (lower.endsWith(".py")) return "text/x-python";
-  if (lower.endsWith(".json")) return "application/json";
-  if (lower.endsWith(".txt")) return "text/plain";
-  return void 0;
-}
-function validateRelativeResourcePath(path3) {
-  const trimmed = String(path3 || "").trim().replace(/\\/g, "/");
-  if (!trimmed) {
-    throw new Error("Resource path cannot be empty");
-  }
-  if (trimmed.startsWith("/") || /^[A-Za-z]:\//.test(trimmed)) {
-    throw new Error("Resource path must be relative");
-  }
-  const segments = trimmed.split("/");
-  if (segments.some((segment) => segment === "..")) {
-    throw new Error("Resource path cannot escape the skill package");
-  }
-  return trimmed.replace(/^\.\/+/, "");
-}
-function createReadResourceCapability(deps) {
-  const tool = {
-    name: "read_resource",
-    label: "read_resource",
-    description: "Load a relative resource file from inside a skill package by owner and path.",
-    parameters: ReadResourceParamsSchema,
-    async execute(toolCallIdOrArgs, maybeArgs) {
-      const args = typeof toolCallIdOrArgs === "string" ? maybeArgs : toolCallIdOrArgs;
-      const owner = String(args?.owner || "").trim();
-      let resourcePath = "";
-      try {
-        resourcePath = validateRelativeResourcePath(args?.path || "");
-      } catch (error) {
-        return {
-          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
-          details: { found: false, owner: owner || void 0, path: args?.path || void 0 },
-          isError: true
-        };
-      }
-      const resource = await deps.resolveResource?.(owner, resourcePath);
-      if (!resource?.content) {
-        return {
-          content: [{ type: "text", text: `Resource not found: ${owner || "(empty)"}/${resourcePath || "(empty)"}` }],
-          details: { found: false, owner: owner || void 0, path: resourcePath || void 0 },
-          isError: true
-        };
-      }
-      const kind = resource.kind || inferKind(resource.path);
-      const mimeType = resource.mimeType || inferMimeType(resource.path);
-      return {
-        content: [{
-          type: "text",
-          text: `# ${resource.owner}/${resource.path}
-
-${resource.content}`
-        }],
-        details: {
-          found: true,
-          owner: resource.owner,
-          path: resource.path,
-          kind,
-          mimeType
-        }
-      };
-    }
-  };
-  return {
-    ...defineSharedCapability({
-      id: "read-resource",
-      description: "Shared capability for loading resources scoped to a skill package.",
-      tools: [tool]
-    }),
-    tool
-  };
-}
-
-// ../../packages/shared-headless-capabilities/src/resolve-resource.ts
-var ResolveResourceParamsSchema = Type.Object({
-  owner: Type.String({ description: "Exact skill name that owns the resource." }),
-  path: Type.String({ description: "Relative path inside the skill package." })
-});
-function inferKind2(path3) {
-  const lower = path3.toLowerCase();
-  if (lower.endsWith(".md")) return "document";
-  if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".sh") || lower.endsWith(".py")) return "script";
-  return void 0;
-}
-function validateRelativeResourcePath2(path3) {
-  const trimmed = String(path3 || "").trim().replace(/\\/g, "/");
-  if (!trimmed) {
-    throw new Error("Resource path cannot be empty");
-  }
-  if (trimmed.startsWith("/") || /^[A-Za-z]:\//.test(trimmed)) {
-    throw new Error("Resource path must be relative");
-  }
-  const segments = trimmed.split("/");
-  if (segments.some((segment) => segment === "..")) {
-    throw new Error("Resource path cannot escape the skill package");
-  }
-  return trimmed.replace(/^\.\/+/, "");
-}
-function createResolveResourceCapability(deps) {
-  const tool = {
-    name: "resolve_resource",
-    label: "resolve_resource",
-    description: "Resolve a relative skill resource to a host executable/readable path without loading its content.",
-    parameters: ResolveResourceParamsSchema,
-    async execute(toolCallIdOrArgs, maybeArgs) {
-      const args = typeof toolCallIdOrArgs === "string" ? maybeArgs : toolCallIdOrArgs;
-      const owner = String(args?.owner || "").trim();
-      let resourcePath = "";
-      try {
-        resourcePath = validateRelativeResourcePath2(args?.path || "");
-      } catch (error) {
-        return {
-          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
-          details: { found: false, owner: owner || void 0, path: args?.path || void 0 },
-          isError: true
-        };
-      }
-      const resource = await deps.resolveResource?.(owner, resourcePath);
-      if (!resource?.resolvedPath) {
-        return {
-          content: [{ type: "text", text: `Resource not found: ${owner || "(empty)"}/${resourcePath || "(empty)"}` }],
-          details: { found: false, owner: owner || void 0, path: resourcePath || void 0 },
-          isError: true
-        };
-      }
-      return {
-        content: [{
-          type: "text",
-          text: [
-            "Resolved skill resource:",
-            `owner: ${resource.owner}`,
-            `path: ${resource.path}`,
-            `resolvedPath: ${resource.resolvedPath}`
-          ].join("\n")
-        }],
-        details: {
-          found: true,
-          owner: resource.owner,
-          path: resource.path,
-          kind: resource.kind || inferKind2(resource.path),
-          resolvedPath: resource.resolvedPath
-        }
-      };
-    }
-  };
-  return {
-    ...defineSharedCapability({
-      id: "resolve-resource",
-      description: "Shared capability for resolving a skill resource to a host path without loading its contents.",
-      tools: [tool]
-    }),
-    tool
-  };
-}
-
 // ../../packages/shared-headless-capabilities/src/session-trace.ts
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -2914,9 +2591,20 @@ function summarizeToolResultDetails(result) {
     "failureCategory",
     "fallbackReason",
     "qualityWarnings",
+    "qualityScore",
     "sourceCount",
+    "sources",
+    "fetchedSources",
+    "browserRequiredSources",
     "actualQueries",
     "attempts",
+    "providerAttempts",
+    "providerHealth",
+    "routeRankReason",
+    "latencyMetrics",
+    "costEstimate",
+    "browserReadSummary",
+    "guardFindings",
     "timedOut"
   ];
   const summary = {};
@@ -2939,6 +2627,54 @@ function summarizeToolResultDetails(result) {
       });
       continue;
     }
+    if ((key === "sources" || key === "fetchedSources" || key === "browserRequiredSources") && Array.isArray(value)) {
+      summary[key] = {
+        count: value.length,
+        items: value.slice(0, 5).map((entry) => {
+          if (!isRecord(entry)) return entry;
+          return {
+            url: entry.finalUrl || entry.url,
+            title: entry.title,
+            score: entry.score,
+            requiresBrowser: entry.requiresBrowser,
+            failureCategory: entry.failureCategory,
+            extractionMethod: entry.extractionMethod,
+            browserReadSummary: entry.browserReadSummary
+          };
+        })
+      };
+      continue;
+    }
+    if (key === "providerHealth" && Array.isArray(value)) {
+      summary[key] = value.slice(0, 5).map((entry) => {
+        if (!isRecord(entry)) return entry;
+        return {
+          routeKey: entry.routeKey,
+          attempts: entry.attempts,
+          successes: entry.successes,
+          failures: entry.failures,
+          lowQuality: entry.lowQuality,
+          rateLimited: entry.rateLimited,
+          timeouts: entry.timeouts
+        };
+      });
+      continue;
+    }
+    if (key === "providerAttempts" && Array.isArray(value)) {
+      summary[key] = value.slice(-5).map((attempt) => {
+        if (!isRecord(attempt)) return attempt;
+        return {
+          provider: attempt.provider,
+          modelId: attempt.modelId,
+          providerMode: attempt.providerMode,
+          routeSource: attempt.routeSource,
+          failureCategory: attempt.failureCategory,
+          sourceCount: attempt.sourceCount,
+          qualityWarnings: attempt.qualityWarnings
+        };
+      });
+      continue;
+    }
     summary[key] = typeof value === "string" && value.length > 300 ? `${value.slice(0, 300)}...` : value;
   }
   return Object.keys(summary).length > 0 ? summary : void 0;
@@ -3636,12 +3372,9 @@ function formatSkillSummariesForPrompt(skills) {
   if (skills.length === 0) return "";
   const lines = [
     "\n\nThe following skills provide specialized instructions for specific tasks.",
-    "Use the read_skill tool only with an exact name from <available_skills> when the task matches its description.",
-    "Tools such as bash, read_file, grep_text, or manage_todo_list are not skills and must not be passed to read_skill.",
-    "Skills may reference package-local resources using relative paths.",
-    "When read_skill returns skill-local resources in details.resources, use read_resource(owner, path) for documents or config files that you need to inspect.",
-    "When read_skill returns a script or executable resource in details.resources, use resolve_resource(owner, path) before execution.",
-    "Do not guess host filesystem paths for skill-local resources.",
+    "Use read_file to load a skill's entry file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against that skill's baseDir and use the resulting ordinary path with file or bash tools.",
+    "Skills are ordinary files in the current runtime filesystem; do not use special skill/resource tool protocols.",
     "",
     "<available_skills>"
   ];
@@ -3649,6 +3382,12 @@ function formatSkillSummariesForPrompt(skills) {
     lines.push("  <skill>");
     lines.push(`    <name>${escapeXml(skill.name)}</name>`);
     lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    if (skill.filePath) {
+      lines.push(`    <entry>${escapeXml(skill.filePath)}</entry>`);
+    }
+    if (skill.baseDir) {
+      lines.push(`    <baseDir>${escapeXml(skill.baseDir)}</baseDir>`);
+    }
     lines.push("  </skill>");
   }
   lines.push("</available_skills>");
@@ -4875,8 +4614,14 @@ function createPolicyEnforcedTools(tools, options = {}) {
   return tools.map((tool) => createPolicyEnforcedTool(tool, options));
 }
 
+// ../../packages/shared-headless-capabilities/src/builtin/fs/read.ts
+import * as nodePath from "node:path";
+
 // ../../packages/shared-headless-capabilities/src/builtin/fs/path-utils.ts
 function isInAllowlist(path3, allowlistedDirs) {
+  if (allowlistedDirs.some((dir) => isGlobalFilesystemSentinel(dir))) {
+    return true;
+  }
   const normalized = normalizeForComparison(path3);
   for (const dir of allowlistedDirs) {
     const normalizedDir = normalizeForComparison(dir);
@@ -4888,9 +4633,19 @@ function isInAllowlist(path3, allowlistedDirs) {
   return false;
 }
 function normalizeForComparison(path3) {
-  const normalized = path3.replace(/\\/g, "/").replace(/\/+/g, "/");
+  const slashNormalized = path3.replace(/\\/g, "/");
+  const isWindowsPath = /^[a-zA-Z]:($|\/)/.test(slashNormalized) || /^\/{2}[^/]+\/[^/]+/.test(slashNormalized);
+  const normalized = slashNormalized.replace(/\/+/g, "/");
   if (normalized === "/") return normalized;
-  return normalized.replace(/\/+$/, "");
+  const trimmed = normalized.replace(/\/+$/, "");
+  return isWindowsPath ? trimmed.toLowerCase() : trimmed;
+}
+function isGlobalFilesystemSentinel(path3) {
+  return normalizeForComparison(String(path3 || "").trim()) === "/";
+}
+function isAbsoluteUserPath(path3) {
+  const normalized = path3.replace(/\\/g, "/");
+  return /^[a-zA-Z]:\//.test(normalized) || /^\/{2}[^/]+\/[^/]+/.test(normalized);
 }
 function validateToolPathArgument(filePath) {
   const trimmed = filePath.trim();
@@ -4908,10 +4663,31 @@ function withTrailingSep(path3) {
   return path3.endsWith("/") ? path3 : `${path3}/`;
 }
 function isWithinRoot(path3, root) {
+  if (isGlobalFilesystemSentinel(root)) {
+    return true;
+  }
   const normalizedPath = normalizeForComparison(path3);
   const normalizedRoot = normalizeForComparison(root);
   return normalizedPath === normalizedRoot || normalizedPath.startsWith(withTrailingSep(normalizedRoot));
 }
+function getAccessRoots(sandboxRoot, options) {
+  const fs2 = getFileSystem();
+  const roots = /* @__PURE__ */ new Set();
+  roots.add(fs2.normalize(sandboxRoot));
+  if (options?.accessRoot) {
+    roots.add(fs2.normalize(options.accessRoot));
+  }
+  for (const root of options?.accessRoots ?? []) {
+    const trimmed = String(root || "").trim();
+    if (trimmed) {
+      roots.add(fs2.normalize(trimmed));
+    }
+  }
+  return Array.from(roots);
+}
+function isWithinAnyRoot(path3, roots) {
+  return roots.some((root) => isWithinRoot(path3, root));
+}
 function normalizePrefix(prefix) {
   const normalized = normalizeForComparison(prefix);
   return normalized.startsWith("/") ? normalized.slice(1) : normalized;
@@ -4992,12 +4768,13 @@ function getResolutionRoot(filePath, sandboxRoot, options, rootName) {
 function resolveInSandbox(filePath, sandboxRoot, options, rootName) {
   const fs2 = getFileSystem();
   const allowlistedDirs = options?.allowlistedDirs ?? [];
+  const accessRoots = getAccessRoots(sandboxRoot, options);
   if (!filePath) {
     throw new Error("Path cannot be empty");
   }
   validateToolPathArgument(filePath);
   const cleaned = filePath.trim().startsWith("@") ? filePath.trim().slice(1) : filePath.trim();
-  if (fs2.isAbsolute(cleaned)) {
+  if (fs2.isAbsolute(cleaned) || isAbsoluteUserPath(cleaned)) {
     const normalized = fs2.normalize(cleaned);
     const selectedRoot2 = rootName ? getRootByName(rootName, sandboxRoot, options) : void 0;
     if (rootName && !selectedRoot2) {
@@ -5020,7 +4797,7 @@ function resolveInSandbox(filePath, sandboxRoot, options, rootName) {
     if (isInAllowlist(normalized, allowlistedDirs)) {
       return normalized;
     }
-    if (!isWithinRoot(normalized, sandboxRoot)) {
+    if (!isWithinAnyRoot(normalized, accessRoots)) {
       throw new Error(`Absolute path outside sandbox: ${filePath}`);
     }
     return normalized;
@@ -5040,7 +4817,7 @@ function resolveInSandbox(filePath, sandboxRoot, options, rootName) {
     }
     return resolved;
   }
-  if (!isWithinRoot(resolved, sandboxRoot) && !isInAllowlist(resolved, allowlistedDirs)) {
+  if (!isWithinAnyRoot(resolved, accessRoots) && !isInAllowlist(resolved, allowlistedDirs)) {
     throw new Error(`Path escapes sandbox: ${filePath}`);
   }
   return resolved;
@@ -5309,6 +5086,10 @@ function createReadTool(cwd, options) {
               const truncation = truncateHead(selectedContent);
               let outputText;
               let details;
+              const sourceHeader = `File: ${absolutePath}
+Base directory: ${nodePath.dirname(absolutePath)}
+
+`;
               if (truncation.firstLineExceedsLimit) {
                 const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
                 outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit.]`;
@@ -5337,6 +5118,7 @@ function createReadTool(cwd, options) {
               } else {
                 outputText = truncation.content;
               }
+              outputText = sourceHeader + outputText;
               const textContent = [{ type: "text", text: outputText }];
               if (aborted) return;
               if (signal) {
@@ -7473,7 +7255,7 @@ function decodeBytes(bytes, contentType = "") {
     };
   }
 }
-function extractTitle2(html) {
+function extractTitle(html) {
   const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
   return match?.[1]?.replace(/\s+/g, " ").trim();
 }
@@ -7533,6 +7315,15 @@ function createTimeoutSignal(parentSignal, timeoutMs) {
 function assistantText(message) {
   return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
 }
+async function withAbort(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) throw signal.reason ?? new Error("operation aborted");
+  return await new Promise((resolve2, reject) => {
+    const onAbort = () => reject(signal.reason ?? new Error("operation aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve2, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
 async function applyPromptWithModel(deps, prompt, url, content, signal) {
   const model = deps.getModel?.();
   const apiKey = deps.getApiKey?.();
@@ -7548,24 +7339,27 @@ async function applyPromptWithModel(deps, prompt, url, content, signal) {
     };
   }
   try {
-    const response = await completeSimple(
-      model,
-      {
-        systemPrompt: "You are a web_fetch extraction tool. Answer only from the fetched page content. Include uncertainty if the page does not contain the requested information.",
-        messages: [{
-          role: "user",
-          timestamp: Date.now(),
-          content: [{
-            type: "text",
-            text: [`URL: ${url}`, `Task: ${prompt}`, "", "Fetched content:", content].join("\n")
+    const response = await withAbort(
+      completeSimple(
+        model,
+        {
+          systemPrompt: "You are a web_fetch extraction tool. Answer only from the fetched page content. Include uncertainty if the page does not contain the requested information.",
+          messages: [{
+            role: "user",
+            timestamp: Date.now(),
+            content: [{
+              type: "text",
+              text: [`URL: ${url}`, `Task: ${prompt}`, "", "Fetched content:", content].join("\n")
+            }]
           }]
-        }]
-      },
-      {
-        apiKey,
-        maxTokens: Math.min(model.maxTokens || 4096, 4096),
-        signal
-      }
+        },
+        {
+          apiKey,
+          maxTokens: Math.min(model.maxTokens || 4096, 4096),
+          signal
+        }
+      ),
+      signal
     );
     const text = assistantText(response) || response.errorMessage || "(web_fetch extraction model returned no text)";
     return { text, model: modelLabel2(model), isError: response.stopReason === "error" || response.stopReason === "aborted" };
@@ -7651,7 +7445,7 @@ function createSharedWebFetchTool(deps = {}) {
         const raw = decoded.text;
         const isHtml = /html/i.test(contentType) || /<\/?[a-z][\s\S]*>/i.test(raw.slice(0, 2e3));
         const isPdf = /pdf/i.test(contentType) || raw.startsWith("%PDF");
-        const title = isHtml ? extractTitle2(raw) : void 0;
+        const title = isHtml ? extractTitle(raw) : void 0;
         const htmlExtraction = isHtml ? htmlToReadableMarkdown(raw) : void 0;
         let text = htmlExtraction?.text ?? (isPdf ? compactPdfText(raw) : raw.trim());
         const extractionMethod = isHtml ? "html_readability" : isPdf ? "pdf_text" : "plain_text";
@@ -7728,6 +7522,621 @@ function createSharedWebFetchTool(deps = {}) {
   };
 }
 
+// ../../packages/shared-headless-capabilities/src/web-research.ts
+var webResearchSchema = Type.Object({
+  query: Type.String({
+    minLength: 2,
+    description: "The research question or topic. Use for end-to-end public web research."
+  }),
+  allowed_domains: Type.Optional(Type.Array(Type.String({
+    description: "Only include sources from these domains. Use only when the user explicitly asks to limit sources."
+  }))),
+  blocked_domains: Type.Optional(Type.Array(Type.String({
+    description: "Exclude sources from these domains. Use only when the user explicitly asks to avoid sources."
+  }))),
+  max_sources: Type.Optional(Type.Number({
+    minimum: 1,
+    maximum: 8,
+    description: "Maximum credible sources to fetch and cite. Defaults to 3."
+  }))
+});
+var DEFAULT_WEB_RESEARCH_SEARCH_ATTEMPT_TIMEOUT_MS = 45e3;
+var DEFAULT_WEB_RESEARCH_FETCH_ATTEMPT_TIMEOUT_MS = 3e4;
+var DEFAULT_WEB_RESEARCH_BROWSER_ATTEMPT_TIMEOUT_MS = 45e3;
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function textFromResult(result) {
+  return result.content.filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n").trim();
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function normalizeHost(hostname) {
+  return hostname.toLowerCase().replace(/^www\./, "");
+}
+function parseResearchUrl(value) {
+  const trimmed = value.trim();
+  const match = /^(https?):\/\/([^/?#]+)([^?#]*)?(\?[^#]*)?(#.*)?$/i.exec(trimmed);
+  if (!match) return null;
+  const protocol = match[1].toLowerCase();
+  const rawHost = match[2].replace(/^[^@]+@/, "");
+  const hostname = rawHost.startsWith("[") ? rawHost : rawHost.split(":")[0];
+  const pathname = match[3] && match[3].startsWith("/") ? match[3] : "/";
+  const search = match[4] || "";
+  const href = `${protocol}://${rawHost}${pathname}${search}`;
+  return {
+    href,
+    hostname,
+    pathname,
+    search,
+    hasSearchParam(name) {
+      const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(`(?:^\\?|&)${escaped}(?:=|&|$)`, "i").test(search);
+    }
+  };
+}
+function sourceKey(url) {
+  const parsed = parseResearchUrl(url);
+  if (!parsed) return url.trim();
+  return parsed.href.replace(/\/$/, "");
+}
+function isSearchPage(url) {
+  const host = normalizeHost(url.hostname);
+  if (/(google|bing|duckduckgo|baidu|yahoo|yandex)\./.test(host)) return true;
+  return /(^|\/)(search|results)(\/|$)/i.test(url.pathname) || url.hasSearchParam("q");
+}
+function isHomepage(url) {
+  return (url.pathname === "" || url.pathname === "/") && !url.search;
+}
+function looksOfficial(url) {
+  const host = normalizeHost(url.hostname);
+  return host.startsWith("docs.") || host.startsWith("developer.") || host.startsWith("developers.") || host.startsWith("learn.") || host.startsWith("api.") || /(^|\.)gov$/.test(host) || /(^|\.)edu$/.test(host) || /\/(docs|documentation|reference|guide|guides|api|manual)\b/i.test(url.pathname);
+}
+function looksGithubAuthoritative(url) {
+  const host = normalizeHost(url.hostname);
+  if (host !== "github.com") return false;
+  return /\/(releases|issues|pull|wiki|blob|tree|commit)\b/i.test(url.pathname);
+}
+function looksNewsAuthority(url) {
+  const host = normalizeHost(url.hostname);
+  return [
+    "apnews.com",
+    "reuters.com",
+    "bbc.com",
+    "pbs.org",
+    "npr.org",
+    "theguardian.com",
+    "nytimes.com",
+    "wsj.com",
+    "chinadaily.com.cn",
+    "xinhuanet.com"
+  ].some((domain) => host === domain || host.endsWith(`.${domain}`));
+}
+function scoreWebResearchSource(source) {
+  const reasons = [];
+  let score = 45;
+  const url = parseResearchUrl(source.url);
+  if (!url) {
+    score = 0;
+    reasons.push("invalid_url");
+    return { source, score, reasons };
+  }
+  if (looksOfficial(url)) {
+    score += 35;
+    reasons.push("official_or_docs");
+  }
+  if (looksGithubAuthoritative(url)) {
+    score += 25;
+    reasons.push("github_primary_source");
+  }
+  if (looksNewsAuthority(url)) {
+    score += 20;
+    reasons.push("news_authority");
+  }
+  if (isHomepage(url)) {
+    score -= 35;
+    reasons.push("homepage");
+  }
+  if (isSearchPage(url)) {
+    score -= 60;
+    reasons.push("search_page");
+  }
+  if (!source.title?.trim()) {
+    score -= 15;
+    reasons.push("missing_title");
+  }
+  if (/\.pdf($|\?)/i.test(url.pathname)) {
+    score += 10;
+    reasons.push("pdf_document");
+  }
+  return { source, score: clamp(score, 0, 100), reasons };
+}
+function dedupeSources(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const source of sources) {
+    if (!source.url) continue;
+    const key = sourceKey(source.url);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(source);
+  }
+  return deduped;
+}
+function hasChinese(text) {
+  return /[\u3400-\u9fff]/.test(text);
+}
+function isRecentQuery(text) {
+  return /\b(today|latest|current|recent|news|202[0-9]|release|changelog)\b/i.test(text) || /(今天|最新|新闻|最近|当前|今日|发布|更新)/.test(text);
+}
+function isDocsQuery(text) {
+  return /\b(docs?|documentation|api|reference|guide|manual|release notes?|changelog|github|issue)\b/i.test(text) || /(文档|官方|接口|指南|发布说明|更新日志|issue|问题)/i.test(text);
+}
+function planWebResearchQueries(query, dateContext) {
+  const trimmed = query.trim();
+  const variants = /* @__PURE__ */ new Set([trimmed]);
+  const year = dateContext?.currentDate?.slice(0, 4) || String((/* @__PURE__ */ new Date()).getFullYear());
+  if (isRecentQuery(trimmed)) {
+    variants.add(`${trimmed} ${year}`);
+  }
+  if (isDocsQuery(trimmed)) {
+    variants.add(`${trimmed} official documentation`);
+    variants.add(`${trimmed} GitHub release changelog issue`);
+  } else {
+    variants.add(`${trimmed} official sources documentation GitHub release changelog`);
+  }
+  if (hasChinese(trimmed)) {
+    variants.add(`${trimmed} \u5B98\u65B9 \u6587\u6863 \u6765\u6E90`);
+    if (isRecentQuery(trimmed)) variants.add(`${trimmed} ${year} today news`);
+  }
+  return [...variants].slice(0, 5);
+}
+function routeKeyFromAttempt(attempt) {
+  if (!attempt.provider && !attempt.modelId && !attempt.providerMode) return void 0;
+  return `${attempt.provider || "unknown"}/${attempt.modelId || "unknown"}:${attempt.providerMode}`;
+}
+function routeKeyFromDecision(route) {
+  const model = route.model;
+  const providerMode = model?.webSearch?.type || "unavailable";
+  return `${model?.provider || "unknown"}/${model?.id || "unknown"}:${providerMode}`;
+}
+function healthPenalty(health) {
+  if (!health || health.attempts === 0) return 0;
+  const failureRate = health.failures / health.attempts;
+  const lowQualityRate = health.lowQuality / health.attempts;
+  const rateLimitRate = health.rateLimited / health.attempts;
+  return failureRate * 40 + lowQualityRate * 25 + rateLimitRate * 25;
+}
+function sortCandidatesByHealth(candidates, healthEntries) {
+  if (!healthEntries?.length) return candidates;
+  const healthByKey = new Map(healthEntries.map((entry) => [entry.routeKey, entry]));
+  return [...candidates].sort((a, b) => healthPenalty(healthByKey.get(routeKeyFromDecision(a))) - healthPenalty(healthByKey.get(routeKeyFromDecision(b))));
+}
+function describeRouteRanking(candidates, healthEntries) {
+  if (!candidates.length) return ["no configured web_search route candidates"];
+  const healthByKey = new Map((healthEntries || []).map((entry) => [entry.routeKey, entry]));
+  return candidates.slice(0, 5).map((candidate, index) => {
+    const key = routeKeyFromDecision(candidate);
+    const health = healthByKey.get(key);
+    if (!health || health.attempts === 0) return `${index + 1}. ${key}: no prior health data`;
+    const successRate = Math.round(health.successes / Math.max(1, health.attempts) * 100);
+    const lowQualityRate = Math.round(health.lowQuality / Math.max(1, health.attempts) * 100);
+    const medianLatencyMs = Math.round(health.totalDurationMs / Math.max(1, health.attempts));
+    return `${index + 1}. ${key}: success=${successRate}%, lowQuality=${lowQualityRate}%, avgLatencyMs=${medianLatencyMs}, penalty=${Math.round(healthPenalty(health))}`;
+  });
+}
+function updateProviderHealth(current, attempts) {
+  const byKey = new Map((current || []).map((entry) => [entry.routeKey, { ...entry }]));
+  for (const attempt of attempts) {
+    const key = routeKeyFromAttempt(attempt);
+    if (!key) continue;
+    const entry = byKey.get(key) ?? {
+      routeKey: key,
+      attempts: 0,
+      successes: 0,
+      failures: 0,
+      lowQuality: 0,
+      rateLimited: 0,
+      timeouts: 0,
+      totalDurationMs: 0,
+      totalSources: 0,
+      updatedAt: Date.now()
+    };
+    entry.attempts += 1;
+    entry.totalDurationMs += Math.round(attempt.durationSeconds * 1e3);
+    entry.totalSources += attempt.sourceCount || 0;
+    if (attempt.failureCategory) entry.failures += 1;
+    else entry.successes += 1;
+    if (attempt.failureCategory === "low_quality_result" || attempt.qualityWarnings?.length) entry.lowQuality += 1;
+    if (attempt.failureCategory === "rate_limited") entry.rateLimited += 1;
+    if (attempt.failureCategory === "timeout") entry.timeouts += 1;
+    entry.updatedAt = Date.now();
+    byKey.set(key, entry);
+  }
+  return [...byKey.values()].sort((a, b) => b.updatedAt - a.updatedAt).slice(0, 20);
+}
+function contentDetails(result) {
+  return isRecord3(result.details) ? result.details : {};
+}
+function excerpt(text, max = 1400) {
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > max ? `${clean.slice(0, max)}...` : clean;
+}
+function qualityScore(fetched, scored) {
+  if (!fetched.length) return 0;
+  const fetchScore = Math.min(70, fetched.length * 25);
+  const averageSourceScore = fetched.length ? fetched.reduce((sum, item) => sum + item.score, 0) / fetched.length : scored.length ? scored.slice(0, Math.max(1, fetched.length)).reduce((sum, item) => sum + item.score, 0) / Math.max(1, Math.min(scored.length, fetched.length)) : 0;
+  const citationBonus = fetched.some((item) => item.citationAnchors?.length) ? 10 : 0;
+  return clamp(Math.round(fetchScore + averageSourceScore * 0.25 + citationBonus), 0, 100);
+}
+function percentile(values, p) {
+  const sorted = values.filter((value) => Number.isFinite(value)).sort((a, b) => a - b);
+  if (!sorted.length) return void 0;
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p / 100 * sorted.length) - 1));
+  return sorted[index];
+}
+function formatResearchPack(query, fetchedSources, warnings, browserRequiredSources) {
+  const lines = [
+    `Web research pack for: ${query}`,
+    "",
+    "Use the fetched sources below for the final answer. Do not rely on snippets alone.",
+    "If the fetched sources answer the user's request, answer directly; do not run another web_search or web_fetch loop for the same request.",
+    "",
+    "Fetched sources:"
+  ];
+  fetchedSources.forEach((source, index) => {
+    lines.push(`${index + 1}. ${source.title || source.finalUrl || source.url}`);
+    lines.push(`   URL: ${source.finalUrl || source.url}`);
+    lines.push(`   Excerpt: ${source.textExcerpt || "(no excerpt)"}`);
+  });
+  if (browserRequiredSources.length) {
+    lines.push("");
+    lines.push("Browser-required sources:");
+    for (const source of browserRequiredSources) {
+      lines.push(`- ${source.finalUrl || source.url}`);
+    }
+  }
+  if (warnings.length) {
+    lines.push("");
+    lines.push("Warnings:");
+    for (const warning of warnings) lines.push(`- ${warning}`);
+  }
+  lines.push("");
+  lines.push("Sources:");
+  for (const source of fetchedSources) lines.push(`- ${source.finalUrl || source.url}`);
+  return lines.join("\n");
+}
+function createChildSignal(parentSignal) {
+  const controller = new AbortController();
+  const onAbort = () => controller.abort(parentSignal?.reason);
+  if (parentSignal?.aborted) onAbort();
+  else parentSignal?.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: controller.signal,
+    abort: (reason) => controller.abort(reason),
+    dispose: () => parentSignal?.removeEventListener("abort", onAbort)
+  };
+}
+async function runWithDeadline(operation, timeoutMs, message, parentSignal) {
+  const child = createChildSignal(parentSignal);
+  let timer;
+  try {
+    return await new Promise((resolve2, reject) => {
+      timer = setTimeout(() => {
+        const error = new Error(message);
+        child.abort(error);
+        reject(error);
+      }, timeoutMs);
+      operation(child.signal).then(resolve2, reject);
+    });
+  } finally {
+    if (timer) clearTimeout(timer);
+    child.dispose();
+  }
+}
+function createSharedWebResearchTool(deps) {
+  const initialHealth = deps.loadProviderHealth?.();
+  const initialCandidates = deps.resolveToolModelCandidates?.("web_search") ?? [];
+  const webSearchTool = deps.webSearchTool ?? createSharedWebSearchTool({
+    ...deps,
+    resolveToolModelCandidates: (purpose) => sortCandidatesByHealth(deps.resolveToolModelCandidates?.(purpose) ?? [], deps.loadProviderHealth?.() ?? initialHealth)
+  });
+  const webFetchTool = deps.webFetchTool ?? createSharedWebFetchTool(deps);
+  return {
+    name: "web_research",
+    label: "web_research",
+    description: "Run end-to-end public web research: plan search queries, search provider-native sources, fetch credible pages, and return a cited research pack. Use for general online research, current information, official docs, news, releases, issues, and webpage summaries. Use web_search/web_fetch directly only when you need precise low-level control. Do not use bash/curl/Python as a web research fallback.",
+    parameters: webResearchSchema,
+    capabilityMetadata: {
+      riskClass: "network",
+      concurrencySafe: true,
+      permissionScope: "network",
+      readsNetwork: true,
+      availableInPlanMode: true,
+      allowedForSubagentByDefault: true,
+      maxOutputChars: 1e5
+    },
+    execute: async (_toolCallId, rawParams, signal, onUpdate) => {
+      const input = rawParams;
+      const totalStartedAt = Date.now();
+      const currentHealth = deps.loadProviderHealth?.() ?? initialHealth;
+      const activeCandidates = deps.resolveToolModelCandidates?.("web_search") ?? initialCandidates;
+      const rankedCandidates = sortCandidatesByHealth(activeCandidates, currentHealth);
+      const routeRankReason = describeRouteRanking(rankedCandidates.length ? rankedCandidates : activeCandidates, currentHealth);
+      const query = String(input.query || "").trim();
+      const maxSources = clamp(Math.floor(input.max_sources ?? 3), 1, 8);
+      const searchAttemptTimeoutMs = Math.max(1e3, deps.searchAttemptTimeoutMs ?? deps.timeoutMs ?? DEFAULT_WEB_RESEARCH_SEARCH_ATTEMPT_TIMEOUT_MS);
+      const fetchAttemptTimeoutMs = Math.max(1e3, deps.fetchAttemptTimeoutMs ?? DEFAULT_WEB_RESEARCH_FETCH_ATTEMPT_TIMEOUT_MS);
+      const browserAttemptTimeoutMs = Math.max(1e3, deps.browserAttemptTimeoutMs ?? DEFAULT_WEB_RESEARCH_BROWSER_ATTEMPT_TIMEOUT_MS);
+      const attempts = [];
+      const providerAttempts = [];
+      const warnings = [];
+      const sourceReadDurations = [];
+      const actualQueries = [];
+      const allSources = [];
+      const dateContext = deps.getCurrentDateContext?.();
+      const queryVariants = planWebResearchQueries(query, dateContext);
+      const minimumSearchQueries = 1;
+      let searchedQueries = 0;
+      let searchDurationMs = 0;
+      let fetchDurationMs = 0;
+      let browserDurationMs = 0;
+      if (!query) {
+        return {
+          content: [{ type: "text", text: "web_research requires a non-empty query." }],
+          details: {
+            query,
+            actualQueries: [],
+            sources: [],
+            fetchedSources: [],
+            providerAttempts: [],
+            attempts: [],
+            qualityScore: 0,
+            warnings: ["missing_query"],
+            browserRequiredSources: [],
+            routeRankReason,
+            latencyMetrics: { totalDurationMs: Date.now() - totalStartedAt, searchDurationMs: 0, fetchDurationMs: 0, browserDurationMs: 0 },
+            costEstimate: { status: "unknown", reason: "Provider usage is not yet normalized across web research search/fetch/browser routes." }
+          },
+          isError: true
+        };
+      }
+      for (const variant of queryVariants) {
+        const startedAt = Date.now();
+        const allowedDomains = input.allowed_domains?.length ? input.allowed_domains : void 0;
+        const blockedDomains = allowedDomains ? void 0 : input.blocked_domains;
+        if (allowedDomains && input.blocked_domains?.length && warnings.length === 0) {
+          warnings.push("Both allowed_domains and blocked_domains were provided; web_research used allowed_domains and ignored blocked_domains for provider compatibility.");
+        }
+        const searchInput = {
+          query: variant,
+          allowed_domains: allowedDomains,
+          blocked_domains: blockedDomains
+        };
+        onUpdate?.({
+          content: [{ type: "text", text: `Searching web for: ${variant} (timeout ${Math.ceil(searchAttemptTimeoutMs / 1e3)}s)` }],
+          details: { query, actualQueries: [...actualQueries, variant], attempts, providerAttempts, fetchedSources: [], sources: dedupeSources(allSources), qualityScore: 0, warnings, browserRequiredSources: [] }
+        });
+        let result;
+        try {
+          result = await runWithDeadline(
+            (childSignal) => webSearchTool.execute("web_research_search", searchInput, childSignal),
+            searchAttemptTimeoutMs,
+            `web_research search attempt timed out after ${Math.ceil(searchAttemptTimeoutMs / 1e3)} seconds`,
+            signal
+          );
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          attempts.push({
+            phase: "search",
+            query: variant,
+            status: "failed",
+            failureCategory: "timeout",
+            warnings: [message],
+            durationMs: Date.now() - startedAt
+          });
+          searchDurationMs += Date.now() - startedAt;
+          warnings.push(`${variant}: ${message}`);
+          actualQueries.push(variant);
+          break;
+        }
+        const details2 = contentDetails(result);
+        searchDurationMs += Date.now() - startedAt;
+        attempts.push({
+          phase: "search",
+          query: variant,
+          status: result.isError ? "failed" : "completed",
+          failureCategory: details2.failureCategory,
+          warnings: details2.qualityWarnings,
+          durationMs: Date.now() - startedAt
+        });
+        if (details2.actualQueries?.length) actualQueries.push(...details2.actualQueries);
+        else actualQueries.push(variant);
+        if (details2.attempts?.length) providerAttempts.push(...details2.attempts);
+        if (details2.qualityWarnings?.length) warnings.push(...details2.qualityWarnings.map((warning) => `${variant}: ${warning}`));
+        if (Array.isArray(details2.sources)) allSources.push(...details2.sources);
+        searchedQueries += 1;
+        const dedupedSoFar = dedupeSources(allSources);
+        const scoredSoFar = dedupedSoFar.map(scoreWebResearchSource).sort((a, b) => b.score - a.score);
+        const highQualitySources = scoredSoFar.filter((item) => item.score >= 70).length;
+        const searchSourceTarget = Math.min(maxSources, 3);
+        const enoughHighQuality = highQualitySources >= Math.min(searchSourceTarget, 2) || highQualitySources >= 1 && dedupedSoFar.length >= searchSourceTarget * 2 || highQualitySources >= 1 && maxSources === 1;
+        if (searchedQueries >= minimumSearchQueries && enoughHighQuality && !result.isError) {
+          warnings.push(`Fast path used after ${searchedQueries} search quer${searchedQueries === 1 ? "y" : "ies"}: high-quality source target reached.`);
+          break;
+        }
+        if (searchedQueries >= minimumSearchQueries && dedupeSources(allSources).length >= maxSources * 3 && !result.isError) break;
+      }
+      const nextHealth = updateProviderHealth(deps.loadProviderHealth?.() ?? initialHealth, providerAttempts);
+      await deps.saveProviderHealth?.(nextHealth);
+      const dedupedSources = dedupeSources(allSources);
+      const scoredSources = dedupedSources.map(scoreWebResearchSource).sort((a, b) => b.score - a.score);
+      const fetchedSources = [];
+      const browserRequiredSources = [];
+      const minimumFetchedSources = Math.min(maxSources, 2);
+      const targetFetchedSources = Math.min(maxSources, 3);
+      const candidateSources = scoredSources.filter((scored) => {
+        if (scored.score < 35) {
+          warnings.push(`Filtered low-quality source: ${scored.source.url} (${scored.reasons.join(", ") || "low_score"})`);
+          return false;
+        }
+        return true;
+      });
+      const fetchScoredSource = async (scored) => {
+        const startedAt = Date.now();
+        onUpdate?.({
+          content: [{ type: "text", text: `Fetching source: ${scored.source.url}` }],
+          details: { query, actualQueries: [...new Set(actualQueries)], sources: dedupedSources, fetchedSources, providerAttempts, attempts, qualityScore: qualityScore(fetchedSources, scoredSources), warnings, browserRequiredSources }
+        });
+        const fetchResult = await runWithDeadline(
+          (childSignal) => webFetchTool.execute("web_research_fetch", { url: scored.source.url }, childSignal),
+          fetchAttemptTimeoutMs,
+          `web_research fetch attempt timed out after ${Math.ceil(fetchAttemptTimeoutMs / 1e3)} seconds`,
+          signal
+        ).catch((error) => ({
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          details: {
+            url: scored.source.url,
+            sourceUrl: scored.source.url,
+            durationMs: Date.now() - startedAt,
+            failureCategory: "timeout"
+          },
+          isError: true
+        }));
+        const details2 = contentDetails(fetchResult);
+        const text = textFromResult(fetchResult);
+        fetchDurationMs += Date.now() - startedAt;
+        sourceReadDurations.push(Date.now() - startedAt);
+        attempts.push({
+          phase: "fetch",
+          url: scored.source.url,
+          status: fetchResult.isError ? "failed" : "completed",
+          failureCategory: details2.failureCategory,
+          durationMs: Date.now() - startedAt
+        });
+        if (details2.requiresBrowser) {
+          const browserEntry = {
+            url: scored.source.url,
+            finalUrl: details2.finalUrl,
+            title: details2.title || scored.source.title,
+            score: scored.score,
+            scoreReasons: scored.reasons,
+            requiresBrowser: true,
+            failureCategory: details2.failureCategory
+          };
+          if (deps.renderedPageReader) {
+            let browserStartedAt = Date.now();
+            try {
+              onUpdate?.({
+                content: [{ type: "text", text: `Reading browser-rendered source: ${details2.finalUrl || scored.source.url}` }],
+                details: { query, actualQueries: [...new Set(actualQueries)], sources: dedupedSources, fetchedSources, providerAttempts, attempts, qualityScore: qualityScore(fetchedSources, scoredSources), warnings, browserRequiredSources }
+              });
+              const rendered = await runWithDeadline(
+                (childSignal) => deps.renderedPageReader({ url: details2.finalUrl || scored.source.url, query }, childSignal),
+                browserAttemptTimeoutMs,
+                `web_research browser reader timed out after ${Math.ceil(browserAttemptTimeoutMs / 1e3)} seconds`,
+                signal
+              );
+              browserDurationMs += Date.now() - browserStartedAt;
+              sourceReadDurations.push(Date.now() - browserStartedAt);
+              attempts.push({ phase: "browser", url: rendered.finalUrl || rendered.url, status: "completed", durationMs: Date.now() - browserStartedAt });
+              fetchedSources.push({
+                url: scored.source.url,
+                finalUrl: rendered.finalUrl || rendered.url,
+                title: rendered.title || details2.title || scored.source.title,
+                textExcerpt: excerpt(rendered.text),
+                score: scored.score,
+                scoreReasons: scored.reasons,
+                extractionMethod: "browser_rendered",
+                citationAnchors: rendered.citationAnchors,
+                requiresBrowser: false,
+                browserReadSummary: {
+                  screenshotPath: rendered.screenshotPath,
+                  consoleMessageCount: rendered.consoleMessages?.length,
+                  networkRequestCount: rendered.networkRequests?.length
+                }
+              });
+              return;
+            } catch (error) {
+              browserDurationMs += Date.now() - browserStartedAt;
+              attempts.push({ phase: "browser", url: details2.finalUrl || scored.source.url, status: "failed", failureCategory: "requires_browser", durationMs: Date.now() - browserStartedAt });
+              warnings.push(`Browser reader failed for ${details2.finalUrl || scored.source.url}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+          }
+          browserRequiredSources.push(browserEntry);
+          return;
+        }
+        if (fetchResult.isError || !text) {
+          warnings.push(`Could not fetch ${scored.source.url}: ${details2.failureCategory || "fetch_failed"}`);
+          return;
+        }
+        fetchedSources.push({
+          url: scored.source.url,
+          finalUrl: details2.finalUrl || scored.source.url,
+          title: details2.title || scored.source.title,
+          textExcerpt: excerpt(text),
+          score: scored.score,
+          scoreReasons: scored.reasons,
+          extractionMethod: details2.extractionMethod,
+          citationAnchors: details2.citationAnchors,
+          requiresBrowser: false,
+          failureCategory: details2.failureCategory
+        });
+      };
+      for (let index = 0; index < candidateSources.length && fetchedSources.length < maxSources; index += 3) {
+        if (fetchedSources.length >= targetFetchedSources && qualityScore(fetchedSources, scoredSources) >= 75) {
+          warnings.push(`Stopped after ${fetchedSources.length} credible fetched source(s); quality target reached before max_sources=${maxSources}.`);
+          break;
+        }
+        const remaining = maxSources - fetchedSources.length;
+        const batch = candidateSources.slice(index, index + Math.min(3, remaining)).filter((scored) => fetchedSources.length < minimumFetchedSources || scored.score >= 55);
+        if (!batch.length) continue;
+        await Promise.all(batch.map((scored) => fetchScoredSource(scored)));
+      }
+      const score = qualityScore(fetchedSources, scoredSources);
+      const details = {
+        query,
+        actualQueries: [...new Set(actualQueries)],
+        sources: dedupedSources,
+        fetchedSources,
+        providerAttempts,
+        attempts,
+        qualityScore: score,
+        warnings: [...new Set(warnings)],
+        browserRequiredSources,
+        providerHealth: nextHealth,
+        routeRankReason,
+        latencyMetrics: {
+          totalDurationMs: Date.now() - totalStartedAt,
+          searchDurationMs,
+          fetchDurationMs,
+          browserDurationMs,
+          p95SourceReadMs: percentile(sourceReadDurations, 95)
+        },
+        costEstimate: {
+          status: "unknown",
+          reason: "Provider usage is not yet normalized across web research search/fetch/browser routes."
+        }
+      };
+      if (fetchedSources.length === 0) {
+        const reason = browserRequiredSources.length ? "web_research found candidate sources, but they require browser-rendered reading and no host browser reader completed." : "web_research could not fetch any credible source for this query.";
+        return {
+          content: [{ type: "text", text: `${reason}
+
+Queries tried: ${details.actualQueries.join("; ") || query}` }],
+          details,
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: formatResearchPack(query, fetchedSources, details.warnings, browserRequiredSources) }],
+        details
+      };
+    }
+  };
+}
+
 // ../../packages/shared-headless-capabilities/src/code-intel.ts
 import * as fs from "node:fs";
 import * as path2 from "node:path";
@@ -7943,8 +8352,8 @@ export {
   registerInteractionHandler,
   hasInteractionHandler,
   requestInteraction,
-  buildKnowledgeIndexEntry,
-  buildKnowledgeIndexSection,
+  AGENTS_CONTEXT_FILE_NAME,
+  buildProjectContextSection,
   evaluateTodoClosureAfterCompletedTurn,
   evaluateTodoClosureAfterFailedTurn,
   evaluateTodoClosureAfterAbort,
@@ -7958,6 +8367,7 @@ export {
   buildExecutionReminder,
   abortExecutionState,
   continueExecutionState,
+  pauseExecutionState,
   supersedeExecutionState,
   shouldPreserveExecutionStateForUserText,
   BUILTIN_TOOL_CAPABILITY_METADATA,
@@ -7966,11 +8376,8 @@ export {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   createPlanCapability,
-  createReadSkillCapability,
-  createReadResourceCapability,
   modalityForReadFileUnderstandingKind,
   createReadFileUnderstandingHandler,
-  createResolveResourceCapability,
   attachAgentEventsToSessionTrace,
   SessionTraceSnapshotWriter,
   formatSkillSummariesForPrompt,
@@ -7986,6 +8393,7 @@ export {
   buildToolsPromptSection,
   createSharedWebSearchTool,
   createSharedWebFetchTool,
+  createSharedWebResearchTool,
   createLightweightCodeIntelProvider,
   createCodeIntelTool
 };