nolo-cli 0.1.26 → 0.1.29

package/server/handlers/agentRun/autonomousRuntime.ts

@@ -0,0 +1,355 @@
+import { DataType } from "../../../create/types";
+import type { DialogRuntimeProfile } from "../../../app/types";
+import { createPageServer } from "../../../render/page/server/createPage";
+import serverDb from "../../../database/server/db";
+
+type RuntimeCheckpointLike = {
+  toolCallCount?: number;
+  lastToolNames?: string[];
+} | null | undefined;
+
+type AutonomousWorkbenchDocKey = "mission" | "checkpoint" | "ideas";
+
+type AutonomousWorkbenchDoc = {
+  key: AutonomousWorkbenchDocKey;
+  title: string;
+  purpose: string;
+  dbKey: string;
+};
+
+type AutonomousRuntimeContext = {
+  block: string | null;
+  turnInstruction: string | null;
+  requiredTools: string[];
+  disabledTools: string[];
+  exclusiveTools: string[];
+};
+
+type AutonomousWorkbenchDocSpec = {
+  key: AutonomousWorkbenchDocKey;
+  title: string;
+  purpose: string;
+  initialContent: string;
+};
+
+const DURABLE_ASSET_TOOLS = new Set([
+  "createDoc",
+  "updateDoc",
+  "createSkillDoc",
+  "importSkill",
+  "rememberMemory",
+  "writeFile",
+  "applyEdit",
+  "updateSelf",
+  "createTable",
+  "addTableRow",
+]);
+
+const WORKBENCH_TARGET_PATTERN =
+  /(24h|workbench|工作台|mission|checkpoint|ideas|固定工作台|doc|文档)/i;
+
+const WORKBENCH_WRITE_ACTION_PATTERN =
+  /(updateDoc|append|追加|写入|更新|维护|记录|沉淀|保存|补充)/i;
+
+const NON_DOC_EXPLORATION_TOOLS = [
+  "checkEnv",
+  "execShell",
+  "codeSearch",
+  "read",
+  "readFile",
+  "fetchWebpage",
+  "exa_search",
+  "exa-search",
+];
+
+function shortAgentLabel(agentKey: string): string {
+  const trimmed = agentKey.trim();
+  if (trimmed.length <= 24) return trimmed;
+  return `${trimmed.slice(0, 10)}...${trimmed.slice(-10)}`;
+}
+
+function buildMissionDocContent(agentKey: string): string {
+  return [
+    "# 24h Mission",
+    "",
+    `- agentKey: \`${agentKey}\``,
+    "- role: 长期自主发展的 agent",
+    "- default objective: 持续产出可复用资产，而不是反复空总结",
+    "",
+    "## Identity",
+    "- 主动推进长期 mission",
+    "- 可以提出产品、赚钱、自动化、自我改进方向",
+    "- 优先沉淀 doc / memory / 实验结论 / 代码，而不是只停留在聊天",
+    "",
+    "## Current Mission",
+    "- current_focus: 维护一个可验证、可接力、低噪声的长期 agent 记忆/工作台系统",
+    "- success_condition: 下一轮 agent 能从 Checkpoint / Memory / Procedural runbook 恢复任务，而不是靠聊天猜测",
+    "- next_step: 每次真实任务后用 audit 判断推荐优化层；没有失败证据时不新增 summary/memory/skill",
+    "- failure_policy: 如果 running/stale、checkpoint、memory recall 任一层失败，先记录证据和 dialog id，再修最低层原因",
+    "",
+    "## Asset Strategy",
+    "- 能沉淀成长期工作台的内容，优先写 doc",
+    "- 用户偏好和近期复用经验，优先写 user memory",
+    "- 共享协作规则，才写 space memory",
+    "- 重复 3 次以上的排障流程，优先沉淀 procedural memory；只有需要可执行工具链时再升级 skill",
+    "",
+    "## Experiment Log Seed",
+    "- date: 2026-04-30",
+    "- result: 初始 mission 已结构化，后续每轮应补充证据、下一步和失败处理策略",
+  ].join("\n");
+}
+
+function buildCheckpointDocContent(agentKey: string): string {
+  return [
+    "# 24h Checkpoint Log",
+    "",
+    `- agentKey: \`${agentKey}\``,
+    "- 用于持续追加每一轮真正有价值的结果，而不是泛泛汇报",
+    "",
+    "## Logging Rules",
+    "- 记录完成的代码/文档/实验/记忆沉淀",
+    "- 记录失败尝试及其原因",
+    "- 记录下一步最高 ROI 的动作",
+    "",
+    "## Checkpoint Entry: initial-baseline",
+    "- case: workbench-initialization",
+    "- completed: 创建可持续追加的 24h Checkpoint，并固定结构化字段",
+    "- evidence: doc contains case/completed/evidence/next_step/failure_or_blocker/optimization_target",
+    "- next_step: 每轮真实实验后追加一条带 dialog id、marker、测试结果和推荐优化层的记录",
+    "- failure_or_blocker: none",
+    "- optimization_target: none",
+  ].join("\n");
+}
+
+function buildIdeasDocContent(agentKey: string): string {
+  return [
+    "# 24h Ideas Backlog",
+    "",
+    `- agentKey: \`${agentKey}\``,
+    "- 用于沉淀产品、赚钱、自动化、自我改进方向",
+    "",
+    "## Capture Rules",
+    "- 先记 raw ideas，再挑选 promising ideas",
+    "- 每条想法尽量附带 why now / evidence / next experiment",
+    "- 不要把只在当前轮短暂有效的碎片塞满整页",
+    "",
+    "## Idea Entry: memory-continuity-baseline",
+    "- idea: 把 memory 系统优化拆成 hypothesis ladder，用真实 Qwen、audit 和回归测试决定是否投入",
+    "- why_now: checkpoint 已能接力，下一步收益来自更准的失败定位，而不是更多记忆层",
+    "- evidence: H0-H5 均有脚本化实验入口；Checkpoint / Memory / Procedural runbook 可被真实 Qwen 验证",
+    "- next_experiment: 每个新优化先跑 continuity audit，再决定优化 runtime、workbench、summary、memory 或 skill",
+    "- expected_roi: high when it prevents adding low-value memory mechanisms; otherwise observe only",
+  ].join("\n");
+}
+
+function buildAutonomousWorkbenchSpecs(agentKey: string): AutonomousWorkbenchDocSpec[] {
+  const label = shortAgentLabel(agentKey);
+  return [
+    {
+      key: "mission",
+      title: `24h Mission · ${label}`,
+      purpose: "长期身份、当前 mission、约束与策略的主状态页",
+      initialContent: buildMissionDocContent(agentKey),
+    },
+    {
+      key: "checkpoint",
+      title: `24h Checkpoint · ${label}`,
+      purpose: "持续追加阶段进展、失败原因、实验结果与下一步",
+      initialContent: buildCheckpointDocContent(agentKey),
+    },
+    {
+      key: "ideas",
+      title: `24h Ideas · ${label}`,
+      purpose: "沉淀产品、赚钱、自动化、自我改进等长期想法与验证路径",
+      initialContent: buildIdeasDocContent(agentKey),
+    },
+  ];
+}
+
+function detectDurableAssetSignal(toolNames?: string[] | null): boolean {
+  return Array.isArray(toolNames) && toolNames.some((toolName) => DURABLE_ASSET_TOOLS.has(toolName));
+}
+
+function isDirectWorkbenchMaintenanceInput(userInput: string): boolean {
+  if (/(不要|无需|不用|不需要).{0,12}(updateDoc|append|追加|写入|更新|维护|记录|沉淀|保存|补充|文档|doc)/i.test(userInput)) {
+    return false;
+  }
+  return WORKBENCH_WRITE_ACTION_PATTERN.test(userInput) && WORKBENCH_TARGET_PATTERN.test(userInput);
+}
+
+function buildAutonomousRuntimeBlock(args: {
+  docs: AutonomousWorkbenchDoc[];
+  checkpoint?: RuntimeCheckpointLike;
+  hasSpaceWorkbench: boolean;
+  directWorkbenchMaintenance: boolean;
+}): string {
+  if (args.hasSpaceWorkbench && args.directWorkbenchMaintenance && args.docs.length > 0) {
+    const writableDocs = args.docs.filter((doc) =>
+      doc.key === "checkpoint" || doc.key === "ideas"
+    );
+    return [
+      "--- Autonomous runtime: direct workbench maintenance ---",
+      "本轮是固定工作台维护任务。唯一动作：直接调用 updateDoc，不要调用其他工具，不要猜测 dbKey，不要编辑代码。",
+      "可写工作台 dbKey：",
+      ...writableDocs.map((doc) => `- ${doc.key}: ${doc.dbKey}`),
+      "调用时 id 必须逐字使用上面列出的 checkpoint 或 ideas 的 page-... 字符串。",
+      "调用格式：updateDoc({ id: 'page-...', mode: 'append', content })。",
+      "如果本轮是实验、观察、checkpoint、接力、运行连续性任务，写入 checkpoint；如果本轮是产品想法、机会、backlog，写入 ideas。",
+      "checkpoint content 必须使用以下字段，字段名不要改：",
+      "## Checkpoint Entry: <marker 或日期>",
+      "- case: <本轮任务/实验对象>",
+      "- completed: <已经完成了什么>",
+      "- evidence: <dialog id、marker、工具调用、audit 分数、测试结果等证据>",
+      "- next_step: <下一轮可直接执行的一步>",
+      "- failure_or_blocker: <失败原因或 none>",
+      "- optimization_target: <runtime-continuity|workbench-injection|checkpoint-structure|passive-summary|proactive-summary|memory-recall|memory-janitor|none>",
+      "ideas content 必须使用以下字段，字段名不要改：idea、why_now、evidence、next_experiment、expected_roi。",
+      "content 必须包含本轮用户给出的 marker 或 case；没有 marker 时自己生成一个短 marker。",
+    ].join("\n");
+  }
+
+  const lines = [
+    "--- Autonomous runtime ---",
+    "你正在执行长期 autonomous runtime。优先持续产出可复用资产：代码、doc、memory、实验结论、可执行方案。",
+    "可以主动提出产品、赚钱、自动化、自我改进方向，但高价值想法应沉淀到 ideas / checkpoint 之类的 doc，而不是只留在聊天里。",
+    "用户偏好、你的短中期连续性、最近有效经验 → user/private memory。",
+    "共享协作规则、空间共识、团队约定 → space/shared memory。",
+    "需要跨轮次共读和维护的 mission / checkpoint / ideas / runbook / experiment log → doc layer。",
+  ];
+
+  if (args.hasSpaceWorkbench && args.docs.length > 0) {
+    lines.push("固定工作台：");
+    for (const doc of args.docs) {
+      lines.push(`- ${doc.key}: ${doc.title} — dbKey=${doc.dbKey} — ${doc.purpose}`);
+    }
+    lines.push("当本轮目标是维护 mission / checkpoint / ideas，且对应 dbKey 已在固定工作台列出时，直接调用 updateDoc({ id: dbKey, mode: 'append' 或 'replace', content })。");
+    lines.push("不要为了查找这些固定工作台 doc 去搜索代码库或读取环境；只有缺少 dbKey 或任务确实依赖运行环境时才做额外探查。");
+    lines.push("如果这些 doc 仍然空泛，优先把它们推进到可持续接力的状态。");
+  } else {
+    lines.push("当前没有可用的 space 工作台时，先用 memory 保持连续性；后续拿到 space 再创建并接管 mission / checkpoint / ideas doc。");
+  }
+
+  const likelyLooping =
+    !!args.checkpoint &&
+    (args.checkpoint.toolCallCount ?? 0) >= 2 &&
+    !detectDurableAssetSignal(args.checkpoint.lastToolNames);
+  if (likelyLooping) {
+    lines.push("如果你发现自己连续几轮都在重复读取/总结，却没有留下新资产，优先切换到更新 doc、记录实验、形成明确下一步，而不是继续同类审计。");
+  }
+
+  return lines.join("\n");
+}
+
+async function ensureAutonomousWorkbenchDocs(args: {
+  userId: string;
+  spaceId: string;
+  agentKey: string;
+}): Promise<AutonomousWorkbenchDoc[]> {
+  const { userId, spaceId, agentKey } = args;
+  const spaceKey = `space-${spaceId}`;
+  const spaceRecord = (await serverDb.get(spaceKey).catch(() => null)) as Record<string, any> | null;
+  const contents = spaceRecord?.contents ?? {};
+  const specs = buildAutonomousWorkbenchSpecs(agentKey);
+  const docs: AutonomousWorkbenchDoc[] = [];
+
+  for (const spec of specs) {
+    const existingEntry = Object.entries(contents).find(([, value]) => {
+      if (!value || typeof value !== "object") return false;
+      const record = value as Record<string, any>;
+      return record.type === DataType.DOC && record.title === spec.title;
+    });
+
+    if (existingEntry) {
+      const entryKey = existingEntry[0];
+      const record = existingEntry[1] as Record<string, any>;
+      docs.push({
+        key: spec.key,
+        title: spec.title,
+        purpose: spec.purpose,
+        dbKey:
+          typeof record.contentKey === "string" && record.contentKey.trim()
+            ? record.contentKey.trim()
+            : entryKey,
+      });
+      continue;
+    }
+
+    const created = await createPageServer({
+      userId,
+      title: spec.title,
+      content: spec.initialContent,
+      spaceId,
+    });
+    docs.push({
+      key: spec.key,
+      title: spec.title,
+      purpose: spec.purpose,
+      dbKey: created.dbKey,
+    });
+  }
+
+  return docs;
+}
+
+export async function resolveAutonomousRuntimeBlock(args: {
+  runtimeProfile?: DialogRuntimeProfile;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  checkpoint?: RuntimeCheckpointLike;
+  userInput?: string | null;
+}): Promise<string | null> {
+  const context = await resolveAutonomousRuntimeContext(args);
+  return context.block;
+}
+
+export async function resolveAutonomousRuntimeContext(args: {
+  runtimeProfile?: DialogRuntimeProfile;
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  checkpoint?: RuntimeCheckpointLike;
+  userInput?: string | null;
+}): Promise<AutonomousRuntimeContext> {
+  if (args.runtimeProfile !== "autonomous") {
+    return {
+      block: null,
+      turnInstruction: null,
+      requiredTools: [],
+      disabledTools: [],
+      exclusiveTools: [],
+    };
+  }
+
+  const normalizedUserId = args.userId?.trim();
+  const normalizedSpaceId = args.spaceId?.trim();
+  const docs =
+    normalizedUserId && normalizedSpaceId
+      ? await ensureAutonomousWorkbenchDocs({
+          userId: normalizedUserId,
+          spaceId: normalizedSpaceId,
+          agentKey: args.agentKey,
+        })
+      : [];
+
+  const hasWorkbenchDocs = docs.length > 0;
+  const directWorkbenchMaintenance =
+    hasWorkbenchDocs &&
+    typeof args.userInput === "string" &&
+    isDirectWorkbenchMaintenanceInput(args.userInput);
+
+  const block = buildAutonomousRuntimeBlock({
+    docs,
+    checkpoint: args.checkpoint,
+    hasSpaceWorkbench: !!(normalizedUserId && normalizedSpaceId),
+    directWorkbenchMaintenance,
+  });
+
+  return {
+    block,
+    turnInstruction: directWorkbenchMaintenance ? block : null,
+    requiredTools: hasWorkbenchDocs ? ["updateDoc"] : [],
+    disabledTools: directWorkbenchMaintenance ? NON_DOC_EXPLORATION_TOOLS : [],
+    exclusiveTools: directWorkbenchMaintenance ? ["updateDoc"] : [],
+  };
+}

package/server/handlers/agentRun/backgroundRunDialog.ts

@@ -0,0 +1,31 @@
+import {
+  type PreparedRunDialog,
+  type PrepareRunDialogOptions,
+  prepareRunDialog,
+} from "./runDialogPreparation";
+
+export type BackgroundRunDialog =
+  | PreparedRunDialog
+  | {
+      error: string;
+      status: number;
+    };
+
+export function isBackgroundRunDialogError(
+  result: BackgroundRunDialog,
+): result is Extract<BackgroundRunDialog, { error: string }> {
+  return "error" in result;
+}
+
+export async function prepareBackgroundRunDialog(
+  options: PrepareRunDialogOptions,
+): Promise<BackgroundRunDialog> {
+  try {
+    return await prepareRunDialog(options);
+  } catch (error: any) {
+    return {
+      error: error?.message ?? "Failed to create dialog",
+      status: error?.status ?? 500,
+    };
+  }
+}