@femtomc/mu-server 26.2.70 → 26.2.71

package/dist/api/identities.js

@@ -0,0 +1,103 @@
+import { getControlPlanePaths, IdentityStore, ROLE_SCOPES, } from "@femtomc/mu-control-plane";
+export async function identityRoutes(request, url, deps, headers) {
+    const path = url.pathname;
+    const cpPaths = getControlPlanePaths(deps.context.repoRoot);
+    const identityStore = new IdentityStore(cpPaths.identitiesPath);
+    await identityStore.load();
+    if (path === "/api/identities") {
+        if (request.method !== "GET") {
+            return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+        }
+        const includeInactive = url.searchParams.get("include_inactive")?.trim().toLowerCase() === "true";
+        const bindings = identityStore.listBindings({ includeInactive });
+        return Response.json({ count: bindings.length, bindings }, { headers });
+    }
+    if (path === "/api/identities/link") {
+        if (request.method !== "POST") {
+            return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+        }
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return Response.json({ error: "invalid json body" }, { status: 400, headers });
+        }
+        const channel = typeof body.channel === "string" ? body.channel.trim() : "";
+        if (!channel || (channel !== "slack" && channel !== "discord" && channel !== "telegram")) {
+            return Response.json({ error: "channel is required (slack, discord, telegram)" }, { status: 400, headers });
+        }
+        const actorId = typeof body.actor_id === "string" ? body.actor_id.trim() : "";
+        if (!actorId) {
+            return Response.json({ error: "actor_id is required" }, { status: 400, headers });
+        }
+        const tenantId = typeof body.tenant_id === "string" ? body.tenant_id.trim() : "";
+        if (!tenantId) {
+            return Response.json({ error: "tenant_id is required" }, { status: 400, headers });
+        }
+        const roleKey = typeof body.role === "string" ? body.role.trim() : "operator";
+        const roleScopes = ROLE_SCOPES[roleKey];
+        if (!roleScopes) {
+            return Response.json({ error: `invalid role: ${roleKey} (operator, contributor, viewer)` }, { status: 400, headers });
+        }
+        const bindingId = typeof body.binding_id === "string" && body.binding_id.trim().length > 0
+            ? body.binding_id.trim()
+            : `bind-${crypto.randomUUID()}`;
+        const operatorId = typeof body.operator_id === "string" && body.operator_id.trim().length > 0
+            ? body.operator_id.trim()
+            : "default";
+        const decision = await identityStore.link({
+            bindingId,
+            operatorId,
+            channel: channel,
+            channelTenantId: tenantId,
+            channelActorId: actorId,
+            scopes: [...roleScopes],
+        });
+        switch (decision.kind) {
+            case "linked":
+                return Response.json({ ok: true, kind: "linked", binding: decision.binding }, { status: 201, headers });
+            case "binding_exists":
+                return Response.json({ ok: false, kind: "binding_exists", binding: decision.binding }, { status: 409, headers });
+            case "principal_already_linked":
+                return Response.json({ ok: false, kind: "principal_already_linked", binding: decision.binding }, { status: 409, headers });
+        }
+    }
+    if (path === "/api/identities/unlink") {
+        if (request.method !== "POST") {
+            return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+        }
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return Response.json({ error: "invalid json body" }, { status: 400, headers });
+        }
+        const bindingId = typeof body.binding_id === "string" ? body.binding_id.trim() : "";
+        if (!bindingId) {
+            return Response.json({ error: "binding_id is required" }, { status: 400, headers });
+        }
+        const actorBindingId = typeof body.actor_binding_id === "string" ? body.actor_binding_id.trim() : "";
+        if (!actorBindingId) {
+            return Response.json({ error: "actor_binding_id is required" }, { status: 400, headers });
+        }
+        const reason = typeof body.reason === "string" ? body.reason.trim() : null;
+        const decision = await identityStore.unlinkSelf({
+            bindingId,
+            actorBindingId,
+            reason: reason || null,
+        });
+        switch (decision.kind) {
+            case "unlinked":
+                return Response.json({ ok: true, kind: "unlinked", binding: decision.binding }, { headers });
+            case "not_found":
+                return Response.json({ ok: false, kind: "not_found" }, { status: 404, headers });
+            case "invalid_actor":
+                return Response.json({ ok: false, kind: "invalid_actor" }, { status: 403, headers });
+            case "already_inactive":
+                return Response.json({ ok: false, kind: "already_inactive", binding: decision.binding }, { status: 409, headers });
+        }
+    }
+    return Response.json({ error: "Not Found" }, { status: 404, headers });
+}

package/dist/api/runs.d.ts

@@ -0,0 +1,2 @@
+import type { ServerRoutingDependencies } from "../server_routing.js";
+export declare function runRoutes(request: Request, url: URL, deps: ServerRoutingDependencies, headers: Headers): Promise<Response>;

package/dist/api/runs.js

@@ -0,0 +1,207 @@
+import { normalizeWakeMode } from "../server_types.js";
+export async function runRoutes(request, url, deps, headers) {
+    const path = url.pathname;
+    if (path === "/api/runs") {
+        if (request.method !== "GET") {
+            return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+        }
+        const status = url.searchParams.get("status")?.trim() || undefined;
+        const limitRaw = url.searchParams.get("limit");
+        const limit = limitRaw && /^\d+$/.test(limitRaw) ? Math.max(1, Math.min(500, Number.parseInt(limitRaw, 10))) : undefined;
+        const runs = await deps.controlPlaneProxy.listRuns?.({ status, limit });
+        return Response.json({ count: runs?.length ?? 0, runs: runs ?? [] }, { headers });
+    }
+    if (path === "/api/runs/start") {
+        if (request.method !== "POST") {
+            return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+        }
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return Response.json({ error: "invalid json body" }, { status: 400, headers });
+        }
+        const prompt = typeof body.prompt === "string" ? body.prompt.trim() : "";
+        if (prompt.length === 0) {
+            return Response.json({ error: "prompt is required" }, { status: 400, headers });
+        }
+        const maxSteps = typeof body.max_steps === "number" && Number.isFinite(body.max_steps)
+            ? Math.max(1, Math.trunc(body.max_steps))
+            : undefined;
+        try {
+            const run = await deps.controlPlaneProxy.startRun?.({ prompt, maxSteps });
+            if (!run) {
+                return Response.json({ error: "run supervisor unavailable" }, { status: 503, headers });
+            }
+            await deps.registerAutoRunHeartbeatProgram(run).catch(async (error) => {
+                await deps.context.eventLog.emit("run.auto_heartbeat.lifecycle", {
+                    source: "mu-server.runs",
+                    payload: {
+                        action: "register_failed",
+                        run_job_id: run.job_id,
+                        error: deps.describeError(error),
+                    },
+                });
+            });
+            return Response.json({ ok: true, run }, { status: 201, headers });
+        }
+        catch (err) {
+            return Response.json({ error: deps.describeError(err) }, { status: 500, headers });
+        }
+    }
+    if (path === "/api/runs/resume") {
+        if (request.method !== "POST") {
+            return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+        }
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return Response.json({ error: "invalid json body" }, { status: 400, headers });
+        }
+        const rootIssueId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
+        if (rootIssueId.length === 0) {
+            return Response.json({ error: "root_issue_id is required" }, { status: 400, headers });
+        }
+        const maxSteps = typeof body.max_steps === "number" && Number.isFinite(body.max_steps)
+            ? Math.max(1, Math.trunc(body.max_steps))
+            : undefined;
+        try {
+            const run = await deps.controlPlaneProxy.resumeRun?.({ rootIssueId, maxSteps });
+            if (!run) {
+                return Response.json({ error: "run supervisor unavailable" }, { status: 503, headers });
+            }
+            await deps.registerAutoRunHeartbeatProgram(run).catch(async (error) => {
+                await deps.context.eventLog.emit("run.auto_heartbeat.lifecycle", {
+                    source: "mu-server.runs",
+                    payload: {
+                        action: "register_failed",
+                        run_job_id: run.job_id,
+                        error: deps.describeError(error),
+                    },
+                });
+            });
+            return Response.json({ ok: true, run }, { status: 201, headers });
+        }
+        catch (err) {
+            return Response.json({ error: deps.describeError(err) }, { status: 500, headers });
+        }
+    }
+    if (path === "/api/runs/interrupt") {
+        if (request.method !== "POST") {
+            return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+        }
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return Response.json({ error: "invalid json body" }, { status: 400, headers });
+        }
+        const rootIssueId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : null;
+        const jobId = typeof body.job_id === "string" ? body.job_id.trim() : null;
+        const result = await deps.controlPlaneProxy.interruptRun?.({
+            rootIssueId,
+            jobId,
+        });
+        if (!result) {
+            return Response.json({ error: "run supervisor unavailable" }, { status: 503, headers });
+        }
+        if (!result.ok && result.reason === "not_running" && result.run) {
+            await deps.disableAutoRunHeartbeatProgram({
+                jobId: result.run.job_id,
+                status: result.run.status,
+                reason: "interrupt_not_running",
+            }).catch(() => {
+                // best effort cleanup only
+            });
+        }
+        return Response.json(result, { status: result.ok ? 200 : 404, headers });
+    }
+    if (path === "/api/runs/heartbeat") {
+        if (request.method !== "POST") {
+            return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+        }
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return Response.json({ error: "invalid json body" }, { status: 400, headers });
+        }
+        const rootIssueId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : null;
+        const jobId = typeof body.job_id === "string" ? body.job_id.trim() : null;
+        const reason = typeof body.reason === "string" ? body.reason.trim() : null;
+        const wakeMode = normalizeWakeMode(body.wake_mode);
+        const result = await deps.controlPlaneProxy.heartbeatRun?.({
+            rootIssueId,
+            jobId,
+            reason,
+            wakeMode,
+        });
+        if (!result) {
+            return Response.json({ error: "run supervisor unavailable" }, { status: 503, headers });
+        }
+        if (!result.ok && result.reason === "not_running" && result.run) {
+            await deps.disableAutoRunHeartbeatProgram({
+                jobId: result.run.job_id,
+                status: result.run.status,
+                reason: "run_not_running",
+            }).catch(() => {
+                // best effort cleanup only
+            });
+        }
+        if (result.ok) {
+            return Response.json(result, { status: 200, headers });
+        }
+        if (result.reason === "missing_target") {
+            return Response.json(result, { status: 400, headers });
+        }
+        if (result.reason === "not_running") {
+            return Response.json(result, { status: 409, headers });
+        }
+        return Response.json(result, { status: 404, headers });
+    }
+    if (path.startsWith("/api/runs/")) {
+        const rest = path.slice("/api/runs/".length);
+        const [rawId, maybeSub] = rest.split("/");
+        const idOrRoot = decodeURIComponent(rawId ?? "").trim();
+        if (idOrRoot.length === 0) {
+            return Response.json({ error: "missing run id" }, { status: 400, headers });
+        }
+        if (maybeSub === "trace") {
+            if (request.method !== "GET") {
+                return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+            }
+            const limitRaw = url.searchParams.get("limit");
+            const limit = limitRaw && /^\d+$/.test(limitRaw)
+                ? Math.max(1, Math.min(2_000, Number.parseInt(limitRaw, 10)))
+                : undefined;
+            const trace = await deps.controlPlaneProxy.traceRun?.({ idOrRoot, limit });
+            if (!trace) {
+                return Response.json({ error: "run trace not found" }, { status: 404, headers });
+            }
+            return Response.json(trace, { headers });
+        }
+        if (request.method !== "GET") {
+            return Response.json({ error: "Method Not Allowed" }, { status: 405, headers });
+        }
+        const run = await deps.controlPlaneProxy.getRun?.(idOrRoot);
+        if (!run) {
+            return Response.json({ error: "run not found" }, { status: 404, headers });
+        }
+        if (run.status !== "running") {
+            await deps.disableAutoRunHeartbeatProgram({
+                jobId: run.job_id,
+                status: run.status,
+                reason: "run_terminal_snapshot",
+            }).catch(() => {
+                // best effort cleanup only
+            });
+        }
+        return Response.json(run, { headers });
+    }
+    return Response.json({ error: "Not Found" }, { status: 404, headers });
+}

package/dist/cli.js

@@ -1,19 +1,56 @@
 #!/usr/bin/env bun
+import { rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { findRepoRoot } from "@femtomc/mu-core/node";
 import { composeServerRuntime, createServerFromRuntime } from "./server.js";
-const port = parseInt(Bun.env.PORT || "3000", 10);
+// Parse CLI flags: --port N, --repo-root PATH
+function parseArgs(argv) {
+    let port = parseInt(Bun.env.PORT || "3000", 10);
+    let repoRoot = null;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--port" && i + 1 < argv.length) {
+            port = parseInt(argv[++i], 10);
+        }
+        else if (arg.startsWith("--port=")) {
+            port = parseInt(arg.slice("--port=".length), 10);
+        }
+        else if (arg === "--repo-root" && i + 1 < argv.length) {
+            repoRoot = argv[++i];
+        }
+        else if (arg.startsWith("--repo-root=")) {
+            repoRoot = arg.slice("--repo-root=".length);
+        }
+    }
+    return { port, repoRoot };
+}
+const args = parseArgs(process.argv.slice(2));
 let repoRoot;
 try {
-    repoRoot = findRepoRoot();
+    repoRoot = args.repoRoot ?? findRepoRoot();
 }
 catch {
     console.error("Error: Could not find .mu directory. Run 'mu serve' or 'mu run' once to initialize it.");
     process.exit(1);
 }
+const port = args.port;
+const discoveryPath = join(repoRoot, ".mu", "control-plane", "server.json");
 console.log(`Starting mu-server on port ${port}...`);
 console.log(`Repository root: ${repoRoot}`);
 const runtime = await composeServerRuntime({ repoRoot });
-const serverConfig = createServerFromRuntime(runtime, { port });
+const initiateShutdown = async () => {
+    console.log("Shutdown initiated via API");
+    try {
+        rmSync(discoveryPath, { force: true });
+    }
+    catch {
+        // best-effort
+    }
+    await runtime.controlPlane?.stop();
+    server.stop();
+    process.exit(0);
+};
+const serverConfig = createServerFromRuntime(runtime, { port, initiateShutdown });
 let server;
 try {
     server = Bun.serve(serverConfig);
@@ -27,6 +64,18 @@ catch (err) {
     }
     throw err;
 }
+// Write discovery file so clients can find this server
+try {
+    writeFileSync(discoveryPath, JSON.stringify({
+        pid: process.pid,
+        port,
+        url: `http://localhost:${port}`,
+        started_at_ms: Date.now(),
+    }) + "\n");
+}
+catch (err) {
+    console.error(`Warning: could not write ${discoveryPath}: ${err}`);
+}
 console.log(`Server running at http://localhost:${port}`);
 console.log(`Capabilities: lifecycle=[${runtime.capabilities.session_lifecycle_actions.join(",")}]`);
 if (runtime.controlPlane && runtime.controlPlane.activeAdapters.length > 0) {
@@ -40,6 +89,12 @@ else {
     console.log(`API Status: http://localhost:${port}/api/status`);
 }
 const cleanup = async () => {
+    try {
+        rmSync(discoveryPath, { force: true });
+    }
+    catch {
+        // best-effort
+    }
     await runtime.controlPlane?.stop();
     server.stop();
     process.exit(0);

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+export type WakeTurnMode = "off" | "shadow" | "active";
 export type MuConfig = {
     version: 1;
     control_plane: {
@@ -13,17 +14,11 @@ export type MuConfig = {
                 bot_token: string | null;
                 bot_username: string | null;
             };
-            gmail: {
-                enabled: boolean;
-                webhook_secret: string | null;
-                client_id: string | null;
-                client_secret: string | null;
-                refresh_token: string | null;
-            };
         };
         operator: {
             enabled: boolean;
             run_triggers_enabled: boolean;
+            wake_turn_mode: WakeTurnMode;
             provider: string | null;
             model: string | null;
         };
@@ -43,17 +38,11 @@ export type MuConfigPatch = {
                 bot_token?: string | null;
                 bot_username?: string | null;
             };
-            gmail?: {
-                enabled?: boolean;
-                webhook_secret?: string | null;
-                client_id?: string | null;
-                client_secret?: string | null;
-                refresh_token?: string | null;
-            };
         };
         operator?: {
             enabled?: boolean;
             run_triggers_enabled?: boolean;
+            wake_turn_mode?: WakeTurnMode;
             provider?: string | null;
             model?: string | null;
         };
@@ -73,17 +62,11 @@ export type MuConfigPresence = {
                 bot_token: boolean;
                 bot_username: boolean;
             };
-            gmail: {
-                enabled: boolean;
-                webhook_secret: boolean;
-                client_id: boolean;
-                client_secret: boolean;
-                refresh_token: boolean;
-            };
         };
         operator: {
             enabled: boolean;
             run_triggers_enabled: boolean;
+            wake_turn_mode: WakeTurnMode;
             provider: boolean;
             model: boolean;
         };

package/dist/config.js

@@ -15,17 +15,11 @@ export const DEFAULT_MU_CONFIG = {
                 bot_token: null,
                 bot_username: null,
             },
-            gmail: {
-                enabled: false,
-                webhook_secret: null,
-                client_id: null,
-                client_secret: null,
-                refresh_token: null,
-            },
         },
         operator: {
             enabled: true,
             run_triggers_enabled: true,
+            wake_turn_mode: "off",
             provider: null,
             model: null,
         },
@@ -60,6 +54,19 @@ function normalizeBoolean(value, fallback) {
     }
     return fallback;
 }
+function normalizeWakeTurnMode(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "shadow") {
+        return "shadow";
+    }
+    if (normalized === "active") {
+        return "active";
+    }
+    return "off";
+}
 export function normalizeMuConfig(input) {
     const next = cloneDefault();
     const root = asRecord(input);
@@ -90,24 +97,6 @@ export function normalizeMuConfig(input) {
                 next.control_plane.adapters.telegram.bot_username = normalizeNullableString(telegram.bot_username);
             }
         }
-        const gmail = asRecord(adapters.gmail);
-        if (gmail) {
-            if ("enabled" in gmail) {
-                next.control_plane.adapters.gmail.enabled = normalizeBoolean(gmail.enabled, next.control_plane.adapters.gmail.enabled);
-            }
-            if ("webhook_secret" in gmail) {
-                next.control_plane.adapters.gmail.webhook_secret = normalizeNullableString(gmail.webhook_secret);
-            }
-            if ("client_id" in gmail) {
-                next.control_plane.adapters.gmail.client_id = normalizeNullableString(gmail.client_id);
-            }
-            if ("client_secret" in gmail) {
-                next.control_plane.adapters.gmail.client_secret = normalizeNullableString(gmail.client_secret);
-            }
-            if ("refresh_token" in gmail) {
-                next.control_plane.adapters.gmail.refresh_token = normalizeNullableString(gmail.refresh_token);
-            }
-        }
     }
     const operator = asRecord(controlPlane.operator);
     if (operator) {
@@ -117,6 +106,9 @@ export function normalizeMuConfig(input) {
         if ("run_triggers_enabled" in operator) {
             next.control_plane.operator.run_triggers_enabled = normalizeBoolean(operator.run_triggers_enabled, next.control_plane.operator.run_triggers_enabled);
         }
+        if ("wake_turn_mode" in operator) {
+            next.control_plane.operator.wake_turn_mode = normalizeWakeTurnMode(operator.wake_turn_mode, next.control_plane.operator.wake_turn_mode);
+        }
         if ("provider" in operator) {
             next.control_plane.operator.provider = normalizeNullableString(operator.provider);
         }
@@ -166,28 +158,6 @@ function normalizeMuConfigPatch(input) {
                 patch.control_plane.adapters.telegram = telegramPatch;
             }
         }
-        const gmail = asRecord(adapters.gmail);
-        if (gmail) {
-            const gmailPatch = {};
-            if ("enabled" in gmail) {
-                gmailPatch.enabled = normalizeBoolean(gmail.enabled, DEFAULT_MU_CONFIG.control_plane.adapters.gmail.enabled);
-            }
-            if ("webhook_secret" in gmail) {
-                gmailPatch.webhook_secret = normalizeNullableString(gmail.webhook_secret);
-            }
-            if ("client_id" in gmail) {
-                gmailPatch.client_id = normalizeNullableString(gmail.client_id);
-            }
-            if ("client_secret" in gmail) {
-                gmailPatch.client_secret = normalizeNullableString(gmail.client_secret);
-            }
-            if ("refresh_token" in gmail) {
-                gmailPatch.refresh_token = normalizeNullableString(gmail.refresh_token);
-            }
-            if (Object.keys(gmailPatch).length > 0) {
-                patch.control_plane.adapters.gmail = gmailPatch;
-            }
-        }
     }
     const operator = asRecord(controlPlane.operator);
     if (operator) {
@@ -198,6 +168,9 @@ function normalizeMuConfigPatch(input) {
         if ("run_triggers_enabled" in operator) {
             patch.control_plane.operator.run_triggers_enabled = normalizeBoolean(operator.run_triggers_enabled, DEFAULT_MU_CONFIG.control_plane.operator.run_triggers_enabled);
         }
+        if ("wake_turn_mode" in operator) {
+            patch.control_plane.operator.wake_turn_mode = normalizeWakeTurnMode(operator.wake_turn_mode, DEFAULT_MU_CONFIG.control_plane.operator.wake_turn_mode);
+        }
         if ("provider" in operator) {
             patch.control_plane.operator.provider = normalizeNullableString(operator.provider);
         }
@@ -241,23 +214,6 @@ export function applyMuConfigPatch(base, patchInput) {
                 next.control_plane.adapters.telegram.bot_username = adapters.telegram.bot_username ?? null;
             }
         }
-        if (adapters.gmail) {
-            if ("enabled" in adapters.gmail && typeof adapters.gmail.enabled === "boolean") {
-                next.control_plane.adapters.gmail.enabled = adapters.gmail.enabled;
-            }
-            if ("webhook_secret" in adapters.gmail) {
-                next.control_plane.adapters.gmail.webhook_secret = adapters.gmail.webhook_secret ?? null;
-            }
-            if ("client_id" in adapters.gmail) {
-                next.control_plane.adapters.gmail.client_id = adapters.gmail.client_id ?? null;
-            }
-            if ("client_secret" in adapters.gmail) {
-                next.control_plane.adapters.gmail.client_secret = adapters.gmail.client_secret ?? null;
-            }
-            if ("refresh_token" in adapters.gmail) {
-                next.control_plane.adapters.gmail.refresh_token = adapters.gmail.refresh_token ?? null;
-            }
-        }
     }
     const operator = patch.control_plane.operator;
     if (operator) {
@@ -267,6 +223,9 @@ export function applyMuConfigPatch(base, patchInput) {
         if ("run_triggers_enabled" in operator && typeof operator.run_triggers_enabled === "boolean") {
             next.control_plane.operator.run_triggers_enabled = operator.run_triggers_enabled;
         }
+        if ("wake_turn_mode" in operator) {
+            next.control_plane.operator.wake_turn_mode = normalizeWakeTurnMode(operator.wake_turn_mode, next.control_plane.operator.wake_turn_mode);
+        }
         if ("provider" in operator) {
             next.control_plane.operator.provider = operator.provider ?? null;
         }
@@ -317,10 +276,6 @@ export function redactMuConfigSecrets(config) {
     next.control_plane.adapters.discord.signing_secret = redacted(next.control_plane.adapters.discord.signing_secret);
     next.control_plane.adapters.telegram.webhook_secret = redacted(next.control_plane.adapters.telegram.webhook_secret);
     next.control_plane.adapters.telegram.bot_token = redacted(next.control_plane.adapters.telegram.bot_token);
-    next.control_plane.adapters.gmail.webhook_secret = redacted(next.control_plane.adapters.gmail.webhook_secret);
-    next.control_plane.adapters.gmail.client_id = redacted(next.control_plane.adapters.gmail.client_id);
-    next.control_plane.adapters.gmail.client_secret = redacted(next.control_plane.adapters.gmail.client_secret);
-    next.control_plane.adapters.gmail.refresh_token = redacted(next.control_plane.adapters.gmail.refresh_token);
     return next;
 }
 function isPresent(value) {
@@ -341,17 +296,11 @@ export function muConfigPresence(config) {
                     bot_token: isPresent(config.control_plane.adapters.telegram.bot_token),
                     bot_username: isPresent(config.control_plane.adapters.telegram.bot_username),
                 },
-                gmail: {
-                    enabled: config.control_plane.adapters.gmail.enabled,
-                    webhook_secret: isPresent(config.control_plane.adapters.gmail.webhook_secret),
-                    client_id: isPresent(config.control_plane.adapters.gmail.client_id),
-                    client_secret: isPresent(config.control_plane.adapters.gmail.client_secret),
-                    refresh_token: isPresent(config.control_plane.adapters.gmail.refresh_token),
-                },
             },
             operator: {
                 enabled: config.control_plane.operator.enabled,
                 run_triggers_enabled: config.control_plane.operator.run_triggers_enabled,
+                wake_turn_mode: config.control_plane.operator.wake_turn_mode,
                 provider: isPresent(config.control_plane.operator.provider),
                 model: isPresent(config.control_plane.operator.model),
             },

package/dist/control_plane.d.ts

@@ -1,9 +1,9 @@
 import type { MessagingOperatorBackend, MessagingOperatorRuntime } from "@femtomc/mu-agent";
 import { type GenerationTelemetryRecorder } from "@femtomc/mu-control-plane";
-import type { ControlPlaneConfig, ControlPlaneGenerationContext, ControlPlaneHandle, ControlPlaneSessionLifecycle, TelegramGenerationSwapHooks } from "./control_plane_contract.js";
+import { type ControlPlaneConfig, type ControlPlaneGenerationContext, type ControlPlaneHandle, type ControlPlaneSessionLifecycle, type InterRootQueuePolicy, type TelegramGenerationSwapHooks, type WakeDeliveryObserver } from "./control_plane_contract.js";
 import type { ActivityHeartbeatScheduler } from "./heartbeat_scheduler.js";
 import { type ControlPlaneRunSupervisorOpts } from "./run_supervisor.js";
-export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneGenerationContext, ControlPlaneHandle, ControlPlaneSessionLifecycle, ControlPlaneSessionMutationAction, ControlPlaneSessionMutationResult, TelegramGenerationReloadResult, TelegramGenerationRollbackTrigger, TelegramGenerationSwapHooks, } from "./control_plane_contract.js";
+export type { ActiveAdapter, ControlPlaneConfig, ControlPlaneGenerationContext, ControlPlaneHandle, ControlPlaneSessionLifecycle, ControlPlaneSessionMutationAction, ControlPlaneSessionMutationResult, NotifyOperatorsOpts, NotifyOperatorsResult, TelegramGenerationReloadResult, TelegramGenerationRollbackTrigger, TelegramGenerationSwapHooks, WakeDeliveryEvent, WakeDeliveryObserver, WakeNotifyContext, WakeNotifyDecision, } from "./control_plane_contract.js";
 type DetectedAdapter = {
     name: "slack";
     signingSecret: string;
@@ -47,6 +47,8 @@ export type BootstrapControlPlaneOpts = {
     generation?: ControlPlaneGenerationContext;
     telemetry?: GenerationTelemetryRecorder | null;
     telegramGenerationHooks?: TelegramGenerationSwapHooks;
+    wakeDeliveryObserver?: WakeDeliveryObserver | null;
     terminalEnabled?: boolean;
+    interRootQueuePolicy?: InterRootQueuePolicy;
 };
 export declare function bootstrapControlPlane(opts: BootstrapControlPlaneOpts): Promise<ControlPlaneHandle | null>;