@fieldwangai/agentflow 0.1.29 → 0.1.31

package/bin/lib/paths.mjs

@@ -34,6 +34,56 @@ export function getAgentflowDataRoot() {
   return path.join(os.homedir(), "agentflow");
 }
 
+export const AGENTFLOW_DEFAULT_USER_ID = "";
+
+export function sanitizeAgentflowUserId(userId) {
+  const raw = userId == null ? "" : String(userId).trim();
+  if (!raw) return AGENTFLOW_DEFAULT_USER_ID;
+  const normalized = raw.toLowerCase();
+  if (!/^[a-z][a-z0-9_-]{0,63}$/.test(normalized)) return AGENTFLOW_DEFAULT_USER_ID;
+  return normalized;
+}
+
+export function getAgentflowUserDataRoot(userId) {
+  const safe = sanitizeAgentflowUserId(userId ?? process.env.AGENTFLOW_USER_ID);
+  if (!safe) return getAgentflowDataRoot();
+  return path.join(getAgentflowDataRoot(), "users", safe);
+}
+
+export function listAgentflowUserIds() {
+  const usersRoot = path.join(getAgentflowDataRoot(), "users");
+  try {
+    if (!fs.existsSync(usersRoot) || !fs.statSync(usersRoot).isDirectory()) return [];
+    return fs.readdirSync(usersRoot, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => sanitizeAgentflowUserId(entry.name))
+      .filter(Boolean)
+      .sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+
+export function getAgentflowUserContexts() {
+  const ids = listAgentflowUserIds();
+  return [{}, ...ids.map((userId) => ({ userId }))];
+}
+
+export function resolveUniqueUserPipelineDir(flowName) {
+  const name = flowName == null ? "" : String(flowName).trim();
+  if (!name) return null;
+  const matches = [];
+  for (const userId of listAgentflowUserIds()) {
+    const dir = path.join(getAgentflowDataRoot(), "users", userId, "pipelines", name);
+    try {
+      if (fs.existsSync(path.join(dir, "flow.yaml"))) matches.push(dir);
+    } catch {
+      /* ignore unreadable user dirs */
+    }
+  }
+  return matches.length === 1 ? matches[0] : null;
+}
+
 /** 项目内 runBuild 根目录：`<workspaceRoot>/.workspace/agentflow/runBuild`（legacy：写入路径已迁至 `<flowDir>/runBuild`，仅用于兼容读取） */
 export function getWorkspaceRunBuildRoot(workspaceRoot) {
   const root =
@@ -52,23 +102,21 @@ export function getLegacyUserRunBuildRoot() {
  * 统一 runtime root：每个 flow 的 pipeline 源、scripts、runBuild 共用一个根目录。
  * - 若 `~/agentflow/pipelines/<name>/flow.yaml` 存在 → user-scope：`~/agentflow/pipelines/<name>`
  * - 若 `<ws>/.workspace/agentflow/pipelines/<name>/flow.yaml` 存在 → workspace-scope：`<ws>/.workspace/agentflow/pipelines/<name>`
- * - archived（`_archived/<name>`）按对应 scope 返回
  * - 其他（builtin 只读 / 不存在）→ 默认 user-scope 路径（首次 run 时自动创建，builtin 源仍从包内读取但 runBuild 落到用户目录）
+ * 归档 flow 不参与普通 runtime root 解析，避免同名 archived flow 被误当作活跃 flow。
  */
-export function getFlowRuntimeRoot(workspaceRoot, flowName) {
+export function getFlowRuntimeRoot(workspaceRoot, flowName, opts = {}) {
   const root =
     workspaceRoot != null && String(workspaceRoot).trim() !== ""
       ? path.resolve(String(workspaceRoot))
       : process.cwd();
-  const userRoot = getUserPipelinesRoot();
+  const userRoot = getUserPipelinesRoot(opts.userId);
   const userDir = path.join(userRoot, flowName);
   if (fs.existsSync(path.join(userDir, "flow.yaml"))) return userDir;
-  const userArchived = path.join(userRoot, ARCHIVED_PIPELINES_DIR_NAME, flowName);
-  if (fs.existsSync(path.join(userArchived, "flow.yaml"))) return userArchived;
+  const inferredUserDir = resolveUniqueUserPipelineDir(flowName);
+  if (inferredUserDir) return inferredUserDir;
   const wsDir = path.join(root, PIPELINES_DIR, flowName);
   if (fs.existsSync(path.join(wsDir, "flow.yaml"))) return wsDir;
-  const wsArchived = path.join(root, PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowName);
-  if (fs.existsSync(path.join(wsArchived, "flow.yaml"))) return wsArchived;
   // builtin / legacy / 尚未落盘 → 默认 user 目录，runBuild 首次写入时创建
   return userDir;
 }
@@ -78,8 +126,8 @@ export function getFlowRuntimeRoot(workspaceRoot, flowName) {
  * 新运行走 `<flowRuntimeRoot>/runBuild/<uuid>`；
  * 若该 uuid 在旧位置（legacy workspace/user runBuild 根）已存在，则返回旧位置，保留 resume 兼容。
  */
-export function getRunDir(workspaceRoot, flowName, uuid) {
-  const candidates = getRunDirCandidates(workspaceRoot, flowName, uuid);
+export function getRunDir(workspaceRoot, flowName, uuid, opts = {}) {
+  const candidates = getRunDirCandidates(workspaceRoot, flowName, uuid, opts);
   for (const c of candidates) {
     if (fs.existsSync(c)) return c;
   }
@@ -93,9 +141,9 @@ export function getRunDir(workspaceRoot, flowName, uuid) {
  *   2. 旧 workspace：<ws>/.workspace/agentflow/runBuild/<flow>/<uuid>
  *   3. 旧 user：~/agentflow/runBuild/<flow>/<uuid>
  */
-export function getRunDirCandidates(workspaceRoot, flowName, uuid) {
+export function getRunDirCandidates(workspaceRoot, flowName, uuid, opts = {}) {
   const candidates = [
-    path.join(getFlowRuntimeRoot(workspaceRoot, flowName), "runBuild", uuid),
+    path.join(getFlowRuntimeRoot(workspaceRoot, flowName, opts), "runBuild", uuid),
     path.join(getWorkspaceRunBuildRoot(workspaceRoot), flowName, uuid),
     path.join(getLegacyUserRunBuildRoot(), flowName, uuid),
   ];
@@ -110,8 +158,8 @@ export function getRunDirCandidates(workspaceRoot, flowName, uuid) {
   return out;
 }
 
-export function getUserPipelinesRoot() {
-  return path.join(getAgentflowDataRoot(), "pipelines");
+export function getUserPipelinesRoot(userId) {
+  return path.join(getAgentflowUserDataRoot(userId), "pipelines");
 }
 
 export function getReferenceRootAbs() {
@@ -134,6 +182,10 @@ export function getAgentflowUserConfigAbs() {
   return path.join(getAgentflowDataRoot(), "config.json");
 }
 
+export function getAgentflowUserEnvAbs(userId) {
+  return path.join(getAgentflowUserDataRoot(userId), "env.json");
+}
+
 /** CLI / UI 文案用 */
 export const USER_AGENTFLOW_DIR_LABEL = "~/agentflow";
 export const USER_AGENTFLOW_PIPELINES_LABEL = "~/agentflow/pipelines";
@@ -204,8 +256,12 @@ export const LOCAL_ONLY_DEFINITION_IDS = new Set([
   "control_deadline",
   "control_cancelled",
   "control_interval_loop",
+  "control_cd_workspace",
+  "control_user_workspace",
+  "control_load_skills",
   "control_start",
   "control_end",
+  "tool_git_checkout",
   "tool_print",
   "tool_user_check",
   "tool_user_ask",

package/bin/lib/recent-runs.mjs

@@ -151,9 +151,9 @@ function mapFlowSource(src) {
  * @param {string} workspaceRoot
  * @returns {Array<{ flowId: string, flowSource: 'workspace'|'user', runId: string, at: number, durationMs: number, endedAt: number|null, status: 'success'|'failed'|'running'|'stopped'|'interrupted'|'unknown' }>}
  */
-export function listRecentRunsFromDisk(workspaceRoot) {
+export function listRecentRunsFromDisk(workspaceRoot, opts = {}) {
   const out = [];
-  for (const { flowName, uuid, runDir, source } of listAllRunDirs(workspaceRoot)) {
+  for (const { flowName, uuid, runDir, source } of listAllRunDirs(workspaceRoot, opts)) {
     let at = readKeyFromMemory(runDir, "runStartTime");
     if (at == null) {
       try {

package/bin/lib/run-node-statuses-from-disk.mjs

@@ -36,8 +36,8 @@ function parseElapsedMsLine(filePath) {
  * @param {string} uuid
  * @returns {Record<string, { status: string, elapsed?: string }>}
  */
-export function getRunNodeStatusesFromDisk(workspaceRoot, flowName, uuid) {
-  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+export function getRunNodeStatusesFromDisk(workspaceRoot, flowName, uuid, opts = {}) {
+  const runDir = getRunDir(workspaceRoot, flowName, uuid, opts);
   const flowJsonPath = path.join(runDir, "intermediate", "flow.json");
   if (!fs.existsSync(flowJsonPath)) return {};
 
@@ -51,7 +51,7 @@ export function getRunNodeStatusesFromDisk(workspaceRoot, flowName, uuid) {
 
   const order = Array.isArray(flow.order) ? flow.order : [];
   const nodeDefinitions = flow.nodeDefinitions && typeof flow.nodeDefinitions === "object" ? flow.nodeDefinitions : {};
-  const execIdMap = loadAllExecIds(workspaceRoot, flowName, uuid, order);
+  const execIdMap = loadAllExecIds(workspaceRoot, flowName, uuid, order, opts);
   const intermediateDir = path.join(runDir, "intermediate");
   /** @type {Record<string, { status: string, elapsed?: string }>} */
   const out = {};

package/bin/lib/runtime-context.mjs

@@ -0,0 +1,225 @@
+import path from "path";
+import { getFlowDir } from "./workspace.mjs";
+import { PACKAGE_ROOT, PIPELINES_DIR } from "./paths.mjs";
+import { listSkills, listSkillsFromSources, workspaceSkillSources } from "./skill-registry.mjs";
+
+function parseJsonObject(raw) {
+  if (raw == null) return null;
+  if (typeof raw === "object" && !Array.isArray(raw)) return raw;
+  const text = String(raw || "").trim();
+  if (!text) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+export function getPipelineFlowDir(workspaceRoot, flowName, flowJson = null) {
+  if (flowJson?.flowDir && typeof flowJson.flowDir === "string" && flowJson.flowDir.trim()) {
+    return path.isAbsolute(flowJson.flowDir) ? path.resolve(flowJson.flowDir) : path.resolve(workspaceRoot, flowJson.flowDir);
+  }
+  return getFlowDir(workspaceRoot, flowName) || path.join(path.resolve(workspaceRoot), PIPELINES_DIR, flowName);
+}
+
+export function buildDefaultWorkspaceContext(workspaceRoot, flowName, flowJson = null) {
+  const pipelineWorkspace = path.resolve(workspaceRoot);
+  const flowDir = getPipelineFlowDir(workspaceRoot, flowName, flowJson);
+  return {
+    version: 1,
+    label: "pipeline",
+    cwd: pipelineWorkspace,
+    workspaceRoot: pipelineWorkspace,
+    pipelineWorkspace,
+    flowDir,
+    previous: null,
+  };
+}
+
+export function normalizeWorkspaceContext(raw, workspaceRoot, flowName, flowJson = null) {
+  const base = buildDefaultWorkspaceContext(workspaceRoot, flowName, flowJson);
+  const parsed = parseJsonObject(raw);
+  if (!parsed) return base;
+  const cwdRaw = parsed.cwd || parsed.workspaceRoot || parsed.path || "";
+  const cwd = cwdRaw ? path.resolve(String(cwdRaw)) : base.cwd;
+  return {
+    ...base,
+    ...parsed,
+    version: 1,
+    cwd,
+    workspaceRoot: cwd,
+    pipelineWorkspace: path.resolve(parsed.pipelineWorkspace || base.pipelineWorkspace),
+    flowDir: path.resolve(parsed.flowDir || base.flowDir),
+    previous: parsed.previous && typeof parsed.previous === "object" ? parsed.previous : null,
+  };
+}
+
+export function normalizeSkillsContext(raw) {
+  const parsed = parseJsonObject(raw);
+  if (!parsed) return null;
+  return {
+    version: 1,
+    ...parsed,
+    skills: Array.isArray(parsed.skills) ? parsed.skills : [],
+    skillKeys: Array.isArray(parsed.skillKeys) ? parsed.skillKeys : [],
+    sources: Array.isArray(parsed.sources) ? parsed.sources : [],
+    warnings: Array.isArray(parsed.warnings) ? parsed.warnings : [],
+  };
+}
+
+export function expandRuntimePlaceholders(text, workspaceContext, extra = {}) {
+  if (text == null) return "";
+  const raw = String(text).trim();
+  if (!raw) return "";
+  const values = {
+    workspaceRoot: workspaceContext.workspaceRoot || workspaceContext.cwd || "",
+    cwd: workspaceContext.cwd || workspaceContext.workspaceRoot || "",
+    pipelineWorkspace: workspaceContext.pipelineWorkspace || "",
+    flowDir: workspaceContext.flowDir || "",
+    ...extra,
+  };
+  return raw.replace(/\$\{([^}]+)\}/g, (_, key) => {
+    const k = String(key || "").trim();
+    return values[k] != null ? String(values[k]) : "";
+  });
+}
+
+export function resolveWorkspaceTarget(rawTarget, workspaceContext, extra = {}) {
+  const expanded = expandRuntimePlaceholders(rawTarget, workspaceContext, extra).trim();
+  if (!expanded || expanded === "pipeline" || expanded === "pipeline-workspace") {
+    return workspaceContext.pipelineWorkspace;
+  }
+  if (expanded === "current" || expanded === ".") return workspaceContext.cwd;
+  if (expanded === "flowDir") return workspaceContext.flowDir;
+  return path.isAbsolute(expanded) ? path.resolve(expanded) : path.resolve(workspaceContext.cwd, expanded);
+}
+
+export function scanSkillsFromPaths(paths, opts = {}) {
+  const sources = (paths || []).map((entry, index) => ({
+    source: entry.source || `runtime-${index}`,
+    sourceLabel: entry.sourceLabel || entry.label || entry.dir,
+    dir: path.resolve(entry.dir),
+    installedBy: entry.installedBy || "runtime",
+  }));
+  return listSkillsFromSources(sources, { ...opts, warnMissing: true });
+}
+
+export function parseSkillKeyList(raw) {
+  if (Array.isArray(raw)) return raw.map((x) => String(x || "").trim()).filter(Boolean);
+  return String(raw || "")
+    .split(/[\s,]+/)
+    .map((x) => x.trim())
+    .filter(Boolean);
+}
+
+function skillBodyFromRegistryItem(skill) {
+  return {
+    name: skill.name,
+    key: skill.key,
+    description: skill.description,
+    source: skill.source,
+    sourceLabel: skill.sourceLabel,
+    path: skill.path,
+    body: skill.body,
+  };
+}
+
+export function buildSkillsContextFromRegistry({ workspaceContext, skillKeys = [], mergeMode = "replace" }) {
+  const wc = workspaceContext;
+  const wanted = parseSkillKeyList(skillKeys);
+  const registryWorkspaceRoot = wc.pipelineWorkspace || wc.workspaceRoot || wc.cwd || process.cwd();
+  const registry = listSkills(PACKAGE_ROOT, registryWorkspaceRoot);
+  const skillBodies = [];
+  const warnings = [];
+  const seenKeys = new Set();
+
+  for (const raw of wanted) {
+    const key = String(raw || "").trim();
+    if (!key) continue;
+    const match = registry.find((skill) => skill.key === key || skill.name === key || skill.id === key);
+    if (!match) {
+      warnings.push(`skill not found: ${key}`);
+      continue;
+    }
+    const dedupeKey = match.key || match.path || match.name;
+    if (seenKeys.has(dedupeKey)) continue;
+    seenKeys.add(dedupeKey);
+    skillBodies.push(skillBodyFromRegistryItem(match));
+  }
+
+  return {
+    version: 1,
+    workspaceRoot: wc.workspaceRoot,
+    cwd: wc.cwd,
+    pipelineWorkspace: wc.pipelineWorkspace,
+    flowDir: wc.flowDir,
+    source: "public-registry",
+    mergeMode,
+    requestedSkillKeys: wanted,
+    skills: skillBodies.map(({ body, ...meta }) => meta),
+    skillKeys: skillBodies.map((s) => s.key),
+    sources: [...new Set(skillBodies.map((s) => s.sourceLabel || s.source || "").filter(Boolean))],
+    loadedCount: skillBodies.length,
+    warnings,
+    skillBodies,
+  };
+}
+
+export function buildSkillsContext({ workspaceContext, source = "current-workspace", paths = [], include = [], exclude = [], mergeMode = "replace" }) {
+  const wc = workspaceContext;
+  const sourcePaths = [];
+  const addWorkspace = (root, label) => {
+    sourcePaths.push(...workspaceSkillSources(root, label, label));
+  };
+  if (source === "pipeline-workspace") {
+    addWorkspace(wc.pipelineWorkspace, "pipeline");
+  } else if (source === "explicit-paths") {
+    for (const p of paths) {
+      const resolved = path.isAbsolute(p) ? path.resolve(p) : path.resolve(wc.cwd, p);
+      sourcePaths.push({ dir: resolved, label: "explicit" });
+    }
+  } else if (source === "all") {
+    addWorkspace(wc.cwd, "current");
+    if (path.resolve(wc.cwd) !== path.resolve(wc.pipelineWorkspace)) addWorkspace(wc.pipelineWorkspace, "pipeline");
+  } else {
+    addWorkspace(wc.cwd, "current");
+  }
+  const scanned = scanSkillsFromPaths(sourcePaths, { include, exclude });
+  return {
+    version: 1,
+    workspaceRoot: wc.workspaceRoot,
+    cwd: wc.cwd,
+    source,
+    mergeMode,
+    skills: scanned.skills.map(({ body, ...meta }) => meta),
+    skillKeys: scanned.skills.map((s) => s.key),
+    sources: sourcePaths.map((p) => p.dir),
+    loadedCount: scanned.skills.length,
+    warnings: scanned.warnings,
+    skillBodies: scanned.skills.map((s) => ({
+      name: s.name,
+      key: s.key,
+      description: s.description,
+      sourceLabel: s.sourceLabel,
+      path: s.path,
+      body: s.body,
+    })),
+  };
+}
+
+export function renderSkillsContextForPrompt(skillsContext) {
+  const ctx = normalizeSkillsContext(skillsContext);
+  if (!ctx || !Array.isArray(ctx.skillBodies) || ctx.skillBodies.length === 0) return "";
+  const blocks = ctx.skillBodies.slice(0, 20).map((skill) => {
+    const body = String(skill.body || "").trim();
+    return [
+      `### ${skill.name}`,
+      skill.description ? `说明：${skill.description}` : "",
+      `来源：${skill.path || skill.sourceLabel || ""}`,
+      "",
+      body.slice(0, 16000),
+    ].filter(Boolean).join("\n");
+  });
+  return ["## 已加载 Skills", "", ...blocks].join("\n\n");
+}

package/bin/lib/scheduler.mjs

@@ -9,9 +9,10 @@ import {
   readScheduleState,
   writeScheduleState,
 } from "./schedule-config.mjs";
-import { getRunDir, PACKAGE_ROOT } from "./paths.mjs";
+import { getAgentflowUserContexts, getRunDir, PACKAGE_ROOT } from "./paths.mjs";
 import { isApplyProcessAlive } from "./run-apply-active-lock.mjs";
 import { log } from "./log.mjs";
+import { readUserEnvObject } from "./user-env.mjs";
 import { writeResult } from "../pipeline/write-result.mjs";
 
 const DEFAULT_POLL_MS = 30_000;
@@ -92,13 +93,13 @@ function buildCliInputArgs(flowDir, presetName) {
   return args;
 }
 
-function hasHigherPriorityDuplicate(workspaceRoot, flow) {
+function hasHigherPriorityDuplicate(workspaceRoot, flow, opts = {}) {
   if ((flow.source || "user") !== "workspace") return false;
-  return listFlowsJson(workspaceRoot).some((f) => f.id === flow.id && !f.archived && (f.source || "user") === "user");
+  return listFlowsJson(workspaceRoot, opts).some((f) => f.id === flow.id && !f.archived && (f.source || "user") === "user");
 }
 
-function getLatestRunUuidForFlow(workspaceRoot, flowId) {
-  const runRoot = path.dirname(getRunDir(workspaceRoot, flowId, "00000000000000"));
+function getLatestRunUuidForFlow(workspaceRoot, flowId, opts = {}) {
+  const runRoot = path.dirname(getRunDir(workspaceRoot, flowId, "00000000000000", opts));
   if (!fs.existsSync(runRoot)) return null;
   try {
     const dirs = fs.readdirSync(runRoot, { withFileTypes: true })
@@ -209,13 +210,13 @@ function readNodeResultStatus(runDir, instanceId) {
   }
 }
 
-function isFlowCurrentlyRunning(workspaceRoot, flowId, state) {
+function isFlowCurrentlyRunning(workspaceRoot, flowId, state, opts = {}) {
   const candidates = [];
   if (state && typeof state.lastRunUuid === "string") candidates.push(state.lastRunUuid);
-  const latest = getLatestRunUuidForFlow(workspaceRoot, flowId);
+  const latest = getLatestRunUuidForFlow(workspaceRoot, flowId, opts);
   if (latest) candidates.push(latest);
   for (const uuid of candidates) {
-    const runDir = getRunDir(workspaceRoot, flowId, uuid);
+    const runDir = getRunDir(workspaceRoot, flowId, uuid, opts);
     if (isApplyProcessAlive(runDir)) return true;
   }
   return false;
@@ -231,7 +232,7 @@ function baseState(flow, schedule, previousState) {
   };
 }
 
-function ensureNextRunAt(workspaceRoot, flow, schedule, state) {
+function ensureNextRunAt(workspaceRoot, flow, schedule, state, opts = {}) {
   const identity = scheduleIdentity(schedule);
   if (state.scheduleIdentity === identity && state.nextRunAt) return state;
   const nextRunAt = schedule.enabled && schedule.cron ? computeNextRunAtFromSchedule(schedule) : null;
@@ -240,11 +241,11 @@ function ensureNextRunAt(workspaceRoot, flow, schedule, state) {
     nextRunAt,
     lastError: "",
   };
-  writeScheduleState(workspaceRoot, flow.id, flow.source || "user", next);
+  writeScheduleState(workspaceRoot, flow.id, flow.source || "user", next, opts);
   return next;
 }
 
-function startScheduledRun(workspaceRoot, flow, schedule, state) {
+function startScheduledRun(workspaceRoot, flow, schedule, state, opts = {}) {
   const flowDir = flow.path || "";
   const agentflowBin = path.join(PACKAGE_ROOT, "bin", "agentflow.mjs");
   const args = [agentflowBin, "apply", flow.id, "--machine-readable", "--workspace-root", path.resolve(workspaceRoot), "--force"];
@@ -252,7 +253,7 @@ function startScheduledRun(workspaceRoot, flow, schedule, state) {
   const child = spawn(process.execPath, args, {
     cwd: path.resolve(workspaceRoot),
     stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, FORCE_COLOR: "0" },
+    env: { ...process.env, ...readUserEnvObject(opts.userId), FORCE_COLOR: "0", AGENTFLOW_USER_ID: opts.userId || "" },
     detached: true,
   });
 
@@ -276,7 +277,7 @@ function startScheduledRun(workspaceRoot, flow, schedule, state) {
             lastRunUuid,
             lastPid: child.pid || null,
             lastError: "",
-          });
+          }, opts);
         }
       } catch {
         /* ignore non-json lines */
@@ -290,7 +291,7 @@ function startScheduledRun(workspaceRoot, flow, schedule, state) {
   });
 
   child.on("exit", (code, signal) => {
-    const prev = readScheduleState(workspaceRoot, flow.id, flow.source || "user").state || state;
+    const prev = readScheduleState(workspaceRoot, flow.id, flow.source || "user", opts).state || state;
     writeScheduleState(workspaceRoot, flow.id, flow.source || "user", {
       ...baseState(flow, schedule, prev),
       nextRunAt: prev.nextRunAt || computeNextRunAtFromSchedule(schedule),
@@ -300,14 +301,14 @@ function startScheduledRun(workspaceRoot, flow, schedule, state) {
       lastExitSignal: signal || "",
       lastFinishedAt: new Date().toISOString(),
       lastError: code === 0 ? "" : `scheduled run exited with code ${code}${signal ? ` signal ${signal}` : ""}`,
-    });
+    }, opts);
   });
 
   child.unref();
   return child;
 }
 
-function startWaitingRunResume(workspaceRoot, flow, waitState) {
+function startWaitingRunResume(workspaceRoot, flow, waitState, opts = {}) {
   const agentflowBin = path.join(PACKAGE_ROOT, "bin", "agentflow.mjs");
   const uuid = String(waitState.uuid || "");
   const instanceId = String(waitState.instanceId || "");
@@ -325,7 +326,7 @@ function startWaitingRunResume(workspaceRoot, flow, waitState) {
   const child = spawn(process.execPath, args, {
     cwd: path.resolve(workspaceRoot),
     stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, FORCE_COLOR: "0" },
+    env: { ...process.env, ...readUserEnvObject(opts.userId), FORCE_COLOR: "0", AGENTFLOW_USER_ID: opts.userId || "" },
     detached: true,
   });
   child.stdout.on("data", () => {});
@@ -411,17 +412,17 @@ export function cancelScheduledRun(workspaceRoot, flowId, uuid) {
   return { ok: true, flowId, uuid, cancelledAt, updatedWaits: updated, propagatedWaits: propagated, resumePid };
 }
 
-export function listScheduleStatuses(workspaceRoot) {
+export function listScheduleStatuses(workspaceRoot, opts = {}) {
   const rows = [];
-  for (const flow of listFlowsJson(workspaceRoot)) {
+  for (const flow of listFlowsJson(workspaceRoot, opts)) {
     if (flow.archived || flow.source === "builtin") continue;
-    const scheduleRes = readFlowSchedule(workspaceRoot, flow.id, flow.source || "user");
+    const scheduleRes = readFlowSchedule(workspaceRoot, flow.id, flow.source || "user", opts);
     if (!scheduleRes.success) {
       rows.push({ flowId: flow.id, flowSource: flow.source || "user", enabled: false, error: scheduleRes.error });
       continue;
     }
     const schedule = scheduleRes.schedule;
-    const stateRes = readScheduleState(workspaceRoot, flow.id, flow.source || "user");
+    const stateRes = readScheduleState(workspaceRoot, flow.id, flow.source || "user", opts);
     const state = stateRes.success ? stateRes.state : {};
     rows.push({
       flowId: flow.id,
@@ -433,10 +434,10 @@ export function listScheduleStatuses(workspaceRoot) {
       nextRunAt: state.nextRunAt || schedule.nextRunAt || null,
       lastTriggeredAt: state.lastTriggeredAt || null,
       lastRunUuid: state.lastRunUuid || null,
-      lastError: hasHigherPriorityDuplicate(workspaceRoot, flow)
+      lastError: hasHigherPriorityDuplicate(workspaceRoot, flow, opts)
         ? "workspace flow is shadowed by a user flow with the same id"
         : state.lastError || "",
-      running: isFlowCurrentlyRunning(workspaceRoot, flow.id, state),
+      running: isFlowCurrentlyRunning(workspaceRoot, flow.id, state, opts),
       waiting: countActiveWaitsForFlow(flow),
     });
   }
@@ -454,7 +455,9 @@ export async function startScheduler(workspaceRoot, opts = {}) {
   log.info(`AgentFlow scheduler started. workspace=${path.resolve(workspaceRoot)} poll=${pollMs}ms`);
   while (true) {
     const now = Date.now();
-    for (const flow of listFlowsJson(workspaceRoot)) {
+    const contexts = opts.userId ? [{ userId: opts.userId }] : getAgentflowUserContexts();
+    for (const scheduleCtx of contexts) {
+    for (const flow of listFlowsJson(workspaceRoot, scheduleCtx)) {
       if (flow.archived || flow.source === "builtin") continue;
       const flowSource = flow.source || "user";
       let resumedWaitingRun = false;
@@ -462,7 +465,7 @@ export async function startScheduler(workspaceRoot, opts = {}) {
         if (resumedWaitingRun) break;
         for (const waitState of readWaitStates(run.runDir)) {
           if (!waitState || !waitState.wakeAt || !waitState.instanceId) continue;
-          if (waitState.status === "resuming" && !isFlowCurrentlyRunning(workspaceRoot, flow.id, { lastRunUuid: run.uuid })) {
+          if (waitState.status === "resuming" && !isFlowCurrentlyRunning(workspaceRoot, flow.id, { lastRunUuid: run.uuid }, scheduleCtx)) {
             const nodeStatus = readNodeResultStatus(run.runDir, String(waitState.instanceId));
             writeWaitState(waitState, {
               status: nodeStatus === "pending" ? "waiting" : "resumed",
@@ -472,7 +475,7 @@ export async function startScheduler(workspaceRoot, opts = {}) {
           }
           if (waitState.status !== "waiting") continue;
           if (Date.parse(waitState.wakeAt) > now) continue;
-          if (isFlowCurrentlyRunning(workspaceRoot, flow.id, { lastRunUuid: run.uuid })) continue;
+          if (isFlowCurrentlyRunning(workspaceRoot, flow.id, { lastRunUuid: run.uuid }, scheduleCtx)) continue;
           const nextState = {
             ...waitState,
             status: "resuming",
@@ -480,7 +483,7 @@ export async function startScheduler(workspaceRoot, opts = {}) {
             resumeStartedAt: new Date().toISOString(),
           };
           try {
-            const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid: run.uuid, runDir: run.runDir });
+            const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid: run.uuid, runDir: run.runDir }, scheduleCtx);
             nextState.resumePid = child.pid || null;
             writeWaitState(waitState, nextState);
             resumedWaitingRun = true;
@@ -497,41 +500,41 @@ export async function startScheduler(workspaceRoot, opts = {}) {
         }
       }
 
-      const scheduleRes = readFlowSchedule(workspaceRoot, flow.id, flowSource);
+      const scheduleRes = readFlowSchedule(workspaceRoot, flow.id, flowSource, scheduleCtx);
       if (!scheduleRes.success) {
         log.debug(`[scheduler] ${flow.id}: ${scheduleRes.error}`);
         continue;
       }
       const schedule = scheduleRes.schedule;
       if (!schedule.enabled || !schedule.cron) continue;
-      if (hasHigherPriorityDuplicate(workspaceRoot, flow)) {
-        const stateRes = readScheduleState(workspaceRoot, flow.id, flowSource);
+      if (hasHigherPriorityDuplicate(workspaceRoot, flow, scheduleCtx)) {
+        const stateRes = readScheduleState(workspaceRoot, flow.id, flowSource, scheduleCtx);
         writeScheduleState(workspaceRoot, flow.id, flowSource, {
           ...baseState(flow, schedule, stateRes.success ? stateRes.state : {}),
           nextRunAt: null,
           lastError: "workspace flow is shadowed by a user flow with the same id; scheduled run skipped",
           lastErrorAt: new Date().toISOString(),
-        });
+        }, scheduleCtx);
         continue;
       }
-      const stateRes = readScheduleState(workspaceRoot, flow.id, flowSource);
-      let state = ensureNextRunAt(workspaceRoot, flow, schedule, stateRes.success ? stateRes.state : {});
+      const stateRes = readScheduleState(workspaceRoot, flow.id, flowSource, scheduleCtx);
+      let state = ensureNextRunAt(workspaceRoot, flow, schedule, stateRes.success ? stateRes.state : {}, scheduleCtx);
       if (!state.nextRunAt || Date.parse(state.nextRunAt) > now) continue;
 
-      if (isFlowCurrentlyRunning(workspaceRoot, flow.id, state)) {
+      if (isFlowCurrentlyRunning(workspaceRoot, flow.id, state, scheduleCtx)) {
         const nextRunAt = computeNextRunAtFromSchedule(schedule);
         writeScheduleState(workspaceRoot, flow.id, flowSource, {
           ...baseState(flow, schedule, state),
           nextRunAt,
           lastSkippedAt: new Date().toISOString(),
           lastSkipReason: "running",
-        });
+        }, scheduleCtx);
         log.info(`[scheduler] skip ${flow.id}: already running; next=${nextRunAt}`);
         continue;
       }
 
       try {
-        const child = startScheduledRun(workspaceRoot, flow, schedule, state);
+        const child = startScheduledRun(workspaceRoot, flow, schedule, state, scheduleCtx);
         const nextRunAt = computeNextRunAtFromSchedule(schedule);
         writeScheduleState(workspaceRoot, flow.id, flowSource, {
           ...baseState(flow, schedule, state),
@@ -539,7 +542,7 @@ export async function startScheduler(workspaceRoot, opts = {}) {
           lastTriggeredAt: new Date().toISOString(),
           lastPid: child.pid || null,
           lastError: "",
-        });
+        }, scheduleCtx);
         log.info(`[scheduler] triggered ${flow.id}; pid=${child.pid || "?"}; next=${nextRunAt}`);
       } catch (e) {
         const nextRunAt = computeNextRunAtFromSchedule(schedule);
@@ -548,10 +551,11 @@ export async function startScheduler(workspaceRoot, opts = {}) {
           nextRunAt,
           lastError: e && e.message ? e.message : String(e),
           lastErrorAt: new Date().toISOString(),
-        });
+        }, scheduleCtx);
         log.info(`[scheduler] failed ${flow.id}: ${e && e.message ? e.message : String(e)}`);
       }
     }
+    }
     if (once) return;
     await sleep(pollMs);
   }