comisai 1.0.37 → 1.0.40

package/node_modules/@comis/daemon/dist/device/device-pairing.js

@@ -10,7 +10,7 @@
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import { ok, err, tryCatch } from "@comis/shared";
-import { safePath } from "@comis/core";
+import { safePath, systemNowMs } from "@comis/core";
 // ---------------------------------------------------------------------------
 // Defaults
 // ---------------------------------------------------------------------------
@@ -110,14 +110,14 @@ export function createDevicePairing(deps) {
         return writeJsonFileAtomic(pairedPath, items);
     }
     function filterExpired(items) {
-        const now = Date.now();
+        const now = systemNowMs();
         return items.filter((r) => r.requestedAtMs + ttlMs > now);
     }
     function generateToken() {
         return crypto.randomBytes(32).toString("hex");
     }
     function createPairedDevice(req, opts) {
-        const now = Date.now();
+        const now = systemNowMs();
         const token = generateToken();
         return {
             deviceId: req.deviceId,

package/node_modules/@comis/daemon/dist/graph/graph-cleanup.js

@@ -6,6 +6,7 @@
  * from the coordinator's map.
  * @module
  */
+import { systemNowMs, systemClearTimeout } from "@comis/core";
 // ---------------------------------------------------------------------------
 // Timer cleanup
 // ---------------------------------------------------------------------------
@@ -15,16 +16,16 @@
  */
 export function clearAllTimers(deps, gs) {
     for (const timer of gs.nodeTimers.values()) {
-        clearTimeout(timer);
+        systemClearTimeout(timer);
     }
     gs.nodeTimers.clear();
     // Clear retry timers
     for (const timer of gs.retryTimers.values()) {
-        clearTimeout(timer);
+        systemClearTimeout(timer);
     }
     gs.retryTimers.clear();
     if (gs.graphTimer !== undefined) {
-        clearTimeout(gs.graphTimer);
+        systemClearTimeout(gs.graphTimer);
         gs.graphTimer = undefined;
     }
     // Clean up driver state
@@ -50,7 +51,7 @@ export function clearAllTimers(deps, gs) {
  * Also enforces the MAX_GRAPHS cap by removing oldest completed first.
  */
 export function sweepExpiredGraphs(state, config) {
-    const now = Date.now();
+    const now = systemNowMs();
     for (const [graphId, gs] of state.graphs) {
         if (gs.completedAt !== undefined && now - gs.completedAt > config.graphRetentionMs) {
             state.graphs.delete(graphId);

package/node_modules/@comis/daemon/dist/graph/graph-completion.js

@@ -7,10 +7,10 @@
  * exceeded handling, and graph-level timeout cancellation.
  * @module
  */
+import { safePath, systemNowMs, systemDateFrom, systemScheduleTimeout } from "@comis/core";
 import { withTimeout } from "@comis/shared";
 import { writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { ANNOUNCE_PARENT_TIMEOUT_MS } from "../sub-agent-runner.js";
+import { ANNOUNCE_PARENT_TIMEOUT_MS } from "@comis/agent";
 import { clearAllTimers } from "./graph-cleanup.js";
 // ---------------------------------------------------------------------------
 // Graph completion
@@ -28,7 +28,7 @@ export function handleGraphCompletion(state, deps, gs) {
         deps.touchParentSession?.(gs.callerSessionKey);
     }
     // 1. Mark completion time
-    gs.completedAt = Date.now();
+    gs.completedAt = systemNowMs();
     // 1b. Clean up event-driven spawn gate on completion
     gs.cacheWarmCleanup?.();
     // 2. Clear all timers
@@ -74,7 +74,7 @@ export function handleGraphCompletion(state, deps, gs) {
         nodesFailed,
         nodesSkipped,
         ...(gs.cancelReason !== undefined && { cancelReason: gs.cancelReason }),
-        timestamp: Date.now(),
+        timestamp: systemNowMs(),
         // 3.3: Graph-level cache aggregation
         ...cacheRollupFields,
     });
@@ -115,7 +115,7 @@ export function handleGraphCompletion(state, deps, gs) {
                         userId: gs.callerAgentId,
                         channelId: gs.callerSessionKey,
                     };
-                    withTimeout(deps.announceToParent(gs.callerAgentId, sessionKey, announcement, gs.announceChannelType, gs.announceChannelId), ANNOUNCE_PARENT_TIMEOUT_MS, "graph announceToParent").catch((announceErr) => {
+                    withTimeout(deps.announceToParent(gs.callerAgentId, sessionKey, announcement, gs.announceChannelType, gs.announceChannelId), ANNOUNCE_PARENT_TIMEOUT_MS, systemScheduleTimeout, "graph announceToParent").catch((announceErr) => {
                         deps.logger?.warn({ graphId: gs.graphId, err: announceErr, hint: "Parent announcement failed; falling back to direct channel send", errorKind: "internal" }, "Graph parent announcement failed");
                         deps.sendToChannel(gs.announceChannelType, gs.announceChannelId, announcement, buttonOpts).catch((sendErr) => {
                             deps.logger?.warn({ graphId: gs.graphId, err: sendErr, hint: "Failed to announce graph result to channel", errorKind: "network" }, "Graph announcement delivery failed");
@@ -234,7 +234,7 @@ export function buildGraphAnnouncement(gs) {
     const maxAnnouncementChars = gs.maxAnnouncementChars ?? 3000;
     const snap = gs.stateMachine.snapshot();
     const label = gs.graph.graph.label ?? gs.graphId;
-    const durationMs = (gs.completedAt ?? Date.now()) - gs.startedAt;
+    const durationMs = (gs.completedAt ?? systemNowMs()) - gs.startedAt;
     // Identify leaf nodes — nodes that no other node depends on
     const depTargets = new Set(gs.graph.graph.nodes.flatMap(n => n.dependsOn));
     const leafNodeIds = new Set(gs.graph.graph.nodes
@@ -342,7 +342,7 @@ export function handleBudgetExceeded(state, deps, gs, reason) {
         gs.stateMachine.cancel();
     }
     handleGraphCompletion(state, deps, gs);
-    deps.logger?.warn({ graphId: gs.graphId, cumulativeTokens: gs.cumulativeTokens, cumulativeCost: gs.cumulativeCost, hint: "Graph budget is configurable via graph.budget.maxTokens/maxCost", errorKind: "budget" }, "Graph execution budget exceeded");
+    deps.logger?.warn({ graphId: gs.graphId, cumulativeTokens: gs.cumulativeTokens, cumulativeCost: gs.cumulativeCost, hint: "Graph budget is configurable via graph.budget.maxTokens/maxCost", errorKind: "resource" }, "Graph execution budget exceeded");
 }
 // ---------------------------------------------------------------------------
 // Graph timeout
@@ -454,9 +454,9 @@ export function writeRunMetadata(deps, gs) {
         const metadata = {
             graphId: gs.graphId,
             graphName: gs.graph.graph.label ?? gs.graphId,
-            startedAt: new Date(gs.startedAt).toISOString(),
-            completedAt: new Date(gs.completedAt ?? Date.now()).toISOString(),
-            durationMs: (gs.completedAt ?? Date.now()) - gs.startedAt,
+            startedAt: systemDateFrom(gs.startedAt).toISOString(),
+            completedAt: systemDateFrom(gs.completedAt ?? systemNowMs()).toISOString(),
+            durationMs: (gs.completedAt ?? systemNowMs()) - gs.startedAt,
             status: gs.stateMachine.getGraphStatus(),
             traceId: gs.graphTraceId,
             nodesTotal: gs.graph.graph.nodes.length,
@@ -470,7 +470,7 @@ export function writeRunMetadata(deps, gs) {
             ...(Object.keys(degradedNodes).length > 0 && { degradedNodes }),
             nodes: nodesMap,
         };
-        writeFileSync(join(gs.sharedDir, "_run-metadata.json"), JSON.stringify(metadata, null, 2), "utf8");
+        writeFileSync(safePath(gs.sharedDir, "_run-metadata.json"), JSON.stringify(metadata, null, 2), "utf8");
     }
     catch (writeErr) {
         deps.logger?.debug({ graphId: gs.graphId, err: writeErr }, "Failed to write _run-metadata.json (non-critical)");

package/node_modules/@comis/daemon/dist/graph/graph-coordinator-state.d.ts

@@ -7,7 +7,7 @@
  */
 import type { GraphStateMachine } from "./graph-state-machine.js";
 import type { ValidatedGraph, SessionKey, TypedEventBus, NodeTypeDriver, NodeDriverContext, NormalizedMessage } from "@comis/core";
-import type { AnnouncementBatcher } from "../announcement-batcher.js";
+import type { AnnouncementBatcher } from "@comis/orchestrator";
 /**
  * Per-graph run state. Tracks all mutable data for a single graph execution:
  * node mapping, timers, outputs, concurrency counters, driver states, etc.

package/node_modules/@comis/daemon/dist/graph/graph-coordinator.d.ts

@@ -5,7 +5,7 @@
  * @module
  */
 import { type GraphExecutionSnapshot } from "./graph-state-machine.js";
-import type { GraphStatus } from "@comis/core";
+import { type GraphStatus } from "@comis/core";
 import { type Result } from "@comis/shared";
 export type { GraphCoordinatorDeps, GraphRunState, CoordinatorSharedState, CoordinatorConfig } from "./graph-coordinator-state.js";
 import type { GraphCoordinatorDeps } from "./graph-coordinator-state.js";

package/node_modules/@comis/daemon/dist/graph/graph-coordinator.js

@@ -6,13 +6,13 @@
  * @module
  */
 import { createGraphStateMachine } from "./graph-state-machine.js";
+import { safePath, systemNowMs, systemSetInterval, systemClearInterval, systemSetTimeout } from "@comis/core";
 import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
-import { join } from "node:path";
 import { ok, err } from "@comis/shared";
 import { computeGraphToolSuperset } from "./graph-tool-superset.js";
 import { preWarmGraphCache } from "./graph-prewarm.js";
-import { getModel, completeSimple } from "@mariozechner/pi-ai";
+import { getModel, completeSimple } from "@earendil-works/pi-ai";
 // Module imports
 import { globalCompletionHandler, releaseAndDrainQueue } from "./graph-concurrency.js";
 import { spawnNode as spawnNodeFn, spawnReadyNodes as spawnReadyNodesFn, startDriverNode as startDriverNodeFn, markNodeFailed as markNodeFailedFn, handleSubAgentCompleted as handleSubAgentCompletedFn, } from "./graph-node-lifecycle.js";
@@ -82,7 +82,7 @@ export function createGraphCoordinator(deps) {
     }
     deps.eventBus.on("session:sub_agent_completed", onSubAgentCompleted);
     // Sweep interval: remove expired completed graphs
-    const sweepInterval = setInterval(() => {
+    const sweepInterval = systemSetInterval(() => {
         sweepExpiredGraphs(state, config);
     }, config.sweepIntervalMs);
     sweepInterval.unref();
@@ -90,7 +90,7 @@ export function createGraphCoordinator(deps) {
     async function run(params) {
         const graphId = randomUUID();
         const graphTraceId = randomUUID();
-        const sharedDir = join(deps.dataDir, "graph-runs", graphId);
+        const sharedDir = safePath(deps.dataDir, "graph-runs", graphId);
         mkdirSync(sharedDir, { recursive: true, mode: 0o700 });
         if (state.graphs.size >= config.maxGraphs) {
             sweepExpiredGraphs(state, config);
@@ -109,7 +109,7 @@ export function createGraphCoordinator(deps) {
             nodeTimers: new Map(),
             retryTimers: new Map(),
             graphTimer: undefined,
-            startedAt: Date.now(),
+            startedAt: systemNowMs(),
             runningCount: 0,
             callerSessionKey: params.callerSessionKey,
             callerAgentId: params.callerAgentId,
@@ -158,18 +158,18 @@ export function createGraphCoordinator(deps) {
                 graphId,
                 callerSessionKey: params.callerSessionKey,
                 hint: "Graph has no announce channel — completion results will not be delivered to user",
-                errorKind: "configuration",
+                errorKind: "config",
             }, "Graph created without announce channel");
         }
         deps.eventBus.emit("graph:started", {
             graphId,
             label: params.graph.graph.label,
             nodeCount: params.graph.graph.nodes.length,
-            timestamp: Date.now(),
+            timestamp: systemNowMs(),
         });
         deps.logger?.info({ graphId, graphTraceId, nodeCount: params.graph.graph.nodes.length }, "Graph run assigned traceId for sub-agent correlation");
         if (params.graph.graph.timeoutMs !== undefined && params.graph.graph.timeoutMs > 0) {
-            gs.graphTimer = setTimeout(() => handleGraphTimeoutFn(state, deps, gs), params.graph.graph.timeoutMs);
+            gs.graphTimer = systemSetTimeout(() => handleGraphTimeoutFn(state, deps, gs), params.graph.graph.timeoutMs);
             if (typeof gs.graphTimer === "object" && "unref" in gs.graphTimer) {
                 gs.graphTimer.unref();
             }
@@ -271,7 +271,7 @@ export function createGraphCoordinator(deps) {
     }
     function listGraphs(recentMinutes) {
         const cutoff = recentMinutes && recentMinutes > 0
-            ? Date.now() - recentMinutes * 60_000
+            ? systemNowMs() - recentMinutes * 60_000
             : 0;
         return [...state.graphs.values()]
             .filter((gs) => gs.startedAt >= cutoff)
@@ -313,13 +313,13 @@ export function createGraphCoordinator(deps) {
                 gs.syntheticRunResults.clear();
                 gs.stateMachine.cancel();
                 clearAllTimers(deps, gs);
-                gs.completedAt = Date.now();
+                gs.completedAt = systemNowMs();
             }
         }
         // Clear spawn queue and reset global counter
         state.spawnQueue.length = 0;
         state.globalActiveSubAgents = 0;
-        clearInterval(sweepInterval);
+        systemClearInterval(sweepInterval);
     }
     function getConcurrencyStats() {
         return { globalActiveSubAgents: state.globalActiveSubAgents, maxGlobalSubAgents: config.maxGlobalSubAgents, queueDepth: state.spawnQueue.length };

package/node_modules/@comis/daemon/dist/graph/graph-driver-handler.js

@@ -6,10 +6,9 @@
  * wait, wait_for_input, progress), and parallel turn aggregation.
  * @module
  */
-import { parseFormattedSessionKey, } from "@comis/core";
+import { parseFormattedSessionKey, safePath, systemNowMs, systemSetTimeout, systemClearTimeout, } from "@comis/core";
 import { suppressError } from "@comis/shared";
 import { writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { gatedSpawn } from "./graph-concurrency.js";
 import { resolveFileReferenceOutput, persistArtifacts } from "./graph-node-lifecycle.js";
 // ---------------------------------------------------------------------------
@@ -69,7 +68,7 @@ export function handleDriverTurnCompleted(state, deps, config, gs, nodeId, event
             gs.runningCount--;
             const timer = gs.nodeTimers.get(nodeId);
             if (timer) {
-                clearTimeout(timer);
+                systemClearTimeout(timer);
                 gs.nodeTimers.delete(nodeId);
             }
             callbacks.handleBudgetExceeded(gs, tokenExceeded ? "tokens" : "cost");
@@ -95,7 +94,7 @@ export function handleDriverTurnCompleted(state, deps, config, gs, nodeId, event
             // Persist partial output to shared dir
             if (gs.sharedDir) {
                 try {
-                    writeFileSync(join(gs.sharedDir, `${nodeId}-output.md`), partialOutput, "utf8");
+                    writeFileSync(safePath(gs.sharedDir, `${nodeId}-output.md`), partialOutput, "utf8");
                 }
                 catch { /* best-effort */ }
             }
@@ -104,7 +103,7 @@ export function handleDriverTurnCompleted(state, deps, config, gs, nodeId, event
             gs.runningCount--;
             const timer = gs.nodeTimers.get(nodeId);
             if (timer) {
-                clearTimeout(timer);
+                systemClearTimeout(timer);
                 gs.nodeTimers.delete(nodeId);
             }
             deps.eventBus.emit("graph:driver_lifecycle", {
@@ -118,7 +117,7 @@ export function handleDriverTurnCompleted(state, deps, config, gs, nodeId, event
                 graphId: gs.graphId,
                 nodeId,
                 status: "completed",
-                timestamp: Date.now(),
+                timestamp: systemNowMs(),
             });
             if (gs.stateMachine.isTerminal()) {
                 callbacks.handleGraphCompletion(gs);
@@ -138,7 +137,7 @@ export function handleDriverTurnCompleted(state, deps, config, gs, nodeId, event
         gs.runningCount--;
         const timer = gs.nodeTimers.get(nodeId);
         if (timer) {
-            clearTimeout(timer);
+            systemClearTimeout(timer);
             gs.nodeTimers.delete(nodeId);
         }
         gs.nodeOutputs.set(nodeId, output || undefined);
@@ -199,8 +198,8 @@ export function handleDriverTurnCompleted(state, deps, config, gs, nodeId, event
     if (timeoutMs > 0) {
         const existingTimer = gs.nodeTimers.get(nodeId);
         if (existingTimer)
-            clearTimeout(existingTimer);
-        const newTimer = setTimeout(() => handleDriverTimeout(state, deps, config, gs, nodeId, callbacks), timeoutMs);
+            systemClearTimeout(existingTimer);
+        const newTimer = systemSetTimeout(() => handleDriverTimeout(state, deps, config, gs, nodeId, callbacks), timeoutMs);
         if (typeof newTimer === "object" && "unref" in newTimer) {
             newTimer.unref();
         }
@@ -251,7 +250,7 @@ export function handleDriverTimeout(state, deps, config, gs, nodeId, callbacks)
         // Persist partial output to shared dir
         if (gs.sharedDir) {
             try {
-                writeFileSync(join(gs.sharedDir, `${nodeId}-output.md`), partialOutput, "utf8");
+                writeFileSync(safePath(gs.sharedDir, `${nodeId}-output.md`), partialOutput, "utf8");
             }
             catch { /* best-effort */ }
         }
@@ -276,7 +275,7 @@ export function handleDriverTimeout(state, deps, config, gs, nodeId, callbacks)
             graphId: gs.graphId,
             nodeId,
             status: "completed",
-            timestamp: Date.now(),
+            timestamp: systemNowMs(),
         });
         if (gs.stateMachine.isTerminal()) {
             callbacks.handleGraphCompletion(gs);
@@ -310,7 +309,7 @@ export function handleDriverTimeout(state, deps, config, gs, nodeId, callbacks)
         nodeId,
         status: "failed",
         error: "Driver node timeout",
-        timestamp: Date.now(),
+        timestamp: systemNowMs(),
     });
     if (gs.stateMachine.isTerminal()) {
         callbacks.handleGraphCompletion(gs);
@@ -359,12 +358,12 @@ export function handleWaitForInput(state, deps, config, gs, nodeId, action, call
         // Clear timeout and reminder timers
         const timeoutTimer = gs.nodeTimers.get(`${nodeId}:wait_timeout`);
         if (timeoutTimer) {
-            clearTimeout(timeoutTimer);
+            systemClearTimeout(timeoutTimer);
             gs.nodeTimers.delete(`${nodeId}:wait_timeout`);
         }
         const reminderTimer = gs.nodeTimers.get(`${nodeId}:wait_reminder`);
         if (reminderTimer) {
-            clearTimeout(reminderTimer);
+            systemClearTimeout(reminderTimer);
             gs.nodeTimers.delete(`${nodeId}:wait_reminder`);
         }
         // Store the reply text for pickup in handleDriverTurnCompleted
@@ -386,7 +385,7 @@ export function handleWaitForInput(state, deps, config, gs, nodeId, action, call
     // 3. Set up 50% reminder timer
     const reminderMs = Math.floor(action.timeoutMs * 0.5);
     if (reminderMs > 0) {
-        const reminderTimer = setTimeout(() => {
+        const reminderTimer = systemSetTimeout(() => {
             if (!gs.waitHandlers.has(nodeId))
                 return;
             if (gs.announceChannelType && gs.announceChannelId) {
@@ -400,14 +399,14 @@ export function handleWaitForInput(state, deps, config, gs, nodeId, action, call
         gs.nodeTimers.set(`${nodeId}:wait_reminder`, reminderTimer);
     }
     // 4. Set up timeout timer
-    const timeoutTimer = setTimeout(() => {
+    const timeoutTimer = systemSetTimeout(() => {
         if (!gs.waitHandlers.has(nodeId))
             return;
         deps.eventBus.off("message:received", handler);
         gs.waitHandlers.delete(nodeId);
         const rTimer = gs.nodeTimers.get(`${nodeId}:wait_reminder`);
         if (rTimer) {
-            clearTimeout(rTimer);
+            systemClearTimeout(rTimer);
             gs.nodeTimers.delete(`${nodeId}:wait_reminder`);
         }
         gs.nodeTimers.delete(`${nodeId}:wait_timeout`);
@@ -492,7 +491,7 @@ export function executeDriverAction(state, deps, config, gs, nodeId, action, cal
             // Cap at maxParallelSpawns
             let spawns = action.spawns;
             if (spawns.length > config.maxParallelSpawns) {
-                deps.logger?.warn({ graphId: gs.graphId, nodeId, requested: spawns.length, max: config.maxParallelSpawns, hint: "spawn_all array truncated to maxParallelSpawns", errorKind: "limit" }, "spawn_all exceeded maxParallelSpawns, truncating");
+                deps.logger?.warn({ graphId: gs.graphId, nodeId, requested: spawns.length, max: config.maxParallelSpawns, hint: "spawn_all array truncated to maxParallelSpawns", errorKind: "resource" }, "spawn_all exceeded maxParallelSpawns, truncating");
                 spawns = spawns.slice(0, config.maxParallelSpawns);
             }
             ds.pendingParallel = new Map();
@@ -529,7 +528,7 @@ export function executeDriverAction(state, deps, config, gs, nodeId, action, cal
             // Persist output to shared dir
             if (gs.sharedDir && output) {
                 try {
-                    writeFileSync(join(gs.sharedDir, `${nodeId}-output.md`), output, "utf8");
+                    writeFileSync(safePath(gs.sharedDir, `${nodeId}-output.md`), output, "utf8");
                 }
                 catch { /* best-effort */ }
             }
@@ -538,7 +537,7 @@ export function executeDriverAction(state, deps, config, gs, nodeId, action, cal
             gs.runningCount--;
             const timer = gs.nodeTimers.get(nodeId);
             if (timer) {
-                clearTimeout(timer);
+                systemClearTimeout(timer);
                 gs.nodeTimers.delete(nodeId);
             }
             deps.eventBus.emit("graph:driver_lifecycle", {
@@ -553,7 +552,7 @@ export function executeDriverAction(state, deps, config, gs, nodeId, action, cal
                 graphId: gs.graphId,
                 nodeId,
                 status: "completed",
-                timestamp: Date.now(),
+                timestamp: systemNowMs(),
             });
             deps.logger?.debug({ graphId: gs.graphId, nodeId, typeId: ds.driver.typeId }, "Driver node completed");
             if (gs.stateMachine.isTerminal()) {
@@ -576,7 +575,7 @@ export function executeDriverAction(state, deps, config, gs, nodeId, action, cal
             gs.runningCount--;
             const timer = gs.nodeTimers.get(nodeId);
             if (timer) {
-                clearTimeout(timer);
+                systemClearTimeout(timer);
                 gs.nodeTimers.delete(nodeId);
             }
             callbacks.markNodeFailed(gs, nodeId, action.error);

package/node_modules/@comis/daemon/dist/graph/graph-node-lifecycle.js

@@ -6,11 +6,10 @@
  * and sub-agent completion processing.
  * @module
  */
-import { safePath, } from "@comis/core";
+import { safePath, systemNowMs, systemSetTimeout, systemClearTimeout, } from "@comis/core";
 import { tryCatch } from "@comis/shared";
 import { sanitizeAssistantResponse } from "@comis/agent";
 import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { interpolateTaskText, buildContextEnvelope } from "./template-interpolation.js";
 import { gatedSpawn } from "./graph-concurrency.js";
 // ---------------------------------------------------------------------------
@@ -31,7 +30,7 @@ export function resolveFileReferenceOutput(output, sharedDir) {
     if (fileRef[0].endsWith("-output.md"))
         return output;
     try {
-        const candidatePath = join(sharedDir, fileRef[0]);
+        const candidatePath = safePath(sharedDir, fileRef[0]);
         if (!existsSync(candidatePath))
             return output;
         const fileContent = readFileSync(candidatePath, "utf8");
@@ -109,7 +108,7 @@ export function markNodeFailed(state, deps, gs, nodeId, error, callbacks) {
         nodeId,
         status: "failed",
         error,
-        timestamp: Date.now(),
+        timestamp: systemNowMs(),
     });
     deps.logger?.debug({ graphId: gs.graphId, nodeId, error }, "Node failed");
     // Handle retrying nodes
@@ -122,9 +121,9 @@ export function markNodeFailed(state, deps, gs, nodeId, error, callbacks) {
                 graphId: gs.graphId,
                 nodeId: retryNodeId,
                 status: "ready",
-                timestamp: Date.now(),
+                timestamp: systemNowMs(),
             });
-            const retryTimer = setTimeout(() => {
+            const retryTimer = systemSetTimeout(() => {
                 if (gs.stateMachine.isTerminal())
                     return;
                 const currentState = gs.stateMachine.getNodeState(retryNodeId);
@@ -147,7 +146,7 @@ export function markNodeFailed(state, deps, gs, nodeId, error, callbacks) {
                     graphId: gs.graphId,
                     nodeId: skippedId,
                     status: "skipped",
-                    timestamp: Date.now(),
+                    timestamp: systemNowMs(),
                 });
             }
         }
@@ -264,12 +263,12 @@ export function spawnNode(state, deps, config, gs, nodeId, callbacks) {
                 graphId: gs.graphId,
                 nodeId,
                 status: "running",
-                timestamp: Date.now(),
+                timestamp: systemNowMs(),
             });
         }
         gs.runningCount++;
         if (node.timeoutMs !== undefined && node.timeoutMs > 0) {
-            const timer = setTimeout(() => {
+            const timer = systemSetTimeout(() => {
                 const nodeState = gs.stateMachine.getNodeState(nodeId);
                 if (nodeState && nodeState.status === "running") {
                     deps.subAgentRunner.killRun(runId);
@@ -334,7 +333,7 @@ export function spawnReadyNodes(state, deps, config, gs, callbacks) {
             const capturedNodeId = nodeId;
             const capturedGs = gs;
             deps.logger?.debug({ graphId: gs.graphId, nodeId: capturedNodeId, delayMs, staggerIndex: i }, "Sub-agent spawn staggered for cache prefix sharing");
-            setTimeout(() => {
+            systemSetTimeout(() => {
                 // Guard against graph completion during stagger delay
                 if (capturedGs.completedAt !== undefined)
                     return;
@@ -392,7 +391,7 @@ export function startDriverNode(state, deps, gs, nodeId, node, driver, enveloped
             graphId: gs.graphId,
             nodeId,
             status: "running",
-            timestamp: Date.now(),
+            timestamp: systemNowMs(),
         });
     }
     gs.runningCount++;
@@ -406,7 +405,7 @@ export function startDriverNode(state, deps, gs, nodeId, node, driver, enveloped
     // 6. Set up per-node timeout using driver estimate or node config
     const timeoutMs = node.timeoutMs ?? driver.defaultTimeoutMs;
     if (timeoutMs > 0) {
-        const timer = setTimeout(() => {
+        const timer = systemSetTimeout(() => {
             callbacks.handleDriverTimeout(gs, nodeId);
         }, timeoutMs);
         if (typeof timer === "object" && "unref" in timer) {
@@ -443,7 +442,7 @@ export function handleSubAgentCompleted(state, deps, config, gs, event, callback
     // 4. Clear per-node timer if exists
     const timer = gs.nodeTimers.get(nodeId);
     if (timer !== undefined) {
-        clearTimeout(timer);
+        systemClearTimeout(timer);
         gs.nodeTimers.delete(nodeId);
     }
     // 4b. Capture per-node cache data
@@ -467,7 +466,7 @@ export function handleSubAgentCompleted(state, deps, config, gs, event, callback
     // 5c. Auto-persist full output to shared folder for file-reference overflow
     if (gs.sharedDir && output) {
         try {
-            writeFileSync(join(gs.sharedDir, `${nodeId}-output.md`), output, "utf8");
+            writeFileSync(safePath(gs.sharedDir, `${nodeId}-output.md`), output, "utf8");
         }
         catch { /* best-effort, don't block graph progress */ }
     }
@@ -507,9 +506,9 @@ export function handleSubAgentCompleted(state, deps, config, gs, event, callback
                     graphId: gs.graphId,
                     nodeId: retryNodeId,
                     status: "ready",
-                    timestamp: Date.now(),
+                    timestamp: systemNowMs(),
                 });
-                const retryTimer = setTimeout(() => {
+                const retryTimer = systemSetTimeout(() => {
                     if (gs.stateMachine.isTerminal())
                         return;
                     const currentState = gs.stateMachine.getNodeState(retryNodeId);
@@ -532,7 +531,7 @@ export function handleSubAgentCompleted(state, deps, config, gs, event, callback
                         graphId: gs.graphId,
                         nodeId: skippedId,
                         status: "skipped",
-                        timestamp: Date.now(),
+                        timestamp: systemNowMs(),
                     });
                 }
             }
@@ -563,9 +562,9 @@ export function handleSubAgentCompleted(state, deps, config, gs, event, callback
             graphId: gs.graphId,
             nodeId,
             status: nodeCompleted ? "completed" : "failed",
-            durationMs: finalNodeState?.startedAt ? Date.now() - finalNodeState.startedAt : undefined,
+            durationMs: finalNodeState?.startedAt ? systemNowMs() - finalNodeState.startedAt : undefined,
             error: nodeCompleted ? undefined : (run?.error ?? "Unknown error"),
-            timestamp: Date.now(),
+            timestamp: systemNowMs(),
         });
     }
     // 8. Log at DEBUG level
@@ -603,7 +602,7 @@ export function persistArtifacts(deps, gs, nodeId, artifacts) {
     for (const a of artifacts) {
         const safeResult = tryCatch(() => safePath(gs.sharedDir, a.filename));
         if (!safeResult.ok) {
-            deps.logger?.warn({ graphId: gs.graphId, nodeId, filename: a.filename, hint: "Artifact filename rejected by safePath", errorKind: "security" }, "Artifact filename rejected");
+            deps.logger?.warn({ graphId: gs.graphId, nodeId, filename: a.filename, hint: "Artifact filename rejected by safePath", errorKind: "validation" }, "Artifact filename rejected");
             continue;
         }
         writeFileSync(safeResult.value, a.content, "utf8");

package/node_modules/@comis/daemon/dist/graph/graph-prewarm.js

@@ -8,6 +8,7 @@
  * @module
  */
 import { fromPromise } from "@comis/shared";
+import { systemNowMs, systemSetTimeout, systemClearTimeout } from "@comis/core";
 /** Anthropic-family provider identifiers. */
 const ANTHROPIC_PROVIDERS = new Set(["anthropic"]);
 /** Minimum tool count to bother with pre-warm (cache minimum threshold heuristic). */
@@ -47,7 +48,7 @@ export async function preWarmGraphCache(deps, sdk) {
     }
     catch (modelErr) {
         const errorMsg = `Model resolution failed: ${modelErr instanceof Error ? modelErr.message : String(modelErr)}`;
-        deps.logger?.warn({ provider: deps.provider, modelId: deps.modelId, hint: "Pre-warm will be skipped; graph proceeds with event-driven stagger", errorKind: "configuration" }, `Pre-warm model resolution failed: ${errorMsg}`);
+        deps.logger?.warn({ provider: deps.provider, modelId: deps.modelId, hint: "Pre-warm will be skipped; graph proceeds with event-driven stagger", errorKind: "config" }, `Pre-warm model resolution failed: ${errorMsg}`);
         return { success: false, cacheWriteTokens: 0, tokensUsed: 0, cost: 0, error: errorMsg };
     }
     if (!model) {
@@ -57,7 +58,7 @@ export async function preWarmGraphCache(deps, sdk) {
     const context = {
         systemPrompt: deps.systemPrompt,
         messages: [
-            { role: "user", content: ".", timestamp: Date.now() },
+            { role: "user", content: ".", timestamp: systemNowMs() },
         ],
         tools: deps.tools.map((t) => ({
             name: t.name,
@@ -67,7 +68,7 @@ export async function preWarmGraphCache(deps, sdk) {
     };
     // Make the lightweight API call
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 15_000); // 15s timeout
+    const timer = systemSetTimeout(() => controller.abort(), 15_000); // 15s timeout
     const callResult = await fromPromise(sdk.completeSimple(model, context, {
         apiKey: deps.apiKey,
         maxTokens: 1,
@@ -75,7 +76,7 @@ export async function preWarmGraphCache(deps, sdk) {
         cacheRetention: "long",
         signal: controller.signal,
     }));
-    clearTimeout(timer);
+    systemClearTimeout(timer);
     if (!callResult.ok) {
         const errorMsg = callResult.error instanceof Error ? callResult.error.message : String(callResult.error);
         deps.logger?.warn({ provider: deps.provider, modelId: deps.modelId, err: callResult.error, hint: "Pre-warm failed; graph proceeds with event-driven stagger", errorKind: "network" }, `Pre-warm API call failed: ${errorMsg}`);