nolo-cli 0.1.41 → 0.1.43

package/README.md

@@ -37,6 +37,9 @@ nolo
 nolo doctor
 nolo --version
 
+# no Nolo login required: runs the local Codex CLI in the current directory
+nolo run "review this repository"
+
 # update later from your shell
 nolo update
 ```
@@ -48,7 +51,14 @@ Inside the TUI, run:
 ```
 
 The npm package expects Bun to be available because the executable is a Bun
-TypeScript script. For agent calls outside this repository, provide a token:
+TypeScript script.
+
+For local maintainer workflows, `nolo run "..."` does not require a Nolo
+account. It resolves to the built-in `local-codex` agent, runs in the current
+working directory, and uses the local Codex CLI installation. This is intended
+for repository-local review, triage, and release-check tasks.
+
+Remote Nolo records and synced workflows still require a token:
 
 ```bash
 NOLO_SERVER=https://nolo.chat AUTH_TOKEN=<token> nolo
@@ -87,6 +97,8 @@ nolo --help
 nolo doctor
 nolo update
 nolo
+nolo run "review this repository"
+nolo chat "triage the failing tests"
 nolo chat
 nolo connect
 nolo connect --watch
@@ -107,8 +119,8 @@ nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"
 
 For document creation, prefer the CLI over direct scripts. Use `nolo doc create`
 for ordinary pages and `nolo skill-doc create` for skill-backed pages. Both
-support `--sync`, `--dry-run`, `--json`, and `--allow-secrets`; scripts remain
-the lower-level fallback for debugging.
+support `--sync`, `--dry-run`, `--json`, and `--allow-secrets`, and both write
+for the current auth token user rather than a demo bootstrap user.
 
 Experimental machine connector commands:
 
@@ -176,7 +188,7 @@ nolo agent list --space <space>
 nolo dialog list
 nolo dialog list --space <space>
 nolo dialog read <dialog>
-nolo dialog delete <dialog> --yes
+nolo dialog delete <dialog...> --yes
 nolo doc list --agent <agent>
 nolo table query --table meta-0e95801d90-NOLOTASKBOARD --limit 20
 nolo table query --table meta-0e95801d90-NOLOTASKBOARD --columns '["title","status","owner","priority","codeStatus"]' --no-base-fields --output items
@@ -208,14 +220,17 @@ commands instead of ad hoc scripts:
   updates such as `--model`, `--cli-provider`, `--api-source`, and repeated
   `--field key=value`.
 
-Account ownership matters for private agent maintenance. The legacy
-`b2e06f801f` / platform-demo account still owns older agents, task-board data,
-and workspace records, while newer personal or machine-bound work may belong to
-the current operator account. Use `nolo agent read`, `nolo agent update`, and
-repo-native helpers as the normal entrypoints; only owner-only operations such
-as private record updates/deletes should use the maintained platform-demo token
-from `scripts/testUtils.ts` or a regenerated token from `scripts/generateToken.ts`.
-Do not copy token strings into docs, logs, or prompts.
+Account ownership matters for private agent maintenance. Default new tests,
+validation dialogs, task-board writes, machine-bound agent runs, and
+user-visible results should write to the current operator account
+`0e95801d90`. The legacy
+`b2e06f801f` / platform-demo account still owns older public/shared records, but
+it is being retired as the default write target. Use `nolo agent read`,
+`nolo agent update`, and repo-native helpers as the normal entrypoints; only
+owner-only operations that explicitly target legacy records should use the
+maintained platform-demo token from `scripts/testUtils.ts` or a regenerated
+token from `scripts/generateToken.ts`. Do not copy token strings into docs,
+logs, or prompts.
 
 Inside the current TUI, examples of supported slash commands include:
 `/agent`, `/agents`, `/switch`, `/context` (alias `/ctx`), `/dialog`, `/doc`,

package/agent-runtime/agentThread.ts

@@ -0,0 +1,222 @@
+export const AGENT_THREAD_RECORD_PREFIX = "agent-thread";
+export const AGENT_THREAD_INDEX_PREFIX = "agent-threadidx";
+
+export const AGENT_THREAD_STATUSES = [
+  "pending",
+  "running",
+  "done",
+  "failed",
+  "cancelled",
+] as const;
+
+export const AGENT_THREAD_ACTIVE_STATUSES = ["pending", "running"] as const;
+export const AGENT_THREAD_TERMINAL_STATUSES = ["done", "failed", "cancelled"] as const;
+
+export const AGENT_THREAD_KINDS = [
+  "chat",
+  "background",
+  "inline",
+  "handoff",
+  "parallel_branch",
+  "scheduled",
+] as const;
+
+export const AGENT_THREAD_PRESENTATION_INTENTS = [
+  "background_handoff",
+  "inline_result",
+  "handoff_speaker",
+  "parallel_branch",
+] as const;
+
+export type AgentThreadStatus = (typeof AGENT_THREAD_STATUSES)[number];
+export type AgentThreadActiveStatus =
+  (typeof AGENT_THREAD_ACTIVE_STATUSES)[number];
+export type AgentThreadTerminalStatus =
+  (typeof AGENT_THREAD_TERMINAL_STATUSES)[number];
+export type AgentThreadKind = (typeof AGENT_THREAD_KINDS)[number];
+export type AgentThreadPresentationIntent =
+  (typeof AGENT_THREAD_PRESENTATION_INTENTS)[number];
+
+export type AgentThreadListSection = "running" | "future" | "recent";
+
+export type AgentThreadSubjectRef = {
+  kind: string;
+  id: string;
+  role?: string;
+};
+
+export type AgentThreadSchedule =
+  | {
+      kind: "once";
+      timezone?: string;
+      nextRunAt: number;
+    }
+  | {
+      kind: "cron";
+      timezone?: string;
+      expression: string;
+      nextRunAt: number;
+    }
+  | {
+      kind: "interval";
+      timezone?: string;
+      everyMs: number;
+      nextRunAt: number;
+    };
+
+export type AgentThreadEvidence = {
+  kind: string;
+  summary?: string;
+  refs?: AgentThreadSubjectRef[];
+  data?: Record<string, unknown>;
+};
+
+export type AgentThreadRuntimeCheckpoint = {
+  status?: string;
+  toolCallCount?: number;
+  traceSummary?: unknown;
+  lastToolNames?: string[];
+  lastAssistantText?: string;
+  evidence?: AgentThreadEvidence[];
+  policyState?: unknown;
+  runtimeBinding?: unknown;
+  errorMessage?: string;
+};
+
+export type AgentThread = {
+  threadId: string;
+  title?: string;
+  summary?: string;
+
+  primaryAgentKey: string;
+  agentKeys: string[];
+  userId: string;
+
+  status: AgentThreadStatus;
+  threadKind: AgentThreadKind;
+  presentationIntent?: AgentThreadPresentationIntent;
+
+  parentThreadId?: string;
+  rootThreadId?: string;
+
+  dialogId?: string;
+  dialogKey?: string;
+
+  subjectRefs?: AgentThreadSubjectRef[];
+
+  schedule?: AgentThreadSchedule;
+  lastRunThreadId?: string;
+
+  createdAt: number;
+  updatedAt: number;
+  startedAt?: number;
+  finishedAt?: number;
+
+  runtimeCheckpoint?: AgentThreadRuntimeCheckpoint;
+};
+
+export function buildAgentThreadKey(args: {
+  userId: string;
+  threadId: string;
+}): string {
+  return [AGENT_THREAD_RECORD_PREFIX, args.userId, args.threadId].join("-");
+}
+
+export function buildAgentThreadUserRange(userId: string): {
+  gte: string;
+  lte: string;
+} {
+  const start = `${AGENT_THREAD_RECORD_PREFIX}-${userId}-`;
+  return { gte: start, lte: `${start}\uffff` };
+}
+
+export function buildAgentThreadByAgentStatusIndexKey(args: {
+  userId: string;
+  primaryAgentKey: string;
+  status: AgentThreadStatus;
+  threadId: string;
+}): string {
+  return [
+    AGENT_THREAD_INDEX_PREFIX,
+    args.userId,
+    "agent",
+    args.primaryAgentKey,
+    "status",
+    args.status,
+    args.threadId,
+  ].join("-");
+}
+
+export function buildAgentThreadByAgentStatusRange(args: {
+  userId: string;
+  primaryAgentKey: string;
+  status: AgentThreadStatus;
+}): {
+  gte: string;
+  lte: string;
+} {
+  const start = [
+    AGENT_THREAD_INDEX_PREFIX,
+    args.userId,
+    "agent",
+    args.primaryAgentKey,
+    "status",
+    args.status,
+    "",
+  ].join("-");
+  return { gte: start, lte: `${start}\uffff` };
+}
+
+export function isAgentThreadActiveStatus(
+  status: string | null | undefined,
+): status is AgentThreadActiveStatus {
+  return (AGENT_THREAD_ACTIVE_STATUSES as readonly string[]).includes(
+    status ?? "",
+  );
+}
+
+export function isAgentThreadTerminalStatus(
+  status: string | null | undefined,
+): status is AgentThreadTerminalStatus {
+  return (AGENT_THREAD_TERMINAL_STATUSES as readonly string[]).includes(
+    status ?? "",
+  );
+}
+
+export function isFutureAgentThread(
+  thread: Pick<AgentThread, "schedule" | "status">,
+  nowMs: number,
+): boolean {
+  return (
+    isAgentThreadActiveStatus(thread.status) &&
+    typeof thread.schedule?.nextRunAt === "number" &&
+    thread.schedule.nextRunAt > nowMs
+  );
+}
+
+export function getAgentThreadListSection(
+  thread: Pick<AgentThread, "schedule" | "status">,
+  nowMs: number,
+): AgentThreadListSection {
+  if (isFutureAgentThread(thread, nowMs)) return "future";
+  if (isAgentThreadActiveStatus(thread.status)) return "running";
+  return "recent";
+}
+
+export function getAgentThreadRootId(
+  thread: Pick<AgentThread, "threadId" | "parentThreadId" | "rootThreadId">,
+): string {
+  return thread.rootThreadId || thread.parentThreadId || thread.threadId;
+}
+
+export function buildChildAgentThreadRelations(
+  parent: Pick<AgentThread, "threadId" | "rootThreadId">,
+): {
+  parentThreadId: string;
+  rootThreadId: string;
+} {
+  return {
+    parentThreadId: parent.threadId,
+    rootThreadId: parent.rootThreadId || parent.threadId,
+  };
+}

package/agent-runtime/agentThreadAdmission.ts

@@ -0,0 +1,74 @@
+/**
+ * Default maxConcurrent used when an agent has no admission config.
+ * v0 policy: hard-coded to 2 until per-agent config is widely adopted.
+ */
+export const DEFAULT_AGENT_THREAD_MAX_CONCURRENT = 2;
+
+export type AgentThreadAdmissionConfig = {
+  maxConcurrent?: unknown;
+};
+
+export type AgentThreadAdmissionAgentConfig = {
+  maxConcurrent?: unknown;
+  admission?: AgentThreadAdmissionConfig | null;
+} | null | undefined;
+
+export type AgentThreadAdmissionDecision =
+  | {
+      allowed: true;
+      activeThreadCount: number;
+      maxConcurrent: number;
+    }
+  | {
+      allowed: false;
+      reason: "max_concurrent_reached";
+      activeThreadCount: number;
+      maxConcurrent: number;
+    };
+
+export function normalizeAgentThreadMaxConcurrent(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    return null;
+  }
+  return value;
+}
+
+export function resolveAgentThreadMaxConcurrent(
+  agentConfig: AgentThreadAdmissionAgentConfig,
+): number | null {
+  const nestedLimit = normalizeAgentThreadMaxConcurrent(
+    agentConfig?.admission?.maxConcurrent,
+  );
+  if (nestedLimit != null) return nestedLimit;
+  return normalizeAgentThreadMaxConcurrent(agentConfig?.maxConcurrent);
+}
+
+export function decideAgentThreadAdmission(input: {
+  agentConfig: AgentThreadAdmissionAgentConfig;
+  activeThreadCount: number;
+}): AgentThreadAdmissionDecision {
+  const activeThreadCount =
+    typeof input.activeThreadCount === "number" &&
+    Number.isFinite(input.activeThreadCount) &&
+    input.activeThreadCount > 0
+      ? Math.floor(input.activeThreadCount)
+      : 0;
+  const maxConcurrent =
+    resolveAgentThreadMaxConcurrent(input.agentConfig) ??
+    DEFAULT_AGENT_THREAD_MAX_CONCURRENT;
+
+  if (activeThreadCount < maxConcurrent) {
+    return {
+      allowed: true,
+      activeThreadCount,
+      maxConcurrent,
+    };
+  }
+
+  return {
+    allowed: false,
+    reason: "max_concurrent_reached",
+    activeThreadCount,
+    maxConcurrent,
+  };
+}

package/agent-runtime/dialogWritePlan.ts

@@ -10,6 +10,11 @@ type DialogWriteOp = {
   key: string;
   value: DialogRecord;
 };
+type DialogSubjectRef = {
+  kind: string;
+  id: string;
+  role?: string;
+};
 
 function extractLastUserText(messages: AgentRuntimeChatMessage[]) {
   const lastUser = [...messages].reverse().find((message) => message.role === "user");
@@ -38,6 +43,41 @@ function normalizeNonEmptyString(value: unknown) {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 
+function normalizeSubjectRef(ref: unknown): DialogSubjectRef | null {
+  if (!ref || typeof ref !== "object") return null;
+  const raw = ref as Record<string, unknown>;
+  const kind = normalizeNonEmptyString(raw.kind);
+  const id = normalizeNonEmptyString(raw.id);
+  if (!kind || !id) return null;
+  const role = normalizeNonEmptyString(raw.role);
+  return {
+    kind,
+    id,
+    ...(role ? { role } : {}),
+  };
+}
+
+function mergeSubjectRefs(...groups: unknown[]): DialogSubjectRef[] | undefined {
+  const refs: DialogSubjectRef[] = [];
+  const seen = new Set<string>();
+  for (const group of groups) {
+    if (!Array.isArray(group)) continue;
+    for (const item of group) {
+      const ref = normalizeSubjectRef(item);
+      if (!ref) continue;
+      const key = `${ref.kind}:${ref.id}:${ref.role ?? ""}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      refs.push(ref);
+    }
+  }
+  return refs.length ? refs : undefined;
+}
+
+function buildRuntimeSubjectRefs(runtimeContext?: Record<string, any> | null): DialogSubjectRef[] | undefined {
+  return mergeSubjectRefs(runtimeContext?.subjectRefs);
+}
+
 function buildDialogLineageFields(args: {
   input: AgentRuntimeSaveTurnInput;
   existingDialog?: DialogRecord | null;
@@ -105,6 +145,7 @@ export function buildAgentRuntimeDialogWritePlan(args: {
   const dialogId = args.input.continueDialogId || args.createId();
   const nowIso = new Date(args.now).toISOString();
   const dialogKey = `dialog-${args.userId}-${dialogId}`;
+  const subjectRefs = buildRuntimeSubjectRefs(args.input.runtimeContext);
   const dialogRecord = {
     ...(args.existingDialog && typeof args.existingDialog === "object" ? args.existingDialog : {}),
     id: dialogId,
@@ -126,6 +167,7 @@ export function buildAgentRuntimeDialogWritePlan(args: {
     usage: args.input.result.usage,
     ...(normalizeNonEmptyString(args.input.spaceId) ? { spaceId: normalizeNonEmptyString(args.input.spaceId) } : {}),
     ...(normalizeNonEmptyString(args.input.category) ? { category: normalizeNonEmptyString(args.input.category) } : {}),
+    ...(subjectRefs ? { subjectRefs } : {}),
     ...buildDialogLineageFields({
       input: args.input,
       existingDialog: args.existingDialog,

package/agent-runtime/hostAdapter.ts

@@ -55,6 +55,7 @@ export type AgentRuntimeSaveTurnInput = {
   agentKey: string;
   messages: AgentRuntimeChatMessage[];
   result: AgentRuntimeResult;
+  runtimeContext?: Record<string, any> | null;
   continueDialogId?: string;
   spaceId?: string;
   category?: string;

package/agent-runtime/index.ts

@@ -32,6 +32,31 @@ export {
   buildAgentRuntimeAgentLookupKeys,
   shouldFetchAgentRuntimeRecordRemotely,
 } from "./agentRecordKeys";
+export {
+  DEFAULT_AGENT_THREAD_MAX_CONCURRENT,
+  decideAgentThreadAdmission,
+  normalizeAgentThreadMaxConcurrent,
+  resolveAgentThreadMaxConcurrent,
+} from "./agentThreadAdmission";
+export {
+  AGENT_THREAD_ACTIVE_STATUSES,
+  AGENT_THREAD_INDEX_PREFIX,
+  AGENT_THREAD_KINDS,
+  AGENT_THREAD_PRESENTATION_INTENTS,
+  AGENT_THREAD_RECORD_PREFIX,
+  AGENT_THREAD_STATUSES,
+  AGENT_THREAD_TERMINAL_STATUSES,
+  buildAgentThreadByAgentStatusIndexKey,
+  buildAgentThreadByAgentStatusRange,
+  buildAgentThreadKey,
+  buildAgentThreadUserRange,
+  buildChildAgentThreadRelations,
+  getAgentThreadListSection,
+  getAgentThreadRootId,
+  isAgentThreadActiveStatus,
+  isAgentThreadTerminalStatus,
+  isFutureAgentThread,
+} from "./agentThread";
 export { resolveAgentRuntimeConfigFromRecord } from "./agentRecordConfig";
 export { dialogMessageRecordToAgentRuntimeMessage } from "./dialogMessageRecord";
 export { buildAgentRuntimeDialogWritePlan } from "./dialogWritePlan";
@@ -126,6 +151,24 @@ export type {
   RuntimeToolSurfaceResult,
   RuntimeToolSurfaceVisibility,
 } from "./runtimeToolSurface";
+export type {
+  AgentThreadAdmissionAgentConfig,
+  AgentThreadAdmissionConfig,
+  AgentThreadAdmissionDecision,
+} from "./agentThreadAdmission";
+export type {
+  AgentThread,
+  AgentThreadActiveStatus,
+  AgentThreadEvidence,
+  AgentThreadKind,
+  AgentThreadListSection,
+  AgentThreadPresentationIntent,
+  AgentThreadRuntimeCheckpoint,
+  AgentThreadSchedule,
+  AgentThreadStatus,
+  AgentThreadSubjectRef,
+  AgentThreadTerminalStatus,
+} from "./agentThread";
 export type {
   AgentRuntimeChatMessage,
   AgentRuntimeDecision,

package/agent-runtime/localLoop.ts

@@ -16,12 +16,14 @@ export type LocalAgentTurnInput = {
   category?: string;
   inheritedFromDialogKey?: string;
   parentDialogId?: string;
+  runtimeContext?: Record<string, any> | null;
   timeoutMs?: number;
   onToolEvent?: (event: LocalAgentToolEvent) => void;
 };
 
 export type LocalAgentTurnResult = AgentRuntimeResult & {
   dialogId: string;
+  turnMessages?: AgentRuntimeChatMessage[];
 };
 
 export type LocalAgentToolEvent = {
@@ -146,6 +148,26 @@ function summarizeToolResult(content: unknown, metadata?: Record<string, unknown
   return parts.join(" ");
 }
 
+function formatToolMessageContent(args: {
+  toolName: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+}) {
+  if (
+    (
+      args.toolName !== "listFiles" &&
+      args.toolName !== "globFiles" &&
+      args.toolName !== "searchFiles" &&
+      args.toolName !== "readFile"
+    ) ||
+    !args.metadata ||
+    Object.keys(args.metadata).length === 0
+  ) {
+    return args.content;
+  }
+  return `${args.content}\n\n[tool metadata]\n${JSON.stringify(args.metadata)}`;
+}
+
 function buildMessages(args: {
   prompt?: string;
   history: AgentRuntimeChatMessage[];
@@ -269,7 +291,11 @@ export async function runLocalAgentTurn(
       }
       messages.push({
         role: "tool",
-        content: toolResult.content,
+        content: formatToolMessageContent({
+          toolName,
+          content: toolResult.content,
+          metadata: toolResult.metadata,
+        }),
         tool_call_id: toolCall.id,
         ...(toolResult.metadata ? { tool_result_metadata: toolResult.metadata } : {}),
       });
@@ -281,14 +307,16 @@ export async function runLocalAgentTurn(
     role: "assistant",
     content: result.content,
   });
+  const turnMessages = messages.slice(turnStartIndex);
   const saved = await input.adapter.saveTurn({
     agentKey: agentConfig.key,
-    messages: messages.slice(turnStartIndex),
+    messages: turnMessages,
     result: {
       ...result,
       ...(toolCallCount > 0 ? { toolCallCount } : {}),
       ...((agentConfig as any).toolSurface ? { runtimeToolSurface: (agentConfig as any).toolSurface } : {}),
     },
+    ...(input.runtimeContext ? { runtimeContext: input.runtimeContext } : {}),
     ...(input.continueDialogId ? { continueDialogId: input.continueDialogId } : {}),
     ...(input.spaceId ? { spaceId: input.spaceId } : {}),
     ...(input.category ? { category: input.category } : {}),
@@ -301,5 +329,6 @@ export async function runLocalAgentTurn(
     ...(toolCallCount > 0 ? { toolCallCount } : {}),
     ...((agentConfig as any).toolSurface ? { runtimeToolSurface: (agentConfig as any).toolSurface } : {}),
     dialogId: saved.dialogId,
+    turnMessages,
   };
 }

package/agent-runtime/localToolPolicy.ts

@@ -32,6 +32,7 @@ const DEFAULT_LOCAL_TOOLS = new Set([
   "readFile",
   "writeFile",
   "editFile",
+  "globFiles",
   "searchFiles",
   "execShell",
 ]);