@mastra/code-sdk 0.0.0-mastracode-cloud-20260706153555

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/constants.ts"],"sourcesContent":["import * as path from 'node:path';\n\n// Default config directory name used for all project-level and global config paths.\nexport const DEFAULT_CONFIG_DIR = '.mastracode';\n\n/**\n * Validate that a configDirName is a safe single directory name.\n * Rejects absolute paths, path separators, and traversal components.\n */\nexport function validateConfigDirName(configDirName: string): void {\n  if (configDirName.trim().length === 0) {\n    throw new Error('configDirName must be a non-empty directory name');\n  }\n\n  if (\n    path.isAbsolute(configDirName) ||\n    configDirName.includes('/') ||\n    configDirName.includes('\\\\') ||\n    configDirName === '..' ||\n    configDirName === '.'\n  ) {\n    throw new Error(\n      `configDirName must be a single directory name without path separators or traversal components, got: \"${configDirName}\"`,\n    );\n  }\n}\n\n// Default OM model - using gemini-2.5-flash for efficiency\nexport const DEFAULT_OM_MODEL_ID = process.env.DEFAULT_OM_MODEL_ID ?? 'google/gemini-2.5-flash';\n\n// Default OM thresholds — per-thread overrides are loaded from thread metadata\nexport const DEFAULT_OBS_THRESHOLD = 30_000;\nexport const DEFAULT_REF_THRESHOLD = 40_000;\n"],"mappings":"AAAA,YAAY,UAAU;AAGf,MAAM,qBAAqB;AAM3B,SAAS,sBAAsB,eAA6B;AACjE,MAAI,cAAc,KAAK,EAAE,WAAW,GAAG;AACrC,UAAM,IAAI,MAAM,kDAAkD;AAAA,EACpE;AAEA,MACE,KAAK,WAAW,aAAa,KAC7B,cAAc,SAAS,GAAG,KAC1B,cAAc,SAAS,IAAI,KAC3B,kBAAkB,QAClB,kBAAkB,KAClB;AACA,UAAM,IAAI;AAAA,MACR,wGAAwG,aAAa;AAAA,IACvH;AAAA,EACF;AACF;AAGO,MAAM,sBAAsB,QAAQ,IAAI,uBAAuB;AAG/D,MAAM,wBAAwB;AAC9B,MAAM,wBAAwB;","names":[]}

package/dist/error-classification.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks whether an error is an ERR_STREAM_DESTROYED error, which is a
+ * non-fatal condition that occurs when code writes to a stream after it
+ * has been closed (e.g., client disconnect, cancelled LLM stream, LSP
+ * shutdown, killed subprocess).
+ *
+ * Walks the `.cause` chain up to a depth limit.
+ */
+export declare function isStreamDestroyedError(err: unknown, depth?: number): boolean;
+//# sourceMappingURL=error-classification.d.ts.map

package/dist/error-classification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-classification.d.ts","sourceRoot":"","sources":["../src/error-classification.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,OAAO,CASvE"}

package/dist/error-classification.js

@@ -0,0 +1,14 @@
+function isStreamDestroyedError(err, depth = 0) {
+  if (!err || depth > 5) return false;
+  const e = err;
+  if (e.code === "ERR_STREAM_DESTROYED") return true;
+  if (typeof e.message === "string" && e.message.includes("stream was destroyed")) return true;
+  if (e.cause && isStreamDestroyedError(e.cause, depth + 1)) return true;
+  if (Array.isArray(e.errors) && e.errors.some((inner) => isStreamDestroyedError(inner, depth + 1)))
+    return true;
+  return false;
+}
+export {
+  isStreamDestroyedError
+};
+//# sourceMappingURL=error-classification.js.map

package/dist/error-classification.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/error-classification.ts"],"sourcesContent":["/**\n * Checks whether an error is an ERR_STREAM_DESTROYED error, which is a\n * non-fatal condition that occurs when code writes to a stream after it\n * has been closed (e.g., client disconnect, cancelled LLM stream, LSP\n * shutdown, killed subprocess).\n *\n * Walks the `.cause` chain up to a depth limit.\n */\nexport function isStreamDestroyedError(err: unknown, depth = 0): boolean {\n  if (!err || depth > 5) return false;\n  const e = err as any;\n  if (e.code === 'ERR_STREAM_DESTROYED') return true;\n  if (typeof e.message === 'string' && e.message.includes('stream was destroyed')) return true;\n  if (e.cause && isStreamDestroyedError(e.cause, depth + 1)) return true;\n  if (Array.isArray(e.errors) && e.errors.some((inner: unknown) => isStreamDestroyedError(inner, depth + 1)))\n    return true;\n  return false;\n}\n"],"mappings":"AAQO,SAAS,uBAAuB,KAAc,QAAQ,GAAY;AACvE,MAAI,CAAC,OAAO,QAAQ,EAAG,QAAO;AAC9B,QAAM,IAAI;AACV,MAAI,EAAE,SAAS,uBAAwB,QAAO;AAC9C,MAAI,OAAO,EAAE,YAAY,YAAY,EAAE,QAAQ,SAAS,sBAAsB,EAAG,QAAO;AACxF,MAAI,EAAE,SAAS,uBAAuB,EAAE,OAAO,QAAQ,CAAC,EAAG,QAAO;AAClE,MAAI,MAAM,QAAQ,EAAE,MAAM,KAAK,EAAE,OAAO,KAAK,CAAC,UAAmB,uBAAuB,OAAO,QAAQ,CAAC,CAAC;AACvG,WAAO;AACT,SAAO;AACT;","names":[]}

package/dist/evals/context-builder.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Eval Context Builder for MastraCode
+ *
+ * Converts AgentController session data into scorer-compatible format.
+ * Supports both agent-type scorers (ScorerRunInputForAgent) and
+ * trajectory scorers (Trajectory).
+ */
+import type { AgentController, Session } from '@mastra/core/agent-controller';
+import type { ScorerRunInputForAgent, ScorerRunOutputForAgent, Trajectory } from '@mastra/core/evals';
+export type MastraCodeEvalContext = {
+    /** Scorer-compatible agent input (messages, system prompt, etc.) */
+    agentInput: ScorerRunInputForAgent;
+    /** Scorer-compatible agent output (response messages) */
+    agentOutput: ScorerRunOutputForAgent;
+    /** Execution trajectory extracted from trace spans */
+    trajectory: Trajectory | undefined;
+    /** Request context with session metadata */
+    requestContext: Record<string, unknown>;
+    /** The thread ID this context was built from */
+    threadId: string;
+    /** The trace ID for observability linkage */
+    traceId: string | undefined;
+};
+export type BuildContextOptions = {
+    /** AgentController instance to extract data from */
+    controller: AgentController<any>;
+    /** Session whose state/model/thread is being evaluated */
+    session: Session<any>;
+    /** Thread ID to build context for (defaults to current thread) */
+    threadId?: string;
+    /** Limit messages to the last N turns (user+assistant pairs). Undefined = all messages */
+    lastNTurns?: number;
+};
+/**
+ * Build an evaluation context from a AgentController session.
+ *
+ * This extracts messages from storage, builds trajectory from trace spans,
+ * and packages everything into the format scorers expect.
+ */
+export declare function buildEvalContext(options: BuildContextOptions): Promise<MastraCodeEvalContext>;
+//# sourceMappingURL=context-builder.d.ts.map

package/dist/evals/context-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-builder.d.ts","sourceRoot":"","sources":["../../src/evals/context-builder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAE9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAItG,MAAM,MAAM,qBAAqB,GAAG;IAClC,oEAAoE;IACpE,UAAU,EAAE,sBAAsB,CAAC;IACnC,yDAAyD;IACzD,WAAW,EAAE,uBAAuB,CAAC;IACrC,sDAAsD;IACtD,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC;IACnC,4CAA4C;IAC5C,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,oDAAoD;IACpD,UAAU,EAAE,eAAe,CAAC,GAAG,CAAC,CAAC;IACjC,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAoCnG"}

package/dist/evals/context-builder.js

@@ -0,0 +1,120 @@
+import { extractTrajectoryFromTrace } from "@mastra/core/evals";
+async function buildEvalContext(options) {
+  const { controller, session, lastNTurns } = options;
+  const threadId = options.threadId ?? session.thread.getId();
+  if (!threadId) {
+    throw new Error("No thread ID available. Start a session before building eval context.");
+  }
+  const mastra = controller.getMastra();
+  const storage = mastra?.getStorage();
+  const rawMessages = await getRawMessages(storage, threadId, lastNTurns);
+  const { inputMessages, systemMessages, outputMessages } = categorizeMessages(rawMessages);
+  const { trajectory, traceId } = await extractSessionTrajectory(storage, threadId);
+  const requestContext = buildRequestContext(session, threadId);
+  return {
+    agentInput: {
+      inputMessages,
+      rememberedMessages: [],
+      // AgentController doesn't separate these; memory recall is transparent
+      systemMessages,
+      taggedSystemMessages: {}
+    },
+    agentOutput: outputMessages,
+    trajectory,
+    requestContext,
+    threadId,
+    traceId
+  };
+}
+async function getRawMessages(storage, threadId, lastNTurns) {
+  if (!storage) return [];
+  const memoryStore = await storage.getStore("memory");
+  if (!memoryStore) return [];
+  const result = await memoryStore.listMessages({
+    threadId,
+    perPage: false
+  });
+  let messages = result.messages;
+  if (lastNTurns !== void 0 && lastNTurns > 0) {
+    messages = trimToLastNTurns(messages, lastNTurns);
+  }
+  return messages;
+}
+function trimToLastNTurns(messages, turns) {
+  let turnCount = 0;
+  let cutoffIndex = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      turnCount++;
+      if (turnCount === turns) {
+        cutoffIndex = i;
+        break;
+      }
+    }
+  }
+  return messages.slice(cutoffIndex);
+}
+function categorizeMessages(messages) {
+  const inputMessages = [];
+  const systemMessages = [];
+  const outputMessages = [];
+  for (const msg of messages) {
+    switch (msg.role) {
+      case "user":
+        inputMessages.push(msg);
+        break;
+      case "system":
+        systemMessages.push({
+          role: "system",
+          content: extractTextContent(msg)
+        });
+        break;
+      case "assistant":
+        outputMessages.push(msg);
+        break;
+    }
+  }
+  return { inputMessages, systemMessages, outputMessages };
+}
+function extractTextContent(msg) {
+  if (!msg.content?.parts) return "";
+  return msg.content.parts.filter((p) => p.type === "text" && "text" in p).map((p) => p.text).join("\n");
+}
+async function extractSessionTrajectory(storage, threadId) {
+  if (!storage) return { trajectory: void 0, traceId: void 0 };
+  try {
+    const observabilityStore = await storage.getStore("observability");
+    if (!observabilityStore) return { trajectory: void 0, traceId: void 0 };
+    const result = await observabilityStore.listTraces({
+      filters: { threadId },
+      pagination: { page: 0, perPage: 1 },
+      orderBy: { field: "startedAt", direction: "DESC" }
+    });
+    if (!result?.spans?.length) return { trajectory: void 0, traceId: void 0 };
+    const traceId = result.spans[0].traceId;
+    const trace = await observabilityStore.getTrace({ traceId });
+    if (!trace?.spans?.length) return { trajectory: void 0, traceId };
+    const trajectory = extractTrajectoryFromTrace(trace.spans);
+    return { trajectory, traceId };
+  } catch {
+    return { trajectory: void 0, traceId: void 0 };
+  }
+}
+function buildRequestContext(session, threadId) {
+  const state = session.state.get();
+  return {
+    threadId,
+    mode: state.currentMode ?? state.mode,
+    modelId: session.model.get(),
+    projectPath: state.projectPath,
+    projectName: state.projectName,
+    gitBranch: state.gitBranch,
+    thinkingLevel: state.thinkingLevel,
+    yolo: state.yolo,
+    smartEditing: state.smartEditing
+  };
+}
+export {
+  buildEvalContext
+};
+//# sourceMappingURL=context-builder.js.map

package/dist/evals/context-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/evals/context-builder.ts"],"sourcesContent":["/**\n * Eval Context Builder for MastraCode\n *\n * Converts AgentController session data into scorer-compatible format.\n * Supports both agent-type scorers (ScorerRunInputForAgent) and\n * trajectory scorers (Trajectory).\n */\n\nimport type { MastraDBMessage } from '@mastra/core/agent';\nimport type { AgentController, Session } from '@mastra/core/agent-controller';\nimport { extractTrajectoryFromTrace } from '@mastra/core/evals';\nimport type { ScorerRunInputForAgent, ScorerRunOutputForAgent, Trajectory } from '@mastra/core/evals';\nimport type { CoreMessage, CoreSystemMessage } from '@mastra/core/llm';\nimport type { MastraCompositeStore } from '@mastra/core/storage';\n\nexport type MastraCodeEvalContext = {\n  /** Scorer-compatible agent input (messages, system prompt, etc.) */\n  agentInput: ScorerRunInputForAgent;\n  /** Scorer-compatible agent output (response messages) */\n  agentOutput: ScorerRunOutputForAgent;\n  /** Execution trajectory extracted from trace spans */\n  trajectory: Trajectory | undefined;\n  /** Request context with session metadata */\n  requestContext: Record<string, unknown>;\n  /** The thread ID this context was built from */\n  threadId: string;\n  /** The trace ID for observability linkage */\n  traceId: string | undefined;\n};\n\nexport type BuildContextOptions = {\n  /** AgentController instance to extract data from */\n  controller: AgentController<any>;\n  /** Session whose state/model/thread is being evaluated */\n  session: Session<any>;\n  /** Thread ID to build context for (defaults to current thread) */\n  threadId?: string;\n  /** Limit messages to the last N turns (user+assistant pairs). Undefined = all messages */\n  lastNTurns?: number;\n};\n\n/**\n * Build an evaluation context from a AgentController session.\n *\n * This extracts messages from storage, builds trajectory from trace spans,\n * and packages everything into the format scorers expect.\n */\nexport async function buildEvalContext(options: BuildContextOptions): Promise<MastraCodeEvalContext> {\n  const { controller, session, lastNTurns } = options;\n  const threadId = options.threadId ?? session.thread.getId();\n\n  if (!threadId) {\n    throw new Error('No thread ID available. Start a session before building eval context.');\n  }\n\n  const mastra = controller.getMastra();\n  const storage = mastra?.getStorage();\n\n  // 1. Get raw MastraDB messages from memory storage\n  const rawMessages = await getRawMessages(storage, threadId, lastNTurns);\n\n  // 2. Split messages into input/output categories\n  const { inputMessages, systemMessages, outputMessages } = categorizeMessages(rawMessages);\n\n  // 3. Extract trajectory from observability traces\n  const { trajectory, traceId } = await extractSessionTrajectory(storage, threadId);\n\n  // 4. Build request context from AgentController state\n  const requestContext = buildRequestContext(session, threadId);\n\n  return {\n    agentInput: {\n      inputMessages,\n      rememberedMessages: [], // AgentController doesn't separate these; memory recall is transparent\n      systemMessages,\n      taggedSystemMessages: {},\n    },\n    agentOutput: outputMessages,\n    trajectory,\n    requestContext,\n    threadId,\n    traceId,\n  };\n}\n\n/**\n * Fetch raw MastraDBMessage[] from memory storage for a thread.\n */\nasync function getRawMessages(\n  storage: MastraCompositeStore | undefined,\n  threadId: string,\n  lastNTurns?: number,\n): Promise<MastraDBMessage[]> {\n  if (!storage) return [];\n\n  const memoryStore = await storage.getStore('memory');\n  if (!memoryStore) return [];\n\n  const result = await memoryStore.listMessages({\n    threadId,\n    perPage: false,\n  });\n\n  let messages = result.messages;\n\n  if (lastNTurns !== undefined && lastNTurns > 0) {\n    messages = trimToLastNTurns(messages, lastNTurns);\n  }\n\n  return messages;\n}\n\n/**\n * Trim messages to the last N user-assistant turn pairs.\n */\nfunction trimToLastNTurns(messages: MastraDBMessage[], turns: number): MastraDBMessage[] {\n  // Walk backward, counting user messages as turn boundaries.\n  // When we find the Nth user message, slice from there to include\n  // that turn and everything after it.\n  let turnCount = 0;\n  let cutoffIndex = 0;\n\n  for (let i = messages.length - 1; i >= 0; i--) {\n    if (messages[i]!.role === 'user') {\n      turnCount++;\n      if (turnCount === turns) {\n        cutoffIndex = i;\n        break;\n      }\n    }\n  }\n\n  return messages.slice(cutoffIndex);\n}\n\n/**\n * Categorize messages into input (user), system, and output (assistant) groups.\n */\nfunction categorizeMessages(messages: MastraDBMessage[]): {\n  inputMessages: MastraDBMessage[];\n  systemMessages: CoreMessage[];\n  outputMessages: MastraDBMessage[];\n} {\n  const inputMessages: MastraDBMessage[] = [];\n  const systemMessages: CoreSystemMessage[] = [];\n  const outputMessages: MastraDBMessage[] = [];\n\n  for (const msg of messages) {\n    switch (msg.role) {\n      case 'user':\n        inputMessages.push(msg);\n        break;\n      case 'system':\n        systemMessages.push({\n          role: 'system',\n          content: extractTextContent(msg),\n        });\n        break;\n      case 'assistant':\n        outputMessages.push(msg);\n        break;\n    }\n  }\n\n  return { inputMessages, systemMessages, outputMessages };\n}\n\n/**\n * Extract plain text content from a MastraDBMessage.\n */\nfunction extractTextContent(msg: MastraDBMessage): string {\n  if (!msg.content?.parts) return '';\n\n  return msg.content.parts\n    .filter((p): p is { type: 'text'; text: string } => p.type === 'text' && 'text' in p)\n    .map(p => p.text)\n    .join('\\n');\n}\n\n/**\n * Extract trajectory from trace spans in observability storage.\n * Looks up traces by threadId metadata.\n */\nasync function extractSessionTrajectory(\n  storage: MastraCompositeStore | undefined,\n  threadId: string,\n): Promise<{ trajectory: Trajectory | undefined; traceId: string | undefined }> {\n  if (!storage) return { trajectory: undefined, traceId: undefined };\n\n  try {\n    const observabilityStore = await storage.getStore('observability');\n    if (!observabilityStore) return { trajectory: undefined, traceId: undefined };\n\n    // Find traces associated with this thread\n    const result = await observabilityStore.listTraces({\n      filters: { threadId },\n      pagination: { page: 0, perPage: 1 },\n      orderBy: { field: 'startedAt', direction: 'DESC' },\n    });\n\n    if (!result?.spans?.length) return { trajectory: undefined, traceId: undefined };\n\n    const traceId = result.spans[0]!.traceId;\n    const trace = await observabilityStore.getTrace({ traceId });\n\n    if (!trace?.spans?.length) return { trajectory: undefined, traceId };\n\n    const trajectory = extractTrajectoryFromTrace(trace.spans);\n    return { trajectory, traceId };\n  } catch {\n    // Trace extraction is best-effort\n    return { trajectory: undefined, traceId: undefined };\n  }\n}\n\n/**\n * Build request context from AgentController state for scorer evaluation.\n */\nfunction buildRequestContext(session: Session<any>, threadId: string): Record<string, unknown> {\n  const state = session.state.get() as Record<string, unknown>;\n\n  return {\n    threadId,\n    mode: state.currentMode ?? state.mode,\n    modelId: session.model.get(),\n    projectPath: state.projectPath,\n    projectName: state.projectName,\n    gitBranch: state.gitBranch,\n    thinkingLevel: state.thinkingLevel,\n    yolo: state.yolo,\n    smartEditing: state.smartEditing,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/evals/index.d.ts

@@ -0,0 +1,4 @@
+export { buildEvalContext } from './context-builder.js';
+export type { MastraCodeEvalContext, BuildContextOptions } from './context-builder.js';
+export { createOutcomeScorer, createEfficiencyScorer } from './scorers/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/evals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/evals/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACvF,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/evals/index.js

@@ -0,0 +1,8 @@
+import { buildEvalContext } from "./context-builder.js";
+import { createOutcomeScorer, createEfficiencyScorer } from "./scorers/index.js";
+export {
+  buildEvalContext,
+  createEfficiencyScorer,
+  createOutcomeScorer
+};
+//# sourceMappingURL=index.js.map

package/dist/evals/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/evals/index.ts"],"sourcesContent":["export { buildEvalContext } from './context-builder.js';\nexport type { MastraCodeEvalContext, BuildContextOptions } from './context-builder.js';\nexport { createOutcomeScorer, createEfficiencyScorer } from './scorers/index.js';\n"],"mappings":"AAAA,SAAS,wBAAwB;AAEjC,SAAS,qBAAqB,8BAA8B;","names":[]}

package/dist/evals/scorers/classify-command.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared command classification utilities for scoring.
+ *
+ * Used by both live scorers (outcome.ts) and offline scorers (outcome-match.ts)
+ * to consistently identify build, test, and other command types.
+ */
+/**
+ * Check if a command string is a build/typecheck command.
+ * Handles compound commands (e.g. `pnpm build && pnpm test`) by checking each segment.
+ */
+export declare function isBuildCommand(command: string): boolean;
+/**
+ * Check if a command string is a test command.
+ */
+export declare function isTestCommand(command: string): boolean;
+/**
+ * Extract exit code from an `execute_command` result.
+ * Only trusts explicit exitCode/code fields — no heuristic fallbacks.
+ */
+export declare function getExitCode(result: unknown): number | null;
+/**
+ * Determine if a tool call result indicates success (exit code 0, no explicit error).
+ * Works with both structured result objects and string results.
+ */
+export declare function isSuccessResult(result: unknown, error?: unknown): boolean;
+/**
+ * Match a file path from tool output against an expected path.
+ * Supports exact match and suffix match (e.g. "src/foo.ts" matches "/abs/path/src/foo.ts").
+ */
+export declare function matchFilePath(actual: string, expected: string): boolean;
+//# sourceMappingURL=classify-command.d.ts.map

package/dist/evals/scorers/classify-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-command.d.ts","sourceRoot":"","sources":["../../../src/evals/scorers/classify-command.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAUvD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAgB1D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAiBzE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGvE"}

package/dist/evals/scorers/classify-command.js

@@ -0,0 +1,52 @@
+function isBuildCommand(command) {
+  const segments = command.split(/\s*(?:&&|\|\||;)\s*/);
+  return segments.some((seg) => {
+    const trimmed = seg.trim();
+    if (!/\b(tsc|typecheck|type-check|build)\b/.test(trimmed)) return false;
+    const primaryVerb = trimmed.replace(/^(?:pnpm|npm|yarn|npx|bunx?|turbo)\s+(?:run\s+)?/, "").split(/\s/)[0] ?? "";
+    return !/^(test|vitest|jest|mocha|pytest)$/.test(primaryVerb);
+  });
+}
+function isTestCommand(command) {
+  return /\b(test|vitest|jest|mocha|pytest|spec)\b/.test(command);
+}
+function getExitCode(result) {
+  if (result == null) return null;
+  if (typeof result === "string") {
+    const exitMatch = result.match(/exit(?:ed)?\s+(?:with\s+)?(?:code\s+)?(\d+)/i);
+    if (exitMatch) return parseInt(exitMatch[1], 10);
+    return null;
+  }
+  if (typeof result === "object") {
+    const obj = result;
+    if ("exitCode" in obj && typeof obj.exitCode === "number") return obj.exitCode;
+    if ("code" in obj && typeof obj.code === "number") return obj.code;
+  }
+  return null;
+}
+function isSuccessResult(result, error) {
+  if (error) return false;
+  if (!result) return false;
+  if (typeof result === "object") {
+    const obj = result;
+    const exitCode = obj.exitCode ?? obj.code;
+    if (typeof exitCode === "number") return exitCode === 0;
+  }
+  if (typeof result === "string") {
+    const exitMatch = result.match(/exit(?:ed)?\s+(?:with\s+)?(?:code\s+)?(\d+)/i);
+    if (exitMatch) return exitMatch[1] === "0";
+  }
+  return false;
+}
+function matchFilePath(actual, expected) {
+  if (actual === expected) return true;
+  return actual.endsWith(`/${expected}`) || expected.endsWith(`/${actual}`);
+}
+export {
+  getExitCode,
+  isBuildCommand,
+  isSuccessResult,
+  isTestCommand,
+  matchFilePath
+};
+//# sourceMappingURL=classify-command.js.map

package/dist/evals/scorers/classify-command.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/evals/scorers/classify-command.ts"],"sourcesContent":["/**\n * Shared command classification utilities for scoring.\n *\n * Used by both live scorers (outcome.ts) and offline scorers (outcome-match.ts)\n * to consistently identify build, test, and other command types.\n */\n\n/**\n * Check if a command string is a build/typecheck command.\n * Handles compound commands (e.g. `pnpm build && pnpm test`) by checking each segment.\n */\nexport function isBuildCommand(command: string): boolean {\n  const segments = command.split(/\\s*(?:&&|\\|\\||;)\\s*/);\n  return segments.some(seg => {\n    const trimmed = seg.trim();\n    if (!/\\b(tsc|typecheck|type-check|build)\\b/.test(trimmed)) return false;\n    // Don't reject if \"test\" only appears as a substring (e.g. \"build-test-output\").\n    // Only reject if a test runner is the primary verb of this segment.\n    const primaryVerb = trimmed.replace(/^(?:pnpm|npm|yarn|npx|bunx?|turbo)\\s+(?:run\\s+)?/, '').split(/\\s/)[0] ?? '';\n    return !/^(test|vitest|jest|mocha|pytest)$/.test(primaryVerb);\n  });\n}\n\n/**\n * Check if a command string is a test command.\n */\nexport function isTestCommand(command: string): boolean {\n  return /\\b(test|vitest|jest|mocha|pytest|spec)\\b/.test(command);\n}\n\n/**\n * Extract exit code from an `execute_command` result.\n * Only trusts explicit exitCode/code fields — no heuristic fallbacks.\n */\nexport function getExitCode(result: unknown): number | null {\n  if (result == null) return null;\n\n  if (typeof result === 'string') {\n    const exitMatch = result.match(/exit(?:ed)?\\s+(?:with\\s+)?(?:code\\s+)?(\\d+)/i);\n    if (exitMatch) return parseInt(exitMatch[1]!, 10);\n    return null;\n  }\n\n  if (typeof result === 'object') {\n    const obj = result as Record<string, unknown>;\n    if ('exitCode' in obj && typeof obj.exitCode === 'number') return obj.exitCode;\n    if ('code' in obj && typeof obj.code === 'number') return obj.code;\n  }\n\n  return null;\n}\n\n/**\n * Determine if a tool call result indicates success (exit code 0, no explicit error).\n * Works with both structured result objects and string results.\n */\nexport function isSuccessResult(result: unknown, error?: unknown): boolean {\n  if (error) return false;\n  if (!result) return false;\n\n  if (typeof result === 'object') {\n    const obj = result as Record<string, unknown>;\n    const exitCode = (obj.exitCode as number | undefined) ?? (obj.code as number | undefined);\n    if (typeof exitCode === 'number') return exitCode === 0;\n  }\n\n  if (typeof result === 'string') {\n    const exitMatch = result.match(/exit(?:ed)?\\s+(?:with\\s+)?(?:code\\s+)?(\\d+)/i);\n    if (exitMatch) return exitMatch[1] === '0';\n  }\n\n  // No explicit exit code — can't determine\n  return false;\n}\n\n/**\n * Match a file path from tool output against an expected path.\n * Supports exact match and suffix match (e.g. \"src/foo.ts\" matches \"/abs/path/src/foo.ts\").\n */\nexport function matchFilePath(actual: string, expected: string): boolean {\n  if (actual === expected) return true;\n  return actual.endsWith(`/${expected}`) || expected.endsWith(`/${actual}`);\n}\n"],"mappings":"AAWO,SAAS,eAAe,SAA0B;AACvD,QAAM,WAAW,QAAQ,MAAM,qBAAqB;AACpD,SAAO,SAAS,KAAK,SAAO;AAC1B,UAAM,UAAU,IAAI,KAAK;AACzB,QAAI,CAAC,uCAAuC,KAAK,OAAO,EAAG,QAAO;AAGlE,UAAM,cAAc,QAAQ,QAAQ,oDAAoD,EAAE,EAAE,MAAM,IAAI,EAAE,CAAC,KAAK;AAC9G,WAAO,CAAC,oCAAoC,KAAK,WAAW;AAAA,EAC9D,CAAC;AACH;AAKO,SAAS,cAAc,SAA0B;AACtD,SAAO,2CAA2C,KAAK,OAAO;AAChE;AAMO,SAAS,YAAY,QAAgC;AAC1D,MAAI,UAAU,KAAM,QAAO;AAE3B,MAAI,OAAO,WAAW,UAAU;AAC9B,UAAM,YAAY,OAAO,MAAM,8CAA8C;AAC7E,QAAI,UAAW,QAAO,SAAS,UAAU,CAAC,GAAI,EAAE;AAChD,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,WAAW,UAAU;AAC9B,UAAM,MAAM;AACZ,QAAI,cAAc,OAAO,OAAO,IAAI,aAAa,SAAU,QAAO,IAAI;AACtE,QAAI,UAAU,OAAO,OAAO,IAAI,SAAS,SAAU,QAAO,IAAI;AAAA,EAChE;AAEA,SAAO;AACT;AAMO,SAAS,gBAAgB,QAAiB,OAA0B;AACzE,MAAI,MAAO,QAAO;AAClB,MAAI,CAAC,OAAQ,QAAO;AAEpB,MAAI,OAAO,WAAW,UAAU;AAC9B,UAAM,MAAM;AACZ,UAAM,WAAY,IAAI,YAAoC,IAAI;AAC9D,QAAI,OAAO,aAAa,SAAU,QAAO,aAAa;AAAA,EACxD;AAEA,MAAI,OAAO,WAAW,UAAU;AAC9B,UAAM,YAAY,OAAO,MAAM,8CAA8C;AAC7E,QAAI,UAAW,QAAO,UAAU,CAAC,MAAM;AAAA,EACzC;AAGA,SAAO;AACT;AAMO,SAAS,cAAc,QAAgB,UAA2B;AACvE,MAAI,WAAW,SAAU,QAAO;AAChC,SAAO,OAAO,SAAS,IAAI,QAAQ,EAAE,KAAK,SAAS,SAAS,IAAI,MAAM,EAAE;AAC1E;","names":[]}

package/dist/evals/scorers/efficiency.d.ts

@@ -0,0 +1,44 @@
+/**
+ * MastraCode Efficiency Scorer (Code-based, Agent type, 30% sampling)
+ *
+ * Measures how efficiently the agent completes work through quantitative ratios.
+ * Unlike the Outcome Scorer (which checks *what* happened), this checks
+ * *how much work* it took.
+ *
+ * This scorer produces a score from 0-1 but also exposes raw metrics in the
+ * reason text for trend analysis. The score represents "how cleanly did the
+ * agent work?" — not whether it got the right answer.
+ *
+ * Sampled at 30% because it's slightly more expensive (analyzes message sequences).
+ */
+export declare function createEfficiencyScorer(): import("@mastra/core/evals").MastraScorer<"mastracode-efficiency", import("@mastra/core/evals").ScorerRunInputForAgent, import("@mastra/core/evals").ScorerRunOutputForAgent, Record<"preprocessStepResult", {
+    empty: true;
+    totalCalls: number;
+    totalTurns: number;
+    redundancy?: undefined;
+    turnCount?: undefined;
+    retryEfficiency?: undefined;
+    readBeforeEdit?: undefined;
+} | {
+    empty: false;
+    redundancy: {
+        score: number;
+        ratio: number;
+        detail: string;
+    };
+    turnCount: {
+        score: number;
+        detail: string;
+    };
+    retryEfficiency: {
+        score: number;
+        detail: string;
+    };
+    readBeforeEdit: {
+        score: number;
+        detail: string;
+    };
+    totalCalls: number;
+    totalTurns: number;
+}> & Record<"generateScoreStepResult", number> & Record<"generateReasonStepResult", string>>;
+//# sourceMappingURL=efficiency.d.ts.map

package/dist/evals/scorers/efficiency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"efficiency.d.ts","sourceRoot":"","sources":["../../../src/evals/scorers/efficiency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAsOH,wBAAgB,sBAAsB;;;;;;;;;;;eA7JyB,MAAM;eAAS,MAAM;gBAAU,MAAM;;;eAqCnD,MAAM;gBAAU,MAAM;;;eAqBH,MAAM;gBAAU,MAAM;;;eAuDvB,MAAM;gBAAU,MAAM;;;;6FA8GxF"}

package/dist/evals/scorers/efficiency.js

@@ -0,0 +1,201 @@
+import { createScorer, filterRun } from "@mastra/core/evals";
+import { extractToolCalls } from "./extract-tools.js";
+const WEIGHTS = {
+  redundancy: 0.35,
+  turnCount: 0.3,
+  retryEfficiency: 0.2,
+  readBeforeEdit: 0.15
+};
+const THRESHOLDS = {
+  /** Redundancy ratio below this is considered acceptable (no penalty). */
+  redundancyAcceptableRate: 0.05,
+  /** Penalty multiplier applied to redundancy ratio above the acceptable rate. */
+  redundancyPenaltyMultiplier: 3,
+  /** Turns at or below this is considered normal (score 1.0). */
+  turnCountNormalMax: 8,
+  /** Penalty per turn beyond the normal maximum (for turns 9–15). */
+  turnCountPenaltyPerTurn: 0.04,
+  /** Penalty per turn beyond 15. */
+  turnCountExtendedPenaltyPerTurn: 0.03,
+  /** Number of consecutive failures before a retry chain is "excessive". */
+  retryExcessiveThreshold: 3,
+  /** Tools considered "edit" tools that should be preceded by a read. */
+  editTools: ["string_replace_lsp", "ast_smart_edit"],
+  /** Tools that satisfy read-before-edit (only `view` truly reads a specific file). */
+  readTools: ["view"],
+  /** Tools whose repeated identical calls are intentional (idempotent reads). */
+  redundancyWhitelist: ["view", "search_content", "find_files", "lsp_inspect", "web_search", "web_extract"],
+  /** Minimum tool calls required to produce a meaningful score. */
+  minToolCalls: 2
+};
+function countAssistantTurns(messages) {
+  return messages.filter((m) => m.role === "assistant").length;
+}
+function scoreRedundancy(calls) {
+  if (calls.length < 2) return { score: 1, ratio: 0, detail: "Too few calls" };
+  const mutationCalls = calls.filter((c) => !THRESHOLDS.redundancyWhitelist.includes(c.toolName));
+  if (mutationCalls.length < 2) return { score: 1, ratio: 0, detail: "No mutation tools to check" };
+  const fingerprints = /* @__PURE__ */ new Map();
+  for (const call of mutationCalls) {
+    const fp = `${call.toolName}:${JSON.stringify(call.args)}`;
+    const existing = fingerprints.get(fp) ?? { count: 0, successCount: 0 };
+    existing.count++;
+    if (!call.isError) existing.successCount++;
+    fingerprints.set(fp, existing);
+  }
+  let redundantCount = 0;
+  for (const { successCount } of fingerprints.values()) {
+    if (successCount > 1) redundantCount += successCount - 1;
+  }
+  const ratio = redundantCount / mutationCalls.length;
+  const acceptable = THRESHOLDS.redundancyAcceptableRate;
+  const score = ratio <= acceptable ? 1 : Math.max(0, 1 - (ratio - acceptable) * THRESHOLDS.redundancyPenaltyMultiplier);
+  return {
+    score,
+    ratio,
+    detail: `${redundantCount}/${mutationCalls.length} redundant mutations (${(ratio * 100).toFixed(0)}%)`
+  };
+}
+function scoreTurnCount(turns) {
+  const normalMax = THRESHOLDS.turnCountNormalMax;
+  const penaltyPerTurn = THRESHOLDS.turnCountPenaltyPerTurn;
+  const extendedPenalty = THRESHOLDS.turnCountExtendedPenaltyPerTurn;
+  if (turns <= 1) return { score: 1, detail: `${turns} turn` };
+  if (turns <= normalMax) return { score: 1, detail: `${turns} turns (within normal range)` };
+  if (turns <= 15) {
+    const score2 = 1 - (turns - normalMax) * penaltyPerTurn;
+    return { score: score2, detail: `${turns} turns (slightly extended)` };
+  }
+  const midPenalty = (15 - normalMax) * penaltyPerTurn;
+  const score = Math.max(0, 1 - midPenalty - (turns - 15) * extendedPenalty);
+  return { score, detail: `${turns} turns (extended session)` };
+}
+function scoreRetryEfficiency(calls) {
+  if (calls.length < 2) return { score: 1, detail: "Too few calls" };
+  const groupKey = (call) => {
+    const path = String(call.args.path ?? call.args.command ?? "");
+    return `${call.toolName}:${path}`;
+  };
+  const byGroup = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const key = groupKey(call);
+    const arr = byGroup.get(key) ?? [];
+    arr.push(call);
+    byGroup.set(key, arr);
+  }
+  let totalRetryChains = 0;
+  let excessiveRetries = 0;
+  const threshold = THRESHOLDS.retryExcessiveThreshold;
+  for (const [, toolCalls] of byGroup) {
+    let consecutiveFailures = 0;
+    for (const call of toolCalls) {
+      if (call.isError) {
+        consecutiveFailures++;
+      } else {
+        if (consecutiveFailures > 0) {
+          totalRetryChains++;
+          if (consecutiveFailures >= threshold) excessiveRetries++;
+        }
+        consecutiveFailures = 0;
+      }
+    }
+    if (consecutiveFailures > 0) {
+      totalRetryChains++;
+      if (consecutiveFailures >= threshold) excessiveRetries++;
+    }
+  }
+  if (totalRetryChains === 0) return { score: 1, detail: "No retry chains" };
+  if (excessiveRetries === 0) return { score: 0.9, detail: `${totalRetryChains} retry chain(s), all resolved quickly` };
+  const score = Math.max(0, 0.8 - excessiveRetries * 0.2);
+  return {
+    score,
+    detail: `${excessiveRetries} excessive retry chain(s) (${threshold}+ failures before success)`
+  };
+}
+function scoreReadBeforeEdit(calls) {
+  const editTools = THRESHOLDS.editTools;
+  const readTools = THRESHOLDS.readTools;
+  const edits = calls.filter((c) => editTools.includes(c.toolName));
+  if (edits.length === 0) return { score: 1, detail: "No edits to check" };
+  const readPaths = /* @__PURE__ */ new Set();
+  let compliant = 0;
+  let total = 0;
+  for (const call of calls) {
+    const rawPath = String(call.args.path ?? "");
+    if (!rawPath) continue;
+    if (readTools.includes(call.toolName)) {
+      readPaths.add(rawPath);
+    } else if (editTools.includes(call.toolName)) {
+      total++;
+      if (hasReadPath(readPaths, rawPath)) {
+        compliant++;
+      }
+    }
+  }
+  if (total === 0) return { score: 1, detail: "No path-targeted edits" };
+  const ratio = compliant / total;
+  const violations = total - compliant;
+  if (violations === 0) return { score: 1, detail: `All ${total} edits had prior reads` };
+  return { score: ratio, detail: `${violations}/${total} edits without prior read` };
+}
+function hasReadPath(readPaths, editPath) {
+  if (readPaths.has(editPath)) return true;
+  for (const rp of readPaths) {
+    if (rp.endsWith(`/${editPath}`) || editPath.endsWith(`/${rp}`)) return true;
+  }
+  return false;
+}
+function createEfficiencyScorer() {
+  return createScorer({
+    id: "mastracode-efficiency",
+    name: "MastraCode Efficiency",
+    description: "Measures coding session efficiency: redundancy, turn count, retry patterns, read-before-edit. 30% sampled.",
+    type: "agent",
+    prepareRun: filterRun({ partTypes: ["tool-invocation", "text"] })
+  }).preprocess(async ({ run }) => {
+    const messages = run.output ?? [];
+    const calls = extractToolCalls(messages);
+    const turns = countAssistantTurns(messages);
+    if (calls.length < THRESHOLDS.minToolCalls) {
+      return { empty: true, totalCalls: calls.length, totalTurns: turns };
+    }
+    const redundancy = scoreRedundancy(calls);
+    const turnCount = scoreTurnCount(turns);
+    const retryEfficiency = scoreRetryEfficiency(calls);
+    const readBeforeEdit = scoreReadBeforeEdit(calls);
+    return {
+      empty: false,
+      redundancy,
+      turnCount,
+      retryEfficiency,
+      readBeforeEdit,
+      totalCalls: calls.length,
+      totalTurns: turns
+    };
+  }).generateScore(({ results }) => {
+    const p = results.preprocessStepResult;
+    if (p.empty) return 0;
+    const score = p.redundancy.score * WEIGHTS.redundancy + p.turnCount.score * WEIGHTS.turnCount + p.retryEfficiency.score * WEIGHTS.retryEfficiency + p.readBeforeEdit.score * WEIGHTS.readBeforeEdit;
+    return Math.round(score * 100) / 100;
+  }).generateReason(({ results, score }) => {
+    const p = results.preprocessStepResult;
+    if (p.empty) {
+      return `Score: 0 (${p.totalCalls} tool calls \u2014 below minimum threshold for scoring)`;
+    }
+    const pct = (w) => `${(w * 100).toFixed(0)}%`;
+    const parts = [`Score: ${score} (${p.totalCalls} calls, ${p.totalTurns} turns)`];
+    parts.push(`Redundancy (${pct(WEIGHTS.redundancy)}): ${p.redundancy.detail} [${p.redundancy.score}]`);
+    parts.push(`Turn count (${pct(WEIGHTS.turnCount)}): ${p.turnCount.detail} [${p.turnCount.score}]`);
+    parts.push(
+      `Retry efficiency (${pct(WEIGHTS.retryEfficiency)}): ${p.retryEfficiency.detail} [${p.retryEfficiency.score}]`
+    );
+    parts.push(
+      `Read-before-edit (${pct(WEIGHTS.readBeforeEdit)}): ${p.readBeforeEdit.detail} [${p.readBeforeEdit.score}]`
+    );
+    return parts.join("\n");
+  });
+}
+export {
+  createEfficiencyScorer
+};
+//# sourceMappingURL=efficiency.js.map

package/dist/evals/scorers/efficiency.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/evals/scorers/efficiency.ts"],"sourcesContent":["/**\n * MastraCode Efficiency Scorer (Code-based, Agent type, 30% sampling)\n *\n * Measures how efficiently the agent completes work through quantitative ratios.\n * Unlike the Outcome Scorer (which checks *what* happened), this checks\n * *how much work* it took.\n *\n * This scorer produces a score from 0-1 but also exposes raw metrics in the\n * reason text for trend analysis. The score represents \"how cleanly did the\n * agent work?\" — not whether it got the right answer.\n *\n * Sampled at 30% because it's slightly more expensive (analyzes message sequences).\n */\n\nimport type { MastraDBMessage } from '@mastra/core/agent';\nimport { createScorer, filterRun } from '@mastra/core/evals';\n\nimport type { ExtractedToolCall } from './extract-tools.js';\nimport { extractToolCalls } from './extract-tools.js';\n\n// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n// CONFIGURATION — Adjust weights and thresholds here\n// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n/**\n * Dimension weights (must sum to 1.0).\n *\n * - redundancy:     Duplicate mutation tool calls with identical args.\n * - turnCount:      Total assistant turns to complete the task.\n * - retryEfficiency: How quickly the agent recovers from tool failures.\n * - readBeforeEdit: Whether files are read before being edited.\n */\nconst WEIGHTS = {\n  redundancy: 0.35,\n  turnCount: 0.3,\n  retryEfficiency: 0.2,\n  readBeforeEdit: 0.15,\n} as const;\n\n/**\n * Scoring thresholds and multipliers.\n */\nconst THRESHOLDS = {\n  /** Redundancy ratio below this is considered acceptable (no penalty). */\n  redundancyAcceptableRate: 0.05,\n\n  /** Penalty multiplier applied to redundancy ratio above the acceptable rate. */\n  redundancyPenaltyMultiplier: 3,\n\n  /** Turns at or below this is considered normal (score 1.0). */\n  turnCountNormalMax: 8,\n\n  /** Penalty per turn beyond the normal maximum (for turns 9–15). */\n  turnCountPenaltyPerTurn: 0.04,\n\n  /** Penalty per turn beyond 15. */\n  turnCountExtendedPenaltyPerTurn: 0.03,\n\n  /** Number of consecutive failures before a retry chain is \"excessive\". */\n  retryExcessiveThreshold: 3,\n\n  /** Tools considered \"edit\" tools that should be preceded by a read. */\n  editTools: ['string_replace_lsp', 'ast_smart_edit'] as string[],\n\n  /** Tools that satisfy read-before-edit (only `view` truly reads a specific file). */\n  readTools: ['view'] as string[],\n\n  /** Tools whose repeated identical calls are intentional (idempotent reads). */\n  redundancyWhitelist: ['view', 'search_content', 'find_files', 'lsp_inspect', 'web_search', 'web_extract'] as string[],\n\n  /** Minimum tool calls required to produce a meaningful score. */\n  minToolCalls: 2,\n} as const;\n\n/**\n * Count assistant turns (messages with role === 'assistant').\n */\nfunction countAssistantTurns(messages: MastraDBMessage[]): number {\n  return messages.filter(m => m.role === 'assistant').length;\n}\n\n/**\n * Calculate redundant call ratio.\n * Only counts mutation/action tools as redundant — reads are whitelisted.\n */\nfunction scoreRedundancy(calls: ExtractedToolCall[]): { score: number; ratio: number; detail: string } {\n  if (calls.length < 2) return { score: 1, ratio: 0, detail: 'Too few calls' };\n\n  // Only consider non-whitelisted (mutation) tools for redundancy\n  const mutationCalls = calls.filter(c => !THRESHOLDS.redundancyWhitelist.includes(c.toolName));\n  if (mutationCalls.length < 2) return { score: 1, ratio: 0, detail: 'No mutation tools to check' };\n\n  const fingerprints = new Map<string, { count: number; successCount: number }>();\n  for (const call of mutationCalls) {\n    const fp = `${call.toolName}:${JSON.stringify(call.args)}`;\n    const existing = fingerprints.get(fp) ?? { count: 0, successCount: 0 };\n    existing.count++;\n    if (!call.isError) existing.successCount++;\n    fingerprints.set(fp, existing);\n  }\n\n  // Only count as redundant if the same successful call happened multiple times\n  let redundantCount = 0;\n  for (const { successCount } of fingerprints.values()) {\n    if (successCount > 1) redundantCount += successCount - 1;\n  }\n\n  const ratio = redundantCount / mutationCalls.length;\n  const acceptable = THRESHOLDS.redundancyAcceptableRate;\n  const score =\n    ratio <= acceptable ? 1 : Math.max(0, 1 - (ratio - acceptable) * THRESHOLDS.redundancyPenaltyMultiplier);\n  return {\n    score,\n    ratio,\n    detail: `${redundantCount}/${mutationCalls.length} redundant mutations (${(ratio * 100).toFixed(0)}%)`,\n  };\n}\n\n/**\n * Score turn count efficiency.\n * Fewer turns to accomplish the task = more efficient.\n */\nfunction scoreTurnCount(turns: number): { score: number; detail: string } {\n  const normalMax = THRESHOLDS.turnCountNormalMax;\n  const penaltyPerTurn = THRESHOLDS.turnCountPenaltyPerTurn;\n  const extendedPenalty = THRESHOLDS.turnCountExtendedPenaltyPerTurn;\n\n  if (turns <= 1) return { score: 1, detail: `${turns} turn` };\n  if (turns <= normalMax) return { score: 1, detail: `${turns} turns (within normal range)` };\n  if (turns <= 15) {\n    const score = 1 - (turns - normalMax) * penaltyPerTurn;\n    return { score, detail: `${turns} turns (slightly extended)` };\n  }\n\n  const midPenalty = (15 - normalMax) * penaltyPerTurn;\n  const score = Math.max(0, 1 - midPenalty - (turns - 15) * extendedPenalty);\n  return { score, detail: `${turns} turns (extended session)` };\n}\n\n/**\n * Score failed-then-succeeded ratio.\n * Groups retry chains by tool name + target file path for more accurate detection.\n */\nfunction scoreRetryEfficiency(calls: ExtractedToolCall[]): { score: number; detail: string } {\n  if (calls.length < 2) return { score: 1, detail: 'Too few calls' };\n\n  // Group calls by tool name + target file path (if available)\n  const groupKey = (call: ExtractedToolCall): string => {\n    const path = String(call.args.path ?? call.args.command ?? '');\n    return `${call.toolName}:${path}`;\n  };\n\n  const byGroup = new Map<string, ExtractedToolCall[]>();\n  for (const call of calls) {\n    const key = groupKey(call);\n    const arr = byGroup.get(key) ?? [];\n    arr.push(call);\n    byGroup.set(key, arr);\n  }\n\n  let totalRetryChains = 0;\n  let excessiveRetries = 0;\n  const threshold = THRESHOLDS.retryExcessiveThreshold;\n\n  for (const [, toolCalls] of byGroup) {\n    let consecutiveFailures = 0;\n    for (const call of toolCalls) {\n      if (call.isError) {\n        consecutiveFailures++;\n      } else {\n        if (consecutiveFailures > 0) {\n          totalRetryChains++;\n          if (consecutiveFailures >= threshold) excessiveRetries++;\n        }\n        consecutiveFailures = 0;\n      }\n    }\n    // Count unrecovered retry chains (failures at end of group with no success)\n    if (consecutiveFailures > 0) {\n      totalRetryChains++;\n      if (consecutiveFailures >= threshold) excessiveRetries++;\n    }\n  }\n\n  if (totalRetryChains === 0) return { score: 1, detail: 'No retry chains' };\n  if (excessiveRetries === 0) return { score: 0.9, detail: `${totalRetryChains} retry chain(s), all resolved quickly` };\n\n  const score = Math.max(0, 0.8 - excessiveRetries * 0.2);\n  return {\n    score,\n    detail: `${excessiveRetries} excessive retry chain(s) (${threshold}+ failures before success)`,\n  };\n}\n\n/**\n * Score read-before-edit compliance.\n * Only `view` satisfies a read — search/find don't provide specific file content.\n */\nfunction scoreReadBeforeEdit(calls: ExtractedToolCall[]): { score: number; detail: string } {\n  const editTools = THRESHOLDS.editTools;\n  const readTools = THRESHOLDS.readTools;\n\n  const edits = calls.filter(c => editTools.includes(c.toolName));\n  if (edits.length === 0) return { score: 1, detail: 'No edits to check' };\n\n  // Build set of files that were read before each edit.\n  // Use suffix-normalized paths so that \"/abs/path/src/foo.ts\" and \"src/foo.ts\" match.\n  const readPaths = new Set<string>();\n  let compliant = 0;\n  let total = 0;\n\n  for (const call of calls) {\n    const rawPath = String(call.args.path ?? '');\n    if (!rawPath) continue;\n\n    if (readTools.includes(call.toolName)) {\n      readPaths.add(rawPath);\n    } else if (editTools.includes(call.toolName)) {\n      total++;\n      if (hasReadPath(readPaths, rawPath)) {\n        compliant++;\n      }\n    }\n  }\n\n  if (total === 0) return { score: 1, detail: 'No path-targeted edits' };\n\n  const ratio = compliant / total;\n  const violations = total - compliant;\n  if (violations === 0) return { score: 1, detail: `All ${total} edits had prior reads` };\n  return { score: ratio, detail: `${violations}/${total} edits without prior read` };\n}\n\n/** Check if any read path matches the edit path, using suffix matching for mixed abs/relative paths. */\nfunction hasReadPath(readPaths: Set<string>, editPath: string): boolean {\n  if (readPaths.has(editPath)) return true;\n  for (const rp of readPaths) {\n    if (rp.endsWith(`/${editPath}`) || editPath.endsWith(`/${rp}`)) return true;\n  }\n  return false;\n}\n\nexport function createEfficiencyScorer() {\n  return createScorer({\n    id: 'mastracode-efficiency',\n    name: 'MastraCode Efficiency',\n    description:\n      'Measures coding session efficiency: redundancy, turn count, retry patterns, read-before-edit. 30% sampled.',\n    type: 'agent',\n    prepareRun: filterRun({ partTypes: ['tool-invocation', 'text'] }),\n  })\n    .preprocess(async ({ run }) => {\n      const messages = (run.output ?? []) as MastraDBMessage[];\n      const calls = extractToolCalls(messages);\n      const turns = countAssistantTurns(messages);\n\n      // H1: Empty sessions → score 0\n      if (calls.length < THRESHOLDS.minToolCalls) {\n        return { empty: true as const, totalCalls: calls.length, totalTurns: turns };\n      }\n\n      const redundancy = scoreRedundancy(calls);\n      const turnCount = scoreTurnCount(turns);\n      const retryEfficiency = scoreRetryEfficiency(calls);\n      const readBeforeEdit = scoreReadBeforeEdit(calls);\n\n      return {\n        empty: false as const,\n        redundancy,\n        turnCount,\n        retryEfficiency,\n        readBeforeEdit,\n        totalCalls: calls.length,\n        totalTurns: turns,\n      };\n    })\n    .generateScore(({ results }) => {\n      const p = results.preprocessStepResult;\n      if (p.empty) return 0;\n\n      const score =\n        p.redundancy.score * WEIGHTS.redundancy +\n        p.turnCount.score * WEIGHTS.turnCount +\n        p.retryEfficiency.score * WEIGHTS.retryEfficiency +\n        p.readBeforeEdit.score * WEIGHTS.readBeforeEdit;\n\n      return Math.round(score * 100) / 100;\n    })\n    .generateReason(({ results, score }) => {\n      const p = results.preprocessStepResult;\n      if (p.empty) {\n        return `Score: 0 (${p.totalCalls} tool calls — below minimum threshold for scoring)`;\n      }\n\n      const pct = (w: number) => `${(w * 100).toFixed(0)}%`;\n      const parts: string[] = [`Score: ${score} (${p.totalCalls} calls, ${p.totalTurns} turns)`];\n\n      parts.push(`Redundancy (${pct(WEIGHTS.redundancy)}): ${p.redundancy.detail} [${p.redundancy.score}]`);\n      parts.push(`Turn count (${pct(WEIGHTS.turnCount)}): ${p.turnCount.detail} [${p.turnCount.score}]`);\n      parts.push(\n        `Retry efficiency (${pct(WEIGHTS.retryEfficiency)}): ${p.retryEfficiency.detail} [${p.retryEfficiency.score}]`,\n      );\n      parts.push(\n        `Read-before-edit (${pct(WEIGHTS.readBeforeEdit)}): ${p.readBeforeEdit.detail} [${p.readBeforeEdit.score}]`,\n      );\n\n      return parts.join('\\n');\n    });\n}\n"],"mappings":"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","names":["score"]}