@geminixiang/mikan 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/index.js

@@ -1,9 +1,9 @@
 export { defaultCommandHandlers, dispatchCommand } from "./commands/registry.js";
 export * from "./harness/index.js";
-export * from "./sessions/agent-memory-file-manager.js";
+export * from "./sessions/chat-history-sync.js";
 export * from "./sessions/metadata.js";
 export * from "./sessions/policy.js";
 export * from "./sessions/store.js";
 export { createConversationRuntime, } from "./runtime/conversation-runtime.js";
-export { SandboxError, createExecutor, getSandboxAdapters, parseSandboxArg, validateSandbox, } from "./sandbox/index.js";
+export { SandboxError, configureGondolinRuntime, createExecutor, getSandboxAdapters, parseSandboxArg, validateSandbox, } from "./sandbox/index.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACjF,cAAc,oBAAoB,CAAC;AAEnC,cAAc,yCAAyC,CAAC;AACxD,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EACL,yBAAyB,GAK1B,MAAM,mCAAmC,CAAC;AAc3C,OAAO,EACL,YAAY,EACZ,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,eAAe,GAChB,MAAM,oBAAoB,CAAC","sourcesContent":["export { defaultCommandHandlers, dispatchCommand } from \"./commands/registry.js\";\nexport * from \"./harness/index.js\";\nexport type { CommandContext, CommandHandler, CommandServices } from \"./commands/types.js\";\nexport * from \"./sessions/agent-memory-file-manager.js\";\nexport * from \"./sessions/metadata.js\";\nexport * from \"./sessions/policy.js\";\nexport * from \"./sessions/store.js\";\nexport {\n  createConversationRuntime,\n  type CreateSessionSandboxOptions,\n  type RunSessionOptions,\n  type ConversationRuntime,\n  type ConversationRuntimeOptions,\n} from \"./runtime/conversation-runtime.js\";\nexport type {\n  MessagingBot,\n  ConversationContext,\n  ConversationEvent,\n  MessagingEventHandler,\n  ChatAdapter,\n  ConversationMessage,\n  ConversationResponder,\n  ChatToolResult,\n  ConversationKind,\n  MessagingInfo,\n  RunningSession,\n} from \"./adapter.js\";\nexport {\n  SandboxError,\n  createExecutor,\n  getSandboxAdapters,\n  parseSandboxArg,\n  validateSandbox,\n} from \"./sandbox/index.js\";\nexport type {\n  CloudflareSandboxConfig,\n  ExecOptions,\n  ExecResult,\n  Executor,\n  SandboxAdapter,\n  SandboxConfig,\n} from \"./sandbox/index.js\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACjF,cAAc,oBAAoB,CAAC;AAEnC,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,OAAO,EACL,yBAAyB,GAI1B,MAAM,mCAAmC,CAAC;AAc3C,OAAO,EACL,YAAY,EACZ,wBAAwB,EACxB,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,eAAe,GAEhB,MAAM,oBAAoB,CAAC","sourcesContent":["export { defaultCommandHandlers, dispatchCommand } from \"./commands/registry.js\";\nexport * from \"./harness/index.js\";\nexport type { CommandContext, CommandHandler, CommandServices } from \"./commands/types.js\";\nexport * from \"./sessions/chat-history-sync.js\";\nexport * from \"./sessions/metadata.js\";\nexport * from \"./sessions/policy.js\";\nexport * from \"./sessions/store.js\";\nexport {\n  createConversationRuntime,\n  type RunSessionOptions,\n  type ConversationRuntime,\n  type ConversationRuntimeOptions,\n} from \"./runtime/conversation-runtime.js\";\nexport type {\n  MessagingBot,\n  ConversationContext,\n  ConversationEvent,\n  MessagingEventHandler,\n  ChatAdapter,\n  ConversationMessage,\n  ConversationResponder,\n  ChatToolResult,\n  ConversationKind,\n  MessagingInfo,\n  RunningSession,\n} from \"./adapter.js\";\nexport {\n  SandboxError,\n  configureGondolinRuntime,\n  createExecutor,\n  getSandboxAdapters,\n  parseSandboxArg,\n  validateSandbox,\n  type GondolinBootstrapOptions,\n} from \"./sandbox/index.js\";\nexport type {\n  CloudflareSandboxConfig,\n  ExecOptions,\n  ExecResult,\n  Executor,\n  SandboxAdapter,\n  SandboxConfig,\n} from \"./sandbox/index.js\";\n"]}

package/dist/main.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import "./observability/instrument.js";
-import { join, resolve } from "path";
+import { join } from "path";
 import { mkdirSync, statSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { fileURLToPath } from "url";
 import { dirname, join as pathJoin } from "path";
 import { DiscordMessagingBot } from "./adapters/discord/bot.js";
+import { GithubMessagingBot } from "./adapters/github/bot.js";
+import { createGithubToolPack } from "./adapters/github/tool-pack.js";
+import { GcpTokenProvider } from "./adapters/github/gcp-auth.js";
 import { TelegramMessagingBot } from "./adapters/telegram/bot.js";
 import { SlackMessagingBot as SlackMessagingBotClass } from "./adapters/slack/bot.js";
-import { downloadChannel } from "./download.js";
+import { downloadChannel } from "./cli/download.js";
 import { EventsWatcher } from "./events.js";
 import * as log from "./log.js";
 import { startWebServer } from "./web/server.js";
@@ -16,13 +18,23 @@ import { InMemoryAdminTokenStore } from "./web/admin/store.js";
 import { InMemoryLinkTokenStore } from "./web/login/store.js";
 import { InMemorySessionViewTokenStore } from "./web/session-view/store.js";
 import { DockerContainerManager } from "./provisioner.js";
-import { assertStateDirOutsideWorkspace, createGlobalSettingsFile, loadGlobalSettings, MissingGlobalSettingsError, } from "./config.js";
+import { assertStateDirOutsideWorkspace, createGlobalSettingsFile, loadGlobalSettings, MissingGlobalSettingsError, resolveLinkBaseUrl, } from "./config.js";
 import { configureHttpDispatcher, defaultAuthPath, defaultModelsJsonPath, parseHttpIdleTimeoutMs, } from "./harness/index.js";
 import { existsSync, readFileSync } from "fs";
 import { readEnv, setEnvAliases } from "./utils/env.js";
 import { ensureDirExists, isRecord, readJsonFileIfExists } from "./utils/file-guards.js";
-import { SandboxError, parseSandboxArg, validateSandbox, } from "./sandbox/index.js";
+import { SandboxError, validateSandbox } from "./sandbox/index.js";
+import { helpText, resolveBoot } from "./cli/boot.js";
+import { envReport, noPlatformsMessage, platformIsActive } from "./env-manifest.js";
+import { disconnectAllGondolinRuntimes, gondolinResources, stopIdleGondolinVms, sweepUnadoptedGondolinWorkers, } from "./sandbox/gondolin.js";
+import { configureGondolinRuntime } from "./sandbox/gondolin-bootstrap.js";
+import { gondolinInventory } from "./sandbox/gondolin-inventory.js";
+import { gondolinFleet } from "./sandbox/gondolin-fleet.js";
+import { gondolinGateway } from "./sandbox/gondolin-gateway.js";
+import { gondolinJoin } from "./sandbox/gondolin-join.js";
+import { checkWorkspaceExported } from "./sandbox/gondolin-nfs-advisory.js";
 import { FileVaultManager } from "./vault/index.js";
+import { runExtCommand } from "./cli/ext.js";
 import { createConversationRuntime } from "./runtime/conversation-runtime.js";
 import { ChannelStore } from "./store.js";
 import * as Sentry from "@sentry/node";
@@ -44,56 +56,19 @@ const SLACK_APP_TOKEN = readEnv("SLACK_APP_TOKEN");
 const SLACK_BOT_TOKEN = readEnv("SLACK_BOT_TOKEN");
 const TELEGRAM_BOT_TOKEN = readEnv("TELEGRAM_BOT_TOKEN");
 const DISCORD_BOT_TOKEN = readEnv("DISCORD_BOT_TOKEN");
-const LINK_URL = readEnv("LINK_URL");
+const GITHUB_APP_ID = readEnv("GITHUB_APP_ID");
+const GITHUB_APP_PRIVATE_KEY = readEnv("GITHUB_APP_PRIVATE_KEY");
+const GITHUB_APP_PRIVATE_KEY_PATH = readEnv("GITHUB_APP_PRIVATE_KEY_PATH");
+const GITHUB_INSTALLATION_ID = readEnv("GITHUB_INSTALLATION_ID");
+const GITHUB_REPOS = readEnv("GITHUB_REPOS");
+const GITHUB_POLL_INTERVAL = readEnv("GITHUB_POLL_INTERVAL");
+const GOOGLE_APPLICATION_CREDENTIALS = readEnv("GOOGLE_APPLICATION_CREDENTIALS");
+const GOOGLE_CLOUD_PROJECT = readEnv("GOOGLE_CLOUD_PROJECT");
+// Externally-visible base URL of the link/OAuth server; the env read and
+// trailing-slash normalization live in config.resolveLinkBaseUrl.
+const LINK_BASE_URL = resolveLinkBaseUrl();
 const LINK_PORT_RAW = readEnv("LINK_PORT");
-const LINK_PORT = LINK_PORT_RAW ? parseInt(LINK_PORT_RAW, 10) : LINK_URL ? 8181 : undefined;
-function parseArgs() {
-    const args = process.argv.slice(2);
-    let sandbox = { type: "host" };
-    let workingDir;
-    let stateDirArg;
-    let downloadChannelId;
-    let showOnboard = false;
-    let showVersion = false;
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === "--version" || arg === "-v" || arg === "-V") {
-            showVersion = true;
-        }
-        else if (arg === "--onboard") {
-            showOnboard = true;
-        }
-        else if (arg.startsWith("--sandbox=")) {
-            sandbox = parseSandboxArg(arg.slice("--sandbox=".length));
-        }
-        else if (arg === "--sandbox") {
-            sandbox = parseSandboxArg(args[++i] || "");
-        }
-        else if (arg.startsWith("--state-dir=")) {
-            stateDirArg = arg.slice("--state-dir=".length);
-        }
-        else if (arg === "--state-dir") {
-            stateDirArg = args[++i];
-        }
-        else if (arg.startsWith("--download=")) {
-            downloadChannelId = arg.slice("--download=".length);
-        }
-        else if (arg === "--download") {
-            downloadChannelId = args[++i];
-        }
-        else if (!arg.startsWith("-")) {
-            workingDir = arg;
-        }
-    }
-    return {
-        workingDir: workingDir ? resolve(workingDir) : undefined,
-        stateDir: stateDirArg ? resolve(stateDirArg) : undefined,
-        sandbox,
-        downloadChannel: downloadChannelId,
-        showOnboard,
-        showVersion,
-    };
-}
+const LINK_PORT = LINK_PORT_RAW ? parseInt(LINK_PORT_RAW, 10) : LINK_BASE_URL ? 8181 : undefined;
 const WORLD_WRITABLE_MODE = 0o002;
 function ensureSecureStateDir(path) {
     let stat;
@@ -149,31 +124,79 @@ function handleStartupError(error) {
     console.error(String(error));
     process.exit(1);
 }
-let parsedArgs;
+let plan;
 try {
-    parsedArgs = parseArgs();
+    plan = resolveBoot();
 }
 catch (error) {
     handleStartupError(error);
 }
+// `mikan ext …` manages extensions and exits; handle it before the normal
+// bot-mode startup (which requires platform tokens).
+if (plan.mode === "ext") {
+    const code = await runExtCommand(plan.extArgs ?? []);
+    process.exit(code);
+}
 // Global fetch: proxy support (HTTP_PROXY/HTTPS_PROXY/NO_PROXY) and idle
 // timeouts so a stalled LLM stream errors out instead of hanging a session.
 const httpIdleTimeoutMs = parseHttpIdleTimeoutMs(readEnv("HTTP_IDLE_TIMEOUT"));
 configureHttpDispatcher(httpIdleTimeoutMs);
-// Handle --version
-if (parsedArgs.showVersion) {
+if (plan.mode === "help") {
+    console.log(helpText());
+    process.exit(0);
+}
+if (plan.mode === "env") {
+    console.log(envReport());
+    process.exit(0);
+}
+if (plan.mode === "version") {
     console.log(getVersion());
     process.exit(0);
 }
+// Handle --worker-token: mint a one-time join token for a dial-home worker
+if (plan.mode === "worker-token") {
+    const stateDir = plan.stateDir;
+    setEnvAliases("STATE_DIR", stateDir);
+    ensureSecureStateDir(stateDir);
+    gondolinJoin.configure(join(stateDir, "gondolin-gateway"));
+    try {
+        let gatewayPort = 8433;
+        let gatewayHost;
+        try {
+            const gateway = loadGlobalSettings().sandbox?.gondolin?.remote?.gateway;
+            if (gateway) {
+                gatewayPort = gateway.port;
+                gatewayHost = gateway.hostnames?.[0];
+            }
+        }
+        catch {
+            // settings are optional for minting; the CA lives in the state dir
+        }
+        const minted = await gondolinJoin.mintToken();
+        const host = gatewayHost ?? "<mikan-host>";
+        console.log("Worker join token (single use, expires in 15 minutes):");
+        console.log("");
+        console.log(`  mikan-worker join https://${host}:${gatewayPort} \\`);
+        console.log(`    --token ${minted.token} \\`);
+        console.log(`    --ca-pin ${minted.fingerprint} \\`);
+        console.log(`    --name <worker-name> --workspace-root <shared-workspace-path> \\`);
+        console.log(`    --worker-entry /opt/mikan/dist/sandbox/gondolin-worker-main.js`);
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
 // Handle --onboard mode
-if (parsedArgs.showOnboard) {
-    const stateDir = parsedArgs.stateDir ?? join(homedir(), ".mikan");
+if (plan.mode === "onboard") {
+    const stateDir = plan.stateDir;
     setEnvAliases("STATE_DIR", stateDir);
     ensureSecureStateDir(stateDir);
     try {
         const settingsPath = createGlobalSettingsFile(stateDir);
         console.log(`Created global settings at ${settingsPath}`);
-        console.log("Review the file, then start mikan with your working directory.");
+        console.log(`Review the file, then start mikan (workspace defaults to ${join(stateDir, "workspace")}).`);
         process.exit(0);
     }
     catch (err) {
@@ -182,40 +205,36 @@ if (parsedArgs.showOnboard) {
     }
 }
 // Handle --download mode (Slack only)
-if (parsedArgs.downloadChannel) {
+if (plan.mode === "download" && plan.downloadChannel) {
     if (!SLACK_BOT_TOKEN) {
         console.error("Missing env: SLACK_BOT_TOKEN");
         process.exit(1);
     }
-    await downloadChannel(parsedArgs.downloadChannel, SLACK_BOT_TOKEN);
+    await downloadChannel(plan.downloadChannel, SLACK_BOT_TOKEN);
     process.exit(0);
 }
-// Normal bot mode - require working dir
-if (!parsedArgs.workingDir) {
-    console.error("Usage: mikan [--state-dir=<dir>] [--sandbox=host|container:<name>|image:<image>|firecracker:<vm-id>:<host-path>|cloudflare:<sandbox-id>] <working-directory>");
-    console.error("       mikan --onboard [--state-dir=<dir>]");
-    console.error("       mikan --download <channel-id>");
-    process.exit(1);
-}
-const { workingDir, sandbox } = { workingDir: parsedArgs.workingDir, sandbox: parsedArgs.sandbox };
-const stateDir = parsedArgs.stateDir ?? join(homedir(), ".mikan");
+// Normal bot mode - working dir is optional and defaults under the state dir
+const sandbox = plan.sandbox;
+const stateDir = plan.stateDir;
+const workingDir = plan.workingDir;
 setEnvAliases("STATE_DIR", stateDir);
 ensureSecureStateDir(stateDir);
+if (!plan.workingDirExplicit) {
+    ensureDirExists(workingDir);
+}
 try {
     assertStateDirOutsideWorkspace(stateDir, workingDir, sandbox.type);
 }
 catch (error) {
     handleStartupError(error);
 }
-// Validate platform tokens
-const hasSlack = !!(SLACK_APP_TOKEN && SLACK_BOT_TOKEN);
-const hasTelegram = !!TELEGRAM_BOT_TOKEN;
-const hasDiscord = !!DISCORD_BOT_TOKEN;
-if (!hasSlack && !hasTelegram && !hasDiscord) {
-    console.error("No platform tokens found. Set one of:\n" +
-        "  Slack:    SLACK_APP_TOKEN + SLACK_BOT_TOKEN\n" +
-        "  Telegram: TELEGRAM_BOT_TOKEN\n" +
-        "  Discord:  DISCORD_BOT_TOKEN");
+// Validate platform tokens — activation rules live in the env manifest.
+const hasSlack = platformIsActive("slack");
+const hasTelegram = platformIsActive("telegram");
+const hasDiscord = platformIsActive("discord");
+const hasGithub = platformIsActive("github");
+if (!hasSlack && !hasTelegram && !hasDiscord && !hasGithub) {
+    console.error(noPlatformsMessage());
     process.exit(1);
 }
 try {
@@ -228,7 +247,10 @@ const vaultManager = new FileVaultManager(stateDir);
 if (vaultManager.isEnabled()) {
     console.log(sandbox.type === "container"
         ? "  Vault system enabled. Container vault active."
-        : sandbox.type === "image" || sandbox.type === "firecracker" || sandbox.type === "cloudflare"
+        : sandbox.type === "image" ||
+            sandbox.type === "gondolin" ||
+            sandbox.type === "firecracker" ||
+            sandbox.type === "cloudflare"
             ? "  Vault system enabled. Conversation-scoped credential routing active."
             : "  Vault system enabled. Host mode will not inject vault env.");
 }
@@ -240,11 +262,12 @@ const startupConfig = (() => {
         handleStartupError(error);
     }
 })();
-const sandboxLimits = startupConfig.sandboxCpus || startupConfig.sandboxMemory
-    ? { cpus: startupConfig.sandboxCpus, memory: startupConfig.sandboxMemory }
+const sandboxSettings = startupConfig.sandbox;
+const sandboxLimits = sandboxSettings?.cpus || sandboxSettings?.memory
+    ? { cpus: sandboxSettings?.cpus, memory: sandboxSettings?.memory }
     : undefined;
-const sandboxBoostLimits = startupConfig.sandboxBoostCpus || startupConfig.sandboxBoostMemory
-    ? { cpus: startupConfig.sandboxBoostCpus, memory: startupConfig.sandboxBoostMemory }
+const sandboxBoostLimits = sandboxSettings?.boost?.cpus || sandboxSettings?.boost?.memory
+    ? { cpus: sandboxSettings?.boost?.cpus, memory: sandboxSettings?.boost?.memory }
     : undefined;
 const provisioner = sandbox.type === "image"
     ? new DockerContainerManager(sandbox.image, {
@@ -252,7 +275,26 @@ const provisioner = sandbox.type === "image"
         boostLimits: sandboxBoostLimits,
     })
     : undefined;
-if (sandbox.type === "image") {
+if (sandbox.type === "gondolin") {
+    try {
+        configureGondolinRuntime({
+            stateDir,
+            limits: sandboxLimits,
+            boostLimits: sandboxBoostLimits,
+            remote: sandboxSettings?.gondolin?.remote,
+            requireRemote: sandbox.profile === "remote",
+        });
+    }
+    catch (error) {
+        handleStartupError(error);
+    }
+}
+const resourceController = sandbox.type === "image"
+    ? provisioner
+    : sandbox.type === "gondolin"
+        ? gondolinResources
+        : undefined;
+if (sandbox.type === "image" || sandbox.type === "gondolin") {
     ensureDirExists(join(workingDir, "skills"));
     ensureDirExists(join(workingDir, "events"));
     try {
@@ -270,50 +312,119 @@ setInterval(() => linkTokenStore.purge(), 5 * 60 * 1000).unref();
 setInterval(() => sessionViewTokenStore.purge(), 5 * 60 * 1000).unref();
 setInterval(() => adminTokenStore.purge(), 5 * 60 * 1000).unref();
 function portalBaseUrl() {
-    if (LINK_URL)
-        return LINK_URL.replace(/\/+$/, "");
+    if (LINK_BASE_URL)
+        return LINK_BASE_URL;
     if (LINK_PORT)
         return `http://localhost:${LINK_PORT}`;
     return undefined;
 }
-/** Idle timeout for managed image containers (10 minutes) */
-const IMAGE_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+/** Idle timeout for managed sandboxes (10 minutes) */
+const MANAGED_SANDBOX_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 if (provisioner) {
     await provisioner.reconcile();
-    await provisioner.stopIdle(IMAGE_IDLE_TIMEOUT_MS);
-    setInterval(() => provisioner.stopIdle(IMAGE_IDLE_TIMEOUT_MS), IMAGE_IDLE_TIMEOUT_MS).unref();
+    await provisioner.stopIdle(MANAGED_SANDBOX_IDLE_TIMEOUT_MS);
+    setInterval(() => provisioner.stopIdle(MANAGED_SANDBOX_IDLE_TIMEOUT_MS), MANAGED_SANDBOX_IDLE_TIMEOUT_MS).unref();
+}
+if (sandbox.type === "gondolin" && sandbox.profile === "remote") {
+    checkWorkspaceExported(workingDir, sandboxSettings?.gondolin?.remote?.gateway?.hostnames?.[0]);
+    await gondolinGateway.start();
+    await gondolinFleet.reconcile();
+    setInterval(() => {
+        void stopIdleGondolinVms(MANAGED_SANDBOX_IDLE_TIMEOUT_MS);
+        void gondolinFleet.reconcile();
+    }, MANAGED_SANDBOX_IDLE_TIMEOUT_MS).unref();
+}
+else if (sandbox.type === "gondolin") {
+    gondolinInventory.touchHeartbeat();
+    await gondolinInventory.reconcile();
+    setInterval(() => {
+        gondolinInventory.touchHeartbeat();
+        void stopIdleGondolinVms(MANAGED_SANDBOX_IDLE_TIMEOUT_MS);
+        void sweepUnadoptedGondolinWorkers();
+    }, MANAGED_SANDBOX_IDLE_TIMEOUT_MS).unref();
 }
-// Declared before the runtime so the notifier closure can capture them;
-// bots register below once their platforms initialize.
-const bots = [];
 const botsByPlatform = {};
 /**
- * Extension `api.notify` backend: post into a conversation without an agent
- * run. Platform resolution mirrors event files — explicit platform, or the
- * sole running platform.
+ * Resolve which platform bot to use: an explicit platform, or the sole
+ * running one. Mirrors event-file platform resolution.
  */
-const platformNotifier = async (conversationId, text, platform) => {
+function resolvePlatformBot(op, platform) {
     const available = Object.keys(botsByPlatform);
     const key = platform?.trim().toLowerCase() || (available.length === 1 ? available[0] : undefined);
     const bot = key ? botsByPlatform[key] : undefined;
     if (!bot) {
         throw new Error(platform
-            ? `notify: unknown platform '${platform}' (available: ${available.join(", ") || "none"})`
-            : `notify: multiple platforms active (${available.join(", ")}); specify platform`);
+            ? `${op}: unknown platform '${platform}' (available: ${available.join(", ") || "none"})`
+            : `${op}: multiple platforms active (${available.join(", ")}); specify platform`);
     }
+    return [key, bot];
+}
+/** Extension `api.notify` backend: post into a conversation without a run. */
+const platformNotifier = async (conversationId, text, platform) => {
+    const [key, bot] = resolvePlatformBot("notify", platform);
     await bot.postMessage(conversationId, text);
     log.logInfo(`[notify] posted to ${key}/${conversationId} (${text.length} chars)`);
 };
+/** Extension `api.react` backend: add a reaction to a message. */
+const platformReactor = async (conversationId, messageTs, emoji, platform) => {
+    const [key, bot] = resolvePlatformBot("react", platform);
+    if (!bot.addReaction) {
+        throw new Error(`react: platform '${key}' does not support reactions`);
+    }
+    await bot.addReaction(conversationId, messageTs, emoji);
+    log.logInfo(`[react] :${emoji}: on ${key}/${conversationId}`);
+};
+/** Extension `api.uploadFile` backend: send a host file into a conversation. */
+const platformUploader = async (conversationId, filePath, title, platform) => {
+    const [key, bot] = resolvePlatformBot("upload", platform);
+    if (!bot.uploadFile) {
+        throw new Error(`upload: platform '${key}' does not support file uploads`);
+    }
+    await bot.uploadFile(conversationId, filePath, title);
+    log.logInfo(`[upload] ${filePath} to ${key}/${conversationId}`);
+};
+/** github_* tool backends: PR push/create and CI checks, host-side. */
+function requireGithubBot(op) {
+    const bot = botsByPlatform.github;
+    if (!bot) {
+        throw new Error(`${op}: the GitHub platform is not running`);
+    }
+    return bot;
+}
+/**
+ * Platform capability pack factories — only when the corresponding bot is
+ * configured. Factories, not instances: each runner materializes its own
+ * pack so per-run bind state never crosses conversations.
+ */
+function buildPlatformToolPackFactories() {
+    if (!hasGithub)
+        return [];
+    const platformGithubOps = {
+        pushAndCreatePr: (conversationId, request) => requireGithubBot("github_pr").ops.pushAndCreatePr(conversationId, request),
+        getChecks: (conversationId, branch) => requireGithubBot("github_checks").ops.getChecks(conversationId, branch),
+        getJobLog: (conversationId, jobId) => requireGithubBot("github_checks").ops.getJobLog(conversationId, jobId),
+        getBuildLog: (conversationId, buildId) => requireGithubBot("github_checks").ops.getBuildLog(conversationId, buildId),
+        replyToReviewThread: (conversationId, commentId, body) => requireGithubBot("github_review_reply").ops.replyToReviewThread(conversationId, commentId, body),
+        syncRepo: (conversationId, branch) => requireGithubBot("github_sync").ops.syncRepo(conversationId, branch),
+        readGithub: (conversationId, request) => requireGithubBot("github_read").ops.readGithub(conversationId, request),
+        manageIssue: (conversationId, request) => requireGithubBot("github_issue").ops.manageIssue(conversationId, request),
+    };
+    return [() => createGithubToolPack(platformGithubOps)];
+}
 const handler = createConversationRuntime({
     workingDir,
     sandbox,
     vaultManager,
     provisioner,
+    resourceController,
     linkTokenStore,
     sessionViewTokenStore,
     adminTokenStore,
     portalBaseUrl: portalBaseUrl(),
     platformNotifier,
+    platformReactor,
+    platformUploader,
+    platformToolPackFactories: buildPlatformToolPackFactories(),
 });
 const sandboxDesc = sandbox.type === "host"
     ? "host"
@@ -321,9 +432,11 @@ const sandboxDesc = sandbox.type === "host"
         ? `container:${sandbox.container}`
         : sandbox.type === "image"
             ? `image:${sandbox.image}`
-            : sandbox.type === "firecracker"
-                ? `firecracker:${sandbox.vmId}`
-                : `cloudflare:${sandbox.sandboxId}`;
+            : sandbox.type === "gondolin"
+                ? `gondolin:${sandbox.profile}`
+                : sandbox.type === "firecracker"
+                    ? `firecracker:${sandbox.vmId}`
+                    : `cloudflare:${sandbox.sandboxId}`;
 log.logStartup(workingDir, sandboxDesc);
 logHarnessStartupSummary();
 /**
@@ -368,7 +481,6 @@ if (hasSlack) {
         workingDir,
         store: sharedStore,
     });
-    bots.push(slackMessagingBot);
     botsByPlatform.slack = slackMessagingBot;
     log.logInfo("Platform: Slack");
 }
@@ -381,7 +493,6 @@ if (hasTelegram) {
         token: telegramToken,
         workingDir,
     });
-    bots.push(telegramMessagingBot);
     botsByPlatform.telegram = telegramMessagingBot;
     log.logInfo("Platform: Telegram");
 }
@@ -394,10 +505,49 @@ if (hasDiscord) {
         token: discordToken,
         workingDir,
     });
-    bots.push(discordMessagingBot);
     botsByPlatform.discord = discordMessagingBot;
     log.logInfo("Platform: Discord");
 }
+if (hasGithub) {
+    if (!GITHUB_APP_ID || !GITHUB_INSTALLATION_ID) {
+        throw new Error("GitHub startup requires GITHUB_APP_ID and GITHUB_INSTALLATION_ID");
+    }
+    // Env vars flatten PEM newlines to literal `\n`; a key file avoids that.
+    const githubPrivateKey = GITHUB_APP_PRIVATE_KEY_PATH
+        ? readFileSync(GITHUB_APP_PRIVATE_KEY_PATH, "utf-8")
+        : GITHUB_APP_PRIVATE_KEY?.replace(/\\n/g, "\n");
+    if (!githubPrivateKey) {
+        throw new Error("GitHub startup requires GITHUB_APP_PRIVATE_KEY or GITHUB_APP_PRIVATE_KEY_PATH");
+    }
+    const pollIntervalSeconds = GITHUB_POLL_INTERVAL ? parseInt(GITHUB_POLL_INTERVAL, 10) : NaN;
+    const githubMessagingBot = new GithubMessagingBot(handler, {
+        appId: GITHUB_APP_ID,
+        privateKey: githubPrivateKey,
+        installationId: GITHUB_INSTALLATION_ID,
+        repos: GITHUB_REPOS
+            ? GITHUB_REPOS.split(",")
+                .map((repo) => repo.trim())
+                .filter(Boolean)
+            : [],
+        pollIntervalMs: (Number.isFinite(pollIntervalSeconds) && pollIntervalSeconds > 0 ? pollIntervalSeconds : 60) *
+            1000,
+        workingDir,
+        syncStatePath: join(stateDir, "github-sync.json"),
+        // Host-side GCP creds (e.g. a WIF external_account file) unlock Cloud
+        // Build logs in github_checks; without them external CI degrades to
+        // guidance text. Credentials never enter the sandbox.
+        cloudBuild: GOOGLE_APPLICATION_CREDENTIALS
+            ? {
+                tokenProvider: new GcpTokenProvider({
+                    credentialsPath: GOOGLE_APPLICATION_CREDENTIALS,
+                }),
+                projectFallback: GOOGLE_CLOUD_PROJECT,
+            }
+            : undefined,
+    });
+    botsByPlatform.github = githubMessagingBot;
+    log.logInfo(`Platform: GitHub${GOOGLE_APPLICATION_CREDENTIALS ? " (Cloud Build logs enabled)" : ""}`);
+}
 if (LINK_PORT) {
     startWebServer({
         port: LINK_PORT,
@@ -424,13 +574,14 @@ eventsWatcher.start();
 async function shutdown() {
     await handler.shutdown();
     eventsWatcher.stop();
+    await disconnectAllGondolinRuntimes();
     await Sentry.close(5000);
     process.exit(0);
 }
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 // Start all bots
-await Promise.all(bots.map((bot) => bot.start().catch((err) => {
+await Promise.all(Object.values(botsByPlatform).map((bot) => bot.start().catch((err) => {
     log.logWarning("Failed to start bot", err instanceof Error ? err.message : String(err));
     process.exit(1);
 })));