@femtomc/mu-server 26.2.120 → 26.3.2

package/dist/api/heartbeats.js

@@ -36,6 +36,39 @@ export async function heartbeatRoutes(request, url, deps, headers) {
         if ("prompt" in body && typeof body.prompt !== "string" && body.prompt !== null) {
             return Response.json({ error: "prompt must be string or null" }, { status: 400, headers });
         }
+        const parseNullableString = (value) => {
+            if (value === undefined)
+                return undefined;
+            if (value === null)
+                return null;
+            if (typeof value === "string")
+                return value;
+            return undefined;
+        };
+        const operatorProvider = parseNullableString(body.operator_provider);
+        if ("operator_provider" in body && operatorProvider === undefined) {
+            return Response.json({ error: "operator_provider must be string or null" }, { status: 400, headers });
+        }
+        const operatorModel = parseNullableString(body.operator_model);
+        if ("operator_model" in body && operatorModel === undefined) {
+            return Response.json({ error: "operator_model must be string or null" }, { status: 400, headers });
+        }
+        const operatorThinking = parseNullableString(body.operator_thinking);
+        if ("operator_thinking" in body && operatorThinking === undefined) {
+            return Response.json({ error: "operator_thinking must be string or null" }, { status: 400, headers });
+        }
+        const contextSessionId = parseNullableString(body.context_session_id);
+        if ("context_session_id" in body && contextSessionId === undefined) {
+            return Response.json({ error: "context_session_id must be string or null" }, { status: 400, headers });
+        }
+        const contextSessionFile = parseNullableString(body.context_session_file);
+        if ("context_session_file" in body && contextSessionFile === undefined) {
+            return Response.json({ error: "context_session_file must be string or null" }, { status: 400, headers });
+        }
+        const contextSessionDir = parseNullableString(body.context_session_dir);
+        if ("context_session_dir" in body && contextSessionDir === undefined) {
+            return Response.json({ error: "context_session_dir must be string or null" }, { status: 400, headers });
+        }
         const prompt = typeof body.prompt === "string" ? body.prompt : body.prompt === null ? null : undefined;
         const everyMs = typeof body.every_ms === "number" && Number.isFinite(body.every_ms)
             ? Math.max(0, Math.trunc(body.every_ms))
@@ -52,6 +85,12 @@ export async function heartbeatRoutes(request, url, deps, headers) {
                 metadata: body.metadata && typeof body.metadata === "object" && !Array.isArray(body.metadata)
                     ? body.metadata
                     : undefined,
+                operatorProvider,
+                operatorModel,
+                operatorThinking,
+                contextSessionId,
+                contextSessionFile,
+                contextSessionDir,
             });
             return Response.json({ ok: true, program }, { status: 201, headers });
         }
@@ -75,6 +114,15 @@ export async function heartbeatRoutes(request, url, deps, headers) {
             return Response.json({ error: "program_id is required" }, { status: 400, headers });
         }
         try {
+            const parseNullableString = (value) => {
+                if (value === undefined)
+                    return undefined;
+                if (value === null)
+                    return null;
+                if (typeof value === "string")
+                    return value;
+                return undefined;
+            };
             const updateOpts = {
                 programId,
                 title: typeof body.title === "string" ? body.title : undefined,
@@ -98,6 +146,48 @@ export async function heartbeatRoutes(request, url, deps, headers) {
                     return Response.json({ error: "prompt must be string or null" }, { status: 400, headers });
                 }
             }
+            if ("operator_provider" in body) {
+                const value = parseNullableString(body.operator_provider);
+                if (value === undefined) {
+                    return Response.json({ error: "operator_provider must be string or null" }, { status: 400, headers });
+                }
+                updateOpts.operatorProvider = value;
+            }
+            if ("operator_model" in body) {
+                const value = parseNullableString(body.operator_model);
+                if (value === undefined) {
+                    return Response.json({ error: "operator_model must be string or null" }, { status: 400, headers });
+                }
+                updateOpts.operatorModel = value;
+            }
+            if ("operator_thinking" in body) {
+                const value = parseNullableString(body.operator_thinking);
+                if (value === undefined) {
+                    return Response.json({ error: "operator_thinking must be string or null" }, { status: 400, headers });
+                }
+                updateOpts.operatorThinking = value;
+            }
+            if ("context_session_id" in body) {
+                const value = parseNullableString(body.context_session_id);
+                if (value === undefined) {
+                    return Response.json({ error: "context_session_id must be string or null" }, { status: 400, headers });
+                }
+                updateOpts.contextSessionId = value;
+            }
+            if ("context_session_file" in body) {
+                const value = parseNullableString(body.context_session_file);
+                if (value === undefined) {
+                    return Response.json({ error: "context_session_file must be string or null" }, { status: 400, headers });
+                }
+                updateOpts.contextSessionFile = value;
+            }
+            if ("context_session_dir" in body) {
+                const value = parseNullableString(body.context_session_dir);
+                if (value === undefined) {
+                    return Response.json({ error: "context_session_dir must be string or null" }, { status: 400, headers });
+                }
+                updateOpts.contextSessionDir = value;
+            }
             const result = await deps.heartbeatPrograms.update(updateOpts);
             if (result.ok) {
                 return Response.json(result, { headers });

package/dist/heartbeat_programs.d.ts

@@ -9,6 +9,12 @@ export type HeartbeatProgramSnapshot = {
     every_ms: number;
     reason: string;
     metadata: Record<string, unknown>;
+    operator_provider: string | null;
+    operator_model: string | null;
+    operator_thinking: string | null;
+    context_session_id: string | null;
+    context_session_file: string | null;
+    context_session_dir: string | null;
     created_at_ms: number;
     updated_at_ms: number;
     last_triggered_at_ms: number | null;
@@ -67,6 +73,12 @@ export type HeartbeatProgramRegistryOpts = {
         prompt: string | null;
         reason: string;
         metadata: Record<string, unknown>;
+        operatorProvider: string | null;
+        operatorModel: string | null;
+        operatorThinking: string | null;
+        contextSessionId: string | null;
+        contextSessionFile: string | null;
+        contextSessionDir: string | null;
         triggeredAtMs: number;
     }) => Promise<HeartbeatProgramDispatchResult>;
     onTickEvent?: (event: HeartbeatProgramTickEvent) => void | Promise<void>;
@@ -88,6 +100,12 @@ export declare class HeartbeatProgramRegistry {
         reason?: string;
         enabled?: boolean;
         metadata?: Record<string, unknown>;
+        operatorProvider?: string | null;
+        operatorModel?: string | null;
+        operatorThinking?: string | null;
+        contextSessionId?: string | null;
+        contextSessionFile?: string | null;
+        contextSessionDir?: string | null;
     }): Promise<HeartbeatProgramSnapshot>;
     update(opts: {
         programId: string;
@@ -97,6 +115,12 @@ export declare class HeartbeatProgramRegistry {
         reason?: string;
         enabled?: boolean;
         metadata?: Record<string, unknown>;
+        operatorProvider?: string | null;
+        operatorModel?: string | null;
+        operatorThinking?: string | null;
+        contextSessionId?: string | null;
+        contextSessionFile?: string | null;
+        contextSessionDir?: string | null;
     }): Promise<HeartbeatProgramOperationResult>;
     remove(programId: string): Promise<HeartbeatProgramOperationResult>;
     trigger(opts: {

package/dist/heartbeat_programs.js

@@ -19,6 +19,13 @@ function normalizePrompt(value) {
     }
     return value;
 }
+function normalizeOptionalString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
 function normalizeProgram(row) {
     if (!row || typeof row !== "object" || Array.isArray(row)) {
         return null;
@@ -43,7 +50,7 @@ function normalizeProgram(row) {
     const lastResultRaw = typeof record.last_result === "string" ? record.last_result.trim().toLowerCase() : null;
     const lastResult = lastResultRaw === "ok" || lastResultRaw === "coalesced" || lastResultRaw === "failed" ? lastResultRaw : null;
     const reason = typeof record.reason === "string" && record.reason.trim().length > 0 ? record.reason.trim() : "scheduled";
-    return {
+    const normalized = {
         v: 1,
         program_id: programId,
         title,
@@ -52,12 +59,29 @@ function normalizeProgram(row) {
         every_ms: everyMs,
         reason,
         metadata: sanitizeMetadata(record.metadata),
+        operator_provider: normalizeOptionalString(record.operator_provider),
+        operator_model: normalizeOptionalString(record.operator_model),
+        operator_thinking: normalizeOptionalString(record.operator_thinking),
+        context_session_id: normalizeOptionalString(record.context_session_id),
+        context_session_file: normalizeOptionalString(record.context_session_file),
+        context_session_dir: normalizeOptionalString(record.context_session_dir),
         created_at_ms: createdAt,
         updated_at_ms: updatedAt,
         last_triggered_at_ms: lastTriggeredAt,
         last_result: lastResult,
         last_error: typeof record.last_error === "string" ? record.last_error : null,
     };
+    const hasProvider = Boolean(normalized.operator_provider);
+    const hasModel = Boolean(normalized.operator_model);
+    if (hasProvider !== hasModel) {
+        normalized.operator_provider = null;
+        normalized.operator_model = null;
+        normalized.operator_thinking = null;
+    }
+    else if (!hasProvider) {
+        normalized.operator_thinking = null;
+    }
+    return normalized;
 }
 function sortPrograms(programs) {
     return [...programs].sort((a, b) => {
@@ -67,6 +91,16 @@ function sortPrograms(programs) {
         return a.program_id.localeCompare(b.program_id);
     });
 }
+function validateOperatorRouting(program) {
+    const hasProvider = typeof program.operator_provider === "string" && program.operator_provider.length > 0;
+    const hasModel = typeof program.operator_model === "string" && program.operator_model.length > 0;
+    if (hasProvider !== hasModel) {
+        throw new Error("heartbeat_program_operator_provider_model_pair_required");
+    }
+    if (program.operator_thinking && !hasProvider) {
+        throw new Error("heartbeat_program_operator_thinking_requires_provider_model");
+    }
+}
 export class HeartbeatProgramRegistry {
     #store;
     #heartbeatScheduler;
@@ -75,6 +109,7 @@ export class HeartbeatProgramRegistry {
     #onLifecycleEvent;
     #nowMs;
     #programs = new Map();
+    #inFlightTicks = new Map();
     #loaded = null;
     constructor(opts) {
         this.#heartbeatScheduler = opts.heartbeatScheduler;
@@ -160,6 +195,19 @@ export class HeartbeatProgramRegistry {
         await this.#onLifecycleEvent(event);
     }
     async #tickProgram(programId, reason) {
+        const inFlight = this.#inFlightTicks.get(programId);
+        if (inFlight) {
+            return { status: "skipped", reason: "coalesced" };
+        }
+        const run = this.#tickProgramUnlocked(programId, reason).finally(() => {
+            if (this.#inFlightTicks.get(programId) === run) {
+                this.#inFlightTicks.delete(programId);
+            }
+        });
+        this.#inFlightTicks.set(programId, run);
+        return await run;
+    }
+    async #tickProgramUnlocked(programId, reason) {
         const program = this.#programs.get(programId);
         if (!program) {
             return { status: "skipped", reason: "not_found" };
@@ -182,6 +230,12 @@ export class HeartbeatProgramRegistry {
                 prompt: program.prompt,
                 reason: heartbeatReason,
                 metadata: { ...program.metadata },
+                operatorProvider: program.operator_provider,
+                operatorModel: program.operator_model,
+                operatorThinking: program.operator_thinking,
+                contextSessionId: program.context_session_id,
+                contextSessionFile: program.context_session_file,
+                contextSessionDir: program.context_session_dir,
                 triggeredAtMs: nowMs,
             });
             if (result.status === "ok") {
@@ -283,12 +337,19 @@ export class HeartbeatProgramRegistry {
             every_ms: this.#normalizeEveryMs(typeof opts.everyMs === "number" && Number.isFinite(opts.everyMs) ? opts.everyMs : 15_000),
             reason: opts.reason?.trim() || "scheduled",
             metadata: sanitizeMetadata(opts.metadata),
+            operator_provider: normalizeOptionalString(opts.operatorProvider),
+            operator_model: normalizeOptionalString(opts.operatorModel),
+            operator_thinking: normalizeOptionalString(opts.operatorThinking),
+            context_session_id: normalizeOptionalString(opts.contextSessionId),
+            context_session_file: normalizeOptionalString(opts.contextSessionFile),
+            context_session_dir: normalizeOptionalString(opts.contextSessionDir),
             created_at_ms: nowMs,
             updated_at_ms: nowMs,
             last_triggered_at_ms: null,
             last_result: null,
             last_error: null,
         };
+        validateOperatorRouting(program);
         this.#programs.set(program.program_id, program);
         this.#applySchedule(program);
         await this.#persist();
@@ -332,6 +393,25 @@ export class HeartbeatProgramRegistry {
         if (opts.metadata) {
             program.metadata = sanitizeMetadata(opts.metadata);
         }
+        if ("operatorProvider" in opts) {
+            program.operator_provider = normalizeOptionalString(opts.operatorProvider);
+        }
+        if ("operatorModel" in opts) {
+            program.operator_model = normalizeOptionalString(opts.operatorModel);
+        }
+        if ("operatorThinking" in opts) {
+            program.operator_thinking = normalizeOptionalString(opts.operatorThinking);
+        }
+        if ("contextSessionId" in opts) {
+            program.context_session_id = normalizeOptionalString(opts.contextSessionId);
+        }
+        if ("contextSessionFile" in opts) {
+            program.context_session_file = normalizeOptionalString(opts.contextSessionFile);
+        }
+        if ("contextSessionDir" in opts) {
+            program.context_session_dir = normalizeOptionalString(opts.contextSessionDir);
+        }
+        validateOperatorRouting(program);
         const nowMs = Math.trunc(this.#nowMs());
         program.updated_at_ms = nowMs;
         this.#applySchedule(program);
@@ -396,6 +476,7 @@ export class HeartbeatProgramRegistry {
         for (const program of this.#programs.values()) {
             this.#heartbeatScheduler.unregister(this.#scheduleId(program.program_id));
         }
+        this.#inFlightTicks.clear();
         this.#programs.clear();
     }
 }

package/dist/server.js

@@ -77,6 +77,20 @@ function extractWakeTurnReply(turnResult) {
     const compact = presented.compact.trim();
     return compact.length > 0 ? compact : null;
 }
+function extractWakeTurnFailureCode(turnReply) {
+    if (!turnReply) {
+        return null;
+    }
+    const normalized = turnReply.trim();
+    if (!normalized.toLowerCase().startsWith("i could not complete that turn safely.")) {
+        return null;
+    }
+    const codeMatch = normalized.match(/(?:^|\n)\s*Code:\s*([a-z0-9_]+)/i);
+    if (!codeMatch || typeof codeMatch[1] !== "string") {
+        return null;
+    }
+    return codeMatch[1].toLowerCase();
+}
 function buildWakeTurnIngressText(opts) {
     const wakeSource = stringField(opts.payload, "wake_source") ?? "unknown";
     const programId = stringField(opts.payload, "program_id") ?? "unknown";
@@ -195,16 +209,37 @@ function createServer(options = {}) {
                     message: opts.message,
                     payload: opts.payload,
                 });
+                const operatorProvider = stringField(opts.payload, "operator_provider");
+                const operatorModel = stringField(opts.payload, "operator_model");
+                const operatorThinking = stringField(opts.payload, "operator_thinking");
+                const contextSessionId = stringField(opts.payload, "context_session_id");
+                const contextSessionFile = stringField(opts.payload, "context_session_file");
+                const contextSessionDir = stringField(opts.payload, "context_session_dir");
+                const defaultHeartbeatSessionId = wakeSource === "heartbeat_program" && programId ? `heartbeat-program:${programId}` : null;
+                const operatorSessionId = contextSessionId ?? defaultHeartbeatSessionId;
+                const autonomousMetadata = {
+                    wake_id: wakeId,
+                    wake_source: wakeSource,
+                    program_id: programId,
+                    source_ts_ms: sourceTsMs,
+                };
+                if (operatorProvider)
+                    autonomousMetadata.operator_provider = operatorProvider;
+                if (operatorModel)
+                    autonomousMetadata.operator_model = operatorModel;
+                if (operatorThinking)
+                    autonomousMetadata.operator_thinking = operatorThinking;
+                if (operatorSessionId)
+                    autonomousMetadata.operator_session_id = operatorSessionId;
+                if (contextSessionFile)
+                    autonomousMetadata.operator_session_file = contextSessionFile;
+                if (contextSessionDir)
+                    autonomousMetadata.operator_session_dir = contextSessionDir;
                 const turnResult = await autonomousIngress({
                     text: ingressText,
                     repoRoot: context.repoRoot,
                     requestId: turnRequestId,
-                    metadata: {
-                        wake_id: wakeId,
-                        wake_source: wakeSource,
-                        program_id: programId,
-                        source_ts_ms: sourceTsMs,
-                    },
+                    metadata: autonomousMetadata,
                 });
                 if (turnResult.kind === "noop" || turnResult.kind === "invalid") {
                     decision = {
@@ -229,14 +264,27 @@ function createServer(options = {}) {
                         };
                     }
                     else {
-                        decision = {
-                            outcome: "triggered",
-                            reason: "turn_invoked",
-                            turnRequestId,
-                            turnResultKind: turnResult.kind,
-                            turnReply,
-                            error: null,
-                        };
+                        const failureCode = extractWakeTurnFailureCode(turnReply);
+                        if (failureCode === "operator_busy") {
+                            decision = {
+                                outcome: "fallback",
+                                reason: "operator_busy",
+                                turnRequestId,
+                                turnResultKind: turnResult.kind,
+                                turnReply: null,
+                                error: null,
+                            };
+                        }
+                        else {
+                            decision = {
+                                outcome: "triggered",
+                                reason: "turn_invoked",
+                                turnRequestId,
+                                turnResultKind: turnResult.kind,
+                                turnReply,
+                                error: null,
+                            };
+                        }
                     }
                 }
             }
@@ -272,7 +320,7 @@ function createServer(options = {}) {
         let notifyError = null;
         let deliverySkippedReason = null;
         if (!decision.turnReply) {
-            deliverySkippedReason = "no_turn_reply";
+            deliverySkippedReason = decision.reason === "operator_busy" ? "operator_busy" : "no_turn_reply";
         }
         else if (typeof controlPlaneProxy.notifyOperators !== "function") {
             deliverySkippedReason = "notify_operators_unavailable";
@@ -346,6 +394,9 @@ function createServer(options = {}) {
                 delivery_error: notifyError,
             },
         });
+        if (decision.reason === "operator_busy") {
+            return { status: "coalesced", reason: decision.reason };
+        }
         if (decision.outcome !== "triggered") {
             return { status: "failed", reason: decision.reason };
         }

package/dist/server_program_coordination.js

@@ -12,18 +12,31 @@ export function createServerProgramCoordination(opts) {
         heartbeatScheduler: opts.heartbeatScheduler,
         dispatchWake: async (wakeOpts) => {
             const prompt = wakeOpts.prompt && wakeOpts.prompt.trim().length > 0 ? wakeOpts.prompt : null;
+            const payload = {
+                wake_source: "heartbeat_program",
+                source_ts_ms: wakeOpts.triggeredAtMs,
+                program_id: wakeOpts.programId,
+                title: wakeOpts.title,
+                prompt,
+                reason: wakeOpts.reason,
+                metadata: wakeOpts.metadata,
+            };
+            if (wakeOpts.operatorProvider)
+                payload.operator_provider = wakeOpts.operatorProvider;
+            if (wakeOpts.operatorModel)
+                payload.operator_model = wakeOpts.operatorModel;
+            if (wakeOpts.operatorThinking)
+                payload.operator_thinking = wakeOpts.operatorThinking;
+            if (wakeOpts.contextSessionId)
+                payload.context_session_id = wakeOpts.contextSessionId;
+            if (wakeOpts.contextSessionFile)
+                payload.context_session_file = wakeOpts.contextSessionFile;
+            if (wakeOpts.contextSessionDir)
+                payload.context_session_dir = wakeOpts.contextSessionDir;
             const wakeResult = await opts.emitOperatorWake({
                 dedupeKey: `heartbeat-program:${wakeOpts.programId}`,
                 message: prompt ?? `Heartbeat wake: ${wakeOpts.title}`,
-                payload: {
-                    wake_source: "heartbeat_program",
-                    source_ts_ms: wakeOpts.triggeredAtMs,
-                    program_id: wakeOpts.programId,
-                    title: wakeOpts.title,
-                    prompt,
-                    reason: wakeOpts.reason,
-                    metadata: wakeOpts.metadata,
-                },
+                payload,
             });
             if (wakeResult.status === "coalesced") {
                 return { status: "coalesced", reason: wakeResult.reason };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@femtomc/mu-server",
-	"version": "26.2.120",
+	"version": "26.3.2",
 	"description": "HTTP API server for mu control-plane transport/session plus run/activity scheduling coordination.",
 	"keywords": [
 		"mu",
@@ -30,8 +30,8 @@
 		"start": "bun run dist/cli.js"
 	},
 	"dependencies": {
-		"@femtomc/mu-agent": "26.2.120",
-		"@femtomc/mu-control-plane": "26.2.120",
-		"@femtomc/mu-core": "26.2.120"
+		"@femtomc/mu-agent": "26.3.2",
+		"@femtomc/mu-control-plane": "26.3.2",
+		"@femtomc/mu-core": "26.3.2"
 	}
 }