@femtomc/mu-server 26.2.72 → 26.2.74

package/dist/run_queue.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { FsJsonlStore } from "@femtomc/mu-core/node";
-import { INTER_ROOT_QUEUE_RECONCILE_INVARIANTS, ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS, reconcileInterRootQueue, } from "@femtomc/mu-orchestrator";
+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;
 const DEFAULT_MAX_OPERATION_IDS = 128;
@@ -227,6 +227,16 @@ function snapshotClone(value) {
         applied_operation_ids: [...value.applied_operation_ids],
     };
 }
+function normalizeRunStatus(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "running" || normalized === "completed" || normalized === "failed" || normalized === "cancelled") {
+        return normalized;
+    }
+    return null;
+}
 function normalizeQueueRecordRow(row, nowMs, maxOperationIds) {
     if (!row || typeof row !== "object" || Array.isArray(row)) {
         return null;
@@ -235,78 +245,73 @@ function normalizeQueueRecordRow(row, nowMs, maxOperationIds) {
     const queueId = normalizeString(record.queue_id);
     const mode = normalizeRunMode(record.mode);
     const state = normalizeQueueState(record.state);
-    if (queueId && mode && state) {
-        const createdAt = normalizeTimestamp(record.created_at_ms, nowMs);
-        const updatedAt = normalizeTimestamp(record.updated_at_ms, createdAt);
-        const revision = Math.max(1, normalizeMaxSteps(record.revision, 1));
-        const dedupeKey = normalizeString(record.dedupe_key) ?? `queue:${queueId}`;
-        const prompt = normalizePrompt(record.prompt);
-        const rootIssueId = normalizeIssueId(record.root_issue_id);
-        return {
-            snapshot: {
-                v: 1,
-                queue_id: queueId,
-                dedupe_key: dedupeKey,
-                mode,
-                state,
-                prompt,
-                root_issue_id: rootIssueId,
-                max_steps: normalizeMaxSteps(record.max_steps, DEFAULT_MAX_STEPS),
-                command_id: normalizeString(record.command_id),
-                source: normalizeRunSource(record.source),
-                job_id: normalizeString(record.job_id),
-                started_at_ms: normalizeNullableTimestamp(record.started_at_ms),
-                updated_at_ms: updatedAt,
-                finished_at_ms: normalizeNullableTimestamp(record.finished_at_ms),
-                exit_code: normalizeNullableInt(record.exit_code),
-                pid: normalizeNullableInt(record.pid),
-                last_progress: normalizeString(record.last_progress),
-                created_at_ms: createdAt,
-                revision,
-                applied_operation_ids: normalizeAppliedOperationIds(record.applied_operation_ids, maxOperationIds),
-            },
-            migrated: false,
-        };
-    }
-    const legacyMode = normalizeRunMode(record.mode);
-    const legacyStatusRaw = typeof record.status === "string" ? record.status.trim().toLowerCase() : "";
-    const legacyStatus = legacyStatusRaw === "running" ||
-        legacyStatusRaw === "completed" ||
-        legacyStatusRaw === "failed" ||
-        legacyStatusRaw === "cancelled"
-        ? legacyStatusRaw
-        : null;
-    const legacyJobId = normalizeString(record.job_id);
-    if (!legacyMode || !legacyStatus || !legacyJobId) {
+    if (!queueId || !mode || !state) {
+        return null;
+    }
+    const createdAt = normalizeTimestamp(record.created_at_ms, nowMs);
+    const updatedAt = normalizeTimestamp(record.updated_at_ms, createdAt);
+    const revision = Math.max(1, normalizeMaxSteps(record.revision, 1));
+    const dedupeKey = normalizeString(record.dedupe_key) ?? `queue:${queueId}`;
+    const prompt = normalizePrompt(record.prompt);
+    const rootIssueId = normalizeIssueId(record.root_issue_id);
+    return {
+        v: 1,
+        queue_id: queueId,
+        dedupe_key: dedupeKey,
+        mode,
+        state,
+        prompt,
+        root_issue_id: rootIssueId,
+        max_steps: normalizeMaxSteps(record.max_steps, DEFAULT_MAX_STEPS),
+        command_id: normalizeString(record.command_id),
+        source: normalizeRunSource(record.source),
+        job_id: normalizeString(record.job_id),
+        started_at_ms: normalizeNullableTimestamp(record.started_at_ms),
+        updated_at_ms: updatedAt,
+        finished_at_ms: normalizeNullableTimestamp(record.finished_at_ms),
+        exit_code: normalizeNullableInt(record.exit_code),
+        pid: normalizeNullableInt(record.pid),
+        last_progress: normalizeString(record.last_progress),
+        created_at_ms: createdAt,
+        revision,
+        applied_operation_ids: normalizeAppliedOperationIds(record.applied_operation_ids, maxOperationIds),
+    };
+}
+function queueSnapshotFromRunSnapshotRecord(row, nowMs) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+        return null;
+    }
+    const record = row;
+    const mode = normalizeRunMode(record.mode);
+    const status = normalizeRunStatus(record.status);
+    const jobId = normalizeString(record.job_id);
+    if (!mode || !status || !jobId) {
         return null;
     }
     const createdAt = normalizeTimestamp(record.started_at_ms, nowMs);
     const updatedAt = normalizeTimestamp(record.updated_at_ms, createdAt);
-    const queueIdFromLegacy = `legacy-${legacyJobId}`;
+    const queueId = normalizeString(record.queue_id) ?? `rq-sync-${jobId}`;
     return {
-        snapshot: {
-            v: 1,
-            queue_id: queueIdFromLegacy,
-            dedupe_key: `legacy:${legacyJobId}`,
-            mode: legacyMode,
-            state: queueStateFromRunStatus(legacyStatus),
-            prompt: normalizePrompt(record.prompt),
-            root_issue_id: normalizeIssueId(record.root_issue_id),
-            max_steps: normalizeMaxSteps(record.max_steps, DEFAULT_MAX_STEPS),
-            command_id: normalizeString(record.command_id),
-            source: normalizeRunSource(record.source),
-            job_id: legacyJobId,
-            started_at_ms: normalizeNullableTimestamp(record.started_at_ms),
-            updated_at_ms: updatedAt,
-            finished_at_ms: normalizeNullableTimestamp(record.finished_at_ms),
-            exit_code: normalizeNullableInt(record.exit_code),
-            pid: normalizeNullableInt(record.pid),
-            last_progress: normalizeString(record.last_progress),
-            created_at_ms: createdAt,
-            revision: 1,
-            applied_operation_ids: [],
-        },
-        migrated: true,
+        v: 1,
+        queue_id: queueId,
+        dedupe_key: `runtime:${jobId}`,
+        mode,
+        state: queueStateFromRunStatus(status),
+        prompt: normalizePrompt(record.prompt),
+        root_issue_id: normalizeIssueId(record.root_issue_id),
+        max_steps: normalizeMaxSteps(record.max_steps, DEFAULT_MAX_STEPS),
+        command_id: normalizeString(record.command_id),
+        source: normalizeRunSource(record.source),
+        job_id: jobId,
+        started_at_ms: normalizeNullableTimestamp(record.started_at_ms),
+        updated_at_ms: updatedAt,
+        finished_at_ms: normalizeNullableTimestamp(record.finished_at_ms),
+        exit_code: normalizeNullableInt(record.exit_code),
+        pid: normalizeNullableInt(record.pid),
+        last_progress: normalizeString(record.last_progress),
+        created_at_ms: createdAt,
+        revision: 1,
+        applied_operation_ids: [],
     };
 }
 function mergeQueueAndRunSnapshot(queue, run) {
@@ -444,7 +449,6 @@ export class DurableRunQueue {
     }
     async #load() {
         const rows = await this.#store.read();
-        let migrated = false;
         const byId = new Map();
         const nowMs = Math.trunc(this.#nowMs());
         for (const row of rows) {
@@ -452,22 +456,18 @@ export class DurableRunQueue {
             if (!normalized) {
                 continue;
             }
-            migrated = migrated || normalized.migrated;
-            const existing = byId.get(normalized.snapshot.queue_id);
+            const existing = byId.get(normalized.queue_id);
             if (!existing) {
-                byId.set(normalized.snapshot.queue_id, normalized.snapshot);
+                byId.set(normalized.queue_id, normalized);
                 continue;
             }
-            byId.set(normalized.snapshot.queue_id, chooseLatest(existing, normalized.snapshot));
+            byId.set(normalized.queue_id, chooseLatest(existing, normalized));
         }
         this.#rowsById.clear();
         for (const row of byId.values()) {
             this.#rowsById.set(row.queue_id, row);
         }
         this.#rebuildIndexes();
-        if (migrated) {
-            await this.#persist();
-        }
     }
     async #persist() {
         const rows = this.#allRowsSorted().map((row) => snapshotClone(row));
@@ -756,11 +756,10 @@ export class DurableRunQueue {
                 }
             }
             if (!row && opts.createIfMissing) {
-                const migrated = normalizeQueueRecordRow(opts.run, nowMs, this.#maxOperationIds);
-                if (!migrated) {
+                const next = queueSnapshotFromRunSnapshotRecord(opts.run, nowMs);
+                if (!next) {
                     return null;
                 }
-                const next = migrated.snapshot;
                 if (operationId) {
                     this.#rememberOperation(next, operationId);
                     next.revision += 1;

package/dist/run_supervisor.d.ts

@@ -1,8 +1,6 @@
 import type { CommandRecord } from "@femtomc/mu-control-plane";
-import { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
 export type ControlPlaneRunMode = "run_start" | "run_resume";
 export type ControlPlaneRunStatus = "running" | "completed" | "failed" | "cancelled";
-export type ControlPlaneRunWakeMode = "immediate" | "next_heartbeat";
 export type ControlPlaneRunSnapshot = {
     job_id: string;
     mode: ControlPlaneRunMode;
@@ -33,12 +31,7 @@ export type ControlPlaneRunInterruptResult = {
     reason: "not_found" | "not_running" | "missing_target" | null;
     run: ControlPlaneRunSnapshot | null;
 };
-export type ControlPlaneRunHeartbeatResult = {
-    ok: boolean;
-    reason: "not_found" | "not_running" | "missing_target" | null;
-    run: ControlPlaneRunSnapshot | null;
-};
-export type ControlPlaneRunEventKind = "run_started" | "run_root_discovered" | "run_progress" | "run_heartbeat" | "run_interrupt_requested" | "run_completed" | "run_failed" | "run_cancelled";
+export type ControlPlaneRunEventKind = "run_started" | "run_root_discovered" | "run_progress" | "run_interrupt_requested" | "run_completed" | "run_failed" | "run_cancelled";
 export type ControlPlaneRunEvent = {
     seq: number;
     ts_ms: number;
@@ -61,8 +54,6 @@ export type ControlPlaneRunSupervisorOpts = {
         argv: string[];
         cwd: string;
     }) => ControlPlaneRunProcess;
-    heartbeatIntervalMs?: number;
-    heartbeatScheduler?: ActivityHeartbeatScheduler;
     maxStoredLines?: number;
     maxHistory?: number;
     onEvent?: (event: ControlPlaneRunEvent) => void | Promise<void>;
@@ -73,7 +64,7 @@ export type ControlPlaneRunSupervisorOpts = {
  * Contract with the durable queue/reconcile layer:
  * - this supervisor executes already-selected work; it does not decide inter-root scheduling policy
  * - sequential/parallel root policy is enforced by queue leasing before launch
- * - compatibility adapters may call launch directly during migration, but the default path is queue-first
+ * - queue-first launch is the supported execution path
  */
 export declare class ControlPlaneRunSupervisor {
     #private;
@@ -112,12 +103,6 @@ export declare class ControlPlaneRunSupervisor {
         jobId?: string | null;
         rootIssueId?: string | null;
     }): ControlPlaneRunInterruptResult;
-    heartbeat(opts: {
-        jobId?: string | null;
-        rootIssueId?: string | null;
-        reason?: string | null;
-        wakeMode?: string | null;
-    }): ControlPlaneRunHeartbeatResult;
     startFromCommand(command: CommandRecord): Promise<ControlPlaneRunSnapshot | null>;
     stop(): Promise<void>;
 }

package/dist/run_supervisor.js

@@ -1,6 +1,5 @@
 import { readdir } from "node:fs/promises";
 import { join, relative } from "node:path";
-import { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
 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+/;
@@ -45,13 +44,6 @@ function normalizeIssueId(value) {
     }
     return trimmed.toLowerCase();
 }
-function normalizeWakeMode(value) {
-    if (typeof value !== "string") {
-        return "immediate";
-    }
-    const normalized = value.trim().toLowerCase().replaceAll("-", "_");
-    return normalized === "next_heartbeat" ? "next_heartbeat" : "immediate";
-}
 function pushBounded(lines, line, maxLines) {
     lines.push(line);
     if (lines.length <= maxLines) {
@@ -103,15 +95,12 @@ function describeRun(snapshot) {
  * Contract with the durable queue/reconcile layer:
  * - this supervisor executes already-selected work; it does not decide inter-root scheduling policy
  * - sequential/parallel root policy is enforced by queue leasing before launch
- * - compatibility adapters may call launch directly during migration, but the default path is queue-first
+ * - queue-first launch is the supported execution path
  */
 export class ControlPlaneRunSupervisor {
     #repoRoot;
     #nowMs;
     #spawnProcess;
-    #heartbeatIntervalMs;
-    #heartbeatScheduler;
-    #ownsHeartbeatScheduler;
     #maxStoredLines;
     #maxHistory;
     #onEvent;
@@ -123,9 +112,6 @@ export class ControlPlaneRunSupervisor {
         this.#repoRoot = opts.repoRoot;
         this.#nowMs = opts.nowMs ?? defaultNowMs;
         this.#spawnProcess = opts.spawnProcess ?? defaultSpawnProcess;
-        this.#heartbeatIntervalMs = Math.max(2_000, Math.trunc(opts.heartbeatIntervalMs ?? 15_000));
-        this.#heartbeatScheduler = opts.heartbeatScheduler ?? new ActivityHeartbeatScheduler();
-        this.#ownsHeartbeatScheduler = !opts.heartbeatScheduler;
         this.#maxStoredLines = Math.max(50, Math.trunc(opts.maxStoredLines ?? 1_000));
         this.#maxHistory = Math.max(20, Math.trunc(opts.maxHistory ?? 200));
         this.#onEvent = opts.onEvent ?? null;
@@ -253,7 +239,6 @@ export class ControlPlaneRunSupervisor {
             stderr_lines: [],
             log_hints: new Set(),
             interrupt_requested: false,
-            next_heartbeat_reason: null,
             hard_kill_timer: null,
         };
         this.#jobsById.set(snapshot.job_id, job);
@@ -261,34 +246,11 @@ export class ControlPlaneRunSupervisor {
             this.#jobIdByRootIssueId.set(snapshot.root_issue_id, snapshot.job_id);
         }
         this.#emit("run_started", job, `🚀 Started ${describeRun(snapshot)} (job ${snapshot.job_id}, pid ${snapshot.pid ?? "?"})`);
-        this.#heartbeatScheduler.register({
-            activityId: snapshot.job_id,
-            everyMs: this.#heartbeatIntervalMs,
-            handler: async ({ reason }) => {
-                if (job.snapshot.status !== "running") {
-                    return { status: "skipped", reason: "not_running" };
-                }
-                const normalizedReason = reason?.trim();
-                const heartbeatReason = normalizedReason && normalizedReason.length > 0 && normalizedReason !== "interval"
-                    ? normalizedReason
-                    : job.next_heartbeat_reason;
-                if (heartbeatReason) {
-                    job.next_heartbeat_reason = null;
-                }
-                const elapsedSec = Math.max(0, Math.trunc((this.#nowMs() - job.snapshot.started_at_ms) / 1_000));
-                const root = job.snapshot.root_issue_id ?? job.snapshot.job_id;
-                const progress = job.snapshot.last_progress ? ` · ${job.snapshot.last_progress}` : "";
-                const reasonSuffix = heartbeatReason ? ` · wake=${heartbeatReason}` : "";
-                this.#emit("run_heartbeat", job, `⏱ ${root} running for ${elapsedSec}s${progress}${reasonSuffix}`);
-                return { status: "ran" };
-            },
-        });
         void (async () => {
             const stdoutTask = consumeStreamLines(process.stdout, (line) => this.#handleLine(job, "stdout", line));
             const stderrTask = consumeStreamLines(process.stderr, (line) => this.#handleLine(job, "stderr", line));
             const exitCode = await process.exited.catch(() => -1);
             await Promise.allSettled([stdoutTask, stderrTask]);
-            this.#heartbeatScheduler.unregister(job.snapshot.job_id);
             if (job.hard_kill_timer) {
                 clearTimeout(job.hard_kill_timer);
                 job.hard_kill_timer = null;
@@ -451,34 +413,6 @@ export class ControlPlaneRunSupervisor {
         this.#emit("run_interrupt_requested", job, `⚠️ Interrupt requested for ${root}.`);
         return { ok: true, reason: null, run: this.#snapshot(job) };
     }
-    heartbeat(opts) {
-        const target = opts.jobId?.trim() || opts.rootIssueId?.trim() || "";
-        if (target.length === 0) {
-            return { ok: false, reason: "missing_target", run: null };
-        }
-        const job = this.#resolveJob(target);
-        if (!job) {
-            return { ok: false, reason: "not_found", run: null };
-        }
-        if (job.snapshot.status !== "running") {
-            return { ok: false, reason: "not_running", run: this.#snapshot(job) };
-        }
-        const reason = opts.reason?.trim() || "manual";
-        const wakeMode = normalizeWakeMode(opts.wakeMode);
-        if (wakeMode === "next_heartbeat") {
-            job.next_heartbeat_reason = reason;
-            this.#touch(job);
-            return { ok: true, reason: null, run: this.#snapshot(job) };
-        }
-        if (reason !== "interval") {
-            job.next_heartbeat_reason = null;
-        }
-        this.#heartbeatScheduler.requestNow(job.snapshot.job_id, {
-            reason,
-            coalesceMs: 0,
-        });
-        return { ok: true, reason: null, run: this.#snapshot(job) };
-    }
     async startFromCommand(command) {
         switch (command.target_type) {
             case "run start": {
@@ -508,7 +442,6 @@ export class ControlPlaneRunSupervisor {
     }
     async stop() {
         for (const job of this.#jobsById.values()) {
-            this.#heartbeatScheduler.unregister(job.snapshot.job_id);
             if (job.hard_kill_timer) {
                 clearTimeout(job.hard_kill_timer);
                 job.hard_kill_timer = null;
@@ -522,8 +455,5 @@ export class ControlPlaneRunSupervisor {
                 }
             }
         }
-        if (this.#ownsHeartbeatScheduler) {
-            this.#heartbeatScheduler.stop();
-        }
     }
 }

package/dist/server.d.ts

@@ -1,8 +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 { ForumStore } from "@femtomc/mu-forum";
-import { IssueStore } from "@femtomc/mu-issue";
 import { ControlPlaneActivitySupervisor } from "./activity_supervisor.js";
 import { type MuConfig } from "./config.js";
 import type { ControlPlaneHandle, ControlPlaneSessionLifecycle } from "./control_plane_contract.js";
@@ -21,7 +19,6 @@ export type ServerOptions = {
     controlPlaneReloader?: ControlPlaneReloader;
     generationTelemetry?: GenerationTelemetryRecorder;
     operatorWakeCoalesceMs?: number;
-    autoRunHeartbeatEveryMs?: number;
     config?: MuConfig;
     configReader?: ConfigReader;
     configWriter?: ConfigWriter;
@@ -31,8 +28,6 @@ export type ServerOptions = {
 export type ServerInstanceOptions = Omit<ServerOptions, "repoRoot" | "controlPlane" | "heartbeatScheduler" | "generationTelemetry" | "config" | "sessionLifecycle">;
 export type ServerContext = {
     repoRoot: string;
-    issueStore: IssueStore;
-    forumStore: ForumStore;
     eventLog: EventLog;
     eventsStore: JsonlStore<EventEnvelope>;
 };