@fieldwangai/agentflow 0.1.68 → 0.1.70

package/bin/lib/ui-server.mjs

@@ -43,9 +43,12 @@ import {
 import { t } from "./i18n.mjs";
 import {
   PACKAGE_ROOT,
+  ARCHIVED_PIPELINES_DIR_NAME,
   getAgentflowDataRoot,
   getAgentflowUserConfigAbs,
   getAgentflowUserDataRoot,
+  getUserPipelinesRoot,
+  listAgentflowUserIds,
   getModelListsAbs,
   getRunDir,
 } from "./paths.mjs";
@@ -87,7 +90,7 @@ import {
   publishFlowSnippet,
   publishNodeFromInstance,
 } from "./marketplace.mjs";
-import { buildGitContext, inferGitRepoRootFromWorktree, loadGitWorktree, normalizeGitContext, runGit, unloadGitWorktree } from "./git-worktree.mjs";
+import { buildGitContext, inferGitRepoRootFromWorktree, loadGitWorktree, normalizeGitContext, runGit, sanitizeWorktreeName, unloadGitWorktree } from "./git-worktree.mjs";
 import { createGitLabMergeRequest } from "./gitlab-mr.mjs";
 import {
   authSetupRequired,
@@ -106,6 +109,12 @@ import {
   readAdminBuiltinPipelineConfig,
   updateAdminBuiltinPipelineConfig,
 } from "./admin-builtin-pipelines.mjs";
+import { readAdminStorageConfig, writeAdminStorageConfig } from "./admin-storage-config.mjs";
+import {
+  appendRunLedgerEvent,
+  readRunLedgerEvents,
+  runLedgerId,
+} from "./run-ledger.mjs";
 
 const MIME = {
   ".html": "text/html; charset=utf-8",
@@ -1367,31 +1376,40 @@ function shouldSkipWorkspaceFileRelPath(relPath) {
   ));
 }
 
+const WORKSPACE_FILES_MAX_ITEMS = 500;
+
 function readWorkspaceFilesRecursive(dir, root, depth = 0, maxDepth = 3, budget = { count: 0 }) {
-  if (depth > maxDepth || budget.count > 500) return [];
+  if (depth > maxDepth) return [];
+  if (depth > 0 && budget.count > WORKSPACE_FILES_MAX_ITEMS) return [];
   let entries;
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
+  entries.sort((a, b) => {
+    if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
   const out = [];
   for (const entry of entries) {
-    if (budget.count > 500) break;
+    if (depth > 0 && budget.count > WORKSPACE_FILES_MAX_ITEMS) break;
     if (entry.name.startsWith(".") && entry.name !== ".agents" && entry.name !== ".codex") continue;
     const abs = path.join(dir, entry.name);
     const rel = path.relative(root, abs).replace(/\\/g, "/");
     if (shouldSkipWorkspaceFileRelPath(rel)) continue;
     if (entry.isDirectory()) {
       if (WORKSPACE_FILE_SKIP_DIRS.has(entry.name)) continue;
-      budget.count++;
       out.push({
         type: "directory",
         name: entry.name,
         path: rel,
         icon: workspaceFileIcon(entry.name, true),
-        children: readWorkspaceFilesRecursive(abs, root, depth + 1, maxDepth, budget),
+        children: budget.count > WORKSPACE_FILES_MAX_ITEMS
+          ? []
+          : readWorkspaceFilesRecursive(abs, root, depth + 1, maxDepth, budget),
       });
+      budget.count++;
     } else if (entry.isFile()) {
       if (WORKSPACE_FILE_SKIP_FILES.has(entry.name)) continue;
       const ext = path.extname(entry.name).toLowerCase();
@@ -1402,10 +1420,6 @@ function readWorkspaceFilesRecursive(dir, root, depth = 0, maxDepth = 3, budget
       out.push({ type: "file", name: entry.name, path: rel, icon: workspaceFileIcon(entry.name), size });
     }
   }
-  out.sort((a, b) => {
-    if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
-    return a.name.localeCompare(b.name);
-  });
   return out;
 }
 
@@ -1464,6 +1478,431 @@ function writeDisplayShares(shares) {
   fs.writeFileSync(file, JSON.stringify(shares && typeof shares === "object" ? shares : {}, null, 2) + "\n", "utf-8");
 }
 
+function countFlowYamlDirs(root) {
+  try {
+    if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return 0;
+    return fs.readdirSync(root, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .filter((entry) => entry.name !== ARCHIVED_PIPELINES_DIR_NAME)
+      .filter((entry) => fs.existsSync(path.join(root, entry.name, FLOW_YAML_FILENAME)))
+      .length;
+  } catch {
+    return 0;
+  }
+}
+
+function pipelineCountsForUser(userId) {
+  const pipelinesRoot = getUserPipelinesRoot(userId);
+  const active = countFlowYamlDirs(pipelinesRoot);
+  const archived = countFlowYamlDirs(path.join(pipelinesRoot, ARCHIVED_PIPELINES_DIR_NAME));
+  return {
+    active,
+    archived,
+    total: active + archived,
+  };
+}
+
+const USAGE_DAY_MS = 24 * 60 * 60 * 1000;
+const RUN_LEDGER_STALE_MS = 6 * 60 * 60 * 1000;
+
+function startOfLocalDayMs(timeMs) {
+  const d = new Date(Number(timeMs) || Date.now());
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+
+function localDayKey(timeMs) {
+  const d = new Date(Number(timeMs) || Date.now());
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+function runStatusBucket(status) {
+  const s = String(status || "unknown");
+  if (s === "success" || s === "failed" || s === "running" || s === "stopped" || s === "interrupted") return s;
+  return "unknown";
+}
+
+function buildUsageDailyTrend(runs, days = 14, nowMs = Date.now()) {
+  const startMs = startOfLocalDayMs(nowMs) - (Math.max(1, days) - 1) * USAGE_DAY_MS;
+  const rows = [];
+  const byDate = new Map();
+  for (let i = 0; i < days; i += 1) {
+    const dateMs = startMs + i * USAGE_DAY_MS;
+    const date = localDayKey(dateMs);
+    const row = {
+      date,
+      runs: 0,
+      success: 0,
+      failed: 0,
+      running: 0,
+      stopped: 0,
+      interrupted: 0,
+      unknown: 0,
+      users: 0,
+      pipelines: 0,
+      totalDurationMs: 0,
+      avgDurationMs: 0,
+      _userIds: new Set(),
+      _pipelineKeys: new Set(),
+    };
+    rows.push(row);
+    byDate.set(date, row);
+  }
+  for (const run of runs) {
+    const at = Number(run?.at || 0);
+    if (!Number.isFinite(at) || at < startMs) continue;
+    const row = byDate.get(localDayKey(at));
+    if (!row) continue;
+    const bucket = runStatusBucket(run.status);
+    row.runs += 1;
+    row[bucket] += 1;
+    row.totalDurationMs += Math.max(0, Number(run.durationMs || 0));
+    row._userIds.add(String(run.userId || ""));
+    {
+      const flowSource = String(run.flowSource || "user");
+      const flowId = String(run.flowId || "");
+      const userId = String(run.userId || "");
+      row._pipelineKeys.add(flowSource === "workspace" ? `workspace:${flowId}` : `${userId}:${flowSource}:${flowId}`);
+    }
+  }
+  return rows.map((row) => {
+    row.users = row._userIds.size;
+    row.pipelines = row._pipelineKeys.size;
+    row.avgDurationMs = row.runs > 0 ? Math.round(row.totalDurationMs / row.runs) : 0;
+    delete row._userIds;
+    delete row._pipelineKeys;
+    return row;
+  });
+}
+
+function buildUsageRates(users, runs, nowMs = Date.now(), workspacePipelineCount = 0) {
+  const windowDays = 7;
+  const sinceMs = startOfLocalDayMs(nowMs) - (windowDays - 1) * USAGE_DAY_MS;
+  const recentRuns = runs.filter((run) => Number(run?.at || 0) >= sinceMs);
+  const activeUsers = new Set();
+  const activePipelines = new Set();
+  const statusCounts = {};
+  let recentDurationMs = 0;
+  for (const run of recentRuns) {
+    const userId = String(run.userId || "");
+    if (userId) activeUsers.add(userId);
+    const flowSource = String(run.flowSource || "user");
+    const flowId = String(run.flowId || "");
+    activePipelines.add(flowSource === "workspace" ? `workspace:${flowId}` : `${userId}:${flowSource}:${flowId}`);
+    const bucket = runStatusBucket(run.status);
+    statusCounts[bucket] = (statusCounts[bucket] || 0) + 1;
+    recentDurationMs += Math.max(0, Number(run.durationMs || 0));
+  }
+  const totalUsers = users.length;
+  const totalActivePipelines = users.reduce((sum, user) => sum + Math.max(0, Number(user?.pipelines?.active || 0)), 0)
+    + Math.max(0, Number(workspacePipelineCount || 0));
+  const completedRuns = recentRuns.length - (statusCounts.running || 0);
+  const badRuns = (statusCounts.failed || 0) + (statusCounts.stopped || 0) + (statusCounts.interrupted || 0) + (statusCounts.unknown || 0);
+  return {
+    windowDays,
+    activeUsers: activeUsers.size,
+    activeUserRate: totalUsers > 0 ? activeUsers.size / totalUsers : 0,
+    activePipelines: activePipelines.size,
+    activePipelineRate: totalActivePipelines > 0 ? activePipelines.size / totalActivePipelines : 0,
+    runs: recentRuns.length,
+    avgRunsPerDay: recentRuns.length / windowDays,
+    successRuns: statusCounts.success || 0,
+    badRuns,
+    runningRuns: statusCounts.running || 0,
+    successRate: completedRuns > 0 ? (statusCounts.success || 0) / completedRuns : 0,
+    failureRate: completedRuns > 0 ? badRuns / completedRuns : 0,
+    avgDurationMs: recentRuns.length > 0 ? Math.round(recentDurationMs / recentRuns.length) : 0,
+  };
+}
+
+function appendWorkspaceRunStarted(record) {
+  appendRunLedgerEvent({
+    ...record,
+    type: "run_started",
+    kind: "workspace",
+    at: Number(record.startedAt || record.at || Date.now()),
+  });
+}
+
+function appendWorkspaceRunFinished(record, status) {
+  appendRunLedgerEvent({
+    ...record,
+    type: "run_finished",
+    kind: "workspace",
+    at: Number(record.startedAt || record.at || Date.now()),
+    endedAt: Number(record.endedAt || Date.now()),
+    durationMs: Math.max(0, Number(record.durationMs || (Number(record.endedAt || Date.now()) - Number(record.startedAt || record.at || Date.now())))),
+    status,
+  });
+}
+
+function normalizeWorkspaceUsageRecord(parsed, source = "workspace-run") {
+  const userId = String(parsed?.userId || "").trim();
+  const flowId = String(parsed?.flowId || "").trim();
+  const at = Number(parsed?.at || parsed?.startedAt || 0);
+  if (!userId || !flowId || !Number.isFinite(at) || at <= 0) return null;
+  return {
+    userId,
+    username: String(parsed?.username || userId),
+    flowId,
+    flowSource: String(parsed?.flowSource || "user"),
+    runId: String(parsed?.runId || ""),
+    at,
+    endedAt: parsed?.endedAt == null ? null : Number(parsed.endedAt),
+    durationMs: Math.max(0, Number(parsed?.durationMs || 0)),
+    status: runStatusBucket(parsed?.status),
+    source,
+  };
+}
+
+function readLegacyWorkspaceRunUsageRecords() {
+  const filePath = path.join(getAgentflowDataRoot(), "admin", "workspace-run-usage.jsonl");
+  if (!fs.existsSync(filePath)) return [];
+  let items = [];
+  try {
+    items = fs.readFileSync(filePath, "utf-8")
+      .split(/\r?\n/)
+      .filter((line) => line.trim())
+      .map((line) => {
+        try { return JSON.parse(line); } catch { return null; }
+      })
+      .filter(Boolean);
+  } catch {
+    items = [];
+  }
+  return items
+    .map((item) => normalizeWorkspaceUsageRecord(item, "workspace-run-legacy"))
+    .filter(Boolean);
+}
+
+function readWorkspaceRunLedgerRecords(options = {}) {
+  const byRunId = new Map();
+  for (const event of readRunLedgerEvents(options)) {
+    if (String(event?.kind || "") !== "workspace") continue;
+    const runId = String(event?.runId || "").trim();
+    if (!runId) continue;
+    const existing = byRunId.get(runId) || {};
+    if (event.type === "run_started") {
+      byRunId.set(runId, {
+        ...existing,
+        ...event,
+        runId,
+        at: Number(event.at || existing.at || Date.now()),
+        status: existing.status || "running",
+      });
+    } else if (event.type === "run_finished") {
+      byRunId.set(runId, {
+        ...existing,
+        ...event,
+        runId,
+        at: Number(existing.at || event.at || Date.now()),
+        endedAt: event.endedAt == null ? null : Number(event.endedAt),
+        durationMs: Math.max(0, Number(event.durationMs || 0)),
+        status: runStatusBucket(event.status),
+      });
+    }
+  }
+  const now = Date.now();
+  return Array.from(byRunId.values())
+    .map((item) => {
+      const at = Number(item?.at || 0);
+      const status = runStatusBucket(item?.status);
+      if (status === "running" && at > 0 && now - at > RUN_LEDGER_STALE_MS) {
+        return {
+          ...item,
+          endedAt: Number(item?.endedAt || at + RUN_LEDGER_STALE_MS),
+          durationMs: Math.max(0, Number(item?.durationMs || Math.min(now - at, RUN_LEDGER_STALE_MS))),
+          status: "interrupted",
+        };
+      }
+      return item;
+    })
+    .map((item) => normalizeWorkspaceUsageRecord(item, "workspace-run-ledger"))
+    .filter(Boolean);
+}
+
+function readWorkspaceRunUsageRecords(options = {}) {
+  const sinceMs = Number(options?.sinceMs || 0);
+  return [
+    ...readLegacyWorkspaceRunUsageRecords(),
+    ...readWorkspaceRunLedgerRecords(options),
+  ].filter((run) => !Number.isFinite(sinceMs) || sinceMs <= 0 || Number(run?.at || 0) >= sinceMs);
+}
+
+function activeWorkspaceRunUsageRecords() {
+  const out = [];
+  for (const entry of activeWorkspaceRuns.values()) {
+    const userId = String(entry?.userId || "").trim();
+    const flowId = String(entry?.flowId || "").trim();
+    const at = Number(entry?.startedAt || 0);
+    if (!userId || !flowId || !Number.isFinite(at) || at <= 0) continue;
+    out.push({
+      userId,
+      username: String(entry?.username || userId),
+      flowId,
+      flowSource: String(entry?.flowSource || "user"),
+      runId: String(entry?.runId || ""),
+      at,
+      endedAt: null,
+      durationMs: Math.max(0, Date.now() - at),
+      status: "running",
+      source: "workspace-run-active",
+    });
+  }
+  return out;
+}
+
+function dedupeWorkspaceUsageRuns(runs = []) {
+  const byKey = new Map();
+  for (const run of runs) {
+    const runId = String(run?.runId || "").trim();
+    const key = runId || `${run?.userId || ""}:${run?.flowSource || ""}:${run?.flowId || ""}:${run?.at || ""}:${run?.status || ""}`;
+    if (!key) continue;
+    const existing = byKey.get(key);
+    if (!existing) {
+      byKey.set(key, run);
+      continue;
+    }
+    const runScore = (item) => {
+      if (item?.source === "workspace-run-active") return 3;
+      if (item?.status && item.status !== "running") return 2;
+      return 1;
+    };
+    if (runScore(run) >= runScore(existing)) byKey.set(key, run);
+  }
+  return Array.from(byKey.values());
+}
+
+function buildAdminUsageDashboard(workspaceRoot) {
+  const authUsers = readAuthUsers();
+  const usageSinceMs = startOfLocalDayMs(Date.now()) - 13 * USAGE_DAY_MS;
+  const workspacePipelineCount = listFlowsJson(workspaceRoot, { includeWorkspaceFlows: true })
+    .filter((flow) => flow?.source === "workspace" && !flow?.archived)
+    .length;
+  const workspaceUsageRuns = dedupeWorkspaceUsageRuns([
+    ...readWorkspaceRunUsageRecords({ sinceMs: usageSinceMs }),
+    ...activeWorkspaceRunUsageRecords(),
+  ]);
+  const userIds = Array.from(new Set([
+    ...Object.keys(authUsers || {}),
+    ...listAgentflowUserIds(),
+    ...workspaceUsageRuns.map((run) => run.userId),
+  ].map((id) => String(id || "").trim()).filter(Boolean))).sort((a, b) => a.localeCompare(b));
+  const allRuns = [];
+  const workspaceUsageByUser = new Map();
+  for (const run of workspaceUsageRuns) {
+    const userId = String(run.userId || "");
+    if (!workspaceUsageByUser.has(userId)) workspaceUsageByUser.set(userId, []);
+    workspaceUsageByUser.get(userId).push(run);
+  }
+  const users = userIds.map((userId) => {
+    const user = authUsers[userId] || {};
+    const pipelineCounts = pipelineCountsForUser(userId);
+    const pipelineRuns = listRecentRunsFromDisk(workspaceRoot, {
+      userId,
+      includeWorkspaceRuns: false,
+      includeLegacyUserRuns: false,
+    });
+    const runs = [...pipelineRuns, ...(workspaceUsageByUser.get(userId) || [])]
+      .sort((a, b) => Number(b.at || 0) - Number(a.at || 0));
+    const statusCounts = {};
+    let totalDurationMs = 0;
+    for (const run of runs) {
+      allRuns.push({ ...run, userId, username: user.username || userId });
+      const status = String(run.status || "unknown");
+      statusCounts[status] = (statusCounts[status] || 0) + 1;
+      totalDurationMs += Math.max(0, Number(run.durationMs || 0));
+    }
+    const lastRun = runs[0] || null;
+    return {
+      userId,
+      username: user.username || userId,
+      isAdmin: Boolean(user.isAdmin),
+      pipelines: pipelineCounts,
+      runs: {
+        total: runs.length,
+        running: statusCounts.running || 0,
+        success: statusCounts.success || 0,
+        failed: statusCounts.failed || 0,
+        stopped: statusCounts.stopped || 0,
+        interrupted: statusCounts.interrupted || 0,
+        unknown: statusCounts.unknown || 0,
+        totalDurationMs,
+        avgDurationMs: runs.length > 0 ? Math.round(totalDurationMs / runs.length) : 0,
+        lastRunAt: lastRun?.at || null,
+        lastRunFlowId: lastRun?.flowId || "",
+        lastRunStatus: lastRun?.status || "",
+        recent: runs.slice(0, 5).map((run) => ({
+          flowId: run.flowId,
+          flowSource: run.flowSource,
+          runId: run.runId,
+          at: run.at,
+          endedAt: run.endedAt,
+          durationMs: run.durationMs,
+          status: run.status,
+        })),
+      },
+    };
+  });
+  const totals = users.reduce((acc, user) => {
+    acc.users += 1;
+    acc.admins += user.isAdmin ? 1 : 0;
+    acc.pipelines += user.pipelines.total;
+    acc.activePipelines += user.pipelines.active;
+    acc.archivedPipelines += user.pipelines.archived;
+    acc.runs += user.runs.total;
+    acc.runningRuns += user.runs.running;
+    acc.successRuns += user.runs.success;
+    acc.failedRuns += user.runs.failed;
+    acc.stoppedRuns += user.runs.stopped;
+    acc.interruptedRuns += user.runs.interrupted;
+    acc.unknownRuns += user.runs.unknown;
+    acc.totalDurationMs += user.runs.totalDurationMs;
+    return acc;
+  }, {
+    users: 0,
+    admins: 0,
+    pipelines: 0,
+    activePipelines: 0,
+    archivedPipelines: 0,
+    runs: 0,
+    runningRuns: 0,
+    successRuns: 0,
+    failedRuns: 0,
+    stoppedRuns: 0,
+    interruptedRuns: 0,
+    unknownRuns: 0,
+    totalDurationMs: 0,
+  });
+  totals.avgDurationMs = totals.runs > 0 ? Math.round(totals.totalDurationMs / totals.runs) : 0;
+  const recentRuns = allRuns
+    .slice()
+    .sort((a, b) => Number(b.at || 0) - Number(a.at || 0))
+    .slice(0, 50)
+    .map((run) => ({
+      userId: String(run.userId || ""),
+      username: String(run.username || run.userId || ""),
+      flowId: String(run.flowId || ""),
+      flowSource: String(run.flowSource || "user"),
+      runId: String(run.runId || ""),
+      at: Number(run.at || 0),
+      endedAt: run.endedAt == null ? null : Number(run.endedAt),
+      durationMs: Math.max(0, Number(run.durationMs || 0)),
+      status: runStatusBucket(run.status),
+      runType: String(run.source || "").startsWith("workspace-run") ? "workspace" : "pipeline",
+    }));
+  return {
+    generatedAt: new Date().toISOString(),
+    totals,
+    usage: buildUsageRates(users, allRuns, Date.now(), workspacePipelineCount),
+    dailyTrend: buildUsageDailyTrend(allRuns, 14),
+    recentRuns,
+    users,
+  };
+}
+
 function createDisplayShareId() {
   return crypto.randomBytes(12).toString("base64url");
 }
@@ -1629,6 +2068,44 @@ function mergeWorkspaceRunGraph(currentGraph, runGraph, touchedIds) {
   };
 }
 
+function mergeWorkspacePersistentNodeRefs(incomingGraph, currentGraph) {
+  const incoming = normalizeWorkspaceGraphPayload(incomingGraph || {});
+  const current = normalizeWorkspaceGraphPayload(currentGraph || {});
+  const instances = { ...(incoming.instances || {}) };
+  for (const [id, currentInstance] of Object.entries(current.instances || {})) {
+    const nextInstance = instances[id];
+    if (!nextInstance || typeof nextInstance !== "object") continue;
+    for (const key of ["scriptRef", "implementationRef", "implementationMode"]) {
+      const currentValue = currentInstance?.[key];
+      const nextValue = nextInstance?.[key];
+      if (currentValue != null && String(currentValue).trim() && (nextValue == null || !String(nextValue).trim())) {
+        nextInstance[key] = currentValue;
+      }
+    }
+  }
+  return { ...incoming, instances };
+}
+
+function hydrateWorkspaceNodeRefsFromFiles(scopedRoot, graph) {
+  const next = normalizeWorkspaceGraphPayload(graph || {});
+  const instances = { ...(next.instances || {}) };
+  let changed = false;
+  for (const [nodeId, instance] of Object.entries(instances)) {
+    if (!instance || typeof instance !== "object") continue;
+    const defId = String(instance.definitionId || "");
+    if (defId === "workspace_run" || defId === "workspace_scheduled_run") continue;
+    if (!String(instance.implementationRef || "").trim()) {
+      const implementationRef = workspaceDefaultImplementationRef(nodeId);
+      const abs = workspaceResolveFlowFile(scopedRoot, implementationRef, "implementationRef");
+      if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
+        instances[nodeId] = { ...instance, implementationRef };
+        changed = true;
+      }
+    }
+  }
+  return changed ? { ...next, instances } : next;
+}
+
 function resolveWorkspaceScopeRoot(workspaceRoot, params = {}, opts = {}) {
   const flowId = params.flowId != null ? String(params.flowId).trim() : "";
   if (!flowId) return { root: path.resolve(workspaceRoot), flowId: "", flowSource: "", archived: false };
@@ -2214,6 +2691,45 @@ function workspaceResolvePath(baseCwd, raw) {
   return path.isAbsolute(text) ? path.resolve(text) : path.resolve(baseCwd, text);
 }
 
+function workspaceShellQuote(value) {
+  return "'" + String(value ?? "").replace(/'/g, "'\\''") + "'";
+}
+
+function workspaceSafeFlowRelPath(raw, fieldName = "path") {
+  const text = String(raw || "").trim().replace(/^["']|["']$/g, "");
+  if (!text) return "";
+  if (text.length > 260) throw new Error(`${fieldName} is too long`);
+  if (/[\r\n<>]/.test(text)) throw new Error(`${fieldName} contains invalid characters`);
+  if (/^(?:https?:|data:|blob:|file:|javascript:|mailto:|tel:)/i.test(text)) {
+    throw new Error(`${fieldName} must be a relative file path`);
+  }
+  if (path.isAbsolute(text)) throw new Error(`${fieldName} must be relative`);
+  const normalized = path.posix.normalize(text.replace(/\\/g, "/")).replace(/^\/+/, "");
+  if (!normalized || normalized === "." || normalized.startsWith("../") || normalized.includes("/../")) {
+    throw new Error(`${fieldName} escapes workspace root`);
+  }
+  return normalized;
+}
+
+function workspaceResolveFlowFile(scopedRoot, relPath, fieldName = "path") {
+  const clean = workspaceSafeFlowRelPath(relPath, fieldName);
+  if (!clean) return "";
+  const root = path.resolve(scopedRoot);
+  const abs = path.resolve(root, ...clean.split("/"));
+  const rootWithSep = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+  if (abs !== root && !abs.startsWith(rootWithSep)) {
+    throw new Error(`${fieldName} escapes workspace root`);
+  }
+  return abs;
+}
+
+function workspaceReadTextFileIfExists(absPath, maxChars = 60000) {
+  const file = String(absPath || "").trim();
+  if (!file || !fs.existsSync(file) || !fs.statSync(file).isFile()) return "";
+  const raw = fs.readFileSync(file, "utf-8");
+  return raw.length > maxChars ? `${raw.slice(0, maxChars)}\n...[truncated ${raw.length - maxChars} chars]` : raw;
+}
+
 function workspaceSanitizeRepoDirName(repoUrl) {
   const raw = String(repoUrl || "").trim().replace(/\.git$/i, "");
   const last = raw.split(/[/:]/).filter(Boolean).pop() || "repo";
@@ -2500,7 +3016,7 @@ function workspaceRunPlan(graph, runNodeId, scopedRoot = "") {
   const addNeeded = (id) => {
     if (!id || needed.has(id)) return;
     const defId = String(instances[id]?.definitionId || "");
-    if (id !== target && defId === "workspace_run") {
+    if (id !== target && (defId === "workspace_run" || defId === "workspace_scheduled_run")) {
       pauseNodeIds.add(id);
       return;
     }
@@ -2726,6 +3242,314 @@ function workspacePromptUpstreamText(upstreamText, runPackage = {}) {
   return upstreamText;
 }
 
+function workspaceImplementationInlineText(instance) {
+  const candidates = [instance?.implementation, instance?.implementationPlan];
+  for (const item of candidates) {
+    if (item == null) continue;
+    if (typeof item === "string" && item.trim()) return item.trim();
+    if (typeof item === "object" && !Array.isArray(item)) {
+      const content = item.content ?? item.body ?? item.notes ?? "";
+      if (String(content || "").trim()) return String(content).trim();
+    }
+  }
+  return "";
+}
+
+function workspaceMaterializeImplementationReference(instance, scopedRoot, runPackage = {}) {
+  const implementationRef = String(instance?.implementationRef || "").trim();
+  if (!implementationRef) return null;
+  const abs = workspaceResolveFlowFile(scopedRoot, implementationRef, "implementationRef");
+  const exists = fs.existsSync(abs) && fs.statSync(abs).isFile();
+  const nodeRunDir = String(runPackage?.nodeRunDir || "").trim();
+  let mounted = "";
+  if (exists && nodeRunDir) {
+    try {
+      const mountedRel = path.join("references", "implementation.md");
+      const dest = path.resolve(nodeRunDir, mountedRel);
+      const nodeRunWithSep = nodeRunDir.endsWith(path.sep) ? nodeRunDir : `${nodeRunDir}${path.sep}`;
+      if (dest === nodeRunDir || dest.startsWith(nodeRunWithSep)) {
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.copyFileSync(abs, dest);
+        mounted = mountedRel.split(path.sep).join(path.posix.sep);
+      }
+    } catch {
+      mounted = "";
+    }
+  }
+  return { implementationRef, exists, mounted };
+}
+
+function workspaceImplementationBlock(instance, scopedRoot, runPackage = {}) {
+  const ref = workspaceMaterializeImplementationReference(instance, scopedRoot, runPackage);
+  const inline = workspaceImplementationInlineText(instance);
+  if (!ref && !inline) return "";
+  const mode = String(instance?.implementationMode || "").trim();
+  return [
+    "## 参考实现方案",
+    "",
+    mode ? `mode: ${mode}` : "",
+    ref ? `- 实现方案文件：\`${ref.mounted || ref.implementationRef}\`` : "",
+    ref?.mounted ? `- 原始流水线路径：\`${ref.implementationRef}\`` : "",
+    ref && !ref.exists ? "- 当前实现方案文件不存在，本次不要依赖旧方案。" : "",
+    inline ? "- 节点存在内联实现方案字段，但本提示不会内联其内容；如需复用，请优先参考实现方案文件。" : "",
+    "",
+    "该文件只作为可选参考，用于了解上次执行的实现路径。不要把旧方案当成硬约束；如果与当前任务、输入或输出要求冲突，以当前任务为准。",
+    "只有在需要复用细节或确认历史约定时才读取该文件；不要在最终回复中复述参考方案内容。",
+  ].filter((line) => line !== "").join("\n");
+}
+
+function workspaceSafeNodeFileName(nodeId) {
+  const text = String(nodeId || "").trim().replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+  return text || "node";
+}
+
+function workspaceDefaultImplementationRef(nodeId) {
+  return `nodes/${workspaceSafeNodeFileName(nodeId)}/implementation.md`;
+}
+
+function workspaceImplementationModeForInstance(instance) {
+  const explicit = String(instance?.implementationMode || "").trim();
+  if (explicit) return explicit;
+  return String(instance?.definitionId || "") === "tool_nodejs" ? "script" : "steps";
+}
+
+function workspaceClipImplementationText(value, maxChars = 2400) {
+  const text = String(value ?? "").trim();
+  if (!text) return "";
+  return text.length > maxChars ? `${text.slice(0, maxChars)}\n...[truncated ${text.length - maxChars} chars]` : text;
+}
+
+function workspaceUniqueImplementationList(items = [], maxItems = 12) {
+  const out = [];
+  const seen = new Set();
+  for (const item of items) {
+    const text = String(item || "").trim();
+    if (!text) continue;
+    const key = text.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(text);
+    if (out.length >= maxItems) break;
+  }
+  return out;
+}
+
+function workspaceImplementationArtifactCandidates(structured = {}, result = "") {
+  const candidates = [
+    structured.resultFile,
+    structured.result,
+    result,
+    ...Object.values(structured.outParams || {}),
+  ];
+  return workspaceUniqueImplementationList(candidates, 10)
+    .filter((item) => /^(?:outputs|nodes|artifacts)\//.test(item) && !/[\r\n]/.test(item));
+}
+
+function workspaceReadImplementationArtifact(scopedRoot, structured = {}, result = "") {
+  const root = String(scopedRoot || "").trim();
+  if (!root) return null;
+  for (const rel of workspaceImplementationArtifactCandidates(structured, result)) {
+    let abs = "";
+    try {
+      abs = workspaceResolveFlowFile(root, rel, "resultFile");
+    } catch {
+      continue;
+    }
+    if (!abs || !fs.existsSync(abs) || !fs.statSync(abs).isFile()) continue;
+    const ext = path.extname(abs).toLowerCase();
+    const content = workspaceReadTextFileIfExists(abs, 120000);
+    if (!content.trim()) continue;
+    return { rel, abs, ext, content };
+  }
+  return null;
+}
+
+function workspaceImplementationArtifactContext(scopedRoot, structured = {}, result = "") {
+  const artifact = workspaceReadImplementationArtifact(scopedRoot, structured, result);
+  if (!artifact) return "无可读取产物文件。";
+  return [
+    `产物路径：${artifact.rel}`,
+    `文件类型：${artifact.ext || "(unknown)"}`,
+    "",
+    "产物内容：",
+    "```",
+    workspaceClipImplementationText(artifact.content, 50000),
+    "```",
+  ].join("\n");
+}
+
+function workspaceBuildImplementationPrompt(instance, nodeId, opts = {}) {
+  const defId = String(instance?.definitionId || "").trim();
+  const label = String(instance?.label || nodeId || "node").trim();
+  const mode = workspaceImplementationModeForInstance(instance);
+  const inputValues = opts.inputValues || {};
+  const structured = opts.structured && typeof opts.structured === "object" ? opts.structured : {};
+  const result = String(opts.resultContent || structured.result || "").trim();
+  const task = workspaceResolveBodyPlaceholders(instance?.body || "", inputValues).trim();
+  const scriptRef = String(instance?.scriptRef || "").trim();
+  const inlineScript = String(instance?.script || "").trim();
+  const previousImplementation = opts.previousImplementation
+    ? workspaceClipImplementationText(opts.previousImplementation, 12000)
+    : "";
+  return [
+    "你要为 AgentFlow 的一个节点写“实现方案”Markdown。这个文件会在下次运行同一个节点前作为上下文给模型参考。",
+    "",
+    "要求：",
+    "- 必须基于实际任务、输入和产物内容自己总结，不要写流水账，不要写“使用 Agent 生成输出”这类空话。",
+    "- 写清楚这次结果到底是如何实现的：核心思路、产物结构、关键文件/路径、关键样式/函数/数据结构、可复用约定。",
+    "- 写清楚下次如果要继续迭代，应该从哪里改、哪些约定不能破坏。",
+    "- 如果产物是 HTML/UI，必须总结页面模块、视觉风格、关键 class/token、交互点和下游展示契约。",
+    "- 如果产物是脚本，必须总结脚本入口、环境变量、输入输出协议和错误处理方式。",
+    "- 只输出 Markdown 正文，不要输出代码围栏包裹整篇，不要解释你在总结。",
+    "",
+    "## 节点信息",
+    "",
+    `nodeId: ${nodeId}`,
+    `label: ${label}`,
+    `definitionId: ${defId || "(unknown)"}`,
+    `mode: ${mode}`,
+    scriptRef ? `scriptRef: ${scriptRef}` : "",
+    inlineScript ? `inlineScript: ${workspaceClipImplementationText(inlineScript, 1200)}` : "",
+    "",
+    "## 当前任务",
+    "",
+    workspaceClipImplementationText(task || instance?.body || scriptRef || inlineScript || "(无显式任务)", 6000),
+    "",
+    "## 输入",
+    "",
+    JSON.stringify(inputValues || {}, null, 2),
+    "",
+    "## 输出",
+    "",
+    JSON.stringify({
+      result: structured.result || result,
+      resultFile: structured.resultFile || "",
+      outParams: structured.outParams || {},
+    }, null, 2),
+    "",
+    previousImplementation ? "## 上一版实现方案" : "",
+    previousImplementation || "",
+    previousImplementation ? "" : "",
+    "## 实际产物上下文",
+    "",
+    workspaceImplementationArtifactContext(opts.scopedRoot, structured, result),
+  ].filter((line) => line !== "").join("\n");
+}
+
+async function workspaceGenerateImplementationMarkdown({
+  scopedRoot,
+  nodeId,
+  instance,
+  inputValues,
+  resultContent,
+  structured,
+  implementationPath,
+  previousImplementation,
+  runPackage,
+  modelKey,
+  userCtx,
+  emit,
+  onActiveChild,
+}) {
+  const prompt = workspaceBuildImplementationPrompt(instance, nodeId, {
+    scopedRoot,
+    inputValues,
+    resultContent,
+    structured,
+    previousImplementation,
+  });
+  let content = "";
+  let lastAssistant = "";
+  let resultText = "";
+  emit?.({ type: "status", line: "Summarize implementation plan with model" });
+  const handle = startComposerAgent({
+    uiWorkspaceRoot: scopedRoot,
+    cliWorkspace: runPackage?.nodeRunDir || scopedRoot,
+    prompt,
+    modelKey,
+    agentflowUserId: userCtx?.userId || "",
+    extraEnv: runtimeEnvForUser(userCtx, {
+      AGENTFLOW_IMPLEMENTATION_REF: implementationPath || "",
+      AGENTFLOW_NODE_RUN_DIR: runPackage?.nodeRunDir || "",
+      AGENTFLOW_NODE_TMP_DIR: runPackage?.nodeTmpDir || "",
+      AGENTFLOW_OUTPUTS_DIR: runPackage?.outputsDir || "",
+    }),
+    onStreamEvent: (ev) => {
+      if (ev?.type === "natural" && ev.kind === "assistant" && typeof ev.text === "string") {
+        lastAssistant = ev.text;
+        content += (content ? "\n" : "") + ev.text;
+      } else if (ev?.type === "natural" && ev.kind === "result" && typeof ev.text === "string") {
+        resultText = ev.text;
+      }
+    },
+    onToolCall: (subtype, toolName) => {
+      const sub = subtype ? String(subtype) : "";
+      const tool = toolName ? String(toolName) : "";
+      emit?.({ type: "status", line: `总结方案工具 ${tool || "thinking"}${sub ? ` (${sub})` : ""}` });
+    },
+  });
+  if (typeof onActiveChild === "function") onActiveChild(handle.child || null);
+  try {
+    await handle.finished;
+  } finally {
+    if (typeof onActiveChild === "function") onActiveChild(null);
+  }
+  const markdown = String(resultText || lastAssistant || content || "").trim();
+  return markdown.replace(/^```(?:markdown|md)?\s*/i, "").replace(/```\s*$/i, "").trim();
+}
+
+async function workspacePersistNodeImplementation(scopedRoot, graph, nodeId, opts = {}) {
+  const current = graph?.instances?.[nodeId];
+  if (!current || String(current.definitionId || "") === "workspace_run" || String(current.definitionId || "") === "workspace_scheduled_run") {
+    return { changed: false, wrote: false, instance: current };
+  }
+  const existingRef = String(current.implementationRef || "").trim();
+  const implementationRef = existingRef || workspaceDefaultImplementationRef(nodeId);
+  const abs = workspaceResolveFlowFile(scopedRoot, implementationRef, "implementationRef");
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  const previousImplementation = fs.existsSync(abs) && fs.statSync(abs).isFile()
+    ? workspaceReadTextFileIfExists(abs, 60000)
+    : "";
+  const markdown = await workspaceGenerateImplementationMarkdown({
+    scopedRoot,
+    nodeId,
+    instance: current,
+    inputValues: opts.inputValues || {},
+    resultContent: opts.resultContent || "",
+    structured: opts.structured || {},
+    implementationPath: implementationRef,
+    previousImplementation,
+    runPackage: opts.runPackage,
+    modelKey: opts.modelKey || "",
+    userCtx: opts.userCtx || {},
+    emit: opts.emit,
+    onActiveChild: opts.onActiveChild,
+  });
+  if (!markdown.trim()) throw new Error(`Implementation summary is empty for node ${nodeId}`);
+  fs.writeFileSync(abs, markdown.trimEnd() + "\n", "utf-8");
+  const explicitMode = String(current.implementationMode || "").trim();
+  const next = {
+    ...current,
+    implementationRef,
+    ...(explicitMode ? { implementationMode: explicitMode } : {}),
+  };
+  const changed = String(current.implementationRef || "") !== implementationRef;
+  return { changed, wrote: true, instance: next, implementationRef };
+}
+
+async function workspaceTryPersistNodeImplementation(scopedRoot, graph, nodeId, opts = {}) {
+  try {
+    return await workspacePersistNodeImplementation(scopedRoot, graph, nodeId, opts);
+  } catch (e) {
+    opts.emit?.({
+      type: "natural",
+      kind: "warning",
+      text: `实现方案未更新：${e?.message || String(e)}`,
+    });
+    return { changed: false, wrote: false, instance: graph?.instances?.[nodeId] };
+  }
+}
+
 function parseWorkspaceSkillKeys(raw) {
   const text = String(raw || "").trim();
   if (!text) return [];
@@ -2859,6 +3683,7 @@ function workspaceWriteDisplayContent(instance, content) {
   const unwrapped = workspaceUnwrapOutputEnvelopeForDisplay(content);
   const text = kind === "html" ? normalizeHtmlDisplayContent(unwrapped) : String(unwrapped || "");
   const primaryName = kind === "image" ? "src" : "content";
+  next.displayReloadKey = `${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
   next.body = text;
   next.input = (Array.isArray(next.input) ? next.input : []).map((slot) => (
     String(slot?.name || "") === primaryName || String(slot?.type || "") === "text"
@@ -2898,7 +3723,7 @@ function workspaceUpdateDirectDisplays(graph, sourceId, content, outputs = null)
   return updated;
 }
 
-function workspaceNodePrompt(graph, nodeId, upstreamText, skillsBlock, mcpBlock = "", inputValues = {}, nodeTmpDir = "") {
+function workspaceNodePrompt(graph, nodeId, upstreamText, skillsBlock, mcpBlock = "", inputValues = {}, nodeTmpDir = "", implementationBlock = "") {
   const instance = graph.instances[nodeId] || {};
   const body = workspaceResolveBodyPlaceholders(instance.body || "", inputValues).trim();
   const { values: relevantInputValues, placeholders } = workspaceRelevantInputValues(instance.body || "", inputValues);
@@ -2911,6 +3736,7 @@ function workspaceNodePrompt(graph, nodeId, upstreamText, skillsBlock, mcpBlock
     fileBoundary ? `\n${fileBoundary}` : "",
     inputBlock ? `\n${inputBlock}` : "",
     placeholders.size ? "\n任务只显式引用了上面的输入槽；其它未被 `${...}` 引用的已连接业务输入不要作为分析依据。" : "",
+    implementationBlock ? `\n${implementationBlock}` : "",
     skillsBlock ? `\n## 可用能力\n\n${skillsBlock}` : "",
     mcpBlock ? `\n## 可用 MCP\n\n${mcpBlock}` : "",
     upstreamText ? `\n## 上游正文\n\n${upstreamText}` : "",
@@ -2919,13 +3745,38 @@ function workspaceNodePrompt(graph, nodeId, upstreamText, skillsBlock, mcpBlock
   ].filter(Boolean).join("\n");
 }
 
-function workspaceDefaultWorktreeRoot(scopedRoot) {
-  return path.join(path.resolve(scopedRoot), ".workspace", "agentflow", "worktrees");
+function workspaceDefaultGitRepoRoot(scopedRoot, _userCtx = {}) {
+  return path.join(path.resolve(scopedRoot), ".workspace", "agentflow", "git-repos");
+}
+
+function workspaceDefaultWorktreePath(runTmpRoot, nodeId, repoPath, branch = "") {
+  const repoRoot = path.resolve(repoPath);
+  const repoName = sanitizeWorktreeName(path.basename(repoRoot));
+  const branchName = String(branch || "").trim();
+  let refLabel = branchName;
+  if (!refLabel) {
+    const currentBranch = runGit(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot);
+    if (currentBranch.status === 0 && currentBranch.stdout.trim() && currentBranch.stdout.trim() !== "HEAD") {
+      refLabel = currentBranch.stdout.trim();
+    }
+  }
+  if (!refLabel) {
+    const currentCommit = runGit(["rev-parse", "HEAD"], repoRoot);
+    refLabel = currentCommit.status === 0 && currentCommit.stdout.trim()
+      ? currentCommit.stdout.trim().slice(0, 12)
+      : "HEAD";
+  }
+  return path.join(
+    path.resolve(runTmpRoot),
+    "worktrees",
+    workspaceSanitizeTmpSegment(nodeId, "node"),
+    repoName,
+    sanitizeWorktreeName(refLabel),
+  );
 }
 
-function workspaceShouldAutoCleanupWorktree(scopedRoot, worktreePath, hasExplicitWorktreePath) {
-  if (hasExplicitWorktreePath || !worktreePath) return false;
-  return workspacePathInside(workspaceDefaultWorktreeRoot(scopedRoot), worktreePath);
+function workspaceShouldAutoCleanupWorktree(worktreePath, hasExplicitWorktreePath) {
+  return Boolean(worktreePath) && !hasExplicitWorktreePath;
 }
 
 function workspaceTrackAutoCleanupWorktree(list, item) {
@@ -2961,7 +3812,7 @@ function workspaceCleanupAutoWorktrees(list, graph, emit) {
       const result = unloadGitWorktree({
         repoPath: entry.repoPath,
         worktreePath: entry.worktreePath,
-        force: false,
+        force: true,
         prune: true,
       });
       emit({
@@ -3118,6 +3969,146 @@ function workspaceCleanupTmpRoot(runTmpRoot, userCtx = {}, emit = () => {}) {
   }
 }
 
+function workspaceOutputFileRefsForNode(instance) {
+  const refs = {};
+  const slots = Array.isArray(instance?.output) ? instance.output : [];
+  for (let index = 0; index < slots.length; index += 1) {
+    const slot = slots[index];
+    const name = String(slot?.name || "").trim();
+    const type = String(slot?.type || "");
+    if (!name || type === "node" || name === "next" || name === "prev") continue;
+    const key = name === "content" || index === 0 ? "result" : name;
+    const safe = workspaceSanitizeTmpSegment(key, "result");
+    refs[key] = `outputs/${safe}.txt`;
+  }
+  if (!refs.result) refs.result = "outputs/result.txt";
+  return refs;
+}
+
+function workspaceResolveScriptCommandText(script, values = {}) {
+  return String(script || "").replace(/\$\{([^}]+)\}/g, (_, key) => {
+    const name = String(key || "").trim();
+    return workspaceShellQuote(Object.prototype.hasOwnProperty.call(values, name) ? values[name] : "");
+  });
+}
+
+function workspaceDefaultScriptCommand(scriptAbs) {
+  const ext = path.extname(scriptAbs).toLowerCase();
+  if (ext === ".js" || ext === ".mjs" || ext === ".cjs") return `node ${workspaceShellQuote(scriptAbs)}`;
+  if (ext === ".sh" || ext === ".bash") return `bash ${workspaceShellQuote(scriptAbs)}`;
+  if (ext === ".py") return `python3 ${workspaceShellQuote(scriptAbs)}`;
+  return workspaceShellQuote(scriptAbs);
+}
+
+function workspaceEnvelopeFromOutputFiles(outputRefs, nodeRunDir) {
+  const entries = Object.entries(outputRefs || {})
+    .map(([name, rel]) => {
+      const abs = path.resolve(nodeRunDir, rel);
+      const nodeRootWithSep = nodeRunDir.endsWith(path.sep) ? nodeRunDir : `${nodeRunDir}${path.sep}`;
+      if (abs !== nodeRunDir && !abs.startsWith(nodeRootWithSep)) return null;
+      if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) return null;
+      return { name, rel };
+    })
+    .filter(Boolean);
+  if (entries.length === 0) return "";
+  const result = entries.find((entry) => entry.name === "result") || entries[0];
+  const outParams = entries.filter((entry) => entry !== result);
+  return [
+    "---agentflow",
+    `resultFile: ${result.rel}`,
+    outParams.length ? "outParams:" : "",
+    ...outParams.map((entry) => `  ${entry.name}File: ${entry.rel}`),
+    "---end",
+  ].filter(Boolean).join("\n");
+}
+
+async function workspaceRunToolNodejsScript({
+  scopedRoot,
+  cwd,
+  instance,
+  inputValues,
+  runPackage,
+  userCtx,
+  emit,
+}) {
+  const scriptRef = String(instance?.scriptRef || "").trim();
+  const scriptAbs = scriptRef ? workspaceResolveFlowFile(scopedRoot, scriptRef, "scriptRef") : "";
+  if (scriptAbs && (!fs.existsSync(scriptAbs) || !fs.statSync(scriptAbs).isFile())) {
+    throw new Error(`scriptRef not found: ${scriptRef}`);
+  }
+  const outputRefs = workspaceOutputFileRefsForNode(instance);
+  const outputAbs = Object.fromEntries(
+    Object.entries(outputRefs).map(([key, rel]) => [key, path.resolve(runPackage.nodeRunDir, rel)]),
+  );
+  for (const abs of Object.values(outputAbs)) fs.mkdirSync(path.dirname(abs), { recursive: true });
+  const constants = {
+    workspaceRoot: path.resolve(scopedRoot),
+    pipelineWorkspace: path.resolve(scopedRoot),
+    flowDir: path.resolve(scopedRoot),
+    cwd: path.resolve(cwd || scopedRoot),
+    nodeRunDir: runPackage.nodeRunDir,
+    nodeTmpDir: runPackage.nodeTmpDir,
+    outputsDir: runPackage.outputsDir,
+    scriptRef: scriptAbs,
+    ...inputValues,
+    ...outputRefs,
+  };
+  const inlineScript = String(instance?.script || "").trim();
+  const command = inlineScript
+    ? workspaceResolveScriptCommandText(inlineScript, constants)
+    : scriptAbs
+      ? workspaceDefaultScriptCommand(scriptAbs)
+      : "";
+  if (!command) throw new Error("tool_nodejs requires script or scriptRef");
+
+  emit?.({ type: "status", line: `Run script: ${scriptRef || command.slice(0, 120)}` });
+
+  const env = runtimeEnvForUser(userCtx, {
+    AGENTFLOW_WORKSPACE_ROOT: path.resolve(scopedRoot),
+    AGENTFLOW_NODE_RUN_DIR: runPackage.nodeRunDir,
+    AGENTFLOW_NODE_TMP_DIR: runPackage.nodeTmpDir,
+    AGENTFLOW_OUTPUTS_DIR: runPackage.outputsDir,
+    AGENTFLOW_SCRIPT_REF: scriptAbs,
+    AGENTFLOW_INPUTS_JSON: JSON.stringify(inputValues || {}),
+    AGENTFLOW_OUTPUTS_JSON: JSON.stringify(outputRefs),
+    AGENTFLOW_OUTPUTS_ABS_JSON: JSON.stringify(outputAbs),
+  });
+
+  const started = Date.now();
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, [], {
+      cwd: runPackage.nodeRunDir,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf-8");
+    child.stderr.setEncoding("utf-8");
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (stderr.trim()) {
+        emit?.({ type: "natural", kind: "warning", text: `[script stderr]\n${stderr.trim().slice(-4000)}` });
+      }
+      if (code !== 0) {
+        reject(new Error(`tool_nodejs script exited ${code}${stderr.trim() ? `: ${stderr.trim().slice(-800)}` : ""}`));
+        return;
+      }
+      const elapsedMs = Math.max(0, Date.now() - started);
+      emit?.({ type: "status", line: `Timing script: ${elapsedMs}ms`, timing: { label: "script", elapsedMs } });
+      const content = stdout.trim() || workspaceEnvelopeFromOutputFiles(outputRefs, runPackage.nodeRunDir);
+      resolve(content);
+    });
+  });
+}
+
 async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts = {}) {
   const graph = normalizeWorkspaceGraphPayload(payload.graph || {});
   const runNodeId = String(payload?.runNodeId || "").trim();
@@ -3190,7 +4181,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     const defId = String(instance.definitionId || "");
     emit({ type: "node-start", nodeId, definitionId: defId });
 
-    if (defId === "workspace_run") {
+    if (defId === "workspace_run" || defId === "workspace_scheduled_run") {
       continue;
     }
 
@@ -3297,7 +4288,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       const targetRaw = workspaceSlotValue(workspaceSlotByName(instance, "targetDir")).trim();
       const targetDir = targetRaw
         ? workspaceResolvePath(cwd, targetRaw)
-        : path.join(scopedRoot, ".workspace", "agentflow", "git-repos", workspaceSanitizeRepoDirName(repoUrl));
+        : path.join(workspaceDefaultGitRepoRoot(scopedRoot, userCtx), workspaceSanitizeRepoDirName(repoUrl));
       const pullIfExists = workspaceBoolSlot(instance, "pullIfExists", true);
       const includeSubmodules = workspaceBoolSlot(instance, "includeSubmodules", false);
       fs.mkdirSync(path.dirname(targetDir), { recursive: true });
@@ -3369,14 +4360,16 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       const worktreeInputSlot = (Array.isArray(instance.input) ? instance.input : [])
         .find((slot) => String(slot?.name || "") === "worktreePath") || null;
       const rawWorktreePath = workspaceSlotValue(worktreeInputSlot || workspaceSlotByName(instance, "worktreePath")).trim();
-      const worktreePath = rawWorktreePath ? workspaceResolvePath(cwd, rawWorktreePath) : (gitContext?.worktreePath ? path.resolve(gitContext.worktreePath) : "");
+      const worktreePath = rawWorktreePath
+        ? workspaceResolvePath(cwd, rawWorktreePath)
+        : (gitContext?.worktreePath ? path.resolve(gitContext.worktreePath) : workspaceDefaultWorktreePath(runTmpRoot, nodeId, repoPath, branch));
       const hasExplicitWorktreePath = Boolean(rawWorktreePath) || Boolean(gitContext?.worktreePath);
       const previousCwd = cwd;
       const force = ["true", "1", "yes", "on"].includes(workspaceSlotValue(workspaceSlotByName(instance, "force")).trim().toLowerCase());
       const pruneMissingRaw = workspaceSlotValue(workspaceSlotByName(instance, "pruneMissing")).trim().toLowerCase();
       const pruneMissing = pruneMissingRaw !== "false";
       const result = loadGitWorktree({ repoPath, branch, worktreePath, pipelineWorkspace: scopedRoot, force, pruneMissing });
-      if (workspaceShouldAutoCleanupWorktree(scopedRoot, result.worktreePath, hasExplicitWorktreePath)) {
+      if (workspaceShouldAutoCleanupWorktree(result.worktreePath, hasExplicitWorktreePath)) {
         workspaceTrackAutoCleanupWorktree(autoCleanupWorktrees, {
           nodeId,
           repoPath: result.repoRoot,
@@ -3480,6 +4473,51 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       continue;
     }
 
+    if (defId === "tool_nodejs") {
+      const prepareStartedAt = Date.now();
+      const inputValues = workspaceInputValues(graph, nodeId, outputs);
+      const runPackage = workspaceCreateNodeRunPackage(runTmpRoot, nodeId, {
+        scopedRoot,
+        cwd,
+        task: String(instance.script || instance.scriptRef || instance.body || "").trim(),
+        inputValues,
+      });
+      const runtimeInputValues = { ...inputValues, ...(runPackage.inputValues || {}) };
+      emitTiming(nodeId, "prepare-script", prepareStartedAt, {
+        inputCount: Object.keys(runtimeInputValues || {}).length,
+        nodeRunDir: runPackage.nodeRunDir,
+      });
+      const content = await workspaceRunToolNodejsScript({
+        scopedRoot,
+        cwd,
+        instance,
+        inputValues: runtimeInputValues,
+        runPackage,
+        userCtx,
+        emit: (event) => emit({ ...event, nodeId }),
+      });
+      const normalizedAgentOutput = workspacePublishAgentOutputFiles(workspaceStructuredAgentOutput(content), runPackage);
+      const resultContent = normalizedAgentOutput.result || content;
+      outputs.set(nodeId, resultContent);
+      const slotUpdate = workspaceApplyAgentOutputSlots(instance, normalizedAgentOutput);
+      if (slotUpdate.changed) graph.instances[nodeId] = slotUpdate.instance;
+      const implementationUpdate = await workspaceTryPersistNodeImplementation(scopedRoot, graph, nodeId, {
+        inputValues: runtimeInputValues,
+        resultContent,
+        structured: normalizedAgentOutput,
+        runPackage,
+        modelKey,
+        userCtx,
+        emit: (event) => emit({ ...event, nodeId }),
+        onActiveChild: opts.onActiveChild,
+      });
+      if (implementationUpdate.changed) graph.instances[nodeId] = implementationUpdate.instance;
+      const updatedDisplays = workspaceUpdateDirectDisplays(graph, nodeId, resultContent, outputs);
+      if (slotUpdate.changed || implementationUpdate.changed || updatedDisplays.length) emit({ type: "graph", nodeId, displayNodeIds: updatedDisplays, graph });
+      emit({ type: "node-done", nodeId, definitionId: defId });
+      continue;
+    }
+
     const prepareStartedAt = Date.now();
     const inputValues = workspaceInputValues(graph, nodeId, outputs);
     const relevantInputs = workspaceRelevantInputValues(instance.body || "", inputValues);
@@ -3506,7 +4544,8 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     } catch {
       // Best-effort debug artifact only.
     }
-    const prompt = workspaceNodePrompt(graph, nodeId, promptUpstreamText, promptSkillsBlock, promptMcpBlock, runtimeInputValues, runPackage);
+    const implementationBlock = workspaceImplementationBlock(instance, scopedRoot, runPackage);
+    const prompt = workspaceNodePrompt(graph, nodeId, promptUpstreamText, promptSkillsBlock, promptMcpBlock, runtimeInputValues, runPackage, implementationBlock);
     try {
       fs.writeFileSync(path.join(runPackage.nodeRunDir, "prompt.md"), prompt.trimEnd() + "\n", "utf-8");
     } catch {
@@ -3592,8 +4631,19 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     outputs.set(nodeId, resultContent);
     const slotUpdate = workspaceApplyAgentOutputSlots(instance, normalizedAgentOutput);
     if (slotUpdate.changed) graph.instances[nodeId] = slotUpdate.instance;
+    const implementationUpdate = await workspaceTryPersistNodeImplementation(scopedRoot, graph, nodeId, {
+      inputValues: runtimeInputValues,
+      resultContent,
+      structured: normalizedAgentOutput,
+      runPackage,
+      modelKey,
+      userCtx,
+      emit: (event) => emit({ ...event, nodeId }),
+      onActiveChild: opts.onActiveChild,
+    });
+    if (implementationUpdate.changed) graph.instances[nodeId] = implementationUpdate.instance;
     const updatedDisplays = workspaceUpdateDirectDisplays(graph, nodeId, resultContent, outputs);
-    if (slotUpdate.changed || updatedDisplays.length) emit({ type: "graph", nodeId, displayNodeIds: updatedDisplays, graph });
+    if (slotUpdate.changed || implementationUpdate.changed || updatedDisplays.length) emit({ type: "graph", nodeId, displayNodeIds: updatedDisplays, graph });
     emit({ type: "node-done", nodeId, definitionId: defId });
   }
   } finally {
@@ -4112,6 +5162,46 @@ export function startUiServer({
       }
     }
 
+    if (url.pathname === "/api/admin/storage-config") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin permission required" });
+        return;
+      }
+      if (req.method === "GET") {
+        json(res, 200, { config: readAdminStorageConfig() });
+        return;
+      }
+      if (req.method === "POST") {
+        let payload;
+        try {
+          payload = JSON.parse(await readBody(req));
+        } catch {
+          json(res, 400, { error: "Invalid JSON body" });
+          return;
+        }
+        try {
+          const config = writeAdminStorageConfig(payload?.config || payload || {});
+          json(res, 200, { ok: true, config });
+        } catch (e) {
+          json(res, 400, { error: (e && e.message) || String(e) });
+        }
+        return;
+      }
+    }
+
+    if (req.method === "GET" && url.pathname === "/api/admin/usage-dashboard") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin permission required" });
+        return;
+      }
+      try {
+        json(res, 200, buildAdminUsageDashboard(root));
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (url.pathname === "/api/admin/user-allowlist") {
       if (!authUser?.isAdmin) {
         json(res, 403, { error: "Admin permission required" });
@@ -4408,9 +5498,10 @@ export function startUiServer({
           return;
         }
         const { path: graphPath, graph } = readWorkspaceGraph(scoped.root);
+        const hydratedGraph = hydrateWorkspaceNodeRefsFromFiles(scoped.root, graph);
         json(res, 200, {
           ok: true,
-          graph,
+          graph: hydratedGraph,
           path: graphPath,
           root: scoped.root,
           flowId: scoped.flowId,
@@ -4497,8 +5588,10 @@ export function startUiServer({
           json(res, 400, { error: "Cannot write workspace graph for builtin or archived pipeline" });
           return;
         }
-        const graph = normalizeWorkspaceGraphPayload(payload.graph || payload);
+        const submittedGraph = normalizeWorkspaceGraphPayload(payload.graph || payload);
         const graphPath = workspaceGraphPath(scoped.root);
+        const currentGraph = hydrateWorkspaceNodeRefsFromFiles(scoped.root, readWorkspaceGraph(scoped.root).graph);
+        const graph = mergeWorkspacePersistentNodeRefs(submittedGraph, currentGraph);
         fs.writeFileSync(graphPath, JSON.stringify(graph, null, 2) + "\n", "utf-8");
         json(res, 200, { ok: true, path: graphPath, graph });
       } catch (e) {
@@ -4544,6 +5637,9 @@ export function startUiServer({
         const runEntry = {
           controller,
           child: null,
+          runId: runLedgerId("workspace"),
+          userId: String(userCtx.userId || ""),
+          username: String(authUser?.username || userCtx.userId || ""),
           runNodeId: String(payload.runNodeId || "").trim(),
           flowId,
           flowSource: scoped.flowSource || payload.flowSource || "user",
@@ -4555,6 +5651,7 @@ export function startUiServer({
           },
         };
         activeWorkspaceRuns.set(runKey, runEntry);
+        appendWorkspaceRunStarted(runEntry);
         const setActiveChild = (child) => {
           runEntry.child = child || null;
           if (controller.signal.aborted) runEntry.stopChild();
@@ -4582,12 +5679,27 @@ export function startUiServer({
             const touchedIds = workspaceRunTouchedNodeIds(result);
             const mergedGraph = mergeWorkspaceRunGraph(currentGraph, result.graph, touchedIds);
             fs.writeFileSync(graphPath, JSON.stringify(mergedGraph, null, 2) + "\n", "utf-8");
+            appendWorkspaceRunFinished({
+              ...runEntry,
+              endedAt: Date.now(),
+              durationMs: Date.now() - runEntry.startedAt,
+            }, "success");
             writeEvent({ type: "done", ok: true, path: graphPath, graph: mergedGraph, order: result.order, touchedNodeIds: Array.from(touchedIds), pauseNodeIds: result.pauseNodeIds || [] });
             res.end();
           } catch (e) {
             if (isWorkspaceRunAbortError(e) || controller.signal.aborted) {
+              appendWorkspaceRunFinished({
+                ...runEntry,
+                endedAt: Date.now(),
+                durationMs: Date.now() - runEntry.startedAt,
+              }, "stopped");
               writeEvent({ type: "stopped", ok: false, stopped: true, message: "Workspace run stopped" });
             } else {
+              appendWorkspaceRunFinished({
+                ...runEntry,
+                endedAt: Date.now(),
+                durationMs: Date.now() - runEntry.startedAt,
+              }, "failed");
               writeEvent({ type: "error", error: (e && e.message) || String(e) });
             }
             res.end();
@@ -4606,11 +5718,26 @@ export function startUiServer({
           const touchedIds = workspaceRunTouchedNodeIds(result);
           const mergedGraph = mergeWorkspaceRunGraph(currentGraph, result.graph, touchedIds);
           fs.writeFileSync(graphPath, JSON.stringify(mergedGraph, null, 2) + "\n", "utf-8");
+          appendWorkspaceRunFinished({
+            ...runEntry,
+            endedAt: Date.now(),
+            durationMs: Date.now() - runEntry.startedAt,
+          }, "success");
           json(res, 200, { ok: true, path: graphPath, ...result, graph: mergedGraph, touchedNodeIds: Array.from(touchedIds) });
         } catch (e) {
           if (isWorkspaceRunAbortError(e) || controller.signal.aborted) {
+            appendWorkspaceRunFinished({
+              ...runEntry,
+              endedAt: Date.now(),
+              durationMs: Date.now() - runEntry.startedAt,
+            }, "stopped");
             json(res, 200, { ok: false, stopped: true, message: "Workspace run stopped" });
           } else {
+            appendWorkspaceRunFinished({
+              ...runEntry,
+              endedAt: Date.now(),
+              durationMs: Date.now() - runEntry.startedAt,
+            }, "failed");
             throw e;
           }
         } finally {