@rync/moorline-discord-default 0.0.2

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

@@ -0,0 +1,1195 @@
+import { createRequire as __moorlineCreateRequire } from 'node:module'; const require = __moorlineCreateRequire(import.meta.url);
+
+// packages/discord-runtime/manifest.json
+var manifest_default = {
+  id: "rync/discord-runtime",
+  name: "rync/discord-runtime",
+  version: "0.0.2",
+  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"
+  ],
+  hooks: [
+    "onAction",
+    "onDomainEvent",
+    "onTransportEvent"
+  ],
+  defaultEnabled: true,
+  dependencies: [
+    {
+      surface: "transport",
+      packageId: "rync/discord",
+      requiredState: "active",
+      reason: "Discord runtime routing and commands depend on the rync Discord transport."
+    }
+  ]
+};
+
+// 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) {
+  const providerCommand = typeof context.config?.surfaces?.provider?.config?.command === "string" ? context.config.surfaces.provider.config.command.trim() : "";
+  return providerCommand ? `Provider command: ${providerCommand}.` : "Provider command: unknown.";
+}
+async function loadPromptSections(context, surface, dynamicSections = []) {
+  const sections = [
+    await prompts[surface],
+    `Transport surface: discord ${surface} resource.`,
+    `Provider package: ${context.config?.surfaces?.provider?.activePackageId ?? "unknown"}.`,
+    `Default model preference: ${context.config?.defaults?.model ?? "latest"}.`,
+    providerCommandLine(context)
+  ];
+  for (const section of dynamicSections) {
+    const trimmed = section.trim();
+    if (trimmed) {
+      sections.push(trimmed);
+    }
+  }
+  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",
+    transportResourceId: event.transportResourceId,
+    actorId: event.actor.actorId,
+    actorLabel: event.actor.displayName ?? event.actor.actorId,
+    message: event.message.text,
+    attachments: event.message.attachments,
+    session,
+    cwd: session.workspacePath,
+    runtimeMode: session.runtimeMode,
+    context: {
+      systemPromptSections: await loadPromptSections(context, "session", [
+        `Session ID: ${session.sessionId}`,
+        `Workspace: ${session.workspacePath}`,
+        `Runtime mode: ${session.runtimeMode}`
+      ])
+    }
+  });
+  await context.sendMessage(event.transportResourceId, reply2);
+  context.appendAuditEvent("session.replied", {
+    sessionId: session.sessionId,
+    transportResourceId: event.transportResourceId,
+    pluginId: manifest_default.id
+  });
+  return { handled: true };
+}
+var routing_default = {
+  id: manifest_default.id,
+  manifest: manifest_default,
+  async onTransportEvent(event, context) {
+    if (event.type !== "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") {
+      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");
+  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()
+  };
+}
+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() : "";
+  return {
+    kind: "run",
+    id: actorId,
+    ...actorLabel ? { label: actorLabel } : {}
+  };
+}
+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
+    });
+  }
+};
+
+// packages/discord-runtime/modules/status/index.mjs
+var MAX_EMBED_FIELD_VALUE = 1024;
+function buildHealthEmbed(input) {
+  return {
+    title: "Moorline Health",
+    color: input.dbOk && input.environmentOk ? 3066993 : 15158332,
+    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 }
+    ],
+    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,
+  actions() {
+    return [
+      discordAction(
+        "runtime.status",
+        "Show runtime status",
+        "status",
+        "Show Moorline surface and 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 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({
+          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()
+        }
+      ],
+      ephemeral: true
+    });
+  }
+};
+
+// 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) {
+  for (const module of modules) {
+    const handler = module[hook];
+    if (typeof handler !== "function") {
+      continue;
+    }
+    const result = await handler(...args);
+    if (result?.handled) {
+      return result;
+    }
+  }
+  return { handled: false };
+}
+var index_default = {
+  id: manifest_default.id,
+  manifest: manifest_default,
+  actions() {
+    return modules.flatMap((module) => typeof module.actions === "function" ? module.actions() : []);
+  },
+  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]);
+  }
+};
+export {
+  index_default as default
+};