yt-briefing 1.3.3 → 1.3.4

package/dist/cli.js

@@ -10,6 +10,7 @@
  *   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
+ *   yt-briefing sweep --pending            read-only: the video already shown and not yet rated
  *   yt-briefing rate --rating 0|1 [...]    record a rating for the pending video
  *   yt-briefing transcribe <url|id>        print a single video's transcript
  *   yt-briefing search "<intent>" --channel <@handle|url>   search within one channel → triage → compare

package/dist/yt-sweep.js

@@ -8,12 +8,14 @@
  *
  * Usage:
  *   bun src/yt-sweep.ts [--reset]
+ *   bun src/yt-sweep.ts --pending              (read-only: the video already emitted, still unrated)
  *   bun src/yt-sweep.ts --prefetch <videoId>   (internal: detached next-video warmup)
  *   bun src/yt-sweep.ts --fill                 (internal: detached queue builder)
  *
  * Output (stdout, single JSON line):
  *   {"status":"rating_needed","summary":"<md>","pending":{channel,videoId,title,type,publishedAt,is_baseline}}  (+ "lang")
  *   {"status":"done"}
+ *   {"status":"no_pending"}  (--pending only: no emitted video awaits a rating)
  *   {"status":"rate_limited"}
  *
  * The engine ONLY writes files under DATA_DIR — it never runs git or any VCS. If you
@@ -68,6 +70,7 @@ const CONCURRENCY = 6;
 const argv = process.argv.slice(2);
 const reset = argv.includes('--reset');
 const fillMode = argv.includes('--fill');
+const pendingMode = argv.includes('--pending');
 const pfIdx = argv.indexOf('--prefetch');
 const prefetchTarget = pfIdx !== -1 ? argv[pfIdx + 1] : null;
 const today = new Date().toISOString().slice(0, 10);
@@ -458,6 +461,13 @@ async function processItem(item) {
         return { kind: 'skip', status: 'content_skip', reason: summary.slice(9).trim() };
     return { kind: 'ratable', summary };
 }
+/** The video's metadata as `rating_needed` reports it and yt-rating reads it from pending.json. */
+function pendingOf(item) {
+    return {
+        channel: item.channel, videoId: item.videoId, title: item.title,
+        type: item.type, publishedAt: item.publishedAt, is_baseline: item.is_baseline,
+    };
+}
 async function advance(queue) {
     while (true) {
         // Pull in the background fill (or expand a channel ourselves) until there's an
@@ -472,8 +482,8 @@ async function advance(queue) {
             dropHead(queue);
             continue;
         }
-        // Already emitted (the plugin re-runs the sweep after the briefing turn to open the rating
-        // dialog) or warmed by the background child? Use it and skip the live fetch + content filter.
+        // Already emitted (a repeat sweep before the rating) or warmed by the background child? Use it
+        // and skip the live fetch + content filter.
         const emitted = loadCachedSummary(PENDING_FILE, item.videoId);
         const cached = emitted ?? loadPrefetch(item.videoId);
         if (cached)
@@ -497,10 +507,7 @@ async function advance(queue) {
         }
         // Ratable — hand off to the frontend. Leave item at queue head (rating bumps state,
         // next call detects pointer === videoId and drops it).
-        const pending = {
-            channel: item.channel, videoId: item.videoId, title: item.title,
-            type: item.type, publishedAt: item.publishedAt, is_baseline: item.is_baseline,
-        };
+        const pending = pendingOf(item);
         writeAtomic(PENDING_FILE, { ...pending, summary: result.summary, built_at: today });
         writeFileSync(QUEUE_FILE, JSON.stringify(queue));
         // Warm the NEXT video in the background while the user rates this one. A repeat emit of the
@@ -516,6 +523,21 @@ async function advance(queue) {
     clearPrefetch();
     emit({ status: 'done' });
 }
+/**
+ * --pending mode: the video the sweep already emitted, if it still awaits a rating. The plugin asks
+ * this after a briefing turn to open the rating dialog. Read-only and offline on purpose: a real
+ * sweep there rebuilt the queue once `done` had removed it, and the dialog then asked about a new
+ * video the chat never showed.
+ */
+function runPending() {
+    const queue = loadQueue();
+    const head = queue?.items[0];
+    const summary = head && loadCachedSummary(PENDING_FILE, head.videoId);
+    if (!queue || !head || !summary || isResolved(statePointer(head), head.videoId, queue.seen)) {
+        emit({ status: 'no_pending' });
+    }
+    emit({ status: 'rating_needed', summary, pending: pendingOf(head), lang: LANG });
+}
 /**
  * --prefetch mode: compute the summary for one specific queued video and cache it, with
  * NO side effects on state.md / queue / pending. Runs detached while the user rates the
@@ -573,6 +595,9 @@ if (prefetchTarget) {
 if (fillMode) {
     await runFill(); // detached background queue builder — never returns
 }
+if (pendingMode) {
+    runPending(); // read-only answer for the rating dialog — never returns
+}
 if (reset) {
     if (existsSync(QUEUE_FILE))
         rmSync(QUEUE_FILE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yt-briefing",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "A self-learning YouTube briefing for Claude Code: it sweeps the channels you follow, filters noise in two stages (title, then transcript), gives you a short briefing of the rest in your language in the chat, and adapts to your ratings — one video at a time.",
   "type": "module",
   "bin": {

package/plugin/hooks/register.tsx

@@ -8,8 +8,10 @@ import { engine } from './engine.ts'
 // a phone; the rating dialog opens once that turn has ended. Ratings and comments are written by
 // the engine, never by this module.
 
-/** A sweep can expand channels, fetch transcripts and summarize; give it the engine's full budget. */
+/** A sweep can expand channels, fetch transcripts and summarize; the model's call gets this budget. */
 const SWEEP_MS = 10 * 60_000
+/** Local files only, no network. */
+const PENDING_MS = 30_000
 /** A rating is a file write; a raw comment adds one `claude -p` call to distill it. */
 const RATE_MS = 3 * 60_000
 
@@ -26,9 +28,9 @@ function parseOut(stdout: string): SweepOut {
   return JSON.parse(line) as SweepOut
 }
 
-/** One engine sweep: the next ratable video, or the end state. Throws when the engine does not answer. */
-async function runSweep($: EngineInterface): Promise<SweepOut> {
-  const run = await $.process.run(engine('yt-sweep'), { timeoutMs: SWEEP_MS })
+/** The video this run already showed and not yet rated. Never a real sweep: that could fetch a new one. */
+async function shownVideo($: EngineInterface): Promise<SweepOut> {
+  const run = await $.process.run([...engine('yt-sweep'), '--pending'], { timeoutMs: PENDING_MS })
   return parseOut(run.stdout)
 }
 
@@ -93,7 +95,7 @@ function loopSection(): string {
   const sweep = engine('yt-sweep').join(' ')
   return [
     `The yt-briefing plugin is running the person's YouTube briefing. A user message reading exactly "${FIRST_TEXT}" or "${NEXT_TEXT}" is its request for the next video:`,
-    `for "${FIRST_TEXT}" run \`${sweep} --reset\`, for "${NEXT_TEXT}" run \`${sweep}\`; it prints one JSON line. If \`status\` is \`rating_needed\`, answer with \`summary\` verbatim as your whole message, Markdown kept: nothing before or after it, no question, no tool call after it (the plugin opens the rating dialog itself).`,
+    `for "${FIRST_TEXT}" run \`${sweep} --reset\`, for "${NEXT_TEXT}" run \`${sweep}\`, in the foreground with a ${SWEEP_MS / 60_000}-minute timeout; it prints one JSON line. If \`status\` is \`rating_needed\`, answer with \`summary\` verbatim as your whole message, Markdown kept: nothing before or after it, no question, no tool call after it (the plugin opens the rating dialog itself).`,
     'Otherwise answer with one short line saying why there is nothing to rate. Write in the language of the summaries.',
   ].join('\n')
 }
@@ -110,9 +112,10 @@ function submitLater($: EngineInterface, reset: boolean) {
 async function rateAfterTurn($: EngineInterface) {
   let out: SweepOut
   try {
-    out = await runSweep($)
-  } catch {
+    out = await shownVideo($)
+  } catch (err) {
     looping = false
+    $.ui.toast(`Could not open the rating: ${String(err).slice(0, 200)}`)
     return
   }
   if (out.status !== 'rating_needed' || !out.pending || !out.summary) {