fix(gitagent+eval): capture the real answer, not gitclaw status lines

gitagent (gitclaw) emits lifecycle status messages ("Agent X started/finished")
as plain text around the real answer and, unlike the Claude SDK, never sends a
`result` frame. So output-capturing consumers fell back to the last text line —
the trailing "Agent X finished" status — instead of the answer. Surfaced in the
Simulation Engine: a gitagent agent that answered "4" was scored against
"Agent agent-designer finished".

- engine-gitagent: track the real assistant text (extractAssistantText already
  ignores status lines) and emit a synthetic `result` frame at end-of-turn,
  mirroring engine-deepagents.
- eval-runner: defensively skip "Agent X started/finished" lines in the
  last-text fallback, so it works even before the engine fix is everywhere.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: patel-lyzr

packages/agentos-server/src/eval-runner.ts

@@ -296,7 +296,11 @@ export async function runAgainstHarness(
 
   const transcript = tOrder.flatMap((id) => tMessages.get(id) ?? []);
   const toolCalls = transcript.filter((e) => e.type === "tool_use" && e.tool).map((e) => e.tool as string);
-  const lastText = [...transcript].reverse().find((e) => e.type === "text")?.text ?? "";
+  // Fallback to the last real assistant text, skipping gitclaw lifecycle status
+  // lines ("Agent X started" / "Agent X finished") — those are wrapper output,
+  // not the answer, and would otherwise be captured as the final output.
+  const isLifecycle = (t: string): boolean => /^Agent .+ (started|finished)$/.test(t.trim());
+  const lastText = [...transcript].reverse().find((e) => e.type === "text" && e.text && !isLifecycle(e.text))?.text ?? "";
 
   const policyDenials: PolicyDenial[] = permissionDenials.map((d) => ({
     tool: d.tool_name ?? "unknown",

packages/engine-gitagent/src/engine.ts

@@ -156,6 +156,12 @@ export class GitAgentEngine implements EngineDriver<GitclawForwardOptions & { di
 
       // Stream this turn's messages. Each assistant text turn we observe
       // gets persisted + accumulated so the next iteration sees it.
+      // `finalText` tracks the real assistant answer (extractAssistantText
+      // ignores gitclaw's lifecycle/status lines) so we can emit a synthetic
+      // `result` frame at end-of-turn — gitclaw, unlike the Claude SDK, never
+      // sends one, which left output-capturing consumers (e.g. the eval runner)
+      // grabbing the trailing "Agent X finished" status instead of the answer.
+      let finalText = "";
       try {
         for await (const message of query(options)) {
           if (ctx.abortSignal.aborted) break;
@@ -181,6 +187,7 @@ export class GitAgentEngine implements EngineDriver<GitclawForwardOptions & { di
 
           const text = extractAssistantText(message);
           if (text) {
+            finalText = text;
             const assistantIndex = indexer.next();
             if (store) {
               await appendAssistantTurn(store, ctx.sessionId, text, assistantIndex);
@@ -194,6 +201,14 @@ export class GitAgentEngine implements EngineDriver<GitclawForwardOptions & { di
             } as SessionStoreEntry);
           }
         }
+        // Synthetic result frame carrying this turn's final answer. gitclaw
+        // emits no Claude-SDK-style `result` message, so without this the
+        // answer is only available as mid-stream assistant text — and raw
+        // consumers fall back to the last text line, which is gitclaw's
+        // "Agent X finished" status. (deepagents synthesizes one too.)
+        if (finalText) {
+          yield { kind: "sdk_message", payload: { type: "result", subtype: "success", result: finalText } };
+        }
         log.info("engine.turn.end", {
           engine: "gitagent",
           sessionId: ctx.sessionId,