@rync/moorline-discord-default 0.0.2 → 0.0.4

package/packages/plugins/rync/discord-runtime/index.mjs

@@ -4,29 +4,20 @@ import { createRequire as __moorlineCreateRequire } from 'node:module'; const re
 var manifest_default = {
   id: "rync/discord-runtime",
   name: "rync/discord-runtime",
-  version: "0.0.2",
+  version: "0.0.4",
   type: "plugin",
   description: "Discord runtime commands and message routing for Moorline.",
   entrypoint: "index.mjs",
   priority: 100,
   capabilities: [
-    "runtime.control",
-    "memory.read",
     "transport.message.send",
-    "transport.resource.create",
-    "transport.resource.update",
-    "transport.resource.delete",
-    "net.connect",
     "fs.read",
     "session.inspect",
-    "session.create",
-    "session.archive",
-    "session.delete"
+    "provider.headless.run"
   ],
   hooks: [
     "onAction",
-    "onDomainEvent",
-    "onTransportEvent"
+    "onTransportIntent"
   ],
   defaultEnabled: true,
   dependencies: [
@@ -39,458 +30,9 @@ var manifest_default = {
   ]
 };
 
-// packages/discord-runtime/modules/shared.mjs
-function discordAction(id, title, commandName, commandDescription, subcommandName, subcommandDescription, options, policy) {
-  if (Array.isArray(subcommandName) || subcommandName === void 0 && subcommandDescription && typeof subcommandDescription === "object" && !Array.isArray(subcommandDescription)) {
-    policy = subcommandDescription;
-    options = subcommandName;
-    subcommandDescription = void 0;
-    subcommandName = void 0;
-  }
-  return {
-    id,
-    title,
-    description: subcommandDescription ?? commandDescription,
-    ...policy ? { policy } : {},
-    metadata: {
-      discordCommand: {
-        commandName,
-        commandDescription,
-        ...subcommandName ? { subcommandName } : {},
-        ...subcommandDescription ? { subcommandDescription } : {},
-        ...options ? { options } : {}
-      }
-    }
-  };
-}
-function stringOption(input, key) {
-  const value = input[key];
-  return typeof value === "string" ? value.trim() : "";
-}
-function toRuntimeReply(payload) {
-  const blocks = (payload.embeds ?? []).map((embed) => ({
-    kind: "fields",
-    ...embed.title ? { title: embed.title } : {},
-    ...embed.description ? { text: embed.description } : {},
-    ...embed.fields ? {
-      fields: embed.fields.map((field) => ({
-        label: field.name,
-        value: field.value,
-        ...field.inline !== void 0 ? { inline: field.inline } : {}
-      }))
-    } : {}
-  }));
-  return {
-    ...payload.content ? { text: payload.content } : {},
-    ...blocks.length > 0 ? { blocks } : {}
-  };
-}
-async function reply(event, payload) {
-  const native = event.native?.payload;
-  if (native && typeof native === "object" && typeof native.reply === "function") {
-    await native.reply(payload);
-    return { handled: true };
-  }
-  return { handled: true, reply: toRuntimeReply(payload) };
-}
-async function defer(event, payload) {
-  const native = event.native?.payload;
-  if (native && typeof native === "object" && typeof native.defer === "function") {
-    await native.defer(payload);
-  }
-}
-function isMissingPermissions(error) {
-  return !!error && typeof error === "object" && error.code === 50013;
-}
-function workspaceDisplay(sessionId) {
-  return `runtime/workspaces/${sessionId}`;
-}
-
-// packages/discord-runtime/modules/admin-control/index.mjs
-function currentThreadIdOrNull(context, transportResourceId) {
-  return context.getSessionByTransportResourceId(transportResourceId)?.threadId ?? null;
-}
-var admin_control_default = {
-  id: manifest_default.id,
-  manifest: manifest_default,
-  actions() {
-    return [
-      discordAction(
-        "runtime.admin.status",
-        "Admin status",
-        "admin",
-        "Administrative runtime controls",
-        "status",
-        "Show runtime control state",
-        void 0,
-        { allowedWhileDraining: true, bypassQueue: true }
-      ),
-      discordAction(
-        "runtime.admin.reload",
-        "Reload runtime",
-        "admin",
-        "Administrative runtime controls",
-        "reload",
-        "Reload the runtime worker",
-        [
-          {
-            type: "string",
-            name: "mode",
-            description: "Reload mode",
-            required: true,
-            choices: [
-              { name: "graceful", value: "graceful" },
-              { name: "force", value: "force" }
-            ]
-          }
-        ],
-        { allowedWhileDraining: true, bypassQueue: true }
-      ),
-      discordAction(
-        "runtime.admin.provider-stop",
-        "Stop provider sessions",
-        "admin",
-        "Administrative runtime controls",
-        "provider-stop",
-        "Stop provider sessions",
-        [
-          {
-            type: "string",
-            name: "scope",
-            description: "Whether to stop all sessions or only the current session",
-            required: true,
-            choices: [
-              { name: "all", value: "all" },
-              { name: "current", value: "current" }
-            ]
-          }
-        ],
-        { allowedWhileDraining: true, bypassQueue: true }
-      ),
-      discordAction(
-        "runtime.admin.provider-start",
-        "Recover provider sessions",
-        "admin",
-        "Administrative runtime controls",
-        "provider-start",
-        "Recover provider sessions",
-        [
-          {
-            type: "string",
-            name: "scope",
-            description: "Whether to recover all sessions or only the current session",
-            required: true,
-            choices: [
-              { name: "all", value: "all" },
-              { name: "current", value: "current" }
-            ]
-          }
-        ],
-        { allowedWhileDraining: true, bypassQueue: true }
-      ),
-      discordAction(
-        "runtime.admin.accepting",
-        "Toggle accepting work",
-        "admin",
-        "Administrative runtime controls",
-        "accepting",
-        "Enable or disable acceptance of new work",
-        [
-          {
-            type: "string",
-            name: "value",
-            description: "Whether the runtime should accept new work",
-            required: true,
-            choices: [
-              { name: "true", value: "true" },
-              { name: "false", value: "false" }
-            ]
-          }
-        ],
-        { allowedWhileDraining: true, bypassQueue: true }
-      )
-    ];
-  },
-  async onAction(event, context) {
-    if (!event.actionId.startsWith("runtime.admin.")) {
-      return { handled: false };
-    }
-    const requestedBy = event.actor;
-    if (!context.isAdminActor(requestedBy)) {
-      context.appendAuditEvent("runtime.admin.denied", {
-        actionId: event.actionId,
-        requestedBy: requestedBy.actorId,
-        accessGroupIds: requestedBy.accessGroupIds ?? [],
-        isSurfaceAdmin: requestedBy.isSurfaceAdmin === true
-      });
-      return await reply(event, {
-        content: "This command is restricted to Moorline admins.",
-        ephemeral: true
-      });
-    }
-    if (event.actionId === "runtime.admin.status") {
-      const control = context.getRuntimeControlStatus();
-      const runtime = context.getRuntimeStatus();
-      return await reply(event, {
-        content: "Moorline admin status",
-        embeds: [
-          {
-            title: "Runtime Control",
-            color: 3447003,
-            fields: [
-              { name: "Supervised", value: control.supervised ? "yes" : "no", inline: true },
-              { name: "Accepting Work", value: control.acceptingNewWork ? "yes" : "no", inline: true },
-              { name: "Running Sessions", value: String(runtime.runningSessions), inline: true },
-              { name: "Waiting Sessions", value: String(runtime.waitingSessions), inline: true }
-            ],
-            timestamp: context.nowIso()
-          }
-        ],
-        ephemeral: true
-      });
-    }
-    if (event.actionId === "runtime.admin.reload") {
-      const mode = stringOption(event.input, "mode") === "force" ? "force" : "graceful";
-      const result = await context.requestRuntimeReload({
-        mode,
-        reason: `Discord admin request from ${requestedBy.actorId}`,
-        requestedBy
-      });
-      context.appendAuditEvent("runtime.reload.requested.by-admin", {
-        requestedBy: requestedBy.actorId,
-        mode
-      });
-      return await reply(event, {
-        content: result.detail,
-        ephemeral: true
-      });
-    }
-    if (event.actionId === "runtime.admin.provider-stop") {
-      const threadId = stringOption(event.input, "scope") === "current" && event.transportResourceId ? currentThreadIdOrNull(context, event.transportResourceId) : null;
-      if (stringOption(event.input, "scope") === "current" && !threadId) {
-        return await reply(event, {
-          content: "This resource does not map to an active Moorline session.",
-          ephemeral: true
-        });
-      }
-      await context.stopProvider({
-        ...threadId ? { threadId } : {},
-        reason: `Discord admin request from ${requestedBy.actorId}`,
-        requestedBy
-      });
-      return await reply(event, {
-        content: threadId ? `Stopped provider session ${threadId}.` : "Stopped all provider sessions.",
-        ephemeral: true
-      });
-    }
-    if (event.actionId === "runtime.admin.provider-start") {
-      const threadId = stringOption(event.input, "scope") === "current" && event.transportResourceId ? currentThreadIdOrNull(context, event.transportResourceId) : null;
-      if (stringOption(event.input, "scope") === "current" && !threadId) {
-        return await reply(event, {
-          content: "This resource does not map to an active Moorline session.",
-          ephemeral: true
-        });
-      }
-      await context.startProvider({
-        ...threadId ? { threadId } : {},
-        reason: `Discord admin request from ${requestedBy.actorId}`,
-        requestedBy
-      });
-      return await reply(event, {
-        content: threadId ? `Recovered provider session ${threadId}.` : "Recovered all provider sessions.",
-        ephemeral: true
-      });
-    }
-    if (event.actionId === "runtime.admin.accepting") {
-      const accepting = stringOption(event.input, "value") === "true";
-      await context.setRuntimeAcceptingNewWork({
-        accepting,
-        reason: `Discord admin request from ${requestedBy.actorId}`,
-        requestedBy
-      });
-      return await reply(event, {
-        content: accepting ? "Runtime is now accepting new work." : "Runtime is no longer accepting new work.",
-        ephemeral: true
-      });
-    }
-    return await reply(event, {
-      content: `Unsupported admin action: ${event.actionId}`,
-      ephemeral: true
-    });
-  }
-};
-
-// packages/discord-runtime/modules/channel-lifecycle/index.mjs
-function summarizeArchivedTarget(target) {
-  return {
-    id: target.session.sessionId,
-    transportResourceId: target.session.transportResourceId,
-    workspacePath: target.session.workspacePath
-  };
-}
-var channel_lifecycle_default = {
-  id: manifest_default.id,
-  manifest: manifest_default,
-  actions() {
-    return [
-      discordAction(
-        "resource.archive",
-        "Archive the current Moorline session resource",
-        "archive",
-        "Archive the current Moorline session resource",
-        void 0,
-        { allowedWhileDraining: true, bypassQueue: true }
-      ),
-      discordAction(
-        "resource.delete",
-        "Delete the current archived Moorline session resource",
-        "delete",
-        "Delete the current archived Moorline session resource",
-        [
-          {
-            type: "string",
-            name: "confirm",
-            description: "Type delete to confirm destructive removal",
-            required: true,
-            choices: [{ name: "delete", value: "delete" }]
-          }
-        ],
-        { allowedWhileDraining: true, bypassQueue: true }
-      )
-    ];
-  },
-  async onAction(event, context) {
-    if (event.actionId === "resource.archive") {
-      if (!event.transportResourceId) {
-        return await reply(event, { content: "This action requires a target resource.", ephemeral: true });
-      }
-      try {
-        const archived = await context.archiveTransportResourceTarget({ transportResourceId: event.transportResourceId });
-        if (!archived) {
-          return await reply(event, {
-            content: "This resource is not an archivable Moorline session.",
-            ephemeral: true
-          });
-        }
-        const target = summarizeArchivedTarget(archived);
-        await context.sendMessage(target.transportResourceId, {
-          text: "Session archived. Use `/delete confirm:delete` to remove the local workspace.",
-          blocks: [
-            {
-              kind: "fields",
-              title: "Session Archived",
-              tone: "warning",
-              fields: [
-                { label: "Session", value: target.id },
-                { label: "Workspace", value: workspaceDisplay(target.id) }
-              ]
-            }
-          ]
-        });
-        await context.sendStatusUpdate({
-          text: `Archived session ${target.id} from ${target.transportResourceId}.`,
-          blocks: [
-            {
-              kind: "fields",
-              title: "Session Archived",
-              tone: "warning",
-              fields: [
-                { label: "Session", value: target.id },
-                { label: "Resource", value: target.transportResourceId }
-              ]
-            }
-          ]
-        });
-        context.appendAuditEvent("session.archived", {
-          sessionId: target.id,
-          transportResourceId: target.transportResourceId,
-          pluginId: manifest_default.id
-        });
-        return await reply(event, {
-          content: `Archived session ${target.id}.`,
-          ephemeral: true
-        });
-      } catch (error) {
-        if (!isMissingPermissions(error)) throw error;
-        return await reply(event, {
-          content: "Archive failed: Moorline needs permission to update the current resource and archive area.",
-          ephemeral: true
-        });
-      }
-    }
-    if (event.actionId === "resource.delete") {
-      if (!event.transportResourceId) {
-        return await reply(event, { content: "This action requires a target resource.", ephemeral: true });
-      }
-      if (stringOption(event.input, "confirm") !== "delete") {
-        return await reply(event, {
-          content: "Deletion cancelled: pass confirm:delete to remove the archived resource.",
-          ephemeral: true
-        });
-      }
-      const session = context.getSessionByTransportResourceId(event.transportResourceId);
-      if (session && session.lifecycleStatus !== "archived") {
-        return await reply(event, {
-          content: `Session ${session.sessionId} must be archived before deletion.`,
-          ephemeral: true
-        });
-      }
-      if (!session) {
-        return await reply(event, {
-          content: "This resource is not a deletable Moorline session.",
-          ephemeral: true
-        });
-      }
-      await defer(event, { ephemeral: true });
-      try {
-        const deleted = await context.deleteArchivedTransportResourceTarget({ transportResourceId: event.transportResourceId });
-        if (!deleted) {
-          return await reply(event, {
-            content: "This archived resource could not be deleted.",
-            ephemeral: true
-          });
-        }
-        const target = summarizeArchivedTarget(deleted);
-        await context.sendStatusUpdate({
-          text: `Deleted archived session ${target.id} and removed its local workspace.`,
-          blocks: [
-            {
-              kind: "fields",
-              title: "Session Deleted",
-              tone: "danger",
-              fields: [
-                { label: "Session", value: target.id },
-                { label: "Workspace", value: workspaceDisplay(target.id) }
-              ]
-            }
-          ]
-        });
-        context.appendAuditEvent("session.deleted", {
-          sessionId: target.id,
-          transportResourceId: target.transportResourceId,
-          workspacePath: target.workspacePath,
-          pluginId: manifest_default.id
-        });
-        return await reply(event, {
-          content: `Deleted archived session ${target.id} and removed its local workspace (${workspaceDisplay(target.id)}).`,
-          ephemeral: true
-        });
-      } catch (error) {
-        if (!isMissingPermissions(error)) throw error;
-        return await reply(event, {
-          content: "Delete failed: Moorline needs permission to delete the archived resource.",
-          ephemeral: true
-        });
-      }
-    }
-    return { handled: false };
-  }
-};
-
 // packages/discord-runtime/modules/routing/index.mjs
 import { readFile } from "node:fs/promises";
 var prompts = {
-  coordination: readFile(new globalThis.URL("./coordination.md", import.meta.url), "utf8").then((value) => value.trim()),
   session: readFile(new globalThis.URL("./session.md", import.meta.url), "utf8").then((value) => value.trim())
 };
 function providerCommandLine(context) {
@@ -513,35 +55,6 @@ async function loadPromptSections(context, surface, dynamicSections = []) {
   }
   return sections;
 }
-function mainCoordinationRuntimeMode(context) {
-  return context.config?.defaults?.runtimeMode === "approval-required" ? "approval-required" : "full-access";
-}
-async function routeCoordinationMessage(event, context) {
-  const runtimeMode = mainCoordinationRuntimeMode(context);
-  const reply2 = await context.runAgent({
-    surface: "coordination",
-    transportResourceId: event.transportResourceId,
-    actorId: event.actor.actorId,
-    actorLabel: event.actor.displayName ?? event.actor.actorId,
-    message: event.message.text,
-    attachments: event.message.attachments,
-    session: null,
-    cwd: context.getRuntimeRootPath(),
-    runtimeMode,
-    context: {
-      systemPromptSections: await loadPromptSections(context, "coordination", [
-        "This coordination surface may use the runtime root for machine-level work, but it is not a durable worker workspace."
-      ])
-    }
-  });
-  await context.sendMessage(event.transportResourceId, reply2);
-  context.appendAuditEvent("coordination.replied", {
-    transportResourceId: event.transportResourceId,
-    mode: runtimeMode,
-    pluginId: manifest_default.id
-  });
-  return { handled: true };
-}
 async function routeSessionMessage(event, context, session) {
   const reply2 = await context.runAgent({
     surface: "session",
@@ -572,325 +85,85 @@ async function routeSessionMessage(event, context, session) {
 var routing_default = {
   id: manifest_default.id,
   manifest: manifest_default,
-  async onTransportEvent(event, context) {
-    if (event.type !== "message.received") {
+  async onTransportIntent(event, context) {
+    if (event.type !== "transport.message.received") {
       return { handled: false };
     }
-    const surface = context.getSurfaceState();
-    if (event.transportResourceId === surface.coordinationResourceId) {
-      return await routeCoordinationMessage(event, context);
-    }
     const session = context.getSessionByTransportResourceId(event.transportResourceId);
-    if (!session || session.lifecycleStatus === "archived") {
+    if (!session) {
       return { handled: false };
     }
     return await routeSessionMessage(event, context, session);
   }
 };
 
-// packages/discord-runtime/modules/session-commands/index.mjs
-function summarizeSessions(sessions) {
-  if (sessions.length === 0) return "No sessions yet.";
-  return sessions.map(
-    (session) => `${`- ${session.sessionId} (${session.lifecycleStatus}, ${session.runtimeMode})`}${session.summary ? ` | ${session.summary}` : ""}`
-  ).join("\n");
-}
-function buildSessionListEmbed(sessions) {
-  const openSessions = sessions.filter((session) => session.lifecycleStatus !== "archived");
-  const coolSessions = sessions.filter((session) => session.lifecycleStatus === "cool");
-  const archivedSessions = sessions.filter((session) => session.lifecycleStatus === "archived");
+// packages/discord-runtime/modules/shared.mjs
+function discordAction(id, title, commandName, commandDescription, subcommandName, subcommandDescription, options, policy) {
+  if (Array.isArray(subcommandName) || subcommandName === void 0 && subcommandDescription && typeof subcommandDescription === "object" && !Array.isArray(subcommandDescription)) {
+    policy = subcommandDescription;
+    options = subcommandName;
+    subcommandDescription = void 0;
+    subcommandName = void 0;
+  }
   return {
-    title: "Moorline Sessions",
-    color: 3447003,
-    fields: [
-      { name: "Open", value: String(openSessions.length), inline: true },
-      { name: "Cool", value: String(coolSessions.length), inline: true },
-      { name: "Archived", value: String(archivedSessions.length), inline: true },
-      { name: "Session Summary", value: summarizeSessions(sessions).slice(0, 1024) || "No sessions yet." }
-    ],
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    id,
+    title,
+    description: subcommandDescription ?? commandDescription,
+    ...policy ? { policy } : {},
+    metadata: {
+      discordCommand: {
+        commandName,
+        commandDescription,
+        ...subcommandName ? { subcommandName } : {},
+        ...subcommandDescription ? { subcommandDescription } : {},
+        ...options ? { options } : {}
+      }
+    }
   };
 }
-function sessionOwnerFromEvent(event) {
-  const actorId = typeof event?.actor?.actorId === "string" ? event.actor.actorId.trim() : "";
-  if (!actorId) {
-    return void 0;
-  }
-  const actorLabel = typeof event?.actor?.displayName === "string" ? event.actor.displayName.trim() : "";
+function toRuntimeReply(payload) {
+  const blocks = (payload.embeds ?? []).map((embed) => ({
+    kind: "fields",
+    ...embed.title ? { title: embed.title } : {},
+    ...embed.description ? { text: embed.description } : {},
+    ...embed.fields ? {
+      fields: embed.fields.map((field) => ({
+        label: field.name,
+        value: field.value,
+        ...field.inline !== void 0 ? { inline: field.inline } : {}
+      }))
+    } : {}
+  }));
   return {
-    kind: "run",
-    id: actorId,
-    ...actorLabel ? { label: actorLabel } : {}
+    ...payload.content ? { text: payload.content } : {},
+    ...blocks.length > 0 ? { blocks } : {}
   };
 }
-var session_commands_default = {
-  id: manifest_default.id,
-  manifest: manifest_default,
-  actions() {
-    return [
-      discordAction(
-        "session.create",
-        "Create a new worker session",
-        "session",
-        "Manage Moorline worker sessions",
-        "create",
-        "Create a new worker session",
-        [
-          { type: "string", name: "name", description: "Short session name", required: true },
-          {
-            type: "string",
-            name: "mode",
-            description: "Runtime mode",
-            choices: [
-              { name: "full-access", value: "full-access" },
-              { name: "approval-required", value: "approval-required" }
-            ]
-          }
-        ]
-      ),
-      discordAction(
-        "session.archive",
-        "Archive a session",
-        "session",
-        "Manage Moorline worker sessions",
-        "archive",
-        "Archive a session resource",
-        [{ type: "string", name: "session_id", description: "Archive a specific session id" }],
-        { allowedWhileDraining: true, bypassQueue: true }
-      ),
-      discordAction(
-        "session.delete",
-        "Delete an archived session",
-        "session",
-        "Manage Moorline worker sessions",
-        "delete",
-        "Delete an archived session and its local workspace",
-        [
-          {
-            type: "string",
-            name: "confirm",
-            description: "Type delete to confirm destructive removal",
-            required: true,
-            choices: [{ name: "delete", value: "delete" }]
-          },
-          { type: "string", name: "session_id", description: "Delete a specific archived session id" }
-        ],
-        { allowedWhileDraining: true, bypassQueue: true }
-      ),
-      discordAction(
-        "session.list",
-        "List sessions",
-        "session",
-        "Manage Moorline worker sessions",
-        "list",
-        "List active and archived sessions"
-      )
-    ];
-  },
-  async onAction(event, context) {
-    if (!event.actionId.startsWith("session.")) {
-      return { handled: false };
-    }
-    if (event.actionId === "session.create") {
-      const requestedName = stringOption(event.input, "name");
-      if (!requestedName) {
-        return await reply(event, { content: "name is required", ephemeral: true });
-      }
-      const requestedMode = stringOption(event.input, "mode");
-      const runtimeMode = requestedMode === "full-access" || requestedMode === "approval-required" ? requestedMode : context.config.defaults.runtimeMode;
-      const created = await context.createSession({
-        requestedName,
-        runtimeMode,
-        owner: sessionOwnerFromEvent(event)
-      });
-      const notificationErrors = [];
-      try {
-        await context.sendMessage(created.transportResourceId, {
-          text: `Session ready: ${created.session.sessionId}. Start by sharing your first task.`
-        });
-      } catch (error) {
-        notificationErrors.push(error instanceof Error ? error.message : String(error));
-      }
-      context.appendAuditEvent("session.created", {
-        sessionId: created.session.sessionId,
-        transportResourceId: created.transportResourceId,
-        runtimeMode,
-        pluginId: manifest_default.id
-      });
-      if (notificationErrors.length > 0) {
-        context.appendAuditEvent("session.created.notification_failed", {
-          sessionId: created.session.sessionId,
-          transportResourceId: created.transportResourceId,
-          runtimeMode,
-          errors: notificationErrors,
-          pluginId: manifest_default.id
-        });
-      }
-      return await reply(event, {
-        content: notificationErrors.length === 0 ? `Created session ${created.session.sessionId} in <#${created.transportResourceId}>.` : `Created session ${created.session.sessionId} in <#${created.transportResourceId}>. Warning: follow-up notifications failed; check runtime status.`,
-        ephemeral: true
-      });
-    }
-    if (event.actionId === "session.archive") {
-      if (!event.transportResourceId && !stringOption(event.input, "session_id")) {
-        return await reply(event, {
-          content: "Run this in a session resource or pass session_id.",
-          ephemeral: true
-        });
-      }
-      try {
-        const session = await context.archiveSession({
-          transportResourceId: event.transportResourceId ?? "",
-          ...stringOption(event.input, "session_id") ? { sessionId: stringOption(event.input, "session_id") } : {}
-        });
-        if (!session) {
-          return await reply(event, { content: "No matching session found.", ephemeral: true });
-        }
-        context.appendAuditEvent("session.archived", {
-          sessionId: session.sessionId,
-          transportResourceId: session.transportResourceId,
-          pluginId: manifest_default.id
-        });
-        return await reply(event, {
-          content: `Archived session ${session.sessionId}.`,
-          ephemeral: true
-        });
-      } catch (error) {
-        if (!isMissingPermissions(error)) throw error;
-        return await reply(event, {
-          content: "Archive failed: Moorline needs permission to update the session resource and archive area.",
-          ephemeral: true
-        });
-      }
-    }
-    if (event.actionId === "session.delete") {
-      if (!event.transportResourceId && !stringOption(event.input, "session_id")) {
-        return await reply(event, {
-          content: "Run this in a session resource or pass session_id.",
-          ephemeral: true
-        });
-      }
-      const requestedSessionId = stringOption(event.input, "session_id");
-      const target = (requestedSessionId ? context.getSessionById(requestedSessionId) : null) ?? (event.transportResourceId ? context.getSessionByTransportResourceId(event.transportResourceId) : null);
-      if (!target) {
-        return await reply(event, { content: "No matching session found.", ephemeral: true });
-      }
-      if (target.lifecycleStatus !== "archived") {
-        return await reply(event, {
-          content: `Session ${target.sessionId} must be archived before deletion.`,
-          ephemeral: true
-        });
-      }
-      if (stringOption(event.input, "confirm") !== "delete") {
-        return await reply(event, {
-          content: "Deletion cancelled: pass confirm:delete to remove the archived session.",
-          ephemeral: true
-        });
-      }
-      if (event.transportResourceId && target.transportResourceId === event.transportResourceId) {
-        await defer(event, { ephemeral: true });
-      }
-      try {
-        const deleted = await context.deleteArchivedSession({
-          transportResourceId: event.transportResourceId ?? target.transportResourceId,
-          ...requestedSessionId ? { sessionId: requestedSessionId } : {}
-        });
-        if (!deleted) {
-          return await reply(event, { content: "No matching session found.", ephemeral: true });
-        }
-        context.appendAuditEvent("session.deleted", {
-          sessionId: deleted.sessionId,
-          transportResourceId: deleted.transportResourceId,
-          workspacePath: deleted.workspacePath,
-          pluginId: manifest_default.id
-        });
-        return await reply(event, {
-          content: `Deleted archived session ${deleted.sessionId} and removed its local workspace (${workspaceDisplay(deleted.sessionId)}).`,
-          ephemeral: true
-        });
-      } catch (error) {
-        if (!isMissingPermissions(error)) throw error;
-        return await reply(event, {
-          content: "Delete failed: Moorline needs permission to delete the archived session resource.",
-          ephemeral: true
-        });
-      }
-    }
-    if (event.actionId === "session.list") {
-      return await reply(event, {
-        content: "Current Moorline sessions",
-        embeds: [buildSessionListEmbed(context.listSessions())],
-        ephemeral: true
-      });
-    }
-    return await reply(event, {
-      content: `Unsupported session action: ${event.actionId}`,
-      ephemeral: true
-    });
+async function reply(event, payload) {
+  const native = event.native?.payload;
+  if (native && typeof native === "object" && typeof native.reply === "function") {
+    await native.reply(payload);
+    return { handled: true };
   }
-};
+  return { handled: true, reply: toRuntimeReply(payload) };
+}
 
 // packages/discord-runtime/modules/status/index.mjs
-var MAX_EMBED_FIELD_VALUE = 1024;
-function buildHealthEmbed(input) {
+function statusEmbed(input) {
   return {
-    title: "Moorline Health",
-    color: input.dbOk && input.environmentOk ? 3066993 : 15158332,
+    title: "Moorline Status",
+    color: input.acceptingNewWork ? 3066993 : 15844367,
     fields: [
       { name: "Uptime", value: `${input.uptimeSeconds}s`, inline: true },
-      { name: "Database", value: input.dbDetail ?? (input.dbOk ? "OK" : "Error"), inline: true },
-      { name: "Environment", value: input.environmentDetail ?? (input.environmentOk ? "OK" : "Error"), inline: true },
-      { name: "Open Sessions", value: String(input.activeSessions), inline: true },
-      { name: "Cool Sessions", value: String(input.coolSessions), inline: true },
-      { name: "Archived Sessions", value: String(input.archivedSessions), inline: true }
+      { name: "Accepting Work", value: input.acceptingNewWork ? "Yes" : "No", inline: true },
+      { name: "Open Sessions", value: String(input.openSessions), inline: true },
+      { name: "Running", value: String(input.runningSessions), inline: true },
+      { name: "Waiting", value: String(input.waitingSessions), inline: true },
+      { name: "Provider", value: input.providerLabel ?? "unknown", inline: true }
     ],
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function parseAnswers(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { answer: raw };
-    const result = {};
-    for (const [key, value] of Object.entries(parsed)) {
-      if (typeof value === "string") result[key] = value;
-      else if (Array.isArray(value)) {
-        const normalized = value.filter((entry) => typeof entry === "string");
-        if (normalized.length > 0) result[key] = normalized;
-      }
-    }
-    return Object.keys(result).length > 0 ? result : { answer: raw };
-  } catch {
-    return { answer: raw };
-  }
-}
-function toBlock(title, tone, fields) {
-  return {
-    kind: "fields",
-    title,
-    tone,
-    fields: fields.map((field) => ({
-      label: field.name,
-      value: field.value,
-      ...field.inline !== void 0 ? { inline: field.inline } : {}
-    }))
-  };
-}
-function truncateEmbedValue(value, maxLength = MAX_EMBED_FIELD_VALUE) {
-  const normalized = String(value ?? "").trim();
-  if (!normalized) return "None";
-  if (normalized.length <= maxLength) return normalized;
-  return `${normalized.slice(0, Math.max(0, maxLength - 14))}...(truncated)`;
-}
-function summarizeRuntimeIssue(event) {
-  if (event.type === "turn.failed") {
-    return "A turn failed. Check local runtime audit logs for detailed diagnostics.";
-  }
-  if (event.type === "provider.closed") {
-    return "A provider session closed unexpectedly. Check local runtime audit logs for details.";
-  }
-  return "A runtime error occurred. Check local runtime audit logs for details.";
-}
 var status_default = {
   id: manifest_default.id,
   manifest: manifest_default,
@@ -900,253 +173,32 @@ var status_default = {
         "runtime.status",
         "Show runtime status",
         "status",
-        "Show Moorline surface and runtime status",
+        "Show Moorline runtime status",
         void 0,
         void 0,
         void 0,
         { allowedWhileDraining: true }
-      ),
-      discordAction(
-        "runtime.turn.stop",
-        "Stop the active turn",
-        "turn",
-        "Control the active provider turn in this session",
-        "stop",
-        "Interrupt the active turn for this session",
-        void 0,
-        { allowedWhileDraining: true, bypassQueue: true }
-      ),
-      discordAction(
-        "runtime.request.cancel",
-        "Cancel a pending runtime request",
-        "request",
-        "Respond to a pending runtime user-input request",
-        "cancel",
-        "Cancel a pending runtime request",
-        [{ type: "string", name: "request_id", description: "Pending request id", required: true }],
-        { allowedWhileDraining: true, bypassQueue: true }
-      ),
-      discordAction(
-        "runtime.request.answer",
-        "Answer a pending runtime request",
-        "request",
-        "Respond to a pending runtime user-input request",
-        "answer",
-        "Answer a pending runtime user-input request",
-        [
-          { type: "string", name: "request_id", description: "Pending request id", required: true },
-          {
-            type: "string",
-            name: "answers",
-            description: "Plain text answer or JSON object keyed by question id",
-            required: true
-          }
-        ],
-        { allowedWhileDraining: true, bypassQueue: true }
       )
     ];
   },
-  async onDomainEvent(event, context) {
-    if (event.transportResourceId === null) return;
-    if (event.type === "turn.waiting_for_approval" || event.type === "turn.waiting_for_input") {
-      await context.sendStatusUpdate({
-        text: `Session ${event.sessionId ?? event.threadId} is waiting.`,
-        blocks: [
-          toBlock("Turn Waiting", "warning", [
-            { name: "Session", value: event.sessionId ?? event.threadId },
-            { name: "State", value: event.type.replace("turn.", "").replace(/_/g, " ") }
-          ])
-        ]
-      });
-    }
-    if (event.type === "turn.failed" || event.type === "runtime.error" || event.type === "provider.closed") {
-      const detail = summarizeRuntimeIssue(event);
-      await context.sendStatusUpdate({
-        text: `Session ${event.sessionId ?? event.threadId} hit a runtime problem.`,
-        blocks: [
-          toBlock("Runtime Issue", "danger", [
-            { name: "Session", value: event.sessionId ?? event.threadId },
-            { name: "Detail", value: detail }
-          ])
-        ]
-      });
-    }
-  },
   async onAction(event, context) {
-    if (event.actionId === "runtime.turn.stop") {
-      if (!event.transportResourceId) {
-        return await reply(event, { content: "This action requires a target session resource.", ephemeral: true });
-      }
-      const session = context.getSessionByTransportResourceId(event.transportResourceId);
-      if (!session) {
-        return await reply(event, {
-          content: "This resource does not have an active Moorline session.",
-          ephemeral: true
-        });
-      }
-      await context.interruptTurn({ threadId: session.threadId });
-      return await reply(event, {
-        content: `Interrupt sent for ${session.sessionId}.`,
-        ephemeral: true
-      });
-    }
-    if (event.actionId === "runtime.request.cancel" || event.actionId === "runtime.request.answer") {
-      if (!event.transportResourceId) {
-        return await reply(event, { content: "This action requires a target resource.", ephemeral: true });
-      }
-      const requestId = stringOption(event.input, "request_id");
-      if (!requestId) {
-        return await reply(event, { content: "request_id is required.", ephemeral: true });
-      }
-      const request = context.listPendingRequests(event.transportResourceId).find((entry) => entry.requestId === requestId);
-      if (!request) {
-        return await reply(event, {
-          content: `No pending request ${requestId} was found in this resource.`,
-          ephemeral: true
-        });
-      }
-      if (event.actionId === "runtime.request.cancel") {
-        try {
-          await context.cancelRuntimeRequest({
-            threadId: request.threadId,
-            requestId,
-            requestType: request.requestType,
-            requesterActor: event.actor
-          });
-        } catch (error) {
-          return await reply(event, {
-            content: error instanceof Error ? error.message : String(error),
-            ephemeral: true
-          });
-        }
-        return await reply(event, {
-          content: `Cancelled request ${requestId}.`,
-          ephemeral: true
-        });
-      }
-      if (request.requestType !== "tool_user_input") {
-        return await reply(event, {
-          content: `Request ${requestId} is approval-driven. Use the request actions instead.`,
-          ephemeral: true
-        });
-      }
-      try {
-        await context.respondToRuntimeUserInput({
-          threadId: request.threadId,
-          requestId,
-          answers: parseAnswers(stringOption(event.input, "answers")),
-          requesterActor: event.actor
-        });
-      } catch (error) {
-        return await reply(event, {
-          content: error instanceof Error ? error.message : String(error),
-          ephemeral: true
-        });
-      }
-      return await reply(event, {
-        content: `Answered request ${requestId}.`,
-        ephemeral: true
-      });
-    }
     if (event.actionId !== "runtime.status") {
       return { handled: false };
     }
-    const surface = context.getSurfaceState();
     const runtimeStatus = context.getRuntimeStatus();
+    const controlStatus = context.getRuntimeControlStatus();
     const providerDiagnostics = context.getProviderDiagnostics();
-    const overview = context.getRuntimeOverview();
-    const receipts = overview.receipts;
-    const activities = overview.sessions.flatMap((session) => session.recentActivities).slice(-5);
-    const projectionStates = overview.projectionStates;
-    const projectionFailures = projectionStates.filter((entry) => entry.failure !== null);
-    const providerErrorCount = Number(providerDiagnostics.statusCounts.error ?? 0);
-    const dbOk = projectionFailures.length === 0;
-    const environmentOk = providerErrorCount === 0;
-    const dbDetail = projectionFailures.length === 0 ? "OK" : `Error (${projectionFailures.length} projection failure${projectionFailures.length === 1 ? "" : "s"})`;
-    const environmentDetail = providerErrorCount === 0 ? "OK" : `Error (${providerErrorCount} provider session${providerErrorCount === 1 ? "" : "s"})`;
     return await reply(event, {
       content: "Moorline runtime status",
       embeds: [
-        buildHealthEmbed({
+        statusEmbed({
           uptimeSeconds: runtimeStatus.uptimeSeconds,
-          dbOk,
-          environmentOk,
-          dbDetail,
-          environmentDetail,
-          activeSessions: runtimeStatus.openSessions,
-          coolSessions: runtimeStatus.coolSessions,
-          archivedSessions: runtimeStatus.archivedSessions
-        }),
-        {
-          title: "Runtime Activity",
-          color: 1752220,
-          fields: [
-            { name: "Running Sessions", value: String(runtimeStatus.runningSessions), inline: true },
-            { name: "Waiting Sessions", value: String(runtimeStatus.waitingSessions), inline: true },
-            {
-              name: "Pending Receipts",
-              value: truncateEmbedValue(
-                receipts.length === 0 ? "None" : receipts.slice(-5).map((receipt) => `${receipt.threadId}: ${receipt.state}`).join("\n")
-              )
-            },
-            {
-              name: "Recent Activity",
-              value: truncateEmbedValue(
-                activities.length === 0 ? "None" : activities.map((activity) => `${activity.title}${activity.detail ? ` - ${activity.detail}` : ""}`).join("\n")
-              )
-            }
-          ],
-          timestamp: context.nowIso()
-        },
-        {
-          title: "Provider Diagnostics",
-          color: 10181046,
-          fields: [
-            { name: "Account", value: providerDiagnostics.accountLabel ?? "unknown", inline: true },
-            { name: "Default Model", value: context.getDefaultModel(), inline: true },
-            { name: "Connected Sessions", value: String(providerDiagnostics.connectedSessions), inline: true },
-            {
-              name: "Models",
-              value: truncateEmbedValue(providerDiagnostics.availableModels.join(", ") || "Unknown"),
-              inline: true
-            },
-            {
-              name: "Provider Statuses",
-              value: truncateEmbedValue(
-                Object.entries(providerDiagnostics.statusCounts).map(([status, count]) => `${status}: ${count}`).join("\n") || "None"
-              )
-            },
-            {
-              name: "Capabilities",
-              value: truncateEmbedValue(Object.keys(providerDiagnostics.capabilityMetadata).join(", ") || "None")
-            }
-          ],
-          timestamp: context.nowIso()
-        },
-        {
-          title: "Projection Health",
-          color: projectionFailures.length === 0 ? 3066993 : 15158332,
-          fields: [
-            {
-              name: "Pipelines",
-              value: truncateEmbedValue(
-                projectionStates.map((entry) => `${entry.projector}: ${entry.failure ? `failed (${entry.failure})` : "ok"}`).join("\n") || "None"
-              )
-            }
-          ],
-          timestamp: context.nowIso()
-        },
-        {
-          title: "Managed Surface",
-          color: 3447003,
-          fields: [
-            { name: "Coordination", value: `<#${surface.coordinationResourceId}>`, inline: true },
-            { name: "Status", value: `<#${surface.statusResourceId}>`, inline: true },
-            { name: "Sessions", value: surface.sessionsCategoryId, inline: true },
-            { name: "Archive", value: surface.archiveCategoryId, inline: true }
-          ],
-          timestamp: context.nowIso()
-        }
+          acceptingNewWork: controlStatus.acceptingNewWork,
+          openSessions: runtimeStatus.openSessions,
+          runningSessions: runtimeStatus.runningSessions,
+          waitingSessions: runtimeStatus.waitingSessions,
+          providerLabel: providerDiagnostics.accountLabel
+        })
       ],
       ephemeral: true
     });
@@ -1155,10 +207,7 @@ var status_default = {
 
 // packages/discord-runtime/index.mjs
 var modules = [
-  admin_control_default,
-  channel_lifecycle_default,
   routing_default,
-  session_commands_default,
   status_default
 ];
 async function firstHandled(hook, args) {
@@ -1183,11 +232,8 @@ var index_default = {
   async onAction(event, context) {
     return await firstHandled("onAction", [event, context]);
   },
-  async onDomainEvent(event, context) {
-    return await firstHandled("onDomainEvent", [event, context]);
-  },
-  async onTransportEvent(event, context) {
-    return await firstHandled("onTransportEvent", [event, context]);
+  async onTransportIntent(intent, context) {
+    return await firstHandled("onTransportIntent", [intent, context]);
   }
 };
 export {