@opencoreai/opencore 0.2.2

package/src/index.ts

@@ -0,0 +1,2523 @@
+import "dotenv/config";
+import figlet from "figlet";
+import { execFile, spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { promisify } from "node:util";
+import { stdin as input, stdout as output } from "node:process";
+import { DashboardServer } from "./dashboard-server.js";
+import { MacController } from "./mac-controller.mjs";
+import { SKILL_CATALOG } from "./skill-catalog.mjs";
+import {
+  buildCredentialExecutionContext,
+  ensureCredentialStore,
+  extractCredentialSaveCandidates,
+  readCredentialStore,
+  summarizeCredentialStoreForPrompt,
+  updateCredentialDefaults,
+  upsertCredentialEntry,
+} from "./credential-store.mjs";
+
+const MAX_STEPS = Math.max(1, Number(process.env.COMPUTER_USE_MAX_STEPS || 40));
+const ACTION_DELAY_MS = Math.max(0, Number(process.env.COMPUTER_USE_ACTION_DELAY_MS || 350));
+const OPENAI_MODEL = "gpt-5.4";
+const OPENAI_COMPUTER_MODEL_CANDIDATES = [OPENAI_MODEL, "computer-use-preview", "computer-use-preview-2025-03-11"];
+const API_IMAGE_MAX_BYTES = 5 * 1024 * 1024;
+const API_IMAGE_TARGET_BYTES = 4_900_000;
+const MANAGER_HEARTBEAT_INTERVAL_MS = Math.max(
+  15_000,
+  Number(process.env.OPENCORE_MANAGER_HEARTBEAT_INTERVAL_MS || 60_000),
+);
+const OPENCORE_HOME = path.join(os.homedir(), ".opencore");
+const SOUL_PATH = path.join(OPENCORE_HOME, "soul.md");
+const MEMORY_PATH = path.join(OPENCORE_HOME, "memory.md");
+const HEARTBEAT_PATH = path.join(OPENCORE_HOME, "heartbeat.md");
+const GUIDELINES_PATH = path.join(OPENCORE_HOME, "guidelines.md");
+const INSTRUCTIONS_PATH = path.join(OPENCORE_HOME, "instructions.md");
+const SETTINGS_PATH = path.join(OPENCORE_HOME, "configs", "settings.json");
+const SCHEDULES_PATH = path.join(OPENCORE_HOME, "configs", "schedules.json");
+const SCREENSHOT_DIR = path.join(OPENCORE_HOME, "screenshots");
+const SKILLS_DIR = path.join(OPENCORE_HOME, "skills");
+const INDICATOR_STATE_PATH = path.join(OPENCORE_HOME, "indicator-state.json");
+const SCHEDULER_LOG_PATH = path.join(OPENCORE_HOME, "logs", "scheduler.log");
+const DASHBOARD_PORT = Number(process.env.OPENCORE_DASHBOARD_PORT || 4111);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT_DIR = path.resolve(__dirname, "..");
+const TEMPLATE_DIR = path.join(ROOT_DIR, "templates");
+const INDICATOR_SCRIPT_PATH = path.join(ROOT_DIR, "src", "opencore-indicator.js");
+const DEFAULT_SOUL = "# OpenCore Soul\nName: OpenCore\n";
+const DEFAULT_MEMORY = "# OpenCore Memory\n";
+const DEFAULT_HEARTBEAT = `# OpenCore Heartbeat
+
+## Current Task
+No active task.
+
+## Big Steps
+1. Wait for a new task.
+
+## Execution Notes
+- Rewrite this file at the start of every new task.
+`;
+const HEARTBEAT_SCHEDULE_START = "<!-- OPENCORE_SCHEDULES_START -->";
+const HEARTBEAT_SCHEDULE_END = "<!-- OPENCORE_SCHEDULES_END -->";
+const DEFAULT_GUIDELINES = "# OpenCore Guidelines\n";
+const DEFAULT_INSTRUCTIONS = "# OpenCore Instructions\n";
+const LEGACY_DEFAULT_MEMORY = `# OpenCore Memory
+
+This file stores durable notes and action history for both the Manager Agent and Computer Agent.
+`;
+const EDITABLE_FILES: Record<string, string> = {
+  soul: SOUL_PATH,
+  memory: MEMORY_PATH,
+  heartbeat: HEARTBEAT_PATH,
+  guidelines: GUIDELINES_PATH,
+  instructions: INSTRUCTIONS_PATH,
+};
+
+const DEFAULT_SYSTEM_SKILLS = SKILL_CATALOG.filter((skill: any) => skill?.config?.builtin);
+
+type ManagerRoute = "direct" | "computer" | "edit_file" | "local";
+type ManagerDecision = {
+  route: ManagerRoute;
+  direct_answer?: string;
+  computer_task?: string;
+  file_target?: string;
+  edit_instructions?: string;
+  local_task?: string;
+};
+
+type HeartbeatTickDecision = {
+  run_now: boolean;
+  task?: string;
+  reason?: string;
+};
+
+type ManagerInferredUpdate = {
+  target: string;
+  instructions: string;
+};
+
+type ManagerPersistentUpdatePlan = {
+  memory_notes?: string[];
+  file_updates?: ManagerInferredUpdate[];
+};
+
+type ScheduledTaskPlan = {
+  should_schedule: boolean;
+  cron_expression?: string;
+  task?: string;
+  summary?: string;
+  schedule_kind?: "one_time" | "recurring";
+  expected_time_iso?: string;
+};
+
+type ScheduledTaskRecord = {
+  id: string;
+  task: string;
+  cron_expression: string;
+  summary: string;
+  schedule_kind: "one_time" | "recurring";
+  created_at: string;
+  updated_at: string;
+  last_run_at?: string;
+  expected_time_iso?: string;
+  last_status?: "scheduled" | "running" | "done" | "error" | "missed" | "cancelled";
+  last_error?: string;
+  active: boolean;
+  source_prompt: string;
+};
+
+type ProviderRuntime = { provider: "chatgpt"; openai: any };
+
+type TelegramConfig = {
+  enabled: boolean;
+  botToken: string;
+  chatId: string;
+  userId: string;
+  pairingCode: string;
+  paired: boolean;
+  lastUpdateId: number;
+};
+
+const require = createRequire(import.meta.url);
+const { version: APP_VERSION } = require("../package.json");
+const execFileAsync = promisify(execFile);
+
+async function readSettings() {
+  try {
+    const raw = await fs.readFile(SETTINGS_PATH, "utf8");
+    return JSON.parse(raw || "{}");
+  } catch {
+    return {};
+  }
+}
+
+async function readTemplate(name: string, fallback: string) {
+  try {
+    return await fs.readFile(path.join(TEMPLATE_DIR, name), "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+async function ensureTemplateApplied(filePath: string, template: string, legacyDefaults: string[] = []) {
+  try {
+    const existing = await fs.readFile(filePath, "utf8");
+    const normalized = existing.trim();
+    const isLegacy = legacyDefaults.some((value) => normalized === String(value || "").trim());
+    if (isLegacy) {
+      await fs.writeFile(filePath, template, "utf8");
+    }
+  } catch {
+    await fs.writeFile(filePath, template, "utf8");
+  }
+}
+
+async function ensureOpenCoreHome() {
+  await fs.mkdir(path.join(OPENCORE_HOME, "configs"), { recursive: true });
+  await fs.mkdir(path.join(OPENCORE_HOME, "logs"), { recursive: true });
+  await fs.mkdir(path.join(OPENCORE_HOME, "cache"), { recursive: true });
+  await fs.mkdir(SCREENSHOT_DIR, { recursive: true });
+  await fs.mkdir(SKILLS_DIR, { recursive: true });
+
+  const soulTemplate = await readTemplate("default-soul.md", DEFAULT_SOUL);
+  const memoryTemplate = await readTemplate("default-memory.md", LEGACY_DEFAULT_MEMORY);
+  const guidelinesTemplate = await readTemplate("default-guidelines.md", DEFAULT_GUIDELINES);
+  const instructionsTemplate = await readTemplate("default-instructions.md", DEFAULT_INSTRUCTIONS);
+  const heartbeatTemplate = await readTemplate("default-heartbeat.md", DEFAULT_HEARTBEAT);
+
+  await ensureTemplateApplied(SOUL_PATH, soulTemplate, [DEFAULT_SOUL]);
+  await ensureTemplateApplied(MEMORY_PATH, memoryTemplate, [LEGACY_DEFAULT_MEMORY, DEFAULT_MEMORY]);
+  await ensureTemplateApplied(HEARTBEAT_PATH, heartbeatTemplate, [DEFAULT_HEARTBEAT]);
+  await ensureTemplateApplied(GUIDELINES_PATH, guidelinesTemplate, [DEFAULT_GUIDELINES]);
+  await ensureTemplateApplied(INSTRUCTIONS_PATH, instructionsTemplate, [DEFAULT_INSTRUCTIONS]);
+  try {
+    await fs.access(SETTINGS_PATH);
+  } catch {
+    await fs.writeFile(
+      SETTINGS_PATH,
+      `${JSON.stringify(
+        {
+          name: "OpenCore",
+          platform: "macOS",
+          provider: "chatgpt",
+          openai_api_key: "",
+          telegram_enabled: false,
+          telegram_bot_token: "",
+          telegram_chat_id: "",
+          telegram_user_id: "",
+          telegram_pairing_code: "",
+          telegram_paired: false,
+          telegram_last_update_id: 0,
+          user_display_name: "",
+          assistant_tone: "",
+          schema_version: 1,
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+  }
+  try {
+    await fs.access(SCHEDULES_PATH);
+  } catch {
+    await fs.writeFile(SCHEDULES_PATH, "[]\n", "utf8");
+  }
+  await ensureDefaultOpenCoreSkills();
+  await ensureCredentialStore();
+}
+
+async function ensureDefaultOpenCoreSkills() {
+  for (const skill of DEFAULT_SYSTEM_SKILLS) {
+    const dir = path.join(SKILLS_DIR, skill.id);
+    const skillFile = path.join(dir, "SKILL.md");
+    const configFile = path.join(dir, "config.json");
+    await fs.mkdir(dir, { recursive: true });
+    try {
+      await fs.access(skillFile);
+    } catch {
+      await fs.writeFile(skillFile, `${skill.markdown.trim()}\n`, "utf8");
+    }
+    try {
+      await fs.access(configFile);
+    } catch {
+      await fs.writeFile(
+        configFile,
+        `${JSON.stringify(
+          {
+            id: skill.id,
+            name: skill.name,
+            description: skill.description,
+            ...skill.config,
+          },
+          null,
+          2,
+        )}\n`,
+        "utf8",
+      );
+    }
+  }
+}
+
+async function readSchedules(): Promise<ScheduledTaskRecord[]> {
+  try {
+    const raw = await fs.readFile(SCHEDULES_PATH, "utf8");
+    const parsed = JSON.parse(raw || "[]");
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+async function writeSchedules(items: ScheduledTaskRecord[]) {
+  await fs.writeFile(SCHEDULES_PATH, `${JSON.stringify(items, null, 2)}\n`, "utf8");
+}
+
+async function updateScheduleRecord(id: string, apply: (item: ScheduledTaskRecord) => ScheduledTaskRecord | null) {
+  const items = await readSchedules();
+  const next = items
+    .map((item) => (item.id === id ? apply(item) : item))
+    .filter(Boolean) as ScheduledTaskRecord[];
+  await writeSchedules(next);
+  return next.find((item) => item.id === id) || null;
+}
+
+async function setScheduleRecordState(id: string, patch: Partial<ScheduledTaskRecord>) {
+  const next = await updateScheduleRecord(id, (item) => ({ ...item, ...patch, updated_at: new Date().toISOString() }));
+  if (next) await syncHeartbeatScheduleRecord(next);
+  return next;
+}
+
+function shellQuote(value: string) {
+  return `'${String(value || "").replace(/'/g, `'\\''`)}'`;
+}
+
+async function readCrontabRaw() {
+  try {
+    const { stdout } = await execFileAsync("/bin/zsh", ["-lc", "crontab -l 2>/dev/null || true"]);
+    return String(stdout || "");
+  } catch {
+    return "";
+  }
+}
+
+async function writeCrontabRaw(content: string) {
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn("crontab", ["-"], {
+      stdio: ["pipe", "ignore", "pipe"],
+      env: process.env,
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk || "");
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if ((code ?? 1) !== 0) reject(new Error(stderr.trim() || `crontab exited with code ${code}`));
+      else resolve();
+    });
+    child.stdin.end(content);
+  });
+}
+
+function scheduleCronMarker(id: string) {
+  return `# OPENCORE_SCHEDULE:${id}`;
+}
+
+function buildScheduleCronLine(id: string, cronExpression: string) {
+  const binPath = path.join(ROOT_DIR, "bin", "opencore.mjs");
+  const cmd =
+    `${shellQuote(process.execPath)} ${shellQuote(binPath)} run-scheduled ${shellQuote(id)} ` +
+    `>> ${shellQuote(SCHEDULER_LOG_PATH)} 2>&1`;
+  return `${cronExpression} ${cmd} ${scheduleCronMarker(id)}`;
+}
+
+async function upsertCronSchedule(record: ScheduledTaskRecord) {
+  const current = await readCrontabRaw();
+  const filtered = current
+    .split("\n")
+    .filter((line) => !line.includes(scheduleCronMarker(record.id)) && !line.includes(`# OPENCORE_SCHEDULE:${record.id}`))
+    .filter((line, idx, arr) => !(idx === arr.length - 1 && !line.trim()));
+  filtered.push(buildScheduleCronLine(record.id, record.cron_expression));
+  await writeCrontabRaw(`${filtered.join("\n").trim()}\n`);
+}
+
+async function removeCronSchedule(id: string) {
+  const current = await readCrontabRaw();
+  const filtered = current
+    .split("\n")
+    .filter((line) => !line.includes(scheduleCronMarker(id)))
+    .filter((line, idx, arr) => !(idx === arr.length - 1 && !line.trim()));
+  await writeCrontabRaw(`${filtered.join("\n").trim()}\n`);
+}
+
+async function walkFiles(dir: string, out: string[] = []) {
+  let entries: any[] = [];
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkFiles(full, out);
+    } else {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+async function loadInstalledSkills(maxChars = 9000) {
+  const files = (await walkFiles(SKILLS_DIR))
+    .filter((file) => /skill\.md$/i.test(path.basename(file)) || /\.md$/i.test(file))
+    .sort((a, b) => a.localeCompare(b))
+    .slice(0, 30);
+  const chunks: string[] = [];
+  for (const file of files) {
+    const content = await readTextFile(file, "");
+    if (!content.trim()) continue;
+    const rel = path.relative(SKILLS_DIR, file);
+    chunks.push(`## ${rel}\n${content.trim()}`);
+    if (chunks.join("\n\n").length >= maxChars) break;
+  }
+  const joined = chunks.join("\n\n");
+  return joined.length > maxChars ? `${joined.slice(0, maxChars)}\n\n...[truncated]` : joined;
+}
+
+async function listInstalledSkillFiles() {
+  const files = (await walkFiles(SKILLS_DIR))
+    .filter((file) => /skill\.md$/i.test(path.basename(file)) || /\.md$/i.test(file))
+    .sort((a, b) => (a < b ? -1 : 1));
+  return files.map((file) => path.relative(SKILLS_DIR, file));
+}
+
+async function readTextFile(filePath: string, fallback = "") {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+async function appendMemory(entry: string) {
+  const line = `${new Date().toISOString()} ${entry}\n`;
+  await fs.appendFile(MEMORY_PATH, line, "utf8").catch(() => {});
+}
+
+async function appendLearnedFacts(notes: string[]) {
+  for (const note of notes.map((item) => String(item || "").trim()).filter(Boolean)) {
+    await appendMemory(`[learned] ${note}`);
+  }
+}
+
+async function showMacNotification(title: string, message: string) {
+  const safeTitle = String(title || "OpenCore").replace(/"/g, '\\"');
+  const safeMessage = String(message || "").replace(/"/g, '\\"');
+  try {
+    await execFileAsync("osascript", [
+      "-e",
+      `display notification "${safeMessage}" with title "${safeTitle}" subtitle "Computer control active"`,
+    ]);
+  } catch {
+    // Notification is best-effort only.
+  }
+}
+
+async function writeIndicatorState(state: {
+  running: boolean;
+  active: boolean;
+  message?: string;
+}) {
+  const payload = {
+    running: Boolean(state.running),
+    active: Boolean(state.active),
+    message: String(state.message || "").trim(),
+    updated_at: new Date().toISOString(),
+  };
+  await fs.writeFile(INDICATOR_STATE_PATH, `${JSON.stringify(payload, null, 2)}\n`, "utf8").catch(() => {});
+}
+
+function startIndicatorProcess() {
+  try {
+    const child = spawn("osascript", ["-l", "JavaScript", INDICATOR_SCRIPT_PATH], {
+      stdio: ["ignore", "ignore", "pipe"],
+      env: { ...process.env, OPENCORE_INDICATOR_STATE_PATH: INDICATOR_STATE_PATH },
+    });
+    child.stderr?.on("data", (chunk: Buffer | string) => {
+      const text = String(chunk || "").trim();
+      if (text) console.warn(`[indicator] ${text}`);
+    });
+    child.on("exit", (code: number | null, signal: NodeJS.Signals | null) => {
+      if (code !== null && code !== 0) {
+        console.warn(`[indicator] exited with code ${code}`);
+      } else if (signal) {
+        console.warn(`[indicator] exited with signal ${signal}`);
+      }
+    });
+    return child;
+  } catch {
+    return null;
+  }
+}
+
+function stopIndicatorProcess(indicator: any) {
+  if (!indicator) return;
+  try {
+    indicator.kill("SIGTERM");
+  } catch {}
+}
+
+async function readMemoryExcerpt(maxChars = 6000) {
+  const memory = await readTextFile(MEMORY_PATH, "");
+  if (!memory) return "";
+  if (memory.length <= maxChars) return memory;
+  return memory.slice(memory.length - maxChars);
+}
+
+function maskConfig(config: any) {
+  const safe = { ...(config || {}) };
+  if (safe.openai_api_key) safe.openai_api_key = "***masked***";
+  if (safe.telegram_bot_token) safe.telegram_bot_token = "***masked***";
+  if (safe.telegram_pairing_code) safe.telegram_pairing_code = "***masked***";
+  return safe;
+}
+
+function parseTelegramConfig(settings: any): TelegramConfig {
+  return {
+    enabled: Boolean(settings?.telegram_bot_token),
+    botToken: String(settings?.telegram_bot_token || "").trim(),
+    chatId: String(settings?.telegram_chat_id || "").trim(),
+    userId: String(settings?.telegram_user_id || "").trim(),
+    pairingCode: String(settings?.telegram_pairing_code || "").trim(),
+    paired: Boolean(settings?.telegram_paired && settings?.telegram_chat_id),
+    lastUpdateId: Number(settings?.telegram_last_update_id || 0) || 0,
+  };
+}
+
+async function writeSettingsPatch(patch: Record<string, any>) {
+  const current = await readSettings();
+  const next = { ...current, ...patch };
+  await fs.writeFile(SETTINGS_PATH, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return next;
+}
+
+function formatNetworkError(error: unknown) {
+  if (!error) return "Unknown network error";
+  if (error instanceof Error) {
+    const cause: any = (error as any).cause;
+    const parts = [error.message];
+    if (cause?.code) parts.push(`code=${cause.code}`);
+    if (cause?.errno && cause?.errno !== cause?.code) parts.push(`errno=${cause.errno}`);
+    if (cause?.syscall) parts.push(`syscall=${cause.syscall}`);
+    if (cause?.hostname) parts.push(`host=${cause.hostname}`);
+    if (cause?.address) parts.push(`address=${cause.address}`);
+    if (cause?.port) parts.push(`port=${cause.port}`);
+    return parts.filter(Boolean).join(" | ");
+  }
+  return String(error);
+}
+
+async function telegramApi(token: string, method: string, params: Record<string, any> = {}) {
+  const url = new URL(`https://api.telegram.org/bot${token}/${method}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined || value === null || value === "") continue;
+    url.searchParams.set(key, String(value));
+  }
+  const controller = new AbortController();
+  const timeoutMs = 12_000;
+  const timeout = setTimeout(() => controller.abort(new Error(`Telegram API ${method} timed out after ${timeoutMs}ms`)), timeoutMs);
+  let res: Response;
+  try {
+    res = await fetch(url, { signal: controller.signal });
+  } catch (error) {
+    throw new Error(`Telegram API ${method} request failed: ${formatNetworkError(error)}`);
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (!res.ok) {
+    throw new Error(`Telegram API ${method} failed with HTTP ${res.status}`);
+  }
+  const json = await res.json();
+  if (!json?.ok) {
+    throw new Error(String(json?.description || `Telegram API ${method} failed.`));
+  }
+  return json.result;
+}
+
+async function sendTelegramMessage(config: TelegramConfig, text: string) {
+  if (!config.enabled || !config.chatId) return;
+  const body = String(text || "").trim();
+  if (!body) return;
+  const chunks = body.match(/[\s\S]{1,3500}/g) || [];
+  for (const chunk of chunks) {
+    await telegramApi(config.botToken, "sendMessage", {
+      chat_id: config.chatId,
+      text: chunk,
+    });
+  }
+}
+
+function publicTelegramConfig(config: TelegramConfig) {
+  return {
+    enabled: config.enabled,
+    chat_id: config.chatId,
+    user_id: config.userId,
+    paired: config.paired,
+    has_bot_token: Boolean(config.botToken),
+    has_pairing_code: Boolean(config.pairingCode),
+    last_update_id: config.lastUpdateId,
+  };
+}
+
+async function loadPromptContext() {
+  const soulTemplate = await readTemplate("default-soul.md", DEFAULT_SOUL);
+  const guidelinesTemplate = await readTemplate("default-guidelines.md", DEFAULT_GUIDELINES);
+  const instructionsTemplate = await readTemplate("default-instructions.md", DEFAULT_INSTRUCTIONS);
+  const heartbeatTemplate = await readTemplate("default-heartbeat.md", DEFAULT_HEARTBEAT);
+  const soul = await readTextFile(SOUL_PATH, soulTemplate);
+  const heartbeat = await readTextFile(HEARTBEAT_PATH, heartbeatTemplate);
+  const guidelines = await readTextFile(GUIDELINES_PATH, guidelinesTemplate);
+  const instructions = await readTextFile(INSTRUCTIONS_PATH, instructionsTemplate);
+  const config = await readSettings();
+  const credentials = await readCredentialStore();
+  const memoryExcerpt = await readMemoryExcerpt(4000);
+  const installedSkills = await loadInstalledSkills(10000);
+  return {
+    soul,
+    heartbeat,
+    guidelines,
+    instructions,
+    installedSkills: installedSkills || "(no installed skills found)",
+    config: JSON.stringify(maskConfig(config), null, 2),
+    credentialsSummary: summarizeCredentialStoreForPrompt(credentials),
+    memoryExcerpt: memoryExcerpt || "(empty)",
+  };
+}
+
+async function buildComputerSystemPrompt() {
+  const ctx = await loadPromptContext();
+  return [
+    "You are controlling a macOS computer. Use only macOS UI conventions, macOS app names, macOS shortcuts, and macOS controls.",
+    "Do not reference or rely on Windows or Linux buttons, menus, dialogs, or keybindings.",
+    "You are the Computer Agent. Execute UI tasks delegated by the Manager Agent.",
+    "Follow OpenCore guidelines exactly:",
+    ctx.guidelines,
+    "Follow OpenCore user instructions exactly:",
+    ctx.instructions,
+    "Installed OpenCore skills (follow if relevant):",
+    ctx.installedSkills,
+    "OpenCore soul:",
+    ctx.soul,
+    "OpenCore heartbeat plan (must be followed for current task):",
+    ctx.heartbeat,
+    "OpenCore config snapshot (masked):",
+    ctx.config,
+    "Credential store summary (masked):",
+    ctx.credentialsSummary,
+    "OpenCore memory excerpt (recent):",
+    ctx.memoryExcerpt,
+  ].join("\n\n");
+}
+
+async function buildManagerSystemPrompt() {
+  const ctx = await loadPromptContext();
+  return [
+    "You are the OpenCore Manager Agent.",
+    "There are two systems: (1) Manager Agent (you), (2) Computer Agent.",
+    "Manager Agent handles everything except direct computer-use actions.",
+    "You receive user tasks first. Decide whether to answer directly, edit local markdown files, or delegate to Computer Agent.",
+    "You also maintain durable OpenCore state. When the user states a lasting rule, preference, permission, restriction, identity update, or computer fact, update the appropriate markdown files automatically.",
+    "Use guidelines.md for safety, permission, and capability restrictions. Use instructions.md for workflow preferences and operating style. Use soul.md for OpenCore identity/personality. Use memory.md for durable learned facts about the computer, apps, environment, and user preferences.",
+    "Delegate to Computer Agent when UI/computer control is needed.",
+    "Use route=local when the work can be performed locally with shell/file commands without UI control, such as file management, project inspection, text generation to files, and command-line maintenance.",
+    "Do direct answer when task is informational and no computer control is required.",
+    "Do edit_file when user asks to update any markdown/state/config file or when task requires writing files.",
+    "You may edit files and folders anywhere on the user's computer when needed, unless guidelines/instructions explicitly forbid it.",
+    "Return strict JSON only, no markdown, no explanations.",
+    'JSON schema: {"route":"direct|computer|edit_file|local","direct_answer":"...","computer_task":"...","file_target":"soul|memory|heartbeat|guidelines|instructions|/absolute/or/relative/path","edit_instructions":"...","local_task":"..."}',
+    "Follow OpenCore guidelines exactly:",
+    ctx.guidelines,
+    "Follow OpenCore user instructions exactly:",
+    ctx.instructions,
+    "Installed OpenCore skills (follow if relevant):",
+    ctx.installedSkills,
+    "OpenCore soul:",
+    ctx.soul,
+    "OpenCore config snapshot (masked):",
+    ctx.config,
+    "Credential store summary (masked):",
+    ctx.credentialsSummary,
+    "OpenCore memory excerpt (recent):",
+    ctx.memoryExcerpt,
+  ].join("\n\n");
+}
+
+function wantsCredentialSetup(userPrompt: string) {
+  const text = String(userPrompt || "").toLowerCase();
+  return (
+    text.includes("credential") ||
+    text.includes("password") ||
+    text.includes("default email") ||
+    text.includes("login for") ||
+    text.includes("log in for") ||
+    text.includes("sign up for") ||
+    text.includes("save account") ||
+    text.includes("save login")
+  );
+}
+
+function extractCredentialSetupValues(userPrompt: string) {
+  const text = String(userPrompt || "");
+  const websiteMatch =
+    text.match(/(?:website|site|domain|for)\s*[:=]\s*([A-Za-z0-9.-]+\.[A-Za-z]{2,})/i) ||
+    text.match(/\b([A-Za-z0-9.-]+\.[A-Za-z]{2,})\b/);
+  const emailMatch =
+    text.match(/(?:email|login\s+email)\s*[:=]\s*([^\s,;]+@[^\s,;]+)/i) ||
+    text.match(/\b([^\s,;]+@[^\s,;]+\.[A-Za-z]{2,})\b/);
+  const passwordMatch =
+    text.match(/(?:password|pass)\s*[:=]\s*(.+)$/im);
+  const providerMatch =
+    text.match(/(?:email\s+provider|provider)\s*[:=]\s*([A-Za-z0-9._-]+)/i);
+  const autoActivationEnabled =
+    /\b(enable|turn on|activate)\b[\s\S]{0,40}\b(auto(?:matic)?\s+account\s+email\s+activation|email\s+activation)\b/i.test(text)
+      ? true
+      : /\b(disable|turn off)\b[\s\S]{0,40}\b(auto(?:matic)?\s+account\s+email\s+activation|email\s+activation)\b/i.test(text)
+        ? false
+        : undefined;
+  const defaultEmailRequested = /default\s+email/i.test(text);
+  return {
+    website: String(websiteMatch?.[1] || "").trim(),
+    email: String(emailMatch?.[1] || "").trim(),
+    password: String(passwordMatch?.[1] || "").trim(),
+    emailProvider: String(providerMatch?.[1] || "").trim(),
+    defaultEmailRequested,
+    autoActivationEnabled,
+  };
+}
+
+async function handleCredentialSetupRequest(userPrompt: string) {
+  if (!wantsCredentialSetup(userPrompt)) return null;
+  const extracted = extractCredentialSetupValues(userPrompt);
+  const lower = String(userPrompt || "").toLowerCase();
+  const store = await readCredentialStore();
+
+  const wantsDefaultsOnly =
+    extracted.defaultEmailRequested && !extracted.website && !/\b(save|store|add)\b[\s\S]{0,24}\bpassword\b/i.test(lower);
+
+  if (wantsDefaultsOnly || extracted.autoActivationEnabled !== undefined) {
+    const next = await updateCredentialDefaults({
+      default_email: extracted.email || store.default_email,
+      default_email_provider: extracted.emailProvider || store.default_email_provider,
+      auto_email_activation_enabled:
+        extracted.autoActivationEnabled === undefined
+          ? store.auto_email_activation_enabled
+          : extracted.autoActivationEnabled,
+    });
+    const warning =
+      extracted.autoActivationEnabled === true
+        ? "\nWarning: automatic account email activation lets OpenCore open your inbox and follow verification links or codes automatically. Only leave this enabled if you trust the current setup."
+        : "";
+    return {
+      handled: true,
+      answer:
+        `Credential defaults updated.\n` +
+        `Default email: ${next.default_email || "not set"}\n` +
+        `Default email provider: ${next.default_email_provider || "not set"}\n` +
+        `Automatic account email activation: ${next.auto_email_activation_enabled ? "enabled" : "disabled"}${warning}`,
+    };
+  }
+
+  if (!extracted.website) return null;
+  if (!extracted.email && !extracted.password) {
+    return {
+      handled: true,
+      answer:
+        `To save credentials for ${extracted.website}, send at least an email or password.\n` +
+        `Optional fields: email provider, notes, or default email settings.`,
+    };
+  }
+  const next = await upsertCredentialEntry({
+    website: extracted.website,
+    email: extracted.email,
+    password: extracted.password,
+    email_provider: extracted.emailProvider,
+    generated_by_ai: false,
+  });
+  const saved = next.entries.find((entry: any) => entry.website === extracted.website);
+  return {
+    handled: true,
+    answer:
+      `Saved local credentials for ${saved?.website || extracted.website}.\n` +
+      `Email: ${saved?.email ? "saved" : "not set"}\n` +
+      `Password: ${saved?.password ? "saved" : "not set"}\n` +
+      `Email provider: ${saved?.email_provider || "not set"}\n` +
+      `These credentials will be available for future login or sign-up tasks.`,
+  };
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function rgb(r: number, g: number, b: number) {
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+function colorizeBanner(text: string) {
+  const reset = "\x1b[0m";
+  const palette: Array<[number, number, number]> = [
+    [255, 176, 64],
+    [255, 154, 32],
+    [243, 128, 16],
+    [224, 105, 8],
+    [203, 86, 4],
+    [187, 72, 0],
+  ];
+  return text
+    .split("\n")
+    .map((line, i) => `${rgb(...palette[i % palette.length])}${line}${reset}`)
+    .join("\n");
+}
+
+function renderOpenCoreBanner() {
+  const text = figlet.textSync("OPENCORE", {
+    font: "ANSI Shadow",
+    horizontalLayout: "default",
+    verticalLayout: "default",
+  });
+  return colorizeBanner(text);
+}
+
+function extractToolUses(response: any) {
+  return (response.content || []).filter((block: any) => block.type === "tool_use" && block.name === "computer");
+}
+
+function extractAssistantText(response: any) {
+  const textParts = (response.content || [])
+    .filter((block: any) => block.type === "text" && block.text)
+    .map((block: any) => block.text);
+  return textParts.join("\n").trim();
+}
+
+function extractOpenAiText(response: any) {
+  const direct = String(response?.output_text || "").trim();
+  if (direct) return direct;
+  const textParts: string[] = [];
+  for (const item of response?.output || []) {
+    if (item?.type === "message") {
+      for (const block of item?.content || []) {
+        const text = String(block?.text || block?.content || "").trim();
+        if (text) textParts.push(text);
+      }
+    }
+  }
+  return textParts.join("\n").trim();
+}
+
+function extractOpenAiComputerCalls(response: any) {
+  return (response?.output || []).filter((item: any) => item?.type === "computer_call");
+}
+
+function getOpenAiCallActions(call: any) {
+  if (Array.isArray(call?.actions)) return call.actions;
+  if (call?.action) return [call.action];
+  return [];
+}
+
+function decodedBase64Bytes(data: string) {
+  return Buffer.from(String(data || ""), "base64").byteLength;
+}
+
+async function enforceApiImageLimit(base64: string, mediaType = "image/png") {
+  const raw = String(base64 || "").trim();
+  let normalizedMediaType = mediaType;
+  let payload = raw;
+  const dataUrl = /^data:([^;,]+);base64,(.+)$/i.exec(raw);
+  if (dataUrl) {
+    normalizedMediaType = dataUrl[1] || mediaType;
+    payload = dataUrl[2] || "";
+  }
+
+  let data = Buffer.from(payload, "base64");
+  // Always canonicalize base64 to avoid forwarding data URL prefixes or noisy encodings.
+  if (data.byteLength <= API_IMAGE_MAX_BYTES) {
+    return { data: data.toString("base64"), mediaType: normalizedMediaType };
+  }
+
+  const inExt = normalizedMediaType === "image/jpeg" ? "jpg" : "png";
+  const inFile = path.join(
+    os.tmpdir(),
+    `opencore-limit-in-${Date.now()}-${Math.random().toString(36).slice(2)}.${inExt}`,
+  );
+  const attempts: Array<{ dim: number; quality: number }> = [];
+  for (const dim of [1600, 1400, 1200, 1024, 900, 768, 640]) {
+    for (const quality of [80, 70, 60, 50, 40]) attempts.push({ dim, quality });
+  }
+
+  const tempFiles: string[] = [];
+  try {
+    await fs.writeFile(inFile, data);
+    for (const attempt of attempts) {
+      const outFile = path.join(
+        os.tmpdir(),
+        `opencore-limit-out-${Date.now()}-${attempt.dim}-${attempt.quality}-${Math.random().toString(36).slice(2)}.jpg`,
+      );
+      tempFiles.push(outFile);
+      try {
+        await execFileAsync("sips", [
+          inFile,
+          "--resampleHeightWidthMax",
+          String(attempt.dim),
+          "--setProperty",
+          "format",
+          "jpeg",
+          "--setProperty",
+          "formatOptions",
+          String(attempt.quality),
+          "--out",
+          outFile,
+        ]);
+        const candidate = await fs.readFile(outFile);
+        if (candidate.byteLength <= API_IMAGE_TARGET_BYTES) {
+          return { data: candidate.toString("base64"), mediaType: "image/jpeg" };
+        }
+      } catch {
+        // try next compression attempt
+      }
+    }
+  } finally {
+    fs.unlink(inFile).catch(() => {});
+    for (const file of tempFiles) fs.unlink(file).catch(() => {});
+  }
+
+  data = Buffer.from(payload, "base64");
+  throw new Error(
+    `Screenshot payload too large for computer-use API (${data.byteLength} bytes > ${API_IMAGE_MAX_BYTES} bytes) after compression attempts.`,
+  );
+}
+
+function isOpenAiComputerModelError(error: any) {
+  const message = String(error?.message || "");
+  return (
+    Number(error?.status) === 400 ||
+    Number(error?.status) === 404 ||
+    /model|tool|computer|not found|does not exist|not supported|unsupported|access/i.test(message)
+  );
+}
+
+async function createOpenAiResponseWithModelFallback({
+  client,
+  buildPayload,
+}: {
+  client: any;
+  buildPayload: (model: string) => any;
+}) {
+  const tried: string[] = [];
+  let lastError: unknown = null;
+
+  for (const model of OPENAI_COMPUTER_MODEL_CANDIDATES) {
+    tried.push(model);
+    try {
+      const response = await client.responses.create(buildPayload(model));
+      return { response, model };
+    } catch (error) {
+      if (!isOpenAiComputerModelError(error)) throw error;
+      lastError = error;
+    }
+  }
+
+  const wrapped = new Error(
+    `No accessible OpenAI computer-use model was found. Tried: ${tried.join(", ")}.`,
+  );
+  (wrapped as any).cause = lastError;
+  throw wrapped;
+}
+
+async function runTextModel({
+  runtime,
+  systemPrompt,
+  userText,
+  maxTokens = 1200,
+}: {
+  runtime: ProviderRuntime;
+  systemPrompt: string;
+  userText: string;
+  maxTokens?: number;
+}) {
+  const response = await runtime.openai.responses.create({
+    model: OPENAI_MODEL,
+    input: [
+      { role: "system", content: [{ type: "input_text", text: systemPrompt }] },
+      { role: "user", content: [{ type: "input_text", text: userText }] },
+    ],
+    truncation: "auto",
+  });
+  return extractOpenAiText(response);
+}
+
+function extractJsonObject(text: string) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start < 0 || end < 0 || end <= start) return null;
+  const maybe = text.slice(start, end + 1);
+  try {
+    return JSON.parse(maybe);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeFileTarget(value: string | undefined) {
+  const target = String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(".md", "");
+  return target in EDITABLE_FILES ? target : null;
+}
+
+function resolveEditablePath(fileTarget: string | undefined) {
+  const mapped = normalizeFileTarget(fileTarget || "");
+  if (mapped) return { key: mapped, path: EDITABLE_FILES[mapped] };
+  const raw = String(fileTarget || "").trim();
+  if (!raw) return null;
+  const resolved = path.isAbsolute(raw) ? path.normalize(raw) : path.resolve(os.homedir(), raw);
+  return { key: "custom", path: resolved };
+}
+
+async function managerDecide({
+  runtime,
+  userPrompt,
+}: {
+  runtime: ProviderRuntime;
+  userPrompt: string;
+}): Promise<ManagerDecision> {
+  const systemPrompt = await buildManagerSystemPrompt();
+  const text = await runTextModel({
+    runtime,
+    systemPrompt,
+    userText: `User task:\n${userPrompt}\n\nReturn JSON only.`,
+    maxTokens: 900,
+  });
+  const parsed = extractJsonObject(text);
+  if (!parsed || !parsed.route) {
+    return { route: "computer", computer_task: userPrompt };
+  }
+  const route = String(parsed.route) as ManagerRoute;
+  if (!["direct", "computer", "edit_file", "local"].includes(route)) {
+    return { route: "computer", computer_task: userPrompt };
+  }
+  return {
+    route,
+    direct_answer: String(parsed.direct_answer || ""),
+    computer_task: String(parsed.computer_task || ""),
+    file_target: String(parsed.file_target || ""),
+    edit_instructions: String(parsed.edit_instructions || ""),
+    local_task: String(parsed.local_task || ""),
+  };
+}
+
+async function managerDetectScheduleRequest({
+  runtime,
+  userPrompt,
+}: {
+  runtime: ProviderRuntime;
+  userPrompt: string;
+}): Promise<ScheduledTaskPlan> {
+  const systemPrompt = await buildManagerSystemPrompt();
+  const text = await runTextModel({
+    runtime,
+    systemPrompt,
+    userText:
+      `User message:\n${userPrompt}\n\n` +
+      'Return JSON only using schema: {"should_schedule":boolean,"cron_expression":"* * * * *","task":"...","summary":"...","schedule_kind":"one_time|recurring"}\n' +
+      "Interpret whether the user is asking OpenCore to do a task in the future or on a recurring schedule.\n" +
+      "Rules:\n" +
+      "- should_schedule=true only when the user explicitly asks for a future-time or recurring task.\n" +
+      "- task must be the action OpenCore should perform when the schedule fires, without time wording.\n" +
+      "- cron_expression must be a valid 5-field cron expression in the local timezone.\n" +
+      "- schedule_kind=one_time for a single future run; recurring for repeating schedules.\n" +
+      "- expected_time_iso should be provided for one_time schedules when the exact future timestamp can be inferred.\n" +
+      "- summary must be a concise human summary of the schedule.\n" +
+      "- If the request is not a scheduling request, return should_schedule=false.",
+    maxTokens: 700,
+  });
+  const parsed = extractJsonObject(text);
+  if (!parsed || !parsed.should_schedule) return { should_schedule: false };
+  return {
+    should_schedule: Boolean(parsed.should_schedule),
+    cron_expression: String(parsed.cron_expression || "").trim(),
+    task: String(parsed.task || "").trim(),
+    summary: String(parsed.summary || "").trim(),
+    schedule_kind: String(parsed.schedule_kind || "one_time").trim().toLowerCase() === "recurring" ? "recurring" : "one_time",
+    expected_time_iso: String(parsed.expected_time_iso || "").trim(),
+  };
+}
+
+async function managerRewriteFile({
+  runtime,
+  target,
+  userPrompt,
+  editInstructions,
+}: {
+  runtime: ProviderRuntime;
+  target: string;
+  userPrompt: string;
+  editInstructions: string;
+}) {
+  const resolved = resolveEditablePath(target);
+  if (!resolved) return null;
+  const filePath = resolved.path;
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const current = await readTextFile(filePath, "");
+  const systemPrompt = await buildManagerSystemPrompt();
+  const text = await runTextModel({
+    runtime,
+    systemPrompt,
+    userText:
+      `You are editing file target: ${target}\n` +
+      `Resolved file path: ${filePath}\n` +
+      `User request: ${userPrompt}\n` +
+      `Manager instructions: ${editInstructions || "(none)"}\n` +
+      `Current content:\n${current}\n\n` +
+      "Return only the full updated file content. No markdown fences.",
+    maxTokens: 2600,
+  });
+  return text || current;
+}
+
+async function managerBuildLocalCommand({
+  runtime,
+  userPrompt,
+  localTask,
+}: {
+  runtime: ProviderRuntime;
+  userPrompt: string;
+  localTask: string;
+}) {
+  const systemPrompt = await buildManagerSystemPrompt();
+  const text = await runTextModel({
+    runtime,
+    systemPrompt,
+    userText:
+      `User request:\n${userPrompt}\n\n` +
+      `Local task summary:\n${localTask}\n\n` +
+      'Return JSON only using schema: {"command":"...","cwd":"...","summary":"..."}\n' +
+      "Write one macOS-compatible shell command to complete the task locally without UI control.\n" +
+      "Rules:\n" +
+      "- Use zsh-compatible syntax.\n" +
+      "- Prefer safe file and project commands.\n" +
+      "- Use absolute cwd when useful, or omit it.\n" +
+      "- Do not include explanations or markdown.",
+    maxTokens: 700,
+  });
+  const parsed = extractJsonObject(text);
+  if (!parsed || !parsed.command) return null;
+  return {
+    command: String(parsed.command || "").trim(),
+    cwd: String(parsed.cwd || "").trim(),
+    summary: String(parsed.summary || "").trim(),
+  };
+}
+
+function wantsTelegramSetup(userPrompt: string) {
+  const text = String(userPrompt || "").toLowerCase();
+  return text.includes("telegram") && (
+    text.includes("set up") ||
+    text.includes("setup") ||
+    text.includes("connect") ||
+    text.includes("configure") ||
+    text.includes("reconnect")
+  );
+}
+
+function extractTelegramSetupValues(userPrompt: string) {
+  const text = String(userPrompt || "");
+  const botTokenMatch =
+    text.match(/(?:telegram\s+bot\s+token|bot\s+token|token)\s*[:=]\s*([0-9]{6,}:[A-Za-z0-9_-]{20,})/i) ||
+    text.match(/\b([0-9]{6,}:[A-Za-z0-9_-]{20,})\b/);
+  const userIdMatch =
+    text.match(/(?:telegram\s+user\s+id|user\s+id)\s*[:=]\s*([0-9]{5,})/i) ||
+    text.match(/(?:telegram\s+user\s+id\s+is|user\s+id\s+is)\s+([0-9]{5,})/i);
+  const pairingCodeMatch =
+    text.match(/(?:pairing\s+code|pair\s+code|code)\s*[:=]\s*([A-Za-z0-9_-]{3,})/i) ||
+    text.match(/pairing\s+code\s+is\s+([A-Za-z0-9_-]{3,})/i);
+  return {
+    botToken: String(botTokenMatch?.[1] || "").trim(),
+    userId: String(userIdMatch?.[1] || "").trim(),
+    pairingCode: String(pairingCodeMatch?.[1] || "").trim(),
+  };
+}
+
+function generateTelegramPairingCode() {
+  return Math.random().toString(36).slice(2, 8).toUpperCase();
+}
+
+async function handleTelegramSetupRequest(userPrompt: string) {
+  if (!wantsTelegramSetup(userPrompt)) return null;
+  const current = await readSettings();
+  const currentTelegram = parseTelegramConfig(current);
+  const extracted = extractTelegramSetupValues(userPrompt);
+  const botToken = extracted.botToken || currentTelegram.botToken;
+  const userId = extracted.userId || currentTelegram.userId;
+  const pairingCode = extracted.pairingCode || currentTelegram.pairingCode;
+  const missing: string[] = [];
+  if (!botToken) missing.push("Telegram bot token");
+
+  if (missing.length) {
+    return {
+      handled: true,
+      answer:
+        `To finish Telegram setup, send the missing value${missing.length > 1 ? "s" : ""}: ` +
+        `${missing.join(", ")}.` +
+        ` After that, OpenCore will save the bot token and tell you to run /start in Telegram.`,
+      updatedConfig: null as TelegramConfig | null,
+    };
+  }
+
+  await writeSettingsPatch({
+    telegram_enabled: true,
+    telegram_bot_token: botToken,
+    telegram_chat_id: currentTelegram.chatId || "",
+    telegram_user_id: userId,
+    telegram_pairing_code: pairingCode,
+    telegram_paired: Boolean(currentTelegram.chatId && userId && pairingCode),
+    telegram_last_update_id: 0,
+  });
+  const next = parseTelegramConfig(await readSettings());
+  if (!pairingCode) {
+    return {
+      handled: true,
+      answer:
+        "Telegram bot token saved in OpenCore config.\n" +
+        "Next step: start OpenCore, send `/start` to the bot in Telegram, then give the Telegram user ID and pairing code the bot shows you back to OpenCore.",
+      updatedConfig: next,
+    };
+  }
+  if (!userId) {
+    return {
+      handled: true,
+      answer:
+        "Telegram pairing code saved, but the Telegram user ID is still missing.\n" +
+        "Run `/start` in Telegram, then give both the shown user ID and pairing code back to OpenCore.",
+      updatedConfig: next,
+    };
+  }
+  return {
+    handled: true,
+    answer:
+      next.paired
+        ? "Telegram pairing code saved. Telegram is now connected and incoming bot messages will be handled like direct CLI tasks while OpenCore is running."
+        : "Telegram user ID and pairing code saved, but OpenCore has not seen a `/start` chat yet. Start OpenCore, send `/start` to the bot, then save the same values again if needed.",
+    updatedConfig: next,
+  };
+}
+
+async function runLocalCommandTask({
+  runtime,
+  userPrompt,
+  localTask,
+}: {
+  runtime: ProviderRuntime;
+  userPrompt: string;
+  localTask: string;
+}) {
+  const built = await managerBuildLocalCommand({ runtime, userPrompt, localTask });
+  if (!built || !built.command) {
+    return "I could not build a valid local shell command for that task.";
+  }
+  const cwd = built.cwd
+    ? path.isAbsolute(built.cwd)
+      ? built.cwd
+      : path.resolve(os.homedir(), built.cwd)
+    : os.homedir();
+  await appendMemory(`[manager] local_command=${built.command} cwd=${cwd}`);
+  const { stdout, stderr } = await execFileAsync("/bin/zsh", ["-lc", built.command], {
+    cwd,
+    maxBuffer: 1024 * 1024 * 8,
+  } as any);
+  const output = [String(stdout || "").trim(), String(stderr || "").trim()].filter(Boolean).join("\n");
+  const summary = built.summary || "Local command completed.";
+  return output ? `${summary}\n\n${output}`.trim() : summary;
+}
+
+function isValidCronExpression(value: string) {
+  return /^(\S+\s+){4}\S+$/.test(String(value || "").trim());
+}
+
+async function createScheduledTask({
+  runtime,
+  userPrompt,
+  plan,
+}: {
+  runtime: ProviderRuntime;
+  userPrompt: string;
+  plan: ScheduledTaskPlan;
+}) {
+  if (!plan.task || !plan.cron_expression || !isValidCronExpression(plan.cron_expression)) {
+    throw new Error("OpenCore could not derive a valid cron expression and task from the scheduling request.");
+  }
+  const id = `sched_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  const now = new Date().toISOString();
+  const record: ScheduledTaskRecord = {
+    id,
+    task: plan.task,
+    cron_expression: plan.cron_expression,
+    summary: plan.summary || `Scheduled task: ${plan.task}`,
+    schedule_kind: plan.schedule_kind || "one_time",
+    created_at: now,
+    updated_at: now,
+    expected_time_iso: plan.expected_time_iso || "",
+    last_status: "scheduled",
+    active: true,
+    source_prompt: userPrompt,
+  };
+  const items = await readSchedules();
+  items.push(record);
+  await writeSchedules(items);
+  await upsertCronSchedule(record);
+  await syncHeartbeatScheduleRecord(record);
+  await appendMemory(
+    `[manager] scheduled_task id=${record.id} kind=${record.schedule_kind} cron=${record.cron_expression} task=${record.task}`,
+  );
+  return record;
+}
+
+async function recoverScheduledTasksIfNeeded({
+  runtime,
+  controller,
+  dashboard,
+  reason,
+}: {
+  runtime: ProviderRuntime;
+  controller: any;
+  dashboard?: DashboardServer | null;
+  reason: "startup" | "manual";
+}) {
+  const schedules = await readSchedules();
+  const nowMs = Date.now();
+  const candidates = schedules.filter((item) => {
+    const expectedMs = item.expected_time_iso ? Date.parse(item.expected_time_iso) : NaN;
+    const isPastDueOneTime =
+      item.schedule_kind === "one_time" &&
+      item.active &&
+      Number.isFinite(expectedMs) &&
+      expectedMs <= nowMs &&
+      !item.last_run_at;
+    const hadError = item.last_status === "error";
+    const stuckRunning =
+      item.last_status === "running" &&
+      item.last_run_at &&
+      nowMs - Date.parse(item.last_run_at) > 15 * 60 * 1000;
+    const missed = item.last_status === "missed";
+    return isPastDueOneTime || hadError || stuckRunning || missed;
+  });
+
+  const results: string[] = [];
+  for (const item of candidates) {
+    if (item.schedule_kind === "one_time" && item.active) {
+      await removeCronSchedule(item.id).catch(() => {});
+      await setScheduleRecordState(item.id, { active: false, last_status: "missed" });
+    } else if (item.last_status === "running") {
+      await setScheduleRecordState(item.id, { last_status: "missed" });
+    }
+    try {
+      await setScheduleRecordState(item.id, {
+        last_status: "running",
+        last_run_at: new Date().toISOString(),
+        last_error: "",
+      });
+      const answer = await runManagedTask({
+        runtime,
+        controller,
+        userPrompt: item.task,
+        source: "schedule",
+        dashboard: dashboard || null,
+        publishToConsole: reason === "startup",
+        indicatorMessage: "OpenCore is recovering a scheduled task",
+      });
+      if (item.schedule_kind === "one_time") {
+        await setScheduleRecordState(item.id, { active: false, last_status: "done", last_error: "" });
+      } else {
+        await setScheduleRecordState(item.id, { last_status: "done", last_error: "" });
+      }
+      results.push(`${item.id}: recovered successfully`);
+      await appendMemory(`[schedule_recovered id=${item.id}] ${answer.slice(0, 200)}`);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      await setScheduleRecordState(item.id, { last_status: "error", last_error: msg });
+      results.push(`${item.id}: recovery failed (${msg})`);
+      await appendMemory(`[schedule_recovery_error id=${item.id}] ${msg}`);
+    }
+  }
+  return results;
+}
+
+async function managerInferPersistentUpdates({
+  runtime,
+  userPrompt,
+}: {
+  runtime: ProviderRuntime;
+  userPrompt: string;
+}): Promise<ManagerPersistentUpdatePlan> {
+  const systemPrompt = await buildManagerSystemPrompt();
+  const text = await runTextModel({
+    runtime,
+    systemPrompt,
+    userText:
+      `User message:\n${userPrompt}\n\n` +
+      "Determine whether this message contains durable instructions, restrictions, preferences, identity updates, or computer facts that should be persisted for future tasks.\n" +
+      'Return JSON only using schema: {"memory_notes":["..."],"file_updates":[{"target":"guidelines|instructions|soul|memory","instructions":"..."}]}\n' +
+      "Rules:\n" +
+      "- Only include file_updates for durable information that should persist beyond the current task.\n" +
+      "- If the user says something cannot be done on this computer or should never be done, update guidelines.\n" +
+      "- If the user gives preferred behavior or workflow style, update instructions.\n" +
+      "- If the user changes OpenCore identity/personality, update soul.\n" +
+      "- Store important learned facts about the computer or apps in memory_notes.\n" +
+      "- If nothing durable should be saved, return empty arrays.",
+    maxTokens: 900,
+  });
+  const parsed = extractJsonObject(text);
+  if (!parsed || typeof parsed !== "object") return { memory_notes: [], file_updates: [] };
+  return {
+    memory_notes: Array.isArray((parsed as any).memory_notes) ? (parsed as any).memory_notes : [],
+    file_updates: Array.isArray((parsed as any).file_updates) ? (parsed as any).file_updates : [],
+  };
+}
+
+async function applyPersistentUpdatePlan({
+  runtime,
+  userPrompt,
+  plan,
+  dashboard,
+}: {
+  runtime: ProviderRuntime;
+  userPrompt: string;
+  plan: ManagerPersistentUpdatePlan;
+  dashboard: DashboardServer;
+}) {
+  const appliedFiles = new Set<string>();
+  const fileUpdates = Array.isArray(plan.file_updates) ? plan.file_updates : [];
+  for (const item of fileUpdates) {
+    const target = String(item?.target || "").trim();
+    const instructions = String(item?.instructions || "").trim();
+    if (!target || !instructions) continue;
+    const resolved = resolveEditablePath(target);
+    if (!resolved) continue;
+    const updated = await managerRewriteFile({
+      runtime,
+      target,
+      userPrompt,
+      editInstructions: instructions,
+    });
+    if (updated === null) continue;
+    await fs.writeFile(resolved.path, updated, "utf8");
+    appliedFiles.add(resolved.path);
+    await appendMemory(`[manager] auto_updated_file=${resolved.path}`);
+    dashboard.publishEvent({ type: "file_updated", target: resolved.path });
+  }
+  const notes = Array.isArray(plan.memory_notes) ? plan.memory_notes : [];
+  await appendLearnedFacts(notes);
+}
+
+async function managerExtractLearnedFacts({
+  runtime,
+  userPrompt,
+  answer,
+}: {
+  runtime: ProviderRuntime;
+  userPrompt: string;
+  answer: string;
+}) {
+  const systemPrompt = await buildManagerSystemPrompt();
+  const text = await runTextModel({
+    runtime,
+    systemPrompt,
+    userText:
+      `User task:\n${userPrompt}\n\n` +
+      `Task result:\n${answer}\n\n` +
+      'Return JSON only using schema: {"memory_notes":["..."]}\n' +
+      "Extract only durable facts worth remembering for future tasks.\n" +
+      "Prefer facts about the computer, installed apps, blocked permissions, UI quirks, recurring user preferences, and environment behavior.\n" +
+      "Do not repeat transient step logs. If nothing durable was learned, return an empty array.",
+    maxTokens: 500,
+  });
+  const parsed = extractJsonObject(text);
+  return Array.isArray((parsed as any)?.memory_notes) ? (parsed as any).memory_notes : [];
+}
+
+async function managerWriteHeartbeat({
+  runtime,
+  userPrompt,
+  decision,
+}: {
+  runtime: ProviderRuntime;
+  userPrompt: string;
+  decision: ManagerDecision;
+}) {
+  const context = await loadPromptContext();
+  const existingHeartbeat = await readTextFile(HEARTBEAT_PATH, DEFAULT_HEARTBEAT);
+  const scheduleBlock = extractHeartbeatScheduleBlock(existingHeartbeat);
+  const content =
+    (await runTextModel({
+      runtime,
+      systemPrompt:
+        "You are the OpenCore Manager Agent. Rewrite heartbeat.md for every new task. " +
+        "Produce concise markdown with high-level actionable steps for the Computer Agent to follow.",
+      userText:
+        `User task: ${userPrompt}\n` +
+        `Manager route: ${decision.route}\n` +
+        `Delegated computer task: ${decision.computer_task || "(none)"}\n` +
+        `Current guidelines:\n${context.guidelines}\n\n` +
+        "Return markdown only with sections:\n" +
+        "# OpenCore Heartbeat\n" +
+        "## Current Task\n" +
+        "## Big Steps\n" +
+        "## Success Criteria\n" +
+        "## Final Summary Instruction\n" +
+        "Use numbered big steps and include app/site navigation instructions when relevant.",
+      maxTokens: 900,
+    })) || DEFAULT_HEARTBEAT;
+  await fs.writeFile(HEARTBEAT_PATH, mergeHeartbeatWithSchedules(`${content.trim()}\n`, scheduleBlock), "utf8");
+  await appendMemory("[manager] heartbeat_rewritten");
+  return content;
+}
+
+async function clearCompletedHeartbeat() {
+  const heartbeatTemplate = await readTemplate("default-heartbeat.md", DEFAULT_HEARTBEAT);
+  const existing = await readTextFile(HEARTBEAT_PATH, heartbeatTemplate);
+  await fs.writeFile(HEARTBEAT_PATH, mergeHeartbeatWithSchedules(heartbeatTemplate, extractHeartbeatScheduleBlock(existing)), "utf8");
+  await appendMemory("[manager] heartbeat_cleared");
+}
+
+function extractHeartbeatScheduleBlock(content: string) {
+  const text = String(content || "");
+  const start = text.indexOf(HEARTBEAT_SCHEDULE_START);
+  const end = text.indexOf(HEARTBEAT_SCHEDULE_END);
+  if (start < 0 || end < 0 || end <= start) {
+    return `${HEARTBEAT_SCHEDULE_START}\n${HEARTBEAT_SCHEDULE_END}`;
+  }
+  return text.slice(start, end + HEARTBEAT_SCHEDULE_END.length);
+}
+
+function mergeHeartbeatWithSchedules(base: string, scheduleBlock: string) {
+  const normalized = String(base || "").trimEnd();
+  const block = scheduleBlock && scheduleBlock.includes(HEARTBEAT_SCHEDULE_START)
+    ? scheduleBlock
+    : `${HEARTBEAT_SCHEDULE_START}\n${HEARTBEAT_SCHEDULE_END}`;
+  return `${normalized}\n\n## Scheduled Tasks\n${block}\n`;
+}
+
+async function ensureHeartbeatScheduleBlock() {
+  const current = await readTextFile(HEARTBEAT_PATH, DEFAULT_HEARTBEAT);
+  if (current.includes(HEARTBEAT_SCHEDULE_START) && current.includes(HEARTBEAT_SCHEDULE_END)) return;
+  await fs.writeFile(
+    HEARTBEAT_PATH,
+    mergeHeartbeatWithSchedules(current || DEFAULT_HEARTBEAT, `${HEARTBEAT_SCHEDULE_START}\n${HEARTBEAT_SCHEDULE_END}`),
+    "utf8",
+  );
+}
+
+function heartbeatScheduleLine(record: ScheduledTaskRecord) {
+  return `- [${record.last_status || "scheduled"}] ${record.id} | ${record.schedule_kind} | cron=${record.cron_expression} | summary=${record.summary} | task=${record.task.replace(/\s+/g, " ").trim()} | expected=${record.expected_time_iso || "n/a"} | last_run=${record.last_run_at || "n/a"} | updated=${record.updated_at}${record.last_error ? ` | error=${record.last_error.replace(/\s+/g, " ").trim()}` : ""}`;
+}
+
+async function syncHeartbeatScheduleRecord(record: ScheduledTaskRecord) {
+  await ensureHeartbeatScheduleBlock();
+  const current = await readTextFile(HEARTBEAT_PATH, DEFAULT_HEARTBEAT);
+  const block = extractHeartbeatScheduleBlock(current);
+  const inner = block
+    .replace(HEARTBEAT_SCHEDULE_START, "")
+    .replace(HEARTBEAT_SCHEDULE_END, "")
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .filter((line) => line.trim() && !line.includes(`${record.id} |`));
+  inner.push(heartbeatScheduleLine(record));
+  const nextBlock = `${HEARTBEAT_SCHEDULE_START}\n${inner.join("\n")}\n${HEARTBEAT_SCHEDULE_END}`;
+  const next = mergeHeartbeatWithSchedules(current, nextBlock);
+  await fs.writeFile(HEARTBEAT_PATH, next, "utf8");
+}
+
+function wantsHeartbeatAudit(prompt: string) {
+  const text = String(prompt || "").trim().toLowerCase();
+  return (
+    text.includes("heartbeat") ||
+    /check .*done/.test(text) ||
+    /was .*done/.test(text) ||
+    /check if everything was done/.test(text) ||
+    /scheduled task/.test(text)
+  );
+}
+
+function hasActionableHeartbeat(heartbeat: string) {
+  const text = String(heartbeat || "").trim();
+  if (!text) return false;
+  if (/^#\s*opencore heartbeat/i.test(text) && /no active task/i.test(text)) return false;
+  return true;
+}
+
+async function managerEvaluateHeartbeatTick({
+  runtime,
+  heartbeat,
+  heartbeatChanged,
+}: {
+  runtime: ProviderRuntime;
+  heartbeat: string;
+  heartbeatChanged: boolean;
+}): Promise<HeartbeatTickDecision> {
+  if (!hasActionableHeartbeat(heartbeat)) {
+    return { run_now: false, reason: "Heartbeat has no active task." };
+  }
+
+  const now = new Date();
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "local";
+  const text = await runTextModel({
+    runtime,
+    systemPrompt:
+      "You are the OpenCore Manager Agent running periodic heartbeat checks. " +
+      "Decide if OpenCore should immediately start an autonomous task right now. " +
+      "Return JSON only.",
+    userText:
+      `Current time (ISO): ${now.toISOString()}\n` +
+      `Current timezone: ${timezone}\n` +
+      `Heartbeat file changed since last minute check: ${heartbeatChanged ? "yes" : "no"}\n\n` +
+      `Heartbeat content:\n${heartbeat}\n\n` +
+      'Return JSON schema: {"run_now":boolean,"task":"string","reason":"string"}\n' +
+      "Rules:\n" +
+      "- run_now=true only when action is due right now, currently scheduled for now, or heartbeat was updated with a new actionable task.\n" +
+      "- If run_now=true, task must be a short executable task prompt for the Computer Agent.\n" +
+      "- If not due now, set run_now=false.",
+    maxTokens: 500,
+  });
+
+  const parsed = extractJsonObject(text);
+  if (!parsed || typeof parsed.run_now !== "boolean") {
+    return { run_now: false, reason: "Invalid manager heartbeat decision payload." };
+  }
+  return {
+    run_now: Boolean(parsed.run_now),
+    task: String(parsed.task || "").trim(),
+    reason: String(parsed.reason || "").trim(),
+  };
+}
+
+async function executeOpenAiAction(controller: any, action: any) {
+  const type = String(action?.type || "").toLowerCase();
+  switch (type) {
+    case "screenshot":
+      return;
+    case "click":
+      return controller.executeAction({
+        type: "click",
+        x: action.x,
+        y: action.y,
+        button: action.button || "left",
+      });
+    case "double_click":
+    case "double-click":
+      return controller.executeAction({
+        type: "double_click",
+        x: action.x,
+        y: action.y,
+        button: action.button || "left",
+      });
+    case "move":
+    case "mousemove":
+    case "mouse_move":
+      return controller.executeAction({ type: "move", x: action.x, y: action.y });
+    case "drag":
+    case "drag_to":
+    case "dragto":
+      return controller.executeAction({
+        type: "drag",
+        path: [
+          { x: action.from_x ?? controller.cursorX, y: action.from_y ?? controller.cursorY },
+          { x: action.to_x ?? action.x, y: action.to_y ?? action.y },
+        ],
+      });
+    case "scroll":
+      return controller.executeAction({
+        type: "scroll",
+        x: controller.cursorX,
+        y: controller.cursorY,
+        scroll_x: action.scroll_x ?? action.delta_x ?? action.x ?? 0,
+        scroll_y: action.scroll_y ?? action.delta_y ?? action.y ?? 0,
+      });
+    case "type":
+    case "input_text":
+      return controller.executeAction({ type: "type", text: action.text || "" });
+    case "keypress":
+    case "key_press":
+    case "press_key":
+      return controller.executeAction({
+        type: "keypress",
+        keys: Array.isArray(action.keys) ? action.keys : [String(action.key || action.text || "")],
+      });
+    case "wait":
+      return controller.executeAction({ type: "wait", ms: Number(action.ms || 1000) });
+    default:
+      throw new Error(`Unsupported OpenAI action type: ${type || "unknown"}`);
+  }
+}
+
+function summarizeOpenAiAction(action: any = {}) {
+  const type = String(action?.type || "");
+  if (type === "type") return `type(${JSON.stringify(String(action.text || "")).slice(0, 72)})`;
+  if (type === "click") return `click(${action.button || "left"} @ ${action.x},${action.y})`;
+  if (type === "double_click" || type === "double-click") {
+    return `double_click(${action.button || "left"} @ ${action.x},${action.y})`;
+  }
+  return type || "unknown";
+}
+
+function stripCredentialSaveFooters(text: string) {
+  return String(text || "")
+    .split("\n")
+    .filter((line) => !/^CREDENTIAL_SAVE\s+\{.+\}$/.test(line.trim()))
+    .join("\n")
+    .trim();
+}
+
+async function runOpenAiComputerTask({
+  client,
+  controller,
+  prompt,
+  secretTaskContext,
+  onEvent,
+}: {
+  client: any;
+  controller: any;
+  prompt: string;
+  secretTaskContext?: string;
+  onEvent?: (evt: any) => void;
+}) {
+  const systemPrompt = await buildComputerSystemPrompt();
+  let stepCount = 0;
+  let finalText = "";
+  let selectedModel = OPENAI_MODEL;
+
+  const initial = await createOpenAiResponseWithModelFallback({
+    client,
+    buildPayload: (model) => ({
+      model,
+      tools: [{ type: "computer" as const }],
+      input: [
+        {
+          role: "system",
+          content: [{ type: "input_text", text: systemPrompt }],
+        },
+        {
+          role: "user",
+          content: [
+            {
+              type: "input_text",
+              text:
+                "Execute the current task by following heartbeat.md exactly. " +
+                "Use heartbeat.md big steps as the source of truth.\n\n" +
+                `Task input:\n${prompt}` +
+                (secretTaskContext ? `\n\nCredential/task context:\n${secretTaskContext}` : ""),
+            },
+          ],
+        },
+      ],
+      truncation: "auto",
+    }),
+  });
+  let response = initial.response;
+  selectedModel = initial.model;
+  console.log(`Using OpenAI computer model: ${selectedModel}`);
+  await appendMemory(`[system] openai_model_selected=${selectedModel}`);
+
+  while (stepCount < MAX_STEPS) {
+    finalText = extractOpenAiText(response) || finalText;
+    const computerCalls = extractOpenAiComputerCalls(response);
+    if (!computerCalls.length) break;
+
+    const followUpInputs: any[] = [];
+    for (const call of computerCalls) {
+      const actions = getOpenAiCallActions(call);
+      if (!actions.length) {
+        const screenshotRaw = await controller.captureScreenshotBase64();
+        const screenshotMediaType =
+          typeof controller.getLastScreenshotMediaType === "function"
+            ? controller.getLastScreenshotMediaType()
+            : "image/png";
+        const screenshot = await enforceApiImageLimit(screenshotRaw, screenshotMediaType);
+        const savedPath = await persistScreenshotToDisk(screenshot.data, 0, screenshot.mediaType);
+        await appendMemory(`[screenshot step=0] ${savedPath}`);
+        onEvent?.({ type: "screenshot", step: 0, path: savedPath });
+        followUpInputs.push({
+          type: "computer_call_output",
+          call_id: call.call_id,
+          output: {
+            type: "input_image",
+            image_url: `data:${screenshot.mediaType};base64,${screenshot.data}`,
+          },
+        });
+        continue;
+      }
+      for (const action of actions) {
+        if (stepCount >= MAX_STEPS) break;
+        stepCount += 1;
+        const actionSummary = summarizeOpenAiAction(action);
+        console.log(`  [step ${stepCount}] ${actionSummary}`);
+        await appendMemory(`[action step=${stepCount}] ${actionSummary}`);
+        onEvent?.({ type: "action", step: stepCount, action: actionSummary });
+        try {
+          await executeOpenAiAction(controller, action);
+        } catch (error) {
+          await appendMemory(
+            `[action_error step=${stepCount}] ${error instanceof Error ? error.message : String(error)}`,
+          );
+          console.warn(
+            `  [step ${stepCount}] action failed: ${error instanceof Error ? error.message : String(error)}`,
+          );
+        }
+        if (ACTION_DELAY_MS) await sleep(ACTION_DELAY_MS);
+      }
+      const screenshotRaw = await controller.captureScreenshotBase64();
+      const screenshotMediaType =
+        typeof controller.getLastScreenshotMediaType === "function"
+          ? controller.getLastScreenshotMediaType()
+          : "image/png";
+      const screenshot = await enforceApiImageLimit(screenshotRaw, screenshotMediaType);
+      const savedPath = await persistScreenshotToDisk(screenshot.data, stepCount, screenshot.mediaType);
+      await appendMemory(`[screenshot step=${stepCount}] ${savedPath}`);
+      onEvent?.({ type: "screenshot", step: stepCount, path: savedPath });
+      followUpInputs.push({
+        type: "computer_call_output",
+        call_id: call.call_id,
+        output: {
+          type: "input_image",
+          image_url: `data:${screenshot.mediaType};base64,${screenshot.data}`,
+        },
+      });
+    }
+
+    if (!followUpInputs.length) break;
+    response = await client.responses.create({
+      model: selectedModel,
+      previous_response_id: response.id,
+      tools: [{ type: "computer" as const }],
+      input: followUpInputs,
+      truncation: "auto",
+    });
+  }
+
+  if (stepCount >= MAX_STEPS) {
+    console.warn(`Reached max tool steps (${MAX_STEPS}).`);
+  }
+  return finalText || "(No assistant message returned.)";
+}
+
+async function persistScreenshotToDisk(base64: string, stepCount: number, mediaType = "image/png") {
+  const ext = mediaType === "image/jpeg" ? "jpg" : "png";
+  const file = path.join(
+    SCREENSHOT_DIR,
+    `${Date.now()}-step-${String(stepCount).padStart(4, "0")}-${Math.random().toString(36).slice(2, 8)}.${ext}`,
+  );
+  await fs.writeFile(file, Buffer.from(base64, "base64"));
+  return file;
+}
+
+async function runManagedTask({
+  runtime,
+  controller,
+  userPrompt,
+  source,
+  dashboard,
+  publishToConsole = true,
+  indicatorMessage = "OpenCore is controlling this Mac",
+}: {
+  runtime: ProviderRuntime;
+  controller: any;
+  userPrompt: string;
+  source: "terminal" | "dashboard" | "manager" | "schedule" | "telegram";
+  dashboard?: DashboardServer | null;
+  publishToConsole?: boolean;
+  indicatorMessage?: string;
+}) {
+  await appendMemory(`[user] ${userPrompt}`);
+  await dashboard?.publishChat({ role: "user", source: source === "schedule" ? "manager" : source, text: userPrompt });
+  dashboard?.publishEvent({ type: "task_started", source: source === "schedule" ? "manager" : source });
+  await writeIndicatorState({ running: true, active: true, message: indicatorMessage });
+  await showMacNotification("OpenCore", indicatorMessage);
+  if (publishToConsole) console.log(`Running (${source})...`);
+
+  const persistentPlan = await managerInferPersistentUpdates({ runtime, userPrompt });
+  await applyPersistentUpdatePlan({
+    runtime,
+    userPrompt,
+    plan: persistentPlan,
+    dashboard: dashboard || ({ publishEvent() {} } as any),
+  });
+
+  const telegramSetup = await handleTelegramSetupRequest(userPrompt);
+  if (telegramSetup?.handled) {
+    await appendMemory("[manager] configured_telegram");
+    await dashboard?.publishChat({ role: "assistant", source: "system", text: telegramSetup.answer });
+    dashboard?.publishEvent({ type: "task_completed", source: source === "schedule" ? "manager" : source });
+    await writeIndicatorState({ running: true, active: false, message: "OpenCore is idle" });
+    await showMacNotification("OpenCore", "OpenCore updated Telegram settings.");
+    return telegramSetup.answer;
+  }
+
+  const credentialSetup = await handleCredentialSetupRequest(userPrompt);
+  if (credentialSetup?.handled) {
+    await appendMemory("[manager] configured_credentials");
+    await dashboard?.publishChat({ role: "assistant", source: "system", text: credentialSetup.answer });
+    dashboard?.publishEvent({ type: "task_completed", source: source === "schedule" ? "manager" : source });
+    await writeIndicatorState({ running: true, active: false, message: "OpenCore is idle" });
+    await showMacNotification("OpenCore", "OpenCore updated local credentials.");
+    return credentialSetup.answer;
+  }
+
+  if (wantsHeartbeatAudit(userPrompt)) {
+    const recovered = await recoverScheduledTasksIfNeeded({
+      runtime,
+      controller,
+      dashboard: dashboard || null,
+      reason: "manual",
+    });
+    const answer = recovered.length
+      ? `Heartbeat check complete.\n${recovered.map((item) => `- ${item}`).join("\n")}`
+      : "Heartbeat check complete. No missed or errored scheduled tasks were found.";
+    await appendMemory(`[assistant] ${answer}`);
+    await dashboard?.publishChat({ role: "assistant", source: "system", text: answer });
+    await writeIndicatorState({ running: true, active: false, message: "OpenCore is idle" });
+    return answer;
+  }
+
+  const schedulePlan = await managerDetectScheduleRequest({ runtime, userPrompt });
+  if (schedulePlan.should_schedule) {
+    const record = await createScheduledTask({ runtime, userPrompt, plan: schedulePlan });
+    const scheduleAnswer =
+      `Scheduled task created.\n` +
+      `ID: ${record.id}\n` +
+      `Schedule: ${record.summary}\n` +
+      `Cron: ${record.cron_expression}\n` +
+      `Task: ${record.task}`;
+    await appendMemory(`[assistant] ${scheduleAnswer}`);
+    await dashboard?.publishChat({ role: "assistant", source: "system", text: scheduleAnswer });
+    dashboard?.publishEvent({ type: "task_completed", source: source === "schedule" ? "manager" : source });
+    await writeIndicatorState({ running: true, active: false, message: "OpenCore is idle" });
+    await showMacNotification("OpenCore", "OpenCore scheduled the requested task.");
+    return scheduleAnswer;
+  }
+
+  const decision = await managerDecide({ runtime, userPrompt });
+  await appendMemory(`[manager] route=${decision.route}`);
+  await managerWriteHeartbeat({ runtime, userPrompt, decision });
+  let answer = "";
+
+  if (decision.route === "direct") {
+    answer = decision.direct_answer || "Completed without computer interaction.";
+  } else if (decision.route === "edit_file") {
+    const resolved = resolveEditablePath(decision.file_target);
+    if (!resolved) {
+      answer = "I could not determine which file path to edit. Please specify a valid file target.";
+    } else {
+      const updated = await managerRewriteFile({
+        runtime,
+        target: decision.file_target || "",
+        userPrompt,
+        editInstructions: decision.edit_instructions || "",
+      });
+      if (updated === null) {
+        answer = "I could not resolve a writable file target.";
+      } else {
+        await fs.writeFile(resolved.path, updated, "utf8");
+        await appendMemory(`[manager] edited_file=${resolved.path}`);
+        dashboard?.publishEvent({ type: "file_updated", target: resolved.path });
+        answer = `Updated ${resolved.path} based on your request.`;
+      }
+    }
+  } else if (decision.route === "local") {
+    answer = await runLocalCommandTask({
+      runtime,
+      userPrompt,
+      localTask: decision.local_task || userPrompt,
+    });
+  } else {
+    const delegatedTask = decision.computer_task || userPrompt;
+    const credentialTaskContext = buildCredentialExecutionContext(await readCredentialStore(), delegatedTask);
+    await appendMemory(`[manager] delegated_to_computer task=${delegatedTask}`);
+    answer = await runOpenAiComputerTask({
+      client: runtime.openai,
+      controller,
+      prompt: delegatedTask,
+      secretTaskContext: credentialTaskContext,
+      onEvent: (evt) => dashboard?.publishEvent(evt),
+    });
+  }
+
+  for (const candidate of extractCredentialSaveCandidates(answer)) {
+    await upsertCredentialEntry(candidate);
+  }
+  answer = stripCredentialSaveFooters(answer);
+
+  await appendMemory(`[assistant] ${answer}`);
+  await appendLearnedFacts(await managerExtractLearnedFacts({ runtime, userPrompt, answer }));
+  await clearCompletedHeartbeat();
+  dashboard?.publishEvent({ type: "file_updated", target: HEARTBEAT_PATH });
+  await dashboard?.publishChat({ role: "assistant", source: "system", text: answer });
+  dashboard?.publishEvent({ type: "task_completed", source: source === "schedule" ? "manager" : source });
+  await writeIndicatorState({ running: true, active: false, message: "OpenCore is idle" });
+  await showMacNotification("OpenCore", source === "schedule" ? "OpenCore finished a scheduled task." : "OpenCore finished the current task.");
+  return answer;
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const scheduledMode = argv[0] === "--scheduled-id" ? String(argv[1] || "").trim() : "";
+  await ensureOpenCoreHome();
+  await writeIndicatorState({ running: true, active: false, message: "OpenCore is idle" });
+  const settings = await readSettings();
+  const provider = "chatgpt";
+  const openaiKey = String(process.env.OPENAI_API_KEY || settings.openai_api_key || "").trim();
+  let runtime: ProviderRuntime;
+  if (!openaiKey) {
+    console.error("Missing OpenAI API key. Set it in ~/.opencore/configs/settings.json or use: opencore config set-key chatgpt");
+    process.exit(1);
+  }
+  let OpenAIClient: any;
+  try {
+    OpenAIClient = require("openai").default;
+  } catch {
+    console.error("OpenAI SDK is not installed. Run npm install in the OpenCore project to enable ChatGPT mode.");
+    process.exit(1);
+  }
+  runtime = { provider: "chatgpt", openai: new OpenAIClient({ apiKey: openaiKey }) };
+  const controller = new MacController({
+    displayWidth: process.env.COMPUTER_USE_DISPLAY_WIDTH,
+    displayHeight: process.env.COMPUTER_USE_DISPLAY_HEIGHT,
+  });
+  await controller.init();
+  let indicator: any = startIndicatorProcess();
+
+  if (scheduledMode) {
+    const schedules = await readSchedules();
+    const schedule = schedules.find((item) => item.id === scheduledMode && item.active);
+    if (!schedule) {
+      console.error(`Scheduled task not found or inactive: ${scheduledMode}`);
+      await writeIndicatorState({ running: false, active: false, message: "OpenCore has stopped" });
+      stopIndicatorProcess(indicator);
+      process.exit(1);
+    }
+    try {
+      const runStartedAt = new Date().toISOString();
+      if (schedule.schedule_kind === "one_time") {
+        await setScheduleRecordState(schedule.id, {
+          active: false,
+          last_run_at: runStartedAt,
+          last_status: "running",
+          last_error: "",
+        });
+        await removeCronSchedule(schedule.id);
+      } else {
+        await setScheduleRecordState(schedule.id, {
+          last_run_at: runStartedAt,
+          last_status: "running",
+          last_error: "",
+        });
+      }
+      const answer = await runManagedTask({
+        runtime,
+        controller,
+        userPrompt: schedule.task,
+        source: "schedule",
+        dashboard: null,
+        publishToConsole: true,
+        indicatorMessage: "OpenCore is running a scheduled task",
+      });
+      const now = new Date().toISOString();
+      if (schedule.schedule_kind !== "one_time") {
+        await setScheduleRecordState(schedule.id, { last_run_at: now, last_status: "done", last_error: "" });
+      } else {
+        await setScheduleRecordState(schedule.id, { last_run_at: now, last_status: "done", last_error: "" });
+      }
+      console.log(answer);
+      await writeIndicatorState({ running: false, active: false, message: "OpenCore has stopped" });
+      stopIndicatorProcess(indicator);
+      process.exit(0);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(`Scheduled task failed: ${msg}`);
+      await appendMemory(`[scheduled_error id=${scheduledMode}] ${msg}`);
+      await setScheduleRecordState(scheduledMode, { last_status: "error", last_error: msg });
+      await writeIndicatorState({ running: false, active: false, message: "OpenCore has stopped" });
+      stopIndicatorProcess(indicator);
+      process.exit(1);
+    }
+  }
+
+  const queue: Array<{ text: string; source: "terminal" | "dashboard" | "manager" | "telegram" }> = [];
+  let queueRunning = false;
+  let exiting = false;
+  let managerTickRunning = false;
+  let managerTickTimer: NodeJS.Timeout | null = null;
+  let telegramTickRunning = false;
+  let telegramTickTimer: NodeJS.Timeout | null = null;
+  let lastHeartbeatSignature = "";
+  const autoTaskDedupe = new Set<string>();
+  let telegramConfig = parseTelegramConfig(settings);
+  const rl = readline.createInterface({ input, output, terminal: true });
+  let commandPromptBusy = false;
+  const dashboard = new DashboardServer({
+    rootDir: ROOT_DIR,
+    openCoreHome: OPENCORE_HOME,
+    screenshotDir: SCREENSHOT_DIR,
+    onDashboardPrompt: (text) => {
+      queue.push({ text, source: "dashboard" });
+      void processQueue();
+    },
+    getTelegramConfig: async () => publicTelegramConfig(telegramConfig),
+    setTelegramConfig: async (next) => {
+      const nextBotToken = String(next?.bot_token || "").trim() || telegramConfig.botToken;
+      const nextChatId = String(next?.chat_id || "").trim() || telegramConfig.chatId;
+      const nextUserId = String(next?.user_id || "").trim() || telegramConfig.userId;
+      const nextPairingCode = String(next?.pairing_code || "").trim() || telegramConfig.pairingCode;
+      const shouldEnable = Boolean(nextBotToken);
+      const merged = {
+        telegram_enabled: shouldEnable,
+        telegram_chat_id: nextChatId,
+        telegram_user_id: nextUserId,
+        telegram_bot_token: nextBotToken,
+        telegram_pairing_code: nextPairingCode,
+        telegram_paired: Boolean(shouldEnable && nextChatId && nextUserId && nextPairingCode),
+        telegram_last_update_id: Number(next?.last_update_id || telegramConfig.lastUpdateId || 0),
+      };
+      await writeSettingsPatch(merged);
+      telegramConfig = parseTelegramConfig(await readSettings());
+      refreshTelegramPolling();
+      return publicTelegramConfig(telegramConfig);
+    },
+    disconnectTelegram: async () => {
+      await writeSettingsPatch({
+        telegram_enabled: false,
+        telegram_bot_token: "",
+        telegram_chat_id: "",
+        telegram_user_id: "",
+        telegram_pairing_code: "",
+        telegram_paired: false,
+        telegram_last_update_id: 0,
+      });
+      telegramConfig = parseTelegramConfig(await readSettings());
+      refreshTelegramPolling();
+      return publicTelegramConfig(telegramConfig);
+    },
+    onCredentialsUpdated: async () => {
+      await appendMemory("[system] credentials_updated");
+    },
+  });
+  await dashboard.start(DASHBOARD_PORT);
+  const recoveredOnStartup = await recoverScheduledTasksIfNeeded({
+    runtime,
+    controller,
+    dashboard,
+    reason: "startup",
+  });
+
+  console.log(`${renderOpenCoreBanner()}\n\n`);
+  console.log(`OpenCore ${APP_VERSION} macOS`);
+  console.log(`Provider: ${provider}`);
+  console.log(`Dashboard: http://127.0.0.1:${DASHBOARD_PORT}`);
+  console.log("Type a task and press Enter. Use /exit to quit.\n");
+  if (recoveredOnStartup.length) {
+    console.log("Recovered scheduled tasks:");
+    for (const line of recoveredOnStartup) console.log(`- ${line}`);
+    console.log("");
+  }
+
+  async function shutdown(code = 0) {
+    if (exiting) return;
+    exiting = true;
+    if (managerTickTimer) clearInterval(managerTickTimer);
+    if (telegramTickTimer) clearInterval(telegramTickTimer);
+    queue.length = 0;
+    try {
+      rl.close();
+    } catch {}
+    try {
+      await Promise.race([
+        dashboard.stop(1200),
+        sleep(1400),
+      ]);
+    } catch {}
+    await writeIndicatorState({ running: false, active: false, message: "OpenCore has stopped" });
+    stopIndicatorProcess(indicator);
+    indicator = null;
+    process.exit(code);
+  }
+
+  function printSkillsText(skills: string[]) {
+    if (!skills.length) return "No OpenCore skills installed.";
+    return `Installed OpenCore skills:\n${skills.map((skill) => `- ${skill}`).join("\n")}`;
+  }
+
+  function printSchedulesText(active: ScheduledTaskRecord[]) {
+    if (!active.length) return "No active scheduled tasks.";
+    return `Active scheduled tasks:\n${active.map((item) => `- ${item.id} | ${item.schedule_kind} | ${item.cron_expression} | ${item.summary}`).join("\n")}`;
+  }
+
+  async function handleHeartbeatCheck() {
+    const recovered = await recoverScheduledTasksIfNeeded({
+      runtime,
+      controller,
+      dashboard,
+      reason: "manual",
+    });
+    const text = !recovered.length
+      ? "Heartbeat check complete. No missed or errored scheduled tasks were found."
+      : `Heartbeat recovery results:\n${recovered.map((item) => `- ${item}`).join("\n")}`;
+    await appendMemory(`[system] checked_heartbeat recovered=${recovered.length}`);
+    return text;
+  }
+
+  async function disconnectTelegramRuntime() {
+    if (telegramTickTimer) clearInterval(telegramTickTimer);
+    telegramTickTimer = null;
+    await writeSettingsPatch({
+      telegram_enabled: false,
+      telegram_bot_token: "",
+      telegram_chat_id: "",
+      telegram_user_id: "",
+      telegram_pairing_code: "",
+      telegram_paired: false,
+      telegram_last_update_id: 0,
+    });
+    telegramConfig = parseTelegramConfig(await readSettings());
+    refreshTelegramPolling();
+    return "Telegram disconnected.";
+  }
+
+  async function reconnectTelegramInteractive() {
+    if (!input.isTTY || commandPromptBusy) {
+      return "Telegram reconnect requires an interactive terminal.";
+    }
+    commandPromptBusy = true;
+    rl.pause();
+    try {
+      const botToken = String(await rl.question("Telegram bot token: ")).trim();
+      if (!botToken) return "Telegram reconnect cancelled: bot token is required.";
+      const me = await telegramApi(botToken, "getMe");
+      console.log(`Connected bot: @${me?.username || "unknown"}`);
+      await writeSettingsPatch({
+        telegram_enabled: true,
+        telegram_bot_token: botToken,
+        telegram_chat_id: "",
+        telegram_user_id: "",
+        telegram_pairing_code: "",
+        telegram_paired: false,
+        telegram_last_update_id: 0,
+      });
+      telegramConfig = parseTelegramConfig(await readSettings());
+      refreshTelegramPolling();
+      return "Telegram bot token saved. Start OpenCore, send /start to the bot, then give the Telegram user ID and pairing code from Telegram back to OpenCore.";
+    } finally {
+      commandPromptBusy = false;
+      if (!exiting) {
+        rl.resume();
+        rl.prompt();
+      }
+    }
+  }
+
+  async function handleControlCommand(line: string, source: "terminal" | "telegram") {
+    if (line === "/skills") {
+      const skills = await listInstalledSkillFiles();
+      await appendMemory(`[system] listed_skills count=${skills.length}`);
+      return { handled: true, text: printSkillsText(skills) };
+    }
+    if (line === "/schedules") {
+      const schedules = await readSchedules();
+      const active = schedules.filter((item) => item.active);
+      await appendMemory(`[system] listed_schedules count=${active.length}`);
+      return { handled: true, text: printSchedulesText(active) };
+    }
+    if (line === "/check-heartbeat") {
+      return { handled: true, text: await handleHeartbeatCheck() };
+    }
+    if (source === "terminal" && line === "/telegram disconnect") {
+      return { handled: true, text: await disconnectTelegramRuntime() };
+    }
+    if (source === "terminal" && line === "/telegram reconnect") {
+      return { handled: true, text: await reconnectTelegramInteractive() };
+    }
+    if (source === "telegram" && line.startsWith("/")) {
+      return {
+        handled: true,
+        text: "Unsupported Telegram command. Available commands: /skills, /schedules, /check-heartbeat",
+      };
+    }
+    return { handled: false, text: "" };
+  }
+
+  function startTelegramPolling() {
+    if (telegramTickTimer || !telegramConfig.enabled) return;
+    console.log(`Telegram: connected to chat ${telegramConfig.chatId}`);
+    telegramTickTimer = setInterval(() => {
+      void telegramPollTick();
+    }, 4000);
+    if (typeof telegramTickTimer.unref === "function") telegramTickTimer.unref();
+    setTimeout(() => {
+      void telegramPollTick();
+    }, 1500);
+  }
+
+  function stopTelegramPolling() {
+    if (telegramTickTimer) clearInterval(telegramTickTimer);
+    telegramTickTimer = null;
+  }
+
+  function refreshTelegramPolling() {
+    stopTelegramPolling();
+    if (telegramConfig.enabled) startTelegramPolling();
+  }
+
+  async function processQueue() {
+    if (queueRunning) return;
+    queueRunning = true;
+    rl.pause();
+    console.log("> [running... input locked until task completes]");
+    try {
+      while (queue.length) {
+        const item = queue.shift();
+        if (!item) continue;
+        try {
+          const answer = await runManagedTask({
+            runtime,
+            controller,
+            userPrompt: item.text,
+            source: item.source,
+            dashboard,
+          });
+          console.log(`\nAssistant:\n${answer}\n`);
+          if (item.source === "telegram") {
+            await sendTelegramMessage(telegramConfig, answer);
+          }
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          console.error(`\nRequest failed: ${msg}\n`);
+          await appendMemory(`[error] ${msg}`);
+          await dashboard.publishChat({ role: "error", source: "system", text: `Request failed: ${msg}` });
+          dashboard.publishEvent({ type: "task_failed", source: item.source });
+          await writeIndicatorState({ running: true, active: false, message: "OpenCore is idle" });
+          await showMacNotification("OpenCore", "OpenCore stopped because the current task failed.");
+          if (item.source === "telegram") {
+            await sendTelegramMessage(telegramConfig, `Request failed: ${msg}`);
+          }
+        }
+      }
+    } finally {
+      queueRunning = false;
+      if (!exiting) {
+        rl.resume();
+        rl.prompt();
+      }
+    }
+  }
+
+  async function managerHeartbeatTick() {
+    if (exiting || queueRunning || managerTickRunning) return;
+    managerTickRunning = true;
+    try {
+      const heartbeat = await readTextFile(HEARTBEAT_PATH, DEFAULT_HEARTBEAT);
+      const stat = await fs.stat(HEARTBEAT_PATH).catch(() => null);
+      const signature = `${stat?.mtimeMs || 0}:${heartbeat.length}`;
+      const heartbeatChanged = signature !== lastHeartbeatSignature;
+      lastHeartbeatSignature = signature;
+
+      const decision = await managerEvaluateHeartbeatTick({
+        runtime,
+        heartbeat,
+        heartbeatChanged,
+      });
+      if (!decision.run_now) return;
+
+      const task = String(decision.task || "").trim();
+      if (!task) return;
+      const minuteKey = new Date().toISOString().slice(0, 16);
+      const dedupeKey = `${minuteKey}|${signature}|${task.toLowerCase()}`;
+      if (autoTaskDedupe.has(dedupeKey)) return;
+      autoTaskDedupe.add(dedupeKey);
+      if (autoTaskDedupe.size > 800) {
+        const oldest = autoTaskDedupe.values().next().value;
+        if (oldest) autoTaskDedupe.delete(oldest);
+      }
+
+      console.log(`\n[manager heartbeat] ${decision.reason || "Autonomous run triggered."}`);
+      await appendMemory(`[manager_heartbeat] trigger task=${task} reason=${decision.reason || "n/a"}`);
+      queue.push({ text: task, source: "manager" });
+      void processQueue();
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.warn(`[manager heartbeat] check failed: ${msg}`);
+      await appendMemory(`[manager_heartbeat_error] ${msg}`);
+    } finally {
+      managerTickRunning = false;
+    }
+  }
+
+  async function telegramPollTick() {
+    if (exiting || queueRunning || telegramTickRunning || !telegramConfig.enabled) return;
+    telegramTickRunning = true;
+    try {
+      const updates = await telegramApi(telegramConfig.botToken, "getUpdates", {
+        offset: telegramConfig.lastUpdateId + 1,
+        timeout: 1,
+        limit: 10,
+      });
+      if (!Array.isArray(updates) || !updates.length) return;
+
+      let highestUpdateId = telegramConfig.lastUpdateId;
+      for (const update of updates) {
+        const updateId = Number(update?.update_id || 0);
+        if (updateId > highestUpdateId) highestUpdateId = updateId;
+        const message = update?.message;
+        const chatId = String(message?.chat?.id || "");
+        const userId = String(message?.from?.id || "");
+        const text = String(message?.text || "").trim();
+        if (!text) continue;
+        if (text.startsWith("/start")) {
+          if (!telegramConfig.pairingCode) {
+            const generatedCode = generateTelegramPairingCode();
+            await writeSettingsPatch({
+              telegram_chat_id: chatId,
+              telegram_user_id: userId,
+              telegram_pairing_code: generatedCode,
+              telegram_paired: false,
+              telegram_last_update_id: updateId,
+            });
+            telegramConfig = parseTelegramConfig(await readSettings());
+          } else if (!telegramConfig.chatId) {
+            await writeSettingsPatch({
+              telegram_chat_id: chatId,
+              telegram_user_id: userId,
+              telegram_last_update_id: updateId,
+            });
+            telegramConfig = parseTelegramConfig(await readSettings());
+          }
+          const discoveredMessage = telegramConfig.paired
+            ? "OpenCore is connected. You can now send tasks while the CLI is running."
+            : `Your Telegram user ID is: ${userId}\nYour OpenCore pairing code is: ${telegramConfig.pairingCode}\nGive both values to OpenCore in the terminal, dashboard, or chat so it can finish linking Telegram.`;
+          await sendTelegramMessage(
+            { ...telegramConfig, chatId: chatId || telegramConfig.chatId },
+            discoveredMessage,
+          );
+          continue;
+        }
+        if (!telegramConfig.paired) continue;
+        if (telegramConfig.userId && userId !== telegramConfig.userId) continue;
+        if (telegramConfig.chatId && chatId !== telegramConfig.chatId) continue;
+        const commandResult = await handleControlCommand(text, "telegram");
+        if (commandResult.handled) {
+          await sendTelegramMessage(telegramConfig, commandResult.text);
+          continue;
+        }
+        queue.push({ text, source: "telegram" });
+      }
+
+      if (highestUpdateId !== telegramConfig.lastUpdateId) {
+        telegramConfig.lastUpdateId = highestUpdateId;
+        await writeSettingsPatch({ telegram_last_update_id: highestUpdateId });
+      }
+      if (queue.length) void processQueue();
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.warn(`[telegram] poll failed: ${msg}`);
+      await appendMemory(`[telegram_error] ${msg}`);
+    } finally {
+      telegramTickRunning = false;
+    }
+  }
+
+  rl.setPrompt("> ");
+  rl.prompt();
+  managerTickTimer = setInterval(() => {
+    void managerHeartbeatTick();
+  }, MANAGER_HEARTBEAT_INTERVAL_MS);
+  if (typeof managerTickTimer.unref === "function") managerTickTimer.unref();
+  setTimeout(() => {
+    void managerHeartbeatTick();
+  }, 2000);
+  if (telegramConfig.enabled) {
+    startTelegramPolling();
+  } else {
+    console.log("Telegram: not configured");
+  }
+
+  try {
+    await new Promise<void>((resolve) => {
+      rl.on("line", (raw) => {
+        const line = raw.trim();
+        if (!line) {
+          if (!queueRunning && !exiting) rl.prompt();
+          return;
+        }
+        if (line === "/exit" || line === "/quit") {
+          void shutdown(0);
+          resolve();
+          return;
+        }
+        if (
+          line === "/skills" ||
+          line === "/schedules" ||
+          line === "/check-heartbeat" ||
+          line === "/telegram reconnect" ||
+          line === "/telegram disconnect"
+        ) {
+          void (async () => {
+            const result = await handleControlCommand(line, "terminal");
+            if (result.handled && result.text) console.log(result.text);
+            if (!queueRunning && !exiting) rl.prompt();
+          })();
+          return;
+        }
+        if (line.startsWith("/unschedule ")) {
+          void (async () => {
+            const scheduleId = line.slice("/unschedule ".length).trim();
+            if (!scheduleId) {
+              console.log("Usage: /unschedule <schedule-id>");
+              if (!queueRunning && !exiting) rl.prompt();
+              return;
+            }
+            const updated = await setScheduleRecordState(scheduleId, { active: false, last_status: "cancelled", last_error: "" });
+            if (!updated) {
+              console.log(`No schedule found for id: ${scheduleId}`);
+            } else {
+              await removeCronSchedule(scheduleId);
+              console.log(`Removed schedule ${scheduleId}`);
+              await appendMemory(`[system] unscheduled id=${scheduleId}`);
+            }
+            if (!queueRunning && !exiting) rl.prompt();
+          })();
+          return;
+        }
+        if (queueRunning) {
+          console.log("OpenCore is still running. Please wait for it to finish.");
+          rl.prompt();
+          return;
+        }
+        queue.push({ text: line, source: "terminal" });
+        void processQueue();
+      });
+    });
+  } finally {
+    if (!exiting) {
+      await shutdown(0);
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});