nolo-cli 0.1.21 → 0.1.23

package/agent-runtime/agentRecordConfig.ts

@@ -73,6 +73,9 @@ export function resolveAgentRuntimeConfigFromRecord(
   const maxTokens = numberField(record, "max_tokens");
   const reasoningEffort = stringField(record, "reasoning_effort");
   const runtimeBinding = objectField(record, "runtimeBinding");
+  const runtimeToolPolicy =
+    objectField(record, "runtimeToolPolicy") ??
+    objectField(runtimeBinding ?? {}, "runtimeToolPolicy");
   const localWorkspaceMode = localWorkspaceModeField(record);
   const delegation = objectField(record, "delegation");
   return {
@@ -92,6 +95,7 @@ export function resolveAgentRuntimeConfigFromRecord(
     ...(maxTokens !== undefined ? { max_tokens: maxTokens } : {}),
     ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
     ...(runtimeBinding ? { runtimeBinding } : {}),
+    ...(runtimeToolPolicy ? { runtimeToolPolicy } : {}),
     ...(localWorkspaceMode ? { localWorkspaceMode } : {}),
     ...(delegation ? { delegation } : {}),
     rawRecord: record,

package/agent-runtime/hostAdapter.ts

@@ -2,6 +2,7 @@ import type {
   AgentRuntimeChatMessage,
   AgentRuntimeHost,
   AgentRuntimeResult,
+  AgentRuntimeToolPolicy,
 } from "./types";
 
 export type AgentRuntimeAgentConfig = {
@@ -21,6 +22,7 @@ export type AgentRuntimeAgentConfig = {
   max_tokens?: number;
   reasoning_effort?: string;
   runtimeBinding?: Record<string, unknown>;
+  runtimeToolPolicy?: AgentRuntimeToolPolicy;
   localWorkspaceMode?: "current" | "task-worktree";
   delegation?: Record<string, unknown>;
   rawRecord?: Record<string, unknown>;

package/agent-runtime/index.ts

@@ -45,6 +45,11 @@ export {
   executeLocalToolWithPolicy,
   resolveLocalToolPolicy,
 } from "./localToolPolicy";
+export {
+  mergeAgentRuntimeToolPolicies,
+  normalizeAgentRuntimeToolPolicy,
+  resolveEffectiveRuntimeToolPolicy,
+} from "./runtimeToolPolicy";
 export {
   buildLocalWorkspaceOpenAiTools,
   buildLocalWorkspacePolicyToolNames,
@@ -94,5 +99,7 @@ export type {
   AgentRuntimeMode,
   AgentRuntimeRequestedMode,
   AgentRuntimeResult,
+  AgentRuntimeToolPolicy,
   AgentRuntimeToolCall,
+  AgentRuntimeWorkspaceMode,
 } from "./types";

package/agent-runtime/localLoop.ts

@@ -26,6 +26,7 @@ export type LocalAgentToolEvent = {
   toolCallId: string;
   toolName: string;
   message?: string;
+  metadata?: Record<string, unknown>;
 };
 
 const DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS = 16;
@@ -119,6 +120,7 @@ export async function runLocalAgentTurn(
           round,
           toolCallId: toolCall.id,
           toolName,
+          metadata: toolResult.metadata,
         });
       } catch (error) {
         if (!shouldReturnToolExecutionErrors(input.adapter)) throw error;

package/agent-runtime/platformChatProvider.ts

@@ -23,6 +23,7 @@ const PROVIDER_ENDPOINTS: Record<string, string> = {
 export type PlatformChatProviderConfig = {
   serverUrl: string;
   authToken: string;
+  agentKey: string;
   model: string;
   provider: string;
   endpoint: string;
@@ -93,6 +94,7 @@ export function resolvePlatformChatProviderConfig(args: {
   return {
     serverUrl: resolvePlatformServerUrl(args.env),
     authToken: resolvePlatformAuthToken(args.env),
+    agentKey: args.agentConfig.key,
     model: args.agentConfig.model || "gpt-4.1-mini",
     provider,
     endpoint: resolveProviderEndpoint(args.agentConfig),
@@ -118,6 +120,7 @@ export function buildPlatformChatCompletionRequest(args: {
     ...(shouldDisableThinking(args.providerConfig) ? { thinking: { type: "disabled" } } : {}),
     url: args.providerConfig.endpoint,
     provider: args.providerConfig.provider,
+    agentKey: args.providerConfig.agentKey,
     ...(args.providerConfig.apiSource ? { apiSource: args.providerConfig.apiSource } : {}),
     ...(args.providerConfig.apiKey ? { KEY: args.providerConfig.apiKey } : {}),
   };

package/agent-runtime/runtimeToolPolicy.ts

@@ -0,0 +1,92 @@
+import type { AgentRuntimeAgentConfig } from "./hostAdapter";
+import type { AgentRuntimeToolPolicy } from "./types";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function stringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is string => typeof item === "string" && !!item.trim());
+}
+
+function unique(values: string[]) {
+  return [...new Set(values)];
+}
+
+function mergeRecords<T extends Record<string, unknown>>(
+  base: T | undefined,
+  override: T | undefined,
+): T | undefined {
+  if (!base && !override) return undefined;
+  return {
+    ...(base ?? {}),
+    ...(override ?? {}),
+  } as T;
+}
+
+export function normalizeAgentRuntimeToolPolicy(
+  value: unknown,
+): AgentRuntimeToolPolicy | undefined {
+  if (!isRecord(value)) return undefined;
+  return {
+    version: 1,
+    ...(stringArray(value.agentTools).length
+      ? { agentTools: unique(stringArray(value.agentTools)) }
+      : {}),
+    ...(stringArray(value.runtimeTools).length
+      ? { runtimeTools: unique(stringArray(value.runtimeTools)) }
+      : {}),
+    ...(isRecord(value.workspace) ? { workspace: { ...value.workspace } } : {}),
+    ...(isRecord(value.shell) ? { shell: { ...value.shell } } : {}),
+    ...(isRecord(value.git) ? { git: { ...value.git } } : {}),
+    ...(isRecord(value.budget) ? { budget: { ...value.budget } } : {}),
+    ...(isRecord(value.audit) ? { audit: { ...value.audit } } : {}),
+  };
+}
+
+export function mergeAgentRuntimeToolPolicies(
+  base?: AgentRuntimeToolPolicy,
+  override?: AgentRuntimeToolPolicy,
+): AgentRuntimeToolPolicy | undefined {
+  if (!base && !override) return undefined;
+  return {
+    version: 1,
+    agentTools: unique([
+      ...(base?.agentTools ?? []),
+      ...(override?.agentTools ?? []),
+    ]),
+    runtimeTools: unique([
+      ...(base?.runtimeTools ?? []),
+      ...(override?.runtimeTools ?? []),
+    ]),
+    workspace: {
+      ...(base?.workspace ?? {}),
+      ...(override?.workspace ?? {}),
+      writableRoots: unique([
+        ...(base?.workspace?.writableRoots ?? []),
+        ...(override?.workspace?.writableRoots ?? []),
+      ]),
+    },
+    shell: mergeRecords(base?.shell, override?.shell),
+    git: mergeRecords(base?.git, override?.git),
+    budget: mergeRecords(base?.budget, override?.budget),
+    audit: mergeRecords(base?.audit, override?.audit),
+  };
+}
+
+export function resolveEffectiveRuntimeToolPolicy(args: {
+  agentConfig: Pick<AgentRuntimeAgentConfig, "runtimeToolPolicy" | "runtimeBinding">;
+  taskRunControl?: { runtimeToolPolicy?: unknown } | null;
+}): AgentRuntimeToolPolicy | undefined {
+  const agentPolicy = normalizeAgentRuntimeToolPolicy(
+    args.agentConfig.runtimeToolPolicy ??
+      (isRecord(args.agentConfig.runtimeBinding)
+        ? args.agentConfig.runtimeBinding.runtimeToolPolicy
+        : undefined),
+  );
+  const taskPolicy = normalizeAgentRuntimeToolPolicy(
+    args.taskRunControl?.runtimeToolPolicy,
+  );
+  return mergeAgentRuntimeToolPolicies(agentPolicy, taskPolicy);
+}

package/agent-runtime/types.ts

@@ -81,6 +81,48 @@ export type AgentRuntimeDecisionInput = {
   serverFallbackAvailable: boolean;
 };
 
+export type AgentRuntimeWorkspaceMode = "none" | "current" | "task-worktree" | "lease";
+
+export type AgentRuntimeShellPolicy = {
+  enabled?: boolean;
+  mode?: "off" | "worktree";
+  commandPolicy?: "denylist" | "allowlist" | "approval";
+  networkPolicy?: "default-deny" | "allowed" | "approval";
+  maxSeconds?: number;
+  maxOutputBytes?: number;
+};
+
+export type AgentRuntimeGitPolicy = {
+  canCommit?: boolean;
+  canPushAlpha?: boolean;
+  canMergeMain?: boolean;
+};
+
+export type AgentRuntimeAuditPolicy = {
+  logToolCalls?: boolean;
+  logShellCommands?: boolean;
+  writeToDialog?: boolean;
+  writeToTask?: boolean;
+};
+
+export type AgentRuntimeToolPolicy = {
+  version?: 1;
+  agentTools?: string[];
+  runtimeTools?: string[];
+  workspace?: {
+    mode?: AgentRuntimeWorkspaceMode;
+    writableRoots?: string[];
+    cwd?: string;
+  };
+  shell?: AgentRuntimeShellPolicy;
+  git?: AgentRuntimeGitPolicy;
+  budget?: {
+    dailyUsdLimit?: number;
+    maxRunSeconds?: number;
+  };
+  audit?: AgentRuntimeAuditPolicy;
+};
+
 export type AgentRuntimeDecision = {
   mode: AgentRuntimeMode;
   runnable: boolean;

package/agentRunCommand.ts

@@ -3,6 +3,7 @@ import { runAgentTurn, type RunAgentTurnResult } from "./client/agentRun";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "./agentRuntimeLocal";
 import { existsSync, readFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
+import { parseSkillDocProtocol, type WorkflowReferenceConfig } from "./ai/skills/skillDocProtocol";
 import { resolveCliAgentKeyInput } from "./agentAliases";
 import {
   ensureWorkspacePackageLinks,
@@ -27,6 +28,7 @@ type AgentRunCommandDeps = {
   prepareTaskWorktree?: typeof prepareTaskWorktree;
   ensureWorkspacePackageLinks?: typeof ensureWorkspacePackageLinks;
   inspectLocalRunWorkspace?: typeof inspectLocalRunWorkspace;
+  resolveWorkflowReference?: typeof resolveWorkflowReference;
 };
 
 type LocalRunWorkspaceInspection = {
@@ -63,6 +65,13 @@ type ParsedAgentRunArgs = {
   traceTools: boolean;
   useTaskWorktree: boolean;
   taskRunContext?: TaskRunPromptContext;
+  workflowRef?: string;
+};
+
+type ResolvedWorkflowReference = {
+  ref: string;
+  content: string;
+  config?: Partial<WorkflowReferenceConfig>;
 };
 
 const DEFAULT_TEST_ROOT_DIALOG_ID = "01KN6V3MVEQA4Q1PNKVM2W7YY8";
@@ -171,6 +180,7 @@ export function parseAgentRunArgs(
     ...readRepeatedFlagValues(args, "--image-url"),
   ];
   const useTaskWorktree = args.includes("--worktree-task");
+  const workflowRef = readFlagValue(args, "--workflow");
   const taskRowDbKey = readFlagValue(args, "--task-row-dbkey");
   const artifactIds = readFlagValue(args, "--artifact-ids")
     ?.split(",")
@@ -183,6 +193,7 @@ export function parseAgentRunArgs(
     allowShell: args.includes("--dangerously-allow-shell"),
     traceTools: args.includes("--trace-tools"),
     useTaskWorktree,
+    ...(workflowRef ? { workflowRef } : {}),
     ...(taskRowDbKey
       ? {
           taskRunContext: {
@@ -208,6 +219,57 @@ export function parseAgentRunArgs(
   };
 }
 
+function workflowRefToCandidatePath(cwd: string, ref: string) {
+  const normalized = ref.trim();
+  if (!normalized) return "";
+  if (normalized.endsWith(".md") || normalized.includes("/") || normalized.includes("\\")) {
+    const directPath = resolve(cwd, normalized);
+    if (existsSync(directPath)) return directPath;
+  }
+  const fileName = normalized.replace(/[^a-zA-Z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
+  return resolve(cwd, "docs", "workflows", `${fileName}.md`);
+}
+
+export async function resolveWorkflowReference(ref: string, cwd = process.cwd()): Promise<ResolvedWorkflowReference> {
+  const path = workflowRefToCandidatePath(cwd, ref);
+  if (!path || !existsSync(path)) {
+    throw new Error(`Workflow reference not found: ${ref}`);
+  }
+  const markdown = readFileSync(path, "utf8");
+  const parsed = parseSkillDocProtocol(markdown);
+  return {
+    ref,
+    content: parsed.content,
+    ...(parsed.meta?.workflowConfig ? { config: parsed.meta.workflowConfig } : {}),
+  };
+}
+
+export function prependWorkflowReferencePrompt(message: string, workflow?: ResolvedWorkflowReference): string {
+  if (!workflow) return message;
+  const config = workflow.config;
+  return [
+    "AI-native workflow reference:",
+    "- This reference is guidance for the agent, not a central workflow engine.",
+    `- ref: ${workflow.ref}`,
+    ...(config?.id ? [`- id: ${config.id}`] : []),
+    ...(config?.name ? [`- name: ${config.name}`] : []),
+    ...(config?.defaultAgent ? [`- suggested defaultAgent: ${config.defaultAgent}`] : []),
+    ...(config?.inputs?.length ? [`- inputs: ${config.inputs.join(", ")}`] : []),
+    ...(config?.recommendedTools?.length ? [`- recommendedTools: ${config.recommendedTools.join(", ")}`] : []),
+    ...(config?.requiredTools?.length ? [`- requiredTools: ${config.requiredTools.join(", ")}`] : []),
+    ...(config?.requiredOutputs?.length ? [`- requiredOutputs: ${config.requiredOutputs.join(", ")}`] : []),
+    ...(config?.gates?.length ? [`- gates: ${config.gates.join(", ")}`] : []),
+    ...(config?.contextStrategy ? [`- contextStrategy: ${config.contextStrategy}`] : []),
+    ...(config?.failureProtocol ? [`- failureProtocol: ${config.failureProtocol}`] : []),
+    "",
+    "Reference body:",
+    workflow.content,
+    "",
+    "User task:",
+    message,
+  ].join("\n");
+}
+
 function parseDialogReference(rawInput: string) {
   const normalized = rawInput.trim();
   if (normalized.startsWith("dialog-")) {
@@ -353,6 +415,17 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
   }
 
   const runner = deps.runner ?? runAgentTurn;
+  let workflowReference: ResolvedWorkflowReference | undefined;
+  if (parsed.workflowRef) {
+    try {
+      workflowReference = await (deps.resolveWorkflowReference ?? resolveWorkflowReference)(
+        parsed.workflowRef
+      );
+    } catch (error) {
+      output.write(`[nolo] ${error instanceof Error ? error.message : String(error)}\n`);
+      return 1;
+    }
+  }
   let localRuntimeCwd = parsed.cwd;
   if (shouldPrepareTaskWorktree(parsed)) {
     try {
@@ -399,7 +472,7 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     agentName: parsed.agentKey,
     agentKey: parsed.agentKey,
     serverUrl: resolveServerUrl(env),
-    message: parsed.message,
+    message: prependWorkflowReferencePrompt(parsed.message, workflowReference),
     imageUrls: parsed.imageUrls.map(normalizeCliImageInput),
     scriptDir: deps.scriptDir,
     env: runEnv,

package/agentRuntimeCommands.ts

@@ -2,19 +2,11 @@ import type { MachineHeartbeat } from "./connector-experimental/protocol";
 import { detectMachineInfo } from "./connector-experimental/machineInfo";
 import { resolveAgentRuntimeDecision } from "./agent-runtime/runtimeDecision";
 import { resolveCliLocalRuntimeDbPath } from "./localRuntimeDb";
-import {
-  assertMachineRunAllowed,
-  buildMachinePermissionPromptBlock,
-  resolveMachineRunPermissionPolicy,
-} from "./ai/agent/machineRunPermissions";
+import { resolveMachineRunPermissionPolicy } from "./ai/agent/machineRunPermissions";
 import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
 import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import { resolveCliAgentKeyInput } from "./agentAliases";
-import {
-  collectConnectorRunArtifact,
-  readConnectorGitHead,
-  resolveConnectorRunCwd,
-} from "./connectorRunArtifact";
+import { handleConnectorRunMessage } from "./machineCommands";
 
 type EnvLike = Record<string, string | undefined>;
 type OutputLike = { write(chunk: string): unknown };
@@ -138,22 +130,6 @@ function detectLaunchableMachineInfo() {
   return detectMachineInfo({ probeLaunchable: true });
 }
 
-function buildConnectorCliPrompt(agentConfig: any, userInput: string) {
-  const policy = resolveMachineRunPermissionPolicy(agentConfig);
-  return [
-    typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
-    buildMachinePermissionPromptBlock(policy),
-    `--- User task ---\n${userInput}`,
-  ].filter(Boolean).join("\n\n");
-}
-
-function normalizeConnectorRunTimeoutMs(value: unknown): number | undefined {
-  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-    return undefined;
-  }
-  return Math.floor(value);
-}
-
 function requiredCapabilityForAgent(agent: any) {
   if (agent?.apiSource !== "cli") return "";
   const cliProvider = String(agent?.cliProvider || "").trim();
@@ -255,64 +231,6 @@ async function defaultConnectWebSocket(url: string, options: SmokeWebSocketOptio
   });
 }
 
-async function handleSmokeConnectorMessage(
-  message: string,
-  send: (message: string) => void,
-  executeCli: LocalCliExecutor
-) {
-  let parsed: any;
-  try {
-    parsed = JSON.parse(message);
-  } catch {
-    return;
-  }
-  if (parsed?.type !== "agent.run" || typeof parsed.requestId !== "string") return;
-  const agentConfig = parsed.payload?.agentConfig ?? {};
-  try {
-    if (agentConfig.apiSource !== "cli") {
-      throw new Error("Connector can only execute CLI agents. Set the agent apiSource to cli and choose a cliProvider.");
-    }
-    const provider = String(agentConfig.cliProvider || "copilot");
-    const policy = resolveMachineRunPermissionPolicy(agentConfig);
-    const userInput = String(parsed.payload?.userInput ?? "");
-    const timeout = normalizeConnectorRunTimeoutMs(parsed.payload?.timeoutMs);
-    assertMachineRunAllowed(userInput, policy);
-    const cwd = resolveConnectorRunCwd({ env: process.env, policy });
-    const baseSha = await readConnectorGitHead(cwd);
-    const result = await executeCli(
-      provider,
-      buildConnectorCliPrompt(agentConfig, userInput),
-      {
-        model: agentConfig.model || undefined,
-        timeout,
-        cwd,
-        yolo: true,
-      }
-    );
-    const artifacts = await collectConnectorRunArtifact({
-      cwd,
-      baseSha,
-      exitStatus: "completed",
-    });
-    send(JSON.stringify({
-      type: "agent.run.result",
-      requestId: parsed.requestId,
-      result: {
-        content: result.text,
-        model: agentConfig.model ?? provider,
-        trace: [{ role: "assistant", content: result.text }],
-        artifacts,
-      },
-    }));
-  } catch (error) {
-    send(JSON.stringify({
-      type: "agent.run.result",
-      requestId: parsed.requestId,
-      error: error instanceof Error ? error.message : String(error),
-    }));
-  }
-}
-
 async function readAgentRecord(args: {
   agentKey: string;
   authToken: string;
@@ -625,11 +543,21 @@ export async function runAgentSmokeCurrentCommand(
       {
         headers: { Authorization: `Bearer ${authToken}` },
         sentMessages,
-        onMessage: (message) => handleSmokeConnectorMessage(
-          message,
-          (response) => sentMessages.push(response),
-          deps.executeCli ?? defaultExecuteCli
-        ),
+        onMessage: (message) => handleConnectorRunMessage(
+          machine,
+          message,
+          (response) => sentMessages.push(response),
+          deps.executeCli ?? defaultExecuteCli,
+          {
+            ...env,
+            NOLO_SERVER: serverUrl,
+            NOLO_SERVER_URL: serverUrl,
+            BASE_URL: serverUrl,
+            AUTH_TOKEN: authToken,
+            NOLO_MACHINE_API_KEY: authToken,
+          },
+          fetchImpl
+        ),
         onOpen: async () => {
           const res = await fetchImpl(`${serverUrl}/api/agent/run`, {
             method: "POST",