@fieldwangai/agentflow 0.1.166 → 0.1.167

package/bin/lib/workspace-routes.mjs

@@ -11,8 +11,21 @@
  *    是请求回调的闭包，解构之后路由体里的写法完全不变。
  */
 
-import { listFlowsJson, listNodesJson, readNodeDetailJson, readNodeFilePreview } from "./catalog-flows.mjs";
+import { listNodesJson, readNodeDetailJson, readNodeFilePreview } from "./catalog-flows.mjs";
 import { startComposerAgent } from "./composer-agent.mjs";
+import {
+  aiMaterializationPrompt,
+  aiPlanPrompt,
+  appendAiTraceEvents,
+  createAiExplorationSession,
+  classifyAiToolSideEffect,
+  listAiExplorationSessions,
+  materializableAiTraceEvents,
+  parseAiPlanResult,
+  readAiExplorationSession,
+  updateAiExplorationSession,
+  writeAiExplorationMaterialization,
+} from "./ai-exploration.mjs";
 import { buildSkillCompactInjectionBlock, loadResourcesForSkillKeys } from "./composer-skill-router.mjs";
 import { execFileBuffered } from "./exec-buffered.mjs";
 import { runGit } from "./git-worktree.mjs";
@@ -30,28 +43,36 @@ import {
 } from "./marketplace.mjs";
 import {
   appendMarketplaceUsageEvent,
-  marketplaceStatsFor,
-  marketplaceUsageStats,
   marketplaceResourcesForRun,
-  readMarketplaceFlowOrigin,
   writeMarketplaceFlowOrigin,
 } from "./marketplace-usage.mjs";
+import {
+  indexedProjectFlowPreview,
+  getRepositoryIndex,
+  indexedMarketplaceFlowCopies,
+  listIndexedNodes,
+  listIndexedProjectFlows,
+  markRepositoryIndexDirty,
+  updateIndexedProjectFlowVisibility,
+  updateIndexedNodeVisibility,
+  writeProjectFlowMarketplaceMetadata,
+} from "./repository-index.mjs";
 import { NODE_PACKAGE_ENTRY, nodePackageExportsRun, readNodePackageManifest } from "./node-package-manifest.mjs";
 import { inspectNodePackageDirectory } from "./node-package-archive.mjs";
 import { json, readBody } from "./http-util.mjs";
 import { log } from "./log.mjs";
-import { PACKAGE_ROOT, PIPELINES_DIR, getAgentflowUserDataRoot, getUserPipelinesRoot, listAgentflowUserIds } from "./paths.mjs";
+import { PACKAGE_ROOT, PIPELINES_DIR, getAgentflowUserDataRoot, getUserPipelinesRoot } from "./paths.mjs";
 import { validateUserPipelineId } from "./flow-write.mjs";
 import { runLedgerId } from "./run-ledger.mjs";
 import { getTeamById, getTeamForUser } from "./teams.mjs";
 import { readMergedEnvObject, runtimeEnvForUser } from "./user-env.mjs";
-import { acceptWorkspaceCollaborationInvite, addWorkspaceCollaborationMember, deleteWorkspaceCollaborationForFlow, ensureWorkspaceCollaboration, getWorkspaceCollaborationByFlow, getWorkspaceCollaborationForProject, listWorkspaceCollaborationsForUser, removeWorkspaceCollaborationMember, removeWorkspaceCollaborationTeamShare, setWorkspaceCollaborationTeamShare, workspaceCollaborationAccess } from "./workspace-collaboration.mjs";
+import { acceptWorkspaceCollaborationInvite, addWorkspaceCollaborationMember, deleteWorkspaceCollaborationForFlow, ensureWorkspaceCollaboration, getWorkspaceCollaborationForProject, listWorkspaceCollaborationsForUser, removeWorkspaceCollaborationMember, removeWorkspaceCollaborationTeamShare, setWorkspaceCollaborationTeamShare, workspaceCollaborationAccess } from "./workspace-collaboration.mjs";
 import { WorkspaceFlowParseError } from "./workspace-flow-store.mjs";
 import { mergeWorkspaceGraphs, workspaceDesignRevision, workspaceRuntimeRevision } from "./workspace-graph-merge.mjs";
 import { DEFAULT_WORKSPACE_PREVIEW_TTL_MS, createWorkspacePreviewId, normalizeWorkspacePreviewTtlMs, readWorkspacePreviewMetadata, workspaceSharedPreviewFlowDir, writeWorkspacePreviewMetadata } from "./workspace-preview.mjs";
 import { DEFAULT_WORKSPACE_DRAFT_TTL_MS, createWorkspaceDraftId, normalizeWorkspaceDraftTtlMs, readWorkspaceDraftMetadata, workspaceDraftFlowDir, writeWorkspaceDraftMetadata } from "./workspace-draft.mjs";
 import { appendWorkspaceRunLogEvent, createWorkspaceRunLogSession, finishWorkspaceRunLogSession, listWorkspaceRunLogs, readWorkspaceRunLogEvents } from "./workspace-run-logs.mjs";
-import { activeWorkspaceRuns, appendWorkspaceRunFinished, appendWorkspaceRunStarted, cleanupWorkspaceRunResources, hydrateWorkspaceGraphForRuntime, isReadonlyBuiltinFlowSource, isTransientAgentNetworkError, isValidFlowSourceRead, isWorkspaceRunAbortError, listWorkspaceScheduleStatusesForFlow, mergeWorkspacePersistentNodeRefs, mergeWorkspaceRunGraph, normalizeWorkspaceEntry, normalizeWorkspaceScheduledRunConfig, publishWorkspaceRelease, readWorkspaceConversations, readWorkspaceFiles, readWorkspaceGraph, readWorkspaceReleaseStatus, readWorkspaceRunUsageRecords, readWorkspaceStableRelease, removeWorkspaceDeferredRun, resolveWorkspaceFilePath, resolveWorkspaceScopeRoot, rollbackWorkspaceRelease, runWorkspaceGraph, sleepMs, syncWorkspaceSchedulesForGraph, upsertWorkspaceDeferredRun, workspaceActiveRunsForScope, workspaceCollaborationEventKey, workspaceCollaborationSequences, workspaceCollaborationSubscribers, workspaceCollaborationSummaryWithUsers, workspaceDeferredRunsForScope, workspaceDesignPath, workspaceDownloadContentDisposition, workspaceFindActiveRunConflict, workspaceGraphAsSource, workspaceOptimizeRunImplementations, workspaceRepoUrlWithCredential, workspaceRunControl, workspaceRunEntryKey, workspaceRunKey, workspaceRunPlan, workspaceRunPlanNodeIds, workspaceRunTouchedNodeIds, workspaceRuntimeNodeLabel, workspaceScheduleNextRunAt, workspaceScopedUserContext, workspaceSearchGuardrailsBlock, workspaceUnwrapOutputEnvelopeForDisplay, workspacesPath, writeWorkspaceConversations, writeWorkspaceGraph } from "./workspace-server.mjs";
+import { activeWorkspaceRuns, appendWorkspaceRunFinished, appendWorkspaceRunStarted, cleanupWorkspaceRunResources, hydrateWorkspaceGraphForRuntime, isReadonlyBuiltinFlowSource, isTransientAgentNetworkError, isValidFlowSourceRead, isWorkspaceRunAbortError, listWorkspaceScheduleStatusesForFlow, mergeWorkspacePersistentNodeRefs, mergeWorkspaceRunGraph, normalizeWorkspaceEntry, normalizeWorkspaceScheduledRunConfig, publishWorkspaceRelease, readWorkspaceConversations, readWorkspaceFiles, readWorkspaceGraph, readWorkspaceReleaseStatus, readWorkspaceStableRelease, removeWorkspaceDeferredRun, resolveWorkspaceFilePath, resolveWorkspaceScopeRoot, rollbackWorkspaceRelease, runWorkspaceGraph, sleepMs, syncWorkspaceSchedulesForGraph, upsertWorkspaceDeferredRun, workspaceActiveRunsForScope, workspaceCollaborationEventKey, workspaceCollaborationSequences, workspaceCollaborationSubscribers, workspaceCollaborationSummaryWithUsers, workspaceDeferredRunsForScope, workspaceDesignPath, workspaceDownloadContentDisposition, workspaceFindActiveRunConflict, workspaceGraphAsSource, workspaceOptimizeRunImplementations, workspaceRepoUrlWithCredential, workspaceRunControl, workspaceRunEntryKey, workspaceRunKey, workspaceRunPlan, workspaceRunPlanNodeIds, workspaceRunTouchedNodeIds, workspaceRuntimeNodeLabel, workspaceScheduleNextRunAt, workspaceScopedUserContext, workspaceSearchGuardrailsBlock, workspaceUnwrapOutputEnvelopeForDisplay, workspacesPath, writeWorkspaceConversations, writeWorkspaceGraph } from "./workspace-server.mjs";
 import { splitWorkspaceGraph, WORKSPACE_STATE_FILENAME } from "./workspace-state.mjs";
 import { getWorkspaceTree } from "./workspace-tree.mjs";
 import busboy from "busboy";
@@ -1076,196 +1097,8 @@ function workspaceBufferLooksLikeZip(buf) {
   );
 }
 
-function installedMarketplaceFlowCopies(userId) {
-  const copies = new Map();
-  const pipelinesRoot = getUserPipelinesRoot(userId);
-  if (!fs.existsSync(pipelinesRoot)) return copies;
-  for (const entry of fs.readdirSync(pipelinesRoot, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const origin = readMarketplaceFlowOrigin(path.join(pipelinesRoot, entry.name));
-    if (!origin) continue;
-    const key = `${origin.id}@${origin.version}`;
-    const flowIds = copies.get(key) || [];
-    flowIds.push(entry.name);
-    copies.set(key, flowIds);
-  }
-  return copies;
-}
-
-const PROJECT_FLOW_MARKETPLACE_FILENAME = path.join(".workspace", "agentflow", "marketplace.json");
-
-function projectFlowMarketplaceId(ownerUserId, flowSource, flowId) {
-  return `project-flow:${String(ownerUserId || "").trim()}:${String(flowSource || "user").trim()}:${String(flowId || "").trim()}`;
-}
-
-function projectFlowMarketplaceMetadataPath(flowRoot) {
-  return path.join(path.resolve(flowRoot), PROJECT_FLOW_MARKETPLACE_FILENAME);
-}
-
-function readProjectFlowMarketplaceMetadata(flowRoot) {
-  try {
-    const parsed = JSON.parse(fs.readFileSync(projectFlowMarketplaceMetadataPath(flowRoot), "utf-8"));
-    return {
-      visibility: String(parsed?.visibility || "").trim() === "private" ? "private" : "public",
-      updatedAt: String(parsed?.updatedAt || "").trim(),
-    };
-  } catch {
-    return { visibility: "public", updatedAt: "" };
-  }
-}
-
-function writeProjectFlowMarketplaceMetadata(flowRoot, visibility) {
-  const filePath = projectFlowMarketplaceMetadataPath(flowRoot);
-  const value = {
-    version: 1,
-    visibility: String(visibility || "").trim() === "private" ? "private" : "public",
-    updatedAt: new Date().toISOString(),
-  };
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const tempPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
-  fs.writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
-  fs.renameSync(tempPath, filePath);
-  return value;
-}
-
-function runnableProjectFlowEntries(graph, scopedRoot = "") {
-  const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
-  const entries = Object.entries(instances).filter(([, instance]) => (
-    instance?.definitionId === "workspace_run"
-    || instance?.definitionId === "workspace_scheduled_run"
-  ));
-  return entries.flatMap(([entryId, entry]) => {
-    let plan;
-    try {
-      plan = workspaceRunPlan(graph, entryId, scopedRoot, { ignoreCache: true });
-    } catch {
-      return [];
-    }
-    const executedNodeIds = Array.from(new Set((plan.order || []).map((id) => String(id || "").trim()).filter(Boolean)));
-    if (executedNodeIds.length === 0) return [];
-    const includedNodeIds = new Set([entryId, ...executedNodeIds]);
-    const positions = graph?.ui?.nodePositions && typeof graph.ui.nodePositions === "object"
-      ? Object.fromEntries(Object.entries(graph.ui.nodePositions).filter(([id]) => includedNodeIds.has(id)))
-      : {};
-    const sizes = graph?.ui?.nodeSizes && typeof graph.ui.nodeSizes === "object"
-      ? Object.fromEntries(Object.entries(graph.ui.nodeSizes).filter(([id]) => includedNodeIds.has(id)))
-      : {};
-    return [{
-      entryId,
-      entry,
-      runMode: entry.definitionId === "workspace_scheduled_run" ? "scheduled" : "manual",
-      graph: {
-        ...graph,
-        instances: Object.fromEntries(Object.entries(instances).filter(([id]) => includedNodeIds.has(id))),
-        edges: (Array.isArray(graph?.edges) ? graph.edges : []).filter((edge) => (
-          includedNodeIds.has(String(edge?.source || ""))
-          && includedNodeIds.has(String(edge?.target || ""))
-        )),
-        ui: {
-          ...(graph?.ui || {}),
-          nodePositions: positions,
-          nodeSizes: sizes,
-        },
-      },
-    }];
-  });
-}
-
-function projectFlowUpdatedAt(flowRoot, metadata = {}) {
-  if (metadata.updatedAt) return metadata.updatedAt;
-  try {
-    return fs.statSync(path.resolve(flowRoot)).mtime.toISOString();
-  } catch {
-    return "";
-  }
-}
-
 function listRunnableProjectMarketplaceFlows(workspaceRoot, userCtx = {}, scope = "all") {
-  const requestedUserId = String(userCtx.userId || "").trim();
-  const stats = marketplaceUsageStats(workspaceRoot);
-  const runUsage = readWorkspaceRunUsageRecords();
-  const resources = [];
-  const appendFlow = (ownerId, flow, flowSource = "user", workspaceId = "") => {
-    if (!ownerId || (scope === "owned" && ownerId !== requestedUserId)) return;
-    if (flow.archived || !flow.path) return;
-    let stable;
-    let graph;
-    try {
-      stable = readWorkspaceStableRelease(flow.path, workspaceRoot);
-      graph = stable?.graph || readWorkspaceGraph(flow.path, workspaceRoot).graph;
-    } catch {
-      return;
-    }
-    const runnableEntries = runnableProjectFlowEntries(graph, flow.path);
-    if (runnableEntries.length === 0) return;
-    const metadata = readProjectFlowMarketplaceMetadata(flow.path);
-    const owned = ownerId === requestedUserId;
-    if (scope !== "owned" && metadata.visibility === "private" && !owned && userCtx.isAdmin !== true) return;
-    for (const runnable of runnableEntries) {
-      const baseId = projectFlowMarketplaceId(ownerId, flowSource, flow.id);
-      const id = runnableEntries.length === 1 ? baseId : `${baseId}:${runnable.entryId}`;
-      const version = stable?.release?.id || `current-${workspaceDesignRevision(graph).slice(0, 12)}`;
-      const rawEntryLabel = String(runnable.entry?.label || "").trim();
-      const genericLabel = ["", "Run", "Scheduled Run", "运行", "定时运行"].includes(rawEntryLabel);
-      const directRuns = runUsage.filter((run) => (
-        run.status === "success"
-        && run.flowId === flow.id
-        && (run.flowSource || "user") === flowSource
-        && (flowSource !== "user" || run.userId === ownerId)
-        && (run.runNodeId ? run.runNodeId === runnable.entryId : runnableEntries.length === 1)
-      ));
-      const telemetry = marketplaceStatsFor(stats, "project-flow", id, version);
-      const directLastUsedAt = directRuns.reduce((latest, run) => {
-        const value = new Date(Number(run.endedAt || run.at || 0)).toISOString();
-        return !latest || value > latest ? value : latest;
-      }, "");
-      resources.push({
-        resourceType: "flow",
-        projectFlow: true,
-        id,
-        definitionId: `${flow.id}/${runnable.entryId}`,
-        displayName: runnableEntries.length === 1
-          ? flow.id
-          : `${flow.id} · ${genericLabel ? runnable.entryId : rawEntryLabel}`,
-        description: flow.description || "",
-        version,
-        versionLabel: stable?.release?.id ? `Stable ${stable.release.id}` : "当前版本",
-        runMode: runnable.runMode,
-        runModeLabel: runnable.runMode === "scheduled" ? "定时运行" : "手动运行",
-        ownerUserId: ownerId,
-        liveOwnerUserId: ownerId,
-        liveFlowId: flow.id,
-        liveFlowSource: flowSource,
-        liveWorkspaceId: workspaceId,
-        liveEntryId: runnable.entryId,
-        installFlowId: runnableEntries.length === 1 ? flow.id : `${flow.id}-${runnable.entryId}`,
-        visibility: metadata.visibility,
-        nodeCount: Object.keys(runnable.graph?.instances || {}).length,
-        edgeCount: Array.isArray(runnable.graph?.edges) ? runnable.graph.edges.length : 0,
-        updatedAt: projectFlowUpdatedAt(flow.path, metadata),
-        ...telemetry,
-        useCount: telemetry.useCount + directRuns.length,
-        lastUsedAt: [telemetry.lastUsedAt, directLastUsedAt].filter(Boolean).sort().at(-1) || "",
-        _graph: runnable.graph,
-        _flowRoot: flow.path,
-      });
-    }
-  };
-  for (const ownerUserId of listAgentflowUserIds()) {
-    const ownerId = String(ownerUserId || "").trim();
-    for (const flow of listFlowsJson(workspaceRoot, { userId: ownerId })) {
-      if ((flow.source || "user") !== "user" || flow.archived || !flow.path) continue;
-      appendFlow(ownerId, flow, "user");
-    }
-  }
-  for (const flow of listFlowsJson(workspaceRoot, { userId: "", includeWorkspaceFlows: true })) {
-    if ((flow.source || "") !== "workspace" || flow.archived || !flow.path) continue;
-    const collaboration = getWorkspaceCollaborationByFlow(flow.id, false);
-    const ownerId = String(collaboration?.ownerId || "").trim();
-    if (!ownerId) continue;
-    appendFlow(ownerId, flow, "workspace", collaboration.id);
-  }
-  return resources;
+  return listIndexedProjectFlows(workspaceRoot, userCtx, scope);
 }
 
 function publicProjectFlowMarketplaceResource(resource) {
@@ -1295,6 +1128,20 @@ function sortMarketplaceResources(items) {
   ));
 }
 
+function paginateMarketplaceResources(items, url, defaultLimit = 24) {
+  const requestedLimit = Number(url.searchParams.get("limit") || defaultLimit);
+  const limit = Math.min(100, Math.max(1, Number.isFinite(requestedLimit) ? Math.floor(requestedLimit) : defaultLimit));
+  const requestedCursor = Number(url.searchParams.get("cursor") || 0);
+  const offset = Math.max(0, Number.isFinite(requestedCursor) ? Math.floor(requestedCursor) : 0);
+  const pageItems = items.slice(offset, offset + limit);
+  const nextOffset = offset + pageItems.length;
+  return {
+    items: pageItems,
+    total: items.length,
+    nextCursor: nextOffset < items.length ? String(nextOffset) : "",
+  };
+}
+
 /**
  * @param {import('http').IncomingMessage} req
  * @param {import('http').ServerResponse} res
@@ -1357,6 +1204,7 @@ async function workspaceRoutes(req, res, ctx) {
       }
       try {
         const result = publishNodePackageArchive(root, parsed.file, { ownerUserId: userCtx.userId });
+        if (result.ok) markRepositoryIndexDirty(root);
         json(res, result.ok ? (result.alreadyExists ? 200 : 201) : (result.conflict ? 409 : 400), result);
       } catch (e) {
         json(res, 500, { ok: false, error: (e && e.message) || String(e) });
@@ -1389,6 +1237,7 @@ async function workspaceRoutes(req, res, ctx) {
           actorUserId: userCtx.userId || "",
           eventId: `install:node:${id}@${version}:${userCtx.userId || "anonymous"}`,
         });
+        markRepositoryIndexDirty(root);
         res.writeHead(200, {
           "Content-Type": "application/zip",
           "Content-Length": result.archive.length,
@@ -1412,7 +1261,7 @@ async function workspaceRoutes(req, res, ctx) {
         const marketplaceScope = scope === "owned" ? "owned" : "all";
         const queryText = String(url.searchParams.get("q") || "").trim().toLowerCase();
         if (kind === "node") {
-          const marketplaceNodes = listMarketplacePackages(root, { ...userCtx, marketplaceScope }).nodes
+          const marketplaceNodes = listIndexedNodes(root, userCtx, marketplaceScope)
             .map((node) => ({ ...node, resourceType: "node", installed: true }));
           let nodes = marketplaceNodes;
           if (scope === "installed") {
@@ -1443,14 +1292,23 @@ async function workspaceRoutes(req, res, ctx) {
             });
           }
           nodes = sortMarketplaceResources(nodes.filter((item) => marketplaceResourceMatches(item, queryText)));
-          json(res, 200, { kind, scope, sort: "useCount", order: "desc", items: nodes });
+          const page = paginateMarketplaceResources(nodes, url);
+          const index = getRepositoryIndex(root);
+          json(res, 200, {
+            kind,
+            scope,
+            sort: "useCount",
+            order: "desc",
+            ...page,
+            index: { status: "ready", generatedAt: index.generatedAt },
+          });
           return;
         }
         if (kind !== "flow") {
           json(res, 400, { error: "kind must be flow or node" });
           return;
         }
-        const installedCopies = installedMarketplaceFlowCopies(userCtx.userId);
+        const installedCopies = indexedMarketplaceFlowCopies(root, userCtx.userId);
         const projectFlows = listRunnableProjectMarketplaceFlows(root, userCtx, scope).map((flow) => {
           const installedFlowIds = installedCopies.get(`${flow.id}@${flow.version}`) || [];
           return publicProjectFlowMarketplaceResource({
@@ -1464,7 +1322,16 @@ async function workspaceRoutes(req, res, ctx) {
             .filter((item) => scope !== "installed" || item.installed)
             .filter((item) => marketplaceResourceMatches(item, queryText)),
         );
-        json(res, 200, { kind, scope, sort: "useCount", order: "desc", items });
+        const page = paginateMarketplaceResources(items, url);
+        const index = getRepositoryIndex(root);
+        json(res, 200, {
+          kind,
+          scope,
+          sort: "useCount",
+          order: "desc",
+          ...page,
+          index: { status: "ready", generatedAt: index.generatedAt },
+        });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -1517,7 +1384,7 @@ async function workspaceRoutes(req, res, ctx) {
         return;
       }
       try {
-        const installedCopies = installedMarketplaceFlowCopies(userCtx.userId);
+        const installedCopies = indexedMarketplaceFlowCopies(root, userCtx.userId);
         if (projectFlow) {
           const source = listRunnableProjectMarketplaceFlows(root, userCtx, "all")
             .find((flow) => flow.id === id);
@@ -1529,13 +1396,19 @@ async function workspaceRoutes(req, res, ctx) {
             json(res, 409, { error: "该流程已有新版本，请刷新流程仓库后重试" });
             return;
           }
+          const preview = indexedProjectFlowPreview(root, source);
+          if (!preview || preview.stale) {
+            markRepositoryIndexDirty(root);
+            json(res, preview?.stale ? 409 : 404, { error: preview?.stale ? "该流程已有新版本，请刷新流程仓库后重试" : "Project flow preview is unavailable" });
+            return;
+          }
           json(res, 200, {
             flow: {
               ...publicProjectFlowMarketplaceResource(source),
               owned: source.ownerUserId === userCtx.userId,
               installedFlowIds: installedCopies.get(`${id}@${version}`) || [],
             },
-            graph: source._graph,
+            graph: preview.graph,
           });
           return;
         }
@@ -1580,11 +1453,11 @@ async function workspaceRoutes(req, res, ctx) {
         return;
       }
       try {
-        const installedCopies = installedMarketplaceFlowCopies(userCtx.userId);
+        const installedCopies = indexedMarketplaceFlowCopies(root, userCtx.userId);
         let graph;
         let resource;
         if (previewKind === "node") {
-          const node = listMarketplacePackages(root, { ...userCtx, marketplaceScope: "all" }).nodes
+          const node = listIndexedNodes(root, userCtx, "all")
             .find((item) => item.id === id && item.version === version);
           if (!node) {
             json(res, 404, { error: "Node package not found or is private" });
@@ -1629,7 +1502,13 @@ async function workspaceRoutes(req, res, ctx) {
             json(res, 409, { error: "该流程已有新版本，请刷新流程仓库后重试" });
             return;
           }
-          graph = source._graph;
+          const preview = indexedProjectFlowPreview(root, source);
+          if (!preview || preview.stale) {
+            markRepositoryIndexDirty(root);
+            json(res, preview?.stale ? 409 : 404, { error: preview?.stale ? "该流程已有新版本，请刷新流程仓库后重试" : "Project flow preview is unavailable" });
+            return;
+          }
+          graph = preview.graph;
           resource = {
             ...publicProjectFlowMarketplaceResource(source),
             owned: source.ownerUserId === userCtx.userId,
@@ -1746,6 +1625,7 @@ async function workspaceRoutes(req, res, ctx) {
           visibility: payload?.visibility || "public",
           graph,
         }, userCtx);
+        if (result.ok) markRepositoryIndexDirty(root);
         json(res, result.ok ? (result.alreadyExists ? 200 : 201) : (result.conflict ? 409 : 400), result);
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
@@ -1789,7 +1669,13 @@ async function workspaceRoutes(req, res, ctx) {
             json(res, 409, { error: "该流程已有新版本，请刷新流程仓库后重试" });
             return;
           }
-          sourceGraph = source._graph;
+          const preview = indexedProjectFlowPreview(root, source);
+          if (!preview || preview.stale) {
+            markRepositoryIndexDirty(root);
+            json(res, preview?.stale ? 409 : 404, { error: preview?.stale ? "该流程已有新版本，请刷新流程仓库后重试" : "Project flow preview is unavailable" });
+            return;
+          }
+          sourceGraph = preview.graph;
           originKind = "project-flow";
         } else {
           const source = readMarketplaceFlow(root, id, version, { ...userCtx, marketplaceScope: "all" });
@@ -1811,6 +1697,7 @@ async function workspaceRoutes(req, res, ctx) {
           actorUserId: userCtx.userId || "",
           eventId: `install:${originKind}:${id}@${version}:${userCtx.userId || "anonymous"}`,
         });
+        markRepositoryIndexDirty(root);
         json(res, 201, {
           ok: true,
           id,
@@ -1846,17 +1733,27 @@ async function workspaceRoutes(req, res, ctx) {
             return;
           }
           const metadata = writeProjectFlowMarketplaceMetadata(source._flowRoot, payload?.visibility);
+          updateIndexedProjectFlowVisibility(root, id, metadata.visibility, metadata.updatedAt);
           json(res, 200, { ok: true, kind: "project-flow", id, version: source.version, ...metadata });
           return;
         }
+        const resourceKind = String(payload?.kind || "");
+        const resourceId = String(payload?.id || "");
+        const resourceVersion = String(payload?.version || "");
+        const resourceVisibility = String(payload?.visibility || "public");
         const result = setMarketplaceVisibility(
           root,
-          String(payload?.kind || ""),
-          String(payload?.id || ""),
-          String(payload?.version || ""),
-          String(payload?.visibility || "public"),
+          resourceKind,
+          resourceId,
+          resourceVersion,
+          resourceVisibility,
           userCtx,
         );
+        if (result.ok && resourceKind === "node") {
+          updateIndexedNodeVisibility(root, resourceId, resourceVersion, resourceVisibility);
+        } else if (result.ok) {
+          markRepositoryIndexDirty(root);
+        }
         json(res, result.ok ? 200 : 400, result);
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
@@ -2391,6 +2288,7 @@ async function workspaceRoutes(req, res, ctx) {
         const graph = workspaceGraphWithScheduleMode(draftGraph, payload.scheduleMode || "disabled");
         fs.mkdirSync(targetDir, { recursive: true });
         writeWorkspaceGraph(targetDir, graph, root);
+        markRepositoryIndexDirty(root);
         let collaborationCreated = false;
         if (flowSource === "workspace") {
           ensureWorkspaceCollaboration({ flowId, userId: authUser.userId });
@@ -2674,6 +2572,7 @@ async function workspaceRoutes(req, res, ctx) {
           json(res, result.conflict ? 409 : 400, result);
           return;
         }
+        markRepositoryIndexDirty(root);
         const graph = readWorkspaceGraph(scoped.root, root).graph;
         const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx);
         broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
@@ -2722,6 +2621,7 @@ async function workspaceRoutes(req, res, ctx) {
           json(res, 404, result);
           return;
         }
+        markRepositoryIndexDirty(root);
         const graph = readWorkspaceGraph(scoped.root, root).graph;
         const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx);
         broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
@@ -2849,6 +2749,7 @@ async function workspaceRoutes(req, res, ctx) {
           }
           throw new Error(`Workspace graph save rolled back: ${(scheduleError && scheduleError.message) || String(scheduleError)}`);
         }
+        markRepositoryIndexDirty(root);
         broadcastWorkspaceCollaborationEvent(
           userCtx,
           scoped.flowSource,
@@ -2960,6 +2861,7 @@ async function workspaceRoutes(req, res, ctx) {
         graph.instances[scheduleNodeId] = { ...instance, body: JSON.stringify(config) };
         const committed = commitWorkspaceGraph(root, scoped, graph, userCtx);
         const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, committed.graph, authUser, userCtx);
+        markRepositoryIndexDirty(root);
         const schedule = workspaceSchedules.find((item) => item.scheduleNodeId === scheduleNodeId) || {
           flowId,
           flowSource,
@@ -4032,6 +3934,436 @@ async function workspaceRoutes(req, res, ctx) {
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/workspace/explorations") {
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: url.searchParams.get("flowId") || "",
+          flowSource: url.searchParams.get("flowSource") || "user",
+          adminOwnerId: url.searchParams.get("adminOwnerId") || "",
+          archived: url.searchParams.get("archived") === "1" || url.searchParams.get("flowArchived") === "1",
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        json(res, 200, { ok: true, explorations: listAiExplorationSessions(scoped.root) });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "GET" && url.pathname === "/api/workspace/exploration") {
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: url.searchParams.get("flowId") || "",
+          flowSource: url.searchParams.get("flowSource") || "user",
+          adminOwnerId: url.searchParams.get("adminOwnerId") || "",
+          archived: url.searchParams.get("archived") === "1" || url.searchParams.get("flowArchived") === "1",
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        json(res, 200, { ok: true, exploration: readAiExplorationSession(scoped.root, url.searchParams.get("id") || "") });
+      } catch (e) {
+        json(res, /Invalid exploration|ENOENT/.test(String(e?.message || e)) ? 404 : 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspace/exploration") {
+      let payload;
+      try { payload = JSON.parse(await readBody(req)); } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: payload.flowId || "",
+          flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
+          archived: payload.archived === true || payload.flowArchived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
+          json(res, 403, { error: "Exploration write permission denied" });
+          return;
+        }
+        const exploration = createAiExplorationSession(scoped.root, {
+          title: payload.title,
+          goal: payload.goal,
+          mode: payload.mode || "observed",
+          status: payload.status || "running",
+          source: payload.source || { provider: "external", agent: "custom" },
+        });
+        json(res, 201, {
+          ok: true,
+          exploration,
+          ingest: {
+            method: "POST",
+            path: "/api/workspace/exploration/events",
+            body: {
+              flowId: payload.flowId || "",
+              flowSource: payload.flowSource || "user",
+              id: exploration.id,
+              events: [],
+            },
+          },
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspace/exploration/events") {
+      let payload;
+      try { payload = JSON.parse(await readBody(req)); } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: payload.flowId || "",
+          flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
+          archived: payload.archived === true || payload.flowArchived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
+          json(res, 403, { error: "Exploration write permission denied" });
+          return;
+        }
+        const appended = appendAiTraceEvents(scoped.root, payload.id, payload.events || [], {
+          phase: payload.phase || "observed",
+        });
+        if (payload.status || payload.summary) {
+          appended.session = updateAiExplorationSession(scoped.root, payload.id, {
+            ...(payload.status ? { status: payload.status } : {}),
+            ...(payload.summary ? { summary: payload.summary } : {}),
+          });
+        }
+        json(res, 200, { ok: true, ...appended });
+      } catch (e) {
+        json(res, /Invalid exploration|ENOENT/.test(String(e?.message || e)) ? 404 : 400, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspace/exploration/plan") {
+      let payload;
+      try { payload = JSON.parse(await readBody(req)); } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const goal = String(payload?.goal || "").trim();
+      if (!goal) {
+        json(res, 400, { error: "Missing exploration goal" });
+        return;
+      }
+      let scoped;
+      let exploration;
+      try {
+        scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: payload.flowId || "",
+          flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
+          archived: payload.archived === true || payload.flowArchived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
+          json(res, 403, { error: "Exploration write permission denied" });
+          return;
+        }
+        const graphRead = readWorkspaceGraph(scoped.root);
+        const graph = graphRead?.graph || graphRead;
+        const workspaceSource = workspaceGraphAsSource(graph);
+        exploration = createAiExplorationSession(scoped.root, {
+          title: payload.title || goal.slice(0, 80),
+          goal,
+          mode: "planned",
+          status: "planning",
+          source: { provider: "agentflow", agent: String(payload.model || "default") },
+        });
+        const chunks = [];
+        let result = "";
+        const handle = startComposerAgent({
+          uiWorkspaceRoot: scoped.root,
+          cliWorkspace: scoped.root,
+          prompt: aiPlanPrompt({ goal, workspaceSource }),
+          modelKey: typeof payload.model === "string" ? payload.model.trim() : "",
+          agentflowUserId: userCtx.userId || "",
+          mode: "plan",
+          force: false,
+          sandboxDisabled: false,
+          approveMcps: false,
+          sandboxMode: "read-only",
+          allowDanger: false,
+          includeJsonResult: true,
+          onStreamEvent(ev) {
+            if (ev?.type !== "natural" || typeof ev.text !== "string") return;
+            if (ev.kind === "result") result = ev.text.trim();
+            else if (ev.kind === "assistant" && ev.text.trim()) chunks.push(ev.text.trim());
+          },
+        });
+        await handle.finished;
+        const plan = parseAiPlanResult(result || chunks.at(-1) || chunks.join("\n"), exploration.id);
+        const appended = appendAiTraceEvents(scoped.root, exploration.id, plan.events, { phase: "planned" });
+        const ready = updateAiExplorationSession(scoped.root, exploration.id, {
+          title: plan.title,
+          summary: plan.summary,
+          status: "ready",
+          eventCount: appended.session.eventCount,
+        });
+        json(res, 201, { ok: true, exploration: { ...ready, events: appended.events } });
+      } catch (e) {
+        if (scoped?.root && exploration?.id) {
+          try { updateAiExplorationSession(scoped.root, exploration.id, { status: "failed", summary: String(e?.message || e) }); } catch {}
+        }
+        json(res, 500, { error: (e && e.message) || String(e), ...(exploration?.id ? { explorationId: exploration.id } : {}) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspace/exploration/dry-run") {
+      let payload;
+      try { payload = JSON.parse(await readBody(req)); } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: payload.flowId || "",
+          flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
+          archived: payload.archived === true || payload.flowArchived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
+          json(res, 403, { error: "Exploration dry-run permission denied" });
+          return;
+        }
+        const exploration = readAiExplorationSession(scoped.root, payload.id);
+        const planned = exploration.events.filter((event) => event.phase === "planned");
+        if (!planned.length) {
+          json(res, 400, { error: "Exploration has no planned spans" });
+          return;
+        }
+        const runToken = Date.now().toString(36);
+        const simulated = planned.map((event, index) => {
+          const blocked = event.requiresApproval === true || ["write", "external"].includes(event.sideEffect);
+          return {
+            id: `dry_${runToken}_${index + 1}`,
+            spanId: `dry_${runToken}_${event.spanId}`,
+            parentSpanId: event.parentSpanId ? `dry_${runToken}_${event.parentSpanId}` : "",
+            phase: "simulated",
+            type: event.type,
+            name: event.name,
+            summary: blocked
+              ? `策略预检已阻断：${event.summary || event.name}。真实执行前需要明确授权。`
+              : `策略预检通过：${event.summary || event.name}。本次未执行真实工具。`,
+            sideEffect: event.sideEffect,
+            requiresApproval: blocked,
+            status: blocked ? "blocked" : "success",
+            inputPreview: event.inputPreview || "",
+            outputPreview: blocked ? "副作用未执行" : "约束检查通过，未执行真实工具",
+          };
+        });
+        const appended = appendAiTraceEvents(scoped.root, exploration.id, simulated, { phase: "simulated" });
+        const blockedCount = appended.events.filter((event) => event.status === "blocked").length;
+        const updated = updateAiExplorationSession(scoped.root, exploration.id, {
+          mode: "simulated",
+          status: "ready",
+          summary: `Dry-run 策略预检完成：${appended.events.length - blockedCount} 项通过，${blockedCount} 项等待授权。`,
+          eventCount: appended.session.eventCount,
+        });
+        json(res, 200, {
+          ok: true,
+          exploration: { ...updated, events: [...exploration.events, ...appended.events] },
+          dryRun: { kind: "policy-check", executedTools: false, blockedCount },
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspace/exploration/materialize") {
+      let payload;
+      try { payload = JSON.parse(await readBody(req)); } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      let scoped;
+      let exploration;
+      let materializeRunId = "";
+      try {
+        scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: payload.flowId || "",
+          flowSource: payload.flowSource || "user",
+          adminOwnerId: payload.adminOwnerId || "",
+          archived: payload.archived === true || payload.flowArchived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, 400, { error: scoped.error });
+          return;
+        }
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource) || scoped.collaborationAccess?.writable === false) {
+          json(res, 403, { error: "Exploration materialization permission denied" });
+          return;
+        }
+        exploration = readAiExplorationSession(scoped.root, payload.id);
+        if (!exploration.events.length) {
+          json(res, 400, { error: "Exploration has no trace events" });
+          return;
+        }
+        const materializableEvents = materializableAiTraceEvents(exploration);
+        if (!materializableEvents.length) {
+          json(res, 400, { error: "Exploration has no planned or observed spans to materialize" });
+          return;
+        }
+        const dangerousEvents = materializableEvents.filter((event) => event.requiresApproval || ["write", "external"].includes(event.sideEffect));
+        if (dangerousEvents.length && payload.approveSideEffects !== true) {
+          json(res, 409, {
+            error: "Side-effect review is required before materialization",
+            sideEffects: dangerousEvents.map((event) => ({ spanId: event.spanId, name: event.name, sideEffect: event.sideEffect })),
+          });
+          return;
+        }
+        const beforeGraphRead = readWorkspaceGraph(scoped.root);
+        const beforeGraph = beforeGraphRead?.graph || beforeGraphRead;
+        const beforeIds = new Set([
+          ...(beforeGraph.nodes || []).map((node) => String(node.id || "")),
+          ...Object.keys(beforeGraph.instances || {}),
+        ].filter(Boolean));
+        materializeRunId = `materialize_${Date.now().toString(36)}`;
+        appendAiTraceEvents(scoped.root, exploration.id, [{
+          id: `${materializeRunId}_start`,
+          spanId: materializeRunId,
+          type: "agent",
+          name: "固化 Agent",
+          summary: "开始把已审核 Trace 转换为 Workspace DSL 调整态",
+          status: "running",
+          phase: "observed",
+          sideEffect: "write",
+        }], { phase: "observed" });
+        updateAiExplorationSession(scoped.root, exploration.id, { mode: "observed", status: "running" });
+        let reply = "";
+        let toolIndex = 0;
+        const handle = startComposerAgent({
+          uiWorkspaceRoot: scoped.root,
+          cliWorkspace: scoped.root,
+          prompt: aiMaterializationPrompt(exploration, workspaceGraphAsSource(beforeGraph)),
+          modelKey: typeof payload.model === "string" ? payload.model.trim() : "",
+          agentflowUserId: userCtx.userId || "",
+          force: true,
+          sandboxDisabled: false,
+          approveMcps: false,
+          sandboxMode: "workspace-write",
+          allowDanger: false,
+          onToolCall(subtype, toolName) {
+            toolIndex += 1;
+            try {
+              const toolStatus = /(?:complete|success|done)/i.test(String(subtype || ""))
+                ? "success"
+                : /(?:error|fail)/i.test(String(subtype || "")) ? "error" : "running";
+              const sideEffect = classifyAiToolSideEffect(toolName, subtype);
+              appendAiTraceEvents(scoped.root, exploration.id, [{
+                id: `${materializeRunId}_tool_${toolIndex}`,
+                spanId: `${materializeRunId}_tool_${toolIndex}`,
+                parentSpanId: materializeRunId,
+                type: String(subtype || "").toLowerCase() === "thinking" ? "decision" : "tool",
+                name: String(toolName || subtype || "Agent tool"),
+                summary: subtype ? `Agent 工具事件：${subtype}` : "Agent 工具调用",
+                status: toolStatus,
+                phase: "observed",
+                sideEffect,
+              }], { phase: "observed" });
+            } catch {
+              // Trace persistence must not interrupt an in-flight materialization.
+            }
+          },
+          onStreamEvent(ev) {
+            if (ev?.type === "natural" && ["assistant", "result"].includes(ev.kind) && typeof ev.text === "string" && ev.text.trim()) {
+              reply = ev.text.trim();
+            }
+          },
+        });
+        await handle.finished;
+        appendAiTraceEvents(scoped.root, exploration.id, [{
+          id: `${materializeRunId}_finish`,
+          spanId: materializeRunId,
+          type: "agent",
+          name: "固化 Agent",
+          summary: reply || "Workspace DSL 调整态生成完成",
+          status: "success",
+          phase: "observed",
+          sideEffect: "write",
+          endedAt: new Date().toISOString(),
+        }], { phase: "observed" });
+        const graphRead = readWorkspaceGraph(scoped.root);
+        const graph = graphRead?.graph || graphRead;
+        const graphIds = [
+          ...(graph.nodes || []).map((node) => String(node.id || "")),
+          ...Object.keys(graph.instances || {}),
+        ].filter(Boolean);
+        const nodeIds = [...new Set(graphIds)].filter((id) => !beforeIds.has(id));
+        const materialization = writeAiExplorationMaterialization(scoped.root, exploration.id, {
+          nodeIds,
+          designRevision: workspaceDesignRevision(graph),
+        });
+        appendAiTraceEvents(scoped.root, exploration.id, [{
+          type: "status",
+          name: "固化为 Workspace DSL",
+          summary: reply || `新增 ${nodeIds.length} 个节点`,
+          status: "success",
+          phase: "materialized",
+          sideEffect: "write",
+          artifacts: [{ kind: "dsl", path: "workspace.flow.js", label: "Workspace DSL" }],
+        }], { phase: "materialized" });
+        const updated = updateAiExplorationSession(scoped.root, exploration.id, {
+          mode: "materialized",
+          status: "completed",
+          materializedAt: materialization.materializedAt,
+        });
+        json(res, 200, { ok: true, exploration: updated, materialization, graph, reply });
+      } catch (e) {
+        if (scoped?.root && exploration?.id) {
+          try {
+            if (materializeRunId) {
+              appendAiTraceEvents(scoped.root, exploration.id, [{
+                id: `${materializeRunId}_error`,
+                spanId: materializeRunId,
+                type: "agent",
+                name: "固化 Agent",
+                summary: String(e?.message || e),
+                status: "error",
+                phase: "observed",
+                sideEffect: "write",
+                endedAt: new Date().toISOString(),
+              }], { phase: "observed" });
+            }
+            updateAiExplorationSession(scoped.root, exploration.id, { mode: "observed", status: "failed" });
+          } catch {}
+        }
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (url.pathname === "/api/workspace/conversations") {
       let payload = {};
       if (req.method === "POST") {
@@ -4478,6 +4810,7 @@ async function workspaceRoutes(req, res, ctx) {
           json(res, result.conflict ? 409 : 400, { error: result.error || "发布失败" });
           return;
         }
+        markRepositoryIndexDirty(root);
         json(res, 200, { ok: true, ...result });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });