diff --git a/.github/scripts/overnight-watch.mjs b/.github/scripts/overnight-watch.mjs
new file mode 100755
index 000000000..5fc2b1c48
--- /dev/null
+++ b/.github/scripts/overnight-watch.mjs
@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const config = {
+  repoOwner: process.env.REPO_OWNER || "Fearvox",
+  repoName: process.env.REPO_NAME || "EverOS",
+  upstreamRepo: process.env.UPSTREAM_REPO || "EverMind-AI/EverOS",
+  watchBranch:
+    process.env.WATCH_BRANCH || "codex-watch-overnight-2026-05-13",
+  ownerTimezone: process.env.OWNER_TIMEZONE || "America/Los_Angeles",
+  linearTeamId:
+    process.env.LINEAR_TEAM_ID || "233391d6-ec9e-4aa8-b534-16a221b8119a",
+  linearProjectId:
+    process.env.LINEAR_PROJECT_ID || "39aa3865-345c-4313-9dc0-ab3b509c5d21",
+  createTrackingIssue:
+    (process.env.CREATE_TRACKING_ISSUE || "false").toLowerCase() === "true",
+  githubToken: process.env.GITHUB_TOKEN || process.env.GH_TOKEN || "",
+  linearApiKey: process.env.LINEAR_API_KEY || "",
+};
+
+const repoSlug = `${config.repoOwner}/${config.repoName}`;
+const recentWindowHours = Number(process.env.WATCH_WINDOW_HOURS || 24);
+const since = new Date(Date.now() - recentWindowHours * 60 * 60 * 1000);
+const now = new Date();
+
+function run(command, args, options = {}) {
+  const result = execFileSync(command, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", options.inheritStderr ? "inherit" : "pipe"],
+    env: {
+      ...process.env,
+      GH_TOKEN: config.githubToken || process.env.GH_TOKEN,
+    },
+  });
+  return result.trim();
+}
+
+function tryRun(command, args, fallback = "") {
+  try {
+    return run(command, args);
+  } catch (error) {
+    return fallback;
+  }
+}
+
+function ghJson(endpoint) {
+  const output = run("gh", [
+    "api",
+    "-H",
+    "Accept: application/vnd.github+json",
+    endpoint,
+  ]);
+  return JSON.parse(output);
+}
+
+function ensureRemote(name, url) {
+  const remotes = tryRun("git", ["remote"]).split("\n").filter(Boolean);
+  if (!remotes.includes(name)) {
+    run("git", ["remote", "add", name, url]);
+  }
+}
+
+function fetchGitState() {
+  ensureRemote("upstream", `https://github.com/${config.upstreamRepo}.git`);
+  tryRun("git", ["fetch", "origin", "--prune"], "");
+  tryRun("git", ["fetch", "upstream", "main", "--prune"], "");
+
+  const forkHead = tryRun("git", ["rev-parse", "--short", "origin/main"], "unknown");
+  const upstreamHead = tryRun(
+    "git",
+    ["rev-parse", "--short", "upstream/main"],
+    "unknown",
+  );
+  const counts = tryRun(
+    "git",
+    ["rev-list", "--left-right", "--count", "origin/main...upstream/main"],
+    "0\t0",
+  )
+    .split(/\s+/)
+    .map((value) => Number(value));
+
+  const watchBranchSha = tryRun(
+    "git",
+    ["ls-remote", "--heads", "origin", config.watchBranch],
+    "",
+  )
+    .split(/\s+/)[0]
+    ?.slice(0, 12);
+
+  return {
+    forkHead,
+    upstreamHead,
+    forkAhead: counts[0] || 0,
+    forkBehind: counts[1] || 0,
+    watchBranchSha: watchBranchSha || "",
+  };
+}
+
+function fetchGitHubState() {
+  const runs = ghJson(
+    `/repos/${repoSlug}/actions/runs?per_page=50&status=completed`,
+  ).workflow_runs || [];
+  const failedRuns = runs
+    .filter((runInfo) => new Date(runInfo.created_at) >= since)
+    .filter((runInfo) =>
+      ["failure", "cancelled", "timed_out"].includes(runInfo.conclusion),
+    )
+    .slice(0, 10);
+
+  const upstreamPulls = ghJson(
+    `/repos/${config.upstreamRepo}/pulls?state=open&sort=updated&direction=desc&per_page=30`,
+  )
+    .filter((pull) => new Date(pull.updated_at) >= since)
+    .slice(0, 10);
+
+  const forkPulls = ghJson(
+    `/repos/${repoSlug}/pulls?state=open&sort=updated&direction=desc&per_page=30`,
+  )
+    .filter((pull) => new Date(pull.updated_at) >= since)
+    .slice(0, 10);
+
+  return { failedRuns, upstreamPulls, forkPulls };
+}
+
+function lineForPull(pull) {
+  return `- #${pull.number} ${pull.title} (${pull.user.login}, updated ${pull.updated_at})`;
+}
+
+function lineForRun(runInfo) {
+  return `- ${runInfo.name}: ${runInfo.conclusion} (${runInfo.html_url})`;
+}
+
+function renderReport(gitState, githubState) {
+  const findings = [];
+
+  if (!gitState.watchBranchSha) {
+    findings.push(`Watch branch is not on origin: ${config.watchBranch}`);
+  }
+  if (gitState.forkBehind > 0) {
+    findings.push(`Fork main is behind upstream/main by ${gitState.forkBehind} commit(s).`);
+  }
+  if (githubState.failedRuns.length > 0) {
+    findings.push(
+      `${githubState.failedRuns.length} completed workflow run(s) failed in the last ${recentWindowHours}h.`,
+    );
+  }
+
+  const verdict = findings.length > 0 ? "FLAG" : "PASS";
+  const localNow = now.toLocaleString("en-US", {
+    timeZone: config.ownerTimezone,
+    hour12: false,
+  });
+
+  return {
+    verdict,
+    body: [
+      `# Overnight Fork Watch: ${verdict}`,
+      "",
+      `Generated: ${now.toISOString()} (${config.ownerTimezone}: ${localNow})`,
+      `Repository: ${repoSlug}`,
+      `Upstream: ${config.upstreamRepo}`,
+      `Watch branch: \`${config.watchBranch}\``,
+      "",
+      "## Drift",
+      "",
+      `- origin/main: \`${gitState.forkHead}\``,
+      `- upstream/main: \`${gitState.upstreamHead}\``,
+      `- fork ahead: ${gitState.forkAhead}`,
+      `- fork behind: ${gitState.forkBehind}`,
+      `- watch branch on origin: ${
+        gitState.watchBranchSha ? `yes (\`${gitState.watchBranchSha}\`)` : "no"
+      }`,
+      "",
+      "## Findings",
+      "",
+      findings.length ? findings.map((item) => `- ${item}`).join("\n") : "- None.",
+      "",
+      `## Fork Workflow Failures (${recentWindowHours}h)`,
+      "",
+      githubState.failedRuns.length
+        ? githubState.failedRuns.map(lineForRun).join("\n")
+        : "- None.",
+      "",
+      `## Upstream PRs Updated (${recentWindowHours}h)`,
+      "",
+      githubState.upstreamPulls.length
+        ? githubState.upstreamPulls.map(lineForPull).join("\n")
+        : "- None.",
+      "",
+      `## Fork PRs Updated (${recentWindowHours}h)`,
+      "",
+      githubState.forkPulls.length
+        ? githubState.forkPulls.map(lineForPull).join("\n")
+        : "- None.",
+      "",
+      "## Operator Notes",
+      "",
+      "- This issue is safe for public tracking: no local paths, host/IP values, or secrets are included.",
+      "- A GitHub issue created by `GITHUB_TOKEN` does not trigger secondary workflows, so this watch mirrors to Linear directly when `LINEAR_API_KEY` is available.",
+    ].join("\n"),
+  };
+}
+
+function ensureLabel(name, color, description) {
+  tryRun("gh", [
+    "label",
+    "create",
+    name,
+    "--repo",
+    repoSlug,
+    "--color",
+    color,
+    "--description",
+    description,
+  ]);
+}
+
+function issueHasLinearMarker(issueNumber) {
+  const comments = ghJson(`/repos/${repoSlug}/issues/${issueNumber}/comments?per_page=100`);
+  return comments.some((comment) => comment.body.includes("Linear:"));
+}
+
+async function mirrorToLinear(issueNumber, title, body) {
+  if (!config.linearApiKey || issueHasLinearMarker(issueNumber)) {
+    return;
+  }
+
+  const mutation = `
+    mutation IssueCreate($input: IssueCreateInput!) {
+      issueCreate(input: $input) {
+        success
+        issue { id identifier url }
+      }
+    }
+  `;
+
+  const response = await fetch("https://api.linear.app/graphql", {
+    method: "POST",
+    headers: {
+      Authorization: config.linearApiKey,
+      "Content-Type": "application/json",
+      "x-apollo-operation-name": "IssueCreate",
+    },
+    body: JSON.stringify({
+      query: mutation,
+      variables: {
+        input: {
+          title,
+          description: [
+            `**Source**: https://github.com/${repoSlug}/issues/${issueNumber}`,
+            "",
+            "---",
+            "",
+            body,
+          ].join("\n"),
+          teamId: config.linearTeamId,
+          projectId: config.linearProjectId,
+          priority: 3,
+        },
+      },
+    }),
+  });
+
+  const data = await response.json();
+  if (!response.ok || data.errors || !data?.data?.issueCreate?.success) {
+    ensureLabel("sync-failed", "D93F0B", "Linear sync workflow failed for this issue");
+    tryRun("gh", [
+      "issue",
+      "edit",
+      String(issueNumber),
+      "--repo",
+      repoSlug,
+      "--add-label",
+      "sync-failed",
+    ]);
+    throw new Error(`Linear API error: ${JSON.stringify(data)}`);
+  }
+
+  const linearIssue = data.data.issueCreate.issue;
+  const marker = `Linear: [${linearIssue.identifier}](${linearIssue.url})\n\n_Auto-created by overnight-watch._`;
+  run("gh", ["issue", "comment", String(issueNumber), "--repo", repoSlug, "--body", marker]);
+}
+
+function findExistingIssue(title) {
+  const issues = JSON.parse(
+    run("gh", [
+      "issue",
+      "list",
+      "--repo",
+      repoSlug,
+      "--state",
+      "open",
+      "--label",
+      "overnight-watch",
+      "--json",
+      "number,title",
+      "--limit",
+      "20",
+    ]),
+  );
+  return issues.find((issue) => issue.title === title);
+}
+
+async function createOrUpdateTrackingIssue(report) {
+  if (!config.createTrackingIssue || report.verdict === "PASS") {
+    return;
+  }
+
+  ensureLabel("overnight-watch", "1D76DB", "Automated overnight fork watch");
+  ensureLabel("tracking", "5319E7", "Long-lived tracking item");
+  ensureLabel("pr-mirror", "0E8A16", "Mirrored into Linear or Slack tracking");
+
+  const date = now.toISOString().slice(0, 10);
+  const title = `[watch] Overnight fork patrol: ${date}`;
+  const existing = findExistingIssue(title);
+  const tempDir = mkdtempSync(join(tmpdir(), "everos-watch-"));
+  const bodyFile = join(tempDir, "body.md");
+  writeFileSync(bodyFile, report.body);
+
+  if (existing) {
+    run("gh", [
+      "issue",
+      "comment",
+      String(existing.number),
+      "--repo",
+      repoSlug,
+      "--body-file",
+      bodyFile,
+    ]);
+    await mirrorToLinear(existing.number, title, report.body);
+    return;
+  }
+
+  const created = run("gh", [
+    "issue",
+    "create",
+    "--repo",
+    repoSlug,
+    "--title",
+    title,
+    "--body-file",
+    bodyFile,
+    "--label",
+    "overnight-watch",
+    "--label",
+    "tracking",
+    "--label",
+    "pr-mirror",
+  ]);
+  const match = created.match(/\/issues\/(\d+)/);
+  if (match) {
+    await mirrorToLinear(Number(match[1]), title, report.body);
+  }
+}
+
+async function main() {
+  const gitState = fetchGitState();
+  const githubState = fetchGitHubState();
+  const report = renderReport(gitState, githubState);
+  console.log(report.body);
+  await createOrUpdateTrackingIssue(report);
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index a8eec180d..aa74ce5fa 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -103,6 +103,9 @@ jobs:
                   banner_match = re.search(r"\[!\[[^\]]*\]\([^)]+\)\]\(([^)]+)\)", cell)
                   primary_match = re.search(r"^\[(?:Code|Plugin|Live Demo)\]\(([^)]+)\)", cell, flags=re.M)
 
+                  if "Coming soon" in cell and not primary_match:
+                      continue
+
                   if not banner_match:
                       failures.append(f"{path}: {title}: missing linked banner")
                   elif not primary_match:
diff --git a/.github/workflows/overnight-watch.yml b/.github/workflows/overnight-watch.yml
new file mode 100644
index 000000000..3a0e84897
--- /dev/null
+++ b/.github/workflows/overnight-watch.yml
@@ -0,0 +1,56 @@
+name: Fork overnight watch
+
+on:
+  schedule:
+    # 02:13 America/Los_Angeles during daylight time. GitHub cron is UTC.
+    - cron: "13 9 * * *"
+  workflow_dispatch:
+    inputs:
+      create_tracking_issue:
+        description: "Open/update a tracking issue when the watch verdict is FLAG"
+        required: false
+        type: boolean
+        default: true
+      watch_branch:
+        description: "Fork playground branch to verify on origin"
+        required: false
+        type: string
+        default: "codex-watch-overnight-2026-05-13"
+
+permissions:
+  actions: read
+  contents: read
+  issues: write
+  pull-requests: read
+
+concurrency:
+  group: overnight-watch-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  watch:
+    if: github.repository == 'Fearvox/EverOS'
+    runs-on: ubuntu-latest
+    env:
+      REPO_OWNER: ${{ vars.REPO_OWNER || 'Fearvox' }}
+      REPO_NAME: ${{ vars.REPO_NAME || 'EverOS' }}
+      UPSTREAM_REPO: EverMind-AI/EverOS
+      WATCH_BRANCH: ${{ inputs.watch_branch || vars.WATCH_BRANCH || 'codex-watch-overnight-2026-05-13' }}
+      OWNER_TIMEZONE: ${{ vars.OWNER_TIMEZONE || 'America/Los_Angeles' }}
+      LINEAR_TEAM_ID: ${{ vars.LINEAR_TEAM_ID || '233391d6-ec9e-4aa8-b534-16a221b8119a' }}
+      LINEAR_PROJECT_ID: ${{ vars.LINEAR_PROJECT_ID || '39aa3865-345c-4313-9dc0-ab3b509c5d21' }}
+      LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
+      GH_TOKEN: ${{ github.token }}
+      GITHUB_TOKEN: ${{ github.token }}
+      CREATE_TRACKING_ISSUE: ${{ inputs.create_tracking_issue || github.event_name == 'schedule' }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Run overnight watch
+        run: node .github/scripts/overnight-watch.mjs
diff --git a/docs/fork-playground/overnight-watch.md b/docs/fork-playground/overnight-watch.md
new file mode 100644
index 000000000..379fd21b8
--- /dev/null
+++ b/docs/fork-playground/overnight-watch.md
@@ -0,0 +1,54 @@
+# Overnight Fork Watch
+
+This fork can move fast, but the upstream feed should stay boring and auditable.
+The overnight watch is a small GitHub Actions patrol for `Fearvox/EverOS`.
+
+## What It Checks
+
+- `origin/main` drift against `EverMind-AI/EverOS` `upstream/main`.
+- Whether the active playground branch exists on the fork:
+  `codex-watch-overnight-2026-05-13`.
+- Failed, cancelled, or timed-out fork workflow runs in the last 24 hours.
+- Upstream and fork pull requests updated in the last 24 hours.
+
+## Tracking Behavior
+
+The workflow prints a public-safe report on every run. If the verdict is `FLAG`,
+it opens or updates a GitHub issue labeled:
+
+- `overnight-watch`
+- `tracking`
+- `pr-mirror`
+
+Issues created by `GITHUB_TOKEN` do not trigger secondary workflows. Because of
+that, the watch mirrors the tracking issue to Linear directly when
+`LINEAR_API_KEY` is available. The target Linear team/project are:
+
+- Team: `233391d6-ec9e-4aa8-b534-16a221b8119a`
+- Project: `39aa3865-345c-4313-9dc0-ab3b509c5d21`
+
+A `FLAG` verdict does not fail the watch workflow by itself. Runtime errors
+still fail the workflow, but expected drift or downstream failures are reported
+through the tracking issue so the watch does not poison its own next run.
+
+## Manual Run
+
+```bash
+REPO_OWNER=Fearvox \
+REPO_NAME=EverOS \
+WATCH_BRANCH=codex-watch-overnight-2026-05-13 \
+OWNER_TIMEZONE=America/Los_Angeles \
+LINEAR_TEAM_ID=233391d6-ec9e-4aa8-b534-16a221b8119a \
+LINEAR_PROJECT_ID=39aa3865-345c-4313-9dc0-ab3b509c5d21 \
+CREATE_TRACKING_ISSUE=false \
+node .github/scripts/overnight-watch.mjs
+```
+
+Set `CREATE_TRACKING_ISSUE=true` only when you want the local run to mutate
+GitHub issues.
+
+## Public-Surface Hygiene
+
+Reports intentionally avoid local absolute paths, host/IP values, token names
+beyond the required GitHub secret names, and operator-only commands. They should
+be safe to show in Discord or a screen share.