@mndrk/agx 2.0.33 → 2.0.36

package/cloud-runtime/standalone/app/api/prompt-jobs/poll/route.ts

@@ -0,0 +1,232 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+import { pollDueJobs } from '@/src/prompt-scheduler/engine';
+import { getAgent, getAgentSkills } from '@/lib/db';
+import { LOCAL_USER } from '@/lib/auth-mode';
+import { runCliResponse } from '@/lib/cli-runner';
+import type { ChatProvider } from '@/lib/types';
+import { computeNextRun } from '@/src/prompt-scheduler/cron';
+import type { PromptJob, PromptRun } from '@/src/prompt-scheduler/types';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+const AGENTS_DIR = join(homedir(), '.agx', 'agents');
+
+/** Hydrate agent context — identity, self.md, skills */
+async function hydrateAgent(agentId: string): Promise<{
+  provider: ChatProvider;
+  model: string | null;
+  identity: string | undefined;
+  self: string | undefined;
+  skills: string | undefined;
+}> {
+  const agent = await getAgent(agentId, LOCAL_USER.id);
+  if (!agent) return { provider: 'claude', model: null, identity: undefined, self: undefined, skills: undefined };
+
+  const agentDir = join(AGENTS_DIR, agentId);
+
+  // Identity (description + voice)
+  let identity: string | undefined;
+  const parts: string[] = [];
+  if (agent.name) parts.push(`Name: ${agent.name}`);
+  if (agent.description) parts.push(agent.description);
+  if (agent.voice) parts.push(`Voice: ${agent.voice}`);
+  if (parts.length > 0) identity = parts.join('\n');
+
+  // Self.md (evolving bio)
+  let self: string | undefined;
+  const selfPath = join(agentDir, 'self.md');
+  if (existsSync(selfPath)) {
+    const raw = readFileSync(selfPath, 'utf-8');
+    const match = raw.match(/^---[\s\S]*?---\s*\n?([\s\S]*)$/);
+    self = match ? match[1].trim() : raw.trim();
+    if (!self) self = undefined;
+  }
+
+  // Skills
+  let skills: string | undefined;
+  const agentSkills = await getAgentSkills(agentId);
+  if (agentSkills.length > 0) {
+    const skillTexts: string[] = [];
+    for (const skill of agentSkills) {
+      const skillPath = skill.file.startsWith('/') ? skill.file : join(agentDir, skill.file);
+      if (existsSync(skillPath)) {
+        try {
+          const content = readFileSync(skillPath, 'utf-8');
+          skillTexts.push(`## ${skill.file}\n${content}`);
+        } catch {}
+      }
+    }
+    if (skillTexts.length > 0) skills = skillTexts.join('\n\n');
+  }
+
+  return {
+    provider: (agent.provider || 'claude') as ChatProvider,
+    model: agent.model || null,
+    identity,
+    self,
+    skills,
+  };
+}
+
+/** Resolve job to execution context */
+async function resolveJobContext(job: PromptJob): Promise<{
+  provider: ChatProvider;
+  model: string | null;
+  identity: string | undefined;
+  self: string | undefined;
+  skills: string | undefined;
+}> {
+  if (job.agentId) {
+    return hydrateAgent(job.agentId);
+  }
+  return {
+    provider: (job.provider || 'claude') as ChatProvider,
+    model: job.model || null,
+    identity: undefined,
+    self: undefined,
+    skills: undefined,
+  };
+}
+
+/** Execute a prompt using runCliResponse (routes through agx/provider with identity) */
+async function executePrompt(opts: {
+  provider: ChatProvider;
+  model: string | null;
+  prompt: string;
+  identity?: string;
+  self?: string;
+  skills?: string;
+  cliArgs?: string;
+}): Promise<{ output: string; error: string; durationMs: number; status: 'success' | 'failed' }> {
+  const startMs = Date.now();
+  let output = '';
+  let error = '';
+
+  try {
+    await runCliResponse({
+      provider: opts.provider,
+      model: opts.model,
+      prompt: opts.prompt,
+      identity: opts.identity,
+      self: opts.self,
+      skills: opts.skills,
+      passthroughArgs: opts.cliArgs ? opts.cliArgs.split(/\s+/).filter(Boolean) : undefined,
+      onDelta: (chunk) => { output += chunk; },
+    });
+    // On success, don't report stderr as error — it's just CLI debug output
+    return { output, error: '', durationMs: Date.now() - startMs, status: 'success' };
+  } catch (err) {
+    return { output, error: err instanceof Error ? err.message : String(err), durationMs: Date.now() - startMs, status: 'failed' };
+  }
+}
+
+/** Fire a condition gate → if yes → run action prompt */
+async function fireConditionGate(job: PromptJob, run: PromptRun) {
+  const store = getPromptJobStore();
+  const ctx = await resolveJobContext(job);
+  const gatePrompt = `You are a condition evaluator. Evaluate whether the following condition is currently true. Respond with ONLY "yes" or "no" (lowercase, nothing else).\n\nCondition: ${job.condition}`;
+
+  store.updateRun(run.id, { status: 'running', startedAt: new Date().toISOString() });
+
+  const gateResult = await executePrompt({ ...ctx, prompt: gatePrompt, cliArgs: job.cliArgs });
+  const answer = gateResult.output.trim().toLowerCase();
+  const passed = answer.startsWith('yes');
+
+  if (gateResult.status !== 'success' || !passed) {
+    store.updateRun(run.id, {
+      status: 'success',
+      output: `Gate: ${answer}\n(condition not met — skipped action)`,
+      durationMs: gateResult.durationMs,
+      finishedAt: new Date().toISOString(),
+    });
+    store.updateJob(job.id, { lastOutcome: 'success', lastRunAt: Date.now() });
+    return;
+  }
+
+  // Gate passed — execute action prompt with full agent context
+  store.updateRun(run.id, { output: `Gate: yes\nExecuting action prompt...` });
+  const actionResult = await executePrompt({ ...ctx, prompt: job.prompt, cliArgs: job.cliArgs });
+
+  store.updateRun(run.id, {
+    status: actionResult.status,
+    output: `Gate: yes\n---\n${actionResult.output}`,
+    error: actionResult.error || undefined,
+    durationMs: gateResult.durationMs + actionResult.durationMs,
+    finishedAt: new Date().toISOString(),
+  });
+  store.updateJob(job.id, { lastOutcome: actionResult.status, lastRunAt: Date.now() });
+}
+
+/** Fire a simple scheduled run with full agent context */
+async function fireRun(job: PromptJob, run: PromptRun) {
+  const store = getPromptJobStore();
+  const ctx = await resolveJobContext(job);
+
+  store.updateRun(run.id, { status: 'running', startedAt: new Date().toISOString() });
+  const result = await executePrompt({ ...ctx, prompt: job.prompt, cliArgs: job.cliArgs });
+
+  store.updateRun(run.id, {
+    status: result.status,
+    output: result.output,
+    error: result.error || undefined,
+    durationMs: result.durationMs,
+    finishedAt: new Date().toISOString(),
+  });
+  const nextRunAt = job.triggerType === 'condition'
+    ? Date.now() + job.checkEveryMs
+    : computeNextRun(job.cronExpr) ?? null;
+  store.updateJob(job.id, { lastOutcome: result.status, lastRunAt: Date.now(), nextRunAt });
+}
+
+/** Dispatch — fire and forget (don't block the HTTP response) */
+function dispatchRun(job: PromptJob, run: PromptRun) {
+  const fn = job.triggerType === 'condition' && job.condition ? fireConditionGate : fireRun;
+  fn(job, run).catch((err) => {
+    const store = getPromptJobStore();
+    store.updateRun(run.id, {
+      status: 'failed',
+      error: `Dispatch error: ${err instanceof Error ? err.message : String(err)}`,
+      finishedAt: new Date().toISOString(),
+    });
+    store.updateJob(job.id, { lastOutcome: 'failed' });
+  });
+}
+
+/**
+ * POST /api/prompt-jobs/poll
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const store = getPromptJobStore();
+    let body: { jobId?: string } = {};
+    try { body = await req.json(); } catch {}
+
+    if (body.jobId) {
+      const job = store.getJob(body.jobId);
+      if (!job) return NextResponse.json({ error: 'Job not found' }, { status: 404 });
+      const run = store.createRun(job.id);
+      dispatchRun(job, run);
+      return NextResponse.json({ queued: [run], skipped: [] });
+    }
+
+    const result = pollDueJobs(store);
+    for (const run of result.queued) {
+      const job = store.getJob(run.jobId);
+      if (!job) continue;
+      dispatchRun(job, run);
+    }
+
+    return NextResponse.json({ queued: result.queued, skipped: result.skipped });
+  } catch (error) {
+    console.error('Failed to poll prompt jobs:', error);
+    return NextResponse.json(
+      { error: 'Failed to poll prompt jobs', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}

package/cloud-runtime/standalone/app/api/prompt-jobs/route.ts

@@ -0,0 +1,125 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getPromptJobStore } from '@/src/prompt-scheduler/get-store';
+import { parseCadence, computeNextRun } from '@/src/prompt-scheduler/cron';
+import type { PromptJobState } from '@/src/prompt-scheduler/types';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/prompt-jobs
+ * List all jobs, optionally filtered by ?state=active|paused|stopped
+ */
+export async function GET(req: NextRequest) {
+  try {
+    const store = getPromptJobStore();
+    const state = req.nextUrl.searchParams.get('state') as PromptJobState | null;
+    const projectId = req.nextUrl.searchParams.get('projectId') ?? undefined;
+    const filter: { state?: PromptJobState; projectId?: string } = {};
+    if (state) filter.state = state;
+    if (projectId) filter.projectId = projectId;
+    const jobs = store.listJobs(Object.keys(filter).length > 0 ? filter : undefined);
+
+    // Auto-heal active jobs with null nextRunAt
+    for (const job of jobs) {
+      if (job.state === 'active' && job.nextRunAt === null) {
+        let cronExpr = job.cronExpr;
+        // If cronExpr isn't valid cron, try parsing it as NL
+        let nextRunAt = computeNextRun(cronExpr);
+        if (nextRunAt === null) {
+          const parsed = parseCadence(cronExpr);
+          if (parsed) {
+            cronExpr = parsed.cronExpr;
+            nextRunAt = computeNextRun(cronExpr);
+            if (nextRunAt) store.updateJob(job.id, { cronExpr } as any);
+          }
+        }
+        if (nextRunAt === null && job.triggerType === 'condition') {
+          nextRunAt = Date.now() + job.checkEveryMs;
+        }
+        if (nextRunAt) {
+          store.updateJob(job.id, { nextRunAt });
+          job.nextRunAt = nextRunAt;
+        }
+      }
+    }
+
+    return NextResponse.json({ count: jobs.length, jobs });
+  } catch (error) {
+    console.error('Failed to list prompt jobs:', error);
+    return NextResponse.json(
+      { error: 'Failed to list prompt jobs', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}
+
+/**
+ * POST /api/prompt-jobs
+ * Create a new prompt job.
+ * Body: { name, prompt, cli?, cadence, overlapPolicy?, cancelCheckSec? }
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { name, prompt, agentId, projectId, provider, model, cliArgs, cadence, overlapPolicy, catchUpPolicy, cancelCheckSec, triggerType, condition, checkEveryMs } = body;
+
+    if (!name || !prompt) {
+      return NextResponse.json(
+        { error: 'Missing required fields: name, prompt' },
+        { status: 400 },
+      );
+    }
+
+    // For condition triggers, cadence is optional (uses checkEveryMs instead)
+    const effectiveTriggerType = triggerType ?? 'scheduled';
+    if (effectiveTriggerType === 'scheduled' && !cadence) {
+      return NextResponse.json(
+        { error: 'Missing required field: cadence (required for scheduled triggers)' },
+        { status: 400 },
+      );
+    }
+
+    // cadence can be either a cron expression (from schedule builder) or natural language
+    let cronExpr = '';
+    let cadenceLabel = '';
+    if (cadence) {
+      const parsed = parseCadence(cadence);
+      if (parsed) {
+        cronExpr = parsed.cronExpr;
+        cadenceLabel = parsed.cadence;
+      } else {
+        // Might already be a raw cron expression from the schedule builder
+        cronExpr = cadence;
+        cadenceLabel = cadence;
+      }
+    }
+
+    const store = getPromptJobStore();
+    const job = store.createJob({
+      name,
+      prompt,
+      agentId,
+      projectId,
+      provider: provider ?? 'claude',
+      model,
+      cliArgs,
+      cronExpr: cronExpr || undefined,
+      cadence: cadenceLabel || `every ${Math.round((checkEveryMs ?? 300000) / 60000)}m`,
+      overlapPolicy,
+      catchUpPolicy,
+      cancelCheckSec,
+      triggerType: effectiveTriggerType,
+      condition,
+      checkEveryMs,
+    });
+
+    return NextResponse.json({ job }, { status: 201 });
+  } catch (error) {
+    console.error('Failed to create prompt job:', error);
+    return NextResponse.json(
+      { error: 'Failed to create prompt job', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}

package/cloud-runtime/standalone/app/api/skills/assign/route.ts

@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getAgentSkillBindings, setAgentSkillBindings } from "@/lib/agent-skill-bindings";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const agentId = typeof body.agentId === "string" ? body.agentId.trim() : "";
+    const skillId = typeof body.skillId === "string" ? body.skillId.trim() : "";
+    const repo = typeof body.repo === "string" ? body.repo.trim() : "";
+    const condition = typeof body.condition === "string" ? body.condition.trim() : "";
+
+    if (!agentId || !skillId || !repo) {
+      return NextResponse.json({ error: "agentId, repo, and skillId are required" }, { status: 400 });
+    }
+
+    const existing = await getAgentSkillBindings(agentId);
+    const next = existing.some((binding) => binding.repo === repo && binding.skillId === skillId)
+      ? existing.map((binding) => (binding.repo === repo && binding.skillId === skillId ? { repo, skillId, condition } : binding))
+      : [...existing, { repo, skillId, condition }];
+
+    await setAgentSkillBindings(agentId, next);
+    return NextResponse.json({ ok: true, skillBinding: { repo, skillId, condition } });
+  } catch (error) {
+    console.error("Error assigning skill to agent:", error);
+    return NextResponse.json({ error: "Failed to assign skill to agent" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/skills/available/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listAvailableSkills, listInstalledSkillIds } from "@/lib/skills-library";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const provider = searchParams.get("provider") ?? undefined;
+    return NextResponse.json({
+      ok: true,
+      installed: listInstalledSkillIds(),
+      skills: listAvailableSkills(provider),
+    });
+  } catch (error) {
+    console.error("Error fetching available skills:", error);
+    return NextResponse.json({ error: "Failed to fetch available skills" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/skills/detail/route.ts

@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from "next/server";
+import { fetchSkillDetail } from "@/lib/skills-library";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(request: NextRequest) {
+  const { searchParams } = new URL(request.url);
+  const source = searchParams.get("source")?.trim() ?? "";
+  const skillId = searchParams.get("skillId")?.trim() ?? "";
+
+  if (!source || !skillId) {
+    return NextResponse.json({ error: "source and skillId are required" }, { status: 400 });
+  }
+
+  try {
+    const detail = await fetchSkillDetail(source, skillId);
+    return NextResponse.json({ ok: Boolean(detail), detail });
+  } catch (error) {
+    console.error("Error fetching skill detail:", error);
+    return NextResponse.json({ error: "Failed to fetch skill detail" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/skills/history/route.ts

@@ -0,0 +1,18 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listSkillHistory } from "@/lib/skills-library";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const limit = Number.parseInt(searchParams.get("limit") ?? "50", 10);
+    const provider = searchParams.get("provider") ?? undefined;
+    const history = listSkillHistory(Number.isFinite(limit) ? Math.min(Math.max(limit, 1), 200) : 50, provider);
+    return NextResponse.json({ ok: true, history });
+  } catch (error) {
+    console.error("Error fetching skill history:", error);
+    return NextResponse.json({ error: "Failed to fetch skill history" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/skills/learn/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from "next/server";
+import { installSkill } from "@/lib/skills-library";
+import type { ChatProvider } from "@/lib/types";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const repo = typeof body.repo === "string" ? body.repo.trim() : "";
+    const skillId = typeof body.skillId === "string" ? body.skillId.trim() : "";
+    const providers = Array.isArray(body.providers)
+      ? body.providers.filter((value: unknown): value is ChatProvider => typeof value === "string")
+      : [];
+
+    if (!repo || !skillId) {
+      return NextResponse.json({ error: "repo and skillId are required" }, { status: 400 });
+    }
+
+    const result = installSkill({ repo, skillId, providers });
+    if (!result.ok) {
+      return NextResponse.json({ error: result.error || "Failed to install skill", result }, { status: 409 });
+    }
+
+    return NextResponse.json({ ok: true, result });
+  } catch (error) {
+    console.error("Error installing skill:", error);
+    return NextResponse.json({ error: "Failed to install skill" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/skills/route.ts

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from "next/server";
+import { fetchSkillsCatalog, listAvailableSkills, listInstalledSkillIds } from "@/lib/skills-library";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(_request: NextRequest) {
+  try {
+    const [skills, installedIds, available] = await Promise.all([
+      fetchSkillsCatalog(),
+      Promise.resolve(listInstalledSkillIds()),
+      Promise.resolve(listAvailableSkills()),
+    ]);
+    return NextResponse.json({ skills, installed: installedIds, available });
+  } catch (error) {
+    console.error("Error fetching skills catalog:", error);
+    return NextResponse.json({ error: "Failed to fetch skills catalog" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/skills/unlearn/route.ts

@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from "next/server";
+import { removeSkill } from "@/lib/skills-library";
+import type { ChatProvider } from "@/lib/types";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const skillId = typeof body.skillId === "string" ? body.skillId.trim() : "";
+    const providers = Array.isArray(body.providers)
+      ? body.providers.filter((value: unknown): value is ChatProvider => typeof value === "string")
+      : [];
+
+    if (!skillId) {
+      return NextResponse.json({ error: "skillId is required" }, { status: 400 });
+    }
+
+    const result = removeSkill({ skillId, providers });
+    if (!result.ok) {
+      return NextResponse.json({ error: result.error || "Failed to remove skill", result }, { status: 409 });
+    }
+
+    return NextResponse.json({ ok: true, result });
+  } catch (error) {
+    console.error("Error removing skill:", error);
+    return NextResponse.json({ error: "Failed to remove skill" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/thread-repos/route.ts

@@ -0,0 +1,30 @@
+import { NextRequest } from "next/server";
+import {
+  loadThreadRepoSelections,
+  saveThreadRepoSelections,
+} from "@/lib/history-store";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(request: NextRequest) {
+  const rootMessageId = request.nextUrl.searchParams.get("rootMessageId")?.trim() ?? "";
+  if (!rootMessageId) {
+    return Response.json({ error: "rootMessageId is required" }, { status: 400 });
+  }
+  const repoIds = await loadThreadRepoSelections(rootMessageId);
+  return Response.json({ repoIds });
+}
+
+export async function PUT(request: NextRequest) {
+  const body = await request.json().catch(() => null);
+  if (!body || typeof body !== "object") {
+    return Response.json({ error: "invalid body" }, { status: 400 });
+  }
+  const { rootMessageId, repoIds } = body as { rootMessageId?: string; repoIds?: string[] };
+  if (!rootMessageId || !Array.isArray(repoIds)) {
+    return Response.json({ error: "rootMessageId and repoIds[] required" }, { status: 400 });
+  }
+  await saveThreadRepoSelections(rootMessageId, repoIds);
+  return Response.json({ ok: true });
+}

package/cloud-runtime/standalone/app/automations/page.tsx

@@ -6,8 +6,9 @@ import {
   loadWorkspaceSidebarVisible,
   persistWorkspaceSidebarVisible,
 } from "@/state/uiSettings";
+import { useProjectsWithAgents, useProjects } from "@/hooks/useProjects";
 import "@/styles/workspaceSidebar.css";
-import AutomationsBoard from "@/components/AutomationsBoard";
+import PromptJobBoard from "@/components/PromptJobBoard";
 
 export default function AutomationsPage() {
   const [sidebarVisible, setSidebarVisible] = useState(false);
@@ -24,6 +25,13 @@ export default function AutomationsPage() {
     });
   };
 
+  const {
+    projects,
+    createProject,
+    deleteProject,
+  } = useProjectsWithAgents();
+  const { updateProject } = useProjects();
+
   return (
     <div className="flex h-screen bg-[var(--card-bg)] text-[var(--foreground)]">
       <WorkspaceSidebar
@@ -37,9 +45,13 @@ export default function AutomationsPage() {
         onDeleteThread={() => {}}
         visible={sidebarVisible}
         onToggle={toggleSidebar}
+        projects={projects}
+        onCreateProject={createProject}
+        onUpdateProject={updateProject}
+        onDeleteProject={deleteProject}
       />
-      <div className="flex-1 min-w-0 overflow-auto mt-4">
-        <AutomationsBoard />
+      <div className="flex-1 min-w-0 overflow-auto">
+        <PromptJobBoard />
       </div>
     </div>
   );

package/cloud-runtime/standalone/app/execution-graph/page.tsx

@@ -260,7 +260,7 @@ export default function ExecutionGraphPage() {
 
     const renderBoard = () => (
         <div className="flex flex-col h-screen bg-[var(--secondary)] font-sans text-[var(--foreground)] overflow-hidden">
-            <header className="flex items-center justify-between px-8 py-5 bg-[var(--card-bg)] border-b border-[var(--border)]">
+            <header className="desktop-titlebar flex items-center justify-between px-8 py-5 bg-[var(--card-bg)] border-b border-[var(--border)]">
                 <div className="flex items-center gap-4">
                     <div className="w-12 h-12 bg-blue-600 rounded-xl flex items-center justify-center text-white font-black text-2xl shadow-xl shadow-blue-200 transform -rotate-3 hover:rotate-0 transition-transform cursor-pointer">
                         ag
@@ -316,7 +316,7 @@ export default function ExecutionGraphPage() {
 
         return (
             <div className="flex flex-col h-screen bg-[var(--card-bg)] font-sans text-[var(--foreground)] overflow-hidden">
-                <header className="flex items-center px-6 py-4 border-b border-[var(--border)] bg-[var(--card-bg)] z-50 shadow-sm">
+                <header className="desktop-titlebar flex items-center px-6 py-4 border-b border-[var(--border)] bg-[var(--card-bg)] z-50 shadow-sm">
                     <button
                         onClick={closeTask}
                         className="p-2.5 hover:bg-[var(--item-hover-bg)] rounded-xl transition-colors mr-4 text-[var(--app-shell-soft-text)] hover:text-[var(--foreground)]"

package/cloud-runtime/standalone/app/globals.css

@@ -1,5 +1,7 @@
 @import "tailwindcss";
 
+@custom-variant dark (&:where(.dark, .dark *));
+
 :root {
   color-scheme: light;
   /* Core palette - Clean, professional */

package/cloud-runtime/standalone/app/layout.tsx

@@ -44,7 +44,7 @@ export default function RootLayout({
       <head>
         <script dangerouslySetInnerHTML={{ __html: themeBootstrapScript }} />
       </head>
-      <body className={`${geistSans.variable} ${geistMono.variable} antialiased h-screen overflow-hidden bg-[var(--background)] text-[var(--foreground)] selection:bg-[var(--primary)] selection:text-[var(--primary-foreground)]`}>
+      <body className={`${geistSans.variable} ${geistMono.variable} antialiased min-h-screen overflow-x-hidden overflow-y-auto bg-[var(--background)] text-[var(--foreground)] selection:bg-[var(--primary)] selection:text-[var(--primary-foreground)]`}>
         <StartupGuard>{children}</StartupGuard>
         <GoogleAnalytics />
         <PostHogAnalytics />

package/cloud-runtime/standalone/app/projects/[slug]/automations/page.tsx

@@ -0,0 +1,17 @@
+"use client";
+
+import { use } from "react";
+import { useProjects } from "@/hooks/useProjects";
+import PromptJobBoard from "@/components/PromptJobBoard";
+
+export default function ProjectAutomationsPage({
+  params,
+}: {
+  params: Promise<{ slug: string }>;
+}) {
+  const { slug } = use(params);
+  const { projects } = useProjects();
+  const project = projects.find((p) => p.slug === slug);
+
+  return <PromptJobBoard projectId={project?.id} />;
+}