Your dashboard.

// tg_bot.ts: single-file Telegram bot, polling
import { Telegraf } from 'telegraf';
import { readFile, writeFile, appendFile, unlink } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import path from 'node:path';

const DATA_DIR = process.env.ACADEMY_DATA_DIR ?? './data';
const LOG = path.join(DATA_DIR, 'agent.log.ndjson');
const KILL = path.join(DATA_DIR, 'kill_switch.flag');
const OVERRIDE = path.join(DATA_DIR, 'manual_override.json');
const ALLOWED = (process.env.TG_ALLOWED_USER_IDS ?? '').split(',').map(s => s.trim());

const bot = new Telegraf(process.env.TG_BOT_TOKEN!);

bot.use((ctx, next) => {
  const id = String(ctx.from?.id ?? '');
  if (!ALLOWED.includes(id)) return ctx.reply('forbidden');
  return next();
});

async function lastIter(): Promise<string> {
  if (!existsSync(LOG)) return 'no log yet';
  const txt = await readFile(LOG, 'utf8');
  const last = txt.trim().split('\n').slice(-1)[0];
  return '```\n' + last + '\n```';
}

bot.command('status', async (ctx) => {
  const killed = existsSync(KILL) ? 'TRIPPED' : 'live';
  await ctx.reply(`switch: ${killed}\n${await lastIter()}`,
    { parse_mode: 'Markdown' });
});

bot.command('kill', async (ctx) => {
  await writeFile(KILL, `tripped via tg by ${ctx.from?.id}\n`);
  await appendFile(LOG, JSON.stringify({
    ts: new Date().toISOString(),
    event: 'kill_switch_toggled_via_tg', on: true, by: ctx.from?.id,
  }) + '\n');
  await ctx.reply('halt requested. agent stops on next iteration.');
});

bot.command('resume', async (ctx) => {
  if (existsSync(KILL)) await unlink(KILL);
  await appendFile(LOG, JSON.stringify({
    ts: new Date().toISOString(),
    event: 'kill_switch_toggled_via_tg', on: false, by: ctx.from?.id,
  }) + '\n');
  await ctx.reply('cleared. agent resumes on next iteration.');
});

bot.command('override', async (ctx) => {
  const instruction = ctx.message.text.replace(/^\/override\s*/, '');
  if (!instruction) return ctx.reply('usage: /override <one-shot instruction>');
  await writeFile(OVERRIDE, JSON.stringify({
    instruction, ts: new Date().toISOString(), via: 'tg', by: ctx.from?.id,
  }));
  await appendFile(LOG, JSON.stringify({
    ts: new Date().toISOString(),
    event: 'manual_override_set_via_tg', instruction, by: ctx.from?.id,
  }) + '\n');
  await ctx.reply('override applied to next iteration only.');
});

bot.launch();

# tg_bot.py: single-file Telegram bot, polling
import json
import os
from datetime import datetime, timezone
from pathlib import Path

from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes

DATA_DIR = Path(os.environ.get("ACADEMY_DATA_DIR", "./data"))
LOG = DATA_DIR / "agent.log.ndjson"
KILL = DATA_DIR / "kill_switch.flag"
OVERRIDE = DATA_DIR / "manual_override.json"
ALLOWED = {s.strip() for s in os.environ.get("TG_ALLOWED_USER_IDS", "").split(",") if s.strip()}


def authed(uid: str) -> bool:
    return uid in ALLOWED


async def status(update: Update, _: ContextTypes.DEFAULT_TYPE) -> None:
    if not authed(str(update.effective_user.id)):
        return await update.message.reply_text("forbidden")
    killed = "TRIPPED" if KILL.exists() else "live"
    last = LOG.read_text().splitlines()[-1] if LOG.exists() else "no log yet"
    await update.message.reply_text(f"switch: {killed}\n```\n{last}\n```",
                                    parse_mode="Markdown")


async def kill(update: Update, _: ContextTypes.DEFAULT_TYPE) -> None:
    if not authed(str(update.effective_user.id)):
        return await update.message.reply_text("forbidden")
    KILL.write_text(f"tripped via tg by {update.effective_user.id}\n")
    with LOG.open("a") as f:
        f.write(json.dumps({
            "ts": datetime.now(timezone.utc).isoformat(),
            "event": "kill_switch_toggled_via_tg",
            "on": True, "by": update.effective_user.id,
        }) + "\n")
    await update.message.reply_text("halt requested. agent stops on next iteration.")


async def resume(update: Update, _: ContextTypes.DEFAULT_TYPE) -> None:
    if not authed(str(update.effective_user.id)):
        return await update.message.reply_text("forbidden")
    if KILL.exists():
        KILL.unlink()
    with LOG.open("a") as f:
        f.write(json.dumps({
            "ts": datetime.now(timezone.utc).isoformat(),
            "event": "kill_switch_toggled_via_tg",
            "on": False, "by": update.effective_user.id,
        }) + "\n")
    await update.message.reply_text("cleared. agent resumes on next iteration.")


async def override(update: Update, _: ContextTypes.DEFAULT_TYPE) -> None:
    if not authed(str(update.effective_user.id)):
        return await update.message.reply_text("forbidden")
    text = update.message.text.removeprefix("/override").strip()
    if not text:
        return await update.message.reply_text("usage: /override <one-shot instruction>")
    OVERRIDE.write_text(json.dumps({
        "instruction": text,
        "ts": datetime.now(timezone.utc).isoformat(),
        "via": "tg", "by": update.effective_user.id,
    }))
    with LOG.open("a") as f:
        f.write(json.dumps({
            "ts": datetime.now(timezone.utc).isoformat(),
            "event": "manual_override_set_via_tg",
            "instruction": text, "by": update.effective_user.id,
        }) + "\n")
    await update.message.reply_text("override applied to next iteration only.")


app = Application.builder().token(os.environ["TG_BOT_TOKEN"]).build()
app.add_handler(CommandHandler("status", status))
app.add_handler(CommandHandler("kill", kill))
app.add_handler(CommandHandler("resume", resume))
app.add_handler(CommandHandler("override", override))
app.run_polling()