onbuzz 4.4.0 → 4.6.0

package/src/core/agentScheduler.js

@@ -1940,6 +1940,15 @@ class AgentScheduler {
         enhancedSystemPrompt = (enhancedSystemPrompt || '') + systemConstraints;
       }
 
+      // Inject current local time. Re-evaluated every turn so the agent
+      // always sees the wall-clock time the model is answering at — useful
+      // for time-sensitive reasoning (cron expressions, "schedule for
+      // tomorrow morning", "is it past business hours?", etc.).
+      const timeContext = this.contextInjectionService.buildCurrentTimeContext();
+      if (timeContext) {
+        enhancedSystemPrompt = (enhancedSystemPrompt || '') + timeContext;
+      }
+
       // Inject external-channel routing guidance ONLY when the agent has
       // at least one live bridge. Pulls the per-channel alias list from
       // each service so the agent can address specific channels/threads
@@ -1968,18 +1977,49 @@ class AgentScheduler {
       try {
         const lastUserMsg = [...conversationHistory].reverse().find(m => m.role === 'user');
         if (lastUserMsg?.isFlowExecution && lastUserMsg?.flowMetadata) {
-          const flowContext = this.flowContextService.buildFlowAgentContext(
+          // Phase 8: when running inside a flow, by default REPLACE the
+          // agent's persisted system prompt with a flow-worker prompt
+          // built from the node's role + contract. This prevents the
+          // agent's native identity (e.g. "you are a software developer")
+          // from fighting the flow's structured-output requirements.
+          //
+          // Opt-out: if the flow node sets useNativeSystemPrompt:true OR
+          // the node has no instructions/outputs to assert, fall back
+          // to legacy append-context behavior so v1 flows + curated
+          // single-purpose agents still work as before.
+          const opt = lastUserMsg.nodeContract?.useNativeSystemPrompt === true;
+          const replacement = opt ? null : this.flowContextService.buildFlowAgentSystemPrompt(
             lastUserMsg.flowMetadata,
-            lastUserMsg.previousAgentData
+            lastUserMsg.previousAgentData,
+            lastUserMsg.nodeContract
           );
 
-          if (flowContext) {
-            enhancedSystemPrompt = (enhancedSystemPrompt || '') + flowContext;
-            this.logger.info(`Injected flow execution context for agent ${agentId}`, {
+          if (replacement) {
+            // REPLACE mode — the flow node's role becomes the agent's
+            // identity for this turn. Agent's persisted prompt is
+            // intentionally discarded for this invocation only.
+            enhancedSystemPrompt = replacement;
+            this.logger.info(`Replaced system prompt with flow-worker prompt for agent ${agentId}`, {
               flowName: lastUserMsg.flowMetadata.flowName,
               nodePosition: `${lastUserMsg.flowMetadata.nodePosition}/${lastUserMsg.flowMetadata.totalNodes}`,
-              hasPreviousAgent: !!lastUserMsg.previousAgentData
+              hasPreviousAgent: !!lastUserMsg.previousAgentData,
+              promptLength: replacement.length,
             });
+          } else {
+            // APPEND mode (legacy) — used for v1 flows + opt-out cases.
+            const flowContext = this.flowContextService.buildFlowAgentContext(
+              lastUserMsg.flowMetadata,
+              lastUserMsg.previousAgentData,
+              lastUserMsg.nodeContract
+            );
+            if (flowContext) {
+              enhancedSystemPrompt = (enhancedSystemPrompt || '') + flowContext;
+              this.logger.info(`Appended flow execution context for agent ${agentId}`, {
+                flowName: lastUserMsg.flowMetadata.flowName,
+                nodePosition: `${lastUserMsg.flowMetadata.nodePosition}/${lastUserMsg.flowMetadata.totalNodes}`,
+                hasPreviousAgent: !!lastUserMsg.previousAgentData
+              });
+            }
           }
         }
       } catch (error) {

package/src/core/flowCheckpointStore.js

@@ -0,0 +1,146 @@
+/**
+ * FlowCheckpointStore — disk persistence for flow run state.
+ *
+ * Layout:
+ *   <baseDir>/<runId>/run.json         — top-level run metadata + nodeStates
+ *   <baseDir>/<runId>/node-<id>.json   — per-node recorded result
+ *
+ * Why per-node files: a single run.json rewritten after every node is
+ * fine for small flows but loses partial-write safety. Per-node files
+ * are written once per completion (atomic via tmp+rename) and let the
+ * resume path reconstruct progress even if run.json is missing or stale.
+ *
+ * API surface (intentionally narrow — pure data layer):
+ *   saveRun(run)                         → void
+ *   loadRun(runId)                       → run | null
+ *   saveNodeResult(runId, nodeId, value) → void
+ *   loadNodeResult(runId, nodeId)        → value | null
+ *   listNodeResults(runId)               → string[]
+ *   loadAllNodeResults(runId)            → { [nodeId]: value }
+ *   clearRun(runId)                      → void
+ */
+
+import path from 'path';
+import { promises as fs } from 'fs';
+
+// Filenames sanitize node IDs that contain slashes / colons / other
+// characters that aren't safe to drop into a path. We ALSO encode the
+// original id in the file content so loads round-trip exactly.
+function _safeName(s) {
+  return String(s).replace(/[^a-zA-Z0-9_.-]+/g, '_');
+}
+
+function _resolveRunDir(baseDir, runId) {
+  // Defense against ".." escapes — the resolved dir MUST stay under baseDir.
+  const safeId = _safeName(runId);
+  const dir = path.resolve(baseDir, safeId);
+  const baseResolved = path.resolve(baseDir);
+  if (!dir.startsWith(baseResolved + path.sep) && dir !== baseResolved) {
+    throw new Error(`runId resolves outside baseDir (refusing): ${runId}`);
+  }
+  // Also reject obviously-malicious raw inputs to give a clearer error.
+  if (typeof runId === 'string' && (runId.includes('..') || runId.startsWith('/') || runId.startsWith('\\'))) {
+    throw new Error(`runId must not contain "..", absolute path segments, or escape attempts: ${runId}`);
+  }
+  return dir;
+}
+
+async function _writeAtomic(filePath, json) {
+  const tmp = filePath + '.tmp-' + process.pid + '-' + Date.now();
+  await fs.writeFile(tmp, json, 'utf8');
+  await fs.rename(tmp, filePath);
+}
+
+export class FlowCheckpointStore {
+  constructor({ baseDir }) {
+    if (!baseDir || typeof baseDir !== 'string') {
+      throw new Error('FlowCheckpointStore requires a string baseDir');
+    }
+    this.baseDir = baseDir;
+  }
+
+  async saveRun(run) {
+    if (!run || typeof run.id !== 'string') {
+      throw new Error('saveRun requires run.id');
+    }
+    const dir = _resolveRunDir(this.baseDir, run.id);
+    await fs.mkdir(dir, { recursive: true });
+    await _writeAtomic(path.join(dir, 'run.json'), JSON.stringify(run, null, 2));
+  }
+
+  async loadRun(runId) {
+    const dir = _resolveRunDir(this.baseDir, runId);
+    try {
+      const raw = await fs.readFile(path.join(dir, 'run.json'), 'utf8');
+      return JSON.parse(raw);
+    } catch (e) {
+      if (e?.code === 'ENOENT') return null;
+      throw e;
+    }
+  }
+
+  /**
+   * Per-node result file. We store the original nodeId inside the JSON
+   * so listNodeResults can return the original ids regardless of how
+   * the filename was sanitized.
+   */
+  async saveNodeResult(runId, nodeId, value) {
+    const dir = _resolveRunDir(this.baseDir, runId);
+    await fs.mkdir(dir, { recursive: true });
+    const safe = _safeName(nodeId);
+    const fname = `node-${safe}.json`;
+    const payload = { nodeId, value };
+    await _writeAtomic(path.join(dir, fname), JSON.stringify(payload, null, 2));
+  }
+
+  async loadNodeResult(runId, nodeId) {
+    const dir = _resolveRunDir(this.baseDir, runId);
+    const safe = _safeName(nodeId);
+    try {
+      const raw = await fs.readFile(path.join(dir, `node-${safe}.json`), 'utf8');
+      const obj = JSON.parse(raw);
+      return obj && 'value' in obj ? obj.value : null;
+    } catch (e) {
+      if (e?.code === 'ENOENT') return null;
+      throw e;
+    }
+  }
+
+  async listNodeResults(runId) {
+    const dir = _resolveRunDir(this.baseDir, runId);
+    let entries;
+    try {
+      entries = await fs.readdir(dir);
+    } catch (e) {
+      if (e?.code === 'ENOENT') return [];
+      throw e;
+    }
+    const ids = [];
+    for (const name of entries) {
+      if (!name.startsWith('node-') || !name.endsWith('.json')) continue;
+      try {
+        const raw = await fs.readFile(path.join(dir, name), 'utf8');
+        const obj = JSON.parse(raw);
+        if (obj?.nodeId) ids.push(obj.nodeId);
+      } catch { /* skip unreadable entries */ }
+    }
+    return ids;
+  }
+
+  async loadAllNodeResults(runId) {
+    const ids = await this.listNodeResults(runId);
+    const out = {};
+    for (const id of ids) {
+      const v = await this.loadNodeResult(runId, id);
+      if (v !== null) out[id] = v;
+    }
+    return out;
+  }
+
+  async clearRun(runId) {
+    const dir = _resolveRunDir(this.baseDir, runId);
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+export default FlowCheckpointStore;