yt-briefing 0.15.1 → 1.1.0

package/README.md

@@ -16,6 +16,10 @@ It also gets better the more you use it. You give each summary a quick rating, w
 or not, and from that it learns what to keep showing you and what to drop. Over time the queue
 becomes yours: less noise, more of what you care about.
 
+yt-briefing runs inside [Claude Code](https://claude.com/claude-code). `/yt` opens the briefing in
+a pane next to your chat, and the filtering and summaries run on your own Claude Code login. There
+is no separate model, provider or LLM key to set up.
+
 ## First run vs later
 
 On a channel's first sweep there is no history, so yt-briefing takes the latest video of each
@@ -28,11 +32,8 @@ the last one left off.
 
 ## Setup
 
-You'll need Node 18+ or Bun, a YouTube Data API v3 key, an LLM key (a
-[free Gemini key](https://aistudio.google.com/apikey) works, see [Providers](#providers)), and
-a tool that runs skills: [Claude Code](https://claude.com/claude-code),
-[Cursor](https://cursor.com), [Codex](https://developers.openai.com/codex), or anything else
-that loads the standard `SKILL.md` (Agent Skills — 30+ agents).
+You'll need Node 18+ or Bun, a YouTube Data API v3 key, and
+[Claude Code](https://claude.com/claude-code) installed and logged in, with `claude` on your PATH.
 
 1. Install yt-dlp (it pulls the subtitles):
 
@@ -53,18 +54,15 @@ yarn add yt-briefing
 bun  add yt-briefing
 ```
 
-3. Put your keys in a `.env` at your project root — all four are required:
+3. Put your YouTube key in a `.env` at your project root:
 
 ```ini
-YT_BRIEFING_LLM_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai
-YT_BRIEFING_LLM_API_KEY=<key>        # free at https://aistudio.google.com/apikey
-YT_BRIEFING_LLM_MODEL=gemini-2.5-flash
 YT_BRIEFING_YOUTUBE_API_KEY=<key>    # console.cloud.google.com → enable "YouTube Data API v3"
 ```
 
-Any OpenAI-compatible endpoint works — see [Providers](#providers) to use OpenRouter, OpenAI,
-Anthropic, or a local Ollama instead of Gemini. `YT_BRIEFING_PROXY` (datacenter/VPS IPs) is the
-only optional extra.
+Optional extras: `YT_BRIEFING_MODEL` picks the Claude model for filtering and summaries (default
+`sonnet`, any alias or model name `claude --model` accepts, `haiku` for faster runs), and `YT_BRIEFING_PROXY` routes
+transcript fetches through a proxy on datacenter/VPS IPs.
 
 4. Onboard:
 
@@ -72,7 +70,8 @@ only optional extra.
 npx yt-briefing init      # or: bunx yt-briefing init
 ```
 
-`init` asks for your language, the channels to follow, and which tool runs `/yt`.
+`init` asks for your language and the channels to follow, then installs `/yt` and the two
+skills into your project's `.claude/skills/`.
 
 Add or remove channels anytime:
 
@@ -118,84 +117,64 @@ it to go deeper, lower it for a quicker pass:
 /yt-search @betterstack which terminal --top 5
 ```
 
-## Don't shelve it — research it
-
-Tech channels announce something new every week, and the usual fate is "looks interesting" →
-to-do list → never. So the rating popup has a third option next to OK/Weak: **Research**. Pick
-it — or type `? your question` straight into the comment box — and the loop ends there: the
-agent pulls that video's full transcript and works your question with you. Against your own
-codebase if you ask "would this fit my project", against the web if the claims need checking —
-a quick feedback loop instead of a shelf. The video is marked as seen, and the next `/yt`
-resumes the queue right where you broke off.
-
 ## Run it
 
-Open your project in Claude Code or Cursor and run `/yt`. If it's not listed, start a fresh
-session. To install the skills again for another tool or project, run
-`npx yt-briefing install-skill` (it installs `/yt`, `/yt-transcribe`, and `/yt-search`).
-
-## Rating gate
-
-The loop only works if you see the summary *before* you rate it, and that is the one step an
-agent can silently drop — the popup still appears, you still answer, and the rating is recorded
-against a summary nobody read. On Claude Code the installer wires a `PreToolUse` hook into your
-project's `.claude/settings.json` that refuses to *record* a rating unless the video's summary is
-in the chat. It merges with your existing hooks and updates itself on reinstall. If that file
-isn't valid JSON the installer leaves it alone and says so — add the entry yourself:
-
-```json
-{
-  "hooks": {
-    "PreToolUse": [
-      { "matcher": "Bash",
-        "hooks": [ { "type": "command", "command": "node \"${CLAUDE_PROJECT_DIR}/node_modules/yt-briefing/dist/yt-summary-gate.js\"" } ] }
-    ]
-  }
-}
-```
+Open your project in Claude Code and type `/yt`. The briefing opens in a pane: the summary, and
+under it four keys.
 
-It watches the rating write rather than the popup, because the popup cannot be gated: the agent
-pastes the summary and opens the popup in one message, and the harness only writes a message to
-the transcript once that message is complete — so the evidence does not exist yet at popup time.
-The rating write is a separate call in the next message, where it does. The matcher is `Bash`, so
-the hook is invoked on ordinary shell commands too; it reads the command line and exits before
-touching anything. The tradeoff: a genuinely skipped paste is caught after you have answered, so
-that one answer is wasted — but nothing reaches the channel profile unseen.
+| Key | What it does |
+|-----|--------------|
+| `1` OK | Neutral. The video is marked as seen, the next one loads. |
+| `2` Weak | Worthless. The title goes to the channel's skip examples, so the filter learns to drop titles like it. |
+| `3` Research | Ends the loop and hands this video to Claude, see below. |
+| `4` Stop | Closes the pane. The next `/yt` resumes where you stopped. |
 
-Other agents have no equivalent hook, so there the instruction in `SKILL.md` is what holds.
+The **Comment** field takes anything else. Type what you think in your own words ("too many panel
+shows, skip those") and press Enter: Claude turns it into a standing rule for that channel and
+infers the rating. `? your question` starts research with that question, `stop` closes the pane.
 
-## Providers
+Each step is the engine, not a chat turn: rating a video costs no tokens of your session, and
+the next summary is usually ready before you have finished reading the current one.
 
-Any OpenAI-compatible endpoint works. Gemini 2.5 Flash is the easy default. It's fast, cheap,
-and free to start at [Google AI Studio](https://aistudio.google.com/apikey):
+`/yt` is a Claude Code mod (a plugin in `.claude/skills/yt-briefing/`). Claude Code loads it on
+its own once you trust the project folder. If `/yt` is not listed, start a fresh session. To
+install again, after an upgrade or into another project, run `npx yt-briefing install-skill` (it
+installs `/yt`, `/yt-transcribe` and `/yt-search`).
 
-```ini
-YT_BRIEFING_LLM_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai
-YT_BRIEFING_LLM_API_KEY=<gemini-key>
-YT_BRIEFING_LLM_MODEL=gemini-2.5-flash
-```
-
-> On the free tier Gemini sometimes returns a "model is overloaded / high demand" error. Retry,
-> or switch to a paid key (enable billing, same model) to avoid it.
-
-Want something else? Change those three lines for OpenRouter (`https://openrouter.ai/api/v1`),
-OpenAI (`https://api.openai.com/v1`), Anthropic (`https://api.anthropic.com/v1/`,
-e.g. `claude-sonnet-5`), or a local Ollama (`http://localhost:11434/v1`). Set
-`YT_BRIEFING_LLM_BASE_URL`, `_API_KEY`, and `_MODEL` in your root `.env` (see [Setup](#setup)).
-
-## Why an API, not the agent's native model
-
-The filtering and the summaries go through a plain OpenAI-compatible API call from the engine,
-not through the coding agent's own model. Two reasons.
-
-Speed. The engine works ahead in the background. It expands channels in parallel and starts
-summarizing the next video while you rate the current one, so the following step is usually
-ready with no wait. An agent's turn-by-turn loop cannot prefetch like that, and every step pays
-its own cold start, which adds up across a whole queue.
+## Don't shelve it — research it
 
-Compatibility. A standard API plus a standard `SKILL.md` means one engine runs everywhere: Claude
-Code, Cursor, Codex, any other Agent-Skills-compatible tool, or the plain CLI. A tool-native
-approach would tie it to that one tool and one model.
+Tech channels announce something new every week, and the usual fate is "looks interesting" →
+to-do list → never. So next to OK/Weak there is a third key: **Research**. Press it, or type
+`? your question` into the comment field, and the loop ends there: the pane closes and the video
+lands in your chat with its briefing and the command for its full transcript. Claude works your
+question with you, against your own codebase if you ask "would this fit my project", against the
+web if the claims need checking. A quick feedback loop instead of a shelf. The video is marked as
+seen, and the next `/yt` resumes the queue right where you broke off.
+
+## Upgrading from 0.x
+
+1.0 runs on Claude Code only. The OpenAI-compatible provider and its three `YT_BRIEFING_LLM_*`
+keys are gone (delete them from `.env`), and the chat-driven `/yt` skill with its rating popup is
+replaced by the pane. Run `npx yt-briefing install-skill` once in your project: it installs the
+pane, and removes the old `/yt` skill and the summary-gate hook from `.claude/settings.json`. Your
+channels, profiles and ratings in `.yt-briefing/data/` carry over unchanged.
+
+## Why Claude Code, and nothing else
+
+Filtering and summaries are a `claude -p` call from the engine: one prompt in, one answer out, with
+no tools, no project settings or hooks, no MCP servers and no saved session. It runs on the login
+you already have, so there is no second model to pay for or keep a key to. If `ANTHROPIC_API_KEY`
+is set in your environment, the engine removes it for that call, because Claude Code would
+otherwise bill it as API usage instead of using your login.
+
+The engine still works ahead in the background. It expands channels in parallel and summarizes the
+next video while you rate the current one, so each step is usually ready with no wait. The pane
+only shows what the engine produced and sends your key presses back to it.
+
+Supporting every agent that reads `SKILL.md` meant a chat loop for the rating: the model pasted
+each summary, asked the question and recorded the answer, every video a full turn, plus a hook to
+make sure the summary was really shown. A Claude Code pane does the same with no model in the loop,
+which is why 1.0 drops the other agents.
 
 ## Why one transcript at a time
 
@@ -210,7 +189,8 @@ flowing.
 ## Sync across machines
 
 Your state is plain files in `.yt-briefing/data/`. Version that folder (or point `YT_BRIEFING_DATA_DIR`
-at a separate private repo) and commit after each rating. Recipe:
+at a separate private repo) and commit after each rating: set `"after_rate"` in
+`.yt-briefing/data/config.json` to a script and the engine runs it after every rating. Recipe:
 [docs/sync-across-machines.md](./docs/sync-across-machines.md).
 
 ## Running on a VPS

package/dist/bootstrap.js

@@ -8,17 +8,18 @@
  *   1. Output language for summaries + ratings   → DATA_DIR/config.json
  *   2. The channels you follow — just a flat list of handles
  *      → DATA_DIR/channels.md, DATA_DIR/state.md, DATA_DIR/channels/<slug>.md
- *   3. Which agent runs /yt — installs the skill into its skills dir
+ *   3. Installs /yt (the rating pane) + /yt-transcribe + /yt-search into this Claude Code project
  *
- * It does NOT touch keys: those live in your project root .env (see README → Setup); the engine
- * reads them at run time. Re-running is safe: it warns before overwriting existing data and bails.
+ * It does NOT touch keys: the one key (YouTube Data API) lives in your project root .env (see README →
+ * Setup); the engine reads it at run time. Filters and summaries run on your Claude Code login. Re-running is safe: it warns before overwriting existing data and bails.
  * Everything it writes is plain Markdown / JSON you can also edit by hand afterwards.
  */
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { DATA_DIR, BASE_DIR, PKG_ROOT, CHANNELS_DIR, CHANNELS_MD, STATE_MD, CONFIG_JSON, profilePath, ROOT_ENV_PATH, } from "./lib/paths.js";
-import { loadEnv, missingEnv, REQUIRED_LLM, REQUIRED_YOUTUBE } from "./lib/env.js";
-import { AGENTS, installSkills, projectSkillsRoot, customSkillsRootDefault, isPackageDevCwd, installClaudeGate, CLAUDE_CODE } from "./lib/skill-install.js";
+import { loadEnv, missingEnv, REQUIRED_YOUTUBE } from "./lib/env.js";
+import { installAll, isPackageDevCwd } from "./lib/skill-install.js";
+import { claudeMissing } from "./lib/llm.js";
 import { question } from "./lib/prompt.js";
 import { normalizeHandle, slugify, serializeChannels, serializeState, profileBody, baselineStateRow } from "./lib/channels.js";
 const ask = (q, def = '') => {
@@ -41,8 +42,8 @@ function main() {
         }
         console.log('');
     }
-    // Keys are NOT asked here — they live in your project root .env (LLM + YouTube; see README
-    // → Setup). The engine reads them at run time and fails fast naming any that are missing.
+    // Keys are NOT asked here — the YouTube key lives in your project root .env (see README →
+    // Setup). The engine reads it at run time and fails fast naming it if missing.
     // 1. Language ----------------------------------------------------------------
     console.log('  1) Language');
     const outputLang = ask('  Output language for summaries and ratings', 'English');
@@ -75,18 +76,7 @@ function main() {
     if (channels.length === 0) {
         console.log('\n  No channels added — you can add them later by editing data/channels.md.\n');
     }
-    // 3. Coding agent ------------------------------------------------------------
-    // Place the skill INTO THIS PROJECT (the package folder you open in the agent) — never a
-    // home-global dir (that's the npm -g antipattern: machine-wide, invisible, easy to forget).
-    // SKILL.md is the cross-agent standard, so the shipped skill runs in any compatible agent —
-    // we just install it into that agent's skills dir (.claude/skills, .cursor/skills, .codex/skills).
-    // 1/2/3 = known agents; 4 = any other compatible agent (a project folder you name).
-    console.log('\n  3) Which agent will you run /yt in?  (it ships a standard Agent Skill — any compatible agent works)');
-    console.log('       1) Claude Code   2) Cursor   3) Codex   4) Custom folder (any other agent)\n');
-    const agentKey = ask('  Your agent', '1');
-    // For a custom target, ask the folder now (keeps all prompts in the interactive block).
-    const customDir = AGENTS[agentKey] ? '' : ask('  Skills folder to install into', customSkillsRootDefault());
-    // 4. Write everything --------------------------------------------------------
+    // 3. Write everything --------------------------------------------------------
     mkdirSync(CHANNELS_DIR, { recursive: true });
     // Keep the throwaway cache out of git for the consume layout. data/ stays versionable (for sync).
     if (BASE_DIR !== PKG_ROOT) {
@@ -106,44 +96,35 @@ function main() {
     console.log(`    ${CHANNELS_MD}`);
     console.log(`    ${STATE_MD}`);
     console.log(`    ${channels.length} profile(s) in ${CHANNELS_DIR}/`);
-    // Install the /yt + /yt-transcribe skills for the chosen agent (step 6), into THIS project —
-    // process.cwd(), i.e. wherever you ran the command (the package clone in dev, or your own
-    // project when the package is a dependency). The command baked in is the shipped `bun run src`
-    // only for the dev-in-clone case; otherwise the compiled `dist/` command (so a consumed package works).
-    const agent = AGENTS[agentKey];
+    // Install into THIS project — process.cwd(), wherever you ran the command (the package clone in
+    // dev, or your own project when the package is a dependency). The shipped dev commands only for
+    // the dev-in-clone case; otherwise the compiled `dist/` commands (so a consumed package works).
     try {
-        const targets = agent
-            ? installSkills(projectSkillsRoot(agentKey, process.cwd()), /* dist */ !isPackageDevCwd())
-            : installSkills(customDir, /* dist */ true);
-        for (const t of targets)
-            console.log(`    skill → ${t}`);
-        // Claude Code also gets the summary gate — the hook that refuses a rating popup for a video
-        // whose summary was never pasted into the chat. No other agent exposes PreToolUse.
-        if (agentKey === CLAUDE_CODE) {
-            const gate = installClaudeGate(process.cwd(), /* dist */ !isPackageDevCwd());
-            console.log(gate
-                ? `    gate  → ${gate}`
-                : `  ! .claude/settings.json isn't valid JSON — add the summary gate by hand (README → Rating gate).`);
-        }
+        const { written, removed } = installAll(process.cwd(), /* dist */ !isPackageDevCwd());
+        for (const t of written)
+            console.log(`    claude → ${t}`);
+        for (const r of removed)
+            console.log(`    removed (replaced in 1.0) → ${r}`);
     }
     catch (e) {
-        console.log(`  ! Couldn't install the skills (${e.message}) — run  yt-briefing install-skill  later.`);
+        console.log(`  ! Couldn't install into .claude/skills (${e.message}) — run  yt-briefing install-skill  later.`);
     }
-    // Preflight the keys the engine needs at run time. init deliberately does NOT write them —
-    // they live in the project root .env (12-factor) — but warn now, naming any still missing, so
-    // the gap surfaces here instead of at the first /yt.
+    // Preflight what the engine needs at run time, so the gap surfaces here instead of at the
+    // first /yt: the YouTube key in the project root .env, and a logged-in `claude` CLI.
     loadEnv();
-    const missingKeys = missingEnv([...REQUIRED_LLM, ...REQUIRED_YOUTUBE]);
+    const missingKeys = missingEnv(REQUIRED_YOUTUBE);
     if (missingKeys.length) {
-        console.log('\n  ⚠ Keys still needed before /yt will run — add them to your project root .env:');
+        console.log('\n  ⚠ Key still needed before /yt will run — add it to your project root .env:');
         for (const k of missingKeys)
             console.log(`      ${k}`);
-        console.log(`    Path: ${ROOT_ENV_PATH}   ·   full block in README → Setup`);
+        console.log(`    Path: ${ROOT_ENV_PATH}   ·   see README → Setup`);
     }
+    const noClaude = claudeMissing();
+    if (noClaude)
+        console.log(`\n  ⚠ ${noClaude}`);
     console.log('\n  Next:');
-    console.log(`    1. Open this folder in ${agent ? agent.name : 'your agent'}.`);
-    console.log('    2. Start a new chat and type  /yt  (or  /yt-transcribe <url>)');
-    console.log('\n  No agent? Run it in the terminal instead — see the README.\n');
+    console.log('    1. Open this folder in Claude Code (trust it when asked).');
+    console.log('    2. Type  /yt  — the briefing opens in a pane.  (/yt-transcribe <url> for one video)\n');
 }
 try {
     main();

package/dist/cli.js

@@ -6,7 +6,7 @@
  * or Bun), passing remaining args through.
  *
  *   yt-briefing init                       interactive onboarding wizard
- *   yt-briefing install-skill              install the /yt skill into a coding agent
+ *   yt-briefing install-skill              install /yt (pane) + skills into a Claude Code project
  *   yt-briefing add|remove <@handle|url>   add or remove channels (also list)
  *   yt-briefing list                       list the channels you follow
  *   yt-briefing sweep [--reset]            advance one step; prints a JSON status line

package/dist/install-skill.js

@@ -1,63 +1,32 @@
 #!/usr/bin/env node
 /**
- * install-skill — copy this package's skills (`/yt` + `/yt-transcribe`) into a coding agent's
- * skills directory so the agent detects them. For any target that isn't this package under Bun,
- * each command is baked to `"<this runtime>" "<abs>/dist/X.js"` (the compiled build), so it works
- * no matter the agent's working directory or runtime (the engine resolves data/.env from its own
- * location).
+ * install-skill — install yt-briefing into a Claude Code project: the `/yt` mod (the rating pane)
+ * plus the `/yt-transcribe` and `/yt-search` skills, all under `<project>/.claude/skills/`.
  *
- *   yt-briefing install-skill        # interactive: pick agent + scope
+ *   yt-briefing install-skill        # interactive: which project folder
  *
- * `bun run init` already installs these skills into the project as its final step; this
- * standalone command is for re-installing, a different project, or a second agent. There is
- * deliberately no home-global install — the skills live with the project that uses them.
- *
- * SKILL.md is the cross-agent Agent Skills standard, so the shipped skills run in any compatible
- * agent (Claude Code, Cursor, Codex, and 30+ others); this command just (re)places them in the
- * skills dir of whichever agent you pick.
+ * `init` already does this as its final step; this standalone command is for re-installing
+ * (e.g. after an upgrade), or for another project. There is deliberately no home-global install —
+ * everything lives with the project that uses it. Upgrading from 0.x also removes the old
+ * chat-driven `/yt` skill and the summary-gate hook it needed.
  */
-import { AGENTS, installSkills, projectSkillsRoot, customSkillsRootDefault, isPackageDevCwd, installClaudeGate, CLAUDE_CODE } from "./lib/skill-install.js";
+import { installAll, isPackageDevCwd } from "./lib/skill-install.js";
 import { question } from "./lib/prompt.js";
 const ask = (q, def = '') => question(def ? `${q} [${def}]:` : `${q}:`).trim() || def;
-function done(targets, gate) {
-    console.log('\n  ✓ Installed:');
-    for (const t of targets)
-        console.log(`      ${t}`);
-    if (gate)
-        console.log(`      ${gate}  (summary gate)`);
-    if (gate === null)
-        console.log(`  ! .claude/settings.json isn't valid JSON — add the summary gate by hand (README → Rating gate).`);
-    console.log('  Start a fresh agent session, then run  /yt  or  /yt-transcribe\n');
-}
-/** Claude Code only: the PreToolUse hook that blocks a rating popup with no summary in the chat. */
-const gateFor = (key, projectDir, dist) => key === CLAUDE_CODE ? installClaudeGate(projectDir, dist) : undefined;
-// 1) which agent → which skills subdir
-console.log('\n  Install the /yt + /yt-transcribe skills — which agent?\n');
-console.log('    1) Claude Code');
-console.log('    2) Cursor');
-console.log('    3) Codex');
-console.log('    4) Custom folder (any other compatible agent)\n');
-const agentKey = ask('  Agent', '1');
-const agent = AGENTS[agentKey];
-// 3) Custom — write the skills straight into a skills root the user names (their agent's dir).
-// Arbitrary location → bake the absolute dist commands so they work whatever the agent's cwd is.
-if (!agent) {
-    done(installSkills(ask('  Skills folder to install into', customSkillsRootDefault()), true));
-    process.exit(0);
-}
-// 2) Known agent → which project (default: the current folder). No home-global option by
-// design — the skills are always scoped to a project that uses them.
-console.log(`\n  ${agent.name} — which project?\n`);
+console.log('\n  Install /yt (pane) + /yt-transcribe + /yt-search into a Claude Code project.\n');
 console.log('    1) This project (current folder) — recommended');
 console.log('    2) Another project folder\n');
-if (ask('  Where', '1') === '2') {
-    // A different project → the agent's cwd won't be the package, so bake the absolute dist commands.
-    const projectDir = ask('  Project folder', process.cwd());
-    done(installSkills(projectSkillsRoot(agentKey, projectDir), true), gateFor(agentKey, projectDir, true));
-}
-else {
-    // Current folder: shipped `bun run src` only when developing in the package clone under Bun;
-    // otherwise (incl. consuming the package as a dependency) bake the compiled dist commands.
-    const dist = !isPackageDevCwd();
-    done(installSkills(projectSkillsRoot(agentKey, process.cwd()), dist), gateFor(agentKey, process.cwd(), dist));
+const other = ask('  Where', '1') === '2';
+const projectDir = other ? ask('  Project folder', process.cwd()) : process.cwd();
+// The shipped dev commands only work developing inside the package clone under Bun; anything
+// else (another folder, Node, the package consumed as a dependency) gets the compiled dist/ form.
+const { written, removed } = installAll(projectDir, other || !isPackageDevCwd());
+console.log('\n  Installed:');
+for (const t of written)
+    console.log(`      ${t}`);
+if (removed.length) {
+    console.log('  Removed (replaced in 1.0):');
+    for (const r of removed)
+        console.log(`      ${r}`);
 }
+console.log('\n  Start a fresh Claude Code session in that project (trust the folder when asked), then run  /yt\n');

package/dist/lib/config.js

@@ -1,23 +1,26 @@
 /**
- * User preferences for yt-briefing — currently just the output language, decided at
- * onboarding and stored in DATA_DIR/config.json. Kept separate from .env on purpose:
+ * User preferences for yt-briefing — the output language (decided at onboarding) and an optional
+ * after-rate command, stored in DATA_DIR/config.json. Kept separate from .env on purpose:
  * .env holds secrets (API keys, proxy), config.json holds non-secret preferences that
- * both the engine and the agent (skill) read. The skill reads `output_lang` to ask the
- * rating question in the user's language; the engine reads it to write summaries in it.
+ * the engine reads. `output_lang` is the language summaries are written in; `after_rate` is a shell
+ * command run (detached, from the project root) after every recorded rating, e.g. a script that
+ * commits DATA_DIR to git. The engine itself never runs VCS; the command is yours.
  */
 import { readFileSync, existsSync } from 'node:fs';
 import { CONFIG_JSON } from "./paths.js";
 export function loadConfig() {
+    let c = {};
     if (existsSync(CONFIG_JSON)) {
         try {
-            const c = JSON.parse(readFileSync(CONFIG_JSON, 'utf8'));
-            if (typeof c.output_lang === 'string' && c.output_lang.trim()) {
-                return { output_lang: c.output_lang.trim() };
-            }
+            c = JSON.parse(readFileSync(CONFIG_JSON, 'utf8'));
         }
-        catch { /* malformed → fall through to env/default */ }
+        catch { /* malformed → defaults */ }
     }
-    return { output_lang: process.env.OUTPUT_LANG?.trim() || 'English' };
+    const lang = typeof c.output_lang === 'string' && c.output_lang.trim()
+        ? c.output_lang.trim()
+        : process.env.OUTPUT_LANG?.trim() || 'English';
+    const afterRate = typeof c.after_rate === 'string' && c.after_rate.trim() ? c.after_rate.trim() : undefined;
+    return { output_lang: lang, ...(afterRate ? { after_rate: afterRate } : {}) };
 }
 /** The language summaries and ratings are written in. Default English. */
 export const outputLang = () => loadConfig().output_lang;

package/dist/lib/distill.js

@@ -0,0 +1,44 @@
+/**
+ * Turn a raw rating comment ("too much politics, skip these panels") into what the profile
+ * stores: one clean, generalizable rule for `## Notes`, plus the rating it implies.
+ *
+ * This used to be the agent's job in the chat loop. With the rating loop in a pane there is no
+ * agent turn per video, so the engine does it with the same `claude -p` call it uses everywhere.
+ */
+import { chat } from "./llm.js";
+export function distillPrompt(comment, video) {
+    return `A user rating videos from the YouTube channel ${video.channel} left this comment on the video "${video.title}" (${video.type}):
+
+"""${comment}"""
+
+Turn it into ONE durable rule for this channel's profile — a standing instruction the briefing tool will follow for future videos of this channel (what to skip, what to keep, how to summarize). Generalize from this one video to the pattern the user means; keep the user's intent, drop chit-chat. Write the rule in the same language as the comment, one or two sentences.
+
+Also decide the rating for THIS video: 0 if the comment is clearly negative about it (worthless, noise, should have been skipped), otherwise 1.
+
+Output ONLY raw JSON, no fences: {"rating":0|1,"rule":"..."}`;
+}
+/** Parse the model's answer; null when it isn't the JSON asked for. */
+export function parseDistilled(out) {
+    const start = out.indexOf('{'), end = out.lastIndexOf('}');
+    if (start === -1 || end === -1)
+        return null;
+    try {
+        const d = JSON.parse(out.slice(start, end + 1));
+        const rule = typeof d.rule === 'string' ? d.rule.trim() : '';
+        if (!rule || (d.rating !== 0 && d.rating !== 1))
+            return null;
+        return { rating: d.rating, rule };
+    }
+    catch {
+        return null;
+    }
+}
+export async function distillComment(comment, video) {
+    const out = await chat(distillPrompt(comment, video), {
+        system: 'You turn user feedback into concise profile rules. Output only the JSON asked for.',
+    });
+    const d = parseDistilled(out);
+    if (!d)
+        throw new Error(`could not distill the comment: ${out.slice(0, 200)}`);
+    return d;
+}

package/dist/lib/env.js

@@ -18,7 +18,6 @@ export function loadEnv() {
     dotenv.config({ path: ROOT_ENV_PATH });
 }
 /** The required vars per capability — single source of truth for the preflight checks. */
-export const REQUIRED_LLM = ['YT_BRIEFING_LLM_BASE_URL', 'YT_BRIEFING_LLM_API_KEY', 'YT_BRIEFING_LLM_MODEL'];
 export const REQUIRED_YOUTUBE = ['YT_BRIEFING_YOUTUBE_API_KEY'];
 /** Names from `names` that are missing or empty in the environment, in order. */
 export function missingEnv(names) {