@femtomc/mu-server 26.2.75 → 26.2.77

package/dist/heartbeat_programs.d.ts

@@ -4,6 +4,7 @@ export type HeartbeatProgramSnapshot = {
     v: 1;
     program_id: string;
     title: string;
+    prompt: string | null;
     enabled: boolean;
     every_ms: number;
     reason: string;
@@ -45,6 +46,7 @@ export type HeartbeatProgramRegistryOpts = {
     dispatchWake: (opts: {
         programId: string;
         title: string;
+        prompt: string | null;
         reason: string;
         metadata: Record<string, unknown>;
         triggeredAtMs: number;
@@ -61,6 +63,7 @@ export declare class HeartbeatProgramRegistry {
     get(programId: string): Promise<HeartbeatProgramSnapshot | null>;
     create(opts: {
         title: string;
+        prompt?: string | null;
         everyMs?: number;
         reason?: string;
         enabled?: boolean;
@@ -69,6 +72,7 @@ export declare class HeartbeatProgramRegistry {
     update(opts: {
         programId: string;
         title?: string;
+        prompt?: string | null;
         everyMs?: number;
         reason?: string;
         enabled?: boolean;

package/dist/heartbeat_programs.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { FsJsonlStore } from "@femtomc/mu-core/node";
+import { FsJsonlStore, getStorePaths } from "@femtomc/mu-core/node";
 const HEARTBEAT_PROGRAMS_FILENAME = "heartbeats.jsonl";
 function defaultNowMs() {
     return Date.now();
@@ -10,6 +10,15 @@ function sanitizeMetadata(value) {
     }
     return { ...value };
 }
+function normalizePrompt(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    if (value.trim().length === 0) {
+        return null;
+    }
+    return value;
+}
 function normalizeProgram(row) {
     if (!row || typeof row !== "object" || Array.isArray(row)) {
         return null;
@@ -38,6 +47,7 @@ function normalizeProgram(row) {
         v: 1,
         program_id: programId,
         title,
+        prompt: normalizePrompt(record.prompt),
         enabled: record.enabled !== false,
         every_ms: everyMs,
         reason,
@@ -72,7 +82,7 @@ export class HeartbeatProgramRegistry {
         this.#nowMs = opts.nowMs ?? defaultNowMs;
         this.#store =
             opts.store ??
-                new FsJsonlStore(join(opts.repoRoot, ".mu", HEARTBEAT_PROGRAMS_FILENAME));
+                new FsJsonlStore(join(getStorePaths(opts.repoRoot).storeDir, HEARTBEAT_PROGRAMS_FILENAME));
     }
     #scheduleId(programId) {
         return `heartbeat-program:${programId}`;
@@ -146,6 +156,7 @@ export class HeartbeatProgramRegistry {
             const result = await this.#dispatchWake({
                 programId: program.program_id,
                 title: program.title,
+                prompt: program.prompt,
                 reason: heartbeatReason,
                 metadata: { ...program.metadata },
                 triggeredAtMs: nowMs,
@@ -222,6 +233,7 @@ export class HeartbeatProgramRegistry {
             v: 1,
             program_id: `hb-${crypto.randomUUID().slice(0, 12)}`,
             title,
+            prompt: normalizePrompt(opts.prompt),
             enabled: opts.enabled !== false,
             every_ms: typeof opts.everyMs === "number" && Number.isFinite(opts.everyMs)
                 ? Math.max(0, Math.trunc(opts.everyMs))
@@ -252,6 +264,9 @@ export class HeartbeatProgramRegistry {
             }
             program.title = title;
         }
+        if ("prompt" in opts) {
+            program.prompt = normalizePrompt(opts.prompt);
+        }
         if (typeof opts.everyMs === "number" && Number.isFinite(opts.everyMs)) {
             program.every_ms = Math.max(0, Math.trunc(opts.everyMs));
         }

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-export type { ControlPlaneActivityEvent, ControlPlaneActivityEventKind, ControlPlaneActivityMutationResult, ControlPlaneActivitySnapshot, ControlPlaneActivityStatus, ControlPlaneActivitySupervisorOpts, } from "./activity_supervisor.js";
-export { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 export type { MuConfig, MuConfigPatch, MuConfigPresence } from "./config.js";
 export { applyMuConfigPatch, DEFAULT_MU_CONFIG, getMuConfigPath, muConfigPresence, normalizeMuConfig, readMuConfigFile, redactMuConfigSecrets, writeMuConfigFile, } from "./config.js";
 export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneHandle, ControlPlaneSessionLifecycle, ControlPlaneSessionMutationAction, ControlPlaneSessionMutationResult, InterRootQueuePolicy, NotifyOperatorsOpts, NotifyOperatorsResult, OrchestrationQueueState, WakeDeliveryEvent, WakeNotifyContext, WakeNotifyDecision, } from "./control_plane_contract.js";
@@ -17,6 +15,7 @@ export type { HeartbeatProgramDispatchResult, HeartbeatProgramOperationResult, H
 export { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
 export type { ActivityHeartbeatSchedulerOpts, HeartbeatRunResult, HeartbeatTickHandler, } from "./heartbeat_scheduler.js";
 export { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
+export { MemoryIndexMaintainer } from "./memory_index_maintainer.js";
 export type { ServerContext, ServerInstanceOptions, ServerOptions, ServerRuntime, ServerRuntimeCapabilities, ServerRuntimeOptions, } from "./server.js";
 export { composeServerRuntime, createContext, createServerFromRuntime } from "./server.js";
 export type { ShellCommandResult, ShellCommandRunner } from "./session_lifecycle.js";

package/dist/index.js

@@ -1,4 +1,3 @@
-export { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 export { applyMuConfigPatch, DEFAULT_MU_CONFIG, getMuConfigPath, muConfigPresence, normalizeMuConfig, readMuConfigFile, redactMuConfigSecrets, writeMuConfigFile, } from "./config.js";
 export { DEFAULT_INTER_ROOT_QUEUE_POLICY, normalizeInterRootQueuePolicy, ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS, ORCHESTRATION_QUEUE_INVARIANTS, } from "./control_plane_contract.js";
 export { DurableRunQueue, queueStatesForRunStatusFilter, reconcileRunQueue, RUN_QUEUE_RECONCILE_INVARIANTS, runQueuePath, runSnapshotFromQueueSnapshot, runStatusFromQueueState, } from "./run_queue.js";
@@ -8,5 +7,6 @@ export { computeNextScheduleRunAtMs, normalizeCronSchedule } from "./cron_schedu
 export { CronTimerRegistry } from "./cron_timer.js";
 export { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
 export { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
+export { MemoryIndexMaintainer } from "./memory_index_maintainer.js";
 export { composeServerRuntime, createContext, createServerFromRuntime } from "./server.js";
 export { createProcessSessionLifecycle } from "./session_lifecycle.js";

package/dist/memory_index_maintainer.d.ts

@@ -0,0 +1,15 @@
+import { type EventLog } from "@femtomc/mu-core/node";
+import type { MuConfig } from "./config.js";
+import type { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
+export declare class MemoryIndexMaintainer {
+    #private;
+    constructor(opts: {
+        repoRoot: string;
+        heartbeatScheduler: ActivityHeartbeatScheduler;
+        eventLog: EventLog;
+        loadConfigFromDisk: () => Promise<MuConfig>;
+        fallbackConfig: MuConfig;
+    });
+    start(): void;
+    stop(): void;
+}

package/dist/memory_index_maintainer.js

@@ -0,0 +1,165 @@
+import { runContextIndexRebuild, runContextIndexStatus, } from "@femtomc/mu-core/node";
+const MEMORY_INDEX_ACTIVITY_ID = "maintenance:memory-index";
+function describeError(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return String(err);
+}
+function normalizeEveryMs(value) {
+    if (!Number.isFinite(value)) {
+        return 300_000;
+    }
+    return Math.max(1_000, Math.min(86_400_000, Math.trunc(value)));
+}
+function maintainerConfigFromMuConfig(config) {
+    return {
+        enabled: config.control_plane.memory_index.enabled,
+        every_ms: normalizeEveryMs(config.control_plane.memory_index.every_ms),
+    };
+}
+export class MemoryIndexMaintainer {
+    #repoRoot;
+    #scheduler;
+    #eventLog;
+    #loadConfigFromDisk;
+    #fallbackConfig;
+    #currentEveryMs;
+    #started = false;
+    constructor(opts) {
+        this.#repoRoot = opts.repoRoot;
+        this.#scheduler = opts.heartbeatScheduler;
+        this.#eventLog = opts.eventLog;
+        this.#loadConfigFromDisk = opts.loadConfigFromDisk;
+        this.#fallbackConfig = maintainerConfigFromMuConfig(opts.fallbackConfig);
+        this.#currentEveryMs = this.#fallbackConfig.every_ms;
+    }
+    #register(everyMs) {
+        this.#currentEveryMs = everyMs;
+        this.#scheduler.register({
+            activityId: MEMORY_INDEX_ACTIVITY_ID,
+            everyMs,
+            coalesceMs: 0,
+            handler: async ({ reason }) => await this.#tick(reason),
+        });
+    }
+    async #emitTickEvent(payload) {
+        await this.#eventLog.emit("memory_index.maintenance_tick", {
+            source: "mu-server.memory-index-maintainer",
+            payload,
+        });
+    }
+    async #emitRebuildEvent(payload) {
+        await this.#eventLog.emit("memory_index.rebuild", {
+            source: "mu-server.memory-index-maintainer",
+            payload,
+        });
+    }
+    async #emitRebuildFailureEvent(payload) {
+        await this.#eventLog.emit("memory_index.rebuild_failed", {
+            source: "mu-server.memory-index-maintainer",
+            payload,
+        });
+    }
+    async #readConfig() {
+        try {
+            const config = await this.#loadConfigFromDisk();
+            return maintainerConfigFromMuConfig(config);
+        }
+        catch {
+            return this.#fallbackConfig;
+        }
+    }
+    async #tick(reasonRaw) {
+        const reason = typeof reasonRaw === "string" && reasonRaw.trim().length > 0 ? reasonRaw.trim() : "scheduled";
+        const cfg = await this.#readConfig();
+        if (cfg.every_ms !== this.#currentEveryMs) {
+            this.#register(cfg.every_ms);
+            await this.#emitTickEvent({
+                reason,
+                action: "rescheduled",
+                every_ms: cfg.every_ms,
+                enabled: cfg.enabled,
+            });
+            return { status: "skipped", reason: "rescheduled" };
+        }
+        if (!cfg.enabled) {
+            await this.#emitTickEvent({
+                reason,
+                action: "disabled",
+                every_ms: cfg.every_ms,
+                enabled: cfg.enabled,
+            });
+            return { status: "skipped", reason: "disabled" };
+        }
+        let status;
+        try {
+            status = await runContextIndexStatus({ repoRoot: this.#repoRoot });
+        }
+        catch (err) {
+            const error = describeError(err);
+            await this.#emitRebuildFailureEvent({
+                reason,
+                action: "status_failed",
+                error,
+            });
+            return { status: "failed", reason: error };
+        }
+        const needsRebuild = !status.exists || status.stale_source_count > 0;
+        if (!needsRebuild) {
+            await this.#emitTickEvent({
+                reason,
+                action: "up_to_date",
+                enabled: cfg.enabled,
+                every_ms: cfg.every_ms,
+                total_count: status.total_count,
+                stale_source_count: status.stale_source_count,
+            });
+            return { status: "skipped", reason: "up_to_date" };
+        }
+        const startedAtMs = Date.now();
+        try {
+            const rebuild = await runContextIndexRebuild({
+                repoRoot: this.#repoRoot,
+                search: new URLSearchParams(),
+            });
+            await this.#emitRebuildEvent({
+                reason,
+                action: "rebuilt",
+                duration_ms: Math.max(0, Date.now() - startedAtMs),
+                indexed_count: rebuild.indexed_count,
+                total_count: rebuild.total_count,
+                stale_source_count: rebuild.stale_source_count,
+                source_count: rebuild.source_count,
+            });
+            return { status: "ran" };
+        }
+        catch (err) {
+            const error = describeError(err);
+            await this.#emitRebuildFailureEvent({
+                reason,
+                action: "rebuild_failed",
+                duration_ms: Math.max(0, Date.now() - startedAtMs),
+                error,
+                index_exists: status.exists,
+                stale_source_count: status.stale_source_count,
+            });
+            return { status: "failed", reason: error };
+        }
+    }
+    start() {
+        if (this.#started) {
+            return;
+        }
+        this.#started = true;
+        this.#register(this.#currentEveryMs);
+        this.#scheduler.requestNow(MEMORY_INDEX_ACTIVITY_ID, { reason: "startup", coalesceMs: 0 });
+    }
+    stop() {
+        if (!this.#started) {
+            return;
+        }
+        this.#started = false;
+        this.#scheduler.unregister(MEMORY_INDEX_ACTIVITY_ID);
+    }
+}

package/dist/run_queue.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { FsJsonlStore } from "@femtomc/mu-core/node";
+import { FsJsonlStore, getStorePaths } from "@femtomc/mu-core/node";
 import { INTER_ROOT_QUEUE_RECONCILE_INVARIANTS, ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS, reconcileInterRootQueue, } from "./orchestration_queue.js";
 const RUN_QUEUE_FILENAME = "run_queue.jsonl";
 const DEFAULT_MAX_STEPS = 20;
@@ -204,7 +204,7 @@ export function reconcileRunQueue(rows, policy) {
     return reconcileInterRootQueue(rows, policy);
 }
 export function runQueuePath(repoRoot) {
-    return join(repoRoot, ".mu", "control-plane", RUN_QUEUE_FILENAME);
+    return join(getStorePaths(repoRoot).storeDir, "control-plane", RUN_QUEUE_FILENAME);
 }
 function stableCompare(a, b) {
     if (a.created_at_ms !== b.created_at_ms) {

package/dist/run_supervisor.d.ts

@@ -70,8 +70,8 @@ export declare class ControlPlaneRunSupervisor {
     #private;
     constructor(opts: ControlPlaneRunSupervisorOpts);
     /**
-     * Compatibility adapter entrypoint for run-start intent.
-     * Default architecture should enqueue first, then call this after lease acquisition.
+     * Queue-launch entrypoint for run-start intent.
+     * Expected call path: enqueue/activate first, then invoke after lease acquisition.
      */
     launchStart(opts: {
         prompt: string;
@@ -81,8 +81,8 @@ export declare class ControlPlaneRunSupervisor {
         source?: "command" | "api";
     }): Promise<ControlPlaneRunSnapshot>;
     /**
-     * Compatibility adapter entrypoint for run-resume intent.
-     * No feature-flag branch: queue-first reconcile remains the canonical path.
+     * Queue-launch entrypoint for run-resume intent.
+     * Queue-first reconcile remains the canonical execution path.
      */
     launchResume(opts: {
         rootIssueId: string;

package/dist/run_supervisor.js

@@ -1,5 +1,6 @@
 import { readdir } from "node:fs/promises";
 import { join, relative } from "node:path";
+import { getStorePaths } from "@femtomc/mu-core/node";
 const DEFAULT_MAX_STEPS = 20;
 const ROOT_RE = /\bRoot:\s*(mu-[a-z0-9][a-z0-9-]*)\b/i;
 const STEP_RE = /^(Step|Done)\s+\d+\/\d+\s+/;
@@ -275,8 +276,8 @@ export class ControlPlaneRunSupervisor {
         return this.#snapshot(job);
     }
     /**
-     * Compatibility adapter entrypoint for run-start intent.
-     * Default architecture should enqueue first, then call this after lease acquisition.
+     * Queue-launch entrypoint for run-start intent.
+     * Expected call path: enqueue/activate first, then invoke after lease acquisition.
      */
     async launchStart(opts) {
         const prompt = opts.prompt.trim();
@@ -297,8 +298,8 @@ export class ControlPlaneRunSupervisor {
         });
     }
     /**
-     * Compatibility adapter entrypoint for run-resume intent.
-     * No feature-flag branch: queue-first reconcile remains the canonical path.
+     * Queue-launch entrypoint for run-resume intent.
+     * Queue-first reconcile remains the canonical execution path.
      */
     async launchResume(opts) {
         const rootIssueId = normalizeIssueId(opts.rootIssueId);
@@ -355,7 +356,7 @@ export class ControlPlaneRunSupervisor {
         const rootIssueId = job.snapshot.root_issue_id;
         const traceFiles = [];
         if (rootIssueId) {
-            const rootLogsDir = join(this.#repoRoot, ".mu", "logs", rootIssueId);
+            const rootLogsDir = join(getStorePaths(this.#repoRoot).logsDir, rootIssueId);
             try {
                 const entries = await readdir(rootLogsDir, { withFileTypes: true });
                 for (const entry of entries) {

package/dist/server.d.ts

@@ -1,7 +1,6 @@
 import { GenerationTelemetryRecorder } from "@femtomc/mu-control-plane";
 import type { EventEnvelope, JsonlStore } from "@femtomc/mu-core";
 import { EventLog } from "@femtomc/mu-core/node";
-import { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 import { type MuConfig } from "./config.js";
 import type { ControlPlaneHandle, ControlPlaneSessionLifecycle } from "./control_plane_contract.js";
 import { type ConfigReader, type ConfigWriter, type ControlPlaneReloader, type ControlPlaneReloadResult, type ControlPlaneSummary } from "./control_plane_reload.js";
@@ -15,7 +14,6 @@ export type ServerOptions = {
     port?: number;
     controlPlane?: ControlPlaneHandle | null;
     heartbeatScheduler?: ActivityHeartbeatScheduler;
-    activitySupervisor?: ControlPlaneActivitySupervisor;
     controlPlaneReloader?: ControlPlaneReloader;
     generationTelemetry?: GenerationTelemetryRecorder;
     operatorWakeCoalesceMs?: number;
@@ -39,7 +37,6 @@ export declare function createServerFromRuntime(runtime: ServerRuntime, options?
     fetch: (request: Request) => Promise<Response>;
     hostname: string;
     controlPlane: ControlPlaneHandle;
-    activitySupervisor: ControlPlaneActivitySupervisor;
     heartbeatPrograms: import("./heartbeat_programs.js").HeartbeatProgramRegistry;
     cronPrograms: import("./cron_programs.js").CronProgramRegistry;
 };

package/dist/server.js

@@ -1,11 +1,11 @@
 import { GenerationTelemetryRecorder, presentPipelineResultMessage, } from "@femtomc/mu-control-plane";
 import { currentRunId, EventLog, FsJsonlStore, getStorePaths, JsonlEventSink } from "@femtomc/mu-core/node";
-import { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 import { DEFAULT_MU_CONFIG, readMuConfigFile, writeMuConfigFile } from "./config.js";
 import { bootstrapControlPlane } from "./control_plane.js";
 import { createReloadManager, } from "./control_plane_reload.js";
 import { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
 import { createProcessSessionLifecycle } from "./session_lifecycle.js";
+import { MemoryIndexMaintainer } from "./memory_index_maintainer.js";
 import { createServerProgramOrchestration } from "./server_program_orchestration.js";
 import { createServerRequestHandler } from "./server_routing.js";
 import { toNonNegativeInt } from "./server_types.js";
@@ -32,6 +32,10 @@ function stringField(payload, key) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
+function stringFieldRaw(payload, key) {
+    const value = payload[key];
+    return typeof value === "string" ? value : null;
+}
 function numberField(payload, key) {
     const value = payload[key];
     if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -73,15 +77,25 @@ function extractWakeTurnReply(turnResult) {
 function buildWakeTurnCommandText(opts) {
     const wakeSource = stringField(opts.payload, "wake_source") ?? "unknown";
     const programId = stringField(opts.payload, "program_id") ?? "unknown";
+    const title = stringField(opts.payload, "title") ?? "(untitled wake program)";
     const reason = stringField(opts.payload, "reason") ?? "scheduled";
+    const prompt = stringFieldRaw(opts.payload, "prompt");
+    const wakeInstruction = prompt ?? opts.message;
     const payloadSnapshot = stablePayloadSnapshot(opts.payload);
     return [
         "Autonomous wake turn triggered by heartbeat/cron scheduler.",
         `wake_id=${opts.wakeId}`,
         `wake_source=${wakeSource}`,
         `program_id=${programId}`,
-        `reason=${reason}`,
-        `trigger_message=${opts.message}`,
+        `wake_title=${title}`,
+        `wake_reason=${reason}`,
+        "",
+        "wake_prompt:",
+        prompt ?? "(none)",
+        "",
+        "wake_instruction:",
+        wakeInstruction,
+        "",
         `payload=${payloadSnapshot}`,
         "",
         "If action is needed, produce exactly one `/mu ...` command. If no action is needed, return a short operator response that can be broadcast verbatim.",
@@ -102,24 +116,6 @@ function createServer(options = {}) {
     const writeConfig = options.configWriter ?? writeMuConfigFile;
     const fallbackConfig = options.config ?? DEFAULT_MU_CONFIG;
     const heartbeatScheduler = options.heartbeatScheduler ?? new ActivityHeartbeatScheduler();
-    const activitySupervisor = options.activitySupervisor ??
-        new ControlPlaneActivitySupervisor({
-            heartbeatScheduler,
-            onEvent: async (event) => {
-                await context.eventLog.emit(`activity.${event.kind}`, {
-                    source: "mu-server.activity-supervisor",
-                    payload: {
-                        seq: event.seq,
-                        message: event.message,
-                        activity_id: event.activity.activity_id,
-                        kind: event.activity.kind,
-                        status: event.activity.status,
-                        heartbeat_count: event.activity.heartbeat_count,
-                        last_progress: event.activity.last_progress,
-                    },
-                });
-            },
-        });
     const operatorWakeCoalesceMs = toNonNegativeInt(options.operatorWakeCoalesceMs, DEFAULT_OPERATOR_WAKE_COALESCE_MS);
     const operatorWakeLastByKey = new Map();
     const sessionLifecycle = options.sessionLifecycle ?? createProcessSessionLifecycle({ repoRoot });
@@ -458,6 +454,7 @@ function createServer(options = {}) {
             const handle = reloadManager.getControlPlaneCurrent();
             handle?.setWakeDeliveryObserver?.(null);
             reloadManager.setControlPlaneCurrent(null);
+            memoryIndexMaintainer.stop();
             await handle?.stop();
         },
     };
@@ -467,10 +464,17 @@ function createServer(options = {}) {
         eventLog: context.eventLog,
         emitOperatorWake,
     });
+    const memoryIndexMaintainer = new MemoryIndexMaintainer({
+        repoRoot,
+        heartbeatScheduler,
+        eventLog: context.eventLog,
+        loadConfigFromDisk,
+        fallbackConfig,
+    });
+    memoryIndexMaintainer.start();
     const handleRequest = createServerRequestHandler({
         context,
         controlPlaneProxy,
-        activitySupervisor,
         heartbeatPrograms,
         cronPrograms,
         loadConfigFromDisk,
@@ -485,7 +489,6 @@ function createServer(options = {}) {
         fetch: handleRequest,
         hostname: "0.0.0.0",
         controlPlane: controlPlaneProxy,
-        activitySupervisor,
         heartbeatPrograms,
         cronPrograms,
     };

package/dist/server_program_orchestration.js

@@ -11,13 +11,16 @@ export function createServerProgramOrchestration(opts) {
         repoRoot: opts.repoRoot,
         heartbeatScheduler: opts.heartbeatScheduler,
         dispatchWake: async (wakeOpts) => {
+            const prompt = wakeOpts.prompt && wakeOpts.prompt.trim().length > 0 ? wakeOpts.prompt : null;
             const wakeResult = await opts.emitOperatorWake({
                 dedupeKey: `heartbeat-program:${wakeOpts.programId}`,
-                message: `Heartbeat wake: ${wakeOpts.title}`,
+                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,
                 },
@@ -55,6 +58,8 @@ export function createServerProgramOrchestration(opts) {
                         wake_source: "cron_program",
                         source_ts_ms: wakeOpts.triggeredAtMs,
                         program_id: wakeOpts.programId,
+                        title: wakeOpts.title,
+                        prompt: null,
                         reason: wakeOpts.reason,
                         schedule: wakeOpts.schedule,
                         metadata: wakeOpts.metadata,

package/dist/server_routing.d.ts

@@ -1,4 +1,3 @@
-import type { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 import type { MuConfig } from "./config.js";
 import type { ControlPlaneHandle } from "./control_plane_contract.js";
 import type { CronProgramRegistry } from "./cron_programs.js";
@@ -7,7 +6,6 @@ import type { ServerContext } from "./server.js";
 export type ServerRoutingDependencies = {
     context: ServerContext;
     controlPlaneProxy: ControlPlaneHandle;
-    activitySupervisor: ControlPlaneActivitySupervisor;
     heartbeatPrograms: HeartbeatProgramRegistry;
     cronPrograms: CronProgramRegistry;
     loadConfigFromDisk: () => Promise<MuConfig>;

package/dist/server_routing.js

@@ -1,13 +1,6 @@
-import { activityRoutes } from "./api/activities.js";
-import { configRoutes } from "./api/config.js";
 import { controlPlaneRoutes } from "./api/control_plane.js";
 import { cronRoutes } from "./api/cron.js";
-import { eventRoutes } from "./api/events.js";
 import { heartbeatRoutes } from "./api/heartbeats.js";
-import { identityRoutes } from "./api/identities.js";
-import { runRoutes } from "./api/runs.js";
-import { sessionFlashRoutes } from "./api/session_flash.js";
-import { sessionTurnRoutes } from "./api/session_turn.js";
 export function createServerRequestHandler(deps) {
     return async (request) => {
         const url = new URL(request.url);
@@ -36,50 +29,15 @@ export function createServerRequestHandler(deps) {
             }, 100);
             return Response.json({ ok: true, message: "shutdown initiated" }, { headers });
         }
-        if (path === "/api/config") {
-            return configRoutes(request, url, deps, headers);
-        }
-        if (path === "/api/control-plane/reload" ||
-            path === "/api/control-plane/rollback" ||
-            path === "/api/control-plane/channels") {
+        if (path === "/api/control-plane" || path.startsWith("/api/control-plane/")) {
             return controlPlaneRoutes(request, url, deps, headers);
         }
-        if (path === "/api/status") {
-            return Response.json({
-                repo_root: deps.context.repoRoot,
-                control_plane: deps.getControlPlaneStatus(),
-            }, { headers });
-        }
-        if (path === "/api/session-flash" ||
-            path === "/api/session-flash/ack" ||
-            path.startsWith("/api/session-flash/")) {
-            return sessionFlashRoutes(request, url, deps, headers);
-        }
-        if (path === "/api/session-turn") {
-            return sessionTurnRoutes(request, url, deps, headers);
-        }
-        if (path === "/api/runs" || path.startsWith("/api/runs/")) {
-            return runRoutes(request, url, deps, headers);
-        }
         if (path === "/api/cron" || path.startsWith("/api/cron/")) {
             return cronRoutes(request, url, deps, headers);
         }
         if (path === "/api/heartbeats" || path.startsWith("/api/heartbeats/")) {
             return heartbeatRoutes(request, url, deps, headers);
         }
-        if (path === "/api/activities" || path.startsWith("/api/activities/")) {
-            return activityRoutes(request, url, deps, headers);
-        }
-        if (path === "/api/identities" || path === "/api/identities/link" || path === "/api/identities/unlink") {
-            return identityRoutes(request, url, deps, headers);
-        }
-        if (path.startsWith("/api/events")) {
-            const response = await eventRoutes(request, deps.context);
-            headers.forEach((value, key) => {
-                response.headers.set(key, value);
-            });
-            return response;
-        }
         if (path.startsWith("/webhooks/")) {
             const response = await deps.controlPlaneProxy.handleWebhook(path, request);
             if (response) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.75",
+  "version": "26.2.77",
   "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.75",
-    "@femtomc/mu-control-plane": "26.2.75",
-    "@femtomc/mu-core": "26.2.75"
+    "@femtomc/mu-agent": "26.2.77",
+    "@femtomc/mu-control-plane": "26.2.77",
+    "@femtomc/mu-core": "26.2.77"
   }
 }