Aside Publishing, In-Place Broadcast Resume, and the ytfeature Backfill Queue

   git push (aside / edit) ──► post-receive: checkout main, ring .deploy_standby
                                        │
                                        ▼
   stream.py (at paragraph k) ─► get_featured_article_id() == active_article_id?
                                        │
                  ┌─────────────────────┴─────────────────────┐
                  │ YES (Aside / Maintenance)                 │ NO (New Featured Show)
                  ▼                                           ▼
     Pop UPDATING + tick.wav                     Pop UPDATING + tick.wav
     "Minor maintenance is occurring..."         "Receiving updates. A new broadcast..."
     Wait for .reading_trigger + settle          Wait for .reading_trigger + settle
     Dismiss card, restart BGM                   Dismiss card
     Resume paragraph k in place!                return "BREAKING" -> start new show

remotes/honeybot/hooks/post-receive
remotes/honeybot/scripts/content_loader.py
remotes/honeybot/scripts/stream.py
scripts/articles/articleizer.py
scripts/articles/common.py
flake.nix
! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('.deploy_standby'), '| featured_id_helper:', 'def get_featured_article_id' in cl, '| maintenance_line:', 'STANDBY_MAINTENANCE_LINE' in st)"

Target: remotes/honeybot/hooks/post-receive
[[[SEARCH]]]
# 0. The Stand-By Bell: signal the live stream to gracefully announce that
# updates are incoming and HOLD narration, BEFORE the multi-second Jekyll build
# and markdown dye pass thrash the Piper TTS. The completion bell rings at the end.
date +%s > $WORK_TREE/.deploy_standby

# 1. Force Checkout to the Web Root
git --work-tree=$WORK_TREE --git-dir=$GIT_DIR checkout -q -f main
[[[DIVIDER]]]
# 0. Force Checkout to the Web Root FIRST (~10ms on local SSD) so _posts/*.md
# is already updated on disk when stream.py inspects get_featured_article_id()
# on the .deploy_standby bell to decide Maintenance Resume vs. New Broadcast.
git --work-tree=$WORK_TREE --git-dir=$GIT_DIR checkout -q -f main

# 1. The Stand-By Bell: signal the live stream to gracefully announce that
# updates are incoming and HOLD narration, BEFORE the multi-second Jekyll build
# and markdown dye pass thrash the Piper TTS. The completion bell rings at the end.
date +%s > $WORK_TREE/.deploy_standby
[[[REPLACE]]]

Target: remotes/honeybot/scripts/content_loader.py
[[[SEARCH]]]
def get_playlist(recent_n=10, include_archive=True):
    """
    Returns a playlist: Recent N (sorted date desc + sort_order desc) + optional Rest (shuffled).
    When include_archive=False, stops scanning older dates once recent_n articles are loaded.
    """
[[[DIVIDER]]]
def _is_storytime_enabled(frontmatter):
    """True unless frontmatter explicitly opts out via storytime: false or aside: true."""
    if not isinstance(frontmatter, dict):
        return True
    if frontmatter.get('aside') is True:
        return False
    val = frontmatter.get('storytime', True)
    if isinstance(val, bool):
        return val
    return str(val).strip().lower() not in ('false', '0', 'no', 'off', 'aside')

def get_featured_article_id():
    """Return (date_str, sort_order, filename) of the newest Storytime-eligible post on disk."""
    best = None
    try:
        files = sorted(
            list(POSTS_DIR.glob("*.md")) + list(POSTS_DIR.glob("*.markdown")),
            key=lambda p: p.name,
            reverse=True,
        )
        cutoff_date = None
        for filepath in files:
            filename = filepath.name
            try:
                date_str = filename[:10]
                post_date = datetime.strptime(date_str, '%Y-%m-%d').date()
            except ValueError:
                continue
            if cutoff_date is not None and post_date < cutoff_date:
                break
            try:
                head = filepath.read_text(encoding='utf-8')[:4096]
            except OSError:
                continue
            frontmatter = {}
            if head.startswith('---'):
                try:
                    parts = head.split('---', 2)
                    if len(parts) >= 3:
                        frontmatter = yaml.safe_load(parts[1]) or {}
                except yaml.YAMLError:
                    pass
            if not _is_storytime_enabled(frontmatter):
                continue
            try:
                sort_order = int(frontmatter.get('sort_order', 0))
            except (ValueError, TypeError):
                sort_order = 0
            cand = (date_str, sort_order, filename)
            if best is None or cand > best:
                best = cand
            cutoff_date = post_date
    except Exception:
        return None
    return best

def get_playlist(recent_n=10, include_archive=True):
    """
    Returns a playlist: Recent N (sorted date desc + sort_order desc) + optional Rest (shuffled).
    When include_archive=False, stops scanning older dates once recent_n articles are loaded.
    """
[[[REPLACE]]]

Target: remotes/honeybot/scripts/content_loader.py
[[[SEARCH]]]
            # 3. Extract Sort Order (Default to 0)
            try:
                sort_order = int(frontmatter.get('sort_order', 0))
            except (ValueError, TypeError):
                sort_order = 0
[[[DIVIDER]]]
            if not _is_storytime_enabled(frontmatter):
                continue

            # 3. Extract Sort Order (Default to 0)
            try:
                sort_order = int(frontmatter.get('sort_order', 0))
            except (ValueError, TypeError):
                sort_order = 0
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
# Spoken over tick.wav when `publish "msg"` rings .deploy_standby on Honeybot.
# Edit with `ytoutro edit` and audition locally on Prime with `ytoutro`.
STANDBY_INTRO_LINE = "Receiving updates. A new broadcast is coming up."
[[[DIVIDER]]]
# Spoken over tick.wav when `publish "msg"` rings .deploy_standby on Honeybot.
# Edit with `ytoutro edit` and audition locally on Prime with `ytoutro`.
STANDBY_INTRO_LINE = "Receiving updates. A new broadcast is coming up."

STANDBY_MAINTENANCE_LINE = (
    "Minor maintenance is occurring and this article will continue reading in a moment..."
)
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
    except Exception:
        pass
    return intro, loop_lines
[[[DIVIDER]]]
    except Exception:
        pass
    return intro, loop_lines

def load_maintenance_line(stream_file=None):
    """Read STANDBY_MAINTENANCE_LINE fresh from stream.py on disk via AST."""
    import ast
    line = STANDBY_MAINTENANCE_LINE
    target = Path(stream_file) if stream_file else Path(__file__).resolve()
    try:
        tree = ast.parse(target.read_text(encoding="utf-8"))
        for node in tree.body:
            if isinstance(node, ast.Assign):
                for t in node.targets:
                    if isinstance(t, ast.Name) and t.id == "STANDBY_MAINTENANCE_LINE":
                        val = ast.literal_eval(node.value)
                        if isinstance(val, str) and val.strip():
                            line = val.strip()
    except Exception:
        pass
    return line
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
try:
    import score
    from content_loader import check_for_updates, check_standby, trigger_is_fresh, check_live_message, has_pending_update
except ImportError:
    score = None
    def check_live_message():
        return None
    def has_pending_update():
        return False
[[[DIVIDER]]]
try:
    import score
    from content_loader import (
        check_for_updates,
        check_standby,
        trigger_is_fresh,
        check_live_message,
        has_pending_update,
        get_featured_article_id,
    )
except ImportError:
    score = None
    def check_live_message():
        return None
    def has_pending_update():
        return False
    def get_featured_article_id():
        return None
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
    profile_dir = tempfile.mkdtemp(prefix="honeybot_fx_")
[[[DIVIDER]]]
    profile_dir = tempfile.mkdtemp(prefix="honeybot_fx_")
    active_article_id = get_featured_article_id()
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
            # --- The Deploy Stand-By Handshake ---
            # A fresh push rings the standby bell BEFORE the multi-second build.
            # Announce calmly ONCE, cut the current narration, and HOLD (silent) until
            # the completion bell rings -- so the TTS doesn't thrash through the deploy.
            if check_standby():
                standby_intro_line, standby_loop_lines = load_standby_speech()
                was_exclusive = narrator.exclusive_mode.is_set()
                narrator.exclusive_mode.set()
                # The outer `duration` here is a generous LAST-RESORT ceiling, not
                # the thing that's supposed to close this window. The deterministic
                # close is the pkill below, fired the instant check_for_updates()
                # proves the deploy is actually done -- never a guessed elapsed time.
                #
                # CRITICAL: launch on a DAEMON THREAD. conjure_window() (in
                # imports/ascii_displays.py) is BLOCKING -- it bottoms out in
                # proc.wait(timeout=duration). Called inline, it froze this entire
                # loop for the full duration, starving the check_for_updates() poll
                # below and leaving the UPDATING banner stuck on screen (narration
                # silent) until the self-cap expired -- the "never resumes without
                # --reboot" bug. Threaded, the poll keeps running and the pkill
                # tears the card down the instant the completion bell rings: pkill
                # ends card.py, alacritty exits, proc.wait returns, the thread dies.
                updating_card = None
                music_proc = None
                try:
                    stop_storytime_bgm()
                    narrator.interrupt()  # cut current audio + flush the backlog
                    narrator.say(standby_intro_line)
                    for line in standby_loop_lines:
                        narrator.say(line)
                    updating_card = show_card("UPDATING", max_hold=270.0)
                    # Card up -> music up. Born at the same instant as the
                    # UPDATING figlet; dies at the same deterministic teardown
                    # below. PipeWire mixes it under the standby announcement,
                    # broadcast-style.
                    music_proc = start_updating_music()
                    try:
                        subprocess.run(["pkill", "firefox"], check=False)
                    except Exception:
                        pass
                    # Hold narration until the deploy finishes (completion bell rings)
                    # or we time out gracefully, refilling the standby speech queue
                    # whenever it drains so the message genuinely loops until teardown.
                    deadline = time.time() + 240
                    bell_rang = False
                    while time.time() < deadline:
                        if check_for_updates():
                            bell_rang = True
                            break
                        if narrator.queue.unfinished_tasks == 0:
                            for line in standby_loop_lines:
                                narrator.say(line)
                        time.sleep(2)
                    # If the trigger bell rang, hold the UPDATING card up while Jekyll/dye/
                    # Nix activity fully settles. The card disappears exactly when the article
                    # starts reading, with nothing competing for CPU/disk.
                    # Tune SETTLE_SECONDS upward if nixos-rebuild switch is still thrashing.
                    SETTLE_SECONDS = 45
                    if bell_rang:
                        settle_deadline = time.time() + SETTLE_SECONDS
                        while time.time() < settle_deadline:
                            if narrator.queue.unfinished_tasks == 0:
                                for line in standby_loop_lines:
                                    narrator.say(line)
                            time.sleep(1)
                finally:
                    # Tear down the dead-air cover and cut any in-flight standby
                    # speech deterministically the moment we exit standby.
                    narrator.interrupt()
                    stop_updating_music(music_proc)
                    dismiss_card(updating_card)
                    if not was_exclusive:
                        narrator.exclusive_mode.clear()
                    try:
                        subprocess.run(["pkill", "-f", "card.py.*UPDATING"], check=False)
                    except Exception:
                        pass
                return "BREAKING"
[[[DIVIDER]]]
            # --- The Deploy Stand-By Handshake ---
            # A fresh push rings the standby bell BEFORE the multi-second build.
            # If the featured Storytime article on disk changed, announce a new
            # broadcast and return "BREAKING"; if the featured article is unchanged
            # (an aside publish or maintenance push), speak STANDBY_MAINTENANCE_LINE
            # over tick.wav and resume the current article at this exact cue.
            if check_standby():
                standby_intro_line, standby_loop_lines = load_standby_speech()
                maintenance_line = load_maintenance_line()
                new_featured_id = get_featured_article_id()
                is_new_show = (
                    active_article_id is not None
                    and new_featured_id is not None
                    and new_featured_id != active_article_id
                )
                bgm_was_active = (_bgm_proc is not None)
                was_exclusive = narrator.exclusive_mode.is_set()
                narrator.exclusive_mode.set()
                updating_card = None
                music_proc = None
                try:
                    stop_storytime_bgm()
                    narrator.interrupt()  # cut current audio + flush the backlog
                    if is_new_show:
                        narrator.say(standby_intro_line)
                        for line in standby_loop_lines:
                            narrator.say(line)
                    else:
                        narrator.say(maintenance_line)
                    updating_card = show_card("UPDATING", max_hold=270.0)
                    music_proc = start_updating_music()
                    try:
                        subprocess.run(["pkill", "firefox"], check=False)
                    except Exception:
                        pass
                    deadline = time.time() + 240
                    bell_rang = False
                    last_maint_remind = time.time()
                    while time.time() < deadline:
                        if check_for_updates():
                            bell_rang = True
                            break
                        if is_new_show:
                            if narrator.queue.unfinished_tasks == 0:
                                for line in standby_loop_lines:
                                    narrator.say(line)
                        elif (time.time() - last_maint_remind) >= 35 and narrator.queue.unfinished_tasks == 0:
                            narrator.say(maintenance_line)
                            last_maint_remind = time.time()
                        time.sleep(2)
                    SETTLE_SECONDS = 45
                    if bell_rang:
                        latest_after_bell = get_featured_article_id()
                        if (
                            active_article_id is not None
                            and latest_after_bell is not None
                            and latest_after_bell != active_article_id
                        ):
                            is_new_show = True
                        settle_deadline = time.time() + SETTLE_SECONDS
                        while time.time() < settle_deadline:
                            if is_new_show and narrator.queue.unfinished_tasks == 0:
                                for line in standby_loop_lines:
                                    narrator.say(line)
                            elif (not is_new_show) and (time.time() - last_maint_remind) >= 35 and narrator.queue.unfinished_tasks == 0:
                                narrator.say(maintenance_line)
                                last_maint_remind = time.time()
                            time.sleep(1)
                finally:
                    narrator.interrupt()
                    stop_updating_music(music_proc)
                    dismiss_card(updating_card)
                    if not was_exclusive:
                        narrator.exclusive_mode.clear()
                    try:
                        subprocess.run(["pkill", "-f", "card.py.*UPDATING"], check=False)
                    except Exception:
                        pass
                if is_new_show:
                    return "BREAKING"
                if bgm_was_active:
                    start_storytime_bgm()
                narrator.say("Resuming storytime.")
                wait_for_voice_or_live_interrupt(env, profile_dir)
[[[REPLACE]]]

Verify the Car 1 AFTER receipt confirming `post-receive`, `content_loader.py`, and `stream.py` now distinguish between a New Featured Broadcast and a Minor Maintenance / Aside deploy that resumes in place.

Now let's execute Car 2:
1. Add `--aside` to `scripts/articles/articleizer.py` so running `article --aside` sets `storytime: false` in the generated post's YAML frontmatter (while normal `article` omits it or defaults to Storytime-enabled).
2. Add a clean helper command (`ytfeature [slug]` via `scripts/articles/common.py` and `flake.nix`) so I can inspect which published articles have `storytime: false` (our backfill queue), promote any past article to be the active Storytime broadcast on Honeybot, or stamp `vod_url` into frontmatter.

# # Context 1
# flake.nix
# 
# # HOME-HOSTED (NOT BEHIND CDN) NGINX WEBSERVER HONEYBOT AI OBSERVATORY
# nixops.sh
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/nixos/configuration.nix
# remotes/honeybot/scripts/stream.py
# remotes/honeybot/scripts/score.py
# remotes/honeybot/scripts/card.py
# remotes/honeybot/scripts/forest.py
# remotes/honeybot/scripts/test_forest.py
# remotes/honeybot/scripts/logs.py
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/db.py
# 
# # THE JEKYLL BLOG LIKE A HACKER (INVENTED SKILL.md & AGENTS.md FORMAT) PUBLISHING PIPELINE
# ~/repos/nixos/blogs.nix
# ~/.config/pipulate/blogs.json
# scripts/articles/publishizer.py
# scripts/articles/common.py
# scripts/articles/articleizer.py
# scripts/articles/link_injector.py
# scripts/articles/build_knowledge_graph.py
# scripts/articles/editing_prompt.txt
# scripts/articles/sanitizer.py
# scripts/articles/contextualizer.py
# scripts/articles/generate_hubs.py
# scripts/articles/generate_llms_txt.py
# scripts/articles/generate_post_nav.py
# assets/jekyll/common-packages.nix

# Context 2
remotes/honeybot/hooks/post-receive
remotes/honeybot/scripts/content_loader.py
remotes/honeybot/scripts/stream.py
scripts/articles/articleizer.py
scripts/articles/common.py
flake.nix
! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('.deploy_standby'), '| featured_id_helper:', 'def get_featured_article_id' in cl, '| maintenance_line:', 'STANDBY_MAINTENANCE_LINE' in st)"
# TRIMNOIR
~/repos/trimnoir/_config.yml
~/repos/trimnoir/flake.nix
~/repos/trimnoir/Gemfile
~/repos/trimnoir/index.md
~/repos/trimnoir/_layouts/default.html
~/repos/trimnoir/_layouts/page.html
~/repos/trimnoir/_layouts/post.html
~/repos/trimnoir/assets/main.css

remotes/honeybot/hooks/post-receive
remotes/honeybot/scripts/content_loader.py
remotes/honeybot/scripts/stream.py
scripts/articles/articleizer.py
scripts/articles/common.py
scripts/articles/generate_hubs.py
flake.nix
! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); ar=pathlib.Path('scripts/articles/articleizer.py').read_text(); cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('date +%s > \$WORK_TREE/.deploy_standby'), '| storytime_rank:', '_storytime_effective_rank' in cl, '| aside_flag:', '--aside' in ar, '| ytfeature_cmd:', 'def manage_storytime_feature' in cm and 'ytfeature()' in fl)"
~/repos/trimnoir/index.md
~/repos/trimnoir/_layouts/default.html
~/repos/trimnoir/_layouts/post.html
~/repos/trimnoir/assets/main.css

Target: remotes/honeybot/hooks/post-receive
[[[SEARCH]]]
# 0. Force Checkout to the Web Root FIRST (~10ms on local SSD) so _posts/*.md
# is already updated on disk when stream.py inspects get_featured_article_id()
# on the .deploy_standby bell to decide Maintenance Resume vs. New Broadcast.
git --work-tree=$WORK_TREE --git-dir=$GIT_DIR checkout -q -f main
[[[DIVIDER]]]
# 0. Force Checkout to the Web Root FIRST (~10ms on local SSD) so _posts/*.md
# is already updated on disk when stream.py inspects get_featured_article_id()
# on the standby bell to decide Maintenance Resume vs. New Broadcast.
git --work-tree=$WORK_TREE --git-dir=$GIT_DIR checkout -q -f main
[[[REPLACE]]]

Target: remotes/honeybot/scripts/content_loader.py
[[[SEARCH]]]
def _is_storytime_enabled(frontmatter):
    """True unless frontmatter explicitly opts out via storytime: false or aside: true."""
    if not isinstance(frontmatter, dict):
        return True
    if frontmatter.get('aside') is True:
        return False
    val = frontmatter.get('storytime', True)
    if isinstance(val, bool):
        return val
    return str(val).strip().lower() not in ('false', '0', 'no', 'off', 'aside')

def get_featured_article_id():
    """Return (date_str, sort_order, filename) of the newest Storytime-eligible post on disk."""
    best = None
    try:
        files = sorted(
            list(POSTS_DIR.glob("*.md")) + list(POSTS_DIR.glob("*.markdown")),
            key=lambda p: p.name,
            reverse=True,
        )
        cutoff_date = None
        for filepath in files:
            filename = filepath.name
            try:
                date_str = filename[:10]
                post_date = datetime.strptime(date_str, '%Y-%m-%d').date()
            except ValueError:
                continue
            if cutoff_date is not None and post_date < cutoff_date:
                break
            try:
                head = filepath.read_text(encoding='utf-8')[:4096]
            except OSError:
                continue
            frontmatter = {}
            if head.startswith('---'):
                try:
                    parts = head.split('---', 2)
                    if len(parts) >= 3:
                        frontmatter = yaml.safe_load(parts[1]) or {}
                except yaml.YAMLError:
                    pass
            if not _is_storytime_enabled(frontmatter):
                continue
            try:
                sort_order = int(frontmatter.get('sort_order', 0))
            except (ValueError, TypeError):
                sort_order = 0
            cand = (date_str, sort_order, filename)
            if best is None or cand > best:
                best = cand
            cutoff_date = post_date
    except Exception:
        return None
    return best
[[[DIVIDER]]]
def _is_storytime_enabled(frontmatter):
    """True unless frontmatter explicitly opts out via storytime: false or aside: true."""
    if not isinstance(frontmatter, dict):
        return True
    if frontmatter.get('aside') is True:
        return False
    val = frontmatter.get('storytime', True)
    if isinstance(val, bool):
        return val
    return str(val).strip().lower() not in ('false', '0', 'no', 'off', 'aside')

def _storytime_effective_rank(post_date, sort_order, frontmatter):
    """Return (eff_date, eff_order) honoring storytime_featured and storytime_order overrides."""
    eff_date = post_date
    eff_order = sort_order
    if isinstance(frontmatter, dict):
        feat_raw = str(frontmatter.get('storytime_featured') or '').strip()[:10]
        if feat_raw:
            try:
                eff_date = datetime.strptime(feat_raw, '%Y-%m-%d').date()
            except ValueError:
                eff_date = post_date
        if frontmatter.get('storytime_order') is not None:
            try:
                eff_order = int(frontmatter['storytime_order'])
            except (ValueError, TypeError):
                eff_order = sort_order
    return eff_date, eff_order

def _get_pinned_storytime_file():
    """Return Path to the post named in _data/storytime.json if present on disk."""
    try:
        st_file = POSTS_DIR.parent / "_data" / "storytime.json"
        if st_file.is_file():
            import json
            data = json.loads(st_file.read_text(encoding='utf-8'))
            fname = str((data or {}).get('filename') or '').strip()
            if fname:
                cand = POSTS_DIR / fname
                if cand.is_file():
                    return cand
    except Exception:
        pass
    return None

def get_featured_article_id():
    """Return (eff_date_str, eff_order, filename) of the active Storytime-eligible post on disk."""
    best = None
    try:
        files = sorted(
            list(POSTS_DIR.glob("*.md")) + list(POSTS_DIR.glob("*.markdown")),
            key=lambda p: p.name,
            reverse=True,
        )
        pinned = _get_pinned_storytime_file()
        scan_list = list(files[:35])
        if pinned is not None and pinned not in scan_list:
            scan_list.append(pinned)
        for filepath in scan_list:
            filename = filepath.name
            try:
                date_str = filename[:10]
                post_date = datetime.strptime(date_str, '%Y-%m-%d').date()
            except ValueError:
                continue
            try:
                head = filepath.read_text(encoding='utf-8')[:4096]
            except OSError:
                continue
            frontmatter = {}
            if head.startswith('---'):
                try:
                    parts = head.split('---', 2)
                    if len(parts) >= 3:
                        frontmatter = yaml.safe_load(parts[1]) or {}
                except yaml.YAMLError:
                    pass
            if not _is_storytime_enabled(frontmatter):
                continue
            try:
                sort_order = int(frontmatter.get('sort_order', 0))
            except (ValueError, TypeError):
                sort_order = 0
            eff_date, eff_order = _storytime_effective_rank(post_date, sort_order, frontmatter)
            cand = (eff_date.strftime('%Y-%m-%d'), eff_order, filename)
            if best is None or cand > best:
                best = cand
    except Exception:
        return None
    return best
[[[REPLACE]]]

Target: remotes/honeybot/scripts/content_loader.py
[[[SEARCH]]]
        files = sorted(
            list(POSTS_DIR.glob("*.md")) + list(POSTS_DIR.glob("*.markdown")),
            key=lambda p: p.name,
            reverse=True,
        )
        cutoff_date = None
        
        for filepath in files:
[[[DIVIDER]]]
        files = sorted(
            list(POSTS_DIR.glob("*.md")) + list(POSTS_DIR.glob("*.markdown")),
            key=lambda p: p.name,
            reverse=True,
        )
        pinned = _get_pinned_storytime_file()
        if pinned is not None and not include_archive:
            files = [pinned] + [p for p in files if p != pinned]
        cutoff_date = None
        
        for filepath in files:
[[[REPLACE]]]

Target: remotes/honeybot/scripts/content_loader.py
[[[SEARCH]]]
            all_articles.append({
                'date': post_date,
                'sort_order': sort_order, # Added for secondary sort key
                'title': frontmatter.get('title', slug.replace('-', ' ')),
                'url': url,
                'image': image_path,
                'image_alt': image_alt,
                'content': clean_text
            })
            if not include_archive and len(all_articles) >= recent_n and cutoff_date is None:
                cutoff_date = post_date

        # Sort ALL by date first, then by sort_order (both Descending/Reverse)
        # Tuple comparison works element by element: (2026-01-01, 2) > (2026-01-01, 1)
        all_articles.sort(key=lambda x: (x['date'], x['sort_order']), reverse=True)
[[[DIVIDER]]]
            eff_date, eff_order = _storytime_effective_rank(post_date, sort_order, frontmatter)
            all_articles.append({
                'date': post_date,
                'sort_order': sort_order, # Added for secondary sort key
                'eff_date': eff_date,
                'eff_order': eff_order,
                'title': frontmatter.get('title', slug.replace('-', ' ')),
                'url': url,
                'image': image_path,
                'image_alt': image_alt,
                'content': clean_text
            })
            if not include_archive and len(all_articles) >= max(recent_n, 15) and cutoff_date is None:
                cutoff_date = post_date

        # Sort ALL by effective Storytime date/order first, then chronological date/sort_order
        all_articles.sort(
            key=lambda x: (x['eff_date'], x['eff_order'], x['date'], x['sort_order']),
            reverse=True,
        )
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
def create_jekyll_post(article_content, instructions, output_dir, preview_port, base_url="",
                       *, target_config=None):
[[[DIVIDER]]]
def create_jekyll_post(article_content, instructions, output_dir, preview_port, base_url="",
                       *, target_config=None, aside=False):
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
                            if front_matter and 'sort_order' in front_matter:
                                try:
                                    order = int(front_matter['sort_order'])
                                    if order > max_order:
                                        max_order = order
                                except (ValueError, TypeError):
                                    continue
                except Exception as e:
                    print(f"Warning checking sort_order in {post_file.name}: {e}")
            
            if max_order > 0:
[[[DIVIDER]]]
                            if front_matter:
                                for k_ord in ('sort_order', 'storytime_order'):
                                    if k_ord in front_matter:
                                        try:
                                            order = int(front_matter[k_ord])
                                            if order > max_order:
                                                max_order = order
                                        except (ValueError, TypeError):
                                            continue
                except Exception as e:
                    print(f"Warning checking sort_order in {post_file.name}: {e}")
            st_json = target_path.parent / "_data" / "storytime.json"
            if st_json.is_file():
                try:
                    st_data = json.loads(st_json.read_text(encoding='utf-8'))
                    if str(st_data.get('featured_date') or '') == current_date:
                        st_ord = int(st_data.get('featured_order') or 0)
                        if st_ord > max_order:
                            max_order = st_ord
                except Exception:
                    pass
            
            if max_order > 0:
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
    new_yaml_data = {
        'title': yaml_updates.get("title"),
        'permalink': permalink,
        'canonical_url': canonical_url,  # <--- INJECTED HERE
        'description': analysis_content.get("authors_imprint"),
        'meta_description': yaml_updates.get("description"),
        'excerpt': yaml_updates.get("description"),
        'meta_keywords': yaml_updates.get("keywords"),
        'layout': 'post',
        'sort_order': next_sort_order
    }
[[[DIVIDER]]]
    new_yaml_data = {
        'title': yaml_updates.get("title"),
        'permalink': permalink,
        'canonical_url': canonical_url,  # <--- INJECTED HERE
        'description': analysis_content.get("authors_imprint"),
        'meta_description': yaml_updates.get("description"),
        'excerpt': yaml_updates.get("description"),
        'meta_keywords': yaml_updates.get("keywords"),
        'layout': 'post',
        'sort_order': next_sort_order
    }
    if aside:
        new_yaml_data['storytime'] = False
        print("📌 Aside mode (--aside): stamped 'storytime: false' (queued for Storytime backfill; live broadcast will resume in place).")
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
    parser.add_argument(
        '--web', action='store_true',
        help="Skip the API: the editing prompt goes to the clipboard, you paste it into any AI "
             "chat in a browser, copy the reply, press Enter here, and the post is built from it."
    )
    args = parser.parse_args()
[[[DIVIDER]]]
    parser.add_argument(
        '--web', action='store_true',
        help="Skip the API: the editing prompt goes to the clipboard, you paste it into any AI "
             "chat in a browser, copy the reply, press Enter here, and the post is built from it."
    )
    parser.add_argument(
        '--aside', action='store_true',
        help="Publish as a public aside: stamps 'storytime: false' in YAML frontmatter so Honeybot "
             "Storytime resumes the current article after maintenance and queues this post for backfill."
    )
    args = parser.parse_args()
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
        saved_path = create_jekyll_post(
            article_text, instructions, output_dir, preview_port, base_url,
            target_config=target_config)
[[[DIVIDER]]]
        saved_path = create_jekyll_post(
            article_text, instructions, output_dir, preview_port, base_url,
            target_config=target_config, aside=args.aside)
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
    recorded = get_last_published(target_key)
    if recorded and Path(recorded).is_file():
        rec_path = Path(recorded)
        if _DATED_POST_RE.match(rec_path.name) and rec_path.name[:10] >= max_date:
            return rec_path, tcfg
[[[DIVIDER]]]
    recorded = get_last_published(target_key)
    if recorded and Path(recorded).is_file():
        rec_path = Path(recorded)
        if _DATED_POST_RE.match(rec_path.name):
            eff_rec_date = rec_path.name[:10]
            try:
                head = rec_path.read_text(encoding="utf-8")[:2048]
                m_feat = re.search(r"^storytime_featured:\s*['\"]?(\d{4}-\d{2}-\d{2})", head, re.MULTILINE)
                if m_feat and m_feat.group(1) > eff_rec_date:
                    eff_rec_date = m_feat.group(1)
            except Exception:
                pass
            if eff_rec_date >= max_date:
                return rec_path, tcfg
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
        print("PHASE 1: ARTICLEIZE & HERO BANNER TLC (Before `publish`)")
        print("  1. article          Sanitize clipboard + generate Jekyll post & prompts")
        print("  2. ythero           📋 Copy AI Hero Banner Prompt -> generate 16:9 image")
[[[DIVIDER]]]
        print("PHASE 1: ARTICLEIZE & HERO BANNER TLC (Before `publish`)")
        print("  1. article / aside  Generate Jekyll post (`aside` stamps storytime: false)")
        print("  2. ythero           📋 Copy AI Hero Banner Prompt -> generate 16:9 image")
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
        print(" 18. ytoutro            🔊 Hear deploy-standby outro locally (`ytoutro edit|sync|reboot`)")
        print("     ytbgm [VOL]        🎵 Tune Storytime BGM volume live (`ytbgm 0.35`, `off`, `on`, `status`)")
        print("     ytreboot           🔄 Sync Honeybot scripts + restart stream.py watchdog child")
        print(" 19. ytcard             📇 Reprint the full Broadcast Kit for the latest post")
[[[DIVIDER]]]
        print(" 18. ytoutro            🔊 Hear deploy-standby outro locally (`ytoutro edit|sync|reboot`)")
        print("     ytbgm [VOL]        🎵 Tune Storytime BGM volume live (`ytbgm 0.35`, `off`, `on`, `status`)")
        print("     ytreboot           🔄 Sync Honeybot scripts + restart stream.py watchdog child")
        print(" 19. ytfeature [slug]   📌 List `storytime: false` backfill queue, promote a post, or `--vod URL`")
        print(" 20. ytcard             📇 Reprint the full Broadcast Kit for the latest post")
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Pipulate article common utilities & broadcast kit.")
    add_standard_arguments(parser)
    parser.add_argument(
        "--broadcast",
        choices=("help", "card", "summary", "hero", "yaml", "tweet", "linkedin", "pebble", "title", "desc", "top", "outro", "bgm", "reboot", "status", "bell", "stop", "start", "roll", "enable-ws", "say", "ticker", "ping", "watch"),
        default="card",
        help="Print/copy broadcast kit or control Honeybot (help|card|summary|hero|yaml|tweet|linkedin|pebble|title|desc|top|outro|bgm|reboot|status|bell|stop|start|roll|enable-ws|say|ticker|ping|watch).",
    )
[[[DIVIDER]]]
def _ normalize_vod_url(raw_vod):
    """Normalize a YouTube URL, 11-char video ID, or 'live' keyword into a canonical watch URL."""
    s = (raw_vod or "").strip()
    if not s:
        return ""
    if s.lower() == "live":
        st = _load_ytwatch_state()
        vid = str(st.get("video_id") or "").strip()
        if not vid:
            vid = sync_live_video_id(push_remote=False)
        return f"https://www.youtube.com/watch?v={vid}" if vid else ""
    if re.match(r"^[A-Za-z0-9_-]{11}$", s):
        return f"https://www.youtube.com/watch?v={s}"
    m = re.search(r"(?:v=|youtu\.be/|/live/|/shorts/)([A-Za-z0-9_-]{11})", s)
    if m:
        return f"https://www.youtube.com/watch?v={m.group(1)}"
    return s

def manage_storytime_feature(
    target_key="1",
    slug_match=None,
    vod_url=None,
    set_aside=False,
    dry_run=False,
):
    """List Storytime backfill queue (`storytime: false`), promote a post to active Storytime, or stamp `vod_url`."""
    import subprocess
    import yaml
    targets = load_targets()
    tcfg = targets.get(str(target_key), targets.get("1", DEFAULT_TARGETS["1"]))
    posts_dir = Path(tcfg["path"]).expanduser()
    repo_root = posts_dir.parent
    if not posts_dir.is_dir():
        print(f"⚠️ Posts directory not found: {posts_dir}")
        return 1
    dated = sorted(
        [p for p in posts_dir.glob("*.md") if _DATED_POST_RE.match(p.name)],
        key=lambda p: p.name,
        reverse=True,
    )
    if not slug_match and not vod_url and not set_aside:
        backfill = []
        vod_posts = []
        best_active = None
        for p in dated[:120]:
            try:
                head = p.read_text(encoding="utf-8")[:4096]
            except OSError:
                continue
            fm = {}
            if head.startswith("---"):
                parts = head.split("---", 2)
                if len(parts) >= 3:
                    try:
                        fm = yaml.safe_load(parts[1]) or {}
                    except Exception:
                        fm = {}
            title = str(fm.get("title") or p.stem[11:])
            st_val = fm.get("storytime", True)
            is_aside = (fm.get("aside") is True) or (st_val is False) or (str(st_val).strip().lower() in ("false", "0", "no", "off", "aside"))
            date_s = p.name[:10]
            try:
                s_ord = int(fm.get("sort_order", 0))
            except (ValueError, TypeError):
                s_ord = 0
            eff_date_s = str(fm.get("storytime_featured") or date_s)[:10]
            try:
                eff_ord = int(fm.get("storytime_order", s_ord))
            except (ValueError, TypeError):
                eff_ord = s_ord
            if is_aside:
                backfill.append((date_s, s_ord, p.name, title))
            else:
                cand = (eff_date_s, eff_ord, p.name, title, date_s)
                if best_active is None or cand > best_active:
                    best_active = cand
            if fm.get("vod_url"):
                vod_posts.append((date_s, p.name, title, str(fm.get("vod_url"))))
        print("=" * 72)
        print("🎙️  HONEYBOT STORYTIME QUEUE & BACKFILL RADAR")
        print("-" * 72)
        if best_active:
            print(f"🔴 ACTIVE ON STORYTIME : {best_active[2]} (broadcast slot: {best_active[0]} #{best_active[1]})")
            print(f"   Title               : {best_active[3]}")
        else:
            print("🔴 ACTIVE ON STORYTIME : (none found)")
        print("-" * 72)
        print(f"⏳ COMING SOON / ASIDE BACKFILL QUEUE (`storytime: false` — {len(backfill)} post(s)):")
        if backfill:
            for idx, (d_s, s_o, fname, t_s) in enumerate(backfill[:20], 1):
                slug_s = fname[11:].removesuffix(".md")
                print(f"  {idx:2d}. [{d_s} #{s_o}] {t_s}")
                print(f"      ↳ Promote to Storytime: ytfeature {slug_s}")
        else:
            print("  (No `storytime: false` aside posts waiting in queue. Publish one with `aside` or `article --aside`!)")
        if vod_posts:
            print("-" * 72)
            print(f"🎬 ARCHIVED YOUTUBE VOD EPISODES ({len(vod_posts)} stamped):")
            for d_s, fname, t_s, v_u in vod_posts[:8]:
                print(f"  • [{d_s}] {t_s} -> {v_u}")
        print("=" * 72)
        return 0

    post_path, _ = _latest_post_for_target(target_key, slug_match=slug_match)
    if not post_path or not post_path.is_file():
        print(f"❌ No post matched slug: {slug_match!r}")
        return 1

    if vod_url:
        norm_vod = _normalize_vod_url(vod_url)
        if not norm_vod:
            print(f"❌ Could not resolve a valid YouTube VOD URL from: {vod_url!r}")
            return 1
        if dry_run:
            print(f"🎬 [DRY RUN] Would stamp vod_url: {norm_vod} into {post_path.name}")
            return 0
        status = stamp_frontmatter_value(post_path, "vod_url", norm_vod, preserve_mtime=True)
        if (repo_root / ".git").exists():
            subprocess.run(["git", "-C", str(repo_root), "add", "--", str(post_path)], check=False)
        print(f"🎬 [{status}] Stamped vod_url in {post_path.name} -> {norm_vod}")
        if not set_aside and not slug_match:
            return 0

    if set_aside:
        if dry_run:
            print(f"📌 [DRY RUN] Would stamp storytime: false (aside) on {post_path.name}")
            return 0
        st_res = stamp_frontmatter_value(post_path, "storytime", "false", preserve_mtime=True)
        st_json = repo_root / "_data" / "storytime.json"
        if st_json.is_file():
            try:
                cur_st = json.loads(st_json.read_text(encoding="utf-8"))
                if cur_st.get("filename") == post_path.name:
                    st_json.unlink()
            except Exception:
                pass
        if (repo_root / ".git").exists():
            subprocess.run(["git", "-C", str(repo_root), "add", "--", str(post_path)], check=False)
        print(f"📌 [{st_res}] Marked {post_path.name} as an Aside (`storytime: false` — queued for future Storytime).")
        return 0

    if slug_match:
        current_date = datetime.now().strftime("%Y-%m-%d")
        max_order = 0
        for p in posts_dir.glob("*.md"):
            if not _DATED_POST_RE.match(p.name):
                continue
            try:
                head = p.read_text(encoding="utf-8")[:4096]
            except OSError:
                continue
            if not head.startswith("---"):
                continue
            parts = head.split("---", 2)
            if len(parts) < 3:
                continue
            try:
                fm = yaml.safe_load(parts[1]) or {}
            except Exception:
                fm = {}
            if p.name[:10] == current_date:
                try:
                    max_order = max(max_order, int(fm.get("sort_order", 0)))
                except (ValueError, TypeError):
                    pass
            if str(fm.get("storytime_featured") or "")[:10] == current_date:
                try:
                    max_order = max(max_order, int(fm.get("storytime_order", 0)))
                except (ValueError, TypeError):
                    pass
        next_order = max_order + 1
        slug_clean = post_path.stem[11:]
        if dry_run:
            print(
                f"🎙️ [DRY RUN] Would promote {post_path.name} -> storytime: true | "
                f"storytime_featured: {current_date} | storytime_order: {next_order}"
            )
            return 0
        stamp_frontmatter_value(post_path, "storytime", "true", preserve_mtime=False)
        stamp_frontmatter_value(post_path, "storytime_featured", current_date, preserve_mtime=False)
        stamp_frontmatter_value(post_path, "storytime_order", str(next_order), preserve_mtime=False)
        data_dir = repo_root / "_data"
        data_dir.mkdir(parents=True, exist_ok=True)
        st_json = data_dir / "storytime.json"
        st_payload = {
            "filename": post_path.name,
            "slug": slug_clean,
            "featured_date": current_date,
            "featured_order": next_order,
            "promoted_at": datetime.now().isoformat(timespec="seconds"),
        }
        st_json.write_text(json.dumps(st_payload, indent=2) + "\n", encoding="utf-8")
        if (repo_root / ".git").exists():
            subprocess.run(
                ["git", "-C", str(repo_root), "add", "--", str(post_path), str(st_json)],
                check=False,
            )
        record_last_published(target_key, post_path, tcfg.get("name"))
        print(
            f"🚀 Promoted {post_path.name} to Active Storytime! "
            f"(storytime_featured: {current_date}, storytime_order: {next_order})"
        )
        print_broadcast_kit(target_key, mode="summary", slug_match=slug_clean)
        print(f"👉 Next step: run `preview && publish \"Feature {slug_clean} on Honeybot Storytime\"`")
    return 0

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Pipulate article common utilities & broadcast kit.")
    add_standard_arguments(parser)
    parser.add_argument(
        "--broadcast",
        choices=("help", "card", "summary", "hero", "yaml", "tweet", "linkedin", "pebble", "title", "desc", "top", "outro", "bgm", "reboot", "feature", "status", "bell", "stop", "start", "roll", "enable-ws", "say", "ticker", "ping", "watch"),
        default="card",
        help="Print/copy broadcast kit or control Honeybot (help|card|summary|hero|yaml|tweet|linkedin|pebble|title|desc|top|outro|bgm|reboot|feature|status|bell|stop|start|roll|enable-ws|say|ticker|ping|watch).",
    )
    parser.add_argument(
        "--vod",
        type=str,
        default=None,
        help="Stamp a YouTube VOD URL, 11-char video ID, or 'live' into a post's frontmatter via --broadcast feature.",
    )
    parser.add_argument(
        "--aside",
        action="store_true",
        help="Mark a post as `storytime: false` (aside backfill queue) via --broadcast feature.",
    )
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
    if cli_args.broadcast == "reboot":
        sys.exit(reboot_honeybot_stream(sync_only=False, dry_run=cli_args.dry_run))
[[[DIVIDER]]]
    if cli_args.broadcast == "reboot":
        sys.exit(reboot_honeybot_stream(sync_only=False, dry_run=cli_args.dry_run))
    if cli_args.broadcast == "feature":
        feat_slug = cli_args.slug
        feat_vod = cli_args.vod
        feat_aside = cli_args.aside
        tokens = list(cli_args.message or [])
        if tokens and tokens[0].lower() in ("list", "status", "queue"):
            tokens.pop(0)
        if tokens and not feat_slug:
            feat_slug = tokens.pop(0)
        if tokens and not feat_vod:
            feat_vod = tokens.pop(0)
        sys.exit(
            manage_storytime_feature(
                target_key=cli_args.target,
                slug_match=feat_slug,
                vod_url=feat_vod,
                set_aside=feat_aside,
                dry_run=cli_args.dry_run,
            )
        )
[[[REPLACE]]]

Target: flake.nix
[[[SEARCH]]]
          ytapp()    { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/ytstage.py" app "$@"; }
          ytvim()    { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/ytstage.py" vim "$@"; }
[[[DIVIDER]]]
          ytapp()     { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/ytstage.py" app "$@"; }
          ytvim()     { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/ytstage.py" vim "$@"; }
          ytfeature() { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/articles/common.py" --broadcast feature "$@"; }
[[[REPLACE]]]

Target: flake.nix
[[[SEARCH]]]
            alias article='write_post article'
            alias grim='write_post grim'
[[[DIVIDER]]]
            alias article='write_post article'
            alias aside='write_post article --aside'
            alias grim='write_post grim'
[[[REPLACE]]]

Target: flake.nix
[[[SEARCH]]]
            # number blogs.json gives it today, so a renumber in blogs.nix
            # touches nothing in this file.
            alias article='write_post article'
            alias grim='write_post grim'
[[[DIVIDER]]]
            # number blogs.json gives it today, so a renumber in blogs.nix
            # touches nothing in this file.
            alias article='write_post article'
            alias aside='write_post article --aside'
            alias grim='write_post grim'
[[[REPLACE]]]

Target: remotes/honeybot/hooks/post-receive
[[[SEARCH]]]
# 0. Force Checkout to the Web Root FIRST (~10ms on local SSD) so _posts/*.md
# is already updated on disk when stream.py inspects get_featured_article_id()
# on the .deploy_standby bell to decide Maintenance Resume vs. New Broadcast.
git --work-tree=$WORK_TREE --git-dir=$GIT_DIR checkout -q -f main
[[[DIVIDER]]]
# 0. Force Checkout to the Web Root FIRST (~10ms on local SSD) so _posts/*.md
# is already updated on disk when stream.py inspects get_featured_article_id()
# on the standby bell to decide Maintenance Resume vs. New Broadcast.
git --work-tree=$WORK_TREE --git-dir=$GIT_DIR checkout -q -f main
[[[REPLACE]]]

Target: remotes/honeybot/scripts/content_loader.py
[[[SEARCH]]]
def _is_storytime_enabled(frontmatter):
    """True unless frontmatter explicitly opts out via storytime: false or aside: true."""
    if not isinstance(frontmatter, dict):
        return True
    if frontmatter.get('aside') is True:
        return False
    val = frontmatter.get('storytime', True)
    if isinstance(val, bool):
        return val
    return str(val).strip().lower() not in ('false', '0', 'no', 'off', 'aside')

def get_featured_article_id():
    """Return (date_str, sort_order, filename) of the newest Storytime-eligible post on disk."""
    best = None
    try:
        files = sorted(
            list(POSTS_DIR.glob("*.md")) + list(POSTS_DIR.glob("*.markdown")),
            key=lambda p: p.name,
            reverse=True,
        )
        cutoff_date = None
        for filepath in files:
            filename = filepath.name
            try:
                date_str = filename[:10]
                post_date = datetime.strptime(date_str, '%Y-%m-%d').date()
            except ValueError:
                continue
            if cutoff_date is not None and post_date < cutoff_date:
                break
            try:
                head = filepath.read_text(encoding='utf-8')[:4096]
            except OSError:
                continue
            frontmatter = {}
            if head.startswith('---'):
                try:
                    parts = head.split('---', 2)
                    if len(parts) >= 3:
                        frontmatter = yaml.safe_load(parts[1]) or {}
                except yaml.YAMLError:
                    pass
            if not _is_storytime_enabled(frontmatter):
                continue
            try:
                sort_order = int(frontmatter.get('sort_order', 0))
            except (ValueError, TypeError):
                sort_order = 0
            cand = (date_str, sort_order, filename)
            if best is None or cand > best:
                best = cand
            cutoff_date = post_date
    except Exception:
        return None
    return best
[[[DIVIDER]]]
def _is_storytime_enabled(frontmatter):
    """True unless frontmatter explicitly opts out via storytime: false or aside: true."""
    if not isinstance(frontmatter, dict):
        return True
    if frontmatter.get('aside') is True:
        return False
    val = frontmatter.get('storytime', True)
    if isinstance(val, bool):
        return val
    return str(val).strip().lower() not in ('false', '0', 'no', 'off', 'aside')

def _storytime_effective_rank(post_date, sort_order, frontmatter):
    """Return (eff_date, eff_order) honoring storytime_featured and storytime_order overrides."""
    eff_date = post_date
    eff_order = sort_order
    if isinstance(frontmatter, dict):
        feat_raw = str(frontmatter.get('storytime_featured') or '').strip()[:10]
        if feat_raw:
            try:
                eff_date = datetime.strptime(feat_raw, '%Y-%m-%d').date()
            except ValueError:
                eff_date = post_date
        if frontmatter.get('storytime_order') is not None:
            try:
                eff_order = int(frontmatter['storytime_order'])
            except (ValueError, TypeError):
                eff_order = sort_order
    return eff_date, eff_order

def _get_pinned_storytime_file():
    """Return Path to the post named in _data/storytime.json if present on disk."""
    try:
        st_file = POSTS_DIR.parent / "_data" / "storytime.json"
        if st_file.is_file():
            import json
            data = json.loads(st_file.read_text(encoding='utf-8'))
            fname = str((data or {}).get('filename') or '').strip()
            if fname:
                cand = POSTS_DIR / fname
                if cand.is_file():
                    return cand
    except Exception:
        pass
    return None

def get_featured_article_id():
    """Return (eff_date_str, eff_order, filename) of the active Storytime-eligible post on disk."""
    best = None
    try:
        files = sorted(
            list(POSTS_DIR.glob("*.md")) + list(POSTS_DIR.glob("*.markdown")),
            key=lambda p: p.name,
            reverse=True,
        )
        pinned = _get_pinned_storytime_file()
        scan_list = list(files[:35])
        if pinned is not None and pinned not in scan_list:
            scan_list.append(pinned)
        for filepath in scan_list:
            filename = filepath.name
            try:
                date_str = filename[:10]
                post_date = datetime.strptime(date_str, '%Y-%m-%d').date()
            except ValueError:
                continue
            try:
                head = filepath.read_text(encoding='utf-8')[:4096]
            except OSError:
                continue
            frontmatter = {}
            if head.startswith('---'):
                try:
                    parts = head.split('---', 2)
                    if len(parts) >= 3:
                        frontmatter = yaml.safe_load(parts[1]) or {}
                except yaml.YAMLError:
                    pass
            if not _is_storytime_enabled(frontmatter):
                continue
            try:
                sort_order = int(frontmatter.get('sort_order', 0))
            except (ValueError, TypeError):
                sort_order = 0
            eff_date, eff_order = _storytime_effective_rank(post_date, sort_order, frontmatter)
            cand = (eff_date.strftime('%Y-%m-%d'), eff_order, filename)
            if best is None or cand > best:
                best = cand
    except Exception:
        return None
    return best
[[[REPLACE]]]

Target: remotes/honeybot/scripts/content_loader.py
[[[SEARCH]]]
        files = sorted(
            list(POSTS_DIR.glob("*.md")) + list(POSTS_DIR.glob("*.markdown")),
            key=lambda p: p.name,
            reverse=True,
        )
        cutoff_date = None
        
        for filepath in files:
[[[DIVIDER]]]
        files = sorted(
            list(POSTS_DIR.glob("*.md")) + list(POSTS_DIR.glob("*.markdown")),
            key=lambda p: p.name,
            reverse=True,
        )
        pinned = _get_pinned_storytime_file()
        if pinned is not None and not include_archive:
            files = [pinned] + [p for p in files if p != pinned]
        cutoff_date = None
        
        for filepath in files:
[[[REPLACE]]]

Target: remotes/honeybot/scripts/content_loader.py
[[[SEARCH]]]
            all_articles.append({
                'date': post_date,
                'sort_order': sort_order, # Added for secondary sort key
                'title': frontmatter.get('title', slug.replace('-', ' ')),
                'url': url,
                'image': image_path,
                'image_alt': image_alt,
                'content': clean_text
            })
            if not include_archive and len(all_articles) >= recent_n and cutoff_date is None:
                cutoff_date = post_date

        # Sort ALL by date first, then by sort_order (both Descending/Reverse)
        # Tuple comparison works element by element: (2026-01-01, 2) > (2026-01-01, 1)
        all_articles.sort(key=lambda x: (x['date'], x['sort_order']), reverse=True)
[[[DIVIDER]]]
            eff_date, eff_order = _storytime_effective_rank(post_date, sort_order, frontmatter)
            all_articles.append({
                'date': post_date,
                'sort_order': sort_order, # Added for secondary sort key
                'eff_date': eff_date,
                'eff_order': eff_order,
                'title': frontmatter.get('title', slug.replace('-', ' ')),
                'url': url,
                'image': image_path,
                'image_alt': image_alt,
                'content': clean_text
            })
            if not include_archive and len(all_articles) >= max(recent_n, 15) and cutoff_date is None:
                cutoff_date = post_date

        # Sort ALL by effective Storytime date/order first, then chronological date/sort_order
        all_articles.sort(
            key=lambda x: (x['eff_date'], x['eff_order'], x['date'], x['sort_order']),
            reverse=True,
        )
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
def create_jekyll_post(article_content, instructions, output_dir, preview_port, base_url="",
                       *, target_config=None):
[[[DIVIDER]]]
def create_jekyll_post(article_content, instructions, output_dir, preview_port, base_url="",
                       *, target_config=None, aside=False):
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
                            if front_matter and 'sort_order' in front_matter:
                                try:
                                    order = int(front_matter['sort_order'])
                                    if order > max_order:
                                        max_order = order
                                except (ValueError, TypeError):
                                    continue
                except Exception as e:
                    print(f"Warning checking sort_order in {post_file.name}: {e}")
            
            if max_order > 0:
[[[DIVIDER]]]
                            if front_matter:
                                for k_ord in ('sort_order', 'storytime_order'):
                                    if k_ord in front_matter:
                                        try:
                                            order = int(front_matter[k_ord])
                                            if order > max_order:
                                                max_order = order
                                        except (ValueError, TypeError):
                                            continue
                except Exception as e:
                    print(f"Warning checking sort_order in {post_file.name}: {e}")
            st_json = target_path.parent / "_data" / "storytime.json"
            if st_json.is_file():
                try:
                    st_data = json.loads(st_json.read_text(encoding='utf-8'))
                    if str(st_data.get('featured_date') or '') == current_date:
                        st_ord = int(st_data.get('featured_order') or 0)
                        if st_ord > max_order:
                            max_order = st_ord
                except Exception:
                    pass
            
            if max_order > 0:
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
    new_yaml_data = {
        'title': yaml_updates.get("title"),
        'permalink': permalink,
        'canonical_url': canonical_url,  # <--- INJECTED HERE
        'description': analysis_content.get("authors_imprint"),
        'meta_description': yaml_updates.get("description"),
        'excerpt': yaml_updates.get("description"),
        'meta_keywords': yaml_updates.get("keywords"),
        'layout': 'post',
        'sort_order': next_sort_order
    }
[[[DIVIDER]]]
    new_yaml_data = {
        'title': yaml_updates.get("title"),
        'permalink': permalink,
        'canonical_url': canonical_url,  # <--- INJECTED HERE
        'description': analysis_content.get("authors_imprint"),
        'meta_description': yaml_updates.get("description"),
        'excerpt': yaml_updates.get("description"),
        'meta_keywords': yaml_updates.get("keywords"),
        'layout': 'post',
        'sort_order': next_sort_order
    }
    if aside:
        new_yaml_data['storytime'] = False
        print("📌 Aside mode (--aside): stamped 'storytime: false' (queued for Storytime backfill; live broadcast will resume in place).")
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
    parser.add_argument(
        '--web', action='store_true',
        help="Skip the API: the editing prompt goes to the clipboard, you paste it into any AI "
             "chat in a browser, copy the reply, press Enter here, and the post is built from it."
    )
    args = parser.parse_args()
[[[DIVIDER]]]
    parser.add_argument(
        '--web', action='store_true',
        help="Skip the API: the editing prompt goes to the clipboard, you paste it into any AI "
             "chat in a browser, copy the reply, press Enter here, and the post is built from it."
    )
    parser.add_argument(
        '--aside', action='store_true',
        help="Publish as a public aside: stamps 'storytime: false' in YAML frontmatter so Honeybot "
             "Storytime resumes the current article after maintenance and queues this post for backfill."
    )
    args = parser.parse_args()
[[[REPLACE]]]

Target: scripts/articles/articleizer.py
[[[SEARCH]]]
        saved_path = create_jekyll_post(
            article_text, instructions, output_dir, preview_port, base_url,
            target_config=target_config)
[[[DIVIDER]]]
        saved_path = create_jekyll_post(
            article_text, instructions, output_dir, preview_port, base_url,
            target_config=target_config, aside=args.aside)
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
    recorded = get_last_published(target_key)
    if recorded and Path(recorded).is_file():
        rec_path = Path(recorded)
        if _DATED_POST_RE.match(rec_path.name) and rec_path.name[:10] >= max_date:
            return rec_path, tcfg
[[[DIVIDER]]]
    recorded = get_last_published(target_key)
    if recorded and Path(recorded).is_file():
        rec_path = Path(recorded)
        if _DATED_POST_RE.match(rec_path.name):
            eff_rec_date = rec_path.name[:10]
            try:
                head = rec_path.read_text(encoding="utf-8")[:2048]
                m_feat = re.search(r"^storytime_featured:\s*['\"]?(\d{4}-\d{2}-\d{2})", head, re.MULTILINE)
                if m_feat and m_feat.group(1) > eff_rec_date:
                    eff_rec_date = m_feat.group(1)
            except Exception:
                pass
            if eff_rec_date >= max_date:
                return rec_path, tcfg
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
        print("PHASE 1: ARTICLEIZE & HERO BANNER TLC (Before `publish`)")
        print("  1. article          Sanitize clipboard + generate Jekyll post & prompts")
        print("  2. ythero           📋 Copy AI Hero Banner Prompt -> generate 16:9 image")
[[[DIVIDER]]]
        print("PHASE 1: ARTICLEIZE & HERO BANNER TLC (Before `publish`)")
        print("  1. article / aside  Generate Jekyll post (`aside` stamps storytime: false)")
        print("  2. ythero           📋 Copy AI Hero Banner Prompt -> generate 16:9 image")
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
        print(" 18. ytoutro            🔊 Hear deploy-standby outro locally (`ytoutro edit|sync|reboot`)")
        print("     ytbgm [VOL]        🎵 Tune Storytime BGM volume live (`ytbgm 0.35`, `off`, `on`, `status`)")
        print("     ytreboot           🔄 Sync Honeybot scripts + restart stream.py watchdog child")
        print(" 19. ytcard             📇 Reprint the full Broadcast Kit for the latest post")
[[[DIVIDER]]]
        print(" 18. ytoutro            🔊 Hear deploy-standby outro locally (`ytoutro edit|sync|reboot`)")
        print("     ytbgm [VOL]        🎵 Tune Storytime BGM volume live (`ytbgm 0.35`, `off`, `on`, `status`)")
        print("     ytreboot           🔄 Sync Honeybot scripts + restart stream.py watchdog child")
        print(" 19. ytfeature [slug]   📌 List `storytime: false` backfill queue, promote a post, or `--vod URL`")
        print(" 20. ytcard             📇 Reprint the full Broadcast Kit for the latest post")
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Pipulate article common utilities & broadcast kit.")
    add_standard_arguments(parser)
    parser.add_argument(
        "--broadcast",
        choices=("help", "card", "summary", "hero", "yaml", "tweet", "linkedin", "pebble", "title", "desc", "top", "outro", "bgm", "reboot", "status", "bell", "stop", "start", "roll", "enable-ws", "say", "ticker", "ping", "watch"),
        default="card",
        help="Print/copy broadcast kit or control Honeybot (help|card|summary|hero|yaml|tweet|linkedin|pebble|title|desc|top|outro|bgm|reboot|status|bell|stop|start|roll|enable-ws|say|ticker|ping|watch).",
    )
[[[DIVIDER]]]
def _normalize_vod_url(raw_vod):
    """Normalize a YouTube URL, 11-char video ID, or 'live' keyword into a canonical watch URL."""
    s = (raw_vod or "").strip()
    if not s:
        return ""
    if s.lower() == "live":
        st = _load_ytwatch_state()
        vid = str(st.get("video_id") or "").strip()
        if not vid:
            vid = sync_live_video_id(push_remote=False)
        return f"https://www.youtube.com/watch?v={vid}" if vid else ""
    if re.match(r"^[A-Za-z0-9_-]{11}$", s):
        return f"https://www.youtube.com/watch?v={s}"
    m = re.search(r"(?:v=|youtu\.be/|/live/|/shorts/)([A-Za-z0-9_-]{11})", s)
    if m:
        return f"https://www.youtube.com/watch?v={m.group(1)}"
    return s

def manage_storytime_feature(
    target_key="1",
    slug_match=None,
    vod_url=None,
    set_aside=False,
    dry_run=False,
):
    """List Storytime backfill queue (`storytime: false`), promote a post to active Storytime, or stamp `vod_url`."""
    import subprocess
    import yaml
    targets = load_targets()
    tcfg = targets.get(str(target_key), targets.get("1", DEFAULT_TARGETS["1"]))
    posts_dir = Path(tcfg["path"]).expanduser()
    repo_root = posts_dir.parent
    if not posts_dir.is_dir():
        print(f"⚠️ Posts directory not found: {posts_dir}")
        return 1
    dated = sorted(
        [p for p in posts_dir.glob("*.md") if _DATED_POST_RE.match(p.name)],
        key=lambda p: p.name,
        reverse=True,
    )
    if not slug_match and not vod_url and not set_aside:
        backfill = []
        vod_posts = []
        best_active = None
        for p in dated[:120]:
            try:
                head = p.read_text(encoding="utf-8")[:4096]
            except OSError:
                continue
            fm = {}
            if head.startswith("---"):
                parts = head.split("---", 2)
                if len(parts) >= 3:
                    try:
                        fm = yaml.safe_load(parts[1]) or {}
                    except Exception:
                        fm = {}
            title = str(fm.get("title") or p.stem[11:])
            st_val = fm.get("storytime", True)
            is_aside = (fm.get("aside") is True) or (st_val is False) or (str(st_val).strip().lower() in ("false", "0", "no", "off", "aside"))
            date_s = p.name[:10]
            try:
                s_ord = int(fm.get("sort_order", 0))
            except (ValueError, TypeError):
                s_ord = 0
            eff_date_s = str(fm.get("storytime_featured") or date_s)[:10]
            try:
                eff_ord = int(fm.get("storytime_order", s_ord))
            except (ValueError, TypeError):
                eff_ord = s_ord
            if is_aside:
                backfill.append((date_s, s_ord, p.name, title))
            else:
                cand = (eff_date_s, eff_ord, p.name, title, date_s)
                if best_active is None or cand > best_active:
                    best_active = cand
            if fm.get("vod_url"):
                vod_posts.append((date_s, p.name, title, str(fm.get("vod_url"))))
        print("=" * 72)
        print("🎙️  HONEYBOT STORYTIME QUEUE & BACKFILL RADAR")
        print("-" * 72)
        if best_active:
            print(f"🔴 ACTIVE ON STORYTIME : {best_active[2]} (broadcast slot: {best_active[0]} #{best_active[1]})")
            print(f"   Title               : {best_active[3]}")
        else:
            print("🔴 ACTIVE ON STORYTIME : (none found)")
        print("-" * 72)
        print(f"⏳ COMING SOON / ASIDE BACKFILL QUEUE (`storytime: false` — {len(backfill)} post(s)):")
        if backfill:
            for idx, (d_s, s_o, fname, t_s) in enumerate(backfill[:20], 1):
                slug_s = fname[11:].removesuffix(".md")
                print(f"  {idx:2d}. [{d_s} #{s_o}] {t_s}")
                print(f"      ↳ Promote to Storytime: ytfeature {slug_s}")
        else:
            print("  (No `storytime: false` aside posts waiting in queue. Publish one with `aside` or `article --aside`!)")
        if vod_posts:
            print("-" * 72)
            print(f"🎬 ARCHIVED YOUTUBE VOD EPISODES ({len(vod_posts)} stamped):")
            for d_s, fname, t_s, v_u in vod_posts[:8]:
                print(f"  • [{d_s}] {t_s} -> {v_u}")
        print("=" * 72)
        return 0

    post_path, _ = _latest_post_for_target(target_key, slug_match=slug_match)
    if not post_path or not post_path.is_file():
        print(f"❌ No post matched slug: {slug_match!r}")
        return 1

    if vod_url:
        norm_vod = _normalize_vod_url(vod_url)
        if not norm_vod:
            print(f"❌ Could not resolve a valid YouTube VOD URL from: {vod_url!r}")
            return 1
        if dry_run:
            print(f"🎬 [DRY RUN] Would stamp vod_url: {norm_vod} into {post_path.name}")
            return 0
        status = stamp_frontmatter_value(post_path, "vod_url", norm_vod, preserve_mtime=True)
        if (repo_root / ".git").exists():
            subprocess.run(["git", "-C", str(repo_root), "add", "--", str(post_path)], check=False)
        print(f"🎬 [{status}] Stamped vod_url in {post_path.name} -> {norm_vod}")
        if not set_aside and not slug_match:
            return 0

    if set_aside:
        if dry_run:
            print(f"📌 [DRY RUN] Would stamp storytime: false (aside) on {post_path.name}")
            return 0
        st_res = stamp_frontmatter_value(post_path, "storytime", "false", preserve_mtime=True)
        st_json = repo_root / "_data" / "storytime.json"
        if st_json.is_file():
            try:
                cur_st = json.loads(st_json.read_text(encoding="utf-8"))
                if cur_st.get("filename") == post_path.name:
                    st_json.unlink()
            except Exception:
                pass
        if (repo_root / ".git").exists():
            subprocess.run(["git", "-C", str(repo_root), "add", "--", str(post_path)], check=False)
        print(f"📌 [{st_res}] Marked {post_path.name} as an Aside (`storytime: false` — queued for future Storytime).")
        return 0

    if slug_match:
        current_date = datetime.now().strftime("%Y-%m-%d")
        max_order = 0
        for p in posts_dir.glob("*.md"):
            if not _DATED_POST_RE.match(p.name):
                continue
            try:
                head = p.read_text(encoding="utf-8")[:4096]
            except OSError:
                continue
            if not head.startswith("---"):
                continue
            parts = head.split("---", 2)
            if len(parts) < 3:
                continue
            try:
                fm = yaml.safe_load(parts[1]) or {}
            except Exception:
                fm = {}
            if p.name[:10] == current_date:
                try:
                    max_order = max(max_order, int(fm.get("sort_order", 0)))
                except (ValueError, TypeError):
                    pass
            if str(fm.get("storytime_featured") or "")[:10] == current_date:
                try:
                    max_order = max(max_order, int(fm.get("storytime_order", 0)))
                except (ValueError, TypeError):
                    pass
        next_order = max_order + 1
        slug_clean = post_path.stem[11:]
        if dry_run:
            print(
                f"🎙️ [DRY RUN] Would promote {post_path.name} -> storytime: true | "
                f"storytime_featured: {current_date} | storytime_order: {next_order}"
            )
            return 0
        stamp_frontmatter_value(post_path, "storytime", "true", preserve_mtime=False)
        stamp_frontmatter_value(post_path, "storytime_featured", current_date, preserve_mtime=False)
        stamp_frontmatter_value(post_path, "storytime_order", str(next_order), preserve_mtime=False)
        data_dir = repo_root / "_data"
        data_dir.mkdir(parents=True, exist_ok=True)
        st_json = data_dir / "storytime.json"
        st_payload = {
            "filename": post_path.name,
            "slug": slug_clean,
            "featured_date": current_date,
            "featured_order": next_order,
            "promoted_at": datetime.now().isoformat(timespec="seconds"),
        }
        st_json.write_text(json.dumps(st_payload, indent=2) + "\n", encoding="utf-8")
        if (repo_root / ".git").exists():
            subprocess.run(
                ["git", "-C", str(repo_root), "add", "--", str(post_path), str(st_json)],
                check=False,
            )
        record_last_published(target_key, post_path, tcfg.get("name"))
        print(
            f"🚀 Promoted {post_path.name} to Active Storytime! "
            f"(storytime_featured: {current_date}, storytime_order: {next_order})"
        )
        print_broadcast_kit(target_key, mode="summary", slug_match=slug_clean)
        print(f"👉 Next step: run `preview && publish \"Feature {slug_clean} on Honeybot Storytime\"`")
    return 0

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Pipulate article common utilities & broadcast kit.")
    add_standard_arguments(parser)
    parser.add_argument(
        "--broadcast",
        choices=("help", "card", "summary", "hero", "yaml", "tweet", "linkedin", "pebble", "title", "desc", "top", "outro", "bgm", "reboot", "feature", "status", "bell", "stop", "start", "roll", "enable-ws", "say", "ticker", "ping", "watch"),
        default="card",
        help="Print/copy broadcast kit or control Honeybot (help|card|summary|hero|yaml|tweet|linkedin|pebble|title|desc|top|outro|bgm|reboot|feature|status|bell|stop|start|roll|enable-ws|say|ticker|ping|watch).",
    )
    parser.add_argument(
        "--vod",
        type=str,
        default=None,
        help="Stamp a YouTube VOD URL, 11-char video ID, or 'live' into a post's frontmatter via --broadcast feature.",
    )
    parser.add_argument(
        "--aside",
        action="store_true",
        help="Mark a post as `storytime: false` (aside backfill queue) via --broadcast feature.",
    )
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
    if cli_args.broadcast == "reboot":
        sys.exit(reboot_honeybot_stream(sync_only=False, dry_run=cli_args.dry_run))
[[[DIVIDER]]]
    if cli_args.broadcast == "reboot":
        sys.exit(reboot_honeybot_stream(sync_only=False, dry_run=cli_args.dry_run))
    if cli_args.broadcast == "feature":
        feat_slug = cli_args.slug
        feat_vod = cli_args.vod
        feat_aside = cli_args.aside
        tokens = list(cli_args.message or [])
        if tokens and tokens[0].lower() in ("list", "status", "queue"):
            tokens.pop(0)
        if tokens and not feat_slug:
            feat_slug = tokens.pop(0)
        if tokens and not feat_vod:
            feat_vod = tokens.pop(0)
        sys.exit(
            manage_storytime_feature(
                target_key=cli_args.target,
                slug_match=feat_slug,
                vod_url=feat_vod,
                set_aside=feat_aside,
                dry_run=cli_args.dry_run,
            )
        )
[[[REPLACE]]]

Target: flake.nix
[[[SEARCH]]]
          ytapp()    { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/ytstage.py" app "$@"; }
          ytvim()    { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/ytstage.py" vim "$@"; }
[[[DIVIDER]]]
          ytapp()     { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/ytstage.py" app "$@"; }
          ytvim()     { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/ytstage.py" vim "$@"; }
          ytfeature() { "$PIPULATE_ROOT/.venv/bin/python" "$PIPULATE_ROOT/scripts/articles/common.py" --broadcast feature "$@"; }
[[[REPLACE]]]

Target: flake.nix
[[[SEARCH]]]
            alias article='write_post article'
            alias grim='write_post grim'
[[[DIVIDER]]]
            alias article='write_post article'
            alias aside='write_post article --aside'
            alias grim='write_post grim'
[[[REPLACE]]]

Target: flake.nix
[[[SEARCH]]]
            # number blogs.json gives it today, so a renumber in blogs.nix
            # touches nothing in this file.
            alias article='write_post article'
            alias grim='write_post grim'
[[[DIVIDER]]]
            # number blogs.json gives it today, so a renumber in blogs.nix
            # touches nothing in this file.
            alias article='write_post article'
            alias aside='write_post article --aside'
            alias grim='write_post grim'
[[[REPLACE]]]

Verify the Car 2 AFTER receipt confirming `checkout_before_standby: True`, `_storytime_effective_rank: True`, `aside_flag: True`, and `ytfeature_cmd: True`.

Now let's execute Car 3 (Visual Pinning on Homepage Thumbnail Grid & Post Header + Graceful Reboot):
1. Update `scripts/articles/generate_hubs.py` and `~/repos/trimnoir/assets/main.css` + `~/repos/trimnoir/_layouts/post.html` so:
   - Any post with `storytime: false` displays a prominent `"⏳ Coming Soon on YouTube Live Storytime"` badge on its homepage thumbnail card in `index.md` (and in its `#live-observatory` banner in `_layouts/post.html`) so I keep re-encountering my backfill queue visually.
   - Any post with `vod_url` in frontmatter displays a `"🎬 Watch YouTube VOD"` badge/button on its thumbnail card and in `_layouts/post.html`.
2. Make `ytreboot` / `publish --reboot` trigger `announce_scheduled_reboot()` gracefully before restarting `stream.py`.

# # Context 1
# flake.nix
# 
# # HOME-HOSTED (NOT BEHIND CDN) NGINX WEBSERVER HONEYBOT AI OBSERVATORY
# nixops.sh
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/nixos/configuration.nix
# remotes/honeybot/scripts/stream.py
# remotes/honeybot/scripts/score.py
# remotes/honeybot/scripts/card.py
# remotes/honeybot/scripts/forest.py
# remotes/honeybot/scripts/test_forest.py
# remotes/honeybot/scripts/logs.py
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/db.py
# 
# # THE JEKYLL BLOG LIKE A HACKER (INVENTED SKILL.md & AGENTS.md FORMAT) PUBLISHING PIPELINE
# ~/repos/nixos/blogs.nix
# ~/.config/pipulate/blogs.json
# scripts/articles/publishizer.py
# scripts/articles/common.py
# scripts/articles/articleizer.py
# scripts/articles/link_injector.py
# scripts/articles/build_knowledge_graph.py
# scripts/articles/editing_prompt.txt
# scripts/articles/sanitizer.py
# scripts/articles/contextualizer.py
# scripts/articles/generate_hubs.py
# scripts/articles/generate_llms_txt.py
# scripts/articles/generate_post_nav.py
# assets/jekyll/common-packages.nix

# # Context 2
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/stream.py
# scripts/articles/articleizer.py
# scripts/articles/common.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('.deploy_standby'), '| featured_id_helper:', 'def get_featured_article_id' in cl, '| maintenance_line:', 'STANDBY_MAINTENANCE_LINE' in st)"
# # TRIMNOIR
# ~/repos/trimnoir/_config.yml
# ~/repos/trimnoir/flake.nix
# ~/repos/trimnoir/Gemfile
# ~/repos/trimnoir/index.md
# ~/repos/trimnoir/_layouts/default.html
# ~/repos/trimnoir/_layouts/page.html
# ~/repos/trimnoir/_layouts/post.html
# ~/repos/trimnoir/assets/main.css

# Context 3
remotes/honeybot/hooks/post-receive
remotes/honeybot/scripts/content_loader.py
remotes/honeybot/scripts/stream.py
scripts/articles/articleizer.py
scripts/articles/common.py
scripts/articles/generate_hubs.py
flake.nix
! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); ar=pathlib.Path('scripts/articles/articleizer.py').read_text(); cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('date +%s > \$WORK_TREE/.deploy_standby'), '| storytime_rank:', '_storytime_effective_rank' in cl, '| aside_flag:', '--aside' in ar, '| ytfeature_cmd:', 'def manage_storytime_feature' in cm and 'ytfeature()' in fl)"
~/repos/trimnoir/index.md
~/repos/trimnoir/_layouts/default.html
~/repos/trimnoir/_layouts/post.html
~/repos/trimnoir/assets/main.css

remotes/honeybot/hooks/post-receive
remotes/honeybot/scripts/content_loader.py
remotes/honeybot/scripts/stream.py
scripts/articles/articleizer.py
scripts/articles/common.py
scripts/articles/generate_hubs.py
flake.nix
! .venv/bin/python -c "import pathlib; gh=pathlib.Path('scripts/articles/generate_hubs.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); cm=pathlib.Path('scripts/articles/common.py').read_text(); ph=pathlib.Path('~/repos/trimnoir/_layouts/post.html').expanduser().read_text(); css=pathlib.Path('~/repos/trimnoir/assets/main.css').expanduser().read_text(); print('hub_badges:', 'badge-coming-soon' in gh and 'badge-vod' in gh, '| post_layout_badges:', 'badge-coming-soon' in ph and 'page.vod_url' in ph, '| css_badges:', '.badge-coming-soon' in css, '| graceful_reboot:', '_graceful_reboot_requested' in st and 'seq 1 25' in cm)"
~/repos/trimnoir/index.md
~/repos/trimnoir/_layouts/default.html
~/repos/trimnoir/_layouts/post.html
~/repos/trimnoir/assets/main.css

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
# --- Process Singleton ---
STREAM_LOCK_PATH = "/tmp/honeybot-stream.py.lock"
_stream_lock_handle = None
_shutting_down = threading.Event()
[[[DIVIDER]]]
# --- Process Singleton ---
STREAM_LOCK_PATH = "/tmp/honeybot-stream.py.lock"
_stream_lock_handle = None
_shutting_down = threading.Event()
_graceful_reboot_requested = False
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
def register_signal_handlers():
    """Convert incoming SIGTERM signals into a KeyboardInterrupt to execute try-finally blocks."""
    def _handler(signum, frame):
        raise KeyboardInterrupt
    signal.signal(signal.SIGTERM, _handler)
[[[DIVIDER]]]
def register_signal_handlers():
    """Convert incoming SIGTERM/SIGUSR1 into a graceful reboot KeyboardInterrupt."""
    def _handler(signum, frame):
        global _graceful_reboot_requested
        _graceful_reboot_requested = True
        raise KeyboardInterrupt
    signal.signal(signal.SIGTERM, _handler)
    signal.signal(signal.SIGUSR1, _handler)
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
    def _speak_now(self, text):
        """Internal method to actually generate and play audio."""
        if self.stop_event.is_set() or _shutting_down.is_set():
            return
        model_path = MODEL_DIR / MODEL_NAME
        if not model_path.exists():
            return
        with self._play_lock:
            if self.stop_event.is_set() or _shutting_down.is_set():
                return
[[[DIVIDER]]]
    def _speak_now(self, text):
        """Internal method to actually generate and play audio."""
        if self.stop_event.is_set():
            return
        model_path = MODEL_DIR / MODEL_NAME
        if not model_path.exists():
            return
        with self._play_lock:
            if self.stop_event.is_set():
                return
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
    def _play_raw_now(self, raw_path):
        """Play a pre-synthesized .raw file immediately via aplay and unlink when done."""
        if not raw_path or not os.path.exists(raw_path):
            return
        if self.stop_event.is_set() or _shutting_down.is_set():
            try:
                os.remove(raw_path)
            except OSError:
                pass
            return
[[[DIVIDER]]]
    def _play_raw_now(self, raw_path):
        """Play a pre-synthesized .raw file immediately via aplay and unlink when done."""
        if not raw_path or not os.path.exists(raw_path):
            return
        if self.stop_event.is_set():
            try:
                os.remove(raw_path)
            except OSError:
                pass
            return
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
def announce_scheduled_reboot():
    """Announce the 4-hour memory-purging restart with a Figlet card and blocking TTS before exiting."""
    global _reboot_announced
    if _reboot_announced or _shutting_down.is_set():
        return
    _reboot_announced = True
    _shutting_down.set()
    narrator.exclusive_mode.set()
    try:
        narrator.interrupt()
[[[DIVIDER]]]
def announce_scheduled_reboot():
    """Announce the 4-hour memory-purging restart with a Figlet card and blocking TTS before exiting."""
    global _reboot_announced
    if _reboot_announced:
        return
    _reboot_announced = True
    _shutting_down.set()
    narrator.exclusive_mode.set()
    try:
        stop_storytime_bgm()
        narrator.interrupt()
[[[REPLACE]]]

Target: remotes/honeybot/scripts/stream.py
[[[SEARCH]]]
    interrupted = False
    try:
        run_tui_app("logs.py", duration=SHOW_DURATION_MINUTES)
    except KeyboardInterrupt:
        interrupted = True
        _shutting_down.set()
    finally:
        if not interrupted:
            announce_scheduled_reboot()
        _shutting_down.set()
        narrator.stop()
        _reap_orphaned_tts_and_overlays()
[[[DIVIDER]]]
    interrupted = False
    try:
        run_tui_app("logs.py", duration=SHOW_DURATION_MINUTES)
    except KeyboardInterrupt:
        interrupted = True
        if not _graceful_reboot_requested:
            _shutting_down.set()
    finally:
        if (not interrupted) or _graceful_reboot_requested:
            announce_scheduled_reboot()
        _shutting_down.set()
        narrator.stop()
        _reap_orphaned_tts_and_overlays()
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
        print(" 18. ytoutro            🔊 Hear deploy-standby outro locally (`ytoutro edit|sync|reboot`)")
        print("     ytbgm [VOL]        🎵 Tune Storytime BGM volume live (`ytbgm 0.35`, `off`, `on`, `status`)")
        print("     ytreboot           🔄 Sync Honeybot scripts + restart stream.py watchdog child")
        print(" 19. ytcard             📇 Reprint the full Broadcast Kit for the latest post")
[[[DIVIDER]]]
        print(" 18. ytoutro            🔊 Hear deploy-standby outro locally (`ytoutro edit|sync|reboot`)")
        print("     ytbgm [VOL]        🎵 Tune Storytime BGM volume live (`ytbgm 0.35`, `off`, `on`, `status`)")
        print("     ytreboot           🔄 Sync Honeybot scripts + restart stream.py watchdog child")
        print(" 19. ytfeature [slug]   📌 List `storytime: false` backfill queue, promote a post, or `--vod URL`")
        print(" 20. ytcard             📇 Reprint the full Broadcast Kit for the latest post")
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
    print("🎛️  Quick Words:  yt (help) | ythero | ytyaml | tweet | linkedin | ytpebble | yttitle | ytdesc | ytcard | yttop | ytoutro | ytreboot | ytsay | ytticker | ytwatch | ytping | ytroll | ytbell | ytstatus")
[[[DIVIDER]]]
    print("🎛️  Quick Words:  yt (help) | ythero | ytyaml | tweet | linkedin | ytpebble | yttitle | ytdesc | ytfeature | ytcard | yttop | ytoutro | ytreboot | ytsay | ytticker | ytwatch | ytping | ytroll | ytbell | ytstatus")
[[[REPLACE]]]

Target: scripts/articles/common.py
[[[SEARCH]]]
    print(f"🔄 Restarting Honeybot stream.py child on {HONEYBOT_SSH_HOST}...")
    remote_sh = r"""
pattern="/home/mike/www/mikelev[.]in/scripts/stream[.]py"
old_pids=$(pgrep -f -- "$pattern" || true)
for old in $old_pids; do
    echo "   stopping old stream.py pid=$old"
    kill -TERM "$old" 2>/dev/null || true
done
sleep 1
for old in $old_pids; do
    if kill -0 "$old" 2>/dev/null; then
        echo "   force-killing stubborn stream.py pid=$old"
        kill -KILL "$old" 2>/dev/null || true
    fi
done
[[[DIVIDER]]]
    print(f"🔄 Signaling Honeybot stream.py on {HONEYBOT_SSH_HOST} for graceful SCHEDULED REBOOT announcement...")
    remote_sh = r"""
pattern="/home/mike/www/mikelev[.]in/scripts/stream[.]py"
old_pids=$(pgrep -f -- "$pattern" || true)
for old in $old_pids; do
    echo "   signaling stream.py pid=$old for graceful reboot announcement..."
    kill -TERM "$old" 2>/dev/null || true
done
for wait_s in $(seq 1 25); do
    still_alive=0
    for old in $old_pids; do
        if kill -0 "$old" 2>/dev/null; then
            still_alive=1
            break
        fi
    done
    if [ "$still_alive" -eq 0 ]; then
        break
    fi
    sleep 1
done
for old in $old_pids; do
    if kill -0 "$old" 2>/dev/null; then
        echo "   force-killing stubborn stream.py pid=$old"
        kill -KILL "$old" 2>/dev/null || true
    fi
done
[[[REPLACE]]]

Target: flake.nix
[[[SEARCH]]]
            # the template above grows one.
            alias article='write_post article'
            alias grim='write_post grim'
[[[DIVIDER]]]
            # the template above grows one.
            alias article='write_post article'
            alias aside='write_post article --aside'
            alias grim='write_post grim'
[[[REPLACE]]]

Target: scripts/articles/generate_hubs.py
[[[SEARCH]]]
    default_thumb = str(site_cfg.get("default_post_thumb") or "").strip()
    dated.sort(key=common._post_sort_key)
    recent = dated[-count:][::-1]
    cards = ['<div class="recent-posts-grid">']
    stage_rel_paths = ["index.md"]
    for post_path in recent:
        raw = post_path.read_text(encoding="utf-8", errors="ignore")
        fm = {}
        if raw.startswith("---"):
            parts = raw.split("---", 2)
            if len(parts) >= 3:
                try:
                    fm = yaml.safe_load(parts[1]) or {}
                except Exception:
                    fm = {}
        title = str(fm.get("title") or post_path.stem).strip()
        date_str = post_path.name[:10]
        slug = post_path.stem[11:]
        permalink = str(fm.get("permalink") or f"/futureproof/{slug}/").strip()
        summary = str(fm.get("meta_description") or fm.get("excerpt") or fm.get("description") or "").strip()
        if len(summary) > 160:
            summary = summary[:157].rsplit(" ", 1)[0] + "..."
        img_field = fm.get("image")
        if isinstance(img_field, dict):
            raw_img = str(img_field.get("path") or "").strip()
            raw_alt = str(img_field.get("alt") or title)
        elif isinstance(img_field, str):
            raw_img = img_field.strip()
            raw_alt = title
        else:
            raw_img = default_thumb
            raw_alt = title
        thumb_url = _ensure_post_thumbnail(target_repo_root, raw_img, fallback_rel=default_thumb) if raw_img else ""
        for rel_candidate in (raw_img, thumb_url):
            clean_rel = (rel_candidate or "").strip().lstrip("/")
            if clean_rel and (target_repo_root / clean_rel).is_file():
                stage_rel_paths.append(clean_rel)
        esc_title = html.escape(title, quote=True)
        esc_alt = html.escape(raw_alt, quote=True)
        esc_summary = html.escape(summary, quote=True)
        img_html = (
            f'    <img class="recent-post-thumb" src="{thumb_url}" alt="{esc_alt}" width="{THUMB_WIDTH}" height="{THUMB_HEIGHT}" loading="lazy">\n'
            if thumb_url else ""
        )
        cards.append(
            f'  <a class="recent-post-card" href="{permalink}">\n'
            f'{img_html}'
            f'    <div class="recent-post-body">\n'
            f'      <span class="recent-post-date">{date_str}</span>\n'
            f'      <strong class="recent-post-title">{esc_title}</strong>\n'
            f'      <span class="recent-post-desc">{esc_summary}</span>\n'
            f'    </div>\n'
            f'  </a>'
        )
[[[DIVIDER]]]
    default_thumb = str(site_cfg.get("default_post_thumb") or "").strip()
    dated.sort(key=common._post_sort_key)
    recent = list(dated[-count:][::-1])
    seen_recent = {p.name for p in recent}
    for cand_p in dated[-60:][::-1]:
        if cand_p.name in seen_recent:
            continue
        try:
            c_head = cand_p.read_text(encoding="utf-8", errors="ignore")[:4096]
        except OSError:
            continue
        if c_head.startswith("---"):
            c_parts = c_head.split("---", 2)
            if len(c_parts) >= 3:
                try:
                    c_fm = yaml.safe_load(c_parts[1]) or {}
                except Exception:
                    c_fm = {}
                c_st = c_fm.get("storytime", True)
                if (c_fm.get("aside") is True) or (c_st is False) or (str(c_st).strip().lower() in ("false", "0", "no", "off", "aside")):
                    recent.append(cand_p)
                    seen_recent.add(cand_p.name)
    cards = ['<div class="recent-posts-grid">']
    stage_rel_paths = ["index.md"]
    for post_path in recent:
        raw = post_path.read_text(encoding="utf-8", errors="ignore")
        fm = {}
        if raw.startswith("---"):
            parts = raw.split("---", 2)
            if len(parts) >= 3:
                try:
                    fm = yaml.safe_load(parts[1]) or {}
                except Exception:
                    fm = {}
        title = str(fm.get("title") or post_path.stem).strip()
        date_str = post_path.name[:10]
        slug = post_path.stem[11:]
        permalink = str(fm.get("permalink") or f"/futureproof/{slug}/").strip()
        summary = str(fm.get("meta_description") or fm.get("excerpt") or fm.get("description") or "").strip()
        if len(summary) > 160:
            summary = summary[:157].rsplit(" ", 1)[0] + "..."
        st_val = fm.get("storytime", True)
        is_aside = (
            (fm.get("aside") is True)
            or (st_val is False)
            or (str(st_val).strip().lower() in ("false", "0", "no", "off", "aside"))
        )
        vod_url = str(fm.get("vod_url") or "").strip()
        card_cls = "recent-post-card"
        badge_html = ""
        if is_aside:
            card_cls = "recent-post-card is-coming-soon"
            badge_html = '<span class="recent-post-badge badge-coming-soon">⏳ Coming Soon on YouTube Live Storytime</span>'
        elif vod_url:
            card_cls = "recent-post-card has-vod"
            badge_html = '<span class="recent-post-badge badge-vod">🎬 Watch YouTube VOD</span>'
        img_field = fm.get("image")
        if isinstance(img_field, dict):
            raw_img = str(img_field.get("path") or "").strip()
            raw_alt = str(img_field.get("alt") or title)
        elif isinstance(img_field, str):
            raw_img = img_field.strip()
            raw_alt = title
        else:
            raw_img = default_thumb
            raw_alt = title
        thumb_url = _ensure_post_thumbnail(target_repo_root, raw_img, fallback_rel=default_thumb) if raw_img else ""
        for rel_candidate in (raw_img, thumb_url):
            clean_rel = (rel_candidate or "").strip().lstrip("/")
            if clean_rel and (target_repo_root / clean_rel).is_file():
                stage_rel_paths.append(clean_rel)
        esc_title = html.escape(title, quote=True)
        esc_alt = html.escape(raw_alt, quote=True)
        esc_summary = html.escape(summary, quote=True)
        img_html = (
            f'    <img class="recent-post-thumb" src="{thumb_url}" alt="{esc_alt}" width="{THUMB_WIDTH}" height="{THUMB_HEIGHT}" loading="lazy">\n'
            if thumb_url else ""
        )
        meta_html = (
            f'      <div class="recent-post-meta">\n'
            f'        <span class="recent-post-date">{date_str}</span>\n'
            f'        {badge_html}\n'
            f'      </div>\n'
            if badge_html
            else f'      <span class="recent-post-date">{date_str}</span>\n'
        )
        cards.append(
            f'  <a class="{card_cls}" href="{permalink}">\n'
            f'{img_html}'
            f'    <div class="recent-post-body">\n'
            f'{meta_html}'
            f'      <strong class="recent-post-title">{esc_title}</strong>\n'
            f'      <span class="recent-post-desc">{esc_summary}</span>\n'
            f'    </div>\n'
            f'  </a>'
        )
[[[REPLACE]]]

Target: /home/mike/repos/trimnoir/_layouts/post.html
[[[SEARCH]]]
  <div style="text-align: center; margin-top: 2rem; font-size: 0.85em; opacity: 0.8;">
    <a href="{{ page.url | relative_url }}index.md?src=a+href" rel="alternate" type="text/markdown">🤖 Read Raw Markdown</a>
    {%- if page.gdoc_url %}
    • <a href="{{ page.gdoc_url }}" rel="alternate" type="application/vnd.google-apps.document">📄 Google Doc (Try: Tools/Audio/Listen to document summary)</a>
    {%- endif %}
    {%- if page.pinned %}
    • <a href="{{ "/" | relative_url }}#workbench">📌 On the workbench</a>
    {%- endif %}
  </div>
  {{ post_nav }}
  <div id="live-observatory" class="post-yt-live-embed">
    <div class="post-yt-live-header">
      <div class="post-yt-live-copy">
        <div class="post-yt-live-title">
          <span class="post-yt-live-badge">🔴 LIVE 24/7</span>
          <span>Honeybot Storytime &amp; Web Bot AI Observatory</span>
        </div>
        <div class="post-yt-live-sub">
          Rather listen than read? Tune in at <a class="post-yt-url-inline" href="https://www.youtube.com/MikeLevin/live" target="_blank" rel="noopener">youtube.com/MikeLevin/live</a> and listen from one Article Intro to the next Article Intro just 1 time while watching live AI crawlers hit this server in real time.
        </div>
      </div>
      <a id="yt-live-watch-link" class="post-yt-cta-btn" href="https://www.youtube.com/MikeLevin/live" target="_blank" rel="noopener">▶ Watch / Listen Live ↗</a>
    </div>
  </div>
[[[DIVIDER]]]
  <div style="text-align: center; margin-top: 2rem; font-size: 0.85em; opacity: 0.8;">
    <a href="{{ page.url | relative_url }}index.md?src=a+href" rel="alternate" type="text/markdown">🤖 Read Raw Markdown</a>
    {%- if page.gdoc_url %}
    • <a href="{{ page.gdoc_url }}" rel="alternate" type="application/vnd.google-apps.document">📄 Google Doc (Try: Tools/Audio/Listen to document summary)</a>
    {%- endif %}
    {%- if page.vod_url %}
    • <a href="{{ page.vod_url }}" target="_blank" rel="noopener">🎬 Watch YouTube VOD</a>
    {%- elsif page.storytime == false or page.aside == true %}
    • <span>⏳ Coming Soon on YouTube Live Storytime</span>
    {%- endif %}
    {%- if page.pinned %}
    • <a href="{{ "/" | relative_url }}#workbench">📌 On the workbench</a>
    {%- endif %}
  </div>
  {{ post_nav }}
  <div id="live-observatory" class="post-yt-live-embed">
    <div class="post-yt-live-header">
      <div class="post-yt-live-copy">
        <div class="post-yt-live-title">
          {%- if page.storytime == false or page.aside == true %}
          <span class="post-yt-live-badge badge-coming-soon">⏳ COMING SOON ON STORYTIME</span>
          {%- elsif page.vod_url %}
          <span class="post-yt-live-badge badge-vod">🎬 ARCHIVED YOUTUBE VOD</span>
          {%- else %}
          <span class="post-yt-live-badge">🔴 LIVE 24/7</span>
          {%- endif %}
          <span>Honeybot Storytime &amp; Web Bot AI Observatory</span>
        </div>
        <div class="post-yt-live-sub">
          {%- if page.storytime == false or page.aside == true %}
          ⏳ <strong>Coming Soon on YouTube Live Storytime:</strong> This article was published as a chronological aside and is queued for its upcoming full Piper TTS broadcast at <a class="post-yt-url-inline" href="https://www.youtube.com/MikeLevin/live" target="_blank" rel="noopener">youtube.com/MikeLevin/live</a>.
          {%- elsif page.vod_url %}
          🎬 <strong>Archived Broadcast Available:</strong> Watch the recorded Honeybot Storytime episode for this article on YouTube, or tune into the 24/7 live stream at <a class="post-yt-url-inline" href="https://www.youtube.com/MikeLevin/live" target="_blank" rel="noopener">youtube.com/MikeLevin/live</a>.
          {%- else %}
          Rather listen than read? Tune in at <a class="post-yt-url-inline" href="https://www.youtube.com/MikeLevin/live" target="_blank" rel="noopener">youtube.com/MikeLevin/live</a> and listen from one Article Intro to the next Article Intro just 1 time while watching live AI crawlers hit this server in real time.
          {%- endif %}
        </div>
      </div>
      <div class="post-yt-cta-group">
        {%- if page.vod_url %}
        <a class="post-yt-cta-btn post-yt-vod-btn" href="{{ page.vod_url }}" target="_blank" rel="noopener">🎬 Watch YouTube VOD ↗</a>
        {%- endif %}
        <a id="yt-live-watch-link" class="post-yt-cta-btn" href="https://www.youtube.com/MikeLevin/live" target="_blank" rel="noopener">▶ Watch / Listen Live ↗</a>
      </div>
    </div>
  </div>
[[[REPLACE]]]

Target: /home/mike/repos/trimnoir/assets/main.css
[[[SEARCH]]]
.recent-post-date {
    font-size: 0.78rem;
    font-family: monospace;
    opacity: 0.7;
}
[[[DIVIDER]]]
.recent-post-card.is-coming-soon {
    border-color: rgba(245, 158, 11, 0.65);
    box-shadow: 0 0 0 1px rgba(245, 158, 11, 0.22);
}
.recent-post-card.has-vod {
    border-color: rgba(56, 189, 248, 0.55);
}
.recent-post-meta {
    display: flex;
    flex-wrap: wrap;
    align-items: center;
    justify-content: space-between;
    gap: 6px;
}
.recent-post-date {
    font-size: 0.78rem;
    font-family: monospace;
    opacity: 0.7;
}
.recent-post-badge {
    display: inline-flex;
    align-items: center;
    gap: 4px;
    font-size: 0.7rem;
    font-weight: 700;
    padding: 2px 8px;
    border-radius: 999px;
    line-height: 1.3;
}
.recent-post-badge.badge-coming-soon {
    background: rgba(245, 158, 11, 0.16);
    border: 1px solid rgba(217, 119, 6, 0.55);
    color: #b45309;
}
[data-theme="dark"] .recent-post-badge.badge-coming-soon,
.post-yt-live-badge.badge-coming-soon {
    background: rgba(245, 158, 11, 0.2);
    border: 1px solid rgba(245, 158, 11, 0.55);
    color: #fbbf24;
    box-shadow: none;
}
.recent-post-badge.badge-vod {
    background: rgba(2, 132, 199, 0.12);
    border: 1px solid rgba(2, 132, 199, 0.45);
    color: #0369a1;
}
[data-theme="dark"] .recent-post-badge.badge-vod,
.post-yt-live-badge.badge-vod {
    background: rgba(56, 189, 248, 0.18);
    border: 1px solid rgba(56, 189, 248, 0.5);
    color: #38bdf8;
    box-shadow: none;
}
.post-yt-cta-group {
    display: flex;
    flex-wrap: wrap;
    align-items: center;
    gap: 0.55rem;
}
.post-yt-cta-btn.post-yt-vod-btn {
    background: #0284c7;
    border-color: #38bdf8;
    box-shadow: 0 2px 10px rgba(2, 132, 199, 0.35);
}
.post-yt-cta-btn.post-yt-vod-btn:hover {
    background: #0369a1;
}
[[[REPLACE]]]

Verify the Car 3 AFTER receipt confirming `hub_badges: True`, `post_layout_badges: True`, `css_badges: True`, and `graceful_reboot: True`. Summarize the complete `aside` + `ytfeature` workflow so we can hop off the ride and publish this article with `aside`.

# # Context 1
# flake.nix
# 
# # HOME-HOSTED (NOT BEHIND CDN) NGINX WEBSERVER HONEYBOT AI OBSERVATORY
# nixops.sh
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/nixos/configuration.nix
# remotes/honeybot/scripts/stream.py
# remotes/honeybot/scripts/score.py
# remotes/honeybot/scripts/card.py
# remotes/honeybot/scripts/forest.py
# remotes/honeybot/scripts/test_forest.py
# remotes/honeybot/scripts/logs.py
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/db.py
# 
# # THE JEKYLL BLOG LIKE A HACKER (INVENTED SKILL.md & AGENTS.md FORMAT) PUBLISHING PIPELINE
# ~/repos/nixos/blogs.nix
# ~/.config/pipulate/blogs.json
# scripts/articles/publishizer.py
# scripts/articles/common.py
# scripts/articles/articleizer.py
# scripts/articles/link_injector.py
# scripts/articles/build_knowledge_graph.py
# scripts/articles/editing_prompt.txt
# scripts/articles/sanitizer.py
# scripts/articles/contextualizer.py
# scripts/articles/generate_hubs.py
# scripts/articles/generate_llms_txt.py
# scripts/articles/generate_post_nav.py
# assets/jekyll/common-packages.nix

# # Context 2
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/stream.py
# scripts/articles/articleizer.py
# scripts/articles/common.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('.deploy_standby'), '| featured_id_helper:', 'def get_featured_article_id' in cl, '| maintenance_line:', 'STANDBY_MAINTENANCE_LINE' in st)"
# # TRIMNOIR
# ~/repos/trimnoir/_config.yml
# ~/repos/trimnoir/flake.nix
# ~/repos/trimnoir/Gemfile
# ~/repos/trimnoir/index.md
# ~/repos/trimnoir/_layouts/default.html
# ~/repos/trimnoir/_layouts/page.html
# ~/repos/trimnoir/_layouts/post.html
# ~/repos/trimnoir/assets/main.css

# # Context 3
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/stream.py
# scripts/articles/articleizer.py
# scripts/articles/common.py
# scripts/articles/generate_hubs.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); ar=pathlib.Path('scripts/articles/articleizer.py').read_text(); cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('date +%s > \$WORK_TREE/.deploy_standby'), '| storytime_rank:', '_storytime_effective_rank' in cl, '| aside_flag:', '--aside' in ar, '| ytfeature_cmd:', 'def manage_storytime_feature' in cm and 'ytfeature()' in fl)"
# ~/repos/trimnoir/index.md
# ~/repos/trimnoir/_layouts/default.html
# ~/repos/trimnoir/_layouts/post.html
# ~/repos/trimnoir/assets/main.css

# Context 4
remotes/honeybot/hooks/post-receive
remotes/honeybot/scripts/content_loader.py
remotes/honeybot/scripts/stream.py
scripts/articles/articleizer.py
scripts/articles/common.py
scripts/articles/generate_hubs.py
flake.nix
! .venv/bin/python -c "import pathlib; gh=pathlib.Path('scripts/articles/generate_hubs.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); cm=pathlib.Path('scripts/articles/common.py').read_text(); ph=pathlib.Path('~/repos/trimnoir/_layouts/post.html').expanduser().read_text(); css=pathlib.Path('~/repos/trimnoir/assets/main.css').expanduser().read_text(); print('hub_badges:', 'badge-coming-soon' in gh and 'badge-vod' in gh, '| post_layout_badges:', 'badge-coming-soon' in ph and 'page.vod_url' in ph, '| css_badges:', '.badge-coming-soon' in css, '| graceful_reboot:', '_graceful_reboot_requested' in st and 'seq 1 25' in cm)"
~/repos/trimnoir/index.md
~/repos/trimnoir/_layouts/default.html
~/repos/trimnoir/_layouts/post.html
~/repos/trimnoir/assets/main.css

scripts/articles/common.py
flake.nix
! .venv/bin/python -c "import pathlib; cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('yt_help_has_ytfeature:', '19. ytfeature [slug]' in cm and '20. ytcard' in cm, '| both_os_have_aside:', fl.count(\"alias aside='write_post article --aside'\") == 2)"

Target: scripts/articles/common.py
[[[SEARCH]]]
        print(" 19. ytcard
[[[DIVIDER]]]
        print(" 19. ytfeature [slug]   📌 List `storytime: false` backfill queue, promote a post, or `--vod URL`")
        print(" 20. ytcard
[[[REPLACE]]]

Target: flake.nix
[[[SEARCH]]]
            # here with the roster until the template above grows one.
            alias article='write_post article'
            alias grim='write_post grim'
[[[DIVIDER]]]
            # here with the roster until the template above grows one.
            alias article='write_post article'
            alias aside='write_post article --aside'
            alias grim='write_post grim'
[[[REPLACE]]]

Hop off the ride. This ride's stated goal is reached; verify the final AFTER receipt (`yt_help_has_ytfeature: True | both_os_have_aside: True`) and close with the Notary Beat so I can publish this article using our brand-new `aside` command.

# # Context 1
# flake.nix
# 
# # HOME-HOSTED (NOT BEHIND CDN) NGINX WEBSERVER HONEYBOT AI OBSERVATORY
# nixops.sh
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/nixos/configuration.nix
# remotes/honeybot/scripts/stream.py
# remotes/honeybot/scripts/score.py
# remotes/honeybot/scripts/card.py
# remotes/honeybot/scripts/forest.py
# remotes/honeybot/scripts/test_forest.py
# remotes/honeybot/scripts/logs.py
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/db.py
# 
# # THE JEKYLL BLOG LIKE A HACKER (INVENTED SKILL.md & AGENTS.md FORMAT) PUBLISHING PIPELINE
# ~/repos/nixos/blogs.nix
# ~/.config/pipulate/blogs.json
# scripts/articles/publishizer.py
# scripts/articles/common.py
# scripts/articles/articleizer.py
# scripts/articles/link_injector.py
# scripts/articles/build_knowledge_graph.py
# scripts/articles/editing_prompt.txt
# scripts/articles/sanitizer.py
# scripts/articles/contextualizer.py
# scripts/articles/generate_hubs.py
# scripts/articles/generate_llms_txt.py
# scripts/articles/generate_post_nav.py
# assets/jekyll/common-packages.nix

# # Context 2
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/stream.py
# scripts/articles/articleizer.py
# scripts/articles/common.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('.deploy_standby'), '| featured_id_helper:', 'def get_featured_article_id' in cl, '| maintenance_line:', 'STANDBY_MAINTENANCE_LINE' in st)"
# # TRIMNOIR
# ~/repos/trimnoir/_config.yml
# ~/repos/trimnoir/flake.nix
# ~/repos/trimnoir/Gemfile
# ~/repos/trimnoir/index.md
# ~/repos/trimnoir/_layouts/default.html
# ~/repos/trimnoir/_layouts/page.html
# ~/repos/trimnoir/_layouts/post.html
# ~/repos/trimnoir/assets/main.css

# # Context 3
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/stream.py
# scripts/articles/articleizer.py
# scripts/articles/common.py
# scripts/articles/generate_hubs.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); ar=pathlib.Path('scripts/articles/articleizer.py').read_text(); cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('date +%s > \$WORK_TREE/.deploy_standby'), '| storytime_rank:', '_storytime_effective_rank' in cl, '| aside_flag:', '--aside' in ar, '| ytfeature_cmd:', 'def manage_storytime_feature' in cm and 'ytfeature()' in fl)"
# ~/repos/trimnoir/index.md
# ~/repos/trimnoir/_layouts/default.html
# ~/repos/trimnoir/_layouts/post.html
# ~/repos/trimnoir/assets/main.css

# # Context 4
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/stream.py
# scripts/articles/articleizer.py
# scripts/articles/common.py
# scripts/articles/generate_hubs.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; gh=pathlib.Path('scripts/articles/generate_hubs.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); cm=pathlib.Path('scripts/articles/common.py').read_text(); ph=pathlib.Path('~/repos/trimnoir/_layouts/post.html').expanduser().read_text(); css=pathlib.Path('~/repos/trimnoir/assets/main.css').expanduser().read_text(); print('hub_badges:', 'badge-coming-soon' in gh and 'badge-vod' in gh, '| post_layout_badges:', 'badge-coming-soon' in ph and 'page.vod_url' in ph, '| css_badges:', '.badge-coming-soon' in css, '| graceful_reboot:', '_graceful_reboot_requested' in st and 'seq 1 25' in cm)"
# ~/repos/trimnoir/index.md
# ~/repos/trimnoir/_layouts/default.html
# ~/repos/trimnoir/_layouts/post.html
# ~/repos/trimnoir/assets/main.css

# Context 5
scripts/articles/common.py
flake.nix
! .venv/bin/python -c "import pathlib; cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('yt_help_has_ytfeature:', '19. ytfeature [slug]' in cm and '20. ytcard' in cm, '| both_os_have_aside:', fl.count(\"alias aside='write_post article --aside'\") == 2)"

          ▲  /run/current-system/sw/bin (NixOS Immutable Store)
         / \
        /   \     ╔═══════════════════════════════════════════╗
   ◄───┼─────┼───►║   THE EUNUCHS pkill-ABLE PENTAGRAM        ║
      / \   / \   ║   • Zero-Agent Airlock (stream.py)        ║
     /   \ /   \  ║   • Deterministic Piper VITS Player Piano ║
    ▼─────▼─────▼ ║   • SIGTERM -> Figlet Card -> Watchdog    ║
   pkill  |  flock╚═══════════════════════════════════════════╝

flake.nix
scripts/articles/common.py
! .venv/bin/python -c "import pathlib; cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('yt_help_has_ytfeature:', '19. ytfeature [slug]' in cm and '20. ytcard' in cm, '| both_os_have_aside:', fl.count(\"alias aside='write_post article --aside'\") == 2)"

The aside + ytfeature publishing & backfill pipeline is live and verified. Ready for the next adventure.

# # Context 1
# flake.nix
# 
# # HOME-HOSTED (NOT BEHIND CDN) NGINX WEBSERVER HONEYBOT AI OBSERVATORY
# nixops.sh
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/nixos/configuration.nix
# remotes/honeybot/scripts/stream.py
# remotes/honeybot/scripts/score.py
# remotes/honeybot/scripts/card.py
# remotes/honeybot/scripts/forest.py
# remotes/honeybot/scripts/test_forest.py
# remotes/honeybot/scripts/logs.py
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/db.py
# 
# # THE JEKYLL BLOG LIKE A HACKER (INVENTED SKILL.md & AGENTS.md FORMAT) PUBLISHING PIPELINE
# ~/repos/nixos/blogs.nix
# ~/.config/pipulate/blogs.json
# scripts/articles/publishizer.py
# scripts/articles/common.py
# scripts/articles/articleizer.py
# scripts/articles/link_injector.py
# scripts/articles/build_knowledge_graph.py
# scripts/articles/editing_prompt.txt
# scripts/articles/sanitizer.py
# scripts/articles/contextualizer.py
# scripts/articles/generate_hubs.py
# scripts/articles/generate_llms_txt.py
# scripts/articles/generate_post_nav.py
# assets/jekyll/common-packages.nix

# # Context 2
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/stream.py
# scripts/articles/articleizer.py
# scripts/articles/common.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('.deploy_standby'), '| featured_id_helper:', 'def get_featured_article_id' in cl, '| maintenance_line:', 'STANDBY_MAINTENANCE_LINE' in st)"
# # TRIMNOIR
# ~/repos/trimnoir/_config.yml
# ~/repos/trimnoir/flake.nix
# ~/repos/trimnoir/Gemfile
# ~/repos/trimnoir/index.md
# ~/repos/trimnoir/_layouts/default.html
# ~/repos/trimnoir/_layouts/page.html
# ~/repos/trimnoir/_layouts/post.html
# ~/repos/trimnoir/assets/main.css

# # Context 3
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/stream.py
# scripts/articles/articleizer.py
# scripts/articles/common.py
# scripts/articles/generate_hubs.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; pr=pathlib.Path('remotes/honeybot/hooks/post-receive').read_text(); cl=pathlib.Path('remotes/honeybot/scripts/content_loader.py').read_text(); ar=pathlib.Path('scripts/articles/articleizer.py').read_text(); cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('checkout_before_standby:', pr.find('checkout -q -f main') < pr.find('date +%s > \$WORK_TREE/.deploy_standby'), '| storytime_rank:', '_storytime_effective_rank' in cl, '| aside_flag:', '--aside' in ar, '| ytfeature_cmd:', 'def manage_storytime_feature' in cm and 'ytfeature()' in fl)"
# ~/repos/trimnoir/index.md
# ~/repos/trimnoir/_layouts/default.html
# ~/repos/trimnoir/_layouts/post.html
# ~/repos/trimnoir/assets/main.css

# # Context 4
# remotes/honeybot/hooks/post-receive
# remotes/honeybot/scripts/content_loader.py
# remotes/honeybot/scripts/stream.py
# scripts/articles/articleizer.py
# scripts/articles/common.py
# scripts/articles/generate_hubs.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; gh=pathlib.Path('scripts/articles/generate_hubs.py').read_text(); st=pathlib.Path('remotes/honeybot/scripts/stream.py').read_text(); cm=pathlib.Path('scripts/articles/common.py').read_text(); ph=pathlib.Path('~/repos/trimnoir/_layouts/post.html').expanduser().read_text(); css=pathlib.Path('~/repos/trimnoir/assets/main.css').expanduser().read_text(); print('hub_badges:', 'badge-coming-soon' in gh and 'badge-vod' in gh, '| post_layout_badges:', 'badge-coming-soon' in ph and 'page.vod_url' in ph, '| css_badges:', '.badge-coming-soon' in css, '| graceful_reboot:', '_graceful_reboot_requested' in st and 'seq 1 25' in cm)"
# ~/repos/trimnoir/index.md
# ~/repos/trimnoir/_layouts/default.html
# ~/repos/trimnoir/_layouts/post.html
# ~/repos/trimnoir/assets/main.css

# # Context 5
# scripts/articles/common.py
# flake.nix
# ! .venv/bin/python -c "import pathlib; cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('yt_help_has_ytfeature:', '19. ytfeature [slug]' in cm and '20. ytcard' in cm, '| both_os_have_aside:', fl.count(\"alias aside='write_post article --aside'\") == 2)"

# Context 6
# flake.nix
scripts/articles/common.py
! .venv/bin/python -c "import pathlib; cm=pathlib.Path('scripts/articles/common.py').read_text(); fl=pathlib.Path('flake.nix').read_text(); print('yt_help_has_ytfeature:', '19. ytfeature [slug]' in cm and '20. ytcard' in cm, '| both_os_have_aside:', fl.count(\"alias aside='write_post article --aside'\") == 2)"
foo_files.py

================================================================================
   THE OLD GAME (Gated Slop & Pay-to-Play) vs. THE HONEYBOT GAME (Proof-of-Work)
================================================================================

  1. THE GATED WHITE-PAPER TRAP (Zero-Information Lead-Gen)
     • How B2B marketing used to work: Write a "10-Step Cheat Sheet" PDF, hide
       it behind an email-capture form, and buy LinkedIn/X ads to drive clicks.
     • Why that died: Anyone can prompt an LLM to generate that exact same
       cheat sheet in 4 seconds for free. Gating generic advice behind a form
       doesn't prove you're an expert; it proves you have nothing proprietary
       to show.

  2. THE SOCIAL ALGORITHM SHAKE-DOWN (Reach Dampening by Design)
     • Post a link to your own site on X (Twitter), LinkedIn, or YouTube, and
       the platform's feed ranker throttles your reach into the dirt unless you
       pay for "Boosted" ad impressions.
     • Even worse: if your publishing pipeline forces you to choose between
       "interrupting a good live stream" or "hiding your daily engineering work
       in a private journal," you end up self-throttling your own output.

  3. THE SOVEREIGN ALTERNATIVE (Squeezing Every Drop Out of the Lemon)
     • Instead of writing fake "thought leadership," you use AI to knock out
       every ambitious infrastructure project you ever wanted to build—and you
       publish the exact before/after probes, universal diffs, and philosophical
       asides as public, content-negotiated Markdown (`Accept: text/markdown`).
     • With `aside`, there is zero friction: you pour your heart into the
       article while the iron is hot, ship it to `mikelev.in` immediately, and
       let Honeybot pause for 45 seconds of clock-tick maintenance before
       resuming its current broadcast right where it left off.
     • The result:
       (a) AI training/RAG crawlers (ClaudeBot, OAI-SearchBot, Perplexity,
           Googlebot, Bing/IndexNow) ingest your verified diffs in real time—
           and you watch them do it live on the YouTube HUD.
       (b) Your homepage thumbnail grid pins up glowing "⏳ Coming Soon on
           YouTube Live Storytime" badges, turning your own index page into a
           visual programming queue.
       (c) When the current broadcast finishes its run, `ytfeature <slug>`
           promotes the best aside into the live 24/7 spotlight, and `--vod`
           permanently links the recorded YouTube episode back onto the card.
================================================================================

Target: foo_files.py
[[[SEARCH]]]
# --- START RECEIPTS (newest first; cap 20 lines; a line pushed past the cap is deleted, never moved -- git and the rolling pin are the archive) ---
# 2026-11-01 dismount 138X38 FULL-PROPORTION HONEYBOT REPORT OVERLAYS WITH 4-SIDED BLACK PADDING AND UNCLAMPED X11 SPAWN (deeds qamy.ai_555-fea6f089.zip through qamy.ai_557-357fafdd.zip; pipulate commits 8c4b419, 04544fd; Gemini 4 Argon High on every turn): locked station-break report Alacritty geometry to REPORT_WINDOW_COLUMNS = 138 by REPORT_WINDOW_LINES = 38 in remotes/honeybot/scripts/forest.py and remotes/honeybot/scripts/stream.py so the overlay masks the competing middle LED ticker and lower HUD tables while leaving ~1 row of live log motion visible at top and bottom; constrained the inner Rich Panel by REPORT_H_MARGIN = 3 and REPORT_V_MARGIN = 2 inside Align.center(..., vertical="middle") so shorter reports float in a centered black canvas; and moved conjure_window's initial spawn offset in imports/ascii_displays.py from {x=200, y=150} to {x=20, y=20} so xfwm4 never clamps the 38-row window height before _center_and_raise centers it (# § SPAWN INSIDE THE SCREEN BOUNDS). WITNESSED: ascii_displays.py:352 at window.position={x=20, y=20}, forest.py:350 displaced +5 lines, synced via nixops and witnessed live on Honeybot :10.0 via non-blocking ssh conjure_window audition, Ruff clean, deed qamy.ai_557-357fafdd.zip.
[[[DIVIDER]]]
# --- START RECEIPTS (newest first; cap 20 lines; a line pushed past the cap is deleted, never moved -- git and the rolling pin are the archive) ---
# 2026-11-01 dismount ASIDE PUBLISHING, HONEYBOT MAINTENANCE RESUME-IN-PLACE, YTFEATURE BACKFILL PROMOTION, AND GRACEFUL SIGTERM REBOOTS (deeds qamy.ai_562 through qamy.ai_568-f737a272.zip; pipulate commits d167463, 8186b3a, db6b277, c5def75; Gemini 4 Argon High on every turn): decoupled chronological public article publishing from Honeybot Storytime broadcast preemption (# § DECOUPLE PUBLISHING FROM BROADCAST PREEMPTION); moved git checkout -q -f main ahead of .deploy_standby in remotes/honeybot/hooks/post-receive; added _is_storytime_enabled(), _storytime_effective_rank(), _get_pinned_storytime_file(), and get_featured_article_id() in remotes/honeybot/scripts/content_loader.py; updated remotes/honeybot/scripts/stream.py to speak STANDBY_MAINTENANCE_LINE over tick.wav and resume the active article at the current paragraph when get_featured_article_id() is unchanged across a deploy, and wired SIGTERM/SIGUSR1 (_graceful_reboot_requested) into announce_scheduled_reboot(); added --aside (storytime: false) to scripts/articles/articleizer.py, aside and ytfeature (manage_storytime_feature() + --vod URL stamping) to scripts/articles/common.py and flake.nix, and "Coming Soon on YouTube Live Storytime" / "Watch YouTube VOD" badges to scripts/articles/generate_hubs.py and ~/repos/trimnoir/{_layouts/post.html,assets/main.css}. WITNESSED: checkout_before_standby/storytime_rank/aside_flag/ytfeature_cmd False -> True, hub_badges/post_layout_badges/css_badges/graceful_reboot False -> True, yt_help_has_ytfeature/both_os_have_aside False -> True (0.0578s), live ytfeature radar and double-tap ytreboot (pid=2945042 -> 2980818 -> 2981187) witnessed on Honeybot, Ruff clean, deed qamy.ai_568-f737a272.zip.
# 2026-11-01 dismount 138X38 FULL-PROPORTION HONEYBOT REPORT OVERLAYS WITH 4-SIDED BLACK PADDING AND UNCLAMPED X11 SPAWN (deeds qamy.ai_555-fea6f089.zip through qamy.ai_557-357fafdd.zip; pipulate commits 8c4b419, 04544fd; Gemini 4 Argon High on every turn): locked station-break report Alacritty geometry to REPORT_WINDOW_COLUMNS = 138 by REPORT_WINDOW_LINES = 38 in remotes/honeybot/scripts/forest.py and remotes/honeybot/scripts/stream.py so the overlay masks the competing middle LED ticker and lower HUD tables while leaving ~1 row of live log motion visible at top and bottom; constrained the inner Rich Panel by REPORT_H_MARGIN = 3 and REPORT_V_MARGIN = 2 inside Align.center(..., vertical="middle") so shorter reports float in a centered black canvas; and moved conjure_window's initial spawn offset in imports/ascii_displays.py from {x=200, y=150} to {x=20, y=20} so xfwm4 never clamps the 38-row window height before _center_and_raise centers it (# § SPAWN INSIDE THE SCREEN BOUNDS). WITNESSED: ascii_displays.py:352 at window.position={x=20, y=20}, forest.py:350 displaced +5 lines, synced via nixops and witnessed live on Honeybot :10.0 via non-blocking ssh conjure_window audition, Ruff clean, deed qamy.ai_557-357fafdd.zip.
[[[REPLACE]]]

Target: foo_files.py
[[[SEARCH]]]
# 2026-10-22 dismount SEVEN-AT-ONE-SWAT SPATIAL MYELINATION AND TWO-CARD MONTE PIPER-TTS / LIBRUBY ABI JEKYLL FLAKE FIX (deeds qamy.ai_157 through qamy.ai_169; Gemini 4 Argon High on every turn): re-architected `~/repos/nixos/autognome.py` 7-screen GNOME X11 workspace continuum (`swatCommand` / `! swat` in `flake.nix`) for spatial muscle memory and edge-bounce ergonomics, and resolved the dual-fault `trimnoir` Jekyll flake breakage caused by an upstream Python 3.14 `pyopenjtalk-plus` test failure pulled in by `piper-tts` and a stale `.gem` `libruby.so` C-extension ABI mismatch (`# § THE NULL-STATE VERDICT OVER THE CRASH`, `# § TRIM THE GUEST FLAKE`). WITNESSED: `2026-10-22-seven-at-one-swat-spatial-myelination-autognome-x11.md` and `2026-10-22-two-card-monte-piper-tts-libruby-abi-jekyll-flake.md` published and indexed in `postsc 30`, `swatCommand` live in `flake.nix`, Ruff clean.
# --- END RECEIPTS ---
[[[DIVIDER]]]
# --- END RECEIPTS ---
[[[REPLACE]]]

Target: foo_files.py
[[[SEARCH]]]
# § SPAWN INSIDE THE SCREEN BOUNDS (banked 2026-11-01, deed 557) -- Spawn transient X11 overlay windows near the top-left origin ({x=20, y=20}) before measuring and centering them with wmctrl, because spawning a tall terminal at a large initial Y offset pushes its bottom edge past the display height and causes the window manager (xfwm4) to clamp the window's row count before centering runs.
[[[DIVIDER]]]
# § DECOUPLE PUBLISHING FROM BROADCAST PREEMPTION (banked 2026-11-01, deed 568) -- Separate chronological site publishing from live broadcast preemption via frontmatter state (storytime: false for aside posts, storytime_featured and storytime_order for backfill promotion) and compare get_featured_article_id() across deploys so routine edits and aside publishes pause for maintenance and resume the active show at the current paragraph rather than restarting from the top.
# § SPAWN INSIDE THE SCREEN BOUNDS (banked 2026-11-01, deed 557) -- Spawn transient X11 overlay windows near the top-left origin ({x=20, y=20}) before measuring and centering them with wmctrl, because spawning a tall terminal at a large initial Y offset pushes its bottom edge past the display height and causes the window manager (xfwm4) to clamp the window's row count before centering runs.
[[[REPLACE]]]

foo_files.py
scripts/articles/common.py
! .venv/bin/python -c "import pathlib; cm=pathlib.Path('scripts/articles/common.py').read_text(); print('ytfeature_in_common:', 'def manage_storytime_feature' in cm)"

Decoupling Jekyll deploys from 24/7 YouTube TTS preemption: aside frontmatter pauses narration for maintenance, resumes in place, and queues posts for ytfeature.
https://mikelev.in/futureproof/aside-publishing-ytfeature-backfill-storytime/
#NixOS #Jekyll #Python

A wide 16:9 graphic-novel ink-and-wash illustration set against a deep obsidian-slate (#111111) background. Vertically centered in the composition is an intricate brass-and-glass broadcast control console split into two synchronized lanes: on the left, a glowing amber mechanical escapement gear and pendulum clock hold a luminous cyan audio waveform steady at a single frozen paragraph marker; on the right, fresh illuminated parchment scrolls glide through a high-speed pneumatic printing press into a rack of glowing amber lantern cards, each awaiting its turn on the main stage. Warm amber tungsten highlights contrast with cool electric-cyan optical traces and crisp ink linework extending continuously into the dark industrial studio architecture at every edge. Full-bleed edge-to-edge composition filling 100% of the canvas with no borders, no frames, no matting, no margins, and no text overlays or lettering.