@geminixiang/mikan 1.0.0-beta.7 → 1.0.0-beta.71

package/dist/main.js

@@ -1,38 +1,47 @@
 #!/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 { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { DiscordMessagingBot } from "./adapters/discord/bot.js";
+import { GithubMessagingBot } from "./adapters/github/bot.js";
+import { createGithubToolPack } from "./adapters/github/tool-pack.js";
 import { TelegramMessagingBot } from "./adapters/telegram/bot.js";
 import { SlackMessagingBot as SlackMessagingBotClass } from "./adapters/slack/bot.js";
-import { downloadChannel } from "./download.js";
-import { EventsWatcher } from "./events.js";
+import { createSlackToolPack } from "./adapters/slack/tool-pack.js";
+import { downloadChannel } from "./cli/download.js";
+import { DreamScheduler } from "./dream/index.js";
+import { EventScheduler } from "./events/scheduler.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 { 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 { createProcessShutdownHandler, runShutdownSteps } from "./cli/process-lifecycle.js";
+import { startWebServer } from "./adapters/web/server.js";
+import { InMemoryAdminTokenStore } from "./adapters/web/admin/portal.js";
+import { InMemoryLinkTokenStore } from "./adapters/web/login/portal.js";
+import { InMemorySessionViewTokenStore } from "./adapters/web/session-view/portal.js";
+import { DockerContainerManager } from "./sandbox/provisioner.js";
+import { loadGlobalSettings, MissingGlobalSettingsError } from "./settings/index.js";
+import { assertStateDirOutsideWorkspace } from "./file-guards.js";
+import { resolveLinkBaseUrl } from "./env-manifest.js";
+import { configureHttpDispatcher, defaultModelsJsonPath, parseHttpIdleTimeoutMs, } from "./harness/index.js";
+import { readEnv, setEnvAliases } from "./env-manifest.js";
+import { ensureDirExists, isRecord, readJsonFileIfExists } from "./file-guards.js";
+import { SandboxError, validateSandbox } from "./sandbox/index.js";
+import { helpText, resolveBoot } from "./cli/boot.js";
+import { runOnboardCommand } from "./cli/onboard.js";
+import { envReport, noPlatformsMessage, platformIsActive } from "./env-manifest.js";
 import { FileVaultManager } from "./vault/index.js";
-import { runExtCommand } from "./cli/ext.js";
+import { runOfficeCommand } from "./cli/office.js";
+import { runSessionsCommand } from "./cli/sessions.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";
+import { captureError, shutdownObservability } from "./observability/index.js";
 function getVersion() {
     // Try to find package.json in the dist directory or parent
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
     const possiblePaths = [
-        pathJoin(dirname(fileURLToPath(import.meta.url)), "package.json"),
-        pathJoin(dirname(fileURLToPath(import.meta.url)), "..", "package.json"),
-        pathJoin(process.cwd(), "package.json"),
+        join(moduleDir, "package.json"),
+        join(dirname(moduleDir), "package.json"),
+        join(process.cwd(), "package.json"),
     ];
     for (const pkgPath of possiblePaths) {
         const pkg = readJsonFileIfExists(pkgPath, (value) => isRecord(value), () => "Ignoring package.json while resolving version");
@@ -45,57 +54,28 @@ 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 GITHUB_WEBHOOK_SECRET = readEnv("GITHUB_WEBHOOK_SECRET");
+// 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 OPENCONNECTOR_ENDPOINT = readEnv("OPENCONNECTOR_ENDPOINT");
+const openConnector = OPENCONNECTOR_ENDPOINT
+    ? { url: OPENCONNECTOR_ENDPOINT }
+    : undefined;
 const WORLD_WRITABLE_MODE = 0o002;
+// How long in-flight runs (and messages already queued behind them) may keep
+// running after a shutdown signal before they are aborted. pm2 fork-mode reload
+// is sequential, so this is also the window where no process is connected to
+// the platforms; Slack's documented redelivery schedule ends at five minutes.
+const SHUTDOWN_DRAIN_TIMEOUT_MS = 5 * 60_000;
 function ensureSecureStateDir(path) {
     let stat;
     try {
@@ -150,38 +130,44 @@ function handleStartupError(error) {
     console.error(String(error));
     process.exit(1);
 }
-// `mikan ext …` manages extensions and exits; handle it before the normal
-// bot-mode argument parsing (which requires a workspace dir and tokens).
-if (process.argv[2] === "ext") {
-    const code = await runExtCommand(process.argv.slice(3));
-    process.exit(code);
-}
-let parsedArgs;
+let plan;
 try {
-    parsedArgs = parseArgs();
+    plan = resolveBoot();
 }
 catch (error) {
     handleStartupError(error);
 }
+// `mikan office …` inspects/claims conversation offices and exits.
+if (plan.mode === "office") {
+    process.exit(runOfficeCommand(plan.officeArgs ?? []));
+}
+// `mikan sessions …` migrates/maintains session files and exits.
+if (plan.mode === "sessions") {
+    process.exit(await runSessionsCommand(plan.sessionsArgs ?? []));
+}
 // 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");
+// Handle onboard mode
+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.");
-        process.exit(0);
+        process.exit(await runOnboardCommand(stateDir));
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));
@@ -189,53 +175,89 @@ 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 === "cloudflare"
             ? "  Vault system enabled. Conversation-scoped credential routing active."
             : "  Vault system enabled. Host mode will not inject vault env.");
 }
@@ -247,11 +269,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, {
@@ -259,11 +282,25 @@ const provisioner = sandbox.type === "image"
         boostLimits: sandboxBoostLimits,
     })
     : undefined;
+// 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.
+const registryOffices = new OfficeRegistry(stateDir).getOffices();
+if (provisioner && registryOffices.length > 0) {
+    provisioner.armContainerLayoutMigration(buildContainerBindTranslator({
+        offices: registryOffices,
+        workspaceRoot: workingDir,
+        stateDir,
+    }));
+}
+const resourceController = sandbox.type === "image" ? provisioner : undefined;
 if (sandbox.type === "image") {
-    ensureDirExists(join(workingDir, "skills"));
-    ensureDirExists(join(workingDir, "events"));
+    ensureDirExists(workspace.skillsDir);
+    ensureDirExists(workspace.agentsDir);
     try {
-        writeFileSync(join(workingDir, "MEMORY.md"), "", { flag: "wx" });
+        writeFileSync(workspace.memoryPath, "", { flag: "wx" });
     }
     catch (err) {
         if (err.code !== "EEXIST")
@@ -277,64 +314,90 @@ 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();
 }
-// Declared before the runtime so the notifier closure can capture them;
-// bots register below once their platforms initialize.
-const bots = [];
 const botsByPlatform = {};
-/**
- * Resolve which platform bot to use: an explicit platform, or the sole
- * running one. Mirrors event-file platform resolution.
- */
-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;
+/** github_* tool backends: PR push/create and CI checks, host-side. */
+function requireGithubBot(op) {
+    const bot = botsByPlatform.github;
     if (!bot) {
-        throw new Error(platform
-            ? `${op}: unknown platform '${platform}' (available: ${available.join(", ") || "none"})`
-            : `${op}: multiple platforms active (${available.join(", ")}); specify platform`);
+        throw new Error(`${op}: the GitHub platform is not running`);
     }
-    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`);
+    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;
+}
+/**
+ * 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));
     }
-    await bot.addReaction(conversationId, messageTs, emoji);
-    log.logInfo(`[react] :${emoji}: on ${key}/${conversationId}`);
-};
+    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),
+        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;
+}
+let eventScheduler;
 const handler = createConversationRuntime({
-    workingDir,
+    workspace,
+    eventScheduler: () => eventScheduler,
     sandbox,
     vaultManager,
     provisioner,
+    resourceController,
     linkTokenStore,
     sessionViewTokenStore,
     adminTokenStore,
+    openConnector,
     portalBaseUrl: portalBaseUrl(),
-    platformNotifier,
-    platformReactor,
+    platformToolPackFactories: buildPlatformToolPackFactories(),
 });
 const sandboxDesc = sandbox.type === "host"
     ? "host"
@@ -342,9 +405,7 @@ const sandboxDesc = sandbox.type === "host"
         ? `container:${sandbox.container}`
         : sandbox.type === "image"
             ? `image:${sandbox.image}`
-            : sandbox.type === "firecracker"
-                ? `firecracker:${sandbox.vmId}`
-                : `cloudflare:${sandbox.sandboxId}`;
+            : `cloudflare:${sandbox.sandboxId}`;
 log.logStartup(workingDir, sandboxDesc);
 logHarnessStartupSummary();
 /**
@@ -358,19 +419,6 @@ function logHarnessStartupSummary() {
         process.env.HTTP_PROXY ??
         process.env.http_proxy;
     log.logInfo(`HTTP dispatcher: idle timeout ${httpIdleTimeoutMs}ms${proxy ? `, proxy ${proxy}` : ", no proxy"}`);
-    const authPath = defaultAuthPath();
-    if (existsSync(authPath)) {
-        try {
-            const providers = Object.keys(JSON.parse(readFileSync(authPath, "utf-8")));
-            log.logInfo(`Harness auth: ${authPath} (providers: ${providers.join(", ") || "none"})`);
-        }
-        catch {
-            log.logWarning(`Harness auth: ${authPath} exists but is not valid JSON`);
-        }
-    }
-    else {
-        log.logInfo(`Harness auth: ${authPath} missing — provider keys come from env vars only`);
-    }
     const modelsPath = defaultModelsJsonPath();
     log.logInfo(existsSync(modelsPath)
         ? `Harness models.json: ${modelsPath}`
@@ -382,14 +430,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");
 }
@@ -400,9 +445,8 @@ if (hasTelegram) {
     }
     const telegramMessagingBot = new TelegramMessagingBot(handler, {
         token: telegramToken,
-        workingDir,
+        workspace,
     });
-    bots.push(telegramMessagingBot);
     botsByPlatform.telegram = telegramMessagingBot;
     log.logInfo("Platform: Telegram");
 }
@@ -413,14 +457,48 @@ if (hasDiscord) {
     }
     const discordMessagingBot = new DiscordMessagingBot(handler, {
         token: discordToken,
-        workingDir,
+        workspace,
     });
-    bots.push(discordMessagingBot);
     botsByPlatform.discord = discordMessagingBot;
     log.logInfo("Platform: Discord");
 }
-if (LINK_PORT) {
-    startWebServer({
+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"),
+    });
+    botsByPlatform.github = githubMessagingBot;
+    log.logInfo("Platform: GitHub");
+}
+const githubBotForWebhook = botsByPlatform.github;
+if (GITHUB_WEBHOOK_SECRET && (!githubBotForWebhook || !LINK_PORT)) {
+    log.logWarning("GITHUB_WEBHOOK_SECRET is set but " +
+        (githubBotForWebhook ? "LINK_PORT is not" : "the GitHub platform is not enabled") +
+        " — the webhook endpoint will not be served");
+}
+const webServer = LINK_PORT
+    ? startWebServer({
         port: LINK_PORT,
         linkTokenStore,
         vaultManager,
@@ -431,28 +509,109 @@ if (LINK_PORT) {
         },
         sessionViewTokenStore,
         sessionViewInteractive: { handler, botsByPlatform },
-        adminOptions: { adminTokenStore, workingDir, runtime: handler, sandbox, botsByPlatform },
+        adminOptions: {
+            adminTokenStore,
+            workspace,
+            runtime: handler,
+            sandbox,
+            botsByPlatform,
+            eventScheduler: () => eventScheduler,
+        },
+        githubWebhook: GITHUB_WEBHOOK_SECRET && githubBotForWebhook
+            ? {
+                secret: GITHUB_WEBHOOK_SECRET,
+                onPoke: () => githubBotForWebhook.requestPoll(),
+            }
+            : undefined,
+    })
+    : undefined;
+function closeWebServer() {
+    if (!webServer)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        webServer.close((error) => (error ? reject(error) : resolve()));
     });
 }
-// Start events watcher with explicit platform routing
-const eventsWatcher = new EventsWatcher(join(workingDir, "events"), botsByPlatform);
+async function stopConversationIntake() {
+    const results = await Promise.allSettled([
+        ...Object.values(botsByPlatform).map((bot) => bot.stop()),
+        closeWebServer(),
+    ]);
+    const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (failures.length > 0)
+        throw new AggregateError(failures, "Failed to stop conversation intake");
+}
+async function waitForGracefulDrain(drain) {
+    let timeout;
+    const settled = await Promise.race([
+        drain.then(() => true),
+        new Promise((resolve) => {
+            timeout = setTimeout(() => resolve(false), SHUTDOWN_DRAIN_TIMEOUT_MS);
+        }),
+    ]);
+    if (timeout)
+        clearTimeout(timeout);
+    return settled;
+}
+async function drainConversationWork(intakeStop) {
+    const dreamStop = dreamScheduler.stop();
+    const gracefulDrain = Promise.allSettled([intakeStop, dreamStop]);
+    if (!(await waitForGracefulDrain(gracefulDrain))) {
+        const runtimeResult = await Promise.allSettled([handler.shutdown(0)]);
+        const failures = [
+            new Error(`Conversation work did not drain within ${SHUTDOWN_DRAIN_TIMEOUT_MS}ms`),
+            ...runtimeResult.flatMap((result) => (result.status === "rejected" ? [result.reason] : [])),
+        ];
+        throw new AggregateError(failures, "Failed to drain conversation work");
+    }
+    const results = [
+        ...(await gracefulDrain),
+        ...(await Promise.allSettled([handler.shutdown(SHUTDOWN_DRAIN_TIMEOUT_MS)])),
+    ];
+    const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (failures.length > 0)
+        throw new AggregateError(failures, "Failed to drain conversation work");
+}
+// Start the event scheduler; office event stores notify it through the runtime.
+eventScheduler = new EventScheduler(workspace, botsByPlatform);
 const slackMessagingBot = botsByPlatform.slack;
 if (slackMessagingBot) {
-    slackMessagingBot.setEventsWatcher(eventsWatcher);
-}
-eventsWatcher.start();
-// Handle shutdown
-async function shutdown() {
-    await handler.shutdown();
-    eventsWatcher.stop();
-    await Sentry.close(5000);
-    process.exit(0);
+    slackMessagingBot.setEventScheduler(eventScheduler);
 }
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
+eventScheduler.start();
+const dreamScheduler = new DreamScheduler(workspace, handler);
+dreamScheduler.start();
+// Handle shutdown. A second signal is an explicit request to stop waiting.
+const shutdown = createProcessShutdownHandler({
+    stop: () => {
+        const intakeStop = stopConversationIntake();
+        return runShutdownSteps([
+            {
+                name: "event scheduler",
+                run: async () => {
+                    eventScheduler?.stop();
+                },
+            },
+            { name: "conversation work", run: () => drainConversationWork(intakeStop) },
+        ]);
+    },
+    shutdownObservability: () => shutdownObservability(5000),
+    captureError,
+    warn: log.logWarning,
+    exit: (code) => process.exit(code),
+});
+process.on("SIGINT", () => void shutdown("SIGINT"));
+process.on("SIGTERM", () => void shutdown("SIGTERM"));
 // 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