AI-Automation-Library — Build Prompts

Scaffold a new agent-runner job called `album-cover-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Daily AI Meme job. The job runs every Friday at 07:00 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry. Each run: use Codex (`codex exec`) with the built-in `image_generation` tool (gpt-image-2) to generate one square album-cover image (1024×1024). First have Codex do a brief WebSearch for the week's most-talked-about music release, artist, or genre trend; then prompt it to design a striking album cover that references that theme — artist name and album title must be baked into the artwork as styled typography. Output three files into `My-Library/Images/Album-Covers/<Month_YYYY>/album-cover-<slug>_<date>/`: `album-cover-image.png`, `metadata.md` (date, theme, artist ref, model), `prompt.md` (the full generation prompt). Commit and push to `mike_desktop` on the AI-Automation-Library remote. Send an AgentMail email to Mike with the image attached and a one-sentence description of the theme. Wire the PowerShell wrapper at `/tasks/jobs/run_album-cover-of-the-week.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `infographic-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for structure but using a Claude + nanobanana MCP run instead of the Gemini SDK. The job runs every Thursday at 08:00 via cron + watchdog. Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to find the week's most data-rich news story (economics, science, health, or tech — rotate weekly), (2) drafts a concise data narrative with 4–6 key statistics or facts, (3) calls the nanobanana `generate_image` tool with a detailed infographic layout prompt — tall format (2:3 ratio), clean sans-serif typography, data callouts, bold color blocks, title and source line baked in. Output `cover-image.png`, `metadata.md` (date, topic, data points, model), `prompt.md` into `My-Library/Images/Infographics/<Month_YYYY>/infographic-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the image attached and the 4–6 bullet data points in the body. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `brand-identity-pack-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Icon Packs job structure (Gemini SDK `gemini-3.1-flash-image`). The job runs every Wednesday at 07:00 via cron + watchdog. Each run: use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate a cohesive brand identity pack for a fictional company — choose a new industry niche each week (e.g., biotech, artisan food, fintech, space tourism) by rotating through a list defined in the script. Generate four images: (1) primary logo on white background, (2) inverted/dark-mode logo variant, (3) square icon/favicon crop, (4) a brand-card mockup showing the logo in context (business card or app splash). Save all four as `cover-image.png`, `logo-dark.png`, `logo-icon.png`, `brand-card.png` inside `My-Library/Images/Brand-Identity-Packs/<Month_YYYY>/brand-<slug>_<date>/`, plus `metadata.md` (date, niche, color palette description, model) and `prompt.md`. Commit and push to `mike_desktop`. Send an AgentMail email with all four images attached. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-sticker-pack` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Icon Packs job (Gemini SDK `gemini-3.1-flash-image`). The job runs every Saturday at 07:00 via cron + watchdog. Each run: pick a theme from a rotating list in the script (animals, food, tech, emotions, space, retro, sports, nature — one per week cycling). Use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate (a) one composite 3×2 sticker-sheet image showing all six stickers on a white background, and (b) six individual sticker images with transparent/white backgrounds and bold outlines in a chibi/cartoon style. Save `cover-image.png` + `sticker-01.png` through `sticker-06.png` plus `metadata.md` (date, theme, model) and `prompt.md` into `My-Library/Images/Sticker-Packs/<Month_YYYY>/stickers-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the sheet image attached and the theme in the subject line. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `daily-coloring-page` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Poster job structure (Gemini SDK `gemini-3.1-flash-image`). The job runs daily at 05:30 via cron + watchdog. Each run: pick today's theme from a rotating category list in the script (fantasy landscapes, animals, mandalas, architecture, underwater scenes, space, botanical, mythological creatures — cycling daily). Use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate a single A4-portrait-ratio (3:4) black-and-white line-art coloring page — clean thick outlines, no fills, no shading, white background, intricate detail suitable for adult or family coloring. Save `cover-image.png`, `metadata.md` (date, theme, model, prompt summary), and `prompt.md` into `My-Library/Images/Coloring-Book/<Month_YYYY>/coloring-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the image attached and the theme in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `news-movie-poster` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily AI Meme job (Codex gpt-image-2). The job runs every Sunday at 07:00 via cron + watchdog. Each run: invoke `codex exec` with a prompt that (1) uses built-in WebSearch to find the single biggest news story of the past week, (2) reimagines it as a Hollywood movie — invent a punchy title, a one-line tagline, and three fictional "starring" names based on real figures in the story, (3) generates a dramatic 2:3 movie-poster image with gpt-image-2 where the title, tagline, and credits are typeset directly into the artwork in classic movie-poster style. Output `cover-image.png`, `metadata.md` (date, news story headline, invented title/tagline, model), `prompt.md` into `My-Library/Images/News-Movie-Posters/<Month_YYYY>/poster-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the poster attached and the invented title + real story headline in the subject line. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `daily-pixel-art` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Poster job (Gemini SDK `gemini-3.1-flash-image`). The job runs daily at 04:30 via cron + watchdog. Each run: pick a scene category from a rotating list in the script (cozy interiors, cityscapes at night, fantasy villages, retro game levels, space stations, seaside towns, forest clearings, futuristic labs — cycling daily). Use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate a 1:1 pixel-art scene — 16-bit / SNES-era aesthetic, limited palette of 16–32 colors, visible pixel grid, rich detail and atmospheric lighting. Save `cover-image.png`, `metadata.md` (date, scene category, palette description, model), and `prompt.md` into `My-Library/Images/Pixel-Art/<Month_YYYY>/pixel-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the image attached and the scene category in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-isometric-world` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Icon Packs job (Gemini SDK `gemini-3.1-flash-image`). The job runs every Tuesday at 07:00 via cron + watchdog. Each run: select a world theme from a rotating list in the script (medieval castle, space colony, underwater city, jungle treehouse village, cyberpunk alley, arctic research station, hobbit-hole hamlet, volcano forge, cloud kingdom — one per week cycling). Use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate a detailed isometric tiny-world illustration — clean vector-adjacent style, soft shadows, pastel or jewel-tone palette, floating island or contained diorama composition, square canvas. Save `cover-image.png`, `metadata.md` (date, theme, palette, model), `prompt.md` into `My-Library/Images/Isometric-Worlds/<Month_YYYY>/iso-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the image attached and the world theme in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-wallpaper-pack` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Image Prompt Packs job (Gemini SDK `gemini-3.1-flash-image`, multi-image per run). The job runs every Sunday at 06:00 via cron + watchdog. Each run: pick a theme from a rotating list in the script (aurora borealis, deep ocean, macro nature, abstract geometry, retro synthwave, misty mountains, neon cityscape, ancient ruins, golden-hour desert — cycling weekly). Use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate two crops of the same composition: a 16:9 widescreen desktop wallpaper (`wallpaper-desktop.png`) and a 9:16 portrait mobile wallpaper (`wallpaper-mobile.png`) — photorealistic or painterly depending on theme, high visual richness, no text. Save both images plus `metadata.md` (date, theme, model, aspect ratios) and `prompt.md` into `My-Library/Images/Wallpaper-Packs/<Month_YYYY>/wallpaper-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with both images attached and the theme in the subject line. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `daily-tarot-card` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily AI Meme job (Codex gpt-image-2). The job runs daily at 05:00 via cron + watchdog. Maintain a state file at `/tasks/jobs/state/tarot_card_index.json` that tracks which card number (0–77, covering Major and Minor Arcana in sequence) is next; each run increments the counter. Use `codex exec` with `image_generation` (gpt-image-2) to generate the next card in a coherent custom tarot deck: a 2:3.5 vertical card with ornate illustrated artwork in a consistent Art Nouveau / mystical style, the card title typeset at the top, and the Roman numeral or pip symbol at the bottom — text must be baked into the artwork. Output `cover-image.png`, `metadata.md` (date, card name, number, arcana type, model), `prompt.md` into `My-Library/Images/Tarot-Deck/<Month_YYYY>/card-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the card image attached and the card name + number in the subject. Validate one real artifact (card 0 — The Fool) end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-historical-diptych` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure but using a Claude + nanobanana MCP run. The job runs every Wednesday at 08:00 via cron + watchdog. Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to pick a historically significant location, technology, or cultural phenomenon that has transformed dramatically over time (rotate through cities, inventions, fashion, transportation, communication — one domain per week), (2) drafts a brief "then vs now" narrative (two 2–3 sentence descriptions: historical state ~100 years ago, current state), (3) calls nanobanana `generate_image` to create a wide 2:1 landscape diptych — left panel shows the historical scene, right panel shows the modern equivalent, a thin divider line separates them, "THEN" and "NOW" labels plus the subject name are baked in as clean typographic overlays. Output `cover-image.png`, `metadata.md` (date, subject, time periods, domain, model), `prompt.md` into `My-Library/Images/Historical-Diptychs/<Month_YYYY>/diptych-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the diptych attached and the subject + time span in the subject line. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-trading-card-set` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily AI Meme job (Codex gpt-image-2). The job runs every Friday at 08:00 via cron + watchdog. Maintain a state file at `/tasks/jobs/state/trading_card_series.json` tracking the current series theme and card count; rotate the series theme every 4 weeks (AI Pioneers → Mythological Beasts → Retro Tech Icons → Extreme Weather Events — cycling). Each run: invoke `codex exec` with `image_generation` (gpt-image-2) to generate three trading cards as separate images — each card is a 2.5:3.5 portrait with a distinct illustrated character or subject, a card name, a rarity badge (Common / Rare / Legendary), and 3 numeric stats (e.g., Power / Speed / Intelligence) all typeset directly into the card artwork in a TCG style with colored borders (bronze/silver/gold per rarity). Save `card-01.png`, `card-02.png`, `card-03.png`, `metadata.md` (date, series, card names, rarities, model), `prompt.md` into `My-Library/Images/Trading-Cards/<Month_YYYY>/cards-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with all three card images attached and the series + card names in the body. Validate one real artifact end-to-end (generate the first three cards of series 1) before scheduling.

Scaffold `weekly-product-mockup-set` as an agent-runner job using the Daily Icon Packs Gemini SDK batch pattern. Run Tuesdays at 06:45 with cron + watchdog. Each run chooses a rotating product niche (SaaS app, coffee brand, outdoor gear, cosmetics, indie game, smart-home device, cookbook, fitness program) and generates five cohesive mockups: hero packaging, website hero, social ad, app/store tile, and lifestyle scene. Save `mockup-01.png` through `mockup-05.png`, `metadata.md` (date, niche, palette, model), and `prompt.md` under `My-Library/Images/Product-Mockups/<Month_YYYY>/mockups-<slug>_<date>/`. Commit/push `mike_desktop`, email the five images, and validate one real run before scheduling.

Scaffold `daily-scientific-diagram` as an agent-runner Codex gpt-image-2 job. Run daily at 05:45 with cron + watchdog. Rotate through biology, physics, astronomy, geology, chemistry, engineering, and medicine topics; use built-in WebSearch to verify the concept, then generate one clean 16:9 labeled diagram with readable title, arrows, labels, and source note baked into the image. Save `cover-image.png`, `metadata.md` (date, topic, source URLs, model), and `prompt.md` in `My-Library/Images/Scientific-Diagrams/<Month_YYYY>/diagram-<slug>_<date>/`. Commit/push, email the diagram plus three key facts, and validate one real artifact.

Scaffold `weekly-architecture-concept` as an agent-runner Claude + nanobanana job. Run Mondays at 07:20 with cron + watchdog. Each run rotates a building type (micro cabin, library, greenhouse, transit station, museum, school, tiny home, civic plaza), researches one relevant design precedent with WebSearch, then generates a 3-panel concept sheet: exterior view, interior vignette, and floor-plan-style massing sketch, all in one clean presentation image. Save `cover-image.png`, `metadata.md` (date, building type, precedent, design notes, model), and `prompt.md`; commit/push, email the image, and validate end-to-end.

Add a new image collection called "Technology Milestones" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Technology-Milestones/ with: README.md, Prompts/generate-technology-milestones-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Technology-Milestones_<YYYY>.png". (3) Each run advances the collection by one year: research that year's defining consumer tech, internet, AI, cybersecurity, hardware, and platform shifts with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — clean editorial scene with screens, devices, data centers, app-like UI shapes, and newspaper-style labels; avoid exact logos and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateTechnologyMilestones flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.
(Already live — included as a reference example of the collection pattern.)

Add a new image collection called "AI History Timeline" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/AI-History-Timeline/ with: README.md, Prompts/generate-ai-history-timeline-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "AI-History-Timeline_<YYYY>.png". (3) Each run advances the collection by one year: research that year's AI progress — model releases, research breakthroughs, open-source moments, product launches, policy milestones, public adoption — with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — futurist editorial art grounded in concrete artifacts: papers, benchmarks, chat windows, robots, GPUs, cloud consoles, assistants, regulation documents; avoid exact logos and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateAIHistoryTimeline flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Cybersecurity Incidents" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Cybersecurity-Incidents/ with: README.md, Prompts/generate-cybersecurity-incidents-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Cybersecurity-Incidents_<YYYY>.png". (3) Each run advances the collection by one year: research that year's most important breaches, ransomware waves, vulnerabilities, supply-chain attacks, policy changes, and defensive milestones with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — respectful security-magazine style with symbolic locks, server rooms, warning dashboards, phishing envelopes, court documents, and incident-response scenes; no gore, panic, or victim mockery; avoid exact logos and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateCybersecurityIncidents flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Space Exploration" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Space-Exploration/ with: README.md, Prompts/generate-space-exploration-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Space-Exploration_<YYYY>.png". (3) Each run advances the collection by one year: research that year's major launches, Mars missions, telescopes, spacecraft, private space milestones, planetary discoveries, and notable astronomy events with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — cinematic but illustrated: rockets, mission-control rooms, planets, rovers, satellites, astronauts, telescopes, and night-sky discoveries in one cohesive scene; avoid exact logos and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateSpaceExploration flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Movie Yearbooks" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Movie-Yearbooks/ with: README.md, Prompts/generate-movie-yearbooks-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Movie-Yearbooks_<YYYY>.png". (3) Each run advances the collection by one year: research that year's biggest films, awards themes, box-office trends, animation moments, franchise events, and streaming shifts with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — a fictional cinema lobby or magazine-cover montage with symbolic costumes, props, genres, marquees, and short readable movie-title references; avoid exact actor likenesses and copyrighted characters, avoid exact logos; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateMovieYearbooks flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Music Yearbooks" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Music-Yearbooks/ with: README.md, Prompts/generate-music-yearbooks-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Music-Yearbooks_<YYYY>.png". (3) Each run advances the collection by one year: research that year's major albums, tours, genre shifts, awards, festivals, viral songs, and music-business changes with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — concert-poster meets editorial montage: stages, instruments, crowds, headphones, streaming interfaces, vinyl, award trophies, and genre-specific motifs; avoid photorealistic artist likenesses, exact logos, and copyrighted characters; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateMusicYearbooks flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.
(Already live — included as a reference example of the collection pattern.)

Add a new image collection called "Video Game History" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Video-Game-History/ with: README.md, Prompts/generate-video-game-history-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Video-Game-History_<YYYY>.png". (3) Each run advances the collection by one year: research that year's console launches, landmark games, studio shifts, esports moments, handhelds, mobile gaming, streaming, and platform wars with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — arcade/editorial cartoon style with controllers, generic screens, pixel-art references, handhelds, esports stages, and fictionalized game scenes; avoid exact copyrighted characters, exact logos, and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateVideoGameHistory flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Sports Champions" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Sports-Champions/ with: README.md, Prompts/generate-sports-champions-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Sports-Champions_<YYYY>.png". (3) Each run advances the collection by one year: research that year's championship winners and memorable moments across NFL, NBA, MLB, NHL, NCAA, soccer, tennis, golf, and the Olympics with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — sports-page montage with stadiums, courts, fields, trophies, scoreboards, confetti, generic uniforms, city names, and readable winner labels; no official team logos, no exact athlete likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateSportsChampions flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Business & Market Moments" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Business-Market-Moments/ with: README.md, Prompts/generate-business-market-moments-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Business-Market-Moments_<YYYY>.png". (3) Each run advances the collection by one year: research that year's IPOs, crashes, acquisitions, bankruptcies, major product launches, labor stories, retail shifts, crypto cycles, and company pivots with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — financial-newspaper style with stock tickers, storefronts, factories, boardrooms, product shelves, trading floors, charts, and court/regulatory documents; avoid exact logos and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateBusinessMarketMoments flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Climate & Weather Events" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Climate-Weather-Events/ with: README.md, Prompts/generate-climate-weather-events-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Climate-Weather-Events_<YYYY>.png". (3) Each run advances the collection by one year: research that year's major climate science findings, extreme weather events, energy transitions, conservation stories, and environmental policy changes with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — respectful environmental editorial art with maps, thermometers, storm systems, firefighters, wind farms, flooded streets, drought landscapes, scientific charts, and community-recovery scenes; no gore or panic visuals; avoid exact logos and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateClimateWeatherEvents flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Food Trends & Culinary History" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Food-Trends/ with: README.md, Prompts/generate-food-trends-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Food-Trends_<YYYY>.png". (3) Each run advances the collection by one year: research that year's viral foods, restaurant trends, cooking tools, cookbooks, food media, agriculture stories, grocery shifts, and home-cooking changes with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — warm editorial kitchen/table scene with plated foods, grocery shelves, cooking tools, menus, farmers markets, and short readable trend labels; avoid exact logos and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateFoodTrends flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Transportation & Mobility" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Transportation-Mobility/ with: README.md, Prompts/generate-transportation-mobility-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Transportation-Mobility_<YYYY>.png". (3) Each run advances the collection by one year: research that year's electric vehicles, aviation events, rail projects, self-driving milestones, rideshare, shipping disruptions, bike/scooter waves, and infrastructure changes with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — city-street and transit-map montage: EVs, trains, planes, ports, roads, charging stations, traffic dashboards, and infrastructure scenes; avoid exact logos and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateTransportationMobility flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Science Breakthroughs" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Science-Breakthroughs/ with: README.md, Prompts/generate-science-breakthroughs-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per year from 2000–current year, filename "Science-Breakthroughs_<YYYY>.png". (3) Each run advances the collection by one year: research that year's medicine, physics, biology, genetics, energy, archaeology, materials-science, and Nobel-worthy discoveries with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — science-magazine style with labs, microscopes, telescopes, molecules, fossils, clean-energy prototypes, hospital research rooms, and readable short labels; avoid exact logos and photorealistic real-person likenesses; bake the readable year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateScienceBreakthroughs flag and a prompt step so each run picks the first not-yet-generated year, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first year and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Fashion Through the Decades" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Fashion-Through-The-Decades/ with: README.md, Prompts/generate-fashion-through-the-decades-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per entry from an ordered plan table (oldest → newest) — example sequence: 1900s, 1910s, 1920s, 1930s, 1940s, 1950s, 1960s, 1970s, 1980s, 1990s, 2000s, 2010s, 2020s — filename "Fashion-Through-The-Decades_<Entry-Slug>.png" (e.g. "..._1920s.png"); register the collection slug in SLUG_INDEXED_COLLECTIONS in Site/scripts/build-manifest.mjs. (3) Each run advances the collection by one entry: research that decade's defining silhouettes, fabrics, subcultures, designers, and street styles with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — a fashion-plate / magazine-spread montage of figures in period-accurate outfits with accessories, color palettes, and short readable trend labels; avoid exact logos, exact designer-house marks, and photorealistic real-person likenesses; bake the readable decade title into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateFashionThroughTheDecades flag and a prompt step so each run picks the first not-yet-generated entry, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first entry and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Art Movements Timeline" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Art-Movements-Timeline/ with: README.md, Prompts/generate-art-movements-timeline-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per entry from an ordered plan table (oldest → newest) — example sequence: Renaissance, Baroque, Rococo, Neoclassicism, Romanticism, Realism, Impressionism, Post-Impressionism, Expressionism, Cubism, Surrealism, Abstract Expressionism, Pop Art, Minimalism, Street Art, Digital/Generative Art — filename "Art-Movements-Timeline_<Entry-Slug>.png" (e.g. "..._Cubism.png"); register the collection slug in SLUG_INDEXED_COLLECTIONS in Site/scripts/build-manifest.mjs. (3) Each run advances the collection by one entry: research that movement's era, hallmark techniques, themes, and signature motifs with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — an original scene rendered in the visual language of that movement (composition, palette, brushwork cues) with a small museum-placard element; do NOT reproduce specific copyrighted artworks; avoid exact logos and photorealistic real-person likenesses; bake the readable movement name into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateArtMovementsTimeline flag and a prompt step so each run picks the first not-yet-generated entry, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first entry and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Architectural Wonders of the World" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Architectural-Wonders/ with: README.md, Prompts/generate-architectural-wonders-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per entry from an ordered plan table (oldest → newest by build date) — example sequence: Great Pyramid of Giza, Great Wall of China, Colosseum, Hagia Sophia, Angkor Wat, Notre-Dame, Taj Mahal, St. Peter's Basilica, Eiffel Tower, Sydney Opera House, Burj Khalifa — filename "Architectural-Wonders_<Entry-Slug>.png" (e.g. "..._Taj-Mahal.png"); register the collection slug in SLUG_INDEXED_COLLECTIONS in Site/scripts/build-manifest.mjs. (3) Each run advances the collection by one entry: research that structure's era, builders, style, and notable facts with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — a travel-poster / illustrated-postcard view of the landmark with period and setting cues and a short readable name+location label; avoid exact logos and photorealistic real-person likenesses; bake the readable structure name into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateArchitecturalWonders flag and a prompt step so each run picks the first not-yet-generated entry, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first entry and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "World's Fairs & Expos" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Worlds-Fairs-Expos/ with: README.md, Prompts/generate-worlds-fairs-expos-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per entry from an ordered plan table (oldest → newest by year) — example sequence: London 1851, Paris 1889, Chicago 1893, Paris 1900, New York 1939, Brussels 1958, Seattle 1962, Montreal 1967, Osaka 1970, Shanghai 2010, Dubai 2020 — filename "Worlds-Fairs-Expos_<Entry-Slug>.png" (e.g. "..._Chicago-1893.png"); register the collection slug in SLUG_INDEXED_COLLECTIONS in Site/scripts/build-manifest.mjs. (3) Each run advances the collection by one entry: research that fair's host city, theme, signature pavilions/structures, and innovations debuted with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — a vintage exposition-poster montage of the fairgrounds, landmark pavilion, crowds, and era technology with a short readable city+year label; avoid exact logos and photorealistic real-person likenesses; bake the readable fair name+year into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateWorldsFairsExpos flag and a prompt step so each run picks the first not-yet-generated entry, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first entry and confirm it shows in the gallery at library.mikesailab.com/collections/.

Add a new image collection called "Mythical Creatures of World Folklore" to the EXISTING weekend-yearly-collections agent-runner job using the ai-automation-library skill — do NOT scaffold a new cron job or watchdog. (1) Create My-Library/Images/Collections/Mythical-Creatures/ with: README.md, Prompts/generate-mythical-creatures-collection.md (collection goal, master image prompt, metadata checklist, QA checklist), and empty Images/ and Metadata/ folders. (2) Indexing: one image per entry from an ordered plan table grouped by region (a stable curated order) — example sequence: Dragon (China), Phoenix (Greece), Kitsune (Japan), Thunderbird (North America), Kraken (Norse), Anansi (West Africa), Yeti (Himalayas), Bunyip (Australia), Quetzalcoatl (Mesoamerica), Selkie (Scotland), Naga (South Asia), Baba Yaga's beasts (Slavic) — filename "Mythical-Creatures_<Entry-Slug>.png" (e.g. "..._Kitsune.png"); register the collection slug in SLUG_INDEXED_COLLECTIONS in Site/scripts/build-manifest.mjs. (3) Each run advances the collection by one entry: research that creature's culture of origin, legend, and traditional depiction with built-in WebSearch (cite sources in metadata), then generate one cartoon/editorial illustration — a folklore-bestiary plate showing the creature in its mythic habitat with region-appropriate motifs and a short readable name+origin label; avoid exact logos and photorealistic real-person likenesses; bake the readable creature name into the image. (4) Write a metadata .md sidecar per image (selected items, why, sources, final prompt, model, date). (5) Wire it into the weekend-yearly-collections wrapper: add a $GenerateMythicalCreatures flag and a prompt step so each run picks the first not-yet-generated entry, attach the new PNG to the run email, and add the collection to COLLECTION_LABELS in the web-app walker. (6) Run the job once to generate the first entry and confirm it shows in the gallery at library.mikesailab.com/collections/.

Scaffold a new agent-runner job called `weekly-faceless-short` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs every Tuesday at 05:00 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry (max_age 8d). Each run executes a single `claude --print` session that: (1) uses built-in WebSearch to find a compelling AI/tech topic from the past week, (2) writes a 60-second voiceover script broken into 6 segments (~10 s each), (3) calls ElevenLabs MCP `search_voices` to select a suitable voice then `text_to_speech` to render the full narration as `vo.mp3`, (4) calls ElevenLabs MCP `compose_music` with a prompt matching the topic mood to produce `bg.mp3`, (5) calls nanobanana `generate_image` six times to generate one 9:16 still per script segment, saving them as `still-01.png` through `still-06.png`, (6) assembles the video with ffmpeg: scale each still to 1080x1920, apply a slow ken-burns zoompan effect (`zoompan=z='min(zoom+0.0015,1.5)':d=300`), concat the 6 clips to match total VO duration, overlay the VO with `amix` to duck the bg music to -18 dB under narration, burn per-segment caption text with `drawtext` (font Arial, size 52, white with black outline, bottom-center), output `short.mp4` (libx264, crf 23, aac 192k). Save `short.mp4`, `metadata.md` (date, topic, voice ID, music prompt, model), `prompt.md` into `My-Library/Videos/Shorts/<Month_YYYY>/short-<slug>_<date>/`. Commit and push to `mike_desktop` on the AI-Automation-Library remote. Send an AgentMail email with the metadata summary and the topic in the subject line (video too large to attach — note path). Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-faceless-short.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-music-video` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs every Saturday at 06:00 via cron + watchdog (max_age 8d). Each run executes a `claude --print` session that: (1) locates the most recent Weekly Song MP3 under `My-Library/Music/Songs/` (glob for the latest dated folder), reads its `metadata.md` to extract the song title, genre, and mood, (2) uses built-in WebSearch to briefly research the genre's visual aesthetic, (3) divides the song's duration into N sections (roughly every 20 s) and writes a vivid image prompt for each section that fits the song's narrative arc, (4) calls nanobanana `generate_image` once per section (16:9, cinematic style matching genre) saving `frame-01.png`…`frame-N.png`, (5) assembles with ffmpeg: scale frames to 1920x1080, display each frame for its section duration with a 1-second cross-dissolve transition (`xfade=transition=fade`), mux in the Weekly Song MP3 as audio (copy stream, no re-encode), output `music-video.mp4` (libx264 crf 20, aac copy). Save `music-video.mp4`, `metadata.md` (date, song title, genre, section count, model), `prompt.md` into `My-Library/Videos/Music-Videos/<Month_YYYY>/music-video-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the song title and video path in the body. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-music-video.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-podcast-audiogram` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs every Thursday at 06:00 via cron + watchdog (max_age 8d). Each run executes a `claude --print` session that: (1) locates the most recent Weekly Podcast MP3 under `My-Library/Podcasts/Podcasts/` (glob latest dated folder), reads its `metadata.md` for episode title and topic, (2) calls nanobanana `generate_image` to generate a branded 1920x1080 cover image — dark background, podcast title in large text as part of the artwork, abstract wave/sound visualization motif, `mikesailab.com` credit in corner — saving it as `cover-image.png`, (3) trims the audio to 90 seconds if longer (ffmpeg `-t 90`) for a shareable preview clip, (4) assembles the audiogram with ffmpeg: tile `cover-image.png` as the video background for the full 90 s, overlay a real-time waveform using `showwaves=s=1920x200:mode=cline:colors=00bfff` composited at the bottom third with `overlay`, mux the trimmed audio, output `audiogram.mp4` (libx264 crf 22, aac 192k). Save `audiogram.mp4`, `metadata.md` (date, episode title, audio duration, trim flag, model), `prompt.md` into `My-Library/Videos/Audiograms/<Month_YYYY>/audiogram-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the episode title and video path in the body. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-podcast-audiogram.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `daily-news-recap-video` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs daily at 07:30 via cron + watchdog (max_age 26h), after the 06:30 Daily News Collage job. Each run executes a `claude --print` session that: (1) locates today's Daily News Collage output folder under `My-Library/Images/Daily-News-Collage/` (glob for today's date prefix), reads its `metadata.md` to extract the top 4–5 headline summaries, (2) writes a punchy 45-second news-anchor narration script covering those headlines (one sentence per story, brisk pace), (3) calls ElevenLabs MCP `search_voices` to select a clear authoritative voice then `text_to_speech` to render `vo.mp3`, (4) assembles with ffmpeg: for each collage PNG apply a slow ken-burns zoompan (`zoompan=z='min(zoom+0.001,1.3)':d=270:x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)'`), concat panned clips to match VO duration, mux VO audio, burn a lower-third caption strip showing the current headline using `drawtext` (font Arial bold, size 44, white text, semi-transparent dark bar behind), output `news-recap.mp4` (1080x1920, libx264 crf 23, aac 192k). Save `news-recap.mp4`, `metadata.md` (date, headline count, voice ID, model), `prompt.md` into `My-Library/Videos/News-Recaps/<Month_YYYY>/news-recap_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the headline list and video path. Wire the PowerShell wrapper at `/tasks/jobs/run_daily-news-recap-video.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-story-trailer` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs every Friday at 06:00 via cron + watchdog (max_age 8d). Each run executes a `claude --print` session that: (1) locates the most recent Weekly Short Story under `My-Library/Books/Short-Stories/` (glob latest dated folder), reads the story text and `metadata.md` for title and genre, (2) selects 5 pivotal scenes from the story and writes a 60-second dramatic trailer narration (cryptic hook lines, not a plot summary), plus a title-card text and tagline, (3) calls ElevenLabs MCP `search_voices` for a cinematic voice then `text_to_speech` to render `vo.mp3`, (4) calls ElevenLabs MCP `compose_music` with a genre-appropriate cinematic prompt to produce `score.mp3`, (5) calls nanobanana `generate_image` five times for the five scene stills in 16:9 cinematic style, saving `scene-01.png`…`scene-05.png`, (6) assembles with ffmpeg: each still gets a slow zoompan (ken-burns), concat to VO duration, `amix` score at -20 dB under VO, add a 3-second black title-card at the end with `drawtext` burning the story title and tagline in serif font (size 72 + 40), output `story-trailer.mp4` (1920x1080, libx264 crf 20, aac 192k). Save `story-trailer.mp4`, `metadata.md` (date, story title, genre, voice ID, music prompt, model), `prompt.md` into `My-Library/Videos/Story-Trailers/<Month_YYYY>/story-trailer-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the story title and video path. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-story-trailer.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-map-flythrough` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs every Wednesday at 06:00 via cron + watchdog (max_age 8d). Each run executes a `claude --print` session that: (1) locates the most recent Weekly AI Map under `My-Library/Maps/` (glob latest dated folder), reads its `metadata.md` for map subject and region details, (2) writes a 45-second geographic narrator script — a documentary-style voiceover describing the map's subject, key features, and interesting data points, (3) calls ElevenLabs MCP `search_voices` for a documentary-style voice then `text_to_speech` to render `vo.mp3`, (4) calls ElevenLabs MCP `text_to_sound_effects` with a prompt like "gentle ambient wind and distant atmosphere" to produce `ambient.mp3` (5–10 s, looped), (5) assembles with ffmpeg: upscale the map PNG to 3840x2160 then apply a slow multi-stop zoompan flythrough that starts wide, drifts to the center of interest, and slowly zooms back out (`zoompan` with keyframed `x`/`y`/`z` expressions over the full 45 s), mux VO audio and loop `ambient.mp3` with `amix` at -22 dB, output `map-flythrough.mp4` (1920x1080, libx264 crf 20, aac 192k). Save `map-flythrough.mp4`, `metadata.md` (date, map subject, region, voice ID, model), `prompt.md` into `My-Library/Videos/Map-Flythroughs/<Month_YYYY>/map-flythrough-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the map subject and video path. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-map-flythrough.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-quote-video` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs every Monday at 05:00 via cron + watchdog (max_age 8d). Each run executes a `claude --print` session that: (1) uses built-in WebSearch to find one powerful, lesser-known quote from a philosopher, scientist, or artist — avoid overused clichés, (2) attributes the quote and writes a brief 2-sentence reflection on its meaning, (3) calls ElevenLabs MCP `search_voices` for a calm thoughtful voice then `text_to_speech` to render the quote (spoken slowly, ~25 s) as `vo.mp3`, (4) calls ElevenLabs MCP `text_to_sound_effects` with prompt "soft cinematic whoosh and gentle chime" to produce `sfx.mp3`, (5) calls nanobanana `generate_image` to generate a 9:16 abstract background image — deep color gradients, bokeh, no text, mood matching the quote's tone — saving as `bg.png`, (6) assembles with ffmpeg: hold `bg.png` for the full video duration, overlay the quote text word-by-word using multiple `drawtext` filters with `enable='between(t,START,END)'` timing synchronized to the VO (space words across the 25 s proportionally), center-aligned, large bold white font size 68 with black shadow, fade text in with `alpha` expression, mux VO and `sfx.mp3` at -12 dB as an intro accent, output `quote-video.mp4` (1080x1920, libx264 crf 22, aac 192k). Save `quote-video.mp4`, `metadata.md` (date, quote text, author, voice ID, model), `prompt.md` into `My-Library/Videos/Quote-Videos/<Month_YYYY>/quote-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the quote and author in the body and video path. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-quote-video.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-recipe-reel` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs every Sunday at 08:00 via cron + watchdog (max_age 8d). Each run executes a `claude --print` session that: (1) locates the most recent Recipe of the Week output under `My-Library/Cooking/Recipes/` (glob latest dated folder), reads its `metadata.md` for recipe name, ingredients, and step summaries, and discovers available PNG stills (hero image + step images), (2) writes a 60-second punchy cooking-show narration — name the dish, call out 3 key ingredients, walk through 4–5 steps briskly, end with a serving suggestion, (3) calls ElevenLabs MCP `search_voices` for an enthusiastic food-show voice then `text_to_speech` to render `vo.mp3`, (4) calls ElevenLabs MCP `compose_music` with prompt "upbeat lo-fi kitchen jazz, cheerful and warm" to produce `score.mp3`, (5) assembles with ffmpeg: scale all recipe PNGs to 1080x1920 (pad with blur background for non-9:16 sources using `scale`+`boxblur`+`overlay`), display hero for 8 s then each step still proportionally across remaining VO duration, apply gentle zoompan to each, `amix` score at -18 dB under VO, burn ingredient-list lower-third for first 10 s using `drawtext` (white text, dark semi-transparent bar, font size 38), output `recipe-reel.mp4` (libx264 crf 23, aac 192k). Save `recipe-reel.mp4`, `metadata.md` (date, recipe name, step count, voice ID, music prompt, model), `prompt.md` into `My-Library/Videos/Recipe-Reels/<Month_YYYY>/recipe-reel-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the recipe name and video path. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-recipe-reel.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-comic-motion` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs every Thursday at 07:00 via cron + watchdog (max_age 8d). Each run executes a `claude --print` session that: (1) locates the most recent Weekly Comic output under `My-Library/Books/Comics/` (glob latest dated folder), reads its `metadata.md` for the comic title and panel count, discovers panel PNGs in order, (2) reads or infers each panel's dialogue/action and writes a short narrator line per panel (one sentence, read aloud like a dramatic comic announcer) plus an SFX description per panel (e.g., "punchy whoosh", "dramatic sting", "comedic boing"), (3) calls ElevenLabs MCP `search_voices` for a classic comic-narrator voice then `text_to_speech` to render a concatenated narration with 0.5 s pauses between panels as `vo.mp3`, (4) calls ElevenLabs MCP `text_to_sound_effects` once per panel (up to 6 calls) for each SFX description, saving `sfx-01.mp3`…`sfx-N.mp3`, (5) assembles with ffmpeg: scale each panel PNG to 1920x1080 (pad with black bars for non-16:9), apply a slow directional pan (left-to-right or zoom-in alternating per panel) using `zoompan`, concat panels synchronized to VO timing, mix each `sfx-N.mp3` at the start of the corresponding panel segment using `amix` with per-stream delay, output `comic-motion.mp4` (libx264 crf 21, aac 192k). Save `comic-motion.mp4`, `metadata.md` (date, comic title, panel count, voice ID, model), `prompt.md` into `My-Library/Videos/Comic-Motion/<Month_YYYY>/comic-motion-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the comic title and video path. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-comic-motion.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-library-digest-trailer` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Daily Poster job for PowerShell wrapper and cron structure. The job runs every Sunday at 10:00 via cron + watchdog (max_age 8d), after all other weekly jobs have fired. Each run executes a `claude --print` session that: (1) collects one representative still from each of the following this-week outputs — Daily News Collage (latest), Weekly News Montage (latest), Weekly AI Map (latest), Recipe of the Week hero (latest), Weekly Comic first panel (latest), Weekly Short Story cover if exists else skip, Weekly Poster (latest) — globbing each source folder by this week's ISO week or date range; skip any category that produced no output this week, (2) reads each artifact's `metadata.md` to extract a one-line description, (3) writes a 75-second upbeat "what's new in the library this week" host script — one punchy sentence per artifact, cheerful and curious tone, ending with "all of this at mikesailab.com", (4) calls ElevenLabs MCP `search_voices` for an enthusiastic host voice then `text_to_speech` to render `vo.mp3`, (5) calls ElevenLabs MCP `compose_music` with prompt "energetic upbeat intro music, podcast-style, 10 seconds" to produce `intro.mp3`, (6) assembles with ffmpeg: play `intro.mp3` over the first still (8 s, duck to -24 dB when VO starts), then display each collected still for ~8–10 s with a gentle zoompan, mux VO as primary audio, append a 4-second black end-card with `drawtext` burning "mikesailab.com — New every week." in white serif font size 64, output `library-digest.mp4` (1920x1080, libx264 crf 20, aac 192k). Save `library-digest.mp4`, `metadata.md` (date, ISO week, artifact list, voice ID, music prompt, model), `prompt.md` into `My-Library/Videos/Library-Digest/<Month_YYYY>/digest-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the artifact list and video path in the body. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-library-digest-trailer.ps1`. Validate one real artifact end-to-end (even with only 2–3 source stills) before scheduling.

Scaffold `weekly-data-story-short` as an agent-runner job. Run Tuesdays at 09:30 via cron + watchdog. Use Claude WebSearch to find one current data-rich story, write a 60-second vertical-video script, generate 4-6 simple chart/still PNGs with Python/matplotlib or nanobanana as needed, render VO with ElevenLabs TTS, and assemble a 1080x1920 MP4 with ffmpeg captions burned in. Save `data-short.mp4`, `metadata.md` (date, topic, source URLs, chart descriptions, voice ID), and `prompt.md`. Commit/push, email the video path and top takeaway, and validate one real run.

Scaffold `weekly-recipe-reel` as an agent-runner job. Run Saturdays at 10:30 after cooking jobs. Locate the latest recipe under `My-Library/Cooking/`, read its metadata and steps, create a concise vertical reel script, generate or reuse 5-7 food stills, render warm host narration with ElevenLabs, and assemble a 1080x1920 MP4 with step captions, ingredient title cards, and a final plated-food end card. Save `recipe-reel.mp4`, `metadata.md`, and `prompt.md`; commit/push, email the path, and validate with one real recipe.

Scaffold `monthly-artifact-showcase` as an agent-runner job. Run on the first day of each month at 11:00 with cron + watchdog. Collect representative images, covers, maps, app screenshots, comic panels, music covers, and recipe heroes produced in the prior calendar month; have Claude write a 2-3 minute curator script; render VO with ElevenLabs; compose a simple music bed; and assemble a polished 16:9 MP4 with section cards and source paths listed in metadata. Save `monthly-showcase.mp4`, `metadata.md`, and `prompt.md`; commit/push, email the artifact roster, and validate using the prior month.

Scaffold a new agent-runner job called `genre-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly Song job. The job runs every Sunday at 05:00 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry (8d max age). Maintain a state file at /tasks/jobs/state/genre_rotation.json that cycles through a fixed list of 20 genres (lo-fi hip-hop, delta blues, bossa nova, synthwave, Celtic folk, Afrobeat, death metal, jazz fusion, reggaeton, bluegrass, K-pop, flamenco, drum & bass, gospel, ambient techno, classical minimalism, honky-tonk country, samba, ska, post-punk) — advancing by one each week. Each run: (1) invoke `claude --print` with built-in WebSearch to find one notable artist or recent release in the current genre, then write a full set of original lyrics inspired by that genre's conventions — verse/chorus/bridge structure, idiomatic phrasing, no copyright infringement; (2) call ElevenLabs `create_composition_plan` with a detailed style brief referencing the genre and the lyric mood; (3) call ElevenLabs `compose_music` exactly once (PAID — do not retry on partial failure; log the error and exit) passing the plan and lyrics; (4) call nanobanana `generate_image` with a square cover-art prompt matching the genre's visual aesthetic — bold typography, genre-appropriate color palette, no real artist likenesses; (5) write ffmpeg metadata tags (title, artist="Mike's AI Lab", album="Genre-of-the-Week", genre, date) into the MP3. Output `song.mp3`, `cover-image.png`, `lyrics.md`, `metadata.md` (date, genre, reference artist/release, ElevenLabs plan ID, model) into `My-Library/Music/Songs/<date>-genre-<slug>/`. Commit and push to `mike_desktop` on the AI-Automation-Library remote. Send an AgentMail email to Mike with the lyrics in the body and a note that the MP3 is committed. Wire the PowerShell wrapper at /tasks/jobs/run_genre-of-the-week.ps1 invoked by run-job.sh. Validate one real artifact end-to-end (current genre = lo-fi hip-hop) before scheduling.

Scaffold a new agent-runner job called `lofi-loop-pack` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the existing Weekly Song job structure. This job is ON-DEMAND only (no cron line) because compose_music is paid and called three times per run — document this clearly in the wrapper header comment. Each run: generate three thematically related but sonically distinct instrumental loops suitable for background focus/study work. Cycle through a mood list in /tasks/jobs/state/lofi_mood_rotation.json: rainy-day-café, late-night-code, golden-hour-drive, forest-morning, neon-city-night — advancing each run. For each of the three loops: (1) call ElevenLabs `create_composition_plan` describing a short loopable instrumental (no vocals) in the current mood — vary the instrumentation slightly across the three (e.g. piano-led, guitar-led, synth-led); (2) call ElevenLabs `compose_music` once per loop (PAID — one call per loop, three total — log each result before proceeding to the next); (3) use ffmpeg to trim each output to exactly 90 seconds with a 2-second fade-in and 3-second fade-out so it loops cleanly. After all three are generated, call nanobanana `generate_image` once for a shared pack cover — lo-fi aesthetic, the mood name as a subtitle, cozy illustrated scene. Write `loop-01.mp3`, `loop-02.mp3`, `loop-03.mp3`, `cover-image.png`, `metadata.md` (date, mood, instrumentation notes, ElevenLabs plan IDs) into `My-Library/Music/Songs/<date>-lofi-loops-<slug>/`. Commit and push to `mike_desktop`. Send an AgentMail with the mood and loop count in the subject and the metadata in the body. Validate one real artifact end-to-end (mood = rainy-day-café) before wiring the on-demand trigger.

Scaffold a new agent-runner job called `weekly-map-anthem` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the existing Weekly Song job. The job runs every Monday at 06:00 via cron + watchdog (8d max age), the day after the Weekly AI Map job fires on Sunday. Each run: (1) invoke `claude --print` with a prompt that reads the most recently committed Weekly AI Map artifact from `My-Library/Maps/` (glob for the newest dated folder, read its `metadata.md` to extract the featured location name and theme); (2) using that location, write original song lyrics that evoke the geography, culture, history, or atmosphere of the place — aim for 2 verses + chorus + bridge, travel-song or folk-anthem style; (3) call ElevenLabs `create_composition_plan` with a style brief that matches the location's musical heritage (e.g., Nairobi → Afrobeat/Benga elements; Nashville → country; Kyoto → ambient koto-influenced); (4) call ElevenLabs `compose_music` exactly once (PAID); (5) call nanobanana `generate_image` for a square cover that depicts the location in a stylized illustrated travel-poster style — location name as title text, no photo-realistic real people; (6) tag the MP3 with ffmpeg (title = "<Location> Anthem", album = "Weekly Map Anthems", date). Output `anthem.mp3`, `cover-image.png`, `lyrics.md`, `metadata.md` (date, location, source map artifact path, ElevenLabs plan ID, style brief) into `My-Library/Music/Songs/<date>-map-anthem-<slug>/`. Commit and push to `mike_desktop`. Send an AgentMail with the location name + lyrics in the body. Validate one real artifact end-to-end (manually supply a sample map metadata.md if the Maps job has not yet fired) before scheduling.

Scaffold a new agent-runner job called `jingle-sting-pack` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Song job's wrapper and cron structure. The job runs every Wednesday at 04:30 via cron + watchdog (8d max age). IMPORTANT: this job does NOT call compose_music (no paid music charge). It uses ElevenLabs `text_to_sound_effects` only, which is free-tier friendly. Each run: cycle through a sting-theme list in /tasks/jobs/state/jingle_theme_rotation.json (notification-chime, success-fanfare, error-buzz, level-up, ambient-intro, retro-blip, dramatic-sting, soft-landing, power-up, countdown-beep — two themes per pack, five stings per pack sharing the same theme pair). For each of five stings in the current theme: call ElevenLabs `text_to_sound_effects` with a precise audio description targeting 3–8 seconds (e.g., "a bright two-note ascending chime, xylophone and bell tones, 4 seconds"); trim with ffmpeg to a clean end point (no trailing silence). After all five are generated, call nanobanana `generate_image` for a shared cover — retro waveform / audio gear aesthetic, the theme name as a label, square format. Write `sting-01.mp3` through `sting-05.mp3`, `cover-image.png`, `metadata.md` (date, theme, duration of each sting, ElevenLabs text prompts used) into `My-Library/Music/Songs/<date>-jingle-pack-<slug>/`. Commit and push to `mike_desktop`. Send an AgentMail with the theme + sting descriptions in the body. Validate one real artifact end-to-end (theme = notification-chime + success-fanfare) before scheduling.

Scaffold a new agent-runner job called `mood-of-the-news-track` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the existing Weekly Song job. The job runs every Friday at 06:30 via cron + watchdog (8d max age). Each run: (1) invoke `claude --print` with built-in WebSearch to survey the past week's top 5 AI and technology news headlines — distill them into a single emotional mood word (e.g., "anxious", "euphoric", "contemplative", "chaotic", "hopeful") and a one-paragraph narrative summary of the week's vibe; (2) write original lyrics that translate that mood into song — abstract, impressionistic style; 2 verses + chorus, no brand names or specific proper nouns; (3) call ElevenLabs `create_composition_plan` with a detailed brief: tempo and key matching the mood (anxious → fast minor, hopeful → medium major, contemplative → slow ambient), instrumentation, vocal style; (4) call ElevenLabs `compose_music` exactly once (PAID — log the output; do not retry on partial failure); (5) call nanobanana `generate_image` for a square cover — abstract visualisation of the mood word, dark palette, typographic mood-word overlay; (6) tag MP3 with ffmpeg (title = "Mood: <mood-word> — Week of <date>", album = "Mood of the News"). Output `song.mp3`, `cover-image.png`, `lyrics.md`, `metadata.md` (date, mood word, week's news summary, ElevenLabs plan ID) into `My-Library/Music/Songs/<date>-news-mood-<slug>/`. Commit and push to `mike_desktop`. Send an AgentMail with the mood word + news summary + lyrics in the body. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-chiptune` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the existing Weekly Song job. The job runs every Tuesday at 05:00 via cron + watchdog (8d max age). Each run: (1) cycle through a game-era/style list in /tasks/jobs/state/chiptune_style_rotation.json (NES 8-bit adventure, Game Boy dungeon crawler, SNES RPG overworld, Sega Genesis boss battle, Atari 2600 arcade loop, C64 SID synth demo, arcade racing, 16-bit platformer title screen — one per week); (2) call ElevenLabs `create_composition_plan` with an instrumental-only brief: the current era/style, characteristic hardware sound constraints (square waves, triangle bass, noise channel percussion, limited polyphony), upbeat or dramatic energy, 90–120 BPM, no vocals, loopable structure; (3) call ElevenLabs `compose_music` exactly once (PAID — do not retry); (4) call nanobanana `generate_image` for a square pixel-art cover in the matching game-era aesthetic — 16-bit scene, visible pixel grid, the style name as a retro game logo in the corner; (5) tag MP3 with ffmpeg (title = "<style> Chiptune", artist = "Mike's AI Lab", album = "Retro Chiptune Series", date). Output `chiptune.mp3`, `cover-image.png`, `metadata.md` (date, era/style, ElevenLabs plan ID, BPM, instrumentation notes) into `My-Library/Music/Songs/<date>-chiptune-<slug>/`. Commit and push to `mike_desktop`. Send an AgentMail with the style name and metadata in the body. Validate one real artifact end-to-end (style = NES 8-bit adventure) before scheduling.

Scaffold a new agent-runner job called `story-theme-song` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the existing Weekly Song job. The job runs every Saturday at 06:00 via cron + watchdog (8d max age). Each run: (1) invoke `claude --print` with a prompt that globs `My-Library/Stories/` for the most recently committed story artifact (newest dated folder), reads its `story.md` (or equivalent text file) and `metadata.md` to extract the title, genre, protagonist name, and central emotional conflict; (2) write original song lyrics inspired by the story — adapt the emotional arc into a narrative song (verse 1 = setup, chorus = central conflict/emotion, verse 2 = climax, bridge = resolution or twist); match the lyric register to the story's genre (sci-fi → anthemic/electronic flavor, literary fiction → folk/indie flavor, horror → dark minor key flavor); (3) call ElevenLabs `create_composition_plan` with a style brief derived from the story's genre and mood — include vocal style, tempo, key, instrumentation; (4) call ElevenLabs `compose_music` exactly once (PAID); (5) call nanobanana `generate_image` for a square cover that visually references the story's setting or protagonist — illustrated, not photorealistic; story title as subtitle text on the cover; (6) tag MP3 with ffmpeg (title = "<Story Title> — Theme Song", album = "Story Theme Songs", date). Output `song.mp3`, `cover-image.png`, `lyrics.md`, `metadata.md` (date, story title, genre, source story path, ElevenLabs plan ID) into `My-Library/Music/Songs/<date>-story-theme-<slug>/`. Commit and push to `mike_desktop`. Send an AgentMail with the story title + lyrics in the body. Validate one real artifact end-to-end (manually supply a sample story metadata.md if the Stories job has not yet fired) before scheduling.

Scaffold a new agent-runner job called `weekly-soundscape` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Song job's wrapper and cron structure. The job runs every Thursday at 05:30 via cron + watchdog (8d max age). IMPORTANT: this job does NOT call compose_music (zero paid music charge). It builds a layered ambient soundscape entirely from ElevenLabs `text_to_sound_effects` calls (free-tier) mixed with ffmpeg. Each run: (1) cycle through an environment list in /tasks/jobs/state/soundscape_environment_rotation.json (deep forest at dawn, rainy city café, ocean cave with distant waves, spacecraft interior hum, underground library, mountain thunderstorm, night-market crowded bazaar, abandoned greenhouse, arctic wind plateau, coral reef — one per week); (2) for the current environment, define 4–6 distinct audio layer descriptions (e.g., for forest: "steady light rain on broad leaves", "distant owl call, echoing", "low wind through pine canopy", "sporadic frog chorus", "soft stream trickle nearby") — write these descriptions in the claude --print step; (3) call ElevenLabs `text_to_sound_effects` once per layer, requesting each at maximum duration (up to 22 seconds as supported by the API); (4) use ffmpeg to loop each layer clip to 10 minutes (ffmpeg -stream_loop -1) and then mix all layers together with amix=inputs=N:duration=first:normalize=0, adjusting per-layer volume weights for balance (e.g., primary ambient louder, accents quieter); apply a 10-second fade-in and 15-second fade-out to the final mix; (5) call nanobanana `generate_image` for a square cover evoking the environment — photorealistic or painterly, atmospheric lighting, no text overlay; (6) tag the mixed MP3 with ffmpeg metadata (title = "<Environment> Soundscape", album = "Ambient Soundscapes", date). Output `soundscape.mp3`, `cover-image.png`, `metadata.md` (date, environment, layer descriptions, per-layer volume weights, total duration) into `My-Library/Music/Songs/<date>-soundscape-<slug>/`. Commit and push to `mike_desktop`. Send an AgentMail with the environment name + layer list in the body. Validate one real artifact end-to-end (environment = deep forest at dawn) before scheduling.

Scaffold `weekly-study-focus-loop` as an agent-runner music job. Run Mondays at 06:30. Rotate focus moods (lofi coding, ambient piano, synthwave concentration, acoustic study, rain-room texture, minimal techno, library jazz, deep work drone). Use ElevenLabs `compose_music` to produce a loopable 10-minute instrumental MP3 with no vocals, generate a square cover via nanobanana, and save `focus-loop.mp3`, `cover-image.png`, `metadata.md` (mood, BPM if known, prompt, model), and `prompt.md`. Commit/push, email the MP3 + cover, and validate one full run.

Scaffold `weekly-podcast-sting-pack` as an agent-runner job. Run Thursdays at 06:30. Rotate show genres (AI news, cooking, finance, security, storytime, maps/travel, science, app demos) and generate five 8-15 second stings: opener, transition, suspense bed, success tag, outro. Save `sting-01.mp3` through `sting-05.mp3`, `metadata.md` with use cases and prompts, and `prompt.md`. Commit/push, email attachments, and validate one pack.

Scaffold `monthly-genre-fusion-track` as an agent-runner job. Run monthly on day 15 at 07:00. Maintain a state file of genre pairs (bluegrass + synthwave, jazz + chiptune, classical + industrial, Afrobeat + ambient, mariachi + trap, Celtic + techno, surf rock + orchestral). Use ElevenLabs `compose_music` to create one polished 2-3 minute instrumental, generate a cover image, and write `liner-notes.md` explaining the fusion. Save track, cover, liner notes, metadata, and prompt; commit/push, email, and validate one real artifact.

Scaffold a new agent-runner on-demand job called `daily-ai-news-briefing` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Monthly Audio Podcast job (ElevenLabs TTS + ffmpeg stitch). This job is ON-DEMAND (no cron line — run manually via `run-job.sh daily-ai-news-briefing`); add a watchdog entry with a generous max-age of 3d so it only alerts if manually skipped for several days. Each run: (1) invoke `claude --print` to locate the most recent n8n AI-News digest artifact in `My-Library/Content/` (find the latest dated folder), read its text, and rewrite it as a clean ~5-minute spoken-audio script broken into 10–15 narration segments — conversational tone, no markdown, no bullet points, short sentences; (2) call `search_voices` on the ElevenLabs MCP to find a professional male or female news-anchor voice (search term "news anchor" or "broadcaster"); (3) call `text_to_speech` once per segment using that voice ID — NOTE: this is a PAID call (~15 calls/run), warn in the job log; (4) use ffmpeg to concatenate all segment MP3s into a single final `briefing.mp3` with a 300ms silence between segments; (5) write `metadata.md` (date, source digest path, voice ID, segment count, total duration) into `My-Library/Podcasts/AI-News-Briefing/<Month_YYYY>/ai-news-briefing_<date>/`. Commit and push to `mike_desktop` on the AI-Automation-Library remote. Send an AgentMail email to Mike with `briefing.mp3` attached (if under 10 MB; otherwise include the repo path) and the digest headline bullets in the email body. Wire the PowerShell wrapper at `/tasks/jobs/run_daily-ai-news-briefing.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end (locate an actual digest, generate TTS, stitch, commit) before declaring done.

Scaffold a new agent-runner on-demand job called `audiobook-chapter-narration` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Monthly Audio Podcast job (ElevenLabs TTS + ffmpeg stitch). This job is ON-DEMAND (no cron line); add a watchdog entry with max-age 10d. Each run: (1) invoke `claude --print` to find the most recent Weekly Short Story artifact in `My-Library/Content/Short-Stories/` (latest dated folder, read the story `.md` file); (2) have Claude split the story into natural narration segments of 1–3 sentences each (~20–30 segments) and derive a URL-safe slug from the story title; (3) call `search_voices` on the ElevenLabs MCP to find a warm, expressive storyteller voice (search "storyteller" or "audiobook narrator"); (4) call `text_to_speech` once per segment — NOTE: PAID, ~25 calls/run, log cost warning; (5) use ffmpeg to concatenate all segment MP3s with 400ms silence between segments, adding a brief 1-second pause before and after any paragraph breaks Claude marked; (6) write `metadata.md` (date, story title, slug, voice ID, segment count, approx duration) into `My-Library/Podcasts/Audiobook-Narrations/<Month_YYYY>/<story-slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the MP3 attached (if under 10 MB, else repo path) and the story title + first paragraph in the body. Wire `/tasks/jobs/run_audiobook-chapter-narration.ps1`. Validate one real artifact end-to-end before declaring done.

Scaffold a new agent-runner on-demand job called `guided-meditation-audio` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Monthly Audio Podcast job structure. This job is ON-DEMAND (no cron line); add a watchdog entry with max-age 14d. Each run: (1) invoke `claude --print` with a session type drawn from a rotating list in the script (body-scan relaxation, breath-focus meditation, sleep story — forest cabin, visualization — mountain summit, loving-kindness meditation, sleep story — ocean voyage — cycling); (2) Claude writes a full 8–12 minute script for that session type — slow pacing cues ("breathe in... hold... release"), descriptive imagery, gentle transitions, ending with a silent rest prompt; break it into ~25–35 narration segments; derive a slug from the session type; (3) call `search_voices` on ElevenLabs MCP (search "calm" or "meditation" or "ASMR") to pick a soothing voice; (4) optionally call `text_to_sound_effects` once for a soft ambient bed sound description (e.g., "gentle rain on leaves, soft and continuous") to generate a short SFX clip; (5) call `text_to_speech` per narration segment — NOTE: PAID ~30 calls/run; (6) use ffmpeg to concatenate segments with longer 800ms silences between cues; if SFX was generated, loop it as a quiet background track mixed 15 dB below voice; output `meditation.mp3`; (7) write `metadata.md` (date, session type, slug, voice ID, duration, SFX used) into `My-Library/Podcasts/Guided-Meditations/<Month_YYYY>/<session-slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the MP3 attached (if under 10 MB) and the session type in the subject. Wire `/tasks/jobs/run_guided-meditation-audio.ps1`. Validate one real artifact end-to-end before declaring done.

Scaffold a new agent-runner on-demand job called `iam-security-audio-briefing` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the `daily-ai-news-briefing` job (ElevenLabs TTS + ffmpeg stitch, single voice). This job is ON-DEMAND (no cron line); add a watchdog entry with max-age 10d. Each run: (1) invoke `claude --print` to locate the most recent n8n IAM/security digest artifact in `My-Library/Content/` (search for the latest IAM or Security dated folder — check both `IAM-Digest/` and `Security-Digest/` sub-paths); read its text; have Claude rewrite it as a clean ~6-minute spoken briefing script in 12–18 segments — professional, clear diction, define any acronyms on first use (IAM = Identity and Access Management, etc.), no markdown; (2) call `search_voices` on the ElevenLabs MCP (search "professional" or "authoritative" or "corporate") to select a clear, confident narrator voice; (3) call `text_to_speech` once per segment — NOTE: PAID ~15 calls/run, log this; (4) use ffmpeg to concatenate segments with 300ms silence between them → `briefing.mp3`; (5) write `metadata.md` (date, source digest path, voice ID, segment count, approx duration) into `My-Library/Podcasts/Security-Briefings/<Month_YYYY>/iam-briefing_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with `briefing.mp3` attached (if under 10 MB; else repo path) and the top 3 security headlines in the body. Wire `/tasks/jobs/run_iam-security-audio-briefing.ps1`. Validate one real artifact end-to-end before declaring done.

Scaffold a new agent-runner weekly job called `two-host-interview-podcast` following AI-Library-Automations/PORTING-PLAYBOOK.md, using the existing `render-audio-podcast` container skill (multi-speaker TTS→ffmpeg stitch). The job runs every Saturday at 10:00 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry with max-age 8d. Each run: (1) invoke `claude --print` with built-in WebSearch to find the week's most interesting AI/tech development (rotate focus: model releases, research papers, policy/regulation, product launches); (2) Claude writes a two-host interview script — Host A is the curious generalist interviewer, Host B is the knowledgeable expert — approximately 10 minutes of dialogue (~35 speaker turns total), natural back-and-forth, no bullet reading, genuine debate or exploration; mark each line with `HOST_A:` or `HOST_B:` prefix; save the script as `script.md`; derive a topic slug; (3) call `search_voices` on the ElevenLabs MCP to find two contrasting but complementary voices — one slightly warmer/higher, one slightly deeper/cooler; record both voice IDs; (4) invoke the `render-audio-podcast` skill passing the script file and both voice IDs — it handles per-segment TTS calls and ffmpeg stitching — NOTE: PAID ~35 calls/episode; (5) write `metadata.md` (date, topic, slug, Host A voice ID, Host B voice ID, segment count, duration) into `My-Library/Podcasts/Two-Host-Interviews/<Month_YYYY>/<topic-slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the MP3 attached (if under 10 MB, else repo path) and the episode topic + a one-paragraph teaser in the body. Wire `/tasks/jobs/run_two-host-interview-podcast.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner weekly job called `this-week-in-ai-recap` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the `daily-ai-news-briefing` job structure (ElevenLabs TTS + ffmpeg stitch, single voice). The job runs every Sunday at 09:00 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry with max-age 8d. Each run: (1) invoke `claude --print` with built-in WebSearch to research the past 7 days' most significant AI developments — cover at least 4 distinct stories across model releases, research, business/funding, and policy; (2) Claude writes a ~7-minute radio-show recap script in 18–22 segments — upbeat opening catchphrase ("Welcome to This Week in AI!"), one segment per story with context and analysis, a brief "what to watch next week" closing; no bullet points, flowing prose, transitions between segments; (3) call `search_voices` on the ElevenLabs MCP (search "radio" or "broadcaster" or "energetic") to select a confident, upbeat narrator; (4) call `text_to_speech` once per segment — NOTE: PAID ~20 calls/run, log this; (5) ffmpeg concatenate with 250ms silence between segments → `recap.mp3`; (6) write `metadata.md` (date, stories covered as bullet list, voice ID, segment count, duration) into `My-Library/Podcasts/This-Week-in-AI/<Month_YYYY>/this-week-in-ai_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with `recap.mp3` attached (if under 10 MB; else repo path) and the 4 story headlines in the body. Wire `/tasks/jobs/run_this-week-in-ai-recap.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner on-demand job called `sound-effect-pack` following AI-Library-Automations/PORTING-PLAYBOOK.md. This job uses the ElevenLabs MCP `text_to_sound_effects` tool — NOT `text_to_speech` — to generate raw sound-effect clips. This job is ON-DEMAND (no cron line); add a watchdog entry with max-age 30d. Each run: (1) pick the current theme from a rotating list maintained in a state file at `/tasks/jobs/state/sfx_theme_index.json` — themes: Game UI (clicks, pings, alerts), Nature & Ambience (rain, wind, birds), Sci-Fi (lasers, beams, hums), Horror (creaks, stings, whispers), Sports & Action (crowds, whistles, impacts), Retro Arcade (8-bit beeps, coin sounds), Kitchen & Foley (sizzle, pour, chop), Industrial (machinery, pneumatics); advance the index each run; (2) for that theme, define 8 descriptive SFX prompts (e.g. for "Game UI": "short crisp menu click", "success chime with sparkle", "error buzz", etc.); (3) call ElevenLabs MCP `text_to_sound_effects` once per prompt — NOTE: PAID, 8 calls/pack; log cost warning; (4) save individual clips as `sfx-01.mp3` through `sfx-08.mp3` with names derived from the prompt slug; (5) use ffmpeg to concatenate all 8 with 500ms silence between them into `pack-preview.mp3`; (6) write `metadata.md` (date, theme, 8 SFX descriptions mapped to filenames, call count) into `My-Library/Content/Sound-Effect-Packs/<Month_YYYY>/sfx-<theme>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with `pack-preview.mp3` attached and the 8 SFX names listed in the body. Wire `/tasks/jobs/run_sound-effect-pack.ps1`. Validate one real artifact end-to-end (generate one full 8-SFX pack for the first theme) before declaring done.

Scaffold a new agent-runner on-demand job called `audio-drama-comic-adaptation` following AI-Library-Automations/PORTING-PLAYBOOK.md, combining the multi-speaker pattern from the `two-host-interview-podcast` job (ElevenLabs TTS via `render-audio-podcast` skill) with the SFX pattern from the `sound-effect-pack` job (`text_to_sound_effects`). This job is ON-DEMAND (no cron line); add a watchdog entry with max-age 14d. Each run: (1) invoke `claude --print` to find the most recent Weekly Comic artifact in `My-Library/Content/Comics/` (latest dated folder; read the comic script or panel descriptions); (2) Claude adapts the comic into a full audio drama script: give each character a distinct name and personality, write natural dialogue expansions beyond the comic panels, add 2–3 stage directions for sound effects (e.g., [SFX: door slam], [SFX: crowd cheer]); save the full script as `script.md`; derive a slug from the comic title; (3) call `search_voices` on the ElevenLabs MCP to cast 2–3 voices matching the characters' personalities (search terms matching character types — e.g. "villain deep", "young hero", "wise elder"); (4) for each [SFX: ...] stage direction, call `text_to_sound_effects` with an appropriate description — NOTE: PAID ~3 calls; save each SFX clip; (5) invoke the `render-audio-podcast` skill with the dialogue-only script lines and assigned voice IDs to generate per-line TTS MP3s — NOTE: PAID ~35 calls, log warning; (6) use ffmpeg to assemble the final drama: interleave SFX clips at their marked positions, mix SFX at -12 dB below dialogue, output `drama.mp3`; (7) write `metadata.md` (date, comic title, slug, character names + voice IDs, SFX descriptions, total duration) into `My-Library/Podcasts/Audio-Dramas/<Month_YYYY>/<comic-slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with `drama.mp3` attached (if under 10 MB; else repo path), the comic title, and the character cast list in the body. Wire `/tasks/jobs/run_audio-drama-comic-adaptation.ps1`. Validate one real artifact end-to-end before declaring done.

Scaffold `daily-learning-brief` as an agent-runner job. Run daily at 06:15 with cron + watchdog. Rotate through science, history, software, finance, health, geography, and art topics; use Claude WebSearch to verify facts, write a 650-800 word concise script, render it with ElevenLabs TTS, and save `brief.mp3`, `transcript.md`, `metadata.md` (topic, source URLs, voice ID, model), and `prompt.md`. Commit/push, email the MP3 and transcript summary, and validate one real episode.

Scaffold `weekly-soundscape-postcard` as an agent-runner job. Run Sundays at 06:30. Rotate locations (rainy Tokyo alley, desert observatory, cozy spaceship cabin, forest after storm, medieval market morning, arctic research station, ocean pier at dusk). Use ElevenLabs sound effects/music tools to create layered ambience, generate a cover image, and write short location notes. Save `soundscape.mp3`, `cover-image.png`, `notes.md`, `metadata.md`, and `prompt.md`; commit/push, email the audio + cover, and validate end-to-end.

Scaffold `weekly-interview-monologue-pack` as an agent-runner job. Run Wednesdays at 06:45. Each run picks a theme (inventor, chef, explorer, founder, teacher, historian, artist, operator), writes three 2-minute fictional but plausible first-person monologues in distinct voices, renders each with a separate ElevenLabs voice, and saves `monologue-01.mp3` through `monologue-03.mp3`, matching transcripts, `metadata.md`, and `prompt.md`. Commit/push, email the roster, and validate one full pack.

Scaffold a new agent-runner job called `serialized-novella` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Short Story job structure (Gemini SDK). The job runs every Monday at 06:00 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry (max_age 8d).

State file: `/tasks/jobs/state/serialized_novella_state.json` — tracks `novella_slug`, `chapter_number` (int, starts at 1), `running_word_count`, and `synopsis` (one-paragraph rolling summary updated each run).

Each run:
1. Read the state file to get the current chapter number and synopsis.
2. If chapter 1: choose a genre from a rotating list in the script (gothic thriller / sci-fi first contact / cozy mystery / dark fantasy / cli-fi climate thriller — one per novella season of 12 chapters, then rotate); write a cold opening that establishes setting, protagonist, and inciting incident.
3. If chapter 2+: read the three most recent `chapter-*.md` files from the output folder to maintain continuity, then write the next chapter that advances the plot and ends on a hook.
4. Use the `google-genai` SDK with model `gemini-3.1-pro-preview` for all prose generation (target 1 800–2 200 words per chapter, no filler — every sentence must move character or plot).
5. If chapter 1 only: also call `gemini-3.1-flash-image` to generate a 2:3 book-cover image (`cover-image.png`) for the novella — moody, genre-appropriate, no text overlaid.
6. Write the chapter to `My-Library/Books/Serialized-Novella/<novella-slug>/chapter-NN.md` (zero-padded two-digit chapter number). Update `metadata.md` in that folder with: title, chapter number, date, running word count, current synopsis (condense the synopsis by one sentence each chapter to keep it ≤ 150 words). Update the state file.
7. Commit and push to `mike_desktop` on the AI-Automation-Library remote.
8. Send an AgentMail email to Mike with the chapter text pasted in the body, the novella title + chapter number in the subject, and the cover attached (chapter 1 only).

Wire the PowerShell wrapper at `/tasks/jobs/run_serialized-novella.ps1` invoked by `run-job.sh`. Validate one real artifact (chapter 1 of the first novella) end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-poetry-collection` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Short Story job structure (Gemini SDK). The job runs every Wednesday at 05:00 via cron + watchdog (max_age 8d).

State file: `/tasks/jobs/state/poetry_theme_index.json` — tracks which theme is next. Theme list (rotate through indefinitely): Grief & Recovery / City at Dawn / Deep Ocean / Childhood Memory / The Algorithm / Seasons Turning / Forgotten Places / Hunger & Abundance / Light After Dark / Violence & Peace / Technology & Body / Wild Silence. Each theme drives one full week's set.

Each run:
1. Read the state file; pick the current theme; increment the index.
2. Use the `google-genai` SDK with model `gemini-3.1-pro-preview` to generate:
   a. A one-paragraph thematic introduction (100–130 words) framing the week's emotional territory.
   b. Five original poems on the theme — vary the forms across the set (e.g., free verse, sonnet, villanelle, prose poem, haiku sequence). Each poem should be titled. No filler, no clichés — prioritize surprising imagery and rhythmic precision.
3. Use model `gemini-3.1-flash-image` to generate one 3:1 landscape decorative header illustration for the week — abstract, painterly, thematically resonant, no text.
4. Write `poems-<date>.md` (intro + all five poems with titles and form labels) and `header-<date>.png` into `My-Library/Books/Poetry/<Month_YYYY>/`. Write `metadata.md` in that folder updating the collection index (appending date + theme + poem titles).
5. Commit and push to `mike_desktop`.
6. Send an AgentMail with the full poem text in the body, this week's theme in the subject, and the header image attached.

Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-poetry-collection.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold two related agent-runner jobs called `flash-fiction-story` and `flash-fiction-anthology` following AI-Library-Automations/PORTING-PLAYBOOK.md. Copy the Weekly Short Story job for prose generation (Gemini SDK) and the Recipe job for the PDF compile step (pure-Python xhtml2pdf + svglib<1.6, already in the agent-runner image).

JOB 1 — flash-fiction-story (cron: Tuesday & Friday 06:30, watchdog max_age 4d):
State file: `/tasks/jobs/state/flash_fiction_genre_index.json` tracking the next genre. Genre list (rotate): Magical Realism / Dystopian Vignette / Horror Flash / Romantic Comedy Beat / Sci-Fi Snapshot / Historical Moment / Surrealist Fable / Literary Slice-of-Life.
Each run:
1. Pick the next genre; generate one flash-fiction story (350–550 words) using `google-genai` SDK model `gemini-3.1-pro-preview` — tight premise, strong voice, satisfying turn at the end. Give it a title.
2. Save to `My-Library/Books/Flash-Fiction/<Month_YYYY>/stories/<slugified-title>_<date>/` with a YAML frontmatter block (title, date, genre, word_count).
3. Commit + push to `mike_desktop`. No email for story runs (anthology email handles it).

JOB 2 — flash-fiction-anthology (cron: 1st of month 07:00, watchdog max_age 33d):
Each run:
1. Glob all `*.md` story files from `My-Library/Books/Flash-Fiction/<Month_YYYY>/stories/<Month_YYYY>-<MM>-*.md` for the just-completed month.
2. Concatenate them (sorted by date) into a single markdown document with a title page and table of contents.
3. Use `gemini-3.1-flash-image` to generate an anthology cover (2:3, painterly, no text) and save as `cover-<Month_YYYY>-MM.png`.
4. Convert markdown → PDF using xhtml2pdf (markdown→HTML via python-markdown, then HTML→PDF). Embed cover image. Save to `My-Library/Books/Flash-Fiction/<Month_YYYY>/anthologies/<Month_YYYY>-MM-anthology.pdf`.
5. Commit + push to `mike_desktop`.
6. Send an AgentMail with the PDF attached, story count + month in the subject, and a table of contents in the body.

Wire both PowerShell wrappers at `/tasks/jobs/run_flash-fiction-story.ps1` and `/tasks/jobs/run_flash-fiction-anthology.ps1`. Validate one story run and one anthology compile end-to-end before scheduling.

Scaffold a new agent-runner job called `cyoa-story` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Short Story job structure (Gemini SDK). The job runs every Thursday at 06:00 via cron + watchdog (max_age 8d).

State file: `/tasks/jobs/state/cyoa_state.json` — tracks: `story_slug`, `next_node_id` (int, starts at 1), `pending_branches` (array of objects: `{node_id, parent_id, choice_text, summary}` — the queue of unwritten branches from prior nodes).

Setup (first run only): if `pending_branches` is empty and `next_node_id` == 1, generate the opening node — a 400–600 word scene that sets the story world (genre: dark fairy tale), protagonist, and immediate crisis, ending with exactly three labelled choices. Record those three choices in `pending_branches`.

Subsequent runs:
1. Pop the first item from `pending_branches` (FIFO) to get the branch to write next.
2. Read the parent node file and any ancestor nodes (up to three levels back) to maintain narrative continuity.
3. Use `google-genai` SDK model `gemini-3.1-pro-preview` to write a 350–550 word scene for this branch that: references the choice the reader made, advances the plot in a surprising direction, and ends with 2–3 new labelled choices (or, if this node is a natural story terminus, ends with a resolution and the word ENDING in bold).
4. Write the scene to `My-Library/Books/Choose-Your-Adventure/<story-slug>/nodes/node-NNN.md` with YAML frontmatter (node_id, parent_id, choice_made, choices_offered as a list). If not an ENDING node, append the new choices to `pending_branches` in the state file.
5. Regenerate `index.md` in the story folder — a markdown tree showing all written nodes, their parent links, and the choice text connecting them.
6. Commit + push to `mike_desktop`.
7. Send an AgentMail with the new scene pasted in the body, node number + choice made in the subject, and a note of how many pending branches remain in the queue.

Wire the PowerShell wrapper at `/tasks/jobs/run_cyoa-story.ps1` invoked by `run-job.sh`. Validate the first run (opening node + three-branch queue) end-to-end before scheduling.

Scaffold a new agent-runner job called `worldbuilding-codex` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Short Story job structure (Gemini SDK text + image). The job runs every Saturday at 06:30 via cron + watchdog (max_age 8d).

State file: `/tasks/jobs/state/worldbuilding_codex_state.json` — tracks `world_slug` (set once: "aethermere"), `entry_queue` (ordered list of entry topics to write, described below), and `written_entries` (list of filenames written so far).

Entry queue (pre-populate in the state file at scaffold time, 52 entries — one per week for a year): Geography: The Shattered Archipelago / The Ashen Wastes / The Verdant Undercity / ... then Factions: The Tidecallers Guild / The Iron Covenant / ... then History: The First Sundering / The Age of Lattice-Mages / ... then Creatures: The Veilwyrm / The Saltborn / ... and so on — generate the full 52-item list programmatically in the scaffold script based on six categories (Geography, Factions, History, Creatures, Magic & Technology, Notable Figures) with ~8–9 entries each.

Each run:
1. Pop the next topic from `entry_queue`.
2. Read up to five previously written entries (the most recent, or topically adjacent ones referenced in the topic name) to maintain internal consistency.
3. Use `google-genai` SDK model `gemini-3.1-pro-preview` to write a 700–850 word codex entry in an encyclopedic voice — clear headings (Origin, Description, Significance, Notable Facts), vivid world-specific detail, internal cross-references to previously written entries where relevant.
4. Use model `gemini-3.1-flash-image` to generate one 1:1 illustration appropriate to the entry type (map fragment for geography, emblem for factions, portrait sketch for figures, creature study for creatures). Save as `<date>-<entry-slug>.png`.
5. Write `<entry-slug>_<date>/` with YAML frontmatter (category, topic, date, cross_refs list) to `My-Library/Books/Worldbuilding-Codex/aethermere/entries/`. Regenerate `index.md` in the codex root — a table listing all entries by category with dates and links.
6. Commit + push to `mike_desktop`.
7. Send an AgentMail with the entry text in the body, entry topic + category in the subject, and the illustration attached.

Wire the PowerShell wrapper at `/tasks/jobs/run_worldbuilding-codex.ps1`. Validate one real entry (first geography entry) end-to-end before scheduling.

Scaffold a new agent-runner job called `fable-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Short Story job structure (Gemini SDK text + image). The job runs every Friday at 06:00 via cron + watchdog (max_age 8d).

State file: `/tasks/jobs/state/fable_state.json` — tracks `style_index` (cycles through three styles: 0=Aesop Greek / 1=La Fontaine French / 2=West African oral) and `moral_themes_used` (list of moral themes already written, to avoid repeats).

Moral theme pool (embed in the script, ~40 themes): pride before the fall / patience outlasts force / cleverness without wisdom / loyalty tested / envy's blindness / generosity repaid / the cost of silence / small actions, great consequences / knowledge vs. understanding / etc. — write the full list in the scaffold.

Each run:
1. Read the style index; pick the next style. Pick a moral theme not yet used (randomize from remaining pool).
2. Use `google-genai` SDK model `gemini-3.1-pro-preview` to write a 450–650 word fable in the chosen style:
   - Aesop: animal characters, crisp declarative prose, explicit moral statement at the end ("The moral: …")
   - La Fontaine: may include human/divine characters, slightly lyrical prose, ironic tone, moral embedded in the final paragraph
   - West African oral: call-and-response echoes ("And so it was…"), communal protagonist (a village, a family), moral woven through rather than stated at the end
3. Use model `gemini-3.1-flash-image` to generate a 1:1 square woodcut-style illustration — black ink on aged parchment aesthetic, high contrast, depicting the climactic scene of the fable. No text in the image.
4. Write `fable-<date>.md` (fable text with a YAML frontmatter block: style, moral_theme, word_count) and `fable-<date>.png` into `My-Library/Books/Fables/<Month_YYYY>/`. Update `metadata.md` in that folder (append: date, style, moral theme, fable title).
5. Update the state file (increment style_index mod 3; add theme to used list).
6. Commit + push to `mike_desktop`.
7. Send an AgentMail with the fable text in the body, style + moral theme in the subject, and the illustration attached.

Wire the PowerShell wrapper at `/tasks/jobs/run_fable-of-the-week.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `fictional-newspaper` following AI-Library-Automations/PORTING-PLAYBOOK.md. Use Claude (`claude --print`) as the writing engine (built-in WebSearch — no serper MCP needed). The job runs every Sunday at 05:30 via cron + watchdog (max_age 8d).

State file: `/tasks/jobs/state/fictional_newspaper_state.json` — tracks `edition_number` (int, starts at 1) and `setting_index` (cycles through: 0=Aethermere the-fantasy-world / 1=New Meridian the-solarpunk-city / 2=Coldwater Station the-arctic-research-colony).

Each run:
1. Read the state file; select the current setting.
2. Invoke `claude --print` with a prompt that:
   a. Uses built-in WebSearch to scan 3–5 current real-world headlines for thematic inspiration (geopolitics, science, culture — the Claude prompt should say "find 3–5 real headlines this week and use them as loose inspiration for fictional equivalents, transposed into the [setting] world — do not copy real names or places").
   b. Writes the full fictional newspaper front page in markdown with these sections, all set in the chosen fictional world:
      - Masthead: newspaper name, fictional date, edition number, motto
      - LEAD: a 450–600 word front-page story with a punchy headline, byline, and body text
      - BELOW THE FOLD A: a 130–160 word second story with headline and byline
      - BELOW THE FOLD B: a 130–160 word third story with headline and byline
      - CLASSIFIEDS: 5–7 one-line fictional classified ads in the setting's voice
      - WEATHER: a 2-sentence fictional weather report for the setting's geography
3. After Claude writes the markdown, call the `google-genai` SDK with model `gemini-3.1-flash-image` to generate a broadsheet-layout front-page image — aged newsprint aesthetic, masthead text at top, large headline text below, a black-and-white editorial illustration in the center. Bake in the newspaper name, main headline, and fictional date as legible typography.
4. Write `edition_<date>/` and `<date>-front-page.png` into `My-Library/Books/Fictional-Newspaper/<Month_YYYY>/`. Update `metadata.md` (append: date, edition number, setting, main headline).
5. Increment `edition_number` and cycle `setting_index` in the state file. Commit + push to `mike_desktop`.
6. Send an AgentMail with the markdown text in the body, edition number + main headline in the subject, and the front-page image attached.

Wire the PowerShell wrapper at `/tasks/jobs/run_fictional-newspaper.ps1` invoked by `run-job.sh`. Validate one real edition end-to-end (confirm WebSearch fires and the markdown covers all six sections) before scheduling.

Scaffold a new agent-runner job called `daily-haiku-card` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Poster job structure (Gemini SDK daily cadence + image). The job runs daily at 04:00 via cron + watchdog (max_age 26h).

State file: `/tasks/jobs/state/haiku_season_index.json` — tracks `season_index` cycling through four seasons (0=Spring / 1=Summer / 2=Autumn / 3=Winter, one season per quarter of the year based on the actual calendar month).

Each run:
1. Determine the current season from the calendar month (Mar–May=Spring, Jun–Aug=Summer, Sep–Nov=Autumn, Dec–Feb=Winter) — no state file needed for this; derive it from the date.
2. Use `google-genai` SDK model `gemini-3.5-flash` to generate one haiku: exactly three lines, strict 5-7-5 syllable count, rooted in a concrete seasonal image (kigo), no clichés — a moment of quiet observation. Return only the three lines, no titles, no attribution.
3. Use model `gemini-3.1-flash-image` to generate a 1:1 (1024×1024) illustrated card: Japanese woodblock-print aesthetic (ukiyo-e inspired), the haiku's three lines rendered as calligraphy-style text in the lower third of the image, the upper two-thirds a painterly seasonal scene that echoes the haiku's imagery. Soft ink washes, limited palette of 3–5 colors, white or cream background.
4. Write `haiku-<date>.md` (YAML frontmatter: date, season, syllable_check boolean; then the three lines as a blockquote) into `My-Library/Books/Haiku-Journal/<Month_YYYY>/`. Write `haiku-<date>.png` alongside it.
5. Commit + push to `mike_desktop`.
6. Send an AgentMail with the three haiku lines as the entire email body (nothing else — let the haiku breathe), season + date in the subject, and the card image attached.

Wire the PowerShell wrapper at `/tasks/jobs/run_daily-haiku-card.ps1` invoked by `run-job.sh`. Validate one real artifact (haiku + card image) end-to-end, verifying the syllable counts are correct and the image contains legible haiku text, before scheduling.

Scaffold `weekly-microfiction-triptych` as an agent-runner Gemini job. Run Tuesdays at 07:30. Rotate genres and write three 600-900 word linked flash stories that share an object, place, or event but differ in protagonist and tone. Generate one cover image, save `story-01.md` through `story-03.md`, `cover-image.png`, `metadata.md` (genre, shared motif, word counts, model), and `prompt.md`. Commit/push, email the cover and summaries, and validate one real set.

Scaffold `monthly-public-domain-retelling` as an agent-runner job. Run monthly on day 8 at 07:30. Choose a public-domain myth, fairy tale, or classic scene, verify public-domain status/source with WebSearch, write a 2,000-3,500 word contemporary retelling, include `source-notes.md` with provenance and differences, generate a cover, and save all files with metadata. Commit/push, email the synopsis, and validate one artifact.

Scaffold `weekly-poetry-broadside` as an agent-runner job. Run Fridays at 07:30. Rotate forms (sonnet, villanelle, prose poem, haiku sequence, free verse, ghazal-inspired, ballad, ode), write an original poem, generate a tasteful illustration, and render a single-page printable broadside as PDF plus PNG preview. Save `poem.md`, `broadside.pdf`, `preview.png`, `metadata.md`, and `prompt.md`; commit/push, email the preview and poem, and validate one real run.

Scaffold a new agent-runner job called `weekly-alt-history` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Short Story job structure (Gemini SDK text + image, self-contained Python generator that prints ARTIFACT_* markers + a wrapper that commits/pushes and emails). Run every Friday at 10:00 CT via a cron line in /etc/cron.d/agent-cron plus a watchdog entry (max_age 8d).

Premise checklist: `My-Library/Books/Alternate-History/Prompts/alt-history-ideas.md` — a markdown checkbox list of one-line "what if" premises across eras (WWII turning points, Cold War, recent history, ancient/medieval, science & technology, nations & politics). Examples: "The Nazis win the Battle of Stalingrad", "The 9/11 hijackers are stopped at security before boarding", "JFK survives Dallas in 1963", "Rome never falls in 476". Each run takes the next unchecked premise and marks it [x] with the output path after a successful save; when the list is exhausted, the model invents a fresh premise (a real, well-documented turning point, changed at one clear point of divergence). Also write the base prompt template `Prompts/alt-history.md`.

Each run:
1. Take the next premise. Call the `google-genai` SDK model `gemini-3.1-pro-preview` ONCE (JSON mode) to write: title, kebab-case slug, a one-sentence premise, the divergence_point (the real event/date and exactly how it changed), an era label, a one-paragraph synopsis, a ~120-word intro establishing the real history, EXACTLY 8 forward-marching titled sections (~100-130 words each), and a per-section `image_prompt` for a single illustratable scene from that beat — plus a cover_image_prompt. Editorial guardrails (bake into the template): plausible second/third-order consequences, no magic; treat real people and tragedies with respect; non-graphic — the human and geopolitical aftermath, never gore or glorified violence; even-handed and historically literate.
2. Render the cover (2:3) and one 16:9 scene per section with model `gemini-3.1-flash-image`. Append a single shared art-direction string to every image prompt (cinematic historical concept-art, painterly realism, dramatic light; no text/letters/logos/watermarks) so the pack reads as one piece. A single failed scene render is non-fatal — omit that scene.
3. Write `story.md`: YAML frontmatter, the intro, then each section as `## heading` + text + an inline `![heading](scene-NN.png)` beneath it (relative ref — the site manifest builder rewrites it to a /library URL and renders it in the markdown body; do NOT inline the cover, it is the page hero). Also write `synopsis.md`, `metadata.md` (models, premise, divergence point, real events/figures, scenes rendered N/8), `scene-prompts.md`, and `cover-prompt.md`. File the folder as `My-Library/Books/Alternate-History/<Month_YYYY>/<slug>_<date>/`.
4. Commit + push to `mike_desktop` (stage the whole Alternate-History dir so the checklist mutation rides along; rebase-retry once).
5. Send an AgentMail (house-style HTML body) with the premise/era/synopsis and the cover attached.

Register a NEW web-app gallery category `alternate-history` (it is a card shape the gallery hasn't shown): add a `walkAlternateHistory` walker to Site/scripts/build-manifest.mjs and register the category across Site/src/lib/manifest.ts, Site/src/styles/global.css, and Site/src/lib/category-icons.ts (model it on the short-story walker; it renders as a markdown body with the scene images woven in). Add a calendar row and a runbook.

Wire the PowerShell wrapper at `/tasks/jobs/run_weekly_alt_history.ps1` invoked by `run-job.sh`. Validate one real piece end-to-end (8 sections, cover + scenes on disk, inline images resolve in the gallery, email sent) before scheduling.

Scaffold a new agent-runner job called `weekly-browser-game` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly App Prototype job (Claude + nanobanana MCP). The job runs every Wednesday at 11:00 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) picks a game genre from a rotating list in the script (arcade shooter, puzzle-platformer, memory card match, snake variant, brick-breaker, tower defense, word scramble, rhythm clicker, maze, idle clicker — one per week cycling), (2) writes a complete self-contained single-file browser game as `index.html` — all CSS and JavaScript inline, zero external files, only CDN dependencies allowed (prefer vanilla canvas/JS; p5.js CDN acceptable for generative or physics games), the game must be immediately playable on open with keyboard or mouse controls, include a score display and a restart mechanism, and be mobile-touch-aware, (3) calls nanobanana `generate_image` to create a 16:9 cover image depicting the game's visual style and title, saved as `cover-image.png`. Output `index.html`, `cover-image.png`, and `metadata.md` (date, genre, controls summary, CDN deps used) into `My-Library/Apps/Prototypes/<Month_YYYY>/game-<slug>_<date>/`. Commit all three files and push to `mike_desktop` on the AI-Automation-Library remote. Send an AgentMail email to Mike with the cover image attached, the game genre and a one-sentence gameplay description in the body, and a note that the artifact is live in the library. Use built-in WebSearch (not serper MCP — it is unavailable on this box) if the run needs external data. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `daily-coding-challenge` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Daily App Card job (Claude + nanobanana MCP). The job runs daily at 08:00 via cron + watchdog (max_age 26h). Each run: invoke `claude --print` with a prompt that (1) picks a challenge category from a rotating list in the script (arrays & strings, recursion, dynamic programming, graph traversal, bit manipulation, sorting algorithms, hash maps, two-pointer, sliding window, tree traversal — cycling daily), (2) invents a fresh, non-trivial coding challenge for that category — write a clear problem statement with 2–3 concrete examples and explicit input/output constraints, then produce a complete worked solution in Python with inline comments explaining each decision, time and space complexity analysis, and a brief note on alternative approaches, (3) renders everything as a beautiful self-contained `index.html` — dark-themed card layout, the problem statement in a highlighted callout box, the solution in a syntax-highlighted code block (use highlight.js CDN), complexity table, and a collapsible "Alternative Approaches" section, (4) calls nanobanana `generate_image` to create a square cover image in a minimal tech/code aesthetic with the challenge category as the title, saved as `cover-image.png`. Output `index.html`, `cover-image.png`, and `metadata.md` (date, category, problem title, time complexity, space complexity) into `My-Library/Apps/Idea-Cards/<Month_YYYY>/challenge-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached and the problem title + category in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-data-dashboard` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly App Prototype job (Claude + nanobanana MCP). The job runs every Tuesday at 10:00 via cron + watchdog (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to gather the week's top 8–12 data points for a rotating topic domain (S&P 500 sector performance, global temperature anomalies, AI research paper counts by category, sports standings + stat leaders, tech company stock moves, crypto market caps, box-office revenue, global news sentiment by region — one domain per week cycling), (2) writes all the gathered data as inline JavaScript constants inside a complete self-contained `index.html` dashboard — use Chart.js CDN for at least two chart types (e.g., bar + line), include a filter dropdown or date-range toggle, a sortable data table, and a responsive two-column layout; no external data fetches at runtime — all data is baked into the file, (3) calls nanobanana `generate_image` to create a 16:9 cover image depicting the dashboard's domain with a data-visualization aesthetic, saved as `cover-image.png`. Output `index.html`, `cover-image.png`, and `metadata.md` (date, domain, data source summary, CDN deps, data points count) into `My-Library/Apps/Prototypes/<Month_YYYY>/dashboard-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached, the domain name, and the top 3 findings as bullet points in the body. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-dev-tool` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly App Prototype job (Claude + nanobanana MCP). The job runs every Thursday at 11:00 via cron + watchdog (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) picks a developer micro-tool type from a rotating list in the script (regex tester with live match highlighting, cron expression explainer, color palette picker + hex/RGB/HSL converter, JSON/YAML formatter + validator, base64 encoder-decoder, JWT decoder, UUID v4 generator + bulk mode, Markdown previewer, diff viewer, URL encoder-decoder, timestamp converter — one per week cycling), (2) writes a complete self-contained `index.html` implementation of that tool — all logic inline, zero backend, CDN-only deps, a polished dark-themed UI with Tailwind CDN, keyboard shortcuts where natural, copy-to-clipboard on all outputs, and a brief "how to use" tooltip or help section, (3) calls nanobanana `generate_image` to create a square cover image depicting the tool type in a clean monochrome dev-tool aesthetic with the tool name as the title, saved as `cover-image.png`. Output `index.html`, `cover-image.png`, and `metadata.md` (date, tool type, key features, CDN deps) into `My-Library/Apps/Prototypes/<Month_YYYY>/tool-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached, the tool name, and a two-sentence description of what it does in the body. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-generative-art` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly App Prototype job (Claude + nanobanana MCP). The job runs every Saturday at 11:00 via cron + watchdog (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) picks a generative-art algorithm from a rotating list in the script (Perlin-noise terrain, particle attractor system, L-system plant growth, reaction-diffusion pattern, Voronoi diagram, recursive fractal tree, flow-field vectors, cellular automaton, spirograph harmonograph, Conway's Game of Life with custom seeds — one per week cycling), (2) writes a complete self-contained `index.html` generative-art toy — use p5.js CDN for canvas drawing; the sketch must animate continuously, expose 3–5 user-controllable parameters as labeled HTML range sliders rendered below the canvas (e.g., speed, density, color hue, complexity), include a "Randomize" button that re-seeds the algorithm, and a "Save PNG" button that downloads the current frame; the canvas must be full-width and at minimum 600px tall, (3) calls nanobanana `generate_image` to create a square cover image that captures the visual style of the algorithm — abstract, vivid, mathematically beautiful — with the algorithm name as a minimal label, saved as `cover-image.png`. Output `index.html`, `cover-image.png`, and `metadata.md` (date, algorithm, controllable parameters listed, CDN deps) into `My-Library/Apps/Prototypes/<Month_YYYY>/genart-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached, the algorithm name, and a one-sentence description of what the toy does in the body. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-ai-news-quiz` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly App Prototype job (Claude + nanobanana MCP). The job runs every Friday at 12:00 via cron + watchdog (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to gather the week's 10 most significant AI, machine learning, and tech news stories (model releases, research breakthroughs, policy decisions, company moves, product launches), (2) writes 10 multiple-choice quiz questions — one per story — each with 4 answer options (A–D), the correct answer marked, and a 1–2 sentence explanation of why it is correct plus brief context on the story, (3) renders everything as a complete self-contained `index.html` quiz app — dark-themed, one question at a time with a progress bar, immediate per-question feedback (green/red highlight + explanation shown after answering), a final score screen with a performance message and a "Retake" button, all quiz data baked inline as a JS constant (no runtime fetches), (4) calls nanobanana `generate_image` to create a 16:9 cover image with a quiz-game aesthetic, bold "AI News Quiz" title, and visual references to tech/AI, saved as `cover-image.png`. Output `index.html`, `cover-image.png`, and `metadata.md` (date, week range, question count, top 3 story headlines) into `My-Library/Apps/Prototypes/<Month_YYYY>/quiz-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached and the top 3 story headlines as bullet points in the body. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-physics-sim` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly App Prototype job (Claude + nanobanana MCP). The job runs every Sunday at 11:00 via cron + watchdog (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) picks a physics or mathematics topic from a rotating list in the script (projectile motion with drag, double pendulum chaos, orbital gravity n-body, wave interference and superposition, electric field lines, Fourier series approximation, Mandelbrot set explorer, sorting algorithm visualizer, prime sieve of Eratosthenes, Bezier curve construction — one per week cycling), (2) writes a complete self-contained `index.html` simulation — vanilla JS + HTML5 canvas (no external libraries unless MathJax CDN is needed for equations), animated at 60fps using requestAnimationFrame, a two-column layout with the canvas on the left and a labeled control panel + explanatory text sidebar on the right, at least 3 user-adjustable parameters as sliders, a "Pause/Resume" button, and a "Reset" button; the explanatory sidebar must include a plain-English description of the physics/math concept, the governing equation(s) rendered as text or MathJax, and a "why it matters" note, (3) calls nanobanana `generate_image` to create a square cover image depicting the simulation's visual output in a scientific-illustration style with the topic name as a clean label, saved as `cover-image.png`. Output `index.html`, `cover-image.png`, and `metadata.md` (date, topic, adjustable parameters listed, CDN deps if any) into `My-Library/Apps/Prototypes/<Month_YYYY>/sim-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached, the topic name, and the governing equation in the body. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-chrome-extension-concept` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Daily App Card job (Claude + nanobanana MCP) but running weekly. The job runs every Monday at 11:00 via cron + watchdog (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to identify a current browser-productivity pain point or a trending developer/AI tool trend that a Chrome extension could address, (2) invents a concrete Chrome-extension concept: give it a name, one-sentence pitch, and 4–6 feature bullet points, then write (a) a complete `manifest.json` v3 for the extension with appropriate permissions and content-script declarations, and (b) a realistic 30–50 line content-script snippet (`content.js`) or background-service-worker snippet (`background.js`) demonstrating the core mechanic — the code must be syntactically correct and logically sound even if incomplete, (3) renders everything as a beautiful self-contained `index.html` concept card — dark-themed, the extension name as a large header, pitch as a subtitle, a browser-window mockup div showing the extension popup UI (built with inline HTML/CSS), the feature list, the `manifest.json` in a syntax-highlighted code block (highlight.js CDN), and the script snippet in a second code block with copy-to-clipboard, (4) calls nanobanana `generate_image` to create a square cover image styled like a Chrome Web Store listing tile — extension icon area, name, and a clean promotional banner aesthetic — saved as `cover-image.png`. Output `index.html`, `cover-image.png`, and `metadata.md` (date, extension name, pitch, permission list, pain point addressed) into `My-Library/Apps/Idea-Cards/<Month_YYYY>/extension-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached, the extension name and one-sentence pitch in the subject, and the 4–6 feature bullets in the body. Validate one real artifact end-to-end before scheduling.

Scaffold `weekly-personal-finance-calculator` as an agent-runner Claude + nanobanana job. Run Tuesdays at 12:00. Rotate calculator types (compound interest, debt payoff, emergency fund, mortgage comparison, Roth vs traditional, credit-card rewards, savings goal, subscription audit). Generate a self-contained `index.html` with inline JS, responsive controls, charts if useful via Chart.js CDN, input validation, and no runtime network calls. Add `cover-image.png` and `metadata.md`; commit/push, email the cover and calculator type, and validate in a browser.

Scaffold `weekly-kids-learning-game` as an agent-runner job. Run Saturdays at 12:00. Rotate topics (multiplication, spelling, geography flags, planets, fractions, typing, music notes, animal habitats). Build a polished self-contained `index.html` playable by mouse/touch, with score, levels, friendly feedback, restart, and accessible colors. Generate `cover-image.png`, write `metadata.md`, commit/push, email details, and validate desktop/mobile viewport behavior.

Scaffold `weekly-prompt-engineering-playground` as an agent-runner job. Run Mondays at 12:00. Rotate use cases (code review, research brief, image prompt, lesson plan, data analysis, sales email, support macro, agent spec). Generate a self-contained `index.html` that lets users fill variables, toggle tone/format/constraints, preview the final prompt, and copy it. No API calls. Generate `cover-image.png`, `metadata.md`, commit/push, email the use case, and validate one real artifact.

Scaffold a new agent-runner job called `weekly-travel-itinerary-map` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly AI Map job (Claude + nanobanana, Leaflet HTML output). The job runs every Tuesday at 05:30 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry (cadence 8d). Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to pick a compelling multi-stop travel destination cluster — rotate weekly through themes: coastal road trips, mountain circuit tours, European city hops, national-park loops, foodie-city circuits, island chains, ancient-ruins trails, cross-country rail itineraries; (2) researches 6–10 stops with real lat/lon coordinates, brief description, recommended activity, and estimated travel time to next stop; (3) writes a self-contained Leaflet HTML file with numbered circle markers in sequential order, a polyline connecting them in route order, rich popup cards (stop name, activity, travel-time badge, 2-sentence description), a legend, and a title banner — no external CDN dependencies beyond the Leaflet CDN link (unpkg), all GeoJSON/data embedded inline; (4) writes an `itinerary.md` with a full human-readable narrative of the route; (5) calls nanobanana `generate_image` for a scenic cover illustration matching the destination theme (wide landscape or travel-poster style). Output all four files into `My-Library/Maps/AI-Generated-Maps/<Month_YYYY>/itinerary-<slug>_<date>/`: `map.html`, `itinerary.md`, `cover-image.png`, `metadata.md` (date, destination theme, stop count, coordinates bounding box, model). Commit and push to `mike_desktop` on the AI-Automation-Library remote. Send an AgentMail email to Mike with the cover image attached and the route name + stop count in the subject. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-travel-itinerary-map.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-historical-event-map` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly AI Map job (Claude + nanobanana, Leaflet HTML output). The job runs every Wednesday at 05:30 via cron + watchdog (cadence 8d). Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to pick a historically significant event cluster — rotate weekly through themes: famous battles, exploration voyages, migration waves, trade routes, revolutionary movements, scientific expeditions, empire expansions, disaster events; (2) researches 6–12 key sites or waypoints with verified lat/lon, dates, and a 2–3 sentence description of what happened there; (3) writes a self-contained Leaflet HTML with color-coded markers (differentiated by event phase or type), timeline-style popups showing date + significance, a polyline where movement is the story (voyages, campaigns, migrations), a map title and era badge — all data embedded inline, Leaflet CDN only; (4) writes a `writeup.md` with a narrative essay covering the full event arc; (5) calls nanobanana `generate_image` for a dramatic historical-illustration cover (period-appropriate art style referencing the event). Output `map.html`, `writeup.md`, `cover-image.png`, `metadata.md` (date, event name, era, location count, model) into `My-Library/Maps/AI-Generated-Maps/<Month_YYYY>/history-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached and the event name + era in the subject. Wire `/tasks/jobs/run_weekly-historical-event-map.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-best-x-by-state-map` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly AI Map job (Claude + nanobanana, Leaflet HTML output). The job runs every Thursday at 05:30 via cron + watchdog (cadence 8d). Each run: invoke `claude --print` with a prompt that (1) picks a rotating weekly category from a list embedded in the prompt: iconic regional food, state parks by visitor count, craft-beer breweries per capita, college football culture, oddest roadside attractions, BBQ styles, state fair foods, hot springs and natural pools, haunted landmarks, drive-in movie theaters — one per week cycling; (2) uses built-in WebSearch to research the top pick for each of the 50 US states in that category, plus a short justification sentence; (3) writes a self-contained Leaflet HTML US map using an embedded US-states GeoJSON (include the simplified GeoJSON inline — use a compact 50-state boundary dataset Claude generates or a well-known public-domain version), fills each state with a color from a 5-tier palette (top-tier = darkest, unranked = lightest), click popups showing state name + winner + justification, a legend, map title; (4) writes a `writeup.md` listing all 50 state picks with context; (5) calls nanobanana `generate_image` for a bold illustrated cover referencing the category theme. Output `map.html`, `writeup.md`, `cover-image.png`, `metadata.md` (date, category, model) into `My-Library/Maps/AI-Generated-Maps/<Month_YYYY>/bestx-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached and the category in the subject. Wire `/tasks/jobs/run_weekly-best-x-by-state-map.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-fantasy-world-map` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly AI Map job (Claude + nanobanana, Leaflet HTML output). The job runs every Friday at 05:30 via cron + watchdog (cadence 8d). Maintain a state file at `/tasks/jobs/state/fantasy_world_map_state.json` that tracks the current world name, chapter number, and a list of already-placed locations so each weekly map expands the same serialized world rather than starting fresh. Each run: invoke `claude --print` with a prompt that (1) reads the state file to recall the established world, then invents or expands 6–10 new named locations (cities, ruins, forests, mountain ranges, bodies of water, dungeons) consistent with the world's established lore, with fictional lat/lon in a 0–100 coordinate space treated as the world map grid; (2) writes a self-contained Leaflet HTML using a plain parchment-colored tile background (set `L.tileLayer` to a blank/off-white canvas using a data: URI or Leaflet's built-in `#fff` background), custom circle and icon markers in a fantasy color palette (dark gold, deep green, crimson, slate), popups with location name + lore blurb + story hook; includes all previously placed locations from state (smaller markers, muted color) so the world accumulates week over week; (3) writes a `lore.md` with the world name, current chapter, and narrative descriptions of all new locations; (4) updates the state file with the new locations appended; (5) calls nanobanana `generate_image` for a fantasy-map cover illustration in an ink-and-parchment style. Output `map.html`, `lore.md`, `cover-image.png`, `metadata.md` (date, world name, chapter, new location count, total location count, model) into `My-Library/Maps/AI-Generated-Maps/<Month_YYYY>/fantasy-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached and the world name + chapter number in the subject. Wire `/tasks/jobs/run_weekly-fantasy-world-map.ps1`. Validate one real artifact end-to-end (chapter 1, 6 locations, fresh state) before scheduling.

Scaffold a new agent-runner job called `weekly-road-trip-planner-map` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly AI Map job (Claude + nanobanana, Leaflet HTML output). The job runs every Saturday at 05:30 via cron + watchdog (cadence 8d). Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to pick a classic or underrated US (or occasional international) road-trip route — rotate weekly through themes: Pacific Coast Highway, Blue Ridge Parkway, Route 66 segment, Great River Road, Overseas Highway, Going-to-the-Sun Road, Natchez Trace, Lincoln Highway, Loneliest Road in America, Beartooth Highway; (2) researches the route in detail — start/end cities, real lat/lon waypoints every 30–60 miles, and 8–12 notable POIs along the way categorized as: scenic overlooks, roadside oddities, historic sites, best local eats, campgrounds/lodging options; (3) writes a self-contained Leaflet HTML with a thick polyline tracing the route, color-coded POI markers by category (use a distinct color + custom HTML icon label for each category), popups with POI name + category + 2-sentence description + estimated distance from start, a route summary sidebar div showing total miles and recommended days; (4) writes a `trip-guide.md` with a day-by-day driving plan; (5) calls nanobanana `generate_image` for a sun-drenched road-trip cover illustration. Output `map.html`, `trip-guide.md`, `cover-image.png`, `metadata.md` (date, route name, total miles, POI count, model) into `My-Library/Maps/AI-Generated-Maps/<Month_YYYY>/roadtrip-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached and the route name in the subject. Wire `/tasks/jobs/run_weekly-road-trip-planner-map.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-star-chart-map` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly AI Map job (Claude + nanobanana, Leaflet HTML output). The job runs every Sunday at 05:30 via cron + watchdog (cadence 8d). Each run: invoke `claude --print` with a prompt that (1) determines the current week's most prominent astronomical theme — rotate through: Orion and the winter hexagon, the summer triangle, zodiac belt segment, circumpolar constellations, southern sky showcase, Milky Way core region, famous deep-sky objects (Messier catalog highlights), current bright planets + where to find them; (2) maps the selected sky region using RA/Dec converted to a flat 0–360 × −90–90 coordinate space (treated as Leaflet's lat/lon with CRS.Simple), places star markers sized proportionally to visual magnitude (largest circle = brightest), colors them by spectral type (O/B = blue-white, G = yellow, K/M = orange/red), draws constellation stick-figure polylines in dim gold, marks notable deep-sky objects with a distinct icon, adds informational popups on each named star or object; sets the Leaflet tile background to solid black (#0a0a1a) and disables the default tile layer; (3) writes a `sky-guide.md` describing each constellation and object featured; (4) calls nanobanana `generate_image` for a dramatic night-sky illustration cover. Output `map.html`, `sky-guide.md`, `cover-image.png`, `metadata.md` (date, sky region theme, star count, model) into `My-Library/Maps/AI-Generated-Maps/<Month_YYYY>/starchart-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached and the sky region theme in the subject. Wire `/tasks/jobs/run_weekly-star-chart-map.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-food-crawl-map` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly AI Map job (Claude + nanobanana, Leaflet HTML output). The job runs every Monday at 07:00 via cron + watchdog (cadence 8d) — note the 07:00 start time to avoid collision with the existing Weekly AI Map at 05:30. Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to pick a food-crawl city and theme — rotate weekly through: New Orleans French Quarter cocktail crawl, Chicago deep-dish + tavern tour, Tokyo ramen district walk, Portland food-cart pod circuit, New York City pizza slice tour, Nashville hot chicken crawl, San Francisco dim sum + Mission burrito loop, Austin BBQ trail, Oaxaca market and mezcal walk, Charleston Lowcountry seafood route; (2) researches 8–12 specific real establishments with real addresses converted to approximate lat/lon, cuisine type, signature dish, price range, and a 1–2 sentence reason to visit; (3) writes a self-contained Leaflet HTML with markers color-coded by meal type (breakfast/brunch = amber, lunch = green, dinner = indigo, bar/drinks = crimson, market/shop = teal), a numbered walking-route polyline connecting them in recommended crawl order, popups with establishment name + cuisine badge + signature dish + price range ($ to $$$$) + short blurb, a map title and city banner; (4) writes a `crawl-guide.md` with a full narrative guide including logistics (best time of day, how to pace the crawl, transport tips); (5) calls nanobanana `generate_image` for a vibrant street-food illustration cover. Output `map.html`, `crawl-guide.md`, `cover-image.png`, `metadata.md` (date, city, crawl theme, stop count, model) into `My-Library/Maps/AI-Generated-Maps/<Month_YYYY>/foodcrawl-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached and the city + crawl theme in the subject. Wire `/tasks/jobs/run_weekly-food-crawl-map.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-rpg-map` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Weekly AI Map job (Claude + nanobanana, Leaflet HTML output). The job runs every Thursday at 07:00 via cron + watchdog (cadence 8d) — 07:00 to avoid collision with the Weekly Historical Event Map at 05:30. Each run: invoke `claude --print` with a prompt that (1) picks a rotating map type from: multi-level dungeon crawl, overworld wilderness region, city-district street map, sea-chart with island encounters, underground cavern network, crashed-spaceship interior (sci-fi RPG), haunted manor floor plan, planar realm map, ancient temple complex; (2) designs the map — 10–20 named rooms, zones, or locations on a 0–100 × 0–100 coordinate grid, each with: type (room/corridor/boss chamber/safe zone/shop/secret), controlling faction or monster type, suggested encounter CR or loot table entry, a flavor-text description; (3) writes a self-contained Leaflet HTML using `L.CRS.Simple` (no tile layer, white or parchment #f5eedc background), circle or polygon markers color-coded by zone type, polylines for corridors/paths, popups with location name + type badge + faction + encounter/loot hint + flavor text, a map title and scale legend; (4) writes a `region-notes.md` with GM/DM notes: overall layout rationale, faction motivations, 3 plot hooks, suggested session pacing; (5) calls nanobanana `generate_image` for a hand-drawn-style fantasy map cover illustration (ink-on-parchment or hex-grid aesthetic). Output `map.html`, `region-notes.md`, `cover-image.png`, `metadata.md` (date, map type, location count, model) into `My-Library/Maps/AI-Generated-Maps/<Month_YYYY>/rpgmap-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the cover image attached and the map type + title in the subject. Wire `/tasks/jobs/run_weekly-rpg-map.ps1`. Validate one real artifact end-to-end before scheduling.

Scaffold `weekly-literary-places-map` as an agent-runner Claude job. Run Wednesdays at 09:30. Pick one author, novel, or literary movement; use WebSearch to verify 8-12 real locations; build a self-contained Leaflet `index.html` with markers, popups, route/cluster controls as appropriate, citations baked into `metadata.md`, and a nanobanana `cover-image.png`. Commit/push, email the map topic and location list, and validate the HTML opens locally.

Scaffold `monthly-infrastructure-megaproject-map` as an agent-runner job. Run monthly on day 5 at 09:30. Rotate regions and project types (rail, ports, bridges, energy, broadband, water, airports). Research 10-20 active or recently completed projects, emit `projects.csv`, build a Leaflet `index.html` with category filters and popups showing budget/status/source, generate `cover-image.png`, and save `metadata.md`. Commit/push, email top projects, and validate one real map.

Scaffold `weekly-walking-tour-map` as an agent-runner job. Run Sundays at 09:30. Pick a city/neighborhood, research 8-10 walkable stops, create a 2-4 mile route, and build `index.html` with Leaflet route line, stop cards, estimated walking time, source links, and a printable itinerary `tour.md`. Generate `cover-image.png`, save metadata, commit/push, email the route summary, and validate one real tour.

Scaffold a new agent-runner job called `weekly-meal-plan` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Recipe of the Week job but using Claude (`claude --print`) instead of Codex. The job runs every Sunday at 09:00 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to check the current season and any notable food trends or seasonal produce available now, (2) writes a 7-day dinner meal plan (Monday–Sunday) themed around the season — each night gets a dish name, a one-sentence description, and an estimated cook time, (3) generates a consolidated grocery list from all 7 meals grouped by store section (Produce, Proteins, Dairy, Pantry, Frozen), (4) writes both sections as clean markdown. Then run a pure-Python PDF render step using `xhtml2pdf` + `reportlab` + `svglib<1.6` (already baked into the agent-runner image) to produce a two-page cookbook-style PDF: page 1 = the meal plan in a clean table layout, page 2 = the grocery list. Output `meal-plan.pdf`, `meal-plan.md`, and `metadata.md` (date, season, theme, model) into `My-Library/Cooking/Meal-Plans/<Month_YYYY>/meal-plan-<slug>_<date>/`. Commit and push to `mike_desktop` on the AI-Automation-Library remote. Send an AgentMail email to Mike with the PDF attached and the weekly theme in the subject line. Wire the PowerShell wrapper at `/tasks/jobs/run_weekly-meal-plan.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `monthly-cookbook` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Recipe of the Week job for the PDF render pattern. The job runs on the 1st of every month at 14:00 via cron + watchdog (max_age 32d). Each run: (1) scan `My-Library/Cooking/Recipes/<Month_YYYY>/` for all recipe folders whose date falls in the just-completed calendar month — read each folder's `recipe.md` and hero image, (2) invoke `claude --print` to write a short cookbook introduction (2–3 paragraphs) themed around that month's culinary through-line (season, holiday, ingredient, or cuisine theme — Claude infers from the recipe titles), (3) run a pure-Python PDF render using `xhtml2pdf` + `reportlab` + `svglib<1.6` to assemble a multi-page cookbook-style PDF: a cover page (month name, decorative title, intro text), a table of contents, then each recipe as a full-page spread with the hero image and full recipe text. Output `cookbook.pdf`, `metadata.md` (month, recipe count, titles, model) into `My-Library/Cooking/Cookbooks/<Month_YYYY>/<Month_YYYY>-MM-<slug>-cookbook/`. Commit and push to `mike_desktop`. Send an AgentMail email to Mike with the PDF attached and the cookbook title in the subject line. Wire the PowerShell wrapper at `/tasks/jobs/run_monthly-cookbook.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end (compile whatever recipe folders currently exist) before scheduling.

Scaffold a new agent-runner job called `cocktail-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Recipe of the Week job structure exactly. The job runs every Friday at 10:00 via cron + watchdog (max_age 8d). Alternate between a cocktail and a mocktail on successive weeks — maintain a state file at `/tasks/jobs/state/cocktail_type.json` that flips between "cocktail" and "mocktail" each run. Each run: invoke `codex exec` with a prompt that (1) uses built-in WebSearch to find a trending or seasonally appropriate drink recipe for this week, (2) writes a complete recipe card in markdown — drink name, glassware, ingredients list, step-by-step method, flavor profile, and one suggested food pairing, (3) downloads a high-quality hero photo of the finished drink and saves it as `cover-image.png`. Then run a pure-Python PDF render using `xhtml2pdf` + `reportlab` + `svglib<1.6` to produce a single-page cookbook-style recipe card with the hero image at the top, drink name as the headline, and recipe content below. Output `cocktail-card.pdf`, `recipe.md`, `cover-image.png`, and `metadata.md` (date, drink name, type cocktail/mocktail, model) into `My-Library/Cooking/Cocktails/<Month_YYYY>/cocktail-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the PDF attached and the drink name + type in the subject line. Wire the PowerShell wrapper at `/tasks/jobs/run_cocktail-of-the-week.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `cuisine-deep-dive` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Recipe of the Week job for the PDF render pattern. The job runs on the 1st and 3rd Monday of each month at 11:00 via cron + watchdog (max_age 16d). Maintain a rotating cuisine list in the script (Japanese, Moroccan, Peruvian, Georgian, Ethiopian, Lebanese, Vietnamese, Basque, Cajun, Sicilian — cycling in order). Each run: (1) invoke `claude --print` with a prompt that uses built-in WebSearch to research the current cuisine — write a 300-word cultural and culinary history introduction plus three authentic recipes (full ingredients + method for each), formatted as markdown, (2) for each of the three recipes, use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate a stylized food illustration hero image (painterly style, overhead or 3/4 angle, warm natural light, no text), saving them as `hero-01.png`, `hero-02.png`, `hero-03.png`, (3) run a pure-Python PDF render using `xhtml2pdf` + `reportlab` + `svglib<1.6` to produce a multi-page PDF: cover page with cuisine name, a history page, then three recipe spreads each with its hero image. Output the PDF as `cuisine-deep-dive.pdf`, the markdown as `content.md`, the three hero images, and `metadata.md` (date, cuisine, recipe names, model) into `My-Library/Cooking/Cuisine-Deep-Dives/<Month_YYYY>/<cuisine-slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the PDF attached and the cuisine name in the subject line. Wire the PowerShell wrapper at `/tasks/jobs/run_cuisine-deep-dive.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `seasonal-produce-recipe` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Recipe of the Week job structure but using Claude + Gemini for hero generation instead of Codex + download. The job runs every Tuesday at 10:00 via cron + watchdog (max_age 8d). Each run: (1) invoke `claude --print` with a prompt that uses built-in WebSearch to identify one fruit, vegetable, or herb that is currently at peak season in the Northern Hemisphere for today's date — write a complete recipe that showcases it simply (6 ingredients max, under 45 minutes), a 2-sentence "why it's good right now" spotlight, and 2–3 bullet tips on how to select and store the ingredient, all as markdown, (2) use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate a styled hero image of the finished dish — bright natural light, minimal props, the star ingredient visible, no text, (3) run a pure-Python PDF render using `xhtml2pdf` + `reportlab` + `svglib<1.6` to produce a single-page recipe card: hero image at top, ingredient spotlight callout box, recipe below, selection tips in a sidebar. Output `recipe-card.pdf`, `recipe.md`, `cover-image.png`, and `metadata.md` (date, ingredient, season note, model) into `My-Library/Cooking/Seasonal/<Month_YYYY>/seasonal-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the PDF attached and the featured ingredient + dish name in the subject line. Wire the PowerShell wrapper at `/tasks/jobs/run_seasonal-produce-recipe.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `restaurant-copycat` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Recipe of the Week job structure exactly. The job runs every Thursday at 11:00 via cron + watchdog (max_age 8d). Each run: invoke `codex exec` with a prompt that (1) uses built-in WebSearch to pick a well-known restaurant chain or famous restaurant dish that has a widely discussed copycat recipe (rotate through Chipotle, Chick-fil-A, McDonald's, Olive Garden, P.F. Chang's, Applebee's, Shake Shack, Cheesecake Factory, In-N-Out, Cracker Barrel — cycling weekly via an index tracked in a state file at `/tasks/jobs/state/copycat_index.json`), (2) researches and writes a home-cook-friendly copycat recipe in markdown — dish name, "at-home vs. original" intro, full ingredients list, step-by-step method, and a "the secret" callout box naming the key technique or ingredient that makes it authentic, plus 2 serving suggestions, (3) downloads a high-quality hero photo of the dish and saves it as `cover-image.png`. Then run a pure-Python PDF render using `xhtml2pdf` + `reportlab` + `svglib<1.6` to produce a single-page recipe card with hero image, dish name headline, "the secret" callout box highlighted, and full recipe. Output `recipe-card.pdf`, `recipe.md`, `cover-image.png`, and `metadata.md` (date, restaurant, dish name, model) into `My-Library/Cooking/Copycats/<Month_YYYY>/copycat-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the PDF attached and the restaurant + dish name in the subject line. Wire the PowerShell wrapper at `/tasks/jobs/run_restaurant-copycat.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `pairing-card` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Recipe of the Week job for the PDF render pattern and the Cocktail of the Week job for its type-rotation state file. The job runs every Saturday at 10:00 via cron + watchdog (max_age 8d). Maintain a state file at `/tasks/jobs/state/pairing_type.json` that cycles through three pairing types in order: "wine", "beer", "coffee". Each run: (1) invoke `claude --print` with a prompt that uses built-in WebSearch to select a seasonally appropriate dish, then finds an expert-recommended pairing for the current type — write a pairing card in markdown: dish name, pairing pick (specific varietal/style/roast), a 2-sentence "why it works" flavor bridge explanation, three tasting notes for the beverage, and a "budget pick under $20" specific product recommendation, (2) use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate a styled hero illustration showing the dish and the paired beverage together — clean overhead or table-scene composition, warm light, no text, (3) run a pure-Python PDF render using `xhtml2pdf` + `reportlab` + `svglib<1.6` to produce a single-page pairing card: hero image at top, dish + pairing names as headline, flavor bridge callout, tasting notes, budget pick. Output `pairing-card.pdf`, `pairing.md`, `cover-image.png`, and `metadata.md` (date, pairing type, dish, beverage pick, model) into `My-Library/Cooking/Pairings/<Month_YYYY>/pairing-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the PDF attached and the pairing type + dish name in the subject line. Wire the PowerShell wrapper at `/tasks/jobs/run_pairing-card.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `kids-lunchbox-ideas` following AI-Library-Automations/PORTING-PLAYBOOK.md, referencing the Recipe of the Week job for the PDF render pattern and copying the Seasonal-Produce Recipe Card job for the Claude + Gemini hero structure. The job runs every Sunday at 11:00 via cron + watchdog (max_age 8d). Each run: (1) invoke `claude --print` with a prompt that uses built-in WebSearch to check the current school season, any trending kids' food, and the week's day — then writes five distinct lunchbox ideas in markdown: each gets a fun name (e.g., "Dragon Roll-Up"), a shortlist of exactly 3 main ingredients, a one-sentence fun presentation tip that makes it visually appealing for kids, and a flag for any of the 8 common allergens present, (2) use the `google-genai` SDK with model `gemini-3.1-flash-image` to generate a bright, cheerful hero illustration of a fully packed lunchbox showing a colorful variety of the week's ideas — top-down view, vibrant colors, no text, (3) run a pure-Python PDF render using `xhtml2pdf` + `reportlab` + `svglib<1.6` to produce a single-page card: hero image at top, a 5-row layout where each lunchbox idea has its name as a bold header, the 3-ingredient shortlist, the presentation tip, and an allergen note. Output `lunchbox-card.pdf`, `lunchbox.md`, `cover-image.png`, and `metadata.md` (date, five idea names, allergen summary, model) into `My-Library/Cooking/Lunchbox/<Month_YYYY>/lunchbox-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the PDF attached and "5 Lunchbox Ideas — week of MM/DD" in the subject line. Wire the PowerShell wrapper at `/tasks/jobs/run_kids-lunchbox-ideas.ps1` invoked by `run-job.sh`. Validate one real artifact end-to-end before scheduling.

Scaffold `weekly-pantry-rescue-recipe` as an agent-runner cooking job. Run Mondays at 08:30. Rotate a pantry anchor (rice, pasta, beans, canned tomatoes, frozen vegetables, eggs, oats, tortillas, lentils, potatoes), generate a practical recipe using 5-8 common ingredients, include substitutions and storage notes, generate a hero image, and save `recipe.md`, `cover-image.png`, `metadata.md`, and `prompt.md`. Commit/push, email recipe summary, and validate one artifact.

Scaffold `weekly-regional-breakfast` as an agent-runner job. Run Saturdays at 08:30. Rotate countries/regions, research one traditional breakfast with source links, adapt it for a home kitchen, and output `recipe.md`, `cultural-notes.md`, `cover-image.png`, `metadata.md`, and `prompt.md`. Include dietary substitutions and sourcing tips. Commit/push, email the dish and region, and validate one real run.

Scaffold `monthly-mini-cookbook` as an agent-runner job. Run monthly on day 20 at 08:30. Choose a seasonal or practical theme, generate 8-12 original recipes with ingredient lists, steps, substitutions, timing, and notes, create a cover image, render a clean PDF with reportlab, and save `cookbook.pdf`, `recipes.md`, `cover-image.png`, `metadata.md`, and `prompt.md`. Commit/push, email the PDF, and validate one full cookbook.

Build a new n8n workflow called "AI Model Release Tracker — Weekly" following the shared digest pipeline documented in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "AI News Digest" workflow (id emUDXHhVATTRxWmY) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes, one per source):
- Hugging Face blog: https://huggingface.co/blog/feed.xml
- Google DeepMind blog: https://deepmind.google/blog/rss.xml
- OpenAI blog: https://openai.com/blog/rss.xml
- Mistral AI blog: https://mistral.ai/news/feed
- Anthropic news: https://www.anthropic.com/news/rss.xml
- The Decoder: https://the-decoder.com/feed/
- VentureBeat AI: https://venturebeat.com/category/ai/feed/

KEYWORD FILTER (Code node — keep items whose title or description contains any of): model, release, launch, weights, checkpoint, benchmark, MMLU, Elo, context window, vision, multimodal, API, fine-tune, open-source, parameter, version, update, upgrade.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's AI model releases and capability updates. Produce these markdown sections:
## Major Model Launches (new models / architectures released publicly)
## Version & Capability Updates (existing models with significant new features)
## Open-Source Drops (weights, checkpoints, or datasets released publicly)
## Benchmark Highlights (notable leaderboard jumps or new benchmark results)
## What to Watch Next Week (upcoming releases or announced timelines)
For each entry include: model name, org, one-sentence summary, significance rating (High/Medium/Low). Keep the total digest under 1200 words. Do not fabricate entries — only use items from the provided feed content.

EMAIL: label `ai-model-releases` / color sky `#0ea5e9`. Subject: "AI Model Release Tracker — Week of {{$now.format('MMM D, YYYY')}}". Send via HTTP Request to AgentMail API (api.agentmail.to/v0/inboxes/stupidopportunity154@agentmail.to/messages/send), key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit the digest markdown to michaelschecht/AI-Automation-Library on branch mike_n8n, path My-Library/News/AI-News/Model-Releases/<Month_YYYY>/AI-Model-Releases_<date>/ Open or update the weekly PR (same PR as other mike_n8n digests if one exists for the week).

SCHEDULE: every Wednesday at 09:00 ET — add per-workflow settings.timezone = "America/New_York".

Build and validate on local dev n8n first (run manually, confirm the digest email arrives and the GitHub commit appears on mike_n8n), then export the workflow JSON and import to prod (n8n.mikesailab.com). Activate on prod, deactivate on dev. Store the workflow JSON export in Repos/Tools/n8n/workflows/Newsletters/AI-Model-Release-Tracker/.

Build a new n8n workflow called "Tech Layoffs & Hiring Tracker — Weekly" following the shared digest pipeline in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "IAM & Security Briefing" workflow (id KNzMyrRKxPklyqwg) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes):
- TechCrunch: https://techcrunch.com/feed/
- The Verge: https://www.theverge.com/rss/index.xml
- Layoffs.fyi blog: https://layoffs.fyi/feed/ (if unavailable substitute Bloomberg Tech RSS)
- Wired Business: https://www.wired.com/feed/category/business/latest/rss
- Reuters Technology: https://feeds.reuters.com/reuters/technologyNews
- Business Insider Tech: https://www.businessinsider.com/tech.rss

KEYWORD FILTER (Code node — keep items containing any of): layoff, laid off, job cut, headcount, reduction, workforce, severance, hiring freeze, reorg, restructur, RIF, redundanc, job loss, rehiring, hiring surge.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's tech-sector workforce news. Produce these markdown sections:
## Major Layoff Announcements (company, estimated headcount, date, stated reason)
## Hiring Freezes & Reorgs (companies pausing hiring or restructuring teams)
## Return-to-Office & Policy Shifts (any workforce policy changes tied to layoffs)
## Sector Breakdown (which verticals — AI, SaaS, fintech, hardware, media — were most affected)
## Silver Linings: Notable Hiring Waves (companies actively hiring or reversing cuts)
## Context & Analysis (macro drivers: interest rates, AI displacement, post-ZIRP correction, etc.)
## Week-Ahead Watch (companies that have signaled cuts or earnings calls that may trigger them)
Each entry: company name, source headline, estimated impact, significance (High/Medium/Low). Cap total digest at 1100 words. Only include items from provided feed content.

EMAIL: label `tech-layoffs-digest` / color rose `#f43f5e`. Subject: "Tech Layoffs & Hiring Tracker — Week of {{$now.format('MMM D, YYYY')}}". AgentMail HTTP Request node, key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit to branch mike_n8n, path My-Library/News/Tech-Industry/Layoffs/<Month_YYYY>/Tech-Layoffs_<date>/ Open/update the shared weekly PR.

SCHEDULE: every Thursday at 09:00 ET — per-workflow settings.timezone = "America/New_York".

Build and validate on local dev first (manual trigger, confirm email + GitHub commit), then export JSON, import to prod, activate on prod, deactivate on dev. Store export in Repos/Tools/n8n/workflows/Newsletters/Tech-Layoffs-Tracker/.

Build a new n8n workflow called "Open-Source Project of the Week — Digest" following the shared digest pipeline in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "Top 10 GitHub Repos — Weekly" workflow (id bOdlpzvrVKAiMSxi) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes):
- GitHub Trending (all languages, daily): https://github-trending-api.waningflow.com/repositories?since=weekly (HTTP Request node returning JSON — parse with Code node)
- GitHub Explore newsletter RSS: https://github.blog/feed/ 
- TLDR Tech: https://tldr.tech/rss/tech.xml
- Hacker News front page: https://hnrss.org/frontpage
- OSS Insight blog: https://ossinsight.io/blog/rss.xml
- The Register Open Source: https://www.theregister.com/software/open_source/headlines.atom

KEYWORD FILTER (Code node — keep items containing any of): open-source, open source, repo, GitHub, GitLab, MIT license, Apache, star, fork, release, v1.0, self-host, CLI, library, framework, tool, plugin, SDK.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's most notable open-source projects and ecosystem news. Sections:
## Project of the Week (single standout — name, repo URL, what it does, why it matters, star count if available)
## Top 5 Trending Repos (name, language, brief description, growth signal)
## Notable New Releases (v1.0 launches, major version bumps, new projects by known orgs)
## Community & Ecosystem News (governance changes, foundation announcements, notable forks)
## Hidden Gems (low-star but high-quality or novel projects worth bookmarking)
## Developer Tooling Highlights (CLI tools, VS Code extensions, build tools released this week)
Each entry: repo name, org/author, one-sentence description, link if available, significance (High/Medium/Low). Cap at 1000 words. Only use provided feed content.

EMAIL: label `oss-spotlight-digest` / color emerald `#10b981`. Subject: "Open-Source Spotlight — Week of {{$now.format('MMM D, YYYY')}}". AgentMail HTTP Request node, key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit to branch mike_n8n, path My-Library/News/Github/Open-Source-Spotlight/<Month_YYYY>/OSS-Spotlight_<date>/ Open/update the shared weekly PR.

SCHEDULE: every Tuesday at 10:00 ET — per-workflow settings.timezone = "America/New_York".

Build and validate on local dev first, then promote to prod. Store export in Repos/Tools/n8n/workflows/Newsletters/OSS-Spotlight/.

Build a new n8n workflow called "Privacy & AI Regulation Digest — Weekly" following the shared digest pipeline in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "IAM & Security Briefing" workflow (id KNzMyrRKxPklyqwg) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes):
- IAPP (International Association of Privacy Professionals): https://iapp.org/news/rss/
- Electronic Frontier Foundation: https://www.eff.org/rss/updates.xml
- Future of Privacy Forum: https://fpf.org/feed/
- EU AI Act / EUR-Lex new documents RSS: https://eur-lex.europa.eu/tools/rss.do?other
- Politico AI & Tech: https://www.politico.com/rss/technology.xml
- MIT Technology Review Policy: https://www.technologyreview.com/feed/
- The Record (Recorded Future News): https://therecord.media/feed/

KEYWORD FILTER (Code node — keep items containing any of): privacy, GDPR, CCPA, CPRA, AI Act, regulation, compliance, enforcement, data protection, surveillance, biometric, facial recognition, consent, data breach, FTC, ICO, DPC, CNIL, legislative, bill, law, policy, governance, AI safety, foundation model, copyright.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's privacy law and AI regulation developments. Sections:
## Regulatory Actions & Enforcement (fines, investigations, orders by DPAs, FTC, or courts)
## Legislation Updates (new bills, amendments, votes — US federal, US state, EU, UK, global)
## AI Governance News (AI Act implementation, foundation model rules, safety frameworks)
## Corporate Policy & Compliance (companies announcing new privacy/AI policies or audits)
## Biometric & Surveillance Developments (facial recognition bans, surveillance tech rulings)
## Expert Commentary & Analysis (notable op-eds or policy-paper releases)
## What to Watch (upcoming votes, comment periods, enforcement deadlines)
Each entry: jurisdiction, summary, source, significance (High/Medium/Low). Cap at 1100 words. Only use provided feed content.

EMAIL: label `privacy-regulation-digest` / color violet `#7c3aed`. Subject: "Privacy & AI Regulation — Week of {{$now.format('MMM D, YYYY')}}". AgentMail HTTP Request node, key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit to branch mike_n8n, path My-Library/News/Cyber-Security/Privacy-Regulation/<Month_YYYY>/Privacy-AI-Regulation_<date>/ Open/update the shared weekly PR.

SCHEDULE: every Wednesday at 10:00 ET — per-workflow settings.timezone = "America/New_York".

Build and validate on local dev first, then promote to prod. Store export in Repos/Tools/n8n/workflows/Newsletters/Privacy-AI-Regulation/.

Build a new n8n workflow called "Science & Space Digest — Weekly" following the shared digest pipeline in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "AI News Digest" workflow (id emUDXHhVATTRxWmY) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes):
- NASA News: https://www.nasa.gov/rss/dyn/breaking_news.rss
- Nature News: https://www.nature.com/nature.rss
- Science Magazine News: https://www.science.org/rss/news_current.xml
- New Scientist: https://www.newscientist.com/feed/home/?cmpid=RSS|NSNS-2012-GLOBAL|newscientist.com-RSS
- Ars Technica Science: https://feeds.arstechnica.com/arstechnica/science
- SpaceNews: https://spacenews.com/feed/
- Quanta Magazine: https://www.quantamagazine.org/feed/

KEYWORD FILTER (Code node — keep items containing any of): research, study, discovery, published, journal, findings, experiment, space, mission, launch, orbit, telescope, Mars, Moon, asteroid, physics, biology, climate, genome, quantum, neuroscience, particle, breakthrough, peer-reviewed.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's most important science and space news for an intelligent generalist. Sections:
## Discovery of the Week (single standout finding — what it means in plain English)
## Space Missions & Astronomy (launches, mission updates, telescope observations)
## Life Sciences & Medicine (biology, genetics, neuroscience, health research)
## Physics & Materials (quantum, particle physics, materials science breakthroughs)
## Climate & Earth Science (climate research, environmental studies, geology)
## Technology-Driven Science (AI in research, new instruments, computing milestones)
## Upcoming: Launches & Publication Dates (rocket launches or major paper releases expected next week)
Each entry: one-sentence plain-English summary + significance (High/Medium/Low). Avoid jargon; define technical terms inline. Cap at 1100 words. Only use provided feed content.

EMAIL: label `science-space-digest` / color teal `#0d9488`. Subject: "Science & Space Digest — Week of {{$now.format('MMM D, YYYY')}}". AgentMail HTTP Request node, key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit to branch mike_n8n, path My-Library/News/Science/<Month_YYYY>/Science-Space-Digest_<date>/ Open/update the shared weekly PR.

SCHEDULE: every Friday at 10:00 ET — per-workflow settings.timezone = "America/New_York".

Build and validate on local dev first, then promote to prod. Store export in Repos/Tools/n8n/workflows/Newsletters/Science-Space-Digest/.

Build a new n8n workflow called "Deals & Discount Alert Digest — Weekly" following the shared digest pipeline in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "Shopping Portal & Browser Extension Digest" workflow (id KmxmCv2nx1sAriqH) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes):
- Slickdeals front page: https://slickdeals.net/newsearch.php?mode=frontpage&searcharea=deals&searchin=first&rss=1
- Reddit r/deals: https://www.reddit.com/r/deals/.rss
- Reddit r/buildapcsales: https://www.reddit.com/r/buildapcsales/.rss
- The Wirecutter Deals: https://www.nytimes.com/wirecutter/deals/feed/
- Doctor of Credit deals: https://www.doctorofcredit.com/feed/
- Brad's Deals: https://www.bradsdeals.com/feed

KEYWORD FILTER (Code node — keep items containing any of): deal, discount, sale, off, coupon, promo, code, price drop, limited, expires, free shipping, clearance, % off, saving, cashback, rebate, BOGO, bundle, flash sale.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's best deals and discounts. Sections:
## Deal of the Week (single best value — product/service, normal price, deal price, where to get it, expiry if known)
## Electronics & Hardware (laptops, phones, peripherals, components)
## Software & Subscriptions (SaaS tools, streaming, productivity apps, annual plan sales)
## Travel & Experiences (flights, hotels, vacation packages, activity deals)
## Grocery & Household (supermarket deals, bulk savings, subscription-box offers)
## Expiring Soon (deals with a stated deadline in the next 48–72 hours)
## Stacking Opportunities (deals that combine with portal cashback, credit-card rewards, or browser-extension bonuses)
Each entry: item, discount amount/%, retailer, how to claim, expiry. Cap at 1000 words. Only include items from provided feed content; do not invent deals.

EMAIL: label `deals-digest` / color amber `#d97706`. Subject: "Deals & Discount Digest — Week of {{$now.format('MMM D, YYYY')}}". AgentMail HTTP Request node, key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit to branch mike_n8n, path My-Library/Finance-Rewards/Deals-Discounts/<Month_YYYY>/Deals-Digest_<date>/ Open/update the shared weekly PR.

SCHEDULE: every Saturday at 10:00 ET — per-workflow settings.timezone = "America/New_York".

Build and validate on local dev first, then promote to prod. Store export in Repos/Tools/n8n/workflows/Newsletters/Deals-Discount-Digest/.

Build a new n8n workflow called "AI Safety & Alignment Digest — Weekly" following the shared digest pipeline in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "AI News Digest" workflow (id emUDXHhVATTRxWmY) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes):
- Alignment Forum: https://www.alignmentforum.org/feed.xml
- LessWrong (AI-tagged): https://www.lesswrong.com/feed.xml?view=topTags&tagId=jeBpSBpXMC3XVBN8d
- Anthropic Research Blog: https://www.anthropic.com/research/rss.xml
- DeepMind Safety: https://deepmind.google/blog/rss.xml
- AI Incidents Database blog: https://incidentdatabase.ai/rss.xml
- Center for AI Safety: https://www.safe.ai/feed
- MIT Technology Review AI: https://www.technologyreview.com/feed/

KEYWORD FILTER (Code node — keep items containing any of): safety, alignment, interpretability, mechanistic, RLHF, RLAIF, Constitutional AI, red team, jailbreak, hallucination, sycophancy, deceptive, corrigible, agent risk, catastrophic, existential, governance, ethics, bias, fairness, audit, incident, misuse, dual-use, frontier model, ASL.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's AI safety and alignment developments for a technically literate reader. Sections:
## Research Highlights (new papers or posts on alignment, interpretability, or evals)
## Safety Incidents & Red-Team Findings (reported model failures, jailbreaks, misuse cases)
## Governance & Policy Intersection (where safety concerns are shaping legislation or corporate policy)
## Organizational News (new labs, teams, grants, or hires focused on safety work)
## Interpretability & Mechanistic Work (notable progress in understanding model internals)
## Community Debate (significant LessWrong/AF posts or public disagreements worth noting)
## Upcoming: Workshops, Deadlines & Events (conferences, submission deadlines, public comment windows)
Each entry: title/author, one-sentence summary, significance (High/Medium/Low). Keep technical language but define novel terms inline. Cap at 1100 words. Only use provided feed content.

EMAIL: label `ai-safety-digest` / color red `#dc2626`. Subject: "AI Safety & Alignment Digest — Week of {{$now.format('MMM D, YYYY')}}". AgentMail HTTP Request node, key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit to branch mike_n8n, path My-Library/News/AI-News/AI-Safety/<Month_YYYY>/AI-Safety-Digest_<date>/ Open/update the shared weekly PR.

SCHEDULE: every Thursday at 10:00 ET — per-workflow settings.timezone = "America/New_York".

Build and validate on local dev first, then promote to prod. Store export in Repos/Tools/n8n/workflows/Newsletters/AI-Safety-Digest/.

Build a new n8n workflow called "Self-Hosting & Homelab Digest — Weekly" following the shared digest pipeline in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "Top 10 GitHub Repos — Weekly" workflow (id bOdlpzvrVKAiMSxi) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes):
- Reddit r/selfhosted: https://www.reddit.com/r/selfhosted/.rss
- Reddit r/homelab: https://www.reddit.com/r/homelab/.rss
- Awesome-Selfhosted GitHub releases: https://github.com/awesome-selfhosted/awesome-selfhosted/releases.atom
- Noted.lol (self-host blog): https://noted.lol/feed/
- Jeff Geerling blog: https://www.jeffgeerling.com/blog.xml
- Hacker News (self-host tagged): https://hnrss.org/newest?q=self-hosted+OR+homelab+OR+selfhosted

KEYWORD FILTER (Code node — keep items containing any of): self-host, selfhost, homelab, home server, NAS, Docker, Proxmox, Unraid, TrueNAS, Pi-hole, Home Assistant, Nextcloud, Jellyfin, Plex, reverse proxy, VPN, wireguard, container, Kubernetes, k3s, bare metal, rack, UPS, ZFS, RAID, networking, VLAN, firewall, pfSense.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's self-hosting and homelab highlights. Sections:
## App of the Week (single standout self-hosted software — what it replaces, how to deploy, GitHub stars)
## Software Releases & Updates (new versions of popular self-hosted apps: Home Assistant, Nextcloud, Jellyfin, etc.)
## Hardware Finds (mini-PCs, NAS units, networking gear — deals or new releases relevant to homelabs)
## Tutorials & Guides (notable how-tos or write-ups from the community)
## Security & Hardening Tips (vulnerabilities in self-hosted software, best-practice reminders)
## Community Projects & Showcases (impressive homelab builds or automation setups shared this week)
## Starter Picks (one recommendation each for: beginners / intermediate / power-users)
Each entry: one-sentence description, link if available, difficulty (Beginner/Intermediate/Advanced). Cap at 1000 words. Only use provided feed content.

EMAIL: label `homelab-digest` / color cyan `#06b6d4`. Subject: "Self-Hosting & Homelab Digest — Week of {{$now.format('MMM D, YYYY')}}". AgentMail HTTP Request node, key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit to branch mike_n8n, path My-Library/News/Tech-Industry/Self-Hosting/<Month_YYYY>/Homelab-Digest_<date>/ Open/update the shared weekly PR.

SCHEDULE: every Saturday at 09:00 ET — per-workflow settings.timezone = "America/New_York".

Build and validate on local dev first, then promote to prod. Store export in Repos/Tools/n8n/workflows/Newsletters/Homelab-Digest/.

Build a new n8n workflow called "Developer Tooling Changelog Digest — Weekly" following the shared digest pipeline in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "Top 10 GitHub Repos — Weekly" workflow (id bOdlpzvrVKAiMSxi) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes — use GitHub releases.atom feeds where available):
- Node.js releases: https://github.com/nodejs/node/releases.atom
- React releases: https://github.com/facebook/react/releases.atom
- Vite releases: https://github.com/vitejs/vite/releases.atom
- TypeScript releases: https://github.com/microsoft/TypeScript/releases.atom
- Tailwind CSS releases: https://github.com/tailwindlabs/tailwindcss/releases.atom
- n8n releases: https://github.com/n8n-io/n8n/releases.atom
- Prisma releases: https://github.com/prisma/prisma/releases.atom
- Python releases: https://github.com/python/cpython/releases.atom
- Bun releases: https://github.com/oven-sh/bun/releases.atom
- VS Code updates blog: https://code.visualstudio.com/feed.xml
- npm blog: https://github.blog/feed/ (filter for package/registry news)
- Changelog.com podcast feed (developer-tooling episodes): https://changelog.com/podcast.xml

KEYWORD FILTER (Code node — keep items containing any of): release, v\d, version, changelog, breaking change, deprecat, migration, upgrade, patch, security fix, performance, new feature, API change, CLI, plugin, extension, beta, stable, LTS, RC, alpha.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's developer tooling releases and changelog highlights. Sections:
## Breaking Changes & Must-Know Migrations (anything that could break existing projects — version, what changed, migration path)
## Major Version Releases (new major or minor versions of key tools/frameworks)
## Security Patches (CVE fixes, security releases — tool, severity, update urgency)
## Performance & DX Wins (speed improvements, new ergonomic APIs, notable QoL changes)
## Deprecations & Sunset Notices (features or tools being phased out)
## Ecosystem & Registry News (npm/PyPI/crates notable package milestones, registry policy changes)
## Tooling on Mike's Stack (flag any releases touching: React 19, Vite, TypeScript, Tailwind, Node, Prisma, n8n, Python, FastMCP)
Each entry: tool name, version, one-sentence summary of what changed, upgrade priority (Urgent/Soon/Routine). Cap at 1100 words. Only use provided feed content.

EMAIL: label `devtools-changelog-digest` / color sky `#0ea5e9`. Subject: "Dev Tooling Changelog — Week of {{$now.format('MMM D, YYYY')}}". AgentMail HTTP Request node, key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit to branch mike_n8n, path My-Library/News/Tech-Industry/Dev-Tooling/<Month_YYYY>/DevTools-Changelog_<date>/ Open/update the shared weekly PR.

SCHEDULE: every Monday at 10:00 ET — per-workflow settings.timezone = "America/New_York". (Runs after the IAM Briefing at 09:00 — schedule at 10:00 to avoid same-tick concurrency on mike_n8n commits.)

Build and validate on local dev first, then promote to prod. Store export in Repos/Tools/n8n/workflows/Newsletters/DevTools-Changelog/.

Build a new n8n workflow called "Jobs in AI Digest — Weekly" following the shared digest pipeline in AI-Workflow-Hosting-Docs/AI-Library-Automations/n8n-fleet.md. Copy the node structure and credential wiring of the live "AI News Digest" workflow (id emUDXHhVATTRxWmY) on local dev n8n (localhost:5678).

SOURCE FEEDS (RSS Feed Read nodes):
- Hacker News "Who is Hiring" monthly thread (latest): https://hnrss.org/ask?q=who+is+hiring (HTTP Request node + Code node to parse top comments)
- Levels.fyi blog: https://www.levels.fyi/blog/feed/
- Reddit r/MachineLearning jobs: https://www.reddit.com/r/MachineLearning/search/.rss?q=hiring+OR+job&restrict_sr=1&sort=new
- AI Jobs board blog/feed: https://aijobs.net/feed/
- Towards Data Science (career/jobs tagged): https://towardsdatascience.com/feed
- TechCrunch jobs/hiring: https://techcrunch.com/feed/ (filter for hiring/layoff/compensation keywords)
- The Pragmatic Engineer newsletter blog: https://newsletter.pragmaticengineer.com/feed

KEYWORD FILTER (Code node — keep items containing any of): hiring, job, role, position, salary, compensation, TC, remote, AI engineer, ML engineer, LLM, prompt engineer, agent, RAG, fine-tuning, full-stack, backend, frontend, Python, TypeScript, h1b, visa, layoff, headcount, open req, recruiter, offer.

DEEPSEEK PROMPT / SECTION STRUCTURE:
Summarize the past week's AI job market news relevant to a full-stack developer pursuing AI engineering roles. Sections:
## Hot Roles This Week (5–7 specific notable job openings or categories in high demand — company, role type, location/remote status, comp range if stated)
## Compensation Benchmarks (any new salary data, Levels.fyi reports, or comp transparency posts)
## Hiring Signals by Company (companies ramping or contracting AI headcount this week)
## Skills in Demand (technologies, frameworks, or competencies appearing most in job postings)
## Remote vs On-Site Trends (any notable shifts in remote-work policy among AI employers)
## Career Advice & Resources (notable guides, interview prep, or portfolio tips from this week)
## Market Outlook (brief summary of AI job-market sentiment: tight / cooling / hotspots)
Each entry: concise, actionable. Flag roles or news especially relevant to full-stack + AI background. Cap at 1000 words. Only use provided feed content.

EMAIL: label `jobs-in-ai-digest` / color emerald `#059669`. Subject: "Jobs in AI — Week of {{$now.format('MMM D, YYYY')}}". AgentMail HTTP Request node, key from $env.AGENTMAIL_API_KEY.

GITHUB ARCHIVE: commit to branch mike_n8n, path My-Library/News/AI-News/Jobs-in-AI/<Month_YYYY>/Jobs-in-AI_<date>/ Open/update the shared weekly PR.

SCHEDULE: every Friday at 11:00 ET — per-workflow settings.timezone = "America/New_York". (Runs after the Science & Space Digest at 10:00 ET to avoid same-tick concurrency on mike_n8n commits.)

Build and validate on local dev first, then promote to prod. Store export in Repos/Tools/n8n/workflows/Newsletters/Jobs-in-AI/.

Build an n8n workflow called "Cybersecurity Vulnerability Watch - Weekly" using the shared digest pipeline. Sources: CISA KEV catalog, NVD recent CVEs, vendor security blogs (Microsoft, Apple, Google, Cisco, Fortinet, Palo Alto), and security news RSS. Filter for exploited-in-the-wild, critical severity, widely deployed software, and actionable patches. DeepSeek sections: Top Action Item, Exploited This Week, Critical Patch Roundup, Home/SOHO Impact, Enterprise Impact, What To Patch First. Commit markdown to `mike_n8n`, open/update PR, email via AgentMail label `vulnerability-watch`, and validate one real run before activation.

Build an n8n workflow called "Local Events Ideas - Weekly". Use HTTP/RSS sources for official city calendars, Eventbrite/search pages where accessible, venue calendars, museums, parks, live music listings, and weather forecast summary. Filter for the next 10 days. DeepSeek output sections: Best Overall Picks, Free/Low-Cost, Food & Drink, Music/Arts, Outdoors, Family-Friendly, Weather-Aware Recommendations. Commit markdown to `mike_n8n`, open/update PR, email via AgentMail, and validate with one real digest. Include source URLs for each listed event.

Build an n8n workflow called "Personal Tech Buying Guide - Weekly" using RSS/HTTP sources from review sites, deal feeds, manufacturer blogs, and price-tracking pages where accessible. Focus on laptops, monitors, keyboards, storage, mini PCs, networking, smart home, and creator gear. DeepSeek sections: Buy Now, Wait, Skip, Best Under $100, Homelab Pick, Creator Pick, Price Watch. Include caveats on sponsored content and verify prices from provided source text only. Commit markdown, PR, email via AgentMail, and validate one live run.

Scaffold a new agent-runner job called `weekly-faction-profile` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of the existing Daily Character Card job. The job runs every Monday at 07:30 via a cron line in /etc/cron.d/agent-cron plus a watchdog entry. Maintain a themes checklist at `/tasks/jobs/state/faction_themes.md` — a numbered list of faction archetypes (e.g., Merchant Guild, Shadow Cult, Knight Order, Pirate Confederation, Scholastic Academy, Druidic Circle, Revolutionary Cell, Trade Republic, Mercenary Band, Theocratic Empire — add 20 total). Each run picks the next unchecked item, checks it off, and wraps back to the top when exhausted.

Each run: (1) use the `google-genai` SDK with model `gemini-2.5-flash` to generate a faction profile `.md` — sections: Faction Name, Archetype, Founding Myth, Core Doctrine, Key Figures (3 named roles), Allies & Rivals, Symbol & Colors, and a short 3-line "street reputation" quote. (2) Then call `gemini-3.1-flash-image` to generate a faction-banner portrait — heraldic or emblem-style artwork in a fantasy setting, square canvas, the faction's colors and symbol prominent, painterly style, no text overlay. Output `faction-profile.md`, `faction-banner.png`, `metadata.md` (date, faction name, archetype, model) into `My-Library/Content/Characters/Factions/<Month_YYYY>/faction-<slug>_<date>/`. Commit and push to `mike_desktop` on the AI-Automation-Library remote. Send an AgentMail email to Mike with the banner image attached and the faction name + archetype in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-bestiary-entry` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Character Card job structure (Gemini SDK text + portrait). The job runs every Wednesday at 07:30 via cron + watchdog. Maintain a themes checklist at `/tasks/jobs/state/bestiary_themes.md` — a numbered list of 24 creature archetypes spanning fantasy, sci-fi, and folklore (e.g., Undead Colossus, Deep-Sea Leviathan, Fey Trickster, Clockwork Golem, Plague Wraith, Stone Drake, Void Stalker, Bog Hag, Ember Serpent, Dream Eater — add 24 total). Each run picks the next unchecked item, checks it off.

Each run: (1) use the `google-genai` SDK with `gemini-2.5-flash` to generate a bestiary entry `.md` — sections: Creature Name, Classification, Habitat, Size & Appearance, Behavior & Hunting, Danger Rating (1–10), Known Weaknesses, and a short "Field Naturalist's Note" flavor paragraph. (2) Then call `gemini-3.1-flash-image` to generate a full-body creature illustration — natural-history-illustration style (think Audubon meets dark fantasy), white or parchment background, creature centered, detailed anatomical linework with muted color wash, no text. Output `bestiary-entry.md`, `creature-illustration.png`, `metadata.md` (date, creature name, danger rating, model) into `My-Library/Content/Characters/Bestiary/<Month_YYYY>/creature-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the illustration attached and the creature name + danger rating in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-npc-dialogue-pack` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Character Card job (Gemini SDK text + portrait pattern). The job runs every Friday at 07:30 via cron + watchdog. Maintain a themes checklist at `/tasks/jobs/state/npc_archetypes.md` — a numbered list of 20 NPC archetypes (e.g., Grizzled Blacksmith, Mysterious Apothecary, Corrupt Guard Captain, Elven Archivist, Halfling Innkeeper, Wandering Merchant, Blind Oracle, Exiled Noble, Street Urchin Gang Leader, Retired Assassin — add 20 total). Each run picks the next unchecked item.

Each run: (1) use `google-genai` SDK with `gemini-2.5-flash` to generate an NPC profile `.md` — sections: Name, Archetype, Backstory (3 sentences), Personality Traits (3 bullet points), and a Dialogue Pack table with 5 mood columns (Neutral / Suspicious / Friendly / Threatened / Quest-Giving) × 2 lines each (10 voiced lines total), all in first-person character voice. (2) Then call `gemini-3.1-flash-image` to generate a bust-portrait of the NPC — RPG game-art style, painterly, detailed face and costume, dramatic rim lighting, plain dark background, square canvas. Output `npc-profile.md`, `npc-portrait.png`, `metadata.md` (date, NPC name, archetype, model) into `My-Library/Content/Characters/NPC-Dialogue-Packs/<Month_YYYY>/npc-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the portrait attached and the NPC name + archetype in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-rpg-stat-block` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Character Card job (Gemini SDK text + portrait). The job runs every Tuesday at 07:30 via cron + watchdog. Maintain a themes checklist at `/tasks/jobs/state/statblock_subjects.md` — a numbered list of 24 subjects (mix of monsters, NPCs, and environmental hazards; e.g., Cursed Armor Sentinel, Plague Doctor Inquisitor, Giant Mantis Shrimp, Shadow Doppelganger, Volcanic Fire Elemental, Lich Apprentice, Storm Giant Chieftain, Mimic Hive Queen — add 24 total, alternating CR tiers Low/Medium/High/Legendary). Each run picks the next unchecked item.

Each run: (1) use `google-genai` SDK with `gemini-2.5-flash` to generate a full D&D 5e-compatible stat block `.md` — include monster name, type/size/alignment, AC + HP + speed, all six ability scores with modifiers, saving throws, skills, damage immunities/resistances/vulnerabilities, senses, languages, CR, and full trait/action/reaction/legendary-action blocks written in official SRD prose style. (2) Then call `gemini-3.1-flash-image` to generate a circular battle-map token — the creature centered inside a circular frame with a subtle drop shadow, top-down or 3/4 view, vibrant RPG game-art color style, transparent-friendly white background outside the circle. Output `stat-block.md`, `token-art.png`, `metadata.md` (date, subject name, CR, model) into `My-Library/Content/Characters/Stat-Blocks/<Month_YYYY>/statblock-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the token image attached and the subject name + CR in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-world-event-timeline` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Character Card job structure (Gemini SDK text + portrait). The job runs every Thursday at 07:30 via cron + watchdog. Maintain a themes checklist at `/tasks/jobs/state/world_event_themes.md` — a numbered list of 20 historical-arc archetypes (e.g., The Fall of a Great Empire, The Discovery of a Forbidden Magic, A Plague That Reshaped Civilization, The War of Two Faiths, A Technological Revolution, The Opening of a New Trade Route, A Dragon's Century-Long Reign — add 20 total). Each run picks the next unchecked item.

Each run: (1) scan `My-Library/Content/Characters/` for any `.md` files modified in the last 30 days and extract up to 2 character names to weave into this timeline as cameo figures. (2) Use `google-genai` SDK with `gemini-2.5-flash` to generate a world-event timeline `.md` — a fictional historical record with a title, a 2-sentence "Historian's Preface," and 5–8 dated entries (use a fictional calendar like "Year 412 of the Iron Age") each 3–5 sentences; name-drop the cameo characters in at least one entry if found; end with a "Legacy & Aftermath" section. (3) Call `gemini-3.1-flash-image` to generate an epic scene illustration of the climactic event in the timeline — cinematic wide composition, painterly fantasy-art style, dramatic sky and atmosphere, no text overlay. Output `world-event-timeline.md`, `scene-illustration.png`, `metadata.md` (date, arc theme, cameo characters, model) into `My-Library/Content/Characters/World-Events/<Month_YYYY>/event-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the scene illustration attached and the arc theme in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-hero-villain-pair` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Character Card job (Gemini SDK text + portrait) and extending it to generate five files per run. The job runs every Saturday at 08:00 via cron + watchdog. Maintain a themes checklist at `/tasks/jobs/state/hero_villain_themes.md` — a numbered list of 20 paired-conflict archetypes (e.g., Revolutionary vs. Tyrant, Idealist Knight vs. Fallen Paladin, Nature Guardian vs. Industrial Baron, Time Traveler vs. Timeline Enforcer, Street Thief vs. Crime Lord, Reluctant Hero vs. Chaos Incarnate — add 20 total). Each run picks the next unchecked item.

Each run: (1) use `google-genai` SDK with `gemini-2.5-flash` to write two character cards in one prompt — Hero card and Villain card with identical sections (Name, Archetype, Backstory, Core Motivation, Signature Ability, Fatal Flaw, and a 2-line quote) — the two characters must share a single origin event that split their paths. (2) Call `gemini-3.1-flash-image` three times: hero portrait (RPG game-art bust, warm lighting), villain portrait (same style, cooler/darker palette), and a duel-composition wide image (both figures facing each other at dramatic distance, cinematic). Save `hero-card.md`, `villain-card.md`, `hero-portrait.png`, `villain-portrait.png`, `duel-composition.png`, `metadata.md` (date, theme, hero name, villain name, model) into `My-Library/Content/Characters/Hero-Villain-Pairs/<Month_YYYY>/pair-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the duel-composition image attached and both character names in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `biweekly-relationship-web` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Character Card job (Gemini SDK text + portrait). The job runs on the 1st and 3rd Sunday of each month at 08:30 (use a cron expression like `30 8 1-7,15-21 * 0`) plus a watchdog entry with a 16-day max age. Maintain a themes checklist at `/tasks/jobs/state/relweb_themes.md` — a numbered list of 16 story-world archetypes (e.g., Royal Court Intrigue, Thieves' Guild Hierarchy, Adventuring Party Aftermath, Merchant Dynasty, Temple Order, Pirate Fleet, Revolutionary Cell, Arcane Academy — add 16 total). Each run picks the next unchecked item.

Each run: (1) use `google-genai` SDK with `gemini-2.5-flash` to generate a relationship web `.md` — invent 6–8 named characters in the chosen archetype setting; produce a Mermaid `graph LR` block where each node is a character name and each labeled edge is one of: ally, rival, mentor, betrayer, lover, or unknown; follow the diagram with a 1-sentence "Web Summary" and a 2–3 sentence "Hidden Tension" paragraph that reveals one non-obvious connection. (2) Call `gemini-3.1-flash-image` to generate a visual relationship map — illustrated in an old-world "conspiracy board" or "fantasy scroll" aesthetic, character names hand-lettered in nodes, connecting lines with small relationship labels, ink-on-parchment or cork-board visual style, no photographic elements. Output `relationship-web.md` (containing Mermaid + lore text), `relationship-map.png`, `metadata.md` (date, theme, character names list, model) into `My-Library/Content/Characters/Relationship-Webs/<Month_YYYY>/relweb-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the map image attached, character names listed in the body, and the theme in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `daily-writing-prompt-card` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Content Idea Gen job structure (Gemini SDK, Mon/Wed/Fri/Sat/Sun at 07:00 — five days per week to complement the existing Tue & Thu character card). Wire five separate cron lines (one per weekday: 1=Mon, 3=Wed, 5=Fri, 6=Sat, 0=Sun) each calling `run-job.sh daily-writing-prompt-card` plus a watchdog entry with a 2-day max age. Maintain a genres checklist at `/tasks/jobs/state/writing_prompt_genres.md` — a numbered list of 30 genres/tones cycling (e.g., Dark Fantasy, Cozy Mystery, Cli-Fi, Cosmic Horror, Hopepunk, Solarpunk, Gothic Romance, Weird West, Biopunk, Mythic Realism — add 30 total). Each run picks the next unchecked item.

Each run: (1) use `google-genai` SDK with `gemini-2.5-flash` to generate a writing-prompt card `.md` — sections: Genre/Tone label, The Prompt (2–4 evocative sentences ending on an open question or image), and three "Escalation Hooks" (one-liners that push the story into subgenre variants — e.g., "Add: the protagonist has 24 hours," "Flip: the threat is sympathetic," "Raise stakes: an innocent bystander witnesses everything"). (2) Call `gemini-3.1-flash-image` to generate a mood-board atmospheric image that captures the emotional tone of the prompt — cinematic composition, no characters' faces clearly shown (silhouettes or partial), color palette and lighting matched to the genre. Output `writing-prompt.md`, `mood-board.png`, `metadata.md` (date, genre, model) into `My-Library/Content/Content-Ideas/Writing-Prompts/<Month_YYYY>/prompt-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the mood-board image attached and the genre + first sentence of the prompt in the subject. Validate one real artifact end-to-end before scheduling.

Scaffold `weekly-location-lore-card` as an agent-runner Gemini job. Run Mondays at 07:15. Rotate setting types (haunted inn, orbital market, desert monastery, drowned city, wizard university, border town, generation ship deck, undersea archive). Generate a structured `location.md` with overview, sensory details, factions, secrets, adventure hooks, and continuity tags; generate `location.png`; save metadata and prompt. Commit/push, email the image and hooks, and validate one real artifact.

Scaffold `weekly-faction-dossier` as an agent-runner job. Run Thursdays at 07:15. Rotate faction archetypes (guild, cult, research lab, rebel cell, merchant house, AI collective, knightly order, crime syndicate). Generate `faction.md` with mission, hierarchy, symbols, resources, rivals, public face, hidden agenda, and three plot hooks; generate `emblem.png`; save metadata and prompt. Commit/push, email summary, and validate one run.

Scaffold `daily-dialogue-spark` as an agent-runner job. Run daily at 06:50. Rotate conflict types (confession, negotiation, accusation, reunion, betrayal, lesson, farewell, discovery). Generate a `dialogue-spark.md` containing two character roles, a setting, an opening line, ten escalating exchange beats, and three possible endings; generate `scene-card.png`; save metadata and prompt. Commit/push, email the opening line, and validate one artifact.

Scaffold a new agent-runner job called `dataset-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of an existing agent-runner Claude job (PowerShell wrapper at /tasks/jobs/run_dataset-of-the-week.ps1, invoked by run-job.sh, cron + watchdog). The job runs every Monday at 07:00 via a cron line in /etc/cron.d/agent-cron. Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to discover one high-quality, newly released or recently spotlighted open dataset (rotating domain weekly: climate/environment, economics, public health, sports, transportation, demographics, education, energy — one per week cycling); (2) researches the dataset's schema, source URL, row/column counts, license, and 3–5 notable findings or use cases; (3) emits a clean `dataset.csv` (up to 200 representative or summary rows — if the real dataset is huge, emit a curated 200-row sample with a note in the datacard) and a `dataset.json` (same records as an array of objects); (4) emits a `datacard.md` with fields: Title, Domain, Source URL, Date Retrieved, Row Count, Columns (name + type + description for each), License, Notable Findings (3–5 bullets), Suggested Uses (2–3 bullets), Caveats. Output all three files into `My-Library/Reference/Datasets/<Month_YYYY>/dataset-<slug>_<date>/`. Commit and push to `mike_desktop` on the AI-Automation-Library remote. Send an AgentMail email to Mike with the datacard.md content in the body and a subject line of "Dataset of the Week: <dataset title>". Wire the PowerShell wrapper, add the cron line, and register in watchdog.manifest with an 8d max_age. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `cheat-sheet-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of an existing agent-runner Claude job that does a pure-Python PDF render (use reportlab — NOT xhtml2pdf, to avoid the pycairo C-extension chain issue documented in the porting playbook). PowerShell wrapper at /tasks/jobs/run_cheat-sheet-of-the-week.ps1, invoked by run-job.sh, cron + watchdog. The job runs every Wednesday at 07:00. Maintain a state file at /tasks/jobs/state/cheatsheet_topic_index.json that cycles through a topic list: Git CLI, Bash scripting, Python built-ins, Docker CLI, SQL window functions, Regex syntax, Vim keybindings, HTTP status codes, Markdown syntax, Linux file permissions, jq filters, curl flags — one topic per week in order. Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to verify the most up-to-date syntax/flags for the week's topic; (2) produces a dense, well-organized cheat-sheet in markdown — sections, code blocks, tables; maximum one A4 page worth of content; (3) emits that markdown as `cheat-sheet.md`. Then run a pure-Python reportlab script (committed alongside the job) that converts `cheat-sheet.md` to a clean single-page A4 PDF `cheat-sheet.pdf` — dark header bar with topic title, monospace code blocks, two-column layout where sensible. Also emit `metadata.md` (date, topic, source URLs checked, model). Output all three files into `My-Library/Reference/Cheat-Sheets/<Month_YYYY>/cheatsheet-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the PDF attached and "Cheat-Sheet of the Week: <topic>" as the subject. Add cron + watchdog (8d max_age). Validate one real artifact (Git CLI cheat-sheet) end-to-end before scheduling.

Scaffold a new agent-runner job called `ai-tools-comparison` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of an existing agent-runner Claude structured-file job. PowerShell wrapper at /tasks/jobs/run_ai-tools-comparison.ps1, invoked by run-job.sh, cron + watchdog. The job runs every Tuesday at 08:00. Maintain a state file at /tasks/jobs/state/comparison_topic_index.json that cycles through a rotating topic list: coding assistants, image generation models, LLM APIs (pricing + context window), vector databases, AI agent frameworks, speech-to-text APIs, text-to-speech APIs, AI-powered search tools, open-source LLMs (local inference), embedding models, AI video generation tools, AI music generation tools — one topic per week. Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to gather current data on the week's topic — find 6–10 tools/products/models; (2) builds a comparison matrix with 6–8 evaluation dimensions relevant to the topic (e.g. for LLM APIs: Model, Provider, Context Window, Input $/1M tokens, Output $/1M tokens, Free Tier, Strengths, Weaknesses); (3) emits `comparison.md` with a well-formatted markdown table plus a 3–5 sentence "Key Takeaways" section at the bottom; (4) emits `comparison.csv` with the same rows and columns, web-URL-safe values, no line breaks inside cells; (5) emits `metadata.md` (date, topic, number of tools compared, sources checked, model, caveat that data reflects the research date). Output all three files into `My-Library/Reference/Comparisons/<Month_YYYY>/comparison-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the markdown table and key takeaways in the body and "AI Comparison: <topic>" as the subject. Add cron + watchdog (8d max_age). Validate one real artifact (coding assistants) end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-flashcard-deck` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of an existing agent-runner Claude structured-file job. PowerShell wrapper at /tasks/jobs/run_weekly-flashcard-deck.ps1, invoked by run-job.sh, cron + watchdog. The job runs every Thursday at 07:00. Maintain a state file at /tasks/jobs/state/flashcard_topic_index.json cycling through: Python built-in functions, SQL clauses and functions, Docker commands, Linux CLI commands, HTTP methods and status codes, Git commands, Regular expression syntax, Bash scripting constructs, AWS services overview, Kubernetes objects, TypeScript utility types, React hooks API — one topic per week. Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to verify the current authoritative reference for the week's topic; (2) generates exactly 30 flashcard pairs — each Front is a concise question or term, each Back is a clear answer or definition (max 2 sentences); (3) assigns 2–3 comma-separated Anki tags per card (topic slug + sub-category); (4) emits `flashcards.csv` as valid UTF-8 CSV with header row `Front,Back,Tags` and 30 data rows — no line breaks inside cells, escape commas with double-quotes; (5) emits `deck-preview.md` showing the first 10 cards as a numbered Q&A markdown list; (6) emits `metadata.md` (date, topic, card count, source URLs, model). Output all three files into `My-Library/Reference/Flashcards/<Month_YYYY>/flashcards-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the deck-preview.md content in the body and the CSV attached, subject "Flashcard Deck: <topic> (30 cards)". Add cron + watchdog (8d max_age). Validate one real artifact (Python built-in functions) end-to-end before scheduling.

Scaffold a new agent-runner job called `glossary-entry-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of an existing agent-runner Claude structured-file job. PowerShell wrapper at /tasks/jobs/run_glossary-entry-of-the-week.ps1, invoked by run-job.sh, cron + watchdog. The job runs every Friday at 07:00. Maintain a state file at /tasks/jobs/state/glossary_topic_index.json cycling through a topic list that spans AI/ML concepts, software engineering patterns, statistical terms, financial instruments, networking protocols, cryptography primitives, database concepts, cloud-native patterns, mathematical structures, and cognitive biases — seed the list with at least 52 terms (one per year). Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to research the week's term thoroughly — academic definitions, practical usage, historical origin; (2) emits `glossary-entry.md` using this exact structure: # <Term>, ## Definition (2–3 sentences, plain language), ## Technical Detail (3–5 sentences, precise), ## Origin & History (2–4 sentences), ## Related Terms (3–5 linked terms as a bullet list), ## Examples in the Wild (2–3 real-world examples with brief explanations), ## Common Misconceptions (1–3 bullets if applicable), ## Further Reading (2–3 authoritative URLs); (3) emits `metadata.md` (date, term, domain/category, sources, model). Output both files into `My-Library/Reference/Glossary/<Month_YYYY>/glossary-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the glossary-entry.md content pasted in the body and "Glossary: <term>" as the subject. Add cron + watchdog (8d max_age). Validate one real artifact end-to-end before scheduling.

Build an n8n workflow called `llm-benchmark-table` that runs every Monday at 06:00 (America/Chicago). The workflow: (1) HTTP Request node — fetch the Open LLM Leaderboard v2 results JSON from HuggingFace (https://huggingface.co/datasets/open-llm-leaderboard/results or the public API endpoint); also fetch the LMSYS Chatbot Arena leaderboard JSON if a stable public endpoint is available — fall back to a manual curated list committed in the repo if no stable feed exists; (2) Code node — parse and flatten the results into rows of {Model, Provider, Benchmark, Score, Date, Source URL}; filter to the top 20 models by average score across benchmarks; deduplicate by model name (keep highest score per benchmark); (3) DeepSeek node (`deepseek-chat`) — given the filtered rows, produce: a clean markdown table sorted by average score descending, a 3-sentence "This Week's Takeaway" narrative highlighting any notable movements or new entrants; (4) Code node — assemble `benchmarks.md` (## LLM Benchmark Snapshot — <date> header + the markdown table + takeaway section) and `benchmarks.csv` (same rows: Model,Provider,Benchmark,Score,Date,SourceURL); (5) GitHub node — commit both files to `mike_n8n` branch on AI-Automation-Library at `My-Library/Reference/Benchmarks/<Month_YYYY>/benchmarks-llm_<date>/` and open a PR to `mike_desktop`; (6) AgentMail node — email Mike with the markdown table in the body and "LLM Benchmarks: <date>" as subject. Handle fetch errors gracefully — if the leaderboard endpoint is down, skip that source and note it in the takeaway. Validate one real end-to-end run before activating.

Scaffold a new agent-runner job called `timeline-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of an existing agent-runner Claude structured-file job. PowerShell wrapper at /tasks/jobs/run_timeline-of-the-week.ps1, invoked by run-job.sh, cron + watchdog. The job runs every Sunday at 08:00. Maintain a state file at /tasks/jobs/state/timeline_topic_index.json cycling through topics that span technology history, scientific discovery, geopolitical events, cultural movements, and natural history — seed with at least 52 topics (e.g. "History of the Internet", "Evolution of AI", "Space Exploration milestones", "History of Cryptography", "Rise of Social Media", "History of the US Dollar", "Evolution of Programming Languages", "History of Climate Science", "History of Human Flight", "History of Vaccines" — and 42 more). Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to research the week's topic thoroughly, gathering dates and events from authoritative sources; (2) produces a timeline of 20–30 key events, each with: ISO date (<Month_YYYY> or <Month_YYYY>-MM or <date> as precision allows), a one-sentence event description, a category tag (e.g. "Technical", "Political", "Scientific", "Cultural"), and a 1–5 significance score; (3) emits `timeline.csv` with header `Date,Event,Category,Significance` and 20–30 rows, properly quoted, no embedded newlines; (4) emits `timeline.md` as a chronological narrative — H2 for each decade or major era, bullet entries for each event, bold dates; (5) emits `metadata.md` (date, topic, event count, date range covered, sources, model). Output all three files into `My-Library/Reference/Timelines/<Month_YYYY>/timeline-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the timeline.md content in the body and "Timeline: <topic>" as subject. Add cron + watchdog (8d max_age). Validate one real artifact ("Evolution of AI") end-to-end before scheduling.

Scaffold a new agent-runner job called `prompt-pack-of-the-week` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of an existing agent-runner Claude structured-file job. PowerShell wrapper at /tasks/jobs/run_prompt-pack-of-the-week.ps1, invoked by run-job.sh, cron + watchdog. The job runs every Saturday at 08:00. Maintain a state file at /tasks/jobs/state/prompt_pack_topic_index.json cycling through use-case categories: writing & editing, coding & debugging, research & summarization, data analysis, image generation, role-playing & personas, brainstorming & ideation, email & communication, learning & tutoring, productivity & planning, marketing & copywriting, financial analysis — one category per week. Each run: invoke `claude --print` with a prompt that (1) uses built-in WebSearch to research current best practices and community-vetted techniques for the week's category; (2) crafts exactly 10 high-quality, ready-to-use prompt templates for that use case — each with a short title (≤8 words), a one-sentence description of when to use it, the full prompt text (use [PLACEHOLDER] tokens for user-supplied variables), and 2–4 comma-separated tags; (3) emits `prompt-pack.md` with each of the 10 prompts formatted as: `### <title>`, `**Use when:** <description>`, `**Tags:** <tags>`, then the prompt in a fenced code block; (4) emits `prompts.csv` with header `title,description,prompt_text,tags,category,source` and 10 rows — prompt_text properly double-quoted and escaped, tags as a semicolon-separated string within the cell — formatted to match the schema expected by the my-prompt-library import route so Mike can bulk-import directly into prompts.mikesailab.com; (5) emits `metadata.md` (date, category, prompt count, model, note that CSV is formatted for my-prompt-library import). Output all three files into `My-Library/Reference/Prompt-Packs/<Month_YYYY>/prompts-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail with the prompt-pack.md content in the body and "Prompt Pack: <category> (10 prompts)" as subject. Add cron + watchdog (8d max_age). Validate one real artifact ("coding & debugging" pack) end-to-end before scheduling.

Scaffold `api-endpoint-reference-of-the-week` as an agent-runner Claude job. Run Tuesdays at 07:15. Rotate APIs relevant to Mike's stack and interests (OpenAI, GitHub, AgentMail, n8n, Hugging Face, Stripe, Cloudflare, Supabase, Azure OpenAI). Research authoritative docs, produce `api-reference.md` with auth, common endpoints, request/response examples, error handling, and rate-limit notes, plus `examples.json` with sample payloads. Save metadata with source URLs; commit/push, email the reference, and validate one real artifact.

Scaffold `weekly-decision-matrix` as an agent-runner job. Run Thursdays at 07:15. Rotate practical decisions (database choice, hosting platform, AI model choice, project management tool, note app, backup strategy, auth provider, analytics tool). Research 4-8 options, define weighted criteria, emit `matrix.csv`, `recommendation.md`, and `metadata.md` with sources and caveats. Commit/push, email recommendation + table, and validate one real matrix.

Scaffold `weekly-troubleshooting-runbook` as an agent-runner Claude job. Run Fridays at 07:15. Rotate failure modes (Docker container won't start, DNS not resolving, GitHub Actions failing, n8n credential issue, ffmpeg audio sync, Python venv broken, OAuth expired, cron not firing, disk full). Produce `runbook.md` with symptoms, likely causes, diagnosis commands, fix steps, rollback, and prevention checklist; include `metadata.md` with sources and tested assumptions. Commit/push, email the checklist, and validate one artifact.

Scaffold a new agent-runner job called `weekly-cool-websites` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structure of an existing agent-runner Claude WebSearch job (e.g. weekly-iam-idea): a PowerShell wrapper at /tasks/jobs/run_weekly_cool_websites.ps1 that substitutes {REPO_ROOT}/{TARGET_DATE_INSTRUCTION} into a workflow prompt and pipes it to `claude --print --dangerously-skip-permissions`, invoked by run-job.sh, with cron + watchdog. The job runs every Thursday at 15:00 (America/Chicago). Each run: invoke `claude --print` with a prompt that (1) pulls mike_desktop; (2) reads every prior weekly file under My-Library/Content/Cool-Websites/ and collects already-featured site names/domains so it never repeats one; (3) uses built-in WebSearch/WebFetch to discover AND verify (real, live, ideally lesser-known, free/freemium) websites — mining awesome-* GitHub lists, r/InternetIsBeautiful, Show HN, Product Hunt, etc.; (4) organizes at least 28 sites into 8-12 categories (always include a security/privacy/OSINT category as the signature; rotate the rest from: cyber/hacking tools, IT/sysadmin tools, AI tools, video/image tools, dev tools, Windows software, open-source software, productivity & collaboration, learning, games, travel, money/finance, fun/weird internet), each site as a `### [Name](URL)` heading + 1-2 sentence description; (5) writes the digest to My-Library/Content/Cool-Websites/<Month_YYYY>/cool-websites-<date>/cool-websites-<date>.md with YAML frontmatter (title, date, type: cool-websites, site_count, categories, tags, model, source_workflow, cover_image_model/prompt); (6) generates a landscape cover-image.png via the nanobanana MCP (dark neon hacker-tech "cool corners of the internet" collage, no real logos), with a Gemini-SDK fallback (script/categories/shared/gemini_image.py, --aspect 16:9) and never a hand-drawn placeholder; (7) commits ONLY the new folder and pushes mike_desktop (rebase-retry once); (8) writes the repo-relative digest path to .last_weekly_cool_websites_path.txt. The wrapper resolves that handoff path (git-add fallback), builds a structured HTML email (kicker + title + intro + this-week's-categories list) and sends the digest + cover via the shared AgentMail helper (--text-file/--html-file, label weekly-cool-websites). Register the new `cool-websites` gallery category in the web app (walker in Site/scripts/build-manifest.mjs modeled on walkContentIdeas + the 5 manifest.ts spots + global.css token + category-icons.ts), add cron + watchdog (8d max_age), add the calendar TOML row, and validate one real artifact end-to-end before scheduling.

Scaffold `daily-micro-lesson` as an agent-runner Claude job. Run daily at 06:40. Rotate subjects (Python, SQL, statistics, AI concepts, cybersecurity, finance, history, science). Generate a 900-1,200 word lesson with objective, explanation, worked example, three practice questions, answer key, and source links. Save `lesson.md`, `metadata.md`, and `prompt.md`; commit/push, email the objective and questions, and validate one real lesson.

Scaffold `weekly-printable-worksheet` as an agent-runner job. Run Wednesdays at 06:40. Rotate topics and difficulty. Generate 20 practice items, an answer key with explanations, and render a clean printable PDF using reportlab. Save `worksheet.md`, `worksheet.pdf`, `answer-key.md`, `metadata.md`, and `prompt.md`; commit/push, email the PDF, and validate one complete worksheet.

Scaffold `weekly-interactive-quiz-lesson` as an agent-runner job. Run Fridays at 12:30. Pick an educational topic, write a compact lesson and 12-question quiz, then build a self-contained `index.html` with one-question-at-a-time flow, explanations, score screen, and no runtime fetches. Generate `cover-image.png`, save `metadata.md`, commit/push, email the cover and topic, and validate desktop/mobile browser behavior.

Scaffold `weekly-audio-explainer` as an agent-runner job. Run Sundays at 06:40. Rotate topics that benefit from spoken explanation, research sources, write an 8-10 minute script with examples and recap, render with ElevenLabs TTS, and save `audio-lesson.mp3`, `transcript.md`, `metadata.md`, and `prompt.md`. Commit/push, email the MP3 and recap bullets, and validate one full episode.

Scaffold `weekly-sop-builder` as an agent-runner Claude job. Run Mondays at 08:45. Rotate operational processes (newsletter publishing, incident response, content QA, customer support triage, backup verification, lead qualification, invoice follow-up, release checklist). Produce `sop.md` with purpose, roles, prerequisites, step-by-step process, QA checks, failure handling, and improvement notes; emit `checklist.csv` for task tracking and `metadata.md`. Commit/push, email the checklist, and validate one SOP.

Scaffold `weekly-market-opportunity-scan` as an agent-runner Claude job. Run Tuesdays at 08:45. Rotate niches relevant to AI automation, developer tools, local services, creator businesses, and SaaS. Research current signals, competitors, pain points, buyer personas, pricing, risks, and a small experiment Mike could run. Save `market-scan.md`, `sources.csv`, `metadata.md`, and `prompt.md`; commit/push, email the top opportunity and risks, and validate one real scan.

Scaffold `monthly-content-calendar-generator` as an agent-runner job. Run on day 2 monthly at 08:45. Choose a channel/theme (AI lab updates, cooking, maps/travel, apps/tools, education, cybersecurity), generate a 30-day calendar with post date, platform, title, hook, asset needed, CTA, and repurpose notes. Save `content-calendar.csv`, `strategy.md`, `metadata.md`, and `prompt.md`; commit/push, email the strategy summary, and validate one calendar.

Scaffold `weekly-vendor-scorecard` as an agent-runner job. Run Thursdays at 08:45. Rotate vendor categories (email API, TTS provider, image model, hosting provider, observability tool, payment processor, CRM, vector database). Research 4-7 vendors, define weighted criteria, produce `scorecard.csv`, `recommendation.md`, and `metadata.md` with source URLs and caveats. Commit/push, email the recommendation table, and validate one real scorecard.

Scaffold a new agent-runner job called `weekly-pc-game-concept` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Claude + nanobanana pattern from Weekly App Prototype. The job runs every Monday at 09:15 via cron + watchdog (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) picks a PC game genre from a rotating list in the script (immersive sim, survival crafting, colony sim, tactical RPG, roguelike deckbuilder, automation/factory sim, cozy management sim, detective mystery, grand strategy, extraction shooter), (2) researches 3-5 current genre references with built-in WebSearch and records source URLs, (3) writes a complete `game-design-brief.md` with title, one-sentence hook, target player, core loop, systems, progression, world/setting, monetization notes, accessibility notes, risks, and a 6-week prototype plan, (4) renders a self-contained `pitch.html` with a polished one-page pitch view and copyable feature bullets, and (5) calls nanobanana `generate_image` for a 16:9 key-art cover saved as `cover-image.png`. Output `game-design-brief.md`, `pitch.html`, `cover-image.png`, `metadata.md`, and `sources.csv` into `My-Library/Games/PC-Game-Concepts/<Month_YYYY>/pc-game-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the cover attached and the hook plus top 3 differentiators in the body. Validate one real artifact end-to-end before scheduling.

Scaffold a new agent-runner job called `weekly-mobile-game-prototype` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Weekly Browser Game Claude + nanobanana pattern. The job runs every Tuesday at 09:15 via cron + watchdog (max_age 8d). Each run: invoke `claude --print` with a prompt that (1) rotates through mobile-friendly game types (one-thumb endless runner, swipe puzzle, tap timing game, merge game, idle resource loop, match-3 variant, word puzzle, reaction trainer, lane dodger, portrait tower defense), (2) writes a complete self-contained `index.html` optimized for phone portrait orientation, with inline CSS/JS, no backend, no runtime network calls, touch controls, score, levels or escalating difficulty, restart button, muted-by-default sound effects if implemented, and responsive layout for desktop preview, (3) includes an in-page balancing note hidden in a collapsible details section, and (4) calls nanobanana `generate_image` for a square app-store-style cover saved as `cover-image.png`. Output `index.html`, `cover-image.png`, and `metadata.md` (date, game type, controls, difficulty curve, CDN deps) into `My-Library/Games/Mobile-Prototypes/<Month_YYYY>/mobile-game-<slug>_<date>/`. Commit and push to `mike_desktop`. Send an AgentMail email with the cover attached, the game type, and a two-sentence gameplay description. Validate one real artifact in desktop and mobile viewport sizes before scheduling.

Scaffold a new agent-runner job called `weekly-board-game-kit` following AI-Library-Automations/PORTING-PLAYBOOK.md. Use Claude for rules and printable layout generation, and Codex gpt-image-2 for images with readable board/card text. The job runs every Wednesday at 09:15 via cron + watchdog (max_age 8d). Each run: choose a board-game format from a rotating list (worker placement, push-your-luck dice game, cooperative survival, area control, tableau builder, roll-and-write, deduction game, tile laying, auction game, racing game). Generate a complete tabletop kit: `rules.md` with setup, components, turn structure, actions, scoring, variants, and solo mode; `components.csv` listing every token/card/die/marker; `print-and-play.html` containing print-ready board/card/token sheets; `balance-notes.md` explaining probabilities and playtest risks; and image assets `board.png` plus `cards-sheet.png` using gpt-image-2 where all titles and labels are readable. Render a PDF from the HTML if the existing PDF pattern supports it. Save all outputs plus `metadata.md` under `My-Library/Games/Board-Game-Kits/<Month_YYYY>/board-game-<slug>_<date>/`. Commit and push to `mike_desktop`. Email Mike the rules summary, component count, and attached cover/board preview. Validate one real kit by opening the HTML/PDF and checking that text is readable.

Scaffold a new agent-runner job called `weekly-card-game-expansion` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Codex gpt-image-2 text-in-image pattern from Weekly Trading Card Set. The job runs every Thursday at 09:15 via cron + watchdog (max_age 8d). Each run: choose a fictional base game archetype from a rotating list (deckbuilder, dueling TCG, cooperative boss battler, party drafting game, solo roguelike card game, tactical skirmish card game). Generate an 18-card expansion: `cards.csv` with card name, type, cost, rules text, rarity, faction, and design notes; `rules-insert.md` explaining new keywords and compatibility; `print-sheet.html` for printable proxies; and `card-sheet.png` with readable card names, costs, and short rules text baked into the images using gpt-image-2. Include rarity distribution and balance notes in `metadata.md`. Commit and push to `mike_desktop`. Email the expansion theme, three standout cards, and the card sheet. Validate that the CSV has exactly 18 cards and the printable sheet opens correctly.

Scaffold a new agent-runner job called `weekly-game-jam-prompt-pack` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily App Card Claude + nanobanana pattern but running weekly. The job runs every Friday at 09:15 via cron + watchdog (max_age 8d). Each run: generate a compact game-jam pack with one central theme, 10 optional constraints, 10 mechanics prompts, 10 art-direction prompts, 5 stretch goals, 5 anti-goals, and three scoped concept examples (2-hour prototype, weekend prototype, month-long version). Render `jam-pack.md`, `constraints.csv`, and a self-contained `cards.html` that displays shuffled prompt cards with a "draw another" button and copy-to-clipboard. Call nanobanana `generate_image` for a square cover saved as `cover-image.png`. Save everything plus `metadata.md` under `My-Library/Games/Game-Jam-Prompts/<Month_YYYY>/jam-pack-<slug>_<date>/`. Commit and push to `mike_desktop`. Email the central theme and attached cover. Validate one real artifact and confirm the shuffle button works.

Scaffold a new agent-runner job called `weekly-game-asset-pack` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the Daily Icon Packs Gemini SDK batch pattern. The job runs every Saturday at 09:15 via cron + watchdog (max_age 8d). Each run: rotate a game-art style and use case (pixel-art dungeon crawler, cozy farming sim UI, sci-fi RTS icons, fantasy RPG items, mobile puzzle-game tiles, cyberpunk platformer pickups, space shooter enemies, board-game tokens). Use `google-genai` with `gemini-3.1-flash-image` to create a cohesive pack of at least 12 assets: one contact sheet `asset-sheet.png` plus individual files `asset-01.png` through `asset-12.png` where feasible. Add `manifest.json` with filename, intended use, style notes, palette, and prompt fragment for each asset; add `metadata.md` and `prompt.md`. Commit and push to `mike_desktop`. Email the asset sheet and style/use case. Validate one real run by confirming all manifest filenames exist.

Build a new n8n workflow called `weekly-game-news-release-digest` following the existing AI News Digest / text-digest fleet pattern from AI-Library-Automations/runbooks/n8n. The workflow runs Sundays at 08:30 America/Chicago. It gathers current PC, console, mobile, and tabletop game news from RSS/HTTP sources, filters to the top 10-15 items from the past week, uses the LangChain AI Agent with DeepSeek `deepseek-chat` to produce `digest.md` with sections for major releases, notable updates, industry/business moves, indie highlights, mobile trends, and tabletop news, plus `sources.csv` with title, URL, source, date, and category. It emails Mike the digest via AgentMail and commits the markdown/CSV into `My-Library/Games/News-Digests/<Month_YYYY>/game-news-<slug>_<date>/` on branch `mike_n8n`, opening a PR if that is the established digest pattern. Use built-in HTTP/RSS nodes and do not add serper. Validate with one manual workflow execution using real current sources before activating the schedule.

Scaffold a new agent-runner job called `weekly-pc-game-deal-radar` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structured research/report pattern from Weekly Market Opportunity Scan. The job runs every Friday at 13:30 via cron + watchdog (max_age 8d). Each run: use built-in WebSearch to identify notable current PC game deals, free-weekend events, bundles, and deep discounts from reputable public sources. Produce `deal-radar.md` with top picks, why they matter, target player, replay value, caveats, and sale deadline where available; produce `deals.csv` with title, platform/store, discount, current price if found, normal price if found, deadline, URL, and recommendation tier. Include source URLs and date checked in `metadata.md`. Commit and push to `mike_desktop`. Email the top 5 deals and any deadlines. Validate one real report and avoid affiliate links.

Scaffold a new agent-runner job called `weekly-game-mod-idea-lab` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the concept-card pattern from Weekly Chrome-Extension Concept but outputting markdown and HTML. The job runs every Tuesday at 13:30 via cron + watchdog (max_age 8d). Each run: choose a moddable PC game or modding ecosystem from a rotating list (Minecraft datapack, Skyrim quest mod, Stardew Valley content mod, Factorio quality-of-life mod, RimWorld scenario, Cities: Skylines asset pack, Balatro challenge mod, Tabletop Simulator board-game mod, Terraria item mod). Use WebSearch to verify the current modding surface at a high level, then produce `mod-spec.md` with concept, player value, required tools, data/files likely touched, mechanics, quest/content outline where relevant, compatibility risks, and a weekend prototype plan. Render `concept.html` with a concise showcase and code/config snippet if appropriate. Add `asset-wishlist.csv`, `sources.csv`, and `metadata.md`. Commit and push to `mike_desktop`. Email the mod title and implementation risk rating. Validate one real artifact and make clear that this is a concept/spec, not a packaged mod.

Scaffold a new agent-runner job called `monthly-solo-rpg-adventure` following AI-Library-Automations/PORTING-PLAYBOOK.md, copying the structured writing plus PDF/HTML render pattern from the books or cookbook jobs and using nanobanana for cover art. The job runs on day 3 of each month at 09:15 via cron + watchdog (max_age 35d). Each run: choose a genre from a rotating list (fantasy dungeon, sci-fi derelict ship, noir city mystery, post-apocalyptic road trip, cozy village mystery, cosmic horror investigation, pirate island, cyberpunk heist). Generate a complete rules-light solo adventure playable with standard six-sided dice: `adventure.md` with setup, character creation, oracle rules, 12 scenes, encounter tables, item tables, clues, endings, and replay variants; `tables.csv` with all roll tables; `printable.html` suitable for PDF rendering; `cover-image.png` via nanobanana; and `metadata.md` with genre, intended playtime, required dice, and safety/content notes. Commit and push to `mike_desktop`. Email the cover plus adventure hook and playtime. Validate one real adventure and render/open the printable artifact.