chore: ignore safari example xcodeproj/project.pbxproj noise

The Safari browser-extension example regenerates UUIDs and timestamps
in project.pbxproj on every Xcode open/build — pure churn (239± lines)
that creates noisy diffs across every dev's local tree. Untrack the
generated pbxproj and gitignore it; the Swift sources, assets, and
Resources/ subtree stay tracked, and fresh clones that need to build
the example can regenerate the Xcode project from those.

Also rolls in the in-flight benchmark + message-service tool-call
forcing changes and the templates-manifest regeneration so the
worktree stays clean.

Author: lalalune

.gitignore

@@ -23,6 +23,12 @@ xcuserdata/
 # Tauri-generated Xcode project
 examples/browser-extension/safari/
 
+# Safari browser-extension example Xcode project — regenerates UUIDs +
+# timestamps on every Xcode open/build, creating large pure-churn diffs.
+# The Swift sources, assets, and Resources/ subtree stay tracked; only
+# the generated *.xcodeproj/ pbxproj is ignored.
+packages/examples/browser-extension/safari/**/*.xcodeproj/project.pbxproj
+
 # Generated app platform shells; canonical templates live under packages/app-core/platforms.
 packages/app/android/
 packages/app/ios/

packages/app-core/src/benchmark/server.ts

@@ -265,6 +265,18 @@ export async function startBenchmarkServer() {
     `[bench] Initializing eliza benchmark runtime on port ${port}...`,
   );
 
+  // Force the v5 planner to require a structured tool call on every benchmark
+  // turn (unless explicitly disabled). Without this, the planner often picks
+  // `REPLY` and emits the answer as prose, which scores 0 against harnesses
+  // like LifeOpsBench that judge on tool calls (`MESSAGE.triage`,
+  // `CALENDAR.create_event`, etc.). The core gate in `services/message.ts`
+  // (see `isBenchmarkForcingToolCall`) honors this env var ONLY for messages
+  // whose `content.source === "benchmark"` or whose `content.metadata.benchmark`
+  // is set, so a co-resident chat process is unaffected.
+  if (process.env.MILADY_BENCH_FORCE_TOOL_CALL === undefined) {
+    process.env.MILADY_BENCH_FORCE_TOOL_CALL = "1";
+  }
+
   // ═══════════════════════════════════════════════════════════════════════════
   // PLUGIN LOADING — Use full CORE_PLUGINS to test with realistic context
   // ═══════════════════════════════════════════════════════════════════════════
@@ -1014,27 +1026,60 @@ export async function startBenchmarkServer() {
           : callbackTexts.join("\n\n");
       const actions = coerceActions(result.responseContent?.actions);
       const params = coerceParams(result.responseContent?.params);
+      const capturedAction = getCapturedAction();
 
       // Map captured Eliza actions into lifeops_bench tool calls.
       // Strategy: each action name in `actions` is treated as a tool name;
       // its arguments come from `params[actionName]` when present, otherwise
       // an empty object. This matches how OpenClaw/Hermes adapters expose
       // their tool-call traces. The fake-backend rejects unsupported names
       // with a clear error so scenario authors learn about gaps quickly.
-      const toolCalls = actions.map((name, index) => {
+      const toolCalls: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+      }> = [];
+
+      // BENCHMARK_ACTION unwrap: when the planner picks BENCHMARK_ACTION, the
+      // bench plugin captures the underlying tool name + arguments (tau-bench
+      // shape: `{tool_name, arguments}`). Unwrap that capture into a real tool
+      // call against the LifeOps fake backend instead of forwarding the
+      // generic BENCHMARK_ACTION sentinel (which the fake backend rejects).
+      if (
+        capturedAction &&
+        typeof capturedAction.toolName === "string" &&
+        capturedAction.toolName.trim().length > 0
+      ) {
+        toolCalls.push({
+          id: "call_0",
+          name: capturedAction.toolName,
+          arguments:
+            capturedAction.arguments &&
+            typeof capturedAction.arguments === "object"
+              ? capturedAction.arguments
+              : {},
+        });
+      }
+
+      // Also pass through any directly-named actions (e.g. when the planner
+      // emits MESSAGE/CALENDAR directly without the BENCHMARK_ACTION wrapper),
+      // skipping the BENCHMARK_ACTION sentinel itself which has already been
+      // unwrapped above.
+      for (const name of actions) {
+        if (name === "BENCHMARK_ACTION") continue;
         const paramsForAction = params[name];
         const argumentsObj: Record<string, unknown> =
           paramsForAction &&
           typeof paramsForAction === "object" &&
           !Array.isArray(paramsForAction)
             ? (paramsForAction as Record<string, unknown>)
             : {};
-        return {
-          id: `call_${index}`,
+        toolCalls.push({
+          id: `call_${toolCalls.length}`,
           name,
           arguments: argumentsObj,
-        };
-      });
+        });
+      }
 
       // Sum the per-call cache-read tokens across every LLM call that fired
       // during this turn. A call with `cachedTokens === undefined` means the

packages/core/src/services/message.ts

@@ -4721,18 +4721,23 @@ export async function runV5MessageRuntimeStage1(args: {
 			logger: args.runtime.logger as PlannerRuntime["logger"],
 		};
 		const plannerTools = collectPlannerTools(plannerContextWithDecision);
+		const benchmarkForcingToolCall = isBenchmarkForcingToolCall(args.message);
 		const requireNonTerminalToolCall =
-			messageHandler.plan.requiresTool === true && plannerTools.length > 0;
+			(messageHandler.plan.requiresTool === true || benchmarkForcingToolCall) &&
+			plannerTools.length > 0;
 		const effectivePlannerContext = requireNonTerminalToolCall
 			? appendContextEvent(plannerContextWithDecision, {
 					id: `tool-required:${messageHandlerEndedAt}`,
 					type: "instruction",
 					source: "message-service",
 					createdAt: messageHandlerEndedAt,
-					content:
-						"The Stage 1 router marked this current turn as requiring a tool. " +
-						"Do not answer directly from memory, chat history, prior attachments, or prior tool output. " +
-						"Call at least one exposed non-terminal tool that can attempt the current request.",
+					content: benchmarkForcingToolCall
+						? "Benchmark harness mode: every turn must invoke a structured tool from the exposed action surface. " +
+							"Do not answer with REPLY/RESPOND prose — the harness scores tool calls, not conversation. " +
+							"Pick the single best non-terminal action (e.g. MESSAGE, CALENDAR, TODO) that can attempt the request and call it now."
+						: "The Stage 1 router marked this current turn as requiring a tool. " +
+							"Do not answer directly from memory, chat history, prior attachments, or prior tool output. " +
+							"Call at least one exposed non-terminal tool that can attempt the current request.",
 				})
 			: plannerContextWithDecision;
 		const evaluatorEffects: EvaluatorEffects = {

packages/elizaos/templates-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "generatedAt": "2026-05-11T16:59:10.319Z",
+  "generatedAt": "2026-05-11T17:03:45.262Z",
   "repoUrl": "https://github.com/elizaos/eliza",
   "templates": [
     {