@geminixiang/mikan 1.0.0-beta.4 → 1.0.0-beta.40

package/dist/main.js

@@ -1,30 +1,39 @@
 #!/usr/bin/env node
 import "./observability/instrument.js";
-import { join, resolve } from "path";
-import { mkdirSync, statSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { fileURLToPath } from "url";
-import { dirname, join as pathJoin } from "path";
+import { join } from "node:path";
+import { mkdirSync, statSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join as pathJoin } from "node: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 { createSlackToolPack } from "./adapters/slack/tool-pack.js";
+import { downloadChannel } from "./cli/download.js";
 import { EventsWatcher } from "./events.js";
+import { ExtensionCallbackScheduler } from "./extension-schedules.js";
 import * as log from "./log.js";
 import { startWebServer } from "./web/server.js";
 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 { existsSync, readFileSync } from "node:fs";
+import { readEnv, setEnvAliases } from "./env-manifest.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 { configureGondolinRuntime, gondolinResources, reconcileGondolinRuntimes, stopAllGondolinRuntimes, stopIdleGondolinVms, } from "./sandbox/gondolin.js";
 import { FileVaultManager } from "./vault/index.js";
+import { runExtCommand } from "./cli/ext.js";
+import { runOfficeCommand } from "./cli/office.js";
+import { buildContainerBindTranslator, createWorkspace, formatUnmigratedOfficesError, migrateLegacyOffices, OfficeRegistry, } from "./office/index.js";
 import { createConversationRuntime } from "./runtime/conversation-runtime.js";
-import { ChannelStore } from "./store.js";
 import * as Sentry from "@sentry/node";
 function getVersion() {
     // Try to find package.json in the dist directory or parent
@@ -44,56 +53,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 +121,48 @@ 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);
+}
+// `mikan office …` inspects/claims conversation offices and exits.
+if (plan.mode === "office") {
+    process.exit(runOfficeCommand(plan.officeArgs ?? []));
+}
 // 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 --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,53 +171,92 @@ 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);
 }
+// Move legacy raw-id conversation directories to the office-key layout before
+// anything touches the workspace. Runs every boot; a completed migration is a
+// no-op. Unowned or failed offices are fatal: after the layout flip a legacy
+// directory is invisible to the runtime, and booting anyway would present
+// those conversations as silently empty.
+const enabledPlatforms = [
+    ...(hasSlack ? ["slack"] : []),
+    ...(hasTelegram ? ["telegram"] : []),
+    ...(hasDiscord ? ["discord"] : []),
+    ...(hasGithub ? ["github"] : []),
+];
+const officeMigration = (() => {
+    try {
+        return migrateLegacyOffices({ workspaceRoot: workingDir, stateDir, enabledPlatforms });
+    }
+    catch (error) {
+        handleStartupError(error);
+    }
+})();
+if (officeMigration.unowned.length > 0 ||
+    officeMigration.failed.length > 0 ||
+    officeMigration.vaultConflicts.length > 0 ||
+    officeMigration.stateDirConflicts.length > 0) {
+    console.error(formatUnmigratedOfficesError(officeMigration));
+    process.exit(1);
+}
+if (officeMigration.migrated.length > 0 || officeMigration.recovered.length > 0) {
+    console.log(`  Office layout migration: ${officeMigration.migrated.length} moved, ` +
+        `${officeMigration.recovered.length} recovered.`);
+}
+if (officeMigration.vaultKeysMigrated.length > 0) {
+    console.log(`  Vault keys migrated to office keys: ${officeMigration.vaultKeysMigrated.length}.`);
+}
+if (officeMigration.stateDirsMigrated.length > 0) {
+    console.log(`  Host state dirs migrated to office keys: ${officeMigration.stateDirsMigrated.length}.`);
+}
 try {
     await validateSandbox(sandbox);
 }
 catch (error) {
     handleStartupError(error);
 }
+// The one Workspace value for this process: workspace-global paths plus the
+// per-conversation Office factory. Constructed after the office migration so
+// every office it materializes lands in the office-key layout.
+const workspace = createWorkspace({ root: workingDir, stateDir });
 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 +268,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,11 +281,49 @@ const provisioner = sandbox.type === "image"
         boostLimits: sandboxBoostLimits,
     })
     : undefined;
-if (sandbox.type === "image") {
-    ensureDirExists(join(workingDir, "skills"));
-    ensureDirExists(join(workingDir, "events"));
+// Containers provisioned before the office migration mount the renamed
+// legacy paths. Their writable layers (everything installed inside) are
+// preserved: each container is committed and recreated with translated
+// mounts — on demand before its next message, and via a background sweep
+// after the bots start. MIKAN_SKIP_CONTAINER_PRESERVATION=1 falls back to
+// plain removal (containers rebuild from the base image on next use).
+const registryOffices = new OfficeRegistry(stateDir).getOffices();
+if (provisioner && registryOffices.length > 0) {
+    if (readEnv("SKIP_CONTAINER_PRESERVATION") === "1") {
+        if (officeMigration.migrated.length > 0 || officeMigration.recovered.length > 0) {
+            await provisioner.removeContainersForConversations(new Set([...officeMigration.migrated, ...officeMigration.recovered]));
+        }
+    }
+    else {
+        provisioner.armContainerLayoutMigration(buildContainerBindTranslator({
+            offices: registryOffices,
+            workspaceRoot: workingDir,
+            stateDir,
+        }));
+    }
+}
+if (sandbox.type === "gondolin") {
     try {
-        writeFileSync(join(workingDir, "MEMORY.md"), "", { flag: "wx" });
+        configureGondolinRuntime({
+            limits: sandboxLimits,
+            boostLimits: sandboxBoostLimits,
+        });
+    }
+    catch (error) {
+        handleStartupError(error);
+    }
+}
+const resourceController = sandbox.type === "image"
+    ? provisioner
+    : sandbox.type === "gondolin"
+        ? gondolinResources
+        : undefined;
+if (sandbox.type === "image" || sandbox.type === "gondolin") {
+    ensureDirExists(workspace.skillsDir);
+    ensureDirExists(workspace.eventsDir);
+    ensureDirExists(workspace.agentsDir);
+    try {
+        writeFileSync(workspace.memoryPath, "", { flag: "wx" });
     }
     catch (err) {
         if (err.code !== "EEXIST")
@@ -270,50 +337,200 @@ 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") {
+    await reconcileGondolinRuntimes();
+    setInterval(() => void stopIdleGondolinVms(MANAGED_SANDBOX_IDLE_TIMEOUT_MS), 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, options) => {
+    const [key, bot] = resolvePlatformBot("notify", options?.platform);
+    let messageTs;
+    if (options?.threadTs) {
+        if (!bot.postInThread) {
+            throw new Error(`notify: platform '${key}' does not support threaded posts`);
+        }
+        messageTs = await bot.postInThread(conversationId, options.threadTs, text);
+    }
+    else {
+        messageTs = await bot.postMessage(conversationId, text);
     }
-    await bot.postMessage(conversationId, text);
     log.logInfo(`[notify] posted to ${key}/${conversationId} (${text.length} chars)`);
+    return messageTs;
+};
+/** Extension `api.openDm` backend: resolve a user's DM conversation id. */
+const platformDmOpener = async (userId, platform) => {
+    const [key, bot] = resolvePlatformBot("openDm", platform);
+    if (!bot.openDirectConversation) {
+        throw new Error(`openDm: platform '${key}' does not support opening direct messages`);
+    }
+    return bot.openDirectConversation(userId);
+};
+/** Extension `api.fetchHistory` backend: read recent conversation messages. */
+const platformHistoryFetcher = async (conversationId, options) => {
+    const [key, bot] = resolvePlatformBot("fetchHistory", options?.platform);
+    if (!bot.fetchHistory) {
+        throw new Error(`fetchHistory: platform '${key}' does not support history reads`);
+    }
+    const { platform: _platform, ...historyOptions } = options ?? {};
+    return bot.fetchHistory(conversationId, historyOptions);
+};
+/** Extension `api.listUsers` backend: list the workspace's active users. */
+const platformUserLister = async (platform) => {
+    const [key, bot] = resolvePlatformBot("listUsers", platform);
+    if (!bot.listUsers) {
+        throw new Error(`listUsers: platform '${key}' does not support user listings`);
+    }
+    return bot.listUsers();
+};
+/** 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;
+}
+/** slack_* tool backends: Block Kit posting/updating, host-side. */
+function requireSlackBot(op) {
+    const bot = botsByPlatform.slack;
+    if (!bot) {
+        throw new Error(`${op}: the Slack platform is not running`);
+    }
+    return bot;
+}
+/** Extension `api.blockkit` backend: interactive Block Kit, Slack-only today. */
+const platformBlockKit = {
+    postBlocks: async (conversationId, message, platform) => {
+        if (platform && platform !== "slack") {
+            throw new Error(`blockkit: platform '${platform}' does not support Block Kit`);
+        }
+        const bot = requireSlackBot("blockkit");
+        const ts = message.threadTs
+            ? await bot.postInThreadBlocks(conversationId, message.threadTs, message.text, message.blocks)
+            : await bot.postMessageBlocks(conversationId, message.text, message.blocks);
+        return { ts };
+    },
+    updateBlocks: async (conversationId, messageTs, message, platform) => {
+        if (platform && platform !== "slack") {
+            throw new Error(`blockkit: platform '${platform}' does not support Block Kit`);
+        }
+        await requireSlackBot("blockkit").updateMessageBlocks(conversationId, messageTs, message.text, message.blocks);
+    },
 };
+/**
+ * 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() {
+    const factories = [];
+    if (hasSlack) {
+        const platformSlackOps = {
+            postBlocks: async (conversationId, { text, blocks, threadTs }) => {
+                const bot = requireSlackBot("slack_blockkit");
+                const ts = threadTs
+                    ? await bot.postInThreadBlocks(conversationId, threadTs, text, blocks)
+                    : await bot.postMessageBlocks(conversationId, text, blocks);
+                bot.logBotResponse(conversationId, text, ts, threadTs, blocks);
+                return { ts };
+            },
+            updateBlocks: async (conversationId, { ts, text, blocks, threadTs }) => {
+                const bot = requireSlackBot("slack_blockkit");
+                await bot.updateMessageBlocks(conversationId, ts, text, blocks);
+                bot.logBotResponse(conversationId, text, ts, threadTs, blocks);
+            },
+            ownsBlockKitMessage: (conversationId, ts, threadTs) => requireSlackBot("slack_blockkit").ownsBlockKitMessage(conversationId, ts, threadTs),
+        };
+        factories.push(() => createSlackToolPack(platformSlackOps));
+    }
+    if (!hasGithub)
+        return factories;
+    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),
+    };
+    factories.push(() => createGithubToolPack(platformGithubOps));
+    return factories;
+}
+// Host-authoritative engine for extension callback schedules. Dispatch routes
+// through the runtime so fires run against the conversation's activated
+// extensions; created before the runtime, wired after (mutual reference).
+const extensionScheduleEngine = new ExtensionCallbackScheduler({
+    stateDir,
+    dispatch: (fire) => handler.handleExtensionScheduleCallback(fire),
+});
 const handler = createConversationRuntime({
-    workingDir,
+    workspace,
     sandbox,
     vaultManager,
     provisioner,
+    resourceController,
     linkTokenStore,
     sessionViewTokenStore,
     adminTokenStore,
     portalBaseUrl: portalBaseUrl(),
     platformNotifier,
+    platformReactor,
+    platformUploader,
+    platformBlockKit,
+    platformDmOpener,
+    platformHistoryFetcher,
+    platformUserLister,
+    extensionScheduleEngine,
+    platformToolPackFactories: buildPlatformToolPackFactories(),
 });
 const sandboxDesc = sandbox.type === "host"
     ? "host"
@@ -321,9 +538,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();
 /**
@@ -361,14 +580,11 @@ if (hasSlack) {
     if (!slackMessagingBotToken || !slackAppToken) {
         throw new Error("Slack startup requires both SLACK_APP_TOKEN and SLACK_BOT_TOKEN");
     }
-    const sharedStore = new ChannelStore({ workingDir, botToken: slackMessagingBotToken });
     const slackMessagingBot = new SlackMessagingBotClass(handler, {
         appToken: slackAppToken,
         botToken: slackMessagingBotToken,
-        workingDir,
-        store: sharedStore,
+        workspace,
     });
-    bots.push(slackMessagingBot);
     botsByPlatform.slack = slackMessagingBot;
     log.logInfo("Platform: Slack");
 }
@@ -379,9 +595,8 @@ if (hasTelegram) {
     }
     const telegramMessagingBot = new TelegramMessagingBot(handler, {
         token: telegramToken,
-        workingDir,
+        workspace,
     });
-    bots.push(telegramMessagingBot);
     botsByPlatform.telegram = telegramMessagingBot;
     log.logInfo("Platform: Telegram");
 }
@@ -392,12 +607,51 @@ if (hasDiscord) {
     }
     const discordMessagingBot = new DiscordMessagingBot(handler, {
         token: discordToken,
-        workingDir,
+        workspace,
     });
-    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,
+        workspace,
+        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,
@@ -410,28 +664,38 @@ if (LINK_PORT) {
         },
         sessionViewTokenStore,
         sessionViewInteractive: { handler, botsByPlatform },
-        adminOptions: { adminTokenStore, workingDir, runtime: handler, sandbox, botsByPlatform },
+        adminOptions: { adminTokenStore, workspace, runtime: handler, sandbox, botsByPlatform },
     });
 }
 // Start events watcher with explicit platform routing
-const eventsWatcher = new EventsWatcher(join(workingDir, "events"), botsByPlatform);
+const eventsWatcher = new EventsWatcher(workspace.eventsDir, botsByPlatform);
 const slackMessagingBot = botsByPlatform.slack;
 if (slackMessagingBot) {
     slackMessagingBot.setEventsWatcher(eventsWatcher);
 }
 eventsWatcher.start();
+extensionScheduleEngine.start();
 // Handle shutdown
 async function shutdown() {
     await handler.shutdown();
     eventsWatcher.stop();
+    extensionScheduleEngine.stop();
+    await stopAllGondolinRuntimes();
     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);
 })));
+// Drain the container layout migration off the hot path; every unit is
+// idempotent, so an interrupted sweep simply resumes on the next boot.
+if (provisioner) {
+    void provisioner.sweepContainerLayoutMigration().catch((err) => {
+        log.logWarning("Container layout sweep failed", err instanceof Error ? err.message : String(err));
+    });
+}
 //# sourceMappingURL=main.js.map