@gitroll/tacitt-cli 0.4.1 → 0.4.2

package/skills/tacitt/scripts/review.mjs

@@ -1,4 +1,11 @@
-import { cardBatchOpen, phaseOf, uncoveredPending } from './journey-state.mjs'
+import {
+  cardBatch,
+  cardBatchDue,
+  cardBatchDueAt,
+  nextCardsWait,
+  phaseOf,
+  uncoveredPending,
+} from './journey-state.mjs'
 import { startReviewStream } from './review-stream-client.mjs'
 import { createHash, randomUUID } from 'node:crypto'
 import {
@@ -1071,17 +1078,22 @@ async function outstandingPacks(ctx) {
  */
 async function autoRefill(ctx, options) {
   const until = Math.min(Date.now() + Number(options['wait-ms'] ?? 0), ctx.readDeadline)
+  // ADR 0234: a card batch can come due on time alone; neither gathering slots nor waiting for a
+  // child holds it back past that time.
+  await progressOf(ctx)
+  const wake = () => Math.min(until, ctx.cardsDueAt ?? until)
   // A slow pass can outlast the wait while a child publishes; ingest that answer once more
   // rather than returning idle and leaving its slot unused until the next call.
   let lastPass = false
   for (;;) {
-    if (!lastPass) await gatherSlots(ctx, until)
+    if (!lastPass) await gatherSlots(ctx, wake())
     const result = await ingestAndRefill(ctx, options)
     const idle =
       !result.ingested.length &&
       !result.packs.length &&
       !result.paused &&
       !result.continue &&
+      !result.cardBatch.ready &&
       (result.next === 'wait-for-children' || result.next.startsWith('next-packs'))
     if (!idle || lastPass) return result
     if (Date.now() >= until) {
@@ -1089,7 +1101,7 @@ async function autoRefill(ctx, options) {
       lastPass = true
       continue
     }
-    const recheck = Math.min(until, Date.now() + AUTO_RECHECK_MS)
+    const recheck = Math.min(wake(), Date.now() + AUTO_RECHECK_MS)
     while (Date.now() < recheck && !(await answerPublished(ctx)))
       await new Promise((done) =>
         setTimeout(done, Math.max(1, Math.min(LOCK_POLL_MS, recheck - Date.now()))),
@@ -1411,11 +1423,30 @@ export function questionsReady(view) {
 async function progressOf(ctx) {
   const view = await call(ctx, 'journey.get', { journeyId: ctx.journeyId })
   const uncovered = uncoveredPending(view).length
+  const { directory, open } = await cardBatch(ctx.run)
+  const now = Date.now()
+  // ADR 0234: the wait clock restarts after every batch, even one no call saw open.
+  const wait = nextCardsWait(ctx.state.cardsWait, { uncovered, open, batch: directory, now })
+  const previous = ctx.state.cardsWait
+  if (wait.since !== previous?.since || wait.batch !== previous?.batch) {
+    ctx.state.cardsWait = wait
+    await saveState(ctx)
+  }
+  const input = {
+    uncovered,
+    open,
+    readingComplete: view.readingComplete,
+    cards: view.privacy.cards.length,
+    waitingSince: wait.since,
+    now,
+  }
+  const ready = cardBatchDue(input)
+  // `--agents auto` ends its wait when the clock alone makes the batch due.
+  ctx.cardsDueAt = cardBatchDueAt(input)
   return {
     readingComplete: view.readingComplete,
     questionsReady: questionsReady(view),
-    // E3: a card is raised as soon as a value needs one, unless a batch is still being drafted.
-    cardBatch: { uncovered, ready: uncovered > 0 && !(await cardBatchOpen(ctx.run)) },
+    cardBatch: { uncovered, ready },
     works: workProgress(view),
     blockedWorks: blockedWorks(view),
   }