@djolex999/vir-cli 0.13.0 → 0.14.1

package/dist/pipeline/run.js

@@ -3,7 +3,7 @@ import { appendFileSync } from "node:fs";
 import { DAEMON_LOG_PATH, ensureVirDir } from "../config.js";
 import { StateDb } from "../state/db.js";
 import * as ui from "../ui/display.js";
-import { Distiller, normalizeModelName, resolveModelShorthand, } from "./distiller.js";
+import { Distiller, maybeAnthropicClient, normalizeModelName, probeProvider, resolveModelShorthand, } from "./distiller.js";
 import { computeCost } from "../cost/pricing.js";
 import { scoreSession } from "./filter.js";
 import { parseSession } from "./parser.js";
@@ -12,6 +12,19 @@ import { scanArticles } from "./articleReader.js";
 import { distillArticle } from "./articleDistiller.js";
 import { parsePdf, scanPdfs } from "./pdfReader.js";
 import { distillPdf } from "./pdfDistiller.js";
+import { classifyTranscript, decideProject, groupByProject, estimateSessionCost, readTranscriptHead, sniffAgentEntrypoint, } from "./projects.js";
+// A row that holds a successfully distilled note. Neither filter may
+// overwrite one: flipping it to skipped=1 would silently hide the note from
+// listDistilled/embeddings/rewrite — a semi-prune, and both filters are
+// forward-looking only. (Excluding stops FUTURE distills; it never touches
+// what already exists.)
+function isDistilledRow(row) {
+    return (row !== undefined &&
+        row.skipped === 0 &&
+        row.error === null &&
+        row.content !== null &&
+        row.content !== "");
+}
 import { scrub } from "./scrubber.js";
 import { summarizeProject } from "./summarizer.js";
 import { filterToolCalls } from "./toolCallFilter.js";
@@ -26,6 +39,19 @@ export function estimatePerDocDistillCost(cfg, classifyModel, distillModel) {
     return (computeCost(cfg.provider, classifyModel, Math.ceil(3000 / CPT), 200, cfg.pricing, cfg.kieTopUpTier) +
         computeCost(cfg.provider, distillModel, Math.ceil(24_000 / CPT), 1500, cfg.pricing, cfg.kieTopUpTier));
 }
+// The run log is the audit trail for spend, and spend happens in every mode —
+// so this is UNGATED: interactive runs log exactly like daemon runs. (It was
+// once gated behind a daemon-only flag; an interactive run that distilled 6
+// sessions left no trace and produced two wrong diagnoses.) Best-effort:
+// logging must never fail a run.
+export function appendRunLog(msg, logPath = DAEMON_LOG_PATH) {
+    try {
+        appendFileSync(logPath, `[${new Date().toISOString()}] ${msg}\n`);
+    }
+    catch {
+        // ignore log errors
+    }
+}
 export async function runPipeline(cfg, opts = {}) {
     ensureVirDir();
     const db = new StateDb();
@@ -37,6 +63,12 @@ export async function runPipeline(cfg, opts = {}) {
         distilled: 0,
         lowConfidence: 0,
         errored: 0,
+        projectExcluded: 0,
+        projectPending: 0,
+        flagSkipped: 0,
+        workflowSkipped: 0,
+        sidechainSkipped: 0,
+        agentSkipped: 0,
         rewritten: 0,
         notesWritten: [],
         articlesScanned: 0,
@@ -49,17 +81,7 @@ export async function runPipeline(cfg, opts = {}) {
         pdfsErrored: 0,
     };
     const interactive = !opts.quiet;
-    // File-only logging — used for the daemon run.log regardless of UI mode.
-    const fileLog = (msg) => {
-        if (!opts.logToFile)
-            return;
-        try {
-            appendFileSync(DAEMON_LOG_PATH, `[${new Date().toISOString()}] ${msg}\n`);
-        }
-        catch {
-            // ignore log errors
-        }
-    };
+    const fileLog = (msg) => appendRunLog(msg);
     if (interactive) {
         ui.header(opts.dryRun
             ? "run  --dry-run"
@@ -248,16 +270,145 @@ export async function runPipeline(cfg, opts = {}) {
     fileLog(`scanned ${discovered.length} jsonl files`);
     if (interactive)
         ui.blank();
+    // ── transcript-category filter (SCAN phase, upstream of projects) ────────
+    // Nested workflow/sidechain transcripts are agent-internal execution, not
+    // user knowledge — with the default "exclude" they're gated out before
+    // grouping, so they never count as project sessions, pending spend, or
+    // paid work. Rows are recorded (never silent) except under --dry-run,
+    // which must stay side-effect free.
+    let sessionsInScope = discovered;
+    if (cfg.workflowTranscripts !== "include") {
+        sessionsInScope = [];
+        for (const s of discovered) {
+            const cat = classifyTranscript(s.path, cfg.claudeProjectsDir);
+            if (cat === "session") {
+                sessionsInScope.push(s);
+                continue;
+            }
+            const reason = cat === "workflow" ? "workflow-transcript" : "sidechain-transcript";
+            if (cat === "workflow")
+                summary.workflowSkipped += 1;
+            else
+                summary.sidechainSkipped += 1;
+            if (!opts.dryRun) {
+                const existing = db.getByPath(s.path);
+                if (!isDistilledRow(existing) &&
+                    (existing?.hash !== s.hash || existing?.skip_reason !== reason)) {
+                    db.record({
+                        path: s.path,
+                        hash: s.hash,
+                        skipped: true,
+                        notePaths: [],
+                        skipReason: reason,
+                    });
+                }
+            }
+        }
+        const filtered = summary.workflowSkipped + summary.sidechainSkipped;
+        if (filtered > 0) {
+            const msg = `${filtered} agent-internal transcript(s) excluded (${summary.workflowSkipped} workflow, ${summary.sidechainSkipped} sidechain) — workflowTranscripts: exclude`;
+            if (interactive)
+                ui.line(ui.dim(`  ${msg}`));
+            fileLog(msg);
+        }
+    }
+    // ── agent-transcript filter (SCAN phase, its own knob) ───────────────────
+    // Top-level SDK-launched harness agents (review/verify) — detected by the
+    // first user line's entrypoint starting with "sdk". Head-read only; a
+    // truncated or unreadable head falls through to the parser backstop below,
+    // still before any paid call.
+    if (cfg.agentTranscripts !== "include") {
+        const stillHuman = [];
+        for (const s of sessionsInScope) {
+            const entrypoint = sniffAgentEntrypoint(readTranscriptHead(s.path));
+            if (entrypoint === null) {
+                stillHuman.push(s);
+                continue;
+            }
+            summary.agentSkipped += 1;
+            if (!opts.dryRun) {
+                const existing = db.getByPath(s.path);
+                if (!isDistilledRow(existing) &&
+                    (existing?.hash !== s.hash ||
+                        existing?.skip_reason !== "agent-transcript")) {
+                    db.record({
+                        path: s.path,
+                        hash: s.hash,
+                        skipped: true,
+                        notePaths: [],
+                        skipReason: "agent-transcript",
+                        entrypoint,
+                    });
+                }
+            }
+        }
+        sessionsInScope = stillHuman;
+        if (summary.agentSkipped > 0) {
+            const msg = `${summary.agentSkipped} SDK-launched agent transcript(s) excluded — agentTranscripts: exclude`;
+            if (interactive)
+                ui.line(ui.dim(`  ${msg}`));
+            fileLog(msg);
+        }
+    }
+    // ── project filter (SCAN phase — before any paid call) ───────────────────
+    // Decisions live in cfg.projects; absent = undecided, a real visible state.
+    // Filtering here is load-bearing: classify is a paid Haiku call per new
+    // session, so excluded/pending sessions must never reach the distiller.
+    const projectFlags = {
+        only: opts.onlyProjects,
+        excludeProject: opts.excludeProjects,
+    };
+    const projectGroups = groupByProject(sessionsInScope, cfg.claudeProjectsDir);
+    const projectOf = new Map();
+    for (const group of projectGroups.values()) {
+        for (const s of group.sessions)
+            projectOf.set(s.path, group.name);
+    }
+    let projectDecisions = {
+        ...cfg.projects,
+    };
+    const decisionFor = (path) => decideProject(projectOf.get(path) ?? "", projectDecisions, projectFlags);
+    // Undecided projects holding NEW sessions are a spend decision with a
+    // deadline (Claude Code prunes transcripts at ~30 days). Interactive
+    // callers inject onUndecidedProjects and get asked once; the daemon path
+    // records pending rows and notifies instead — it must never prompt.
+    const classifyModelId = normalizeModelName(cfg.models.classify, cfg.provider);
+    const distillModelId = normalizeModelName(resolveModelShorthand(opts.forceDistillModel ?? cfg.models.distill), cfg.provider);
+    const pendingProjects = [];
+    for (const group of projectGroups.values()) {
+        if (decideProject(group.name, projectDecisions, projectFlags) !== "pending")
+            continue;
+        const fresh = group.sessions.filter((s) => opts.full === true || !db.isProcessed(s.path, s.hash));
+        if (fresh.length === 0)
+            continue;
+        const totalBytes = fresh.reduce((sum, s) => sum + s.size, 0);
+        pendingProjects.push({
+            name: group.name,
+            sessionCount: fresh.length,
+            totalBytes,
+            estCost: fresh.reduce((sum, s) => sum +
+                estimateSessionCost(cfg.provider, classifyModelId, distillModelId, s.size, cfg.pricing, cfg.kieTopUpTier), 0),
+        });
+    }
+    if (pendingProjects.length > 0 && opts.onUndecidedProjects && !opts.dryRun) {
+        const answers = await opts.onUndecidedProjects(pendingProjects.sort((a, b) => b.estCost - a.estCost));
+        projectDecisions = { ...projectDecisions, ...answers };
+    }
     // Precompute how many sessions actually need LLM work so the CLI can show
     // an accurate cost confirmation before we hit the API. Also surfaces the
     // found/cached/new breakdown so a fresh DB never silently looks like a
     // stale-cache no-op (the symptom of the state.db → vir.db rename bug).
     let preflightNew = 0;
-    for (const found of discovered) {
+    let preflightFiltered = 0;
+    for (const found of sessionsInScope) {
+        if (decisionFor(found.path) !== "include") {
+            preflightFiltered += 1;
+            continue;
+        }
         if (opts.full || !db.isProcessed(found.path, found.hash))
             preflightNew += 1;
     }
-    const cached = discovered.length - preflightNew;
+    const cached = sessionsInScope.length - preflightNew - preflightFiltered;
     // Notes distilled but never embedded (write-time Ollama outage) — surfaced so
     // a retrieval blind spot is visible, not silent. Counts all three embeddable
     // layers (sessions + topics + articles) so the preflight matches exactly what
@@ -268,12 +419,23 @@ export async function runPipeline(cfg, opts = {}) {
         db.listPdfEmbeddingTargets().length;
     if (interactive) {
         ui.line(ui.dim(`  ${discovered.length} files found  ·  ${cached} cached  ·  ${preflightNew} new` +
+            (preflightFiltered > 0
+                ? `  ·  ${preflightFiltered} project-filtered`
+                : "") +
             (pendingEmbedding > 0
                 ? `  ·  ${pendingEmbedding} pending embedding`
                 : "")));
         ui.blank();
     }
-    fileLog(`preflight: found=${discovered.length} cached=${cached} new=${preflightNew} pendingEmbedding=${pendingEmbedding}`);
+    fileLog(`preflight: found=${discovered.length} cached=${cached} new=${preflightNew} projectFiltered=${preflightFiltered} pendingEmbedding=${pendingEmbedding}`);
+    // 0.14.0 changed the default provider to anthropic (claude-sonnet-5). A kie
+    // config keeps working exactly as configured — someone's config is not ours
+    // to change — but surface the default change once per interactive run so
+    // users who only ever accepted the old init default know the ground moved.
+    if (interactive && cfg.provider === "kie") {
+        ui.line(ui.dim("  Note: the default provider is now anthropic (claude-sonnet-5). Your 'kie' setting is unchanged — run vir init to switch."));
+        ui.blank();
+    }
     // Nudge session-only installs toward hybrid routing. interactive is already
     // false under --quiet/--daemon, so this never prints on the daemon path.
     if (interactive && !cfg.models.distillFast) {
@@ -287,15 +449,28 @@ export async function runPipeline(cfg, opts = {}) {
     // the estimate lands in the right ballpark instead of ~5x low. Still rough —
     // deep sessions vary, and low-confidence drops aren't knowable without the LLM.
     if (opts.dryRun) {
-        const classifyModel = normalizeModelName(cfg.models.classify, cfg.provider);
-        const distillModel = normalizeModelName(resolveModelShorthand(opts.forceDistillModel ?? cfg.models.distill), cfg.provider);
+        const classifyModel = classifyModelId;
+        const distillModel = distillModelId;
         const CLASSIFY_OUTPUT_TOKENS = 350;
         const DISTILL_OUTPUT_TOKENS = 4500;
         const CHARS_PER_TOKEN = 3;
         let totalCost = 0;
         let estimated = 0;
         let filteredOut = 0;
-        for (const found of discovered) {
+        let dryExcluded = 0;
+        let dryPending = 0;
+        for (const found of sessionsInScope) {
+            // Project-filtered sessions are outside the estimate: they will not be
+            // distilled as things stand. Counted separately so they're never a
+            // silent omission from the preview.
+            const decision = decisionFor(found.path);
+            if (decision !== "include") {
+                if (decision === "exclude")
+                    dryExcluded += 1;
+                else if (decision === "pending")
+                    dryPending += 1;
+                continue;
+            }
             if (!opts.full && db.isProcessed(found.path, found.hash))
                 continue;
             let parsed;
@@ -324,12 +499,31 @@ export async function runPipeline(cfg, opts = {}) {
         if (interactive) {
             ui.blank();
             ui.divider();
-            ui.summary({
+            const dryStats = {
                 sessions: { value: estimated, color: ui.info },
                 "filtered out": { value: filteredOut, color: ui.dim },
-                "est. total": { value: ui.formatUsd(totalCost), color: ui.warn },
-            });
+            };
+            if (dryExcluded > 0) {
+                dryStats.excluded = { value: dryExcluded, color: ui.dim };
+            }
+            if (dryPending > 0) {
+                dryStats.undecided = { value: dryPending, color: ui.warn };
+            }
+            if (summary.workflowSkipped + summary.sidechainSkipped > 0) {
+                dryStats.workflow = {
+                    value: summary.workflowSkipped + summary.sidechainSkipped,
+                    color: ui.dim,
+                };
+            }
+            if (summary.agentSkipped > 0) {
+                dryStats.agent = { value: summary.agentSkipped, color: ui.dim };
+            }
+            dryStats["est. total"] = { value: ui.formatUsd(totalCost), color: ui.warn };
+            ui.summary(dryStats);
             ui.divider();
+            if (dryPending > 0) {
+                ui.line(ui.dim(`  ${dryPending} session(s) in undecided projects — run vir projects to include/exclude them`));
+            }
             ui.line(ui.dim("  estimates assume typical output sizes; actuals may vary ±30%"));
         }
         // PDFs are estimated separately: papers exceed the 24k-char distill cap, so
@@ -345,7 +539,7 @@ export async function runPipeline(cfg, opts = {}) {
                 fileLog(`dry-run: newPdfs=${newPdfs} perPdf=${ui.formatUsd(perPdf)} estTotal=${ui.formatUsd(perPdf * newPdfs)}`);
             }
         }
-        fileLog(`dry-run: sessions=${estimated} filtered=${filteredOut} estTotal=${ui.formatUsd(totalCost)}`);
+        fileLog(`dry-run: sessions=${estimated} filtered=${filteredOut} excluded=${dryExcluded} pending=${dryPending} estTotal=${ui.formatUsd(totalCost)}`);
         db.close();
         return summary;
     }
@@ -357,8 +551,52 @@ export async function runPipeline(cfg, opts = {}) {
             return summary;
         }
     }
-    for (const found of discovered) {
+    // One cheap probe before the loop: a provider-wide outage should be ONE
+    // clear failure, not N sessions each burning full retry chains and
+    // attempt-counter increments. Skipped when there is nothing to distill.
+    if (preflightNew > 0) {
         try {
+            await probeProvider(cfg, maybeAnthropicClient(cfg));
+        }
+        catch (err) {
+            const msg = err.message ?? String(err);
+            fileLog(`provider preflight failed: ${msg}`);
+            if (interactive) {
+                ui.row(ui.errorColor(ui.CROSS), ui.text(`provider ${cfg.provider} unreachable — ${msg}`));
+            }
+            db.close();
+            throw new Error(`provider ${cfg.provider} unreachable (preflight probe failed): ${msg}`);
+        }
+    }
+    for (const found of sessionsInScope) {
+        try {
+            // Project filter FIRST — before the cache check and long before any
+            // paid call. Every config-driven skip gets its DB row and reason;
+            // one-off flag skips record nothing (they say nothing about state).
+            const decision = decisionFor(found.path);
+            if (decision === "flag-skip") {
+                summary.flagSkipped += 1;
+                continue;
+            }
+            if (decision === "exclude" || decision === "pending") {
+                const reason = decision === "exclude" ? "project-excluded" : "project-pending";
+                if (decision === "exclude")
+                    summary.projectExcluded += 1;
+                else
+                    summary.projectPending += 1;
+                const existing = db.getByPath(found.path);
+                if (!isDistilledRow(existing) &&
+                    (existing?.hash !== found.hash || existing?.skip_reason !== reason)) {
+                    db.record({
+                        path: found.path,
+                        hash: found.hash,
+                        skipped: true,
+                        notePaths: [],
+                        skipReason: reason,
+                    });
+                }
+                continue;
+            }
             if (!opts.full && db.isProcessed(found.path, found.hash)) {
                 summary.alreadyProcessed += 1;
                 continue;
@@ -373,6 +611,45 @@ export async function runPipeline(cfg, opts = {}) {
                 continue;
             }
             const parsed = parseSession(found.path, found.hash);
+            // Parser backstop for the transcript-category filter: a sidechain by
+            // CONTENT (isSidechain in the JSONL) that structural detection missed
+            // — e.g. a future layout change — still stops before any paid call.
+            if (cfg.workflowTranscripts !== "include" && parsed.isSidechain) {
+                summary.sidechainSkipped += 1;
+                // Same no-overwrite rule as the structural gate: a changed transcript
+                // whose row already holds a distilled note keeps that note visible.
+                if (!isDistilledRow(db.getByPath(found.path))) {
+                    db.record({
+                        path: found.path,
+                        hash: found.hash,
+                        skipped: true,
+                        notePaths: [],
+                        skipReason: "sidechain-transcript",
+                    });
+                }
+                fileLog(`sidechain by content, skipping: ${found.path}`);
+                continue;
+            }
+            // Agent-transcript backstop: the SDK launch signature seen by the full
+            // parse when the scan-time head sniff missed it (truncated head, field
+            // moved). Still pre-classify, so still free.
+            if (cfg.agentTranscripts !== "include" &&
+                typeof parsed.entrypoint === "string" &&
+                parsed.entrypoint.startsWith("sdk")) {
+                summary.agentSkipped += 1;
+                if (!isDistilledRow(db.getByPath(found.path))) {
+                    db.record({
+                        path: found.path,
+                        hash: found.hash,
+                        skipped: true,
+                        notePaths: [],
+                        skipReason: "agent-transcript",
+                        entrypoint: parsed.entrypoint,
+                    });
+                }
+                fileLog(`sdk agent by content, skipping: ${found.path}`);
+                continue;
+            }
             const filter = scoreSession(parsed, cfg.filterThreshold);
             if (!filter.passes) {
                 summary.skippedByFilter += 1;
@@ -421,12 +698,13 @@ export async function runPipeline(cfg, opts = {}) {
                 project: note.classification.project,
                 confidence: note.classification.confidence,
                 startedAt: parsed.startedAt,
+                entrypoint: parsed.entrypoint,
             });
             if (interactive) {
                 ui.categoryRow(note.classification.category, note.classification.topic);
             }
             fileLog(`distilled ${parsed.sessionId.slice(0, 8)} → ${note.classification.category}/${note.classification.topic}`);
-            if (note.classification.confidence >= 0.8) {
+            if (note.classification.confidence >= 0.8 && cfg.notifications !== false) {
                 notify(`Vir — new ${note.classification.category}`, `${note.classification.topic} · ${note.classification.project}`);
             }
             const slug = kebab(note.classification.project);
@@ -469,6 +747,24 @@ export async function runPipeline(cfg, opts = {}) {
             fileLog(`summary failed for project/${slug}: ${msg}`);
         }
     }
+    // Surface undecided projects — one log line and (config-gated) one macOS
+    // notification. Never a prompt: this is the daemon-safe path. Recomputed
+    // post-loop so interactively answered projects don't re-notify.
+    if (summary.projectPending > 0) {
+        const stillPending = new Set();
+        for (const group of projectGroups.values()) {
+            if (decideProject(group.name, projectDecisions, projectFlags) === "pending") {
+                stillPending.add(group.name);
+            }
+        }
+        const msg = `${summary.projectPending} session(s) across ${stillPending.size} project(s) awaiting include/exclude decision — run vir projects`;
+        fileLog(msg);
+        if (interactive)
+            ui.line(ui.dim(`  ${msg}`));
+        if (cfg.notifications !== false && process.platform === "darwin") {
+            notify("vir — projects awaiting decision", `${stillPending.size} project(s), ${summary.projectPending} session(s) pending — run vir projects`);
+        }
+    }
     // Second input source: web articles. Gated on config; a session-only install
     // (no articlesDir) skips this entirely and behaves exactly as before.
     if (cfg.articlesDir && cfg.distillArticles) {
@@ -483,7 +779,7 @@ export async function runPipeline(cfg, opts = {}) {
     // (Ollama down during distill). Without this a transient outage is permanent
     // — the note never enters the embedding-search candidate set.
     await runEmbeddingSweep(db, writer, fileLog, interactive);
-    fileLog(`vir run done — scanned=${summary.scanned} new=${summary.scanned - summary.alreadyProcessed} distilled=${summary.distilled} skipped=${summary.skippedByFilter} lowConf=${summary.lowConfidence} errored=${summary.errored} articles=${summary.articlesDistilled} pdfs=${summary.pdfsDistilled}`);
+    fileLog(`vir run done — scanned=${summary.scanned} new=${summary.scanned - summary.alreadyProcessed} distilled=${summary.distilled} skipped=${summary.skippedByFilter} lowConf=${summary.lowConfidence} errored=${summary.errored} projectExcluded=${summary.projectExcluded} projectPending=${summary.projectPending} flagSkipped=${summary.flagSkipped} workflowSkipped=${summary.workflowSkipped} sidechainSkipped=${summary.sidechainSkipped} agentSkipped=${summary.agentSkipped} articles=${summary.articlesDistilled} pdfs=${summary.pdfsDistilled}`);
     if (interactive) {
         ui.blank();
         ui.divider();
@@ -500,6 +796,21 @@ export async function runPipeline(cfg, opts = {}) {
                 color: summary.errored > 0 ? ui.errorColor : ui.dim,
             },
         };
+        if (summary.projectExcluded > 0) {
+            stats.excluded = { value: summary.projectExcluded, color: ui.dim };
+        }
+        if (summary.projectPending > 0) {
+            stats.undecided = { value: summary.projectPending, color: ui.warn };
+        }
+        if (summary.workflowSkipped + summary.sidechainSkipped > 0) {
+            stats.workflow = {
+                value: summary.workflowSkipped + summary.sidechainSkipped,
+                color: ui.dim,
+            };
+        }
+        if (summary.agentSkipped > 0) {
+            stats.agent = { value: summary.agentSkipped, color: ui.dim };
+        }
         if (cfg.articlesDir && cfg.distillArticles) {
             stats.articles = { value: summary.articlesDistilled, color: ui.success };
         }
@@ -630,7 +941,8 @@ async function runArticlePhase(cfg, db, writer, summary, fileLog, interactive) {
                 ui.categoryRow(distilled.classification.category, article.title);
             }
             fileLog(`distilled article → ${distilled.classification.category}/${article.title}`);
-            if (distilled.classification.confidence >= 0.8) {
+            if (distilled.classification.confidence >= 0.8 &&
+                cfg.notifications !== false) {
                 notify(`Vir — new ${distilled.classification.category}`, article.title);
             }
             await new Promise((r) => setTimeout(r, 2000));
@@ -715,7 +1027,8 @@ async function runPdfPhase(cfg, db, writer, summary, fileLog, interactive) {
                 ui.categoryRow(distilled.classification.category, parsed.title);
             }
             fileLog(`distilled pdf → ${distilled.classification.category}/${parsed.title}`);
-            if (distilled.classification.confidence >= 0.8) {
+            if (distilled.classification.confidence >= 0.8 &&
+                cfg.notifications !== false) {
                 notify(`Vir — new ${distilled.classification.category}`, parsed.title);
             }
             await new Promise((r) => setTimeout(r, 2000));
@@ -758,6 +1071,8 @@ async function rewriteOne(writer, row) {
         userText: "",
         rawSummary: "",
         transcriptText: "",
+        isSidechain: false,
+        entrypoint: null,
     };
     const note = {
         classification: {