lattris 0.1.4 → 0.2.1

package/dist/memory/recording.js

@@ -0,0 +1,258 @@
+import { createHash } from 'node:crypto';
+import { parseArgs } from "../request/flags.js";
+import { HELP_TOKENS } from "../request/flags.js";
+import { RECORDING_FORMATS, TRANSCRIPT_CONVERTERS, buildRecordingBody, formatRecording, mimeForAudio } from "../memory/transcript.js";
+import { allowWords, checkShareWords, isRefusalValue, needsYesWords, resolveBornShares, takeShareFlags } from "../memory/capture-common.js";
+import { emit } from "../render/output.js";
+import { confirmAction } from "../render/prompt.js";
+import { sanitizeForTerminal } from "../render/text.js";
+import { classifyApiError, parseErrorBody } from "../request/door.js";
+import { putToSignedUploadUrl } from "../request/upload.js";
+import { EXIT, refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+export const CAPTURE_RECORDING_HELP = `capture recording — keep an audio recording, its source, and its transcript.
+
+A recording stands on any of THREE substances, at least one:
+  • held audio    the file itself (--audio) — uploaded, then confirmed
+  • a source      where it lives elsewhere (--source-url)
+  • a transcript  the words (a file, in a format the CLI converts)
+
+The API meets ONE transcript shape; vendor formats convert HERE. Formats:
+  json   the file is already {speakers, turns, …} — passed through
+  a      a plain transcript, one turn per line as \`Label: text\`; a line with
+         no colon continues the turn above it
+
+Usage:
+  lattris capture recording <transcript-file> --format a --title "…"
+  lattris capture recording <transcript.json> --format json
+  lattris capture recording --audio talk.m4a --title "…"
+  lattris capture recording --source-url https://… --source-name "…"
+
+  <transcript-file>   optional; the transcript to convert (--format picks how)
+  --format <name>     json | a  (default json when the file ends .json)
+  --audio <path>      the audio file to hold — its size and sha256 are computed
+                      locally, the type comes from the extension (or --mime-type)
+  --mime-type <type>  override the audio content type (an unknown extension)
+  --source-url <url>  where the recording lives, if referenced not held
+  --source-name <s>   the source's name        --title <s>          one line, what it is
+  --title-at-source   its title at the source  --creator <s>        who made it (text)
+  --published-at <t>  when the source published it (ISO 8601)
+  --captured-at <t>   when it was recorded (ISO 8601; the future is refused)
+  --duration <n>      length in seconds
+  --span <uuid>       group it into one of your spans
+  --share-with <who>  who may see it from birth: public, all-contacts, or a contact
+                      (repeatable); asks at a terminal, needs --yes on a pipe
+  --deny <who>        who may not, whatever else allows it: all-contacts or a
+                      contact (repeatable); asks nothing
+  --contributor <id>  whose expression it is — a contact id
+  --allow-banned-words  keep a flagged word in the title deliberately
+
+saved → prints the id, what it stands on, and the address. Held audio uploads
+the bytes and confirms before the receipt.`;
+const RECORDING_FLAG_NAMES = {
+    '--format': 'format',
+    '--audio': 'audio',
+    '--mime-type': 'mimeType',
+    '--source-url': 'sourceUrl',
+    '--source-name': 'sourceName',
+    '--title': 'title',
+    '--title-at-source': 'titleAtSource',
+    '--creator': 'creator',
+    '--published-at': 'publishedAt',
+    '--captured-at': 'capturedAt',
+    '--duration': 'duration',
+    '--span': 'span',
+    '--contributor': 'contributor'
+};
+export const captureRecording = async (cfg, io, args) => {
+    if (args.length === 0 || args.some((t) => HELP_TOKENS.has(t))) {
+        io.stdout.write(`${CAPTURE_RECORDING_HELP}\n`);
+        return;
+    }
+    const allowBanned = args.includes('--allow-banned-words');
+    const yes = args.includes('--yes');
+    const taken = takeShareFlags(args.filter((a) => a !== '--allow-banned-words' && a !== '--yes'));
+    const { flags, positionals, unknown } = parseArgs(RECORDING_FLAG_NAMES, taken.rest);
+    if (unknown ?? taken.unknown) {
+        return refusal(`Unknown flag: ${unknown ?? taken.unknown}\n`);
+    }
+    if (positionals.length > 1) {
+        return refusal(`Unexpected argument: ${positionals[1]}\n`);
+    }
+    const transcriptFile = positionals[0];
+    const badShareWords = checkShareWords(taken.shareWith, taken.deny);
+    if (badShareWords)
+        return badShareWords;
+    const allows = allowWords(taken.shareWith);
+    if (allows.length > 0 && !io.stdin.isTTY && !yes) {
+        return refusal(needsYesWords('recording', allows));
+    }
+    if (transcriptFile === undefined && flags.audio === undefined && flags.sourceUrl === undefined) {
+        return refusal('A recording needs at least one of: a transcript file, --audio, or --source-url.\n');
+    }
+    let transcript;
+    if (transcriptFile !== undefined) {
+        const format = flags.format ?? (transcriptFile.toLowerCase().endsWith('.json') ? 'json' : 'a');
+        const convert = TRANSCRIPT_CONVERTERS[format];
+        if (convert === undefined) {
+            return refusal(`Unknown --format: ${format}. Accepted: ${RECORDING_FORMATS.join(', ')}.\n`);
+        }
+        let raw;
+        try {
+            raw = io.store.files.readFileSync(transcriptFile, 'utf8');
+        }
+        catch {
+            return refusal(`Cannot read transcript file: ${transcriptFile}\n`);
+        }
+        try {
+            transcript = convert(raw);
+        }
+        catch (e) {
+            return refusal(`Could not parse ${transcriptFile} as --format ${format}: ${e instanceof Error ? e.message : 'invalid'}\n`);
+        }
+    }
+    let upload;
+    let audioBytes;
+    if (flags.audio !== undefined) {
+        const mimeType = mimeForAudio(flags.audio, flags.mimeType);
+        if (mimeType === null) {
+            return refusal(`Can't tell the audio type of ${flags.audio} from its extension — pass --mime-type <type>.\n`);
+        }
+        try {
+            audioBytes = io.store.files.readFileSync(flags.audio);
+        }
+        catch {
+            return refusal(`Cannot read audio file: ${flags.audio}\n`);
+        }
+        upload = {
+            filename: flags.audio.slice(flags.audio.lastIndexOf('/') + 1),
+            mimeType,
+            size: audioBytes.length,
+            sha256: createHash('sha256').update(audioBytes).digest('hex')
+        };
+    }
+    if (flags.duration !== undefined && !/^\d+$/.test(flags.duration)) {
+        return refusal(`--duration must be a whole number of seconds: ${flags.duration}\n`);
+    }
+    if (allows.length > 0 && io.stdin.isTTY) {
+        const answer = await confirmAction(io, `Share "${sanitizeForTerminal(flags.title ?? '(untitled)')}" with ${allows.join(', ')}? [y/N] `);
+        if (answer === 'interrupted')
+            return refusal('Cancelled.\n', EXIT.GENERIC);
+        if (answer === 'no') {
+            io.stderr.write('Cancelled.\n');
+            return;
+        }
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    let shares;
+    if (taken.shareWith.length > 0 || taken.deny.length > 0) {
+        const resolved = await resolveBornShares(cfg, io, accessToken, taken.shareWith, taken.deny);
+        if (isRefusalValue(resolved))
+            return resolved;
+        shares = resolved;
+    }
+    const body = buildRecordingBody({
+        transcript,
+        upload,
+        sourceUrl: flags.sourceUrl,
+        title: flags.title,
+        capturedAt: flags.capturedAt,
+        spanId: flags.span,
+        audience: shares?.audience,
+        access: shares !== undefined && shares.access.length > 0 ? shares.access : undefined,
+        contributor: flags.contributor,
+        sourceName: flags.sourceName,
+        titleAtSource: flags.titleAtSource,
+        creator: flags.creator,
+        publishedAt: flags.publishedAt,
+        durationSeconds: flags.duration === undefined ? undefined : Number(flags.duration),
+        allowBannedWords: allowBanned
+    });
+    const created = await io.api(accessToken, `${cfg.apiUrl}/memories/recordings`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body)
+    });
+    if (!created.ok)
+        return refusalOf(created);
+    if ('signedUploadUrl' in created.data) {
+        const pending = created.data;
+        const putOnce = async () => {
+            try {
+                const res = await putToSignedUploadUrl(io.network, pending.signedUploadUrl, upload.mimeType, new Uint8Array(audioBytes));
+                if (res.ok)
+                    return { ok: true };
+                return {
+                    ok: false,
+                    why: res.status === 403
+                        ? 'the signed upload URL was rejected (it may have expired)'
+                        : `HTTP ${res.status}`
+                };
+            }
+            catch (e) {
+                return { ok: false, why: e instanceof Error ? e.message : 'a network error' };
+            }
+        };
+        let put = await putOnce();
+        if (!put.ok)
+            put = await putOnce();
+        if (!put.ok) {
+            return refusal(`The recording was reserved (${pending.block.id}) but the audio upload failed — ${put.why}.\n` +
+                `That reservation has no confirmed audio and is cleared server-side; running the capture ` +
+                `again creates a NEW recording — it does not adopt this one.\n`, EXIT.GENERIC);
+        }
+        const confirmUrl = `${cfg.apiUrl}/memories/${encodeURIComponent(pending.block.id)}/confirm`;
+        const confirmOnce = async () => {
+            try {
+                const res = await io.api(accessToken, confirmUrl, { method: 'POST' });
+                const rawText = res.rawText;
+                if (res.ok || res.answer.kind === 'page')
+                    return { kind: 'ok', data: JSON.parse(rawText), rawText };
+                return { kind: 'http', status: res.status, rawText };
+            }
+            catch (e) {
+                return { kind: 'transport', message: e instanceof Error ? e.message : 'a network error' };
+            }
+        };
+        let confirmed = await confirmOnce();
+        const firstLost = confirmed.kind === 'transport';
+        if (firstLost)
+            confirmed = await confirmOnce();
+        if (confirmed.kind === 'ok') {
+            emit(io, confirmed.data, confirmed.rawText, formatRecording);
+            return;
+        }
+        if (firstLost) {
+            try {
+                const probe = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(pending.block.id)}`);
+                if (probe.ok) {
+                    const rawText = probe.rawText;
+                    const rec = JSON.parse(rawText);
+                    if (rec.media != null) {
+                        emit(io, rec, rawText, formatRecording);
+                        return;
+                    }
+                }
+            }
+            catch { }
+        }
+        if (confirmed.kind === 'http') {
+            const { message, next, exit } = classifyApiError(confirmed.status, parseErrorBody(confirmed.rawText));
+            return {
+                message: `The recording was reserved (${pending.block.id}); the audio uploaded but the confirm did ` +
+                    `not land. That reservation is incomplete and cleared server-side; running the capture ` +
+                    `again creates a NEW recording — it does not finish this one.\n`,
+                exit,
+                answer: { kind: 'door', message, next }
+            };
+        }
+        return refusal(`The audio uploaded but confirming the recording (${pending.block.id}) failed — ${confirmed.message}.\n` +
+            `That reservation is incomplete and cleared server-side; running the capture again creates ` +
+            `a NEW recording — it does not finish this one.\n`, EXIT.GENERIC);
+    }
+    emit(io, created.data, created.rawText, formatRecording);
+};
+//# sourceMappingURL=recording.js.map

package/dist/memory/resend.js

@@ -0,0 +1,82 @@
+import { HELP_TOKENS } from "../request/flags.js";
+import { formatSaved } from "../memory/capture-common.js";
+import { formatBlockLine, formatMemoryDetail } from "../memory/views.js";
+import { emit } from "../render/output.js";
+import { sanitizeForTerminal } from "../render/text.js";
+import { EXIT, refusal } from "../store/exit.js";
+import { AGENT_LABEL_SHAPE, SESSION_ID_SHAPE, isUuidKey, noteWriteHeaders } from "../store/write-identity.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+export const RESEND_HELP = [
+    'resend — send a kept request again, exactly: the same door, the same session, the same',
+    'key, the same body. What a lost response on `capture memory` or `update memory --overwrite`',
+    'leaves under drafts/ in the machine dir.',
+    '',
+    'Usage:',
+    '  lattris resend <path-to-request.json>',
+    '',
+    'If the first attempt landed, the door answers the same receipt and writes nothing; if it',
+    'did not, the write happens now, once. The file’s own session is used, whatever',
+    'LATTRIS_SESSION_ID says here.'
+].join('\n');
+const RESEND_DOORS = /^(POST \/memories\/notes|PATCH \/memories\/[^/\s]+)$/;
+export const resend = async (cfg, io, args) => {
+    if (args.length === 0 || args.some((t) => HELP_TOKENS.has(t))) {
+        io.stdout.write(`${RESEND_HELP}\n`);
+        if (args.length > 0 && !args.some((t) => HELP_TOKENS.has(t)))
+            return refusal('', EXIT.USAGE);
+        return;
+    }
+    if (args.length !== 1) {
+        return refusal('Usage: lattris resend <path-to-request.json>\n');
+    }
+    let draft;
+    try {
+        draft = JSON.parse(io.store.files.readFileSync(args[0], 'utf8'));
+    }
+    catch (e) {
+        return refusal(`Could not read a kept request at ${args[0]}: ${sanitizeForTerminal(e instanceof Error ? e.message : String(e))}\n`);
+    }
+    if (typeof draft !== 'object' ||
+        draft === null ||
+        typeof draft.door !== 'string' ||
+        !RESEND_DOORS.test(draft.door) ||
+        typeof draft.idempotencyKey !== 'string' ||
+        !isUuidKey(draft.idempotencyKey) ||
+        typeof draft.sessionId !== 'string' ||
+        !SESSION_ID_SHAPE.test(draft.sessionId) ||
+        typeof draft.body !== 'object' ||
+        draft.body === null) {
+        return refusal(`${args[0]} is not a kept request (door, idempotencyKey, sessionId and body are what one carries).\n`);
+    }
+    if (draft.agentLabel !== undefined &&
+        (typeof draft.agentLabel !== 'string' || !AGENT_LABEL_SHAPE.test(draft.agentLabel))) {
+        return refusal(`The kept request at ${args[0]} names the agent label "${sanitizeForTerminal(String(draft.agentLabel))}", ` +
+            'which a request header cannot carry: an agent label is 1 to 128 printable ASCII characters. ' +
+            'Nothing was sent.\n');
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const [method, path] = draft.door.split(' ');
+    const identity = { sessionId: draft.sessionId, agentLabel: draft.agentLabel };
+    const result = await io.api(accessToken, `${cfg.apiUrl}${path}`, {
+        method,
+        headers: {
+            'Content-Type': 'application/json',
+            ...noteWriteHeaders(identity, draft.idempotencyKey)
+        },
+        body: JSON.stringify(draft.body)
+    });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    if (method === 'POST') {
+        io.stdout.write(`${formatSaved(result.data)}\n`);
+        return;
+    }
+    emit(io, result.data, result.rawText, (m) => 'visibility' in m
+        ? `Resent.\n\n${formatBlockLine(m)}`
+        : `Resent.\n\n${formatMemoryDetail(m)}`);
+};
+//# sourceMappingURL=resend.js.map

package/dist/memory/restore.js

@@ -0,0 +1,73 @@
+import { parseArgs } from "../request/flags.js";
+import { REVISION_NO_SHAPE } from "../memory/history.js";
+import { FINGERPRINT_SHAPE } from "../memory/update-help.js";
+import { composeAddressFor, formatMemoryDetail } from "../memory/views.js";
+import { emit } from "../render/output.js";
+import { noteWriteHeaders, requireWriteIdentity } from "../store/write-identity.js";
+import { isRefusal, refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+export const RESTORE_HELP = [
+    'restore — bring a note back from deleted items, or bring an earlier revision back as the head.',
+    '',
+    'Usage:',
+    '  lattris restore memory <id-or-prefix> --revision <n> --base-fingerprint <head> [--clear-missing]',
+    '',
+    '  --revision          required; the revision to bring back, from `lattris get history <id>`.',
+    '                      The note\u2019s own current number un-archives it with its last words.',
+    '  --base-fingerprint  required; the head fingerprint history printed. A head that moved',
+    '                      since is refused and nothing changes.',
+    '  --clear-missing     restore even when the revision names a span or contact that no',
+    '                      longer exists, clearing those references; without it the door',
+    '                      refuses and names them.',
+    '',
+    'History is never rewritten: restoring earlier words appends them as a new revision',
+    'that says where it came from. A note back from deleted items returns private.'
+].join('\n');
+const RESTORE_FLAG_NAMES = {
+    '--revision': 'revision',
+    '--base-fingerprint': 'baseFingerprint'
+};
+export const restoreMemory = async (cfg, io, rest) => {
+    const clearMissing = rest.includes('--clear-missing');
+    const { flags, positionals, unknown, notAnId } = parseArgs(RESTORE_FLAG_NAMES, rest.filter((a) => a !== '--clear-missing'), [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 1 ||
+        flags.revision === undefined ||
+        flags.baseFingerprint === undefined) {
+        return refusal(`Usage: lattris restore memory <id> --revision <n> --base-fingerprint <head>\n`);
+    }
+    if (!REVISION_NO_SHAPE.test(flags.revision)) {
+        return refusal(`--revision must be a positive number from the history: ${flags.revision}\n`);
+    }
+    if (!FINGERPRINT_SHAPE.test(flags.baseFingerprint)) {
+        return refusal(`--base-fingerprint must be the 64 lowercase hex characters history printed: ${flags.baseFingerprint}\n`);
+    }
+    const identity = requireWriteIdentity(io.store, io.stdin.isTTY);
+    if (isRefusal(identity))
+        return identity;
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const result = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(positionals[0])}/restore`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...noteWriteHeaders(identity) },
+        body: JSON.stringify({
+            revisionNo: flags.revision,
+            baseFingerprint: flags.baseFingerprint,
+            ...(clearMissing ? { missingReferences: 'clear' } : {})
+        })
+    });
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    let address;
+    if (io.stdout.isTTY)
+        address = await composeAddressFor(cfg, io, accessToken, result.data);
+    emit(io, result.data, result.rawText, (m) => `Restored.\n\n${formatMemoryDetail(m, address)}`);
+};
+//# sourceMappingURL=restore.js.map

package/dist/memory/save-session-chain.js

@@ -0,0 +1,59 @@
+export class ChainSaveError extends Error {
+    epoch;
+    status;
+    body;
+    constructor(epoch, status, body) {
+        super(`epoch ${epoch} save failed (${status} ${body.code ?? ''}): ${body.message ?? 'no message'}`);
+        this.epoch = epoch;
+        this.status = status;
+        this.body = body;
+    }
+}
+export const driveChain = async (chain, receipts, judgment, save) => {
+    const results = [];
+    let previousBlockId;
+    for (let k = 0; k < chain.epochs.length; k++) {
+        const turns = chain.epochs[k];
+        const isLive = k === chain.epochs.length - 1;
+        const base = { turns, source: chain.source };
+        if (chain.conversationId !== null)
+            base.externalConversationId = chain.conversationId;
+        if (isLive && judgment.title !== undefined)
+            base.title = judgment.title;
+        if (isLive && judgment.aiSummary !== undefined)
+            base.aiSummary = judgment.aiSummary;
+        if (judgment.contributor !== undefined)
+            base.contributor = judgment.contributor;
+        const hinted = receipts.epochs[String(k)];
+        let outcome;
+        let forked = false;
+        if (hinted !== undefined) {
+            outcome = await save({ ...base, extends: hinted });
+            if (outcome.status === 409 && outcome.body.code === 'memory:session-diverged') {
+                outcome = await save({ ...base, asNewBlock: true, forkedFrom: hinted });
+                forked = true;
+            }
+            else if (outcome.status === 400 && outcome.body.code === 'memory:unknown-extends') {
+                outcome = await save(previousBlockId !== undefined ? { ...base, continuesFrom: previousBlockId } : base);
+            }
+        }
+        else {
+            outcome = await save(previousBlockId !== undefined && k > 0 ? { ...base, continuesFrom: previousBlockId } : base);
+        }
+        if (outcome.status !== 200 || !outcome.body.block?.id) {
+            throw new ChainSaveError(k, outcome.status, outcome.body);
+        }
+        const blockId = outcome.body.block.id;
+        receipts.epochs[String(k)] = blockId;
+        results.push({
+            epoch: k,
+            blockId,
+            outcome: outcome.body.outcome ?? 'unknown',
+            turnCount: outcome.body.turnCount ?? turns.length,
+            forked
+        });
+        previousBlockId = blockId;
+    }
+    return results;
+};
+//# sourceMappingURL=save-session-chain.js.map

package/dist/memory/transcript.js

@@ -0,0 +1,88 @@
+import { waitsForNameLines } from "../render/rows.js";
+import { sanitizeForTerminal } from "../render/text.js";
+const AUDIO_MIME_BY_EXT = {
+    mp3: 'audio/mpeg',
+    m4a: 'audio/mp4',
+    mp4: 'audio/mp4',
+    wav: 'audio/wav',
+    ogg: 'audio/ogg',
+    oga: 'audio/ogg',
+    webm: 'audio/webm',
+    flac: 'audio/flac',
+    aac: 'audio/aac'
+};
+export const mimeForAudio = (filename, override) => {
+    if (override !== undefined)
+        return override;
+    const ext = filename.slice(filename.lastIndexOf('.') + 1).toLowerCase();
+    return AUDIO_MIME_BY_EXT[ext] ?? null;
+};
+export const convertPlainTranscript = (raw) => {
+    const speakers = {};
+    const keyByLabel = new Map();
+    const turns = [];
+    const keyFor = (label) => {
+        const existing = keyByLabel.get(label);
+        if (existing !== undefined)
+            return existing;
+        const n = keyByLabel.size;
+        const key = String.fromCharCode(97 + (n % 26)) + (n >= 26 ? String(Math.floor(n / 26)) : '');
+        keyByLabel.set(label, key);
+        speakers[key] = { label };
+        return key;
+    };
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        const colon = trimmed.indexOf(':');
+        if (colon > 0 && colon < 40) {
+            const label = trimmed.slice(0, colon).trim();
+            const text = trimmed.slice(colon + 1).trim();
+            turns.push({ speaker: keyFor(label), text });
+        }
+        else if (turns.length > 0) {
+            turns[turns.length - 1].text += `\n${trimmed}`;
+        }
+        else {
+            turns.push({ speaker: keyFor('speaker'), text: trimmed });
+        }
+    }
+    return { speakers, turns };
+};
+export const TRANSCRIPT_CONVERTERS = {
+    json: (raw) => JSON.parse(raw),
+    a: (raw) => convertPlainTranscript(raw)
+};
+export const RECORDING_FORMATS = Object.keys(TRANSCRIPT_CONVERTERS);
+export const buildRecordingBody = (input) => {
+    const body = {};
+    for (const [k, v] of Object.entries(input)) {
+        if (v === undefined)
+            continue;
+        if (k === 'allowBannedWords' && v !== true)
+            continue;
+        body[k] = v;
+    }
+    return body;
+};
+export const formatRecording = (r) => {
+    const lines = [`Saved recording ${r.id}`];
+    if (r.title)
+        lines.push(`  title        ${sanitizeForTerminal(r.title)}`);
+    const stands = [];
+    if (r.media)
+        stands.push(`audio${r.media.status ? ` (${r.media.status})` : ''}`);
+    if (r.sourceUrl)
+        stands.push('source');
+    if (r.transcript)
+        stands.push(`transcript${Array.isArray(r.transcript.turns) ? ` (${r.transcript.turns.length} turns)` : ''}`);
+    lines.push(`  stands on    ${stands.join(', ') || '(nothing yet)'}`);
+    if (r.durationSeconds)
+        lines.push(`  duration     ${r.durationSeconds}s`);
+    lines.push(`  capturedAt   ${r.capturedAt}`);
+    for (const sentence of waitsForNameLines(r.access))
+        lines.push(`  website      ${sentence}`);
+    return lines.join('\n');
+};
+//# sourceMappingURL=transcript.js.map