nolo-cli 0.1.20 → 0.1.21

package/ai/taskRun/taskRunProtocol.ts

@@ -10,6 +10,7 @@ export const TASK_RUN_TOOL_ACTIONS = [
   "upsertWorkItem",
   "claimOrDispatch",
   "claimWorkItem",
+  "recordAgentRun",
   "openDialog",
   "recordArtifact",
   "markBlocked",
@@ -79,6 +80,13 @@ export type TaskRunAgentRun = {
   updatedAt: string;
   resultSummary?: string;
   errorCode?: string;
+  toolsUsed?: string[];
+  toolTraceSummary?: {
+    callCount: number;
+    resultCount: number;
+    errorCount: number;
+    rounds: number;
+  };
 };
 
 export type TaskRunArtifact = {
@@ -614,6 +622,57 @@ export function recordTaskRunAgentDispatch(args: {
   return { meta: updated.meta, workItem: updated.workItem, agentRun };
 }
 
+export function recordTaskRunAgentRun(args: {
+  meta: TaskRunMeta;
+  run: Omit<TaskRunAgentRun, "id" | "startedAt" | "updatedAt"> & {
+    id?: string;
+    startedAt?: string;
+  };
+  now?: string;
+  createId?: () => string;
+}): { meta: TaskRunMeta; agentRun: TaskRunAgentRun } {
+  const now = args.now ?? new Date().toISOString();
+  const meta = cloneMeta(args.meta);
+  const agentRuns = [...(meta.agentRuns ?? [])];
+  const id = args.run.id ?? args.createId?.() ?? createProtocolId();
+  const index = agentRuns.findIndex((run) => run.id === id);
+  const existing = index >= 0 ? agentRuns[index] : undefined;
+  const agentRun: TaskRunAgentRun = {
+    ...(existing ?? {
+      id,
+      agentKey: args.run.agentKey,
+      role: args.run.role,
+      startedAt: args.run.startedAt ?? now,
+    }),
+    ...args.run,
+    id,
+    startedAt: existing?.startedAt ?? args.run.startedAt ?? now,
+    updatedAt: now,
+  };
+  if (index >= 0) {
+    agentRuns[index] = agentRun;
+  } else {
+    agentRuns.push(agentRun);
+  }
+  meta.agentRuns = agentRuns;
+  appendTaskRunEvent({
+    meta,
+    type: "agent_run.recorded",
+    agentKey: agentRun.agentKey,
+    workItemId: agentRun.workItemId,
+    dialogId: agentRun.dialogId,
+    now,
+    payload: {
+      agentRunId: agentRun.id,
+      status: agentRun.status,
+      toolsUsed: agentRun.toolsUsed,
+      toolTraceSummary: agentRun.toolTraceSummary,
+    },
+  });
+  touchTaskRun(meta, now, agentRun.status === "running" ? "running" : undefined);
+  return { meta, agentRun };
+}
+
 export function submitTaskRunOutcome(args: {
   meta: TaskRunMeta;
   workItemId: string;

package/client/agentRun.test.ts

@@ -452,6 +452,75 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("[nolo:tool] round 1 <- gitStatus (call-status)");
   });
 
+  test("passes local tool evidence to task-run writeback", async () => {
+    const output = new CaptureOutput();
+    const writebacks: any[] = [];
+    let completeCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "inspect repo",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      taskRunContext: {
+        rowDbKey: "row-b2e06f801f-01TASK",
+        workItemId: "self",
+      },
+      taskRunRecorder: async (args) => {
+        writebacks.push(args);
+      },
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+          toolNames: ["gitStatus"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            completeCalls += 1;
+            if (completeCalls === 1) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: "call-status",
+                  type: "function",
+                  function: { name: "gitStatus", arguments: "{}" },
+                }],
+              };
+            }
+            return { content: "done", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => ({ content: "clean" }),
+      },
+      scriptPathExists: () => false,
+    });
+
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
+    expect(writebacks).toHaveLength(1);
+    expect(writebacks[0].toolEvidence).toEqual({
+      toolsUsed: ["gitStatus"],
+      summary: {
+        callCount: 1,
+        resultCount: 1,
+        errorCount: 0,
+        rounds: 1,
+      },
+    });
+  });
+
   test("auto mode prefers a working local runtime before HTTP", async () => {
     const output = new CaptureOutput();
     const httpCalls: string[] = [];

package/client/agentRun.ts

@@ -15,6 +15,15 @@ type OutputLike = {
 
 type TaskRunAgentRole = "pm" | "frontend" | "fullstack" | "reviewer" | "codex";
 type TaskRunReviewStatus = "passed" | "needs_changes" | "blocked";
+type TaskRunToolEvidence = {
+  toolsUsed: string[];
+  summary: {
+    callCount: number;
+    resultCount: number;
+    errorCount: number;
+    rounds: number;
+  };
+};
 
 type RunAgentTurnOptions = {
   agentName: string;
@@ -47,6 +56,7 @@ type RunAgentTurnOptions = {
     dialogId?: string;
     resultSummary?: string;
     errorCode?: string;
+    toolEvidence?: TaskRunToolEvidence;
   }) => Promise<void>;
   scriptPathExists?: (path: string) => boolean;
   fetchImpl?: typeof fetch;
@@ -148,6 +158,32 @@ function shouldTraceLocalTools(options: RunAgentTurnOptions) {
   return Boolean(options.traceTools || options.env.NOLO_TRACE_TOOLS === "1");
 }
 
+function shouldCollectLocalToolEvidence(options: RunAgentTurnOptions) {
+  return Boolean(options.taskRunContext?.rowDbKey);
+}
+
+function summarizeLocalToolEvidence(events: LocalAgentToolEvent[]): TaskRunToolEvidence | undefined {
+  if (events.length === 0) return undefined;
+  const toolsUsed = [
+    ...new Set(
+      events
+        .filter((event) => event.type === "tool-call")
+        .map((event) => event.toolName)
+        .filter(Boolean)
+    ),
+  ];
+  const rounds = new Set(events.map((event) => event.round)).size;
+  return {
+    toolsUsed,
+    summary: {
+      callCount: events.filter((event) => event.type === "tool-call").length,
+      resultCount: events.filter((event) => event.type === "tool-result").length,
+      errorCount: events.filter((event) => event.type === "tool-error").length,
+      rounds,
+    },
+  };
+}
+
 const DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT = 128;
 
 function parseLocalToolRoundLimitError(error: unknown) {
@@ -260,6 +296,7 @@ async function defaultTaskRunRecorder(args: {
   dialogId?: string;
   resultSummary?: string;
   errorCode?: string;
+  toolEvidence?: TaskRunToolEvidence;
 }) {
   const context = args.options.taskRunContext;
   if (!context?.rowDbKey) return;
@@ -298,6 +335,12 @@ async function defaultTaskRunRecorder(args: {
       ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
       ...(args.resultSummary ? ["--result-summary", args.resultSummary.slice(0, 240)] : []),
       ...(args.errorCode ? ["--error-code", args.errorCode] : []),
+      ...(args.toolEvidence?.toolsUsed?.length
+        ? ["--tools-used", args.toolEvidence.toolsUsed.join(",")]
+        : []),
+      ...(args.toolEvidence?.summary
+        ? ["--tool-trace-summary", JSON.stringify(args.toolEvidence.summary)]
+        : []),
     ],
   });
   if (context.workItemId && args.dialogId) {
@@ -346,6 +389,7 @@ async function recordTaskRunOutcome(args: {
   dialogId?: string;
   resultSummary?: string;
   errorCode?: string;
+  toolEvidence?: TaskRunToolEvidence;
 }) {
   if (!args.options.taskRunContext?.rowDbKey) return;
   try {
@@ -594,6 +638,7 @@ async function runLocalAgentTurnWithAutoRoundExpansion(
       errorCode: "LOCAL_AGENT_FAILED",
       resultSummary:
         lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError),
+      toolEvidence: lastResult.toolEvidence,
     });
   }
   return lastResult ?? { exitCode: 1 };
@@ -610,7 +655,10 @@ async function runLocalAgentTurnForCli(
   }
 
   options.output.write(`\n${options.agentName} -> working locally...\n`);
+  const toolEvents: LocalAgentToolEvent[] = [];
   try {
+    const traceLocalTools = shouldTraceLocalTools(options);
+    const collectToolEvidence = shouldCollectLocalToolEvidence(options);
     const result = await runLocalAgentTurn({
       adapter,
       agentRef: options.agentKey,
@@ -626,8 +674,13 @@ async function runLocalAgentTurnForCli(
       background: options.background,
       noStream: options.noStream,
       maxToolRounds: options.maxToolRounds,
-      ...(shouldTraceLocalTools(options)
-        ? { onToolEvent: (event) => options.output.write(formatToolTraceEvent(event)) }
+      ...(traceLocalTools || collectToolEvidence
+        ? {
+            onToolEvent: (event) => {
+              if (collectToolEvidence) toolEvents.push(event);
+              if (traceLocalTools) options.output.write(formatToolTraceEvent(event));
+            },
+          }
         : {}),
     });
     const content = result.content.trim();
@@ -641,6 +694,7 @@ async function runLocalAgentTurnForCli(
       status: "completed",
       dialogId: result.dialogId,
       resultSummary: content || undefined,
+      toolEvidence: summarizeLocalToolEvidence(toolEvents),
     });
     return { exitCode: 0, dialogId: result.dialogId };
   } catch (error) {
@@ -651,7 +705,7 @@ async function runLocalAgentTurnForCli(
         }\n`
       );
     }
-    return { exitCode: 1, localError: error };
+    return { exitCode: 1, localError: error, toolEvidence: summarizeLocalToolEvidence(toolEvents) };
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {

package/taskRunCommand.ts

@@ -58,6 +58,16 @@ function csv(raw: string) {
   return raw.split(",").map((item) => item.trim()).filter(Boolean);
 }
 
+function optionalJson(args: string[], flag: string) {
+  const value = optional(args, flag);
+  if (!value) return undefined;
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`${flag} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
 function resolveServerUrl(args: string[], env: EnvLike) {
   return (
     readOption(args, "--server-url") ||
@@ -107,6 +117,23 @@ function buildBody(command: string, args: string[]) {
       role: optional(args, "--role"),
     };
   }
+  if (command === "record-agent-run" || command === "recordAgentRun") {
+    const toolTraceSummary = optionalJson(args, "--tool-trace-summary");
+    return {
+      action: "recordAgentRun",
+      dbKey,
+      ...(optional(args, "--run-id") ? { runId: optional(args, "--run-id") } : {}),
+      agentKey: required(args, "--agent-key"),
+      ...(optional(args, "--role") ? { role: optional(args, "--role") } : {}),
+      runStatus: required(args, "--run-status"),
+      ...(optional(args, "--work-item-id") ? { workItemId: optional(args, "--work-item-id") } : {}),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--result-summary") ? { resultSummary: optional(args, "--result-summary") } : {}),
+      ...(optional(args, "--error-code") ? { errorCode: optional(args, "--error-code") } : {}),
+      ...(optional(args, "--tools-used") ? { toolsUsed: csv(optional(args, "--tools-used")!) } : {}),
+      ...(toolTraceSummary ? { toolTraceSummary } : {}),
+    };
+  }
   if (command === "set-blocker" || command === "setBlocker") {
     return {
       action: "setBlocker",
@@ -181,6 +208,7 @@ function usage() {
     "Usage:",
     "  nolo task-run read-context --row-dbkey <row>",
     "  nolo task-run claim-work-item --row-dbkey <row> --work-item-id <id> --agent-key <agent> [--role <role>]",
+    "  nolo task-run record-agent-run --row-dbkey <row> --agent-key <agent> --run-status <status> [--tools-used <csv>]",
     "  nolo task-run set-blocker --row-dbkey <row> [--work-item-id <id>] --layer <layer> --code <code> --message <message>",
     "  nolo task-run clear-blocker --row-dbkey <row> --blocker-id <id> [--work-item-id <id>]",
     "  nolo task-run submit-outcome --row-dbkey <row> --work-item-id <id> --summary <summary> [--dialog-id <id>]",