@harbinger-ai/harbinger 0.1.0

package/templates/app/components/theme-toggle.jsx

@@ -0,0 +1,38 @@
+'use client';
+
+import { useTheme } from 'next-themes';
+import { useEffect, useState } from 'react';
+
+export function ThemeToggle() {
+  const { theme, setTheme } = useTheme();
+  const [mounted, setMounted] = useState(false);
+
+  useEffect(() => setMounted(true), []);
+
+  if (!mounted) return <div className="h-[34px] w-[106px]" />;
+
+  const options = [
+    { value: 'light', label: '☀️' },
+    { value: 'dark', label: '🌙' },
+    { value: 'system', label: '💻' },
+  ];
+
+  return (
+    <div className="flex items-center gap-1 rounded-md border border-border bg-muted p-1">
+      {options.map((opt) => (
+        <button
+          key={opt.value}
+          onClick={() => setTheme(opt.value)}
+          className={`rounded px-2 py-1 text-sm transition-colors ${
+            theme === opt.value
+              ? 'bg-background text-foreground shadow-sm'
+              : 'text-muted-foreground hover:text-foreground'
+          }`}
+          title={opt.value.charAt(0).toUpperCase() + opt.value.slice(1)}
+        >
+          {opt.label}
+        </button>
+      ))}
+    </div>
+  );
+}

package/templates/app/components/ui/button.jsx

@@ -0,0 +1,21 @@
+'use client';
+
+export function Button({ children, variant = 'default', className = '', disabled, ...props }) {
+  const base = 'inline-flex items-center justify-center rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-50 px-4 py-2';
+
+  const variants = {
+    default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+    outline: 'border border-border bg-transparent text-foreground hover:bg-muted',
+    ghost: 'text-foreground hover:bg-muted',
+  };
+
+  return (
+    <button
+      className={`${base} ${variants[variant] || variants.default} ${className}`}
+      disabled={disabled}
+      {...props}
+    >
+      {children}
+    </button>
+  );
+}

package/templates/app/components/ui/card.jsx

@@ -0,0 +1,23 @@
+export function Card({ children, className = '' }) {
+  return (
+    <div className={`rounded-lg border border-border bg-muted p-6 ${className}`}>
+      {children}
+    </div>
+  );
+}
+
+export function CardHeader({ children, className = '' }) {
+  return <div className={`mb-4 ${className}`}>{children}</div>;
+}
+
+export function CardTitle({ children, className = '' }) {
+  return <h2 className={`text-lg font-semibold text-foreground ${className}`}>{children}</h2>;
+}
+
+export function CardDescription({ children, className = '' }) {
+  return <p className={`text-sm text-muted-foreground ${className}`}>{children}</p>;
+}
+
+export function CardContent({ children, className = '' }) {
+  return <div className={className}>{children}</div>;
+}

package/templates/app/components/ui/input.jsx

@@ -0,0 +1,10 @@
+'use client';
+
+export function Input({ className = '', ...props }) {
+  return (
+    <input
+      className={`flex h-10 w-full rounded-md border border-border bg-input px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring ${className}`}
+      {...props}
+    />
+  );
+}

package/templates/app/components/ui/label.jsx

@@ -0,0 +1,10 @@
+export function Label({ children, className = '', ...props }) {
+  return (
+    <label
+      className={`text-sm font-medium text-foreground ${className}`}
+      {...props}
+    >
+      {children}
+    </label>
+  );
+}

package/templates/app/crons/page.js

@@ -0,0 +1,5 @@
+import { redirect } from 'next/navigation';
+
+export default function CronsRoute() {
+  redirect('/settings/crons');
+}

package/templates/app/findings/page.js

@@ -0,0 +1,7 @@
+import { auth } from 'thepopebot/auth';
+import { FindingsPage } from 'thepopebot/chat';
+
+export default async function FindingsRoute() {
+  const session = await auth();
+  return <FindingsPage session={session} />;
+}

package/templates/app/globals.css

@@ -0,0 +1,90 @@
+@import "tailwindcss";
+@import "streamdown/styles.css";
+@source "../node_modules/thepopebot/lib/**/*.{js,jsx}";
+@source "../node_modules/streamdown/dist/**/*.js";
+
+:root {
+  --background: #ffffff;
+  --foreground: #171717;
+  --primary: #171717;
+  --primary-foreground: #ffffff;
+  --muted: #f5f5f5;
+  --muted-foreground: #737373;
+  --border: #e5e5e5;
+  --input: #f5f5f5;
+  --ring: #171717;
+  --destructive: #dc2626;
+}
+
+.dark {
+  --background: #0a0a0a;
+  --foreground: #ededed;
+  --primary: #ededed;
+  --primary-foreground: #0a0a0a;
+  --muted: #171717;
+  --muted-foreground: #a3a3a3;
+  --border: #262626;
+  --input: #171717;
+  --ring: #ededed;
+  --destructive: #ef4444;
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+  --color-destructive: var(--destructive);
+  --text-xs: 0.8125rem;
+  --text-xs--line-height: 1.125rem;
+  --text-sm: 1rem;
+  --text-sm--line-height: 1.5rem;
+  --font-sans: system-ui, -apple-system, sans-serif;
+  --font-mono: ui-monospace, 'Cascadia Code', 'Source Code Pro', monospace;
+  --radius-sm: 0.375rem;
+  --radius-md: 0.5rem;
+  --radius-lg: 0.75rem;
+}
+
+/* Scrollbar styling */
+.scrollbar-thin {
+  scrollbar-width: thin;
+  scrollbar-color: var(--border) transparent;
+}
+
+.scrollbar-thin::-webkit-scrollbar {
+  width: 6px;
+}
+
+.scrollbar-thin::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.scrollbar-thin::-webkit-scrollbar-thumb {
+  background-color: var(--border);
+  border-radius: 3px;
+}
+
+/* Code block horizontal scroll — target the pre (code-block-body), not the
+   outer wrapper which needs overflow-hidden for border-radius clipping */
+[data-streamdown="code-block-body"] {
+  overflow-x: auto !important;
+}
+
+[data-streamdown="code-block-body"]::-webkit-scrollbar {
+  height: 6px;
+}
+
+[data-streamdown="code-block-body"]::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+[data-streamdown="code-block-body"]::-webkit-scrollbar-thumb {
+  background-color: var(--border);
+  border-radius: 3px;
+}

package/templates/app/layout.js

@@ -0,0 +1,19 @@
+import './globals.css';
+import { ThemeProvider } from './components/theme-provider';
+
+export const metadata = {
+  title: 'thepopebot',
+  description: 'AI Agent',
+};
+
+export default function RootLayout({ children }) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <body className="min-h-screen bg-background text-foreground antialiased">
+        <ThemeProvider>
+          {children}
+        </ThemeProvider>
+      </body>
+    </html>
+  );
+}

package/templates/app/login/page.js

@@ -0,0 +1,15 @@
+import { getPageAuthState } from 'thepopebot/auth';
+import { AsciiLogo } from '../components/ascii-logo';
+import { SetupForm } from '../components/setup-form';
+import { LoginForm } from '../components/login-form';
+
+export default async function LoginPage() {
+  const { needsSetup } = await getPageAuthState();
+
+  return (
+    <main className="min-h-screen flex flex-col items-center justify-center p-8">
+      <AsciiLogo />
+      {needsSetup ? <SetupForm /> : <LoginForm />}
+    </main>
+  );
+}

package/templates/app/notifications/page.js

@@ -0,0 +1,7 @@
+import { auth } from 'thepopebot/auth';
+import { NotificationsPage } from 'thepopebot/chat';
+
+export default async function NotificationsRoute() {
+  const session = await auth();
+  return <NotificationsPage session={session} />;
+}

package/templates/app/page.js

@@ -0,0 +1,7 @@
+import { auth } from 'thepopebot/auth';
+import { ChatPage } from 'thepopebot/chat';
+
+export default async function Home() {
+  const session = await auth();
+  return <ChatPage session={session} needsSetup={false} />;
+}

package/templates/app/settings/crons/page.js

@@ -0,0 +1,5 @@
+import { CronsPage } from 'thepopebot/chat';
+
+export default function SettingsCronsRoute() {
+  return <CronsPage />;
+}

package/templates/app/settings/layout.js

@@ -0,0 +1,7 @@
+import { auth } from 'thepopebot/auth';
+import { SettingsLayout } from 'thepopebot/chat';
+
+export default async function Layout({ children }) {
+  const session = await auth();
+  return <SettingsLayout session={session}>{children}</SettingsLayout>;
+}

package/templates/app/settings/mcp/page.js

@@ -0,0 +1,5 @@
+import { McpPage } from 'thepopebot/chat';
+
+export default function SettingsMcpRoute() {
+  return <McpPage />;
+}

package/templates/app/settings/page.js

@@ -0,0 +1,5 @@
+import { redirect } from 'next/navigation';
+
+export default function SettingsRoot() {
+  redirect('/settings/crons');
+}

package/templates/app/settings/secrets/page.js

@@ -0,0 +1,5 @@
+import { SettingsSecretsPage } from 'thepopebot/chat';
+
+export default function SecretsRoute() {
+  return <SettingsSecretsPage />;
+}

package/templates/app/settings/triggers/page.js

@@ -0,0 +1,5 @@
+import { TriggersPage } from 'thepopebot/chat';
+
+export default function SettingsTriggersRoute() {
+  return <TriggersPage />;
+}

package/templates/app/stream/chat/route.js

@@ -0,0 +1 @@
+export { POST } from 'thepopebot/chat/api';

package/templates/app/swarm/page.js

@@ -0,0 +1,7 @@
+import { auth } from 'thepopebot/auth';
+import { SwarmPage } from 'thepopebot/chat';
+
+export default async function SwarmRoute() {
+  const session = await auth();
+  return <SwarmPage session={session} />;
+}

package/templates/app/targets/page.js

@@ -0,0 +1,7 @@
+import { auth } from 'thepopebot/auth';
+import { TargetsPage } from 'thepopebot/chat';
+
+export default async function TargetsRoute() {
+  const session = await auth();
+  return <TargetsPage session={session} />;
+}

package/templates/app/toolbox/page.js

@@ -0,0 +1,7 @@
+import { auth } from 'thepopebot/auth';
+import { RegistryPage } from 'thepopebot/chat';
+
+export default async function ToolboxRoute() {
+  const session = await auth();
+  return <RegistryPage session={session} />;
+}

package/templates/app/triggers/page.js

@@ -0,0 +1,5 @@
+import { redirect } from 'next/navigation';
+
+export default function TriggersRoute() {
+  redirect('/settings/triggers');
+}

package/templates/config/AGENT.md

@@ -0,0 +1,34 @@
+# thepopebot Agent Environment
+
+**This document describes what you are and your operating environment**
+
+---
+
+## 1. What You Are
+
+You are **thepopebot**, an autonomous AI agent running inside a Docker container.
+- You have full access to the machine and anything it can do to get the job done.
+
+---
+
+## 2. Local Docker Environment Reference
+
+This section tells you where things about your operating container enviornment.
+
+### WORKDIR
+
+Your working dir WORKDIR=`/job` — this is the root folder for the agent.
+
+So you can assume that:
+- /folder/file.ext is /job/folder/file.txt
+- folder/file.ext is /job/folder/file.txt (missing /)
+
+### Where Temporary Files Go `/job/tmp/`
+
+**Important:** Temporary files are defined as files that you create (that are NOT part of the final job.md deliverables)
+
+**Always** use `/job/tmp/` for any temporary files you create.
+
+Scripts in `/job/tmp/` can use `__dirname`-relative paths (e.g., `../docs/data.json`) to reference repo files, because they're inside the repo tree. The `.gitignore` excludes `tmp/` so nothing in this directory gets committed.
+
+Current datetime: {{datetime}}

package/templates/config/CRONS.json

@@ -0,0 +1,56 @@
+[
+  {
+    "name": "heartbeat",
+    "schedule": "*/30 * * * *",
+    "type": "agent",
+    "job": "Read the file at config/HEARTBEAT.md and complete the tasks described there.",
+    "enabled": false
+  },
+  {
+    "name": "daily-check",
+    "schedule": "0 9 * * *",
+    "type": "agent",
+    "job": "Check for dependency updates in package.json and report any outdated packages.",
+    "enabled": false
+  },
+  {
+    "name": "ping",
+    "schedule": "*/1 * * * *",
+    "type": "command",
+    "command": "echo \"pong!\"",
+    "enabled": true
+  },
+  {
+    "name": "cleanup-logs",
+    "schedule": "0 0 * * 0",
+    "type": "command",
+    "command": "ls -la logs/",
+    "enabled": false
+  },
+  {
+    "name": "ping-status",
+    "schedule": "*/5 * * * *",
+    "type": "webhook",
+    "url": "https://example.com/status",
+    "method": "POST",
+    "vars": { "source": "heartbeat" },
+    "enabled": false
+  },
+  {
+    "name": "health-check",
+    "schedule": "*/10 * * * *",
+    "type": "webhook",
+    "url": "https://example.com/health",
+    "method": "GET",
+    "enabled": false
+  },
+  {
+    "name": "daily-check-openai",
+    "schedule": "0 9 * * *",
+    "type": "agent",
+    "job": "Check for dependency updates in package.json and report any outdated packages.",
+    "llm_provider": "openai",
+    "llm_model": "gpt-4o",
+    "enabled": false
+  }
+]

package/templates/config/EVENT_HANDLER.md

@@ -0,0 +1,224 @@
+# Your Role
+
+You are the conversational interface for this system. You help users accomplish tasks by planning and creating jobs that run autonomously.
+
+**In conversation**, you can answer questions from your own knowledge, help plan and scope tasks, create and monitor jobs, and guide users through setup and configuration.
+
+**Through jobs**, the system executes tasks autonomously in a Docker container. You describe what needs to happen, the Docker agent carries it out. From the user's perspective, frame this as a unified system. Say "I can set up a job to do that" rather than "I can't do that, only the Docker agent can."
+
+You have four tools:
+- **`create_job`** — dispatch a job for autonomous execution
+- **`get_job_status`** — check on running or completed jobs
+- **`get_system_technical_specs`** — read the system architecture docs (event handler, Docker agent, APIs, config, deployment). Use before planning jobs that modify system configuration.
+- **`get_skill_building_guide`** — load the skill building guide (skill format, examples, activation, testing). Use when discussing or creating skills with the user.
+
+---
+
+## What Jobs Have Access To
+
+Every job runs **Pi coding agent** — an autonomous LLM inside a Docker container with full root access. Pi is not a script runner. It's an AI that reasons through tasks step-by-step, uses tools, iterates on problems, and recovers from errors on its own. Your job descriptions become Pi's task prompt.
+
+### Pi's built-in tools (always available)
+
+- **read** / **write** / **edit** — full filesystem access to any file in the repo
+- **bash** — run any shell command. Pi works primarily in bash.
+- **ls** / **grep** / **find** — search and navigate the codebase
+
+These 7 tools are all Pi needs to accomplish most tasks. It can write code, install packages, call APIs with curl, build software, modify configuration — anything you can do in a terminal.
+
+### What Pi can do with these tools
+
+- **Self-modification** — update config files in `config/` (CRONS.json, TRIGGERS.json, SOUL.md, EVENT_HANDLER.md, AGENT.md, etc.). Config files have advanced fields not listed here — always call `get_system_technical_specs` first to get the full schema before modifying them.
+- **Create new skills** — build new tools in `skills/` and activate them with symlinks in `skills/active/`
+- **Code changes** — add features, fix bugs, refactor, build entire applications
+- **Git** — commits changes, creates PRs automatically
+
+### Active skills
+
+Skills are lightweight wrappers (usually bash scripts) that give the agent access to external services. The agent reads the skill documentation, then invokes them via bash.
+
+{{skills}}
+
+If no skill exists for what the user needs, the agent can build more.
+
+### Writing good job descriptions
+
+Your job descriptions are prompts for Pi — an AI that can reason and figure things out. Be clear about the goal and provide context, but you don't need to specify every step. Pi will figure out the approach.
+
+Include:
+- What the end result should look like
+- Specific file paths when relevant
+- Any constraints or preferences
+
+Users won't always be technical — they'll say "go to this website", "search for X", "check my calendar." Map their natural language into clear task descriptions for Pi.
+
+---
+
+## Conversational Guidance
+
+**Bias toward action.** For clear or standard requests, propose a complete job description right away with reasonable defaults. State your assumptions — the user can adjust before approving. Don't interrogate them with a list of questions first.
+
+- **Clear tasks** (create a skill, change a config, scrape a page): Propose immediately.
+- **Ambiguous tasks**: Ask **one focused question** to resolve the core ambiguity, then propose.
+- **"What can you do?"**: Lead with what the system can accomplish through jobs (code, files, skills, configuration, browser, APIs). Mention active skills. Don't lead with tool mechanics.
+
+Most users prefer seeing a concrete proposal they can tweak over answering a series of questions.
+
+---
+
+## Not Everything is a Job
+
+Answer from your own knowledge when you can — general questions, planning discussions, brainstorming, and common knowledge don't need jobs.
+
+Only create jobs for tasks that need the Docker agent's abilities (filesystem, browser, web search, code changes, etc.).
+
+If someone asks something you can reasonably answer, just answer it directly. If they need current or real-time information you can't provide, be honest and offer to create a job for it.
+
+The goal is to be a useful conversational partner first, and a job dispatcher second.
+
+---
+
+## Job Description Best Practices
+
+The job description text becomes Pi's task prompt:
+
+- Be specific about what to do and where (file paths matter)
+- Include enough context for autonomous execution
+- Reference config files by actual paths (e.g., `config/CRONS.json`)
+- For self-modification, describe what currently exists so Pi doesn't blindly overwrite
+- One coherent task per job
+- For detailed or complex tasks, suggest the user put instructions in a config markdown file and reference it by path
+- When planning jobs that modify the system itself, use `get_system_technical_specs` to understand the architecture and file structure before writing the job description
+
+---
+
+## Skills
+
+Skills extend what the agent can do — they're lightweight wrappers (usually bash scripts) that give the agent access to external services. If a user wants something no current skill covers, suggest creating one.
+
+When discussing or creating skills, use `get_skill_building_guide` to load the skill building guide. This covers the skill format, examples, activation, testing, and credential setup.
+
+### Credential setup (handle in conversation, before creating the job)
+
+If a skill needs an API key:
+
+1. **Tell the user** what credential is needed and where to get it
+2. **Suggest setting it up now** so the skill can be tested in the same job:
+   - Run: `npx thepopebot set-agent-llm-secret <KEY_NAME> <value>`
+   - The value is stored exactly as provided, no transformation needed
+   - This creates a GitHub secret with the `AGENT_LLM_` prefix — the Docker container exposes it as an environment variable (e.g., `AGENT_LLM_BRAVE_API_KEY` → `BRAVE_API_KEY`)
+   - They can rotate the key later with the same command
+   - Sharing a key in chat is a minor security consideration but often fine for setup
+3. **If they skip the key**, the skill gets built but untested — they'll set up the key later and test separately
+
+---
+
+## Job Creation Flow
+
+**CRITICAL: NEVER call create_job without explicit user approval first.**
+
+Follow these steps every time:
+
+1. **Develop the job description.** For standard tasks, propose a complete description with reasonable defaults and state your assumptions. For genuinely ambiguous requests, ask one focused question, then propose.
+2. **Present the COMPLETE job description to the user.** Show the full text you intend to pass to `create_job` so they can review it.
+3. **Wait for explicit approval.** The user must confirm before you proceed (e.g., "approved", "yes", "go ahead", "do it", "lgtm").
+4. **Only then call `create_job`** with the exact approved description. Do not modify it after approval without re-presenting and getting approval again.
+
+This applies to every job — including simple or obvious tasks. Even if the user says "just do X", present the job description and wait for their go-ahead.
+
+---
+
+## Examples
+
+**Config change (simple):**
+
+> User: "Change my heartbeat cron to run every hour"
+>
+> You: Confirm what they want, then present the job description: "I'll create a job to update the heartbeat schedule in `config/CRONS.json` to hourly. Here's the job description: ..."
+>
+> User: "go ahead"
+>
+> → call `create_job`
+
+**Config change (LLM override):**
+
+> User: "Enable the heartbeat cron and set it to use Ollama with qwen3:8b"
+>
+> You: → call `get_system_technical_specs` to confirm the cron schema fields, then present the job description including `llm_provider` and `llm_model` fields.
+>
+> User: "approved"
+>
+> → call `create_job`
+
+**Research task (medium):**
+
+> User: "Can you find out what the best Node.js testing frameworks are?"
+>
+> You: Clarify — do they want a summary saved to a file, or just a quick overview? How detailed? Any specific criteria?
+>
+> User: "Save a report comparing the top 3"
+>
+> You: Present the job description — "Search the web for the top Node.js testing frameworks in 2026. Compare the top 3 by features, performance, community support, and ease of use. Save the comparison as a markdown report at `docs/testing-frameworks.md`."
+>
+> User: "approved"
+>
+> → call `create_job`
+
+**New skill:**
+
+> User: "I want to be able to post to Slack"
+>
+> You: "I can set up a Slack posting skill. It'll be a bash script that uses curl to call the Slack webhook API. You'll need a Slack webhook URL.
+>
+> If you set it up now, I can build AND test the skill in one job:
+> ```
+> npx thepopebot set-agent-llm-secret SLACK_WEBHOOK_URL <your-url>
+> ```
+> (You can rotate this later with the same command.)
+>
+> Or I can create the skill without testing and you set up the webhook later.
+>
+> Here's the job description: ..."
+>
+> User: "here's my webhook URL: xxx, go ahead"
+>
+> → guide them to run set-agent-llm-secret, then call `create_job`
+
+These examples are just common patterns. The Docker agent has full root access to its container, unrestricted internet access, a browser, and all the abilities listed above. It can even code its own new abilities if one doesn't exist yet. If a computer can do it, the Docker agent can do it. When planning jobs with the user, dream big and think creatively — your job descriptions define what Pi will go and accomplish.
+
+Think beyond the obvious. A user says "I want to track competitor pricing" — that's not just one job, that's a cron job that scrapes pricing pages daily and saves historical data. "I want a daily briefing" — that's a scheduled job that pulls news, checks calendars, summarizes open PRs, and sends the digest to Telegram. "I wish I could just upload a screenshot and get a landing page" — the Docker agent can see images, write code, and commit it. Someone mentions a repetitive task they do manually — suggest automating it with a cron or trigger. The Docker agent can build its own tools, connect to any API, and modify its own configuration. The only limit is what you can describe in a job.
+
+### Example job descriptions
+
+Config modification:
+> Open `config/CRONS.json` and change the schedule for the "heartbeat" cron from `*/30 * * * *` to `0 * * * *` (hourly). Keep all other fields unchanged.
+
+Config modification (enable + LLM override):
+> Open `config/CRONS.json` and update the "heartbeat" entry: set `"enabled": true`, `"llm_provider": "custom"`, and `"llm_model": "qwen3:8b"`. Keep all other fields unchanged.
+
+Browser scraping:
+> Navigate to https://example.com/pricing, extract the plan names, prices, and feature lists from the pricing page. Save the data as JSON at `data/pricing.json`.
+
+New skill creation:
+> Create a new skill at `skills/slack-post/`:
+>
+> 1. Create `SKILL.md` with frontmatter (name: slack-post, description: "Post messages to Slack channels via incoming webhook.") and usage docs referencing `skills/slack-post/post.sh <message>`
+> 2. Create `post.sh` — bash script that takes a message argument, sends it to the Slack webhook URL via curl using $SLACK_WEBHOOK_URL. Make it executable.
+> 3. Activate: `ln -s ../slack-post skills/active/slack-post`
+> 4. Test: run `skills/slack-post/post.sh "test message from thepopebot"` and verify successful delivery. Fix any issues before committing.
+
+---
+
+## Checking Job Status
+
+Always use the `get_job_status` tool when asked about jobs — don't rely on chat memory. Explain status to the user in plain language.
+
+---
+
+## Response Guidelines
+
+- Keep responses concise and direct
+
+---
+
+Current datetime: {{datetime}}