nolo-cli 0.1.20 → 0.1.22

package/ai/skills/skillDocProtocol.ts

@@ -47,12 +47,30 @@ export interface SkillEvalConfig {
   cases: SkillEvalCase[];
 }
 
+export interface WorkflowReferenceConfig {
+  version: "0.1";
+  kind: "workflow";
+  id?: string;
+  name: string;
+  description: string;
+  defaultAgent?: string;
+  inputs?: string[];
+  recommendedTools?: string[];
+  requiredTools?: string[];
+  requiredOutputs?: string[];
+  gates?: string[];
+  budgetTier?: SkillBudgetTier;
+  contextStrategy?: string;
+  failureProtocol?: string;
+}
+
 export interface PageSkillMetadata {
   kind?: SkillDocKind;
   requiredSkills?: string[];
   recommendedSkills?: string[];
   skillConfig?: SkillDocConfig;
   evalConfig?: SkillEvalConfig;
+  workflowConfig?: WorkflowReferenceConfig;
 }
 
 export interface ParsedSkillDocProtocol {
@@ -71,6 +89,7 @@ export interface ParsedExternalSkillMarkdown {
 
 const SKILL_CONFIG_BLOCK = "skill-config";
 const EVAL_CONFIG_BLOCK = "eval-config";
+const WORKFLOW_CONFIG_BLOCK = "workflow-config";
 
 const normalizeStringArray = (value: unknown): string[] | undefined => {
   if (!Array.isArray(value)) return undefined;
@@ -200,6 +219,49 @@ const normalizeEvalConfig = (value: unknown): SkillEvalConfig | undefined => {
     : undefined;
 };
 
+const normalizeWorkflowConfig = (value: unknown): WorkflowReferenceConfig | undefined => {
+  if (!value || typeof value !== "object") return undefined;
+  const record = value as Record<string, unknown>;
+  const name =
+    typeof record.name === "string" && record.name.trim()
+      ? record.name.trim()
+      : "";
+  const description =
+    typeof record.description === "string" && record.description.trim()
+      ? record.description.trim()
+      : "";
+  if (!name || !description) return undefined;
+  const budgetTier = normalizeSkillEnumValue("budgetTier", record.budgetTier);
+  return {
+    version: "0.1",
+    kind: "workflow",
+    id:
+      typeof record.id === "string" && record.id.trim()
+        ? record.id.trim()
+        : undefined,
+    name,
+    description,
+    defaultAgent:
+      typeof record.defaultAgent === "string" && record.defaultAgent.trim()
+        ? record.defaultAgent.trim()
+        : undefined,
+    inputs: normalizeStringArray(record.inputs),
+    recommendedTools: normalizeStringArray(record.recommendedTools),
+    requiredTools: normalizeStringArray(record.requiredTools),
+    requiredOutputs: normalizeStringArray(record.requiredOutputs),
+    gates: normalizeStringArray(record.gates),
+    budgetTier,
+    contextStrategy:
+      typeof record.contextStrategy === "string" && record.contextStrategy.trim()
+        ? record.contextStrategy.trim()
+        : undefined,
+    failureProtocol:
+      typeof record.failureProtocol === "string" && record.failureProtocol.trim()
+        ? record.failureProtocol.trim()
+        : undefined,
+  };
+};
+
 const normalizePageSkillMetadata = (
   value: unknown,
   fallbackTools?: string[]
@@ -214,17 +276,22 @@ const normalizePageSkillMetadata = (
     recommendedSkills: normalizeStringArray(record.recommendedSkills),
     skillConfig: normalizeSkillConfig(record.skillConfig, fallbackTools),
     evalConfig: normalizeEvalConfig(record.evalConfig),
+    workflowConfig: normalizeWorkflowConfig(record.workflowConfig),
   };
 
   if (meta.skillConfig && !meta.kind) {
     meta.kind = "skill";
   }
+  if (meta.workflowConfig && !meta.kind) {
+    meta.kind = "instruction";
+  }
 
   return meta.kind ||
     meta.requiredSkills ||
     meta.recommendedSkills ||
     meta.skillConfig ||
-    meta.evalConfig
+    meta.evalConfig ||
+    meta.workflowConfig
     ? meta
     : undefined;
 };
@@ -268,9 +335,13 @@ export const parseSkillDocProtocol = (
   const source = typeof markdown === "string" ? markdown : "";
   const skillBlock = parseYamlObject(extractCommentBlock(source, SKILL_CONFIG_BLOCK));
   const evalBlock = parseYamlObject(extractCommentBlock(source, EVAL_CONFIG_BLOCK));
+  const workflowBlock = parseYamlObject(extractCommentBlock(source, WORKFLOW_CONFIG_BLOCK));
   const cleanedContent = removeCommentBlock(
-    removeCommentBlock(source, SKILL_CONFIG_BLOCK),
-    EVAL_CONFIG_BLOCK
+    removeCommentBlock(
+      removeCommentBlock(source, SKILL_CONFIG_BLOCK),
+      EVAL_CONFIG_BLOCK
+    ),
+    WORKFLOW_CONFIG_BLOCK
   )
     .replace(/\n{3,}/g, "\n\n")
     .trim();
@@ -292,6 +363,7 @@ export const parseSkillDocProtocol = (
           }
         : {}),
       ...(evalBlock ? { evalConfig: evalBlock } : {}),
+      ...(workflowBlock ? { workflowConfig: workflowBlock } : {}),
     },
     fallbackTools
   );
@@ -364,15 +436,35 @@ export const buildEvalConfigComment = (config: SkillEvalConfig): string =>
     cases: config.cases,
   })}\n-->`;
 
+export const buildWorkflowConfigComment = (config: WorkflowReferenceConfig): string =>
+  `<!-- ${WORKFLOW_CONFIG_BLOCK}\n${yamlBlock({
+    version: config.version,
+    kind: config.kind,
+    ...(config.id ? { id: config.id } : {}),
+    name: config.name,
+    description: config.description,
+    ...(config.defaultAgent ? { defaultAgent: config.defaultAgent } : {}),
+    ...(config.inputs?.length ? { inputs: config.inputs } : {}),
+    ...(config.recommendedTools?.length ? { recommendedTools: config.recommendedTools } : {}),
+    ...(config.requiredTools?.length ? { requiredTools: config.requiredTools } : {}),
+    ...(config.requiredOutputs?.length ? { requiredOutputs: config.requiredOutputs } : {}),
+    ...(config.gates?.length ? { gates: config.gates } : {}),
+    ...(config.budgetTier ? { budgetTier: config.budgetTier } : {}),
+    ...(config.contextStrategy ? { contextStrategy: config.contextStrategy } : {}),
+    ...(config.failureProtocol ? { failureProtocol: config.failureProtocol } : {}),
+  })}\n-->`;
+
 export const buildSkillDocMarkdown = (options: {
   body?: string;
   skillConfig: SkillDocConfig;
   evalConfig?: SkillEvalConfig;
+  workflowConfig?: WorkflowReferenceConfig;
 }): string => {
   const sections = [
     options.body?.trim() || "",
     buildSkillConfigComment(options.skillConfig),
     options.evalConfig ? buildEvalConfigComment(options.evalConfig) : "",
+    options.workflowConfig ? buildWorkflowConfigComment(options.workflowConfig) : "",
   ].filter(Boolean);
   return sections.join("\n\n").trim();
 };

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

@@ -7,6 +7,7 @@ import {
   runAgentTurn,
   shouldUseScriptBridge,
 } from "./agentRun";
+import { NOLO_PROJECT_MANAGER_AGENT_KEY } from "../agentAliases";
 
 class CaptureOutput extends Writable {
   chunks: string[] = [];
@@ -452,6 +453,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[] = [];
@@ -502,7 +572,7 @@ describe("cli agent run client", () => {
 
     const result = await runAgentTurn({
       agentName: "pm",
-      agentKey: "nolo-project-manager",
+      agentKey: "agent-custom-platform-tools",
       serverUrl: "https://nolo.chat",
       message: "write task rows",
       scriptDir: "C:/missing/scripts",
@@ -539,13 +609,60 @@ describe("cli agent run client", () => {
 
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-server" });
     expect(httpCalls).toHaveLength(1);
-    expect(httpCalls[0]?.body.agentKey).toBe("nolo-project-manager");
+    expect(httpCalls[0]?.body.agentKey).toBe("agent-custom-platform-tools");
     expect(output.text()).toContain("auto runtime: skipping local runtime");
     expect(output.text()).toContain("queryTableRows, addTableRow, updateTableRow");
     expect(output.text()).toContain("pm -> working");
     expect(output.text()).toContain("pm > server ok");
   });
 
+  test("auto mode skips known platform agents when local config cannot be read", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: Array<{ url: string; body: any }> = [];
+
+    const result = await runAgentTurn({
+      agentName: "nolo-project-manager",
+      agentKey: NOLO_PROJECT_MANAGER_AGENT_KEY,
+      serverUrl: "https://us.nolo.chat",
+      message: "write task rows",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123", OPENAI_API_KEY: "local-provider-present" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "local-tools"],
+        loadAgentConfig: async () => {
+          throw new Error("Database failed to open: LOCK");
+        },
+        loadDialogHistory: async () => {
+          throw new Error("local runtime should be skipped");
+        },
+        saveTurn: async () => {
+          throw new Error("local runtime should be skipped");
+        },
+        resolveProvider: async () => {
+          throw new Error("local provider should be skipped");
+        },
+        executeTool: async () => {
+          throw new Error("local tools should be skipped");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (url, init) => {
+        httpCalls.push({ url: String(url), body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "server ok", dialogId: "dialog-server" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-server" });
+    expect(httpCalls).toHaveLength(1);
+    expect(httpCalls[0]?.body.agentKey).toBe(NOLO_PROJECT_MANAGER_AGENT_KEY);
+    expect(output.text()).toContain("known platform agent");
+    expect(output.text()).toContain("nolo-project-manager -> working");
+    expect(output.text()).toContain("nolo-project-manager > server ok");
+  });
+
   test("builds the default local adapter when env requests local mode", async () => {
     const output = new CaptureOutput();
     const builtModes: string[] = [];

package/client/agentRun.ts

@@ -1,6 +1,13 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { runLocalAgentTurn } from "../agentRuntimeLocal";
+import {
+  FRONTEND_IMPLEMENTER_AGENT_KEY,
+  NOLO_FULLSTACK_AGENT_KEY,
+  NOLO_PROJECT_MANAGER_AGENT_KEY,
+  NOLO_REVIEW_AGENT_KEY,
+  NOLO_SENIOR_FULLSTACK_AGENT_KEY,
+} from "../agentAliases";
 import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
@@ -15,6 +22,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 +63,7 @@ type RunAgentTurnOptions = {
     dialogId?: string;
     resultSummary?: string;
     errorCode?: string;
+    toolEvidence?: TaskRunToolEvidence;
   }) => Promise<void>;
   scriptPathExists?: (path: string) => boolean;
   fetchImpl?: typeof fetch;
@@ -74,6 +91,38 @@ const SERVER_PLATFORM_TOOL_NAMES = new Set([
   "updateTableRows",
 ]);
 
+const KNOWN_SERVER_PLATFORM_AGENT_KEYS = new Set([
+  FRONTEND_IMPLEMENTER_AGENT_KEY,
+  NOLO_FULLSTACK_AGENT_KEY,
+  NOLO_PROJECT_MANAGER_AGENT_KEY,
+  NOLO_REVIEW_AGENT_KEY,
+  NOLO_SENIOR_FULLSTACK_AGENT_KEY,
+]);
+
+const KNOWN_SERVER_PLATFORM_AGENT_ALIASES = new Set([
+  "code-review",
+  "frontend",
+  "frontend-agent",
+  "frontend-implementer",
+  "full-stack",
+  "fullstack",
+  "nolo code review",
+  "nolo frontend",
+  "nolo fullstack",
+  "nolo project manager",
+  "nolo reviewer",
+  "nolo-code-review",
+  "nolo-frontend",
+  "nolo-fullstack",
+  "nolo-pm",
+  "nolo-project-manager",
+  "nolo-reviewer",
+  "pm",
+  "project-manager",
+  "review",
+  "reviewer",
+]);
+
 export function shouldUseScriptBridge(decision: ScriptBridgeDecision) {
   return !decision.hasAuthToken && decision.scriptPathExists;
 }
@@ -82,6 +131,16 @@ export function findServerPlatformTools(toolNames?: string[]) {
   if (!Array.isArray(toolNames)) return [];
   return toolNames.filter((toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName));
 }
+
+function normalizeAgentRef(ref?: string) {
+  return ref?.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+function isKnownServerPlatformAgent(options: RunAgentTurnOptions) {
+  if (KNOWN_SERVER_PLATFORM_AGENT_KEYS.has(options.agentKey)) return true;
+  const normalizedKey = normalizeAgentRef(options.agentKey);
+  return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
+}
 
 function resolveAuthToken(env: EnvLike) {
   return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
@@ -116,6 +175,13 @@ function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
 }
 
 async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
+  if (isKnownServerPlatformAgent(options)) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
+        "Use --local explicitly to force local workspace tools.\n"
+    );
+    return true;
+  }
   const adapter = resolveLocalRuntimeAdapter(options);
   if (!adapter) return false;
   let agentConfig;
@@ -148,6 +214,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 +352,7 @@ async function defaultTaskRunRecorder(args: {
   dialogId?: string;
   resultSummary?: string;
   errorCode?: string;
+  toolEvidence?: TaskRunToolEvidence;
 }) {
   const context = args.options.taskRunContext;
   if (!context?.rowDbKey) return;
@@ -298,6 +391,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 +445,7 @@ async function recordTaskRunOutcome(args: {
   dialogId?: string;
   resultSummary?: string;
   errorCode?: string;
+  toolEvidence?: TaskRunToolEvidence;
 }) {
   if (!args.options.taskRunContext?.rowDbKey) return;
   try {
@@ -594,6 +694,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 +711,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 +730,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 +750,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 +761,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.22",
   "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>]",