@tea-agent/loop-agent 0.13.0 → 0.14.0

package/dist/commands/loop-benchmark.js

@@ -37,17 +37,17 @@ export function parseLoopBenchmarkArgs(args) {
     return { json, markdown, outputPath };
 }
 export function printLoopBenchmarkUsage() {
-    console.log(`usage: loop-benchmark [options]
-
-Deterministic loop-agent loop benchmark baseline (no live Pi/Cursor calls).
-
-Options:
-  --json              Emit JSON (default when no format flag is set)
-  --markdown          Emit Markdown report
-  --output <path>     Write Markdown report to a repo-relative or absolute path
-  -h, --help          Show this help
-
-Control groups: single-repair, 3-pass-convergence, 3-pass-convergence+quota.
+    console.log(`usage: loop-benchmark [options]
+
+Deterministic loop-agent loop benchmark baseline (no live Pi/Cursor calls).
+
+Options:
+  --json              Emit JSON (default when no format flag is set)
+  --markdown          Emit Markdown report
+  --output <path>     Write Markdown report to a repo-relative or absolute path
+  -h, --help          Show this help
+
+Control groups: single-repair, 3-pass-convergence, 3-pass-convergence+quota.
 Recommendation never changes convergence.enabled default.`);
 }
 export async function runLoopBenchmark(repoRoot, rawArgs) {

package/dist/commands/pi-reuse-benchmark.js

@@ -106,22 +106,22 @@ export function parsePiReuseBenchmarkArgs(args) {
     };
 }
 export function printPiReuseBenchmarkUsage() {
-    console.log(`usage: pi-reuse-benchmark [options]
-
-Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
-
-Options:
-  --report <path>         Benchmark report markdown (approval status)
-  --approval <path>       Explicit approval JSON artifact
-  --off-executor <path>   Baseline executor.jsonl (reuse off)
-  --on-executor <path>    Treatment executor.jsonl (reuse on)
-  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
-  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
-  --json                  Emit JSON (default when no format flag is set)
-  --markdown              Emit Markdown summary
-  -h, --help              Show this help
-
-Recommendations: defer | maintain-opt-in | eligible-for-human-review
+    console.log(`usage: pi-reuse-benchmark [options]
+
+Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
+
+Options:
+  --report <path>         Benchmark report markdown (approval status)
+  --approval <path>       Explicit approval JSON artifact
+  --off-executor <path>   Baseline executor.jsonl (reuse off)
+  --on-executor <path>    Treatment executor.jsonl (reuse on)
+  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
+  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
+  --json                  Emit JSON (default when no format flag is set)
+  --markdown              Emit Markdown summary
+  -h, --help              Show this help
+
+Recommendations: defer | maintain-opt-in | eligible-for-human-review
 Never changes CODE_AGENT_PI_REUSE_RUNTIME default (off).`);
 }
 function resolveRepoRelative(repoRoot, filePath) {

package/dist/executors/pi-event-serializer.js

@@ -5,39 +5,61 @@
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+function unifyToolPayloadFields(event) {
+    const out = { ...event };
+    const args = out.args ?? out.input ?? out.toolInput;
+    if (args !== undefined) {
+        out.args = args;
+        if (out.input === undefined)
+            out.input = args;
+    }
+    const result = out.result ?? out.toolResult;
+    if (result !== undefined) {
+        out.result = result;
+    }
+    return out;
+}
 /** Map SDK event shapes to the JSONL format emitted by `pi -p --mode json`. */
 export function normalizePiSessionEvent(event) {
     const type = typeof event.type === 'string' ? event.type : undefined;
     if (type === 'assistant_message' && isRecord(event.message)) {
-        return {
+        return unifyToolPayloadFields({
             type: 'turn_end',
             message: event.message,
             usage: event.usage,
-        };
+        });
     }
     if (type === 'tool_start' && typeof event.toolName === 'string') {
-        return {
+        const args = event.args ?? event.input ?? event.toolInput;
+        return unifyToolPayloadFields({
             type: 'tool_execution_start',
             toolName: event.toolName,
             toolCallId: event.toolCallId,
-            input: event.input,
-        };
+            input: args,
+            args,
+        });
     }
     if (type === 'tool_end' && typeof event.toolName === 'string') {
-        return {
+        const result = event.result ?? event.toolResult;
+        return unifyToolPayloadFields({
             type: 'tool_execution_end',
             toolName: event.toolName,
             toolCallId: event.toolCallId,
             isError: event.isError,
-        };
+            ...(result !== undefined ? { result } : {}),
+        });
     }
-    return event;
+    return unifyToolPayloadFields(event);
 }
 /** Serialize one SDK session event as a single JSONL line. */
-export function serializeSessionEvent(event) {
-    return JSON.stringify(normalizePiSessionEvent(event));
+export function serializeSessionEvent(event, options) {
+    const normalized = normalizePiSessionEvent(event);
+    if (typeof normalized.recordedAt !== 'string') {
+        normalized.recordedAt = options?.recordedAt ?? new Date().toISOString();
+    }
+    return JSON.stringify(normalized);
 }
 /** Serialize multiple events into newline-delimited JSON (no trailing newline). */
 export function serializeSessionEvents(events) {
-    return events.map(serializeSessionEvent).join('\n');
+    return events.map((event) => serializeSessionEvent(event)).join('\n');
 }

package/dist/sidecars/cursor-prompt/executor.js

@@ -29,7 +29,7 @@ export function resolveArtifactWriteDir(options) {
 }
 export function buildArtifactPathPrompt(writeDir) {
     if (!writeDir)
-        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
+        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
 ${ARTIFACT_INSTRUCTIONS}`;
     return [
         `After changes, write the following files:`,

package/dist/task/runtime.js

@@ -236,35 +236,35 @@ export function shouldInjectSubagentGuidance(step, mode) {
     return false;
 }
 /** Advisory guidance for `analyze-plan` mode. */
-export const SUBAGENT_GUIDANCE_STANDARD = `<subagent_guidance>
-You have access to the \`subagent\` tool for lightweight delegation within this step.
-Use it only for read-only tasks:
-- Parallel scout: dispatch multiple subagents to search/read different areas simultaneously
-- Chain: scout -> planner (one subagent scouts, another plans based on findings)
-- Reviewer: have a subagent review your analysis/plan before finalizing
-Do NOT use subagent for writing, editing, or executing commands.
-Subagent output is advisory only; always verify and incorporate findings into your own output.
-Do NOT treat subagent results as authoritative state or artifact sources.
+export const SUBAGENT_GUIDANCE_STANDARD = `<subagent_guidance>
+You have access to the \`subagent\` tool for lightweight delegation within this step.
+Use it only for read-only tasks:
+- Parallel scout: dispatch multiple subagents to search/read different areas simultaneously
+- Chain: scout -> planner (one subagent scouts, another plans based on findings)
+- Reviewer: have a subagent review your analysis/plan before finalizing
+Do NOT use subagent for writing, editing, or executing commands.
+Subagent output is advisory only; always verify and incorporate findings into your own output.
+Do NOT treat subagent results as authoritative state or artifact sources.
 </subagent_guidance>`;
 /** Strong guidance for `full` mode — prescriptive when to delegate. */
-export const SUBAGENT_GUIDANCE_STRONG = `<subagent_guidance>
-You have access to the \`subagent\` tool for lightweight delegation within this step.
-
-You SHOULD delegate to subagent scouts when:
-- The task requires scanning 3+ directories or comparing implementations across modules
-- You would otherwise need 5+ sequential read/grep calls to gather context
-- A reviewer subagent can independently catch scope drift before you finalize your output
-
-Delegation saves context tokens and produces better results.
-
-Allowed patterns:
-- Parallel scout: dispatch 2-3 subagents simultaneously to cover different file trees
-- Chain: scout -> planner (one subagent scouts, another plans based on findings)
-- Reviewer: have a subagent review your analysis/plan before finalizing
-
-Do NOT use subagent for writing, editing, or executing commands.
-Subagent output is advisory only; always verify and incorporate findings into your own output.
-Do NOT treat subagent results as authoritative state or artifact sources.
+export const SUBAGENT_GUIDANCE_STRONG = `<subagent_guidance>
+You have access to the \`subagent\` tool for lightweight delegation within this step.
+
+You SHOULD delegate to subagent scouts when:
+- The task requires scanning 3+ directories or comparing implementations across modules
+- You would otherwise need 5+ sequential read/grep calls to gather context
+- A reviewer subagent can independently catch scope drift before you finalize your output
+
+Delegation saves context tokens and produces better results.
+
+Allowed patterns:
+- Parallel scout: dispatch 2-3 subagents simultaneously to cover different file trees
+- Chain: scout -> planner (one subagent scouts, another plans based on findings)
+- Reviewer: have a subagent review your analysis/plan before finalizing
+
+Do NOT use subagent for writing, editing, or executing commands.
+Subagent output is advisory only; always verify and incorporate findings into your own output.
+Do NOT treat subagent results as authoritative state or artifact sources.
 </subagent_guidance>`;
 /** Preserved for backward compatibility (alias of STANDARD). */
 export const SUBAGENT_GUIDANCE = SUBAGENT_GUIDANCE_STANDARD;

package/dist/worker/observe/spec-evidence.js

@@ -87,7 +87,11 @@ function resolveToolName(event) {
     return (event.toolName ?? "").toLowerCase();
 }
 function eventTimestamp(event) {
-    return event.timestamp ?? event.at;
+    return event.timestamp ?? event.at ?? event.recordedAt;
+}
+function eventToolArgs(event) {
+    const args = event.args ?? event.toolInput ?? event.input;
+    return args && typeof args === "object" && !Array.isArray(args) ? args : {};
 }
 /**
  * Parse a tool input path to a repo-relative path.
@@ -150,7 +154,7 @@ export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
         const type = event.type;
         const toolName = resolveToolName(event);
         const toolCallId = event.toolCallId;
-        const toolInput = event.toolInput ?? event.input ?? {};
+        const toolInput = eventToolArgs(event);
         const ts = eventTimestamp(event);
         // Collect tool_execution_start events by toolCallId
         if (type === "tool_execution_start" && toolCallId) {
@@ -159,18 +163,21 @@ export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
         }
         // Process tool_execution_end events
         if (type === "tool_execution_end") {
+            const start = toolCallId ? startMap.get(toolCallId) : undefined;
+            const pairedInput = start?.input ?? toolInput;
             // Successful read calls: must have matching start event and no error
             if (toolName === "read") {
                 const isErrored = event.isError === true ||
                     event.toolResult?.error != null ||
-                    event.toolResult?.ok === false;
+                    event.toolResult?.ok === false ||
+                    event.result?.error != null ||
+                    event.result?.ok === false;
                 if (isErrored)
                     continue;
                 let filePath;
                 // Only paired read calls qualify: must have toolCallId, matching start
                 // with same toolName, and start must be a "read" tool.
                 if (toolCallId) {
-                    const start = startMap.get(toolCallId);
                     if (start && start.toolName === "read") {
                         const startInput = start.input ?? {};
                         filePath = typeof startInput.path === "string" ? startInput.path : undefined;
@@ -188,18 +195,20 @@ export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
             }
             // Search/scan tool calls (grep, find, ls, glob)
             if (["grep", "find", "ls", "glob"].includes(toolName)) {
-                const query = typeof toolInput.pattern === "string"
-                    ? toolInput.pattern
-                    : typeof toolInput.query === "string"
-                        ? toolInput.query
-                        : typeof toolInput.path === "string"
-                            ? toolInput.path
+                const query = typeof pairedInput.pattern === "string"
+                    ? pairedInput.pattern
+                    : typeof pairedInput.query === "string"
+                        ? pairedInput.query
+                        : typeof pairedInput.path === "string"
+                            ? pairedInput.path
                             : toolName;
                 searches.push({
                     tool: toolName,
                     query,
                     timestamp: ts,
                 });
+                if (toolCallId)
+                    startMap.delete(toolCallId);
             }
             // Knowledge base connector calls
             if (isKnowledgeBaseTool(toolName)) {

package/dist/worker/observe/static/api.js

@@ -1,46 +1,46 @@
-/** Fetch and artifact helpers (Observe UI R5). */
-
-export async function fetchJson(url) {
-	try {
-		const res = await fetch(url);
-		if (!res.ok) return null;
-		return await res.json();
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Read-only JSON fetch that preserves HTTP status so callers can distinguish
- * 404 (missing) from 409 (ambiguous task identity). Body is parsed best-effort.
- */
-export async function fetchJsonResult(url) {
-	try {
-		const res = await fetch(url);
-		let body = null;
-		try {
-			body = await res.json();
-		} catch {
-			body = null;
-		}
-		return { ok: res.ok, status: res.status, body };
-	} catch {
-		return { ok: false, status: 0, body: null };
-	}
-}
-
-export function artifactUrl(artifactPath) {
-	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
-}
-
-export function parseArtifactPreviewResponse(text) {
-	const parsed = JSON.parse(text);
-	if (!parsed || typeof parsed.content !== "string") {
-		throw new Error("Artifact preview response is invalid");
-	}
-	return {
-		content: parsed.content,
-		truncated: parsed.truncated === true,
-	};
-}
-
+/** Fetch and artifact helpers (Observe UI R5). */
+
+export async function fetchJson(url) {
+	try {
+		const res = await fetch(url);
+		if (!res.ok) return null;
+		return await res.json();
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Read-only JSON fetch that preserves HTTP status so callers can distinguish
+ * 404 (missing) from 409 (ambiguous task identity). Body is parsed best-effort.
+ */
+export async function fetchJsonResult(url) {
+	try {
+		const res = await fetch(url);
+		let body = null;
+		try {
+			body = await res.json();
+		} catch {
+			body = null;
+		}
+		return { ok: res.ok, status: res.status, body };
+	} catch {
+		return { ok: false, status: 0, body: null };
+	}
+}
+
+export function artifactUrl(artifactPath) {
+	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
+}
+
+export function parseArtifactPreviewResponse(text) {
+	const parsed = JSON.parse(text);
+	if (!parsed || typeof parsed.content !== "string") {
+		throw new Error("Artifact preview response is invalid");
+	}
+	return {
+		content: parsed.content,
+		truncated: parsed.truncated === true,
+	};
+}
+