@gitroll/tacitt-cli 0.6.8 → 0.6.10

package/skills/tacitt/scripts/review.mjs

@@ -7,6 +7,7 @@ import {
   phaseOf,
   uncoveredPending,
 } from './journey-state.mjs'
+import { observeScanTiming } from './journey-scan-timing.mjs'
 import { startReviewStream } from './review-stream-client.mjs'
 import { createHash, randomUUID } from 'node:crypto'
 import {
@@ -19,6 +20,7 @@ import {
   readdir,
   realpath,
   rename,
+  stat,
   rm,
   writeFile,
 } from 'node:fs/promises'
@@ -48,13 +50,10 @@ const SLOTS = 16
 // While `--agents auto` waits, journey input (newly published sessions) is rechecked this often.
 const AUTO_RECHECK_MS = 3_000
 const PREPARATION_WAIT_MS = 60_000
-// `--agents auto` gathers this many free slots, waiting at most GATHER_MS after the first, so
-// one parent turn dispatches several children: each turn costs the parent seconds.
-const GATHER_SLOTS = 3
-const GATHER_MS = 10_000
-// A pack with no published answer this long after dispatch has likely lost its child (for
-// example to a parent restart); packs finished within about two minutes on the 2026-10-26 corpus.
-const STALE_MS = 300_000
+// Bound from reservation, allowing the observed long tail of completed children.
+const LOST_PACK_TIMEOUT_MS = 450_000
+// A current draft renews liveness independently of the reservation age.
+const DRAFT_HEARTBEAT_TIMEOUT_MS = 450_000
 const WRAP = 400
 // `review.terms` bounds: a value has 1–4000 code points, an exclusion reason 500.
 const TERM_CODE_POINTS = 4000
@@ -86,9 +85,21 @@ class HelperError extends Error {
     super(code)
     this.code = /^[A-Z_]{3,80}$/u.test(code) ? code : 'HELPER_FAILED'
     if (
-      code === 'INVALID_REVIEW_SPAN' &&
       typeof field === 'string' &&
-      /^terms\[\d+(?:,\d+){0,31}\]$/u.test(field)
+      ((code === 'INVALID_REVIEW_SPAN' && /^terms\[\d+(?:,\d+){0,31}\]$/u.test(field)) ||
+        (code === 'INVALID_SELECTION' &&
+          [
+            'cards.append.empty',
+            'cards.append.limit',
+            'cards.append.duplicate-card',
+            'cards.append.existing-card',
+            'cards.append.duplicate-extension',
+            'cards.append.unknown-card',
+            'cards.append.duplicate-term',
+            'cards.append.term-not-open',
+            'cards.append.own-identity-card',
+            'cards.append.other-person',
+          ].includes(field)))
     )
       this.field = field
   }
@@ -301,7 +312,17 @@ async function observe(ctx, readOnly = false) {
     ctx.state.preparationFailed = false
     if (ctx.state.reader) ctx.state.reader.waitingSince = null
   }
-  if (!readOnly) ctx.state.completedWorks = completedWorks
+  if (!readOnly) {
+    ctx.state.completedWorks = completedWorks
+    ctx.state.preparationBlocked = [
+      ...new Set([
+        ...(ctx.state.preparationBlocked ?? []),
+        ...view.works
+          .filter((work) => work.status === 'blocked')
+          .map((work) => `${work.id}:${work.inputRevision}`),
+      ]),
+    ]
+  }
   const works = Object.fromEntries(
     view.works.map((work) => [work.id, { inputRevision: work.inputRevision, access: work.access }]),
   )
@@ -587,7 +608,7 @@ const withAnswer = (task, text) => {
   // Each pack names its own draft so concurrent children never share a scratch file.
   const draft = resolve(task.replace(/\.md$/u, '.draft.json'))
   const command = `${shellQuote(process.execPath)} ${shellQuote(resolve(task.replace(/\.md$/u, '.publish.mjs')))} ${shellQuote(draft)}`
-  return `${text}\n\n## Your answer\n\nWrite the complete JSON object to ${draft} using your native file-edit tool. Publish it with this exact command:\n\n${command}\n\nThe CLI validates task coverage and every normalized term against the assigned review source before atomically publishing. Invalid source diagnostics identify normalized terms indices and a private normalized-answer receipt; read that receipt because these indices may differ from the original draft after splitting. Preserve supported findings, repair exact contiguous text, and explicitly report unsupported or context-only proposals. Never silently discard a finding to pass validation. Do not write the canonical answer yourself. Correct validation failures in your draft and retry the same command. Reply with only done after successful publication; otherwise report failure.\n`
+  return `${text}\n\n## Your answer\n\nAs soon as your reads return, overwrite ${draft} with {} again: the CLI treats this file as your progress signal and re-dispatches a task whose draft stops changing. Then write the complete JSON object to ${draft} using your native file-edit tool. Publish it with this exact command:\n\n${command}\n\nThe CLI validates task coverage and every normalized term against the assigned review source before atomically publishing. Invalid source diagnostics identify normalized terms indices and a private normalized-answer receipt; read that receipt because these indices may differ from the original draft after splitting. Preserve supported findings, repair exact contiguous text, and explicitly report unsupported or context-only proposals. Never silently discard a finding to pass validation. Do not write the canonical answer yourself. Correct validation failures in your draft and retry the same command. Reply with only done after successful publication; otherwise report failure.\n`
 }
 /** Validate a complete task answer before the publisher replaces any prior answer. */
 export function validatePrivacyAnswer(answer, unitRefs) {
@@ -656,7 +677,7 @@ function packPrompt(task, text) {
   const reads = plan.map(({ offset, limit }) => `(${offset},${limit})`).join(' ')
   // In the prompt itself, not a start file: given the plan indirectly, fast models read the
   // ranges one turn at a time and then reread them, and each extra turn costs seconds.
-  return `Your FIRST message must contain exactly ${plan.length} Read tool calls issued together in parallel on ${task} with these (offset, limit): ${reads}. Do not read it any other way. Allow 24000 output tokens per read; with functions.exec, start its code with // @exec: {"max_output_tokens": 24000} and set the nested exec_command max_output_tokens to 24000. Reread a refused or truncated range in smaller parts. Then follow that task exactly: author the JSON draft with your file-edit tool and run only its exact publisher command. Work alone. Reply done after successful publication.`
+  return `Your FIRST message must contain exactly ${plan.length} Read tool calls issued together in parallel on ${task} with these (offset, limit): ${reads}, plus one file-edit call that creates ${resolve(task.replace(/\.md$/u, '.draft.json'))} containing {} (your progress signal: a task whose draft stops changing is re-dispatched). Do not read it any other way. Allow 24000 output tokens per read; with functions.exec, start its code with // @exec: {"max_output_tokens": 24000} and set the nested exec_command max_output_tokens to 24000. Reread a refused or truncated range in smaller parts. Then follow that task exactly: author the JSON draft with your file-edit tool and run only its exact publisher command. Work alone. Reply done after successful publication.`
 }
 /** Writes a task and its publisher and returns the agent's prompt. */
 export async function writePackTask(task, text, unitRefs, sourceBatches = []) {
@@ -908,6 +929,8 @@ async function finishPack(ctx, meta) {
   ctx.state.queue.unshift(...requeue)
   meta.units = kept
   meta.state = kept.length ? 'open' : 'empty'
+  // The lease starts when the task is handed out, also for a pack resumed from dispatching.
+  meta.dispatchedAt = new Date().toISOString()
   meta.codePoints = batches.reduce(
     (total, item) => total + item.unit.coreCodePoints + item.unit.contextCodePoints,
     0,
@@ -958,7 +981,9 @@ async function waiting(ctx, pack) {
 /** Every open pack whose agent wrote its answer, or whose saved answer is not recorded yet. */
 async function ingestAll(ctx) {
   const changes = await observe(ctx)
+  await reclaimLostPacks(ctx)
   const ingested = []
+  const freedSlots = new Set((ctx.lost ?? []).map((pack) => pack.packId))
   let stopped = false
   const terms = { added: 0, kept: 0, unlocated: 0 }
   for (const pack of await readAll(join(ctx.run, 'packs'))) {
@@ -981,6 +1006,13 @@ async function ingestAll(ctx) {
       })
       continue
     }
+    if (
+      !pack.units.some(({ batchId }) => {
+        const unit = ctx.units.get(batchId)
+        return unit?.packId === pack.id && unit.state === 'dispatched'
+      })
+    )
+      freedSlots.add(pack.id)
     for (const key of Object.keys(terms)) terms[key] += result.terms[key]
     ingested.push({
       packId: pack.id,
@@ -1001,6 +1033,8 @@ async function ingestAll(ctx) {
   if (!paused(ctx) && !stopped && !overBudget(ctx)) await readNext(ctx)
   return {
     changes,
+    lost: ctx.lost ?? [],
+    freedSlots: [...freedSlots],
     ingested,
     terms,
     ...(await progressOf(ctx)),
@@ -1009,6 +1043,42 @@ async function ingestAll(ctx) {
     next: stopped ? 'ingest' : await suggest(ctx),
   }
 }
+async function scanTiming(ctx, cardAgents, ingestStartedAt) {
+  const receipt = await readJson(join(ctx.run, 'scan-timing.json'), null)
+  if (!receipt || receipt.completedAt) return
+  const packs = []
+  for (const pack of await readAll(join(ctx.run, 'packs'))) {
+    let publishedAt = null
+    try {
+      publishedAt = (await stat(answerPath(pack.retryTask ?? pack.task))).mtimeMs
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error
+    }
+    const active =
+      pack.state === 'open' &&
+      pack.units.some(({ batchId }) => {
+        const unit = ctx.units.get(batchId)
+        return unit?.packId === pack.id && unit.state === 'dispatched'
+      })
+    if ((active || publishedAt !== null) && Number.isFinite(Date.parse(pack.dispatchedAt)))
+      packs.push({ id: pack.id, dispatchedAt: pack.dispatchedAt, publishedAt })
+  }
+  await observeScanTiming(ctx.run, {
+    at: Date.now(),
+    ...(ingestStartedAt === undefined ? {} : { ingestStartedAt }),
+    packs,
+    activeCardChildren: cardAgents ?? receipt.measurements?.last?.activeCardChildren ?? 0,
+    queuedBatches: ctx.state.queue.length,
+    unreadBatches: ctx.state.reader?.remaining ?? 0,
+    waiting: ctx.state.reader?.waiting,
+    pendingWorkIds: ctx.view.works
+      .filter(
+        (work) =>
+          work.access !== 'drop' && work.rootSessionIds.length > 0 && work.status === 'pending',
+      )
+      .map((work) => work.id),
+  })
+}
 /** Refill only confirmed free native slots, after exact ingestion has settled. */
 async function ingestAndRefill(ctx, options) {
   const auto = options.agents === 'auto'
@@ -1017,16 +1087,18 @@ async function ingestAndRefill(ctx, options) {
     fail('INVALID_ARGUMENTS')
   const result = await ingestAll(ctx)
   const outstanding = await outstandingPacks(ctx)
-  const agents = auto ? Math.max(0, SLOTS - outstanding.length) : requested
-  const now = Date.now()
-  const stale = outstanding
-    .filter((pack) => now - Date.parse(pack.retryAt ?? pack.dispatchedAt) > STALE_MS)
-    .map((pack) => ({
-      packId: pack.id,
-      ageMs: now - Date.parse(pack.retryAt ?? pack.dispatchedAt),
-      prompt: pack.retryPrompt ?? pack.prompt,
-    }))
-  const slots = { ...(auto ? { freeSlots: agents } : {}), ...(stale.length ? { stale } : {}) }
+  const lostSlots = result.lost.length
+  const available = Math.max(
+    0,
+    SLOTS - outstanding.length - Number(options['card-agents'] ?? 0) - lostSlots,
+  )
+  const plannedAgents = result.cardBatch.ready
+    ? Math.min(available, Number(options['planned-card-agents'] ?? 1))
+    : 0
+  result.cardBatch.plannedAgents = plannedAgents
+  // An explicit count never takes live leases past the sixteen slots (ADR 0179).
+  const agents = auto ? available - plannedAgents : Math.min(requested, available - plannedAgents)
+  const slots = auto ? { freeSlots: agents } : {}
   const unsettled = result.ingested.some(
     (item) =>
       item.error ||
@@ -1082,19 +1154,22 @@ async function autoRefill(ctx, options) {
   // 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 batch already due wakes nothing more: it waits for a free slot like any refill.
+  const wake = () => (ctx.cardsDueAt > Date.now() ? 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, wake())
+    if (!lastPass) await gatherSlots(ctx, wake(), Number(options['card-agents'] ?? 0))
     const result = await ingestAndRefill(ctx, options)
     const idle =
       !result.ingested.length &&
+      !result.lost.length &&
       !result.packs.length &&
       !result.paused &&
       !result.continue &&
-      !result.cardBatch.ready &&
+      // A due batch with no slot to plan a child on keeps waiting instead of spinning.
+      !(result.cardBatch.ready && result.cardBatch.plannedAgents > 0) &&
       (result.next === 'wait-for-children' || result.next.startsWith('next-packs'))
     if (!idle || lastPass) return result
     if (Date.now() >= until) {
@@ -1109,19 +1184,83 @@ async function autoRefill(ctx, options) {
       )
   }
 }
-/** Wait, within `until`, for GATHER_SLOTS free slots or GATHER_MS after the first one frees. */
-async function gatherSlots(ctx, until) {
-  let firstFree = null
+/** Return at the first free slot; card deadlines still bound the wait. */
+async function gatherSlots(ctx, until, cardAgents = 0) {
   while (Date.now() < until) {
-    const free = SLOTS - (await outstandingPacks(ctx)).length
-    if (free >= GATHER_SLOTS) return
-    if (free > 0) {
-      firstFree ??= Date.now()
-      if (Date.now() - firstFree >= GATHER_MS) return
-    }
+    await reclaimLostPacks(ctx)
+    const free = SLOTS - cardAgents - (await outstandingPacks(ctx)).length - (ctx.lost?.length ?? 0)
+    if (ctx.lost?.length) return
+    if (free > 0) return
     await new Promise((done) => setTimeout(done, Math.max(1, Math.min(1_000, until - Date.now()))))
   }
 }
+/** Fence lost task identities before releasing their batch reservations; resume after a crash. */
+async function reclaimLostPacks(ctx) {
+  ctx.lost ??= []
+  // Lease ages are wall-clock. After a gap no helper observed (a suspended machine, a parent that
+  // stopped calling), every live lease restarts instead of all being lost at once.
+  const now = Date.now()
+  const gap = ctx.state.leaseCheckAt != null && now - ctx.state.leaseCheckAt > LOST_PACK_TIMEOUT_MS
+  if (gap) ctx.state.leaseRearmedAt = now
+  if (gap || ctx.state.leaseCheckAt == null || now - ctx.state.leaseCheckAt > 5_000) {
+    ctx.state.leaseCheckAt = now
+    await saveState(ctx)
+  }
+  for (const pack of await readAll(join(ctx.run, 'packs'))) {
+    if (pack.state !== 'lost') {
+      if (
+        pack.state !== 'open' ||
+        pack.repair ||
+        !pack.units.some(({ batchId }) => {
+          const unit = ctx.units.get(batchId)
+          return unit?.packId === pack.id && unit.state === 'dispatched'
+        }) ||
+        (await waiting(ctx, pack))
+      )
+        continue
+      const ageMs = now - Date.parse(pack.retryAt ?? pack.dispatchedAt)
+      // Each earlier reclaim of one of its batches doubles the bound (at most 4x), so a slow
+      // reader or a rate-limited account is not re-dispatched again and again.
+      const reclaims = Math.max(0, ...pack.units.map((u) => ctx.state.reclaims?.[u.batchId] ?? 0))
+      const bound = LOST_PACK_TIMEOUT_MS * 2 ** Math.min(reclaims, 2)
+      const since = Math.min(ageMs, now - (ctx.state.leaseRearmedAt ?? 0))
+      if (!(since >= bound)) continue
+      // A retained original draft cannot keep a later retry child alive.
+      const task = pack.retryTask ?? pack.task
+      try {
+        const draft = await stat(task.replace(/\.md$/u, '.draft.json'))
+        if (now - draft.mtimeMs < DRAFT_HEARTBEAT_TIMEOUT_MS) continue
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error
+      }
+      pack.state = 'lost'
+      pack.lostAt = new Date().toISOString()
+      pack.lostAgeMs = ageMs
+      await savePack(ctx, pack)
+    }
+    if (!pack.lostAcknowledgedAt) {
+      if (!ctx.lost.some((item) => item.packId === pack.id))
+        ctx.lost.push({ packId: pack.id, ageMs: pack.lostAgeMs })
+      continue
+    }
+    for (const { batchId } of pack.units) {
+      const unit = ctx.units.get(batchId)
+      if (unit?.packId !== pack.id || unit.state !== 'dispatched') continue
+      const batch = await loadBatch(ctx, batchId)
+      if (!batch) fail('CORRUPTED_STATE')
+      if (!ctx.state.queue.some((item) => item.batchId === batchId)) {
+        ctx.state.queue.push(queueItem(batch))
+        ctx.state.reclaims = {
+          ...ctx.state.reclaims,
+          [batchId]: (ctx.state.reclaims?.[batchId] ?? 0) + 1,
+        }
+        await saveState(ctx)
+      }
+      await rm(unitPath(ctx, batchId), { force: true })
+      ctx.units.delete(batchId)
+    }
+  }
+}
 async function answerPublished(ctx) {
   for (const pack of await readAll(join(ctx.run, 'packs')))
     if (await waiting(ctx, pack)) return true
@@ -1451,8 +1590,51 @@ async function progressOf(ctx) {
     blockedWorks: blockedWorks(view),
   }
 }
+function pendingPreparation(view, blocked = []) {
+  return view.works
+    .filter(
+      (work) =>
+        work.access !== 'drop' &&
+        work.rootSessionIds.length > 0 &&
+        work.status === 'pending' &&
+        (work.totalBatches === 0 || blocked.includes(`${work.id}:${work.inputRevision}`)),
+    )
+    .map((work) => `${work.id}:${work.inputRevision}:${work.revision}`)
+    .sort()
+    .join('|')
+}
 async function suggest(ctx, readOnly = false) {
   if (paused(ctx)) return 'paused'
+  // Retry changes revision but not inputRevision. Check pending input before the reading queue
+  // drains, once per transition (and once after the owned prepare completes).
+  const pending = pendingPreparation(ctx.view, ctx.state.preparationBlocked)
+  if (!readOnly && ctx.state.preparationBusyPending) {
+    ctx.state.preparationPending = pending || null
+    ctx.state.preparationBusyPending = false
+    await saveState(ctx)
+  }
+  // A live owned prepare admits newly pending Works through its read drain; its exit resets
+  // preparationPending, so anything it left pending is suggested then.
+  const ownedPrepareLive = ctx.state.preparationExitGeneration !== ctx.state.preparationGeneration
+  if (
+    ctx.state.preparationEverStarted &&
+    !ownedPrepareLive &&
+    pending &&
+    pending
+      .split('|')
+      .some((item) => !(ctx.state.preparationPending ?? '').split('|').includes(item)) &&
+    !ctx.state.preparationFailed
+  ) {
+    if (!readOnly) {
+      ctx.state.preparationPending = pending
+      await saveState(ctx)
+    }
+    return 'journey.prepare'
+  }
+  if (!readOnly && pending !== (ctx.state.preparationPending ?? '')) {
+    ctx.state.preparationPending = pending || null
+    await saveState(ctx)
+  }
   const packs = await readAll(join(ctx.run, 'packs'))
   for (const pack of packs) if (await waiting(ctx, pack)) return 'ingest'
   if (packs.some((pack) => pack.repair)) return 'repair-answer'
@@ -1553,14 +1735,33 @@ async function status(ctx) {
 async function prepareOutcome(ctx, options) {
   const { result, code } = options
   if (
-    !['busy', 'started', 'failed'].includes(result) ||
+    !['busy', 'started', 'completed', 'failed'].includes(result) ||
     (result === 'busy' && code !== 'DISCOVERY_BUSY') ||
-    (result === 'started' && code !== undefined) ||
+    (['started', 'completed'].includes(result) && code !== undefined) ||
     (result === 'failed' && (!/^[A-Z_]{3,80}$/u.test(code ?? '') || code === 'DISCOVERY_BUSY'))
   )
     fail('INVALID_ARGUMENTS')
-  ctx.state.preparationStarted = result === 'started'
+  if (result !== 'completed') ctx.state.preparationStarted = result === 'started'
+  if (result === 'started') {
+    ctx.state.preparationPending = pendingPreparation(
+      await call(ctx, 'journey.get', { journeyId: ctx.journeyId }),
+      ctx.state.preparationBlocked,
+    )
+    ctx.state.preparationEverStarted = true
+    ctx.state.preparationBusyPending = false
+    ctx.state.preparationGeneration = (ctx.state.preparationGeneration ?? 0) + 1
+  }
+  if (
+    result === 'completed' &&
+    ctx.state.preparationEverStarted &&
+    ctx.state.preparationExitGeneration !== ctx.state.preparationGeneration
+  ) {
+    ctx.state.preparationExitGeneration = ctx.state.preparationGeneration
+    ctx.state.preparationBusyPending = false
+    ctx.state.preparationPending = null
+  }
   if (result === 'busy') {
+    ctx.state.preparationBusyPending = true
     ctx.state.preparationRestarts = 0
     ctx.state.preparationFailed = false
   }
@@ -1639,6 +1840,9 @@ export async function main(argv) {
       run: { type: 'string' },
       journey: { type: 'string' },
       agents: { type: 'string' },
+      'card-agents': { type: 'string' },
+      'ack-lost': { type: 'string' },
+      'planned-card-agents': { type: 'string' },
       model: { type: 'string' },
       effort: { type: 'string' },
       input: { type: 'string' },
@@ -1656,6 +1860,23 @@ export async function main(argv) {
     const minimum = command === 'ingest' ? 0 : 1
     if (!Number.isInteger(agents) || agents < minimum || agents > SLOTS) fail('INVALID_ARGUMENTS')
   }
+  const cardAgents = Number(values['card-agents'] ?? 0)
+  if (
+    !Number.isInteger(cardAgents) ||
+    cardAgents < 0 ||
+    cardAgents > SLOTS ||
+    (values['card-agents'] !== undefined && !auto)
+  )
+    fail('INVALID_ARGUMENTS')
+  const plannedCardAgents = Number(values['planned-card-agents'] ?? 1)
+  if (
+    !Number.isInteger(plannedCardAgents) ||
+    plannedCardAgents < 1 ||
+    plannedCardAgents > SLOTS ||
+    (values['planned-card-agents'] !== undefined && !auto) ||
+    (values['ack-lost'] !== undefined && (command !== 'ingest' || positionals[1]))
+  )
+    fail('INVALID_ARGUMENTS')
   const waitMs = values['wait-ms'] === undefined ? 0 : Number(values['wait-ms'])
   if (!(Number.isInteger(waitMs) && waitMs >= 0) || (values['wait-ms'] !== undefined && !auto))
     fail('INVALID_ARGUMENTS')
@@ -1680,9 +1901,44 @@ export async function main(argv) {
     fail('INVALID_ARGUMENTS')
   const budget = values['budget-ms'] === undefined ? undefined : Number(values['budget-ms'])
   if (budget !== undefined && !(Number.isInteger(budget) && budget >= 0)) fail('INVALID_ARGUMENTS')
+  const started = Date.now()
   const ctx = await openRun(values.run, budget)
   try {
-    return { ...(await handler(ctx)), agentProfile: ctx.config.agentProfile }
+    if (values['ack-lost'] !== undefined) {
+      const ids = values['ack-lost'].split(',')
+      if (!ids.length || ids.some((id) => !/^[a-zA-Z0-9-]+$/u.test(id))) fail('INVALID_ARGUMENTS')
+      const packs = await readAll(join(ctx.run, 'packs'))
+      const acknowledged = ids.map((id) => packs.find((pack) => pack.id === id))
+      if (acknowledged.some((pack) => !pack || pack.state !== 'lost')) fail('UNKNOWN_PACK')
+      for (const pack of acknowledged) {
+        pack.lostAcknowledgedAt ??= new Date().toISOString()
+        await savePack(ctx, pack)
+      }
+    }
+    const result = await handler(ctx)
+    if (['ingest', 'next-packs'].includes(command) && ctx.view) {
+      try {
+        await scanTiming(
+          ctx,
+          command === 'ingest' ? cardAgents : undefined,
+          command === 'ingest' ? started : undefined,
+        )
+      } catch {
+        // Observability must never turn a committed ingest into a retryable failure.
+        console.error('SCAN_TIMING_FAILED')
+        try {
+          await timing(ctx, {
+            phase: 'local',
+            operation: 'scanTiming',
+            started: new Date(started),
+            outcome: 'SCAN_TIMING_FAILED',
+          })
+        } catch {
+          console.error('SCAN_TIMING_DIAGNOSTIC_FAILED')
+        }
+      }
+    }
+    return { ...result, agentProfile: ctx.config.agentProfile }
   } finally {
     await Promise.all((ctx.streams ?? []).map((item) => item.close()))
     await ctx.release()

package/LICENSE

@@ -1,11 +0,0 @@
-PROPRIETARY SOFTWARE — ALL RIGHTS RESERVED
-
-This repository is not licensed as open-source software. Except for permissions
-expressly granted by the applicable rights holders in a separate written agreement,
-no permission is granted to use, copy, modify, distribute, sublicense, or sell this
-software or substantial portions of it. Public access to source code does not itself
-grant such permission. Rights provided by applicable law or the hosting platform's
-terms are not limited by this notice.
-
-Third-party components remain subject to their respective licenses and notices.
-This notice does not replace or restrict permissions granted by those licenses.