@hraness/sponge 0.3.5 → 0.4.1

package/README.md

@@ -121,21 +121,30 @@ pruned generation needs a rebuild.
 A digest (Digest v2) is a short gist led by one sentence and 3–5 ideas, each a
 claim with detail and 0–2 verbatim quotes, with 1–6 quotes in all.
 A local model proposes it; Sponge checks every rule against the captured text
-and stores only a passing draft. Drafting is opt-in and needs a model server you
-start yourself, such as llama.cpp `llama-server`, LM Studio or Ollama:
+and stores only a passing draft. Drafting is opt-in. `sponge setup --digest`
+installs a pinned llama.cpp and model (Gemma 4 26B-A4B with 32 GB of memory or
+more, Qwen3.5 9B with 16 GB; about 17 or 6 GB of disk), and from then on the
+background worker digests each new capture:
 
 ```sh
-llama-server -m gemma-4-12b-it-Q4_K_M.gguf --port 8080
-sponge digest ITEM --endpoint http://127.0.0.1:8080 --model NAME
+sponge setup --digest            # or --model-file GGUF to reuse a download
+sponge digest ITEM --draft       # draft one item now
+sponge digest --auto off         # stop background digests (on to resume)
 sponge digest ITEM
 sponge review DIGEST --accept all --reject quote:1.0
 ```
 
+Sponge runs its model server sandboxed on loopback, only while drafting, and
+waits while another `llama-server` holds the GPU. To use a server you started
+yourself (llama.cpp `llama-server`, LM Studio or Ollama), pass its endpoint:
+
+```sh
+sponge digest ITEM --endpoint http://127.0.0.1:8080 --model NAME
+```
+
 `--model` must match an id the server lists at `/v1/models`. Endpoints must be
 literal loopback HTTP (`127.0.0.1` or `[::1]`); Sponge refuses anything else so
-captured text never leaves the machine, and never starts or downloads a model.
-Suggested models are Gemma 4 12B on 16 GB Macs and Gemma 4 E4B on 8 GB, with
-Qwen3.5 9B or 4B as alternatives. Rerunning with the same inputs returns the stored
+captured text never leaves the machine. Rerunning with the same inputs returns the stored
 draft. Review targets are `all`, `gist`, `idea:N` and `quote:N.M` (0-based); only
 accepted fields can be published. `--check-support` also requires each quote to
 support its claim by local embedding similarity. See [digest drafting](src/digest/README.md).

package/dist/migrations/011.d.ts

@@ -0,0 +1,3 @@
+/** Digest jobs: one per captured revision, drafted by the worker with the model from `sponge setup --digest`. Local to this device (never in the change log); the server's process custody is the worker's filesystem journal, so a job has no attempt rows or staging. `digest_settings` holds the auto-digest switch and the chosen model alias. Additive. */
+export declare const version = 11;
+export declare const sql = "\nCREATE TABLE digest_jobs(id TEXT PRIMARY KEY,item_id TEXT NOT NULL REFERENCES items(id),revision_id TEXT NOT NULL UNIQUE REFERENCES revisions(id),state TEXT NOT NULL CHECK(state IN ('queued','delayed','running','failed','cancelled','succeeded')),cancel_requested INTEGER NOT NULL DEFAULT 0 CHECK(cancel_requested IN (0,1)),attempt_count INTEGER NOT NULL DEFAULT 0,reason TEXT,retryable INTEGER NOT NULL DEFAULT 0 CHECK(retryable IN (0,1)),not_before TEXT,owner_incarnation TEXT,fence INTEGER,derivation_id TEXT,created_at TEXT NOT NULL,finished_at TEXT) STRICT;\nCREATE INDEX digest_jobs_ready ON digest_jobs(state,not_before,created_at);\nCREATE INDEX digest_jobs_item ON digest_jobs(item_id);\nCREATE TABLE digest_settings(id INTEGER PRIMARY KEY CHECK(id=1),auto INTEGER NOT NULL DEFAULT 0 CHECK(auto IN (0,1)),model TEXT) STRICT;\nINSERT INTO digest_settings(id) VALUES(1);\n";

package/dist/migrations/011.js

@@ -0,0 +1,9 @@
+/** Digest jobs: one per captured revision, drafted by the worker with the model from `sponge setup --digest`. Local to this device (never in the change log); the server's process custody is the worker's filesystem journal, so a job has no attempt rows or staging. `digest_settings` holds the auto-digest switch and the chosen model alias. Additive. */
+export const version = 11;
+export const sql = `
+CREATE TABLE digest_jobs(id TEXT PRIMARY KEY,item_id TEXT NOT NULL REFERENCES items(id),revision_id TEXT NOT NULL UNIQUE REFERENCES revisions(id),state TEXT NOT NULL CHECK(state IN ('queued','delayed','running','failed','cancelled','succeeded')),cancel_requested INTEGER NOT NULL DEFAULT 0 CHECK(cancel_requested IN (0,1)),attempt_count INTEGER NOT NULL DEFAULT 0,reason TEXT,retryable INTEGER NOT NULL DEFAULT 0 CHECK(retryable IN (0,1)),not_before TEXT,owner_incarnation TEXT,fence INTEGER,derivation_id TEXT,created_at TEXT NOT NULL,finished_at TEXT) STRICT;
+CREATE INDEX digest_jobs_ready ON digest_jobs(state,not_before,created_at);
+CREATE INDEX digest_jobs_item ON digest_jobs(item_id);
+CREATE TABLE digest_settings(id INTEGER PRIMARY KEY CHECK(id=1),auto INTEGER NOT NULL DEFAULT 0 CHECK(auto IN (0,1)),model TEXT) STRICT;
+INSERT INTO digest_settings(id) VALUES(1);
+`;

package/dist/migrations/index.js

@@ -10,6 +10,7 @@ import * as m7 from './007.js';
 import * as m8 from './008.js';
 import * as m9 from './009.js';
 import * as m10 from './010.js';
+import * as m11 from './011.js';
 import { syncReady } from '../src/store/sync-ready.js';
 import { incrementalIndex } from '../src/indexing/upgrade.js';
 /** Every migration, in order. Add a new numbered file and append it here; never edit or reorder a released entry. */
@@ -30,6 +31,7 @@ export const migrations = Object.freeze([
     m8,
     { ...m9, step: syncReady },
     { ...m10, step: incrementalIndex },
+    m11,
 ].map((m) => Object.freeze({ ...m })));
 migrations.forEach((m, i) => {
     if (m.version !== i + 1)

package/dist/src/cli/commands.js

@@ -9,6 +9,8 @@ import { portabilityAction } from './portability.js';
 import { restoreLibrary } from '../portability/backup.js';
 import { workerAction, serveWorker, hasDueAcquisition, workerDoctor } from './worker.js';
 import { nativeSetupPlan, provisionNative, inspectNative } from '../models/runtime.js';
+import { digestModel, digestSetupPlan, inspectDigest, provisionDigest } from '../models/digest.js';
+import { withDigestServer } from '../digest/server.js';
 import { nativeDownloadAuthGuidance } from '../models/download.js';
 import { drainIndexQueue } from '../indexing/runner.js';
 import { indexAction, overviewText } from './indexing.js';
@@ -16,7 +18,7 @@ import { pruneText } from '../indexing/prune-run.js';
 import { importAction, jungleAction, jungleText } from './import.js';
 import { digestText, reviewFromSpec, reviewSpec } from './digest.js';
 import { connectEndpoint } from '../digest/endpoint.js';
-import { createDigest } from '../digest/pipeline.js';
+import { createDigest, undigestible } from '../digest/pipeline.js';
 import { createQueryEmbedder, createTextEmbedder } from '../search/query.js';
 import { runtimeGcAction, runtimeGcText, setupRuntimeGc } from './runtimes.js';
 import { drainLibrary } from '../worker/basic.js';
@@ -123,12 +125,35 @@ export const commands = [
     {
         name: 'setup',
         summary: 'Download one pinned runtime',
-        usage: [['setup --capture|--asr|--embedding', 'Download one pinned runtime']],
+        usage: [
+            ['setup --capture|--asr|--embedding', 'Download one pinned runtime'],
+            [
+                'setup --digest [--digest-model ALIAS] [--model-file GGUF]',
+                'Install the local digest model; --model-file copies a GGUF you already have',
+            ],
+        ],
         positional: 0,
-        flags: { capture: 'boolean', asr: 'boolean', embedding: 'boolean' },
+        flags: {
+            capture: 'boolean',
+            asr: 'boolean',
+            embedding: 'boolean',
+            digest: 'boolean',
+            'digest-model': 'value',
+            'model-file': 'value',
+        },
         library: 'open',
-        check: (_, f) => [f.capture, f.asr, f.embedding].filter(Boolean).length === 1,
+        check: (_, f) => [f.capture, f.asr, f.embedding, f.digest].filter(Boolean).length === 1 &&
+            (!!f.digest || (f['digest-model'] === undefined && f['model-file'] === undefined)) &&
+            (f['model-file'] === undefined || abs(f['model-file'])),
         handler: async (c) => {
+            if (c.args.flags.digest) {
+                const flags = c.args.flags, pin = digestModel(typeof flags['digest-model'] === 'string' ? flags['digest-model'] : undefined), modelFile = typeof flags['model-file'] === 'string' ? flags['model-file'] : undefined;
+                process.stderr.write(JSON.stringify({ setup: 'digest', adopt: !!modelFile, ...digestSetupPlan(pin) }) + '\n');
+                await provisionDigest(c.nativeRoot, pin, { signal: c.signal, modelFile });
+                const gc = await setupRuntimeGc(c.store, c.version), settings = c.store.digests.configure({ auto: true, model: pin.alias });
+                c.emit({ digest: 'ready', model: pin.alias, auto: settings.auto, gc }, `Digest model ready: ${pin.alias}. New captures are digested in the background; turn that off with \`sponge digest --auto off\`.`);
+                return 0;
+            }
             if (!c.args.flags.capture) {
                 const kind = c.args.flags.asr ? 'asr' : 'embedding', plan = await nativeSetupPlan(kind, c.version);
                 process.stderr.write(JSON.stringify({ setup: kind, ...plan }) + '\n');
@@ -691,16 +716,43 @@ export const commands = [
                 'digest ITEM --endpoint http://127.0.0.1:PORT --model NAME [--check-support]',
                 'Draft a digest with a local model server you started',
             ],
+            ['digest ITEM --draft [--model ALIAS]', 'Draft a digest with the model from `sponge setup --digest`'],
             ['digest ITEM', 'Show the current digest and its review state'],
+            ['digest --auto on|off', 'Digest new captures in the background with the worker, or stop'],
         ],
-        positional: 1,
-        flags: { endpoint: 'value', model: 'value', 'check-support': 'boolean' },
+        positional: (p) => p.length <= 1,
+        flags: { endpoint: 'value', model: 'value', 'check-support': 'boolean', draft: 'boolean', auto: 'value' },
         library: 'open',
-        check: (_, f) => Boolean(f.endpoint) === Boolean(f.model) &&
+        check: (p, f) => (f.auto === undefined
+            ? p.length === 1
+            : p.length === 0 &&
+                ['on', 'off'].includes(String(f.auto)) &&
+                !f.draft &&
+                !f.endpoint &&
+                !f.model &&
+                !f['check-support']) &&
+            (f.draft ? !f.endpoint && !f['check-support'] : Boolean(f.endpoint) === Boolean(f.model)) &&
             !(f['check-support'] && !f.endpoint) &&
             (f.model === undefined || /^[\w.:/@+-]{1,256}$/.test(String(f.model))),
         handler: async (c) => {
             const { store, args, signal } = c;
+            if (args.flags.auto !== undefined) {
+                const settings = store.digests.configure({ auto: args.flags.auto === 'on' });
+                c.emit({ auto: settings.auto }, `Auto-digest ${settings.auto ? 'on' : 'off'}`);
+                return 0;
+            }
+            if (args.flags.draft) {
+                // Refuse an unknown item or a thin capture before the model server spends its startup on it.
+                const item = store.read(args.positional[0]);
+                if (!item)
+                    throw new SpongeError('unavailable');
+                const thin = undigestible(item.markdown);
+                if (thin)
+                    throw new SpongeError(thin);
+                const runtime = await inspectDigest(c.nativeRoot, args.flags.model ?? store.digests.settings().model ?? undefined), result = await withDigestServer(store.root, runtime, (model) => createDigest(store, args.positional[0], model, { signal }), { signal });
+                c.emit({ digest: result.derivation, duplicate: result.duplicate, ...(result.trace ? { trace: result.trace } : {}) }, digestText(result.derivation));
+                return 0;
+            }
             if (!args.flags.endpoint) {
                 const digest = store.derivations.current('digest', args.positional[0]);
                 if (!digest)

package/dist/src/cli/runtimes.js

@@ -1,15 +1,19 @@
 import { defaultCapturePins } from '../acquisition/index.js';
 import { loadNativeCatalog, nativeModelPackage } from '../models/catalog.js';
 import { modelSetupPlan } from '../models/artifacts.js';
+import { digestFingerprints } from '../models/digest.js';
 import { collectRuntimes } from '../worker/runtime-gc.js';
 import { codeOf } from '../errors.js';
-/** References of this installed Sponge: its capture pin and its catalog's model packages. */
+/** References of this installed Sponge: its capture pin, its catalog's model packages and every digest pin. */
 async function installedReferences(version) {
     let models = null;
     try {
         const catalog = await loadNativeCatalog(version);
         models = {
-            fingerprints: ['asr', 'embedding'].map((kind) => modelSetupPlan(nativeModelPackage(catalog, kind)).fingerprint),
+            fingerprints: [
+                ...['asr', 'embedding'].map((kind) => modelSetupPlan(nativeModelPackage(catalog, kind)).fingerprint),
+                ...digestFingerprints(),
+            ],
         };
     }
     catch {

package/dist/src/cli/worker.js

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import { inspectNative } from '../models/runtime.js';
 import { drainIndexQueue } from '../indexing/runner.js';
+import { drainDigestQueue } from '../digest/runner.js';
 import { drainLibrary } from '../worker/basic.js';
 import { recoverServiceLifetime } from '../service/lifetime.js';
 import { runWorkerService } from '../service/loop.js';
@@ -47,7 +48,7 @@ export function hasDueAcquisition(store) {
     const now = new Date().toISOString();
     return store.queue
         .list()
-        .some((job) => job.operation !== 'index' &&
+        .some((job) => !['index', 'digest'].includes(String(job.operation)) &&
         ['queued', 'delayed'].includes(String(job.state)) &&
         job.cancel_requested !== 1 &&
         (job.not_before === null || job.not_before === undefined || String(job.not_before) <= now));
@@ -83,6 +84,9 @@ export async function drainServiceQueues(store, options, version, signal) {
         const runtime = await inspectNative('embedding', join(store.root, 'runtime', 'models'), version);
         results.push(...(await drainIndexQueue(store, { runtime, signal })));
     }
+    // Last, under its own time budget: drafting holds the GPU and can take minutes per item.
+    if (!signal.aborted && store.queue.pendingCleanup() === 0 && store.digests.due())
+        results.push(...(await drainDigestQueue(store, { nativeRoot: join(store.root, 'runtime', 'models'), signal })));
     if (acquisitionError)
         throw acquisitionError;
     return results;

package/dist/src/digest/endpoint.d.ts

@@ -1,7 +1,8 @@
 import { type DigestModel } from './pipeline.js';
 /**
- * A user-started local OpenAI-compatible server (llama.cpp `llama-server`, LM Studio, Ollama). Captured text must not
- * leave the machine, so only literal loopback HTTP origins are accepted, redirects are refused, and Sponge never starts a server.
+ * A local OpenAI-compatible server: one the user started (llama.cpp `llama-server`, LM Studio, Ollama), or Sponge's own
+ * (src/digest/server.ts). Captured text must not leave the machine, so only literal loopback HTTP origins are accepted
+ * and redirects are refused.
  */
 export declare function loopbackEndpoint(value: string): URL;
 /** GGUF quantization from a model filename, e.g. `gemma-4-12b-it-Q4_K_M.gguf` → `Q4_K_M`. */

package/dist/src/digest/endpoint.js

@@ -1,7 +1,8 @@
 import { SpongeError } from '../errors.js';
 /**
- * A user-started local OpenAI-compatible server (llama.cpp `llama-server`, LM Studio, Ollama). Captured text must not
- * leave the machine, so only literal loopback HTTP origins are accepted, redirects are refused, and Sponge never starts a server.
+ * A local OpenAI-compatible server: one the user started (llama.cpp `llama-server`, LM Studio, Ollama), or Sponge's own
+ * (src/digest/server.ts). Captured text must not leave the machine, so only literal loopback HTTP origins are accepted
+ * and redirects are refused.
  */
 export function loopbackEndpoint(value) {
     let url;

package/dist/src/digest/pipeline.d.ts

@@ -4,7 +4,7 @@ import type { Derivation, DigestCandidate } from './derivation.js';
  * Model-agnostic Digest v2 drafting. The model sees numbered passages and cites a passage id plus a short exact
  * span; code snaps, prunes and checks. Nothing leaves this module except through the injected model.
  */
-export declare const PROMPT_VERSION = "sponge-digest-prompt-v5";
+export declare const PROMPT_VERSION = "sponge-digest-prompt-v6";
 export type ChatMessage = {
     role: 'system' | 'user' | 'assistant';
     content: string;
@@ -56,8 +56,30 @@ interface Highlight {
  * change digest input hashes.
  */
 export declare function canonicalJson(value: unknown): string;
-/** Paragraph-level passages with raw offsets. Headings label passages; code fences and image-only blocks are not quotable. */
-export declare function passages(markdown: string, maxChars?: number): Passage[];
+/** Where a post starts in a captured thread, and who wrote it as the model is told. */
+export interface Post {
+    start: number;
+    label: string;
+}
+/**
+ * The posts of an X thread capture: top-level list items that carry X's post links. The poster's handle comes from
+ * the item's avatar or name link; the thread's author from the title (`Name (@handle) on X`), else the first post. A
+ * later post without a handle is still a reply. Other list items (an X article's bullets) are not posts, and a thread
+ * with no reply has none.
+ */
+export declare function threadPosts(markdown: string): Post[];
+/** A thread's passages without its replies, which are readers' comments rather than the source; renumbered from 1. */
+export declare function authorPassages(markdown: string): Passage[];
+/**
+ * Paragraph-level passages with raw offsets. Headings label passages; code fences and image-only blocks are not
+ * quotable. `posts` (a thread's) also break blocks, and their labels head the passages that follow.
+ */
+export declare function passages(markdown: string, maxChars?: number, posts?: readonly Post[]): Passage[];
+/**
+ * Why a capture cannot be digested, as a detail code, or undefined when it can: its body (past the frontmatter, images
+ * dropped, link text kept) has under `minProseWords` words with letters, or only an archive's metadata was saved.
+ */
+export declare function undigestible(markdown: string): 'source-too-thin' | undefined;
 /** Pack passages into sections of at most `budget` display characters, preferring heading boundaries past half a budget. */
 export declare function sectionsOf(list: Passage[], budget: number): Passage[][];
 /** JSON Schema for the model's draft. Tags become an enum when a vocabulary is given. */
@@ -160,8 +182,11 @@ export interface DigestStore {
         read(kind: 'digest', id: string): Derivation | undefined;
     };
 }
+type DraftOptions = Omit<DraftInput, 'revisionId' | 'markdown' | 'title' | 'form' | 'model' | 'highlights'>;
+/** What the item's current revision is drafted from: its Markdown, title, form and anchored highlights. */
+export declare function digestInputFor(store: Pick<DigestStore, 'read' | 'annotations'>, itemId: string, model: DigestModel, options?: DraftOptions): DraftInput;
 /** Draft and store a digest for the item's current revision. A matching input hash returns the stored draft without calling the model. */
-export declare function createDigest(store: DigestStore, itemId: string, model: DigestModel, options?: Omit<DraftInput, 'revisionId' | 'markdown' | 'title' | 'form' | 'model' | 'highlights'>): Promise<{
+export declare function createDigest(store: DigestStore, itemId: string, model: DigestModel, options?: DraftOptions): Promise<{
     derivation: Derivation;
     duplicate: boolean;
     trace?: DraftTrace;

package/dist/src/digest/pipeline.js

@@ -6,7 +6,7 @@ import { sha256 } from '../util/hash.js';
  * Model-agnostic Digest v2 drafting. The model sees numbered passages and cites a passage id plus a short exact
  * span; code snaps, prunes and checks. Nothing leaves this module except through the injected model.
  */
-export const PROMPT_VERSION = 'sponge-digest-prompt-v5';
+export const PROMPT_VERSION = 'sponge-digest-prompt-v6';
 /** 24k characters is roughly 6k tokens of passages, leaving room for instructions and output in an 8k context on an 8 GB Mac. */
 const defaultDigestParams = {
     temperature: 0,
@@ -40,14 +40,62 @@ export function canonicalJson(value) {
         throw new SpongeError('invalid-input');
     return JSON.stringify(value ?? null);
 }
-/** Paragraph-level passages with raw offsets. Headings label passages; code fences and image-only blocks are not quotable. */
-export function passages(markdown, maxChars = 1200) {
+const postHandle = [
+    /^- \[!\[@(\w+)\]/,
+    /^- \[\[remote image: @(\w+)\]/,
+    /^-\s+\[[^\]]+\]\(https:\/\/x\.com\/(\w+)\)\s*$/,
+];
+/**
+ * The posts of an X thread capture: top-level list items that carry X's post links. The poster's handle comes from
+ * the item's avatar or name link; the thread's author from the title (`Name (@handle) on X`), else the first post. A
+ * later post without a handle is still a reply. Other list items (an X article's bullets) are not posts, and a thread
+ * with no reply has none.
+ */
+export function threadPosts(markdown) {
+    const author = /^title: ".*\(@(\w+)\) on X"/m.exec(frontmatter(markdown))?.[1], items = [];
+    let at = 0;
+    for (const line of markdown.split('\n')) {
+        if (/^- /.test(line) || /^-\s+\[/.test(line))
+            items.push({ start: at, handle: postHandle.map((r) => r.exec(line)?.[1]).find(Boolean), post: false });
+        const item = items.at(-1);
+        if (item && /x\.com\/(compose\/post\?in_reply_to=|\w+\/status\/\d)/.test(line))
+            item.post = true;
+        at += line.length + 1;
+    }
+    const posts = items.filter((i) => i.post || i.handle), by = author ?? posts[0]?.handle, same = (h) => h.toLowerCase() === by?.toLowerCase(), labelled = posts.map((p, i) => ({
+        start: p.start,
+        label: p.handle && !same(p.handle)
+            ? `Reply by @${p.handle}`
+            : p.handle || i === 0
+                ? `Post by ${by ? `@${by}, ` : ''}the author`
+                : 'Reply (poster not captured)',
+    }));
+    // With no reply there is nobody to tell apart, so the passages stay as they are.
+    return labelled.some((p) => p.label !== labelled[0].label) ? labelled : [];
+}
+/** A thread's passages without its replies, which are readers' comments rather than the source; renumbered from 1. */
+export function authorPassages(markdown) {
+    return passages(markdown, undefined, threadPosts(markdown))
+        .filter((p) => !p.heading?.startsWith('Reply'))
+        .map((p, i) => ({ ...p, id: i + 1 }));
+}
+/**
+ * Paragraph-level passages with raw offsets. Headings label passages; code fences and image-only blocks are not
+ * quotable. `posts` (a thread's) also break blocks, and their labels head the passages that follow.
+ */
+export function passages(markdown, maxChars = 1200, posts = []) {
     const out = [], blocks = [];
     let at = 0, start = -1, fence = false, fenced = false;
+    const breaks = new Set(posts.map((p) => p.start));
     for (const line of markdown.split('\n')) {
         const end = at + line.length, blank = !line.trim(), marker = /^\s{0,3}(```|~~~)/.test(line);
         if (marker)
             fence = !fence;
+        if (!fence && !marker && start >= 0 && breaks.has(at)) {
+            blocks.push({ start, end: at - 1, fence: fenced });
+            start = -1;
+            fenced = false;
+        }
         if (blank && !fence && !marker) {
             if (start >= 0)
                 blocks.push({ start, end: at - 1, fence: fenced });
@@ -64,14 +112,17 @@ export function passages(markdown, maxChars = 1200) {
     }
     if (start >= 0)
         blocks.push({ start, end: markdown.length, fence: fenced });
-    let heading = '';
+    let heading = '', post = '';
+    const label = (start) => posts.findLast((p) => p.start <= start)?.label ?? '';
     for (const b of blocks) {
         const raw = markdown.slice(b.start, b.end).trimEnd(), end = b.start + raw.length;
         if (b.fence || !raw.trim())
             continue;
+        if (label(b.start) !== post)
+            heading = post = label(b.start);
         const h = /^\s{0,3}#{1,6}\s+(.+)$/.exec(raw);
         if (h && !raw.includes('\n')) {
-            heading = collapse(h[1]).slice(0, 200);
+            heading = (post ? `${post}: ` : '') + collapse(h[1]).slice(0, 200);
             continue;
         }
         if (/^(\s*!\[[^\]]*\]\([^)]*\)\s*)+$/.test(raw))
@@ -91,6 +142,32 @@ export function passages(markdown, maxChars = 1200) {
     }
     return out;
 }
+const frontmatter = (markdown) => /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/u.exec(markdown)?.[0] ?? '';
+/** A `key: "value"` frontmatter field, as captures write them. */
+function captureField(markdown, key) {
+    const match = new RegExp(`^${key}: (".*")\\r?$`, 'm').exec(frontmatter(markdown));
+    try {
+        const value = match ? JSON.parse(match[1]) : undefined;
+        return typeof value === 'string' ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Prose words under which a capture holds nothing to digest: a gallery of numbered images, a bare link list. */
+const minProseWords = 20;
+/**
+ * Why a capture cannot be digested, as a detail code, or undefined when it can: its body (past the frontmatter, images
+ * dropped, link text kept) has under `minProseWords` words with letters, or only an archive's metadata was saved.
+ */
+export function undigestible(markdown) {
+    if (captureField(markdown, 'capture_method') === 'archive-metadata')
+        return 'source-too-thin';
+    const prose = passages(markdown.slice(frontmatter(markdown).length))
+        .map((p) => p.text.replace(/(!?)\[([^\]]*)\]\([^)]*\)/g, (_, image, text) => (image ? ' ' : text)))
+        .join(' ');
+    return (prose.match(/\p{L}[\p{L}\p{M}'’-]*/gu) ?? []).length < minProseWords ? 'source-too-thin' : undefined;
+}
 function lastSentenceEnd(window) {
     let best = -1;
     for (const m of window.matchAll(/[.!?]["')\]]*(?=\s)/g))
@@ -196,7 +273,12 @@ Source: an essay arguing that taste is a skill.
   claim: Volume beats polish early. | detail: Side-by-side comparison of many rough drafts sharpens judgment faster than finishing one.
 Bad claim: The essay explores how practice over time shapes a person's sense of taste.
 Good claim: Taste is trained.`;
-const system = (budget, vocabulary) => `You write a Digest v2 of one source for a private reading library, in the owner's voice: terse, declarative, specific. Reply with JSON only, matching the schema.
+/** Who speaks in each form, so claims are credited to the person who made them. */
+const voices = {
+    thread: 'This source is an X thread. Its replies are left out. When the author quotes or answers someone, that view stays theirs.',
+    video: 'This source is a recording: credit each claim to the person who says it. In an interview or podcast, the guest’s views are the guest’s, not the host’s.',
+};
+const system = (budget, form, vocabulary) => `You write a Digest v2 of one source for a private reading library, in the owner's voice: terse, declarative, specific. Reply with JSON only, matching the schema.
 - lead: one sentence of at most ${L.leadChars} characters stating this source's specific thesis or result: who (author, organization or product by name) shows or argues what, with the number, name or mechanism that makes it this source. Do not restate the title, describe the source ("This article discusses"), or tease.
 - context: 1 or 2 sentences, at most 45 words: the evidence, method, numbers or limits the lead could not hold. Lead and context together stay within ${L.gistWords} words and ${L.gistSentences} sentences.
 - ideas: ${L.minIdeas} to ${L.maxIdeas} (prefer ${L.maxIdeas} when the source has them), in the order the author makes them, covering the whole source including its caveats and limits. Each idea is a claim with detail:
@@ -205,7 +287,12 @@ const system = (budget, vocabulary) => `You write a Digest v2 of one source for
   - quotes: 0 to ${L.maxQuotesPerIdea} that support this idea, each a contiguous span copied character for character from one numbered passage, ${minQuoteWords + 2} to 20 words, with that passage number. A quote is a fragment, not a whole long sentence: when a sentence runs past 20 words, copy only its strongest part. No added quotation marks or ellipses. Give attribution (who said it) when it is not the author. Prefer reader highlights.
 - Attach at least ${L.minQuotes} and at most ${L.maxQuotes} quotes in all; ${L.minQuotes + 1} to 3 is typical. All quotes together stay within ${budget} words and never overlap.
 - tags: 0 to ${L.maxTags} ${vocabulary?.length ? `from: ${vocabulary.join(', ')}` : 'lowercase kebab-case topics'}; usually one subject tag.
-Plain words. Name things and use numbers. No hedges or filler: may, might, potentially, various, significantly, key, crucial, notably, highlights, explores, discusses, "the author argues", "the article".
+Faithfulness comes before style:
+- Credit each view to who holds it. When the source quotes, interviews or reports someone, their claims are theirs: name them in the detail and the quote attribution, never pass them off as the author's.${voices[form] ? `\n- ${voices[form]}` : ''}
+- Keep each number with its own subject, unit and meaning (an area is not a height, a share is not a count, a cost is not a price) and never compute one the source does not give.
+- Keep the source's direction: never invert a claim, comparison or cause.
+- Keep the source's certainty: a forecast, plan, proposal, rumor or question stays one ("plans to", "expects", "asks whether"); never state it as done or settled. Hedge only where the source does.
+Plain words. Name things and use numbers. No filler: various, significantly, key, crucial, notably, highlights, explores, discusses, "the author argues", "the article".
 Use only what the source says.
 
 ${styleExamples}`;
@@ -255,7 +342,9 @@ function fromModel(text, form) {
     }
     if (!object(v) || !Array.isArray(v.ideas) || !Array.isArray(v.tags))
         return { issues: [{ path: '', code: 'shape' }] };
-    const trim = (s) => (typeof s === 'string' ? s.trim() : s), cites = [];
+    const trim = (s) => (typeof s === 'string' ? s.trim() : s), 
+    // Models sometimes end a sentence with the passage it came from ("… market. [2]").
+    prose = (s) => (typeof s === 'string' ? s.replace(/(\s*\[\d+(?:,\s*\d+)*\])+$/, '').trim() : s), cites = [];
     const ideas = v.ideas.map((idea) => {
         if (!object(idea)) {
             cites.push([]);
@@ -264,19 +353,20 @@ function fromModel(text, form) {
         const quotes = Array.isArray(idea.quotes) ? idea.quotes : [];
         cites.push(quotes.map((q) => (Number.isSafeInteger(q?.passage) ? q.passage : undefined)));
         return {
-            claim: trim(idea.claim),
-            detail: trim(idea.detail),
+            claim: prose(idea.claim),
+            detail: prose(idea.detail),
             quotes: quotes.map((q) => {
                 const attribution = trim(q?.attribution);
                 return { text: trim(q?.text), ...(attribution ? { attribution } : {}) };
             }),
         };
     });
-    const context = trim(v.context);
+    // A context the model stopped mid-sentence is dropped; context is optional.
+    const context = ((c) => (typeof c === 'string' && !/[.!?…。！？)"”’]$/.test(c) ? undefined : c))(prose(v.context));
     const parsed = parseDigest({
         schemaVersion: 2,
         form,
-        gist: { lead: trim(v.lead), ...(context ? { context } : {}) },
+        gist: { lead: prose(v.lead), ...(context ? { context } : {}) },
         ideas,
         tags: v.tags.map(trim),
     });
@@ -453,7 +543,10 @@ export async function draftDigest(input) {
             input.vocabulary.length > 256 ||
             input.vocabulary.some((t) => !/^[a-z0-9][a-z0-9-]{0,63}$/.test(t))))
         throw new SpongeError('invalid-input');
-    const inputHash = digestInputHash({ ...input, model: identity }), source = input.markdown, list = passages(source);
+    const thin = undigestible(input.markdown);
+    if (thin)
+        throw new SpongeError(thin);
+    const inputHash = digestInputHash({ ...input, model: identity }), source = input.markdown, list = input.form === 'thread' ? authorPassages(source) : passages(source);
     if (list.length === 0)
         throw new SpongeError('invalid-input');
     const userSignal = input.signal ?? new AbortController().signal, overall = AbortSignal.any([userSignal, AbortSignal.timeout(p.deadlineMs)]);
@@ -564,7 +657,7 @@ export async function draftDigest(input) {
     }
     const budget = quoteBudget(source), schema = draftSchema(list.length, input.vocabulary);
     const messages = [
-        { role: 'system', content: system(budget, input.vocabulary) },
+        { role: 'system', content: system(budget, input.form, input.vocabulary) },
         {
             role: 'user',
             content: (notesText ? `Notes from each part of the source, in order:\n${notesText}\n\n` : '') +
@@ -637,9 +730,16 @@ export async function draftDigest(input) {
     };
     return { output: result.draft.digest, inputHash, producer, options, trace };
 }
-const formFor = (kind) => (kind === 'pdf' ? 'pdf' : kind === 'media' ? 'video' : 'article');
-/** Draft and store a digest for the item's current revision. A matching input hash returns the stored draft without calling the model. */
-export async function createDigest(store, itemId, model, options = {}) {
+/** X thread captures draft as `thread`, whose prompt rules keep replies apart from the author's posts. */
+const formFor = (kind, markdown) => kind === 'pdf'
+    ? 'pdf'
+    : kind === 'media'
+        ? 'video'
+        : captureField(markdown, 'platform') === 'x' && captureField(markdown, 'capture_scope') === 'thread'
+            ? 'thread'
+            : 'article';
+/** What the item's current revision is drafted from: its Markdown, title, form and anchored highlights. */
+export function digestInputFor(store, itemId, model, options = {}) {
     const item = store.read(itemId);
     if (!item)
         throw new SpongeError('unavailable');
@@ -647,21 +747,25 @@ export async function createDigest(store, itemId, model, options = {}) {
         .list(itemId)
         .filter((a) => a.kind === 'highlight' && a.revisionId === item.revisionId && a.anchored !== false)
         .map((a) => ({ text: a.anchor.exact, start: a.anchor.start }));
-    const input = {
+    return {
         ...options,
         revisionId: item.revisionId,
         markdown: item.markdown,
         title: item.title,
-        form: formFor(item.kind),
+        form: formFor(item.kind, item.markdown),
         model,
         highlights,
     };
-    const prior = store.derivations.find('digest', item.revisionId, digestInputHash({ ...input, model: model.identity }));
+}
+/** Draft and store a digest for the item's current revision. A matching input hash returns the stored draft without calling the model. */
+export async function createDigest(store, itemId, model, options = {}) {
+    const input = digestInputFor(store, itemId, model, options);
+    const prior = store.derivations.find('digest', input.revisionId, digestInputHash({ ...input, model: model.identity }));
     if (prior)
         return { derivation: prior, duplicate: true };
     const draft = await draftDigest(input), stored = store.derivations.put('digest', {
         itemId,
-        revisionId: item.revisionId,
+        revisionId: input.revisionId,
         producer: draft.producer,
         inputHash: draft.inputHash,
         output: draft.output,

package/dist/src/digest/runner.d.ts

@@ -0,0 +1,33 @@
+import type { LibraryStore } from '../store/index.js';
+import { inspectDigest } from '../models/digest.js';
+import { type DigestServerOptions } from './server.js';
+import { createDigest } from './pipeline.js';
+export type DigestRunResult = {
+    ok: true;
+    jobId: string;
+    digestId: string;
+    duplicate: boolean;
+} | {
+    ok: false;
+    jobId?: string;
+    code: string;
+    postponed?: number;
+};
+export interface DigestRunOptions {
+    /** `<library>/runtime/models`, where `sponge setup --digest` installed the runtime. */
+    nativeRoot: string;
+    signal?: AbortSignal;
+    /** No new job is claimed after this long; the one drafting finishes. Default 10 minutes. */
+    budgetMs?: number;
+    /** Test seams. */
+    inspect?: typeof inspectDigest;
+    create?: typeof createDigest;
+    server?: Partial<Omit<DigestServerOptions, 'runProcess' | 'scratchRoot' | 'signal'>>;
+}
+/**
+ * Draft queued digests with one Sponge-owned server per drain (`withDigestServer`), claiming jobs under the worker lease
+ * until the queue is empty, the budget is spent or the signal aborts. Never throws for a missing runtime, a busy GPU or
+ * a server that would not start: the ready jobs are postponed with that reason, so capture and indexing keep running.
+ * `cleanup-required` and `owner-busy` still throw, as the service loop expects.
+ */
+export declare function drainDigestQueue(store: LibraryStore, options: DigestRunOptions): Promise<DigestRunResult[]>;