@femtomc/mu-server 26.2.72 → 26.2.73

package/dist/control_plane_bootstrap_helpers.js

@@ -1,4 +1,5 @@
-import { ApprovedCommandBroker, CommandContextResolver, MessagingOperatorRuntime, operatorExtensionPaths, PiMessagingOperatorBackend, } from "@femtomc/mu-agent";
+import { ApprovedCommandBroker, CommandContextResolver, JsonFileConversationSessionStore, MessagingOperatorRuntime, operatorExtensionPaths, PiMessagingOperatorBackend, } from "@femtomc/mu-agent";
+import { join } from "node:path";
 import { ControlPlaneOutboxDispatcher, } from "@femtomc/mu-control-plane";
 const OUTBOX_DRAIN_INTERVAL_MS = 500;
 export function buildMessagingOperatorRuntime(opts) {
@@ -11,6 +12,7 @@ export function buildMessagingOperatorRuntime(opts) {
             model: opts.config.operator.model ?? undefined,
             extensionPaths: operatorExtensionPaths,
         });
+    const conversationSessionStore = new JsonFileConversationSessionStore(join(opts.repoRoot, ".mu", "control-plane", "operator_conversations.json"));
     return new MessagingOperatorRuntime({
         backend,
         broker: new ApprovedCommandBroker({
@@ -18,6 +20,7 @@ export function buildMessagingOperatorRuntime(opts) {
             contextResolver: new CommandContextResolver({ allowedRepoRoots: [opts.repoRoot] }),
         }),
         enabled: true,
+        conversationSessionStore,
     });
 }
 export function createOutboxDrainLoop(opts) {

package/dist/control_plane_contract.d.ts

@@ -11,12 +11,9 @@ import type { MuConfig } from "./config.js";
 export type ControlPlaneConfig = MuConfig["control_plane"];
 /**
  * Durable orchestration queue contract (default-on path).
- *
- * Scheduler policy/state-machine primitives are owned by `@femtomc/mu-orchestrator` and
- * re-exported here so existing server/control-plane callers keep a stable import surface.
  */
-export type { InterRootQueuePolicy, OrchestrationQueueState } from "@femtomc/mu-orchestrator";
-export { DEFAULT_INTER_ROOT_QUEUE_POLICY, normalizeInterRootQueuePolicy, ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS, ORCHESTRATION_QUEUE_INVARIANTS, } from "@femtomc/mu-orchestrator";
+export type { InterRootQueuePolicy, OrchestrationQueueState } from "./orchestration_queue.js";
+export { DEFAULT_INTER_ROOT_QUEUE_POLICY, normalizeInterRootQueuePolicy, ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS, ORCHESTRATION_QUEUE_INVARIANTS, } from "./orchestration_queue.js";
 export type ActiveAdapter = {
     name: Channel;
     route: string;

package/dist/control_plane_contract.js

@@ -1 +1 @@
-export { DEFAULT_INTER_ROOT_QUEUE_POLICY, normalizeInterRootQueuePolicy, ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS, ORCHESTRATION_QUEUE_INVARIANTS, } from "@femtomc/mu-orchestrator";
+export { DEFAULT_INTER_ROOT_QUEUE_POLICY, normalizeInterRootQueuePolicy, ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS, ORCHESTRATION_QUEUE_INVARIANTS, } from "./orchestration_queue.js";

package/dist/orchestration_queue.d.ts

@@ -0,0 +1,44 @@
+export type OrchestrationQueueState = "queued" | "active" | "waiting_review" | "refining" | "done" | "failed" | "cancelled";
+/**
+ * Inter-root scheduler policy knob for durable queue drain.
+ * - sequential: exactly one active root (`max_active_roots=1`)
+ * - parallel: bounded fanout (`max_active_roots>=1`)
+ */
+export type InterRootQueuePolicy = {
+    mode: "sequential";
+    max_active_roots: 1;
+} | {
+    mode: "parallel";
+    max_active_roots: number;
+};
+export declare const DEFAULT_INTER_ROOT_QUEUE_POLICY: InterRootQueuePolicy;
+export declare function normalizeInterRootQueuePolicy(policy: InterRootQueuePolicy | null | undefined): InterRootQueuePolicy;
+/**
+ * Allowed queue transitions. Queue tests should enforce this table exactly.
+ */
+export declare const ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS: Record<OrchestrationQueueState, readonly OrchestrationQueueState[]>;
+export declare const ORCHESTRATION_QUEUE_INVARIANTS: readonly ["ORCH-QUEUE-001: Queue writes are durable before acknowledging enqueue/start/resume requests.", "ORCH-QUEUE-002: Queue dispatch must claim exactly one active item at a time per root slot.", "ORCH-QUEUE-003: Terminal states (done|failed|cancelled) are immutable.", "ORCH-QUEUE-004: Review path is active -> waiting_review -> (done | refining).", "ORCH-QUEUE-005: Refinement re-enters execution only via refining -> queued.", "ORCH-QUEUE-006: sequential policy permits <=1 active root; parallel permits <=max_active_roots active roots."];
+export type InterRootQueueSnapshot = {
+    queue_id: string;
+    root_issue_id: string | null;
+    state: OrchestrationQueueState;
+    job_id: string | null;
+    created_at_ms: number;
+};
+export type InterRootQueueReconcilePlan = {
+    policy: InterRootQueuePolicy;
+    max_active_roots: number;
+    active_root_count: number;
+    available_root_slots: number;
+    activate_queue_ids: string[];
+    launch_queue_ids: string[];
+};
+export declare const INTER_ROOT_QUEUE_RECONCILE_INVARIANTS: readonly ["ORCH-INTER-ROOT-RECON-001: one queue snapshot + policy yields one deterministic activation/launch plan.", "ORCH-INTER-ROOT-RECON-002: activation order is FIFO (`created_at_ms`, then `queue_id`) with per-root slot dedupe.", "ORCH-INTER-ROOT-RECON-003: sequential policy admits <=1 occupied root; parallel admits <=max_active_roots roots.", "ORCH-INTER-ROOT-RECON-004: launch candidates are active rows without bound job ids, one launch per root slot."];
+/**
+ * Deterministic inter-root queue reconcile primitive.
+ *
+ * Computes queue activation/launch intentions from durable queue state and policy. The caller is
+ * responsible for performing side effects (claim, launch, bind, transition) and reconciling again
+ * against refreshed queue/runtime snapshots.
+ */
+export declare function reconcileInterRootQueue<Row extends InterRootQueueSnapshot>(rows: readonly Row[], policy: InterRootQueuePolicy): InterRootQueueReconcilePlan;

package/dist/orchestration_queue.js

@@ -0,0 +1,111 @@
+export const DEFAULT_INTER_ROOT_QUEUE_POLICY = {
+    mode: "sequential",
+    max_active_roots: 1,
+};
+export function normalizeInterRootQueuePolicy(policy) {
+    if (!policy) {
+        return DEFAULT_INTER_ROOT_QUEUE_POLICY;
+    }
+    if (policy.mode === "parallel") {
+        return {
+            mode: "parallel",
+            max_active_roots: Math.max(1, Math.trunc(policy.max_active_roots)),
+        };
+    }
+    return DEFAULT_INTER_ROOT_QUEUE_POLICY;
+}
+/**
+ * Allowed queue transitions. Queue tests should enforce this table exactly.
+ */
+export const ORCHESTRATION_QUEUE_ALLOWED_TRANSITIONS = {
+    queued: ["active", "cancelled"],
+    active: ["waiting_review", "done", "failed", "cancelled"],
+    waiting_review: ["refining", "done", "failed", "cancelled"],
+    refining: ["queued", "failed", "cancelled"],
+    done: [],
+    failed: [],
+    cancelled: [],
+};
+export const ORCHESTRATION_QUEUE_INVARIANTS = [
+    "ORCH-QUEUE-001: Queue writes are durable before acknowledging enqueue/start/resume requests.",
+    "ORCH-QUEUE-002: Queue dispatch must claim exactly one active item at a time per root slot.",
+    "ORCH-QUEUE-003: Terminal states (done|failed|cancelled) are immutable.",
+    "ORCH-QUEUE-004: Review path is active -> waiting_review -> (done | refining).",
+    "ORCH-QUEUE-005: Refinement re-enters execution only via refining -> queued.",
+    "ORCH-QUEUE-006: sequential policy permits <=1 active root; parallel permits <=max_active_roots active roots.",
+];
+const INTER_ROOT_OCCUPIED_STATES = new Set(["active", "waiting_review", "refining"]);
+export const INTER_ROOT_QUEUE_RECONCILE_INVARIANTS = [
+    "ORCH-INTER-ROOT-RECON-001: one queue snapshot + policy yields one deterministic activation/launch plan.",
+    "ORCH-INTER-ROOT-RECON-002: activation order is FIFO (`created_at_ms`, then `queue_id`) with per-root slot dedupe.",
+    "ORCH-INTER-ROOT-RECON-003: sequential policy admits <=1 occupied root; parallel admits <=max_active_roots roots.",
+    "ORCH-INTER-ROOT-RECON-004: launch candidates are active rows without bound job ids, one launch per root slot.",
+];
+function stableCompare(a, b) {
+    if (a.created_at_ms !== b.created_at_ms) {
+        return a.created_at_ms - b.created_at_ms;
+    }
+    return a.queue_id.localeCompare(b.queue_id);
+}
+function normalizeMaxActiveRoots(policy) {
+    if (policy.mode === "parallel") {
+        return Math.max(1, Math.trunc(policy.max_active_roots));
+    }
+    return 1;
+}
+function queueRootSlotKey(row) {
+    return row.root_issue_id ? `root:${row.root_issue_id}` : `queue:${row.queue_id}`;
+}
+/**
+ * Deterministic inter-root queue reconcile primitive.
+ *
+ * Computes queue activation/launch intentions from durable queue state and policy. The caller is
+ * responsible for performing side effects (claim, launch, bind, transition) and reconciling again
+ * against refreshed queue/runtime snapshots.
+ */
+export function reconcileInterRootQueue(rows, policy) {
+    const sorted = [...rows].sort(stableCompare);
+    const maxActiveRoots = normalizeMaxActiveRoots(policy);
+    const occupiedRoots = new Set();
+    const launchRoots = new Set();
+    const launchQueueIds = [];
+    for (const row of sorted) {
+        if (!INTER_ROOT_OCCUPIED_STATES.has(row.state)) {
+            continue;
+        }
+        const slotKey = queueRootSlotKey(row);
+        occupiedRoots.add(slotKey);
+        if (row.state !== "active" || row.job_id != null || launchRoots.has(slotKey)) {
+            continue;
+        }
+        launchRoots.add(slotKey);
+        launchQueueIds.push(row.queue_id);
+    }
+    const availableRootSlots = Math.max(0, maxActiveRoots - occupiedRoots.size);
+    const claimedRoots = new Set();
+    const activateQueueIds = [];
+    if (availableRootSlots > 0) {
+        for (const row of sorted) {
+            if (row.state !== "queued") {
+                continue;
+            }
+            const slotKey = queueRootSlotKey(row);
+            if (occupiedRoots.has(slotKey) || claimedRoots.has(slotKey)) {
+                continue;
+            }
+            claimedRoots.add(slotKey);
+            activateQueueIds.push(row.queue_id);
+            if (activateQueueIds.length >= availableRootSlots) {
+                break;
+            }
+        }
+    }
+    return {
+        policy,
+        max_active_roots: maxActiveRoots,
+        active_root_count: occupiedRoots.size,
+        available_root_slots: availableRootSlots,
+        activate_queue_ids: activateQueueIds,
+        launch_queue_ids: launchQueueIds,
+    };
+}

package/dist/run_queue.d.ts

@@ -1,5 +1,5 @@
 import type { JsonlStore } from "@femtomc/mu-core";
-import { type InterRootQueuePolicy, type InterRootQueueReconcilePlan, type OrchestrationQueueState } from "@femtomc/mu-orchestrator";
+import { type InterRootQueuePolicy, type InterRootQueueReconcilePlan, type OrchestrationQueueState } from "./orchestration_queue.js";
 import type { ControlPlaneRunMode, ControlPlaneRunSnapshot, ControlPlaneRunStatus } from "./run_supervisor.js";
 export type DurableRunQueueState = OrchestrationQueueState;
 export type DurableRunQueueSnapshot = {

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

@@ -73,7 +73,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;

package/dist/run_supervisor.js

@@ -103,7 +103,7 @@ 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;