예산, 교대, 그리고 조용한 아웃박스

def prepare(self):
    """The review to run now, without writing anything unless a new one starts."""
    with self.engine.connection() as c:
        role=c.execute("SELECT * FROM engine_chief_roles WHERE id='main' AND enabled=1").fetchone()
        if not role:
            return None
        active=c.execute("SELECT * FROM engine_chief_runs WHERE role_id='main' AND status IN ('prepared','running','uncertain')").fetchone()
        if active:
            return dict(active)
        now=time.time()
        if not c.execute("SELECT 1 FROM engine_obligations WHERE status='pending' AND due<=? LIMIT 1",(now,)).fetchone():
            return None
        if c.execute("SELECT count(*) FROM engine_chief_runs WHERE created>?",(now-3600,)).fetchone()[0]>=HOURLY_BUDGET:
            return None
    def run(c):
        ...
        due=[r['id'] for r in c.execute("SELECT id FROM engine_obligations WHERE status='pending' AND due<=? ORDER BY due,id LIMIT 50",(time.time(),))]
        ...
        c.execute("UPDATE engine_chief_roles SET wakes=wakes+1 WHERE id='main'")
        return self.engine.row(c,'engine_chief_runs',rid)
    return self.command(str(uuid4()),'chief.prepare',{},run)

async def rotate(self,role):
    """Start a fresh chief conversation after ROTATE_AFTER wakes.

    Pippa replays a conversation in full on every turn, so a chief
    conversation that only ever grows makes each wake cost more than the
    last (152 messages after three days). The binder keeps the same
    context key, so Dad's Sidekick opens the new conversation.
    """
    ...

async def tick(self):
    review=self.chief.prepare()
    if review is None:
        role=self.chief.context()['role']
        if role and role['enabled'] and role['wakes']>=ROTATE_AFTER and self.client is not None:
            await self.rotate(role)
        return
    ...

import json, sqlite3

db = sqlite3.connect(':memory:')
db.executescript("""
CREATE TABLE outbox (id INTEGER PRIMARY KEY, kind TEXT, session_id TEXT,
                     state TEXT DEFAULT 'pending', created REAL);
CREATE TABLE chief_runs (id INTEGER PRIMARY KEY, decisions TEXT);
""")
now = 3 * 86400.0
# Rows with a receiver get drained; rows for nobody (session_id NULL) pile up.
db.executemany('INSERT INTO outbox(kind, session_id, state, created) VALUES (?,?,?,?)',
               [('work', 's1', 'delivered', 100.0), ('invitation', 's2', 'delivered', 200.0)] +
               [('outcome', None, 'pending', 3600.0 * h) for h in range(1, 16)])
db.executemany('INSERT INTO chief_runs(decisions) VALUES (?)',
               [(json.dumps([{'action': 'defer'}, {'action': 'escalate'}]),)] * 74)

# 1. A queue is healthy when its oldest pending row is young, not when rows exist.
for kind, n, oldest in db.execute(
        "SELECT kind, count(*), min(created) FROM outbox WHERE state='pending' "
        "GROUP BY kind ORDER BY min(created)"):
    print(f'{kind:10} pending={n:3}  oldest={(now - oldest) / 3600:5.1f} h')

# 2. A reviewer is useful when its decisions change work, not when it wakes.
#    defer, escalate and park only reschedule the next look.
EFFECT = {'close', 'release', 'abandon', 'adopt', 'assign', 'retire', 'resend'}
runs = [json.loads(r[0]) for r in db.execute('SELECT decisions FROM chief_runs')]
changed = sum(any(d['action'] in EFFECT for d in run) for run in runs)
print(f'wakes={len(runs)}  wakes that changed anything={changed}')