lattris 0.1.3 → 0.2.0

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,85 @@
+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}`);
+    return lines.join('\n');
+};
+//# sourceMappingURL=transcript.js.map

package/dist/memory/update-help.js

@@ -0,0 +1,126 @@
+export const UPDATE_HELP = [
+    'update — correct a memory you already kept.',
+    '',
+    'For fixing words: a typo, a wrong word, a better title. The record stays the',
+    'same act, kept at the same moment, at the same address.',
+    '',
+    'A new thought is a NEW capture, not an edit — growing a record into something',
+    'it was not is how a record stops being true.',
+    '',
+    'Never delete and re-capture to fix words. That burns the address and the',
+    'original capture time, which are the two things a correction exists to keep.',
+    '',
+    'Usage:',
+    '  echo "..." | lattris update memory <id> --base-fingerprint <fp>      replace the words',
+    '  lattris update memory <photo-id> --expected-updated-at <time> --title "..."   a non-note',
+    '  lattris update memory <id> --base-fingerprint <fp> --title "..."     retitle only',
+    '  lattris update memory <id> --base-fingerprint <fp> --ai-summary "..."',
+    '  lattris update memory <id> --base-fingerprint <fp> --intent <word>',
+    '  lattris update memory <id> --base-fingerprint <fp> --clear-intent',
+    '  echo "..." | lattris update memory <id> --overwrite --reason "..."   replace on purpose',
+    '',
+    '  --base-fingerprint <fp>',
+    '                 a NOTE\u2019s guard: the fingerprint the read you built this edit',
+    '                 on returned — `get memory <id>` prints it.',
+    '  --expected-updated-at <time>',
+    '                 every OTHER type\u2019s guard (a photo, video, session, recording',
+    '                 keeps no fingerprint yet): the updatedAt that read returned.',
+    '                 One guard or --overwrite is required; missing, the edit is',
+    '                 refused here before any words are read.',
+    '  --overwrite    replace whatever is there now, on purpose. Needs --reason, which',
+    '                 is recorded on the note’s history. Sends an Idempotency-Key minted',
+    '                 for this run; a lost response keeps the request under drafts with',
+    '                 that key, and --idempotency-key <uuid> resends it so a retry can',
+    '                 never overwrite twice.',
+    '',
+    '  <id>           a full id or a >=4-char prefix, like `get memory` — an',
+    '                 ambiguous prefix refuses and lists the matches',
+    '  --title        optional; one line, what this is about',
+    '  --ai-summary   optional; the AI-written abstract beside the title — a',
+    '                 finding aid, never the record; correctable forever',
+    '  --intent       optional; a fresh claim about what the record is — the API',
+    '                 owns the words (action/decision/truth/learning/noticed/…)',
+    '                 and an unknown one refuses with the accepted set. A photo',
+    '                 or video carries no intent and says so.',
+    '  --contributor  optional; whose expression this is — a contact id, the same',
+    '                 flag capture takes (`lattris contact list` shows yours)',
+    '  --clear-intent remove the declared intent (there is no magic value —',
+    '                 "none" is not vocabulary and would refuse)',
+    '  --allow-banned-words',
+    '                 keep flagged wording deliberately — without it, certain',
+    '                 words in new words or a new title refuse, and the refusal',
+    '                 names every word found. Rephrase first; override only when',
+    '                 the wording is meant.',
+    '',
+    '  Content arrives on stdin, like capture — no quoting, up to 5MB. Pipe',
+    '  nothing and the words are left exactly as they were.',
+    '',
+    '  The write carries the fingerprint you read. If another session changed',
+    '  the note in between, the door refuses (memory:stale-write), nothing is',
+    '  written, your draft is kept under drafts/ in the machine dir (0600) and',
+    '  the refusal prints where the note stands now: read it again, re-apply',
+    '  your change to those words, and update with that fingerprint. If the',
+    '  note already carries exactly what you sent, the answer is "already',
+    '  saved" and the exit is 0. Two sessions editing one note never erase each',
+    '  other, and every change is kept: `lattris get history <id>`.',
+    '',
+    '  Every note write names its session (X-Lattris-Session-Id): at a terminal',
+    '  one is minted per terminal session; off one, set LATTRIS_SESSION_ID.',
+    '  LATTRIS_AGENT adds a readable label.',
+    '',
+    '  Send nothing at all and there is nothing to do — that is refused here,',
+    '  before the network, rather than spending a round trip to be told.',
+    '',
+    '  A session takes --title, --ai-summary, --intent and --clear-intent (its',
+    '  turns are never edited — new turns go through capture); its receipt is',
+    '  the index row, never the conversation echoed back.',
+    '',
+    'An edge can be corrected too — its REASON only. (from, verb, to) is the',
+    'edge’s identity and never changes here: a different verb is a different',
+    'claim, made by deleting one edge and creating the other.',
+    '',
+    '  lattris update edge <id> --verb <verb> --to <id> --reason "..."',
+    '',
+    '  <id>       the cause-side block — full id or a >=4-char prefix, like',
+    '             `update memory`',
+    '  --verb     required; the edge’s verb, exactly as the read shows it',
+    '  --to       required; the effect-side block — the FULL id from the edge',
+    '             as read, never a prefix (it names WHICH edge; it does not',
+    '             search)',
+    '  --reason   required; the replacement annotation, one line, written to',
+    '             the future walker — when is this edge worth following.',
+    '             Replaces in full; nothing records the previous wording.',
+    '',
+    'A recording’s transcript and speaker map are corrected too — see',
+    '`lattris update recording` for the full form:',
+    '',
+    '  lattris update recording transcript <id> <file> [--force]',
+    '  lattris update recording speakers <id> <key>=me|<contact-id>|clear',
+    '',
+    'updated → prints the id, what changed, and the address.'
+].join('\n');
+export const UPDATE_FLAG_NAMES = {
+    '--title': 'title',
+    '--ai-summary': 'aiSummary',
+    '--intent': 'intent',
+    '--base-fingerprint': 'baseFingerprint',
+    '--expected-updated-at': 'expectedUpdatedAt',
+    '--reason': 'reason',
+    '--idempotency-key': 'idempotencyKey',
+    '--contributor': 'contributor'
+};
+export const FINGERPRINT_SHAPE = /^[0-9a-f]{64}$/;
+const ISO_INSTANT = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?(Z|[+-]\d{2}:\d{2})$/;
+export const isIsoInstant = (value) => {
+    const m = ISO_INSTANT.exec(value);
+    if (!m)
+        return false;
+    const [, y, mo, d, h, mi, s] = m.map(Number);
+    if (mo < 1 || mo > 12 || h > 23 || mi > 59 || s > 60)
+        return false;
+    const daysInMonth = new Date(Date.UTC(y, mo, 0)).getUTCDate();
+    if (d < 1 || d > daysInMonth)
+        return false;
+    return !Number.isNaN(Date.parse(value));
+};
+//# sourceMappingURL=update-help.js.map

package/dist/memory/update.js

@@ -0,0 +1,220 @@
+import { randomUUID } from 'node:crypto';
+import { parseArgs } from "../request/flags.js";
+import { retryWords } from "../memory/capture-common.js";
+import { FINGERPRINT_SHAPE, UPDATE_FLAG_NAMES, isIsoInstant } from "../memory/update-help.js";
+import { composeAddressFor, formatBlockLine, formatMemoryDetail } from "../memory/views.js";
+import { emit } from "../render/output.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { alreadySaved, saveEditDraft, saveRequestDraft } from "../store/drafts.js";
+import { EXIT, isRefusal, refusal } from "../store/exit.js";
+import { isUuidKey, noteWriteHeaders, requireWriteIdentity } from "../store/write-identity.js";
+import { signedIn } from "../request/access-token.js";
+import { ambiguousText } from "../render/rows.js";
+export const updateMemory = async (cfg, io, args) => {
+    const clearIntent = args.includes('--clear-intent');
+    const allowBanned = args.includes('--allow-banned-words');
+    const overwrite = args.includes('--overwrite');
+    const { flags, positionals, unknown, notAnId } = parseArgs(UPDATE_FLAG_NAMES, args.filter((a) => a !== '--clear-intent' && a !== '--allow-banned-words' && a !== '--overwrite'), [0]);
+    if (unknown) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 1) {
+        return refusal(`${UPDATE_USAGE}\n`);
+    }
+    if (overwrite && flags.baseFingerprint !== undefined) {
+        return refusal('--overwrite and --base-fingerprint contradict each other; pass one.\n');
+    }
+    if (overwrite && (flags.reason === undefined || flags.reason.trim().length === 0)) {
+        return refusal('--overwrite needs --reason "...": why the current words are being replaced on purpose. ' +
+            'It is recorded on the note’s history.\n');
+    }
+    if (!overwrite && flags.reason !== undefined) {
+        return refusal('--reason rides --overwrite; pass both or neither.\n');
+    }
+    if (flags.baseFingerprint !== undefined && flags.expectedUpdatedAt !== undefined) {
+        return refusal('--base-fingerprint and --expected-updated-at are two guards; a note takes the first, ' +
+            'every other type the second. Pass one.\n');
+    }
+    if (overwrite && flags.expectedUpdatedAt !== undefined) {
+        return refusal('--overwrite and --expected-updated-at contradict each other; pass one.\n');
+    }
+    if (!overwrite && flags.baseFingerprint === undefined && flags.expectedUpdatedAt === undefined) {
+        return refusal(`A guard is required: --base-fingerprint <fp> for a note (the fingerprint the read you ` +
+            `built this edit on returned — ${renderRunHint(['get', 'memory', positionals[0]])} prints it), ` +
+            'or --expected-updated-at <time> for a photo, video, session or recording (the updatedAt ' +
+            'that read returned). Nothing was read and nothing was written. To replace the words on ' +
+            'purpose whatever is there now, pass --overwrite --reason "...".\n');
+    }
+    if (flags.expectedUpdatedAt !== undefined && !isIsoInstant(flags.expectedUpdatedAt)) {
+        return refusal(`--expected-updated-at must be the updatedAt a read printed, an ISO instant with its zone ` +
+            `(2026-09-03T05:02:40.118Z): ${flags.expectedUpdatedAt}\n`);
+    }
+    if (flags.baseFingerprint !== undefined && !FINGERPRINT_SHAPE.test(flags.baseFingerprint)) {
+        return refusal(`--base-fingerprint must be the 64 lowercase hex characters a read printed: ${flags.baseFingerprint}\n`);
+    }
+    if (flags.idempotencyKey !== undefined && !overwrite) {
+        return refusal('--idempotency-key rides --overwrite (a guarded edit needs no key).\n');
+    }
+    if (flags.idempotencyKey !== undefined && !isUuidKey(flags.idempotencyKey)) {
+        return refusal(`--idempotency-key must be the UUID a draft printed: ${flags.idempotencyKey}\n`);
+    }
+    const identity = requireWriteIdentity(io.store, io.stdin.isTTY);
+    if (isRefusal(identity))
+        return identity;
+    const piped = !io.stdin.isTTY;
+    const typed = piped ? await io.stdin.read() : '';
+    const content = typed.length > 0 ? typed : undefined;
+    const sendTitle = flags.title !== undefined;
+    const sendAiSummary = flags.aiSummary !== undefined;
+    const sendContent = content !== undefined;
+    const sendIntent = flags.intent !== undefined;
+    const sendContributor = flags.contributor !== undefined;
+    if (sendContributor && !isUuidKey(flags.contributor)) {
+        return refusal(`--contributor must be a valid UUID (contact id): ${flags.contributor}\n`);
+    }
+    if (sendIntent && clearIntent) {
+        return refusal('--intent and --clear-intent contradict each other; pass one.\n');
+    }
+    if (!sendTitle &&
+        !sendAiSummary &&
+        !sendContent &&
+        !sendIntent &&
+        !clearIntent &&
+        !sendContributor) {
+        return refusal('Nothing to update: pipe new words in, or pass --title, --ai-summary, --intent, --clear-intent or --contributor.\n');
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const body = {};
+    if (sendTitle)
+        body.title = flags.title;
+    if (sendAiSummary)
+        body.aiSummary = flags.aiSummary;
+    if (sendContent)
+        body.content = content;
+    if (sendIntent)
+        body.intent = flags.intent;
+    if (clearIntent)
+        body.intent = null;
+    if (sendContributor)
+        body.contributor = flags.contributor;
+    if (allowBanned)
+        body.allowBannedWords = true;
+    if (overwrite)
+        body.overwrite = { reason: flags.reason.trim() };
+    else if (flags.baseFingerprint !== undefined)
+        body.baseFingerprint = flags.baseFingerprint;
+    else
+        body.expectedUpdatedAt = flags.expectedUpdatedAt;
+    const idempotencyKey = overwrite ? (flags.idempotencyKey ?? randomUUID()) : undefined;
+    const blockUrl = `${cfg.apiUrl}/memories/${encodeURIComponent(positionals[0])}`;
+    const editDraft = () => ({
+        door: `PATCH /memories/${positionals[0]}`,
+        sessionId: identity.sessionId,
+        agentLabel: identity.agentLabel,
+        baseFingerprint: body.baseFingerprint,
+        expectedUpdatedAt: body.expectedUpdatedAt,
+        overwrite: body.overwrite,
+        allowBannedWords: body.allowBannedWords,
+        fields: {
+            ...(sendTitle ? { title: body.title } : {}),
+            ...(sendAiSummary ? { aiSummary: body.aiSummary } : {}),
+            ...(sendIntent || clearIntent ? { intent: body.intent } : {}),
+            ...(sendContent ? { content: body.content } : {}),
+            ...(sendContributor ? { contributor: body.contributor } : {})
+        }
+    });
+    const keepWords = () => saveEditDraft(io.store, positionals[0], editDraft());
+    const requestDraft = overwrite
+        ? {
+            door: `PATCH /memories/${positionals[0]}`,
+            idempotencyKey: idempotencyKey,
+            sessionId: identity.sessionId,
+            agentLabel: identity.agentLabel,
+            body: body
+        }
+        : undefined;
+    const keepRequest = () => saveRequestDraft(io.store, 'overwrite', requestDraft);
+    const keptWhere = (kept) => kept.wordsPath
+        ? `Your draft is kept at ${kept.draftPath} (every field sent) and its words at ${kept.wordsPath}` +
+            ' — pipe that file back to restore them exactly.'
+        : `Your draft is kept at ${kept.draftPath} (every field sent).`;
+    let result;
+    try {
+        result = await io.api(accessToken, blockUrl, {
+            method: 'PATCH',
+            headers: {
+                'Content-Type': 'application/json',
+                ...noteWriteHeaders(identity, idempotencyKey)
+            },
+            body: JSON.stringify(body)
+        });
+    }
+    catch (e) {
+        const lost = `The response was lost (${sanitizeForTerminal(e instanceof Error ? e.message : String(e))}). `;
+        if (overwrite) {
+            const path = keepRequest();
+            return refusal(`${lost}The request is kept at ${path}. Resend it exactly, same session and same key, with ` +
+                `${retryWords(path)} — if it landed, the door answers the same receipt and overwrites nothing again.\n`, EXIT.GENERIC);
+        }
+        return refusal(`${lost}${keptWhere(keepWords())} Read the block again and retry with its fingerprint.\n`, EXIT.GENERIC);
+    }
+    if (!result.ok) {
+        const matches = ambiguousText(result.body);
+        if (result.body.code === 'memory:stale-write') {
+            const detail = (result.body.detail ?? {});
+            const current = (detail.current ?? {});
+            if (alreadySaved(body, current)) {
+                return {
+                    ...refusalOf(result, matches +
+                        `Already saved: the block already carries these words (revision ${String(detail.currentRevisionNo ?? '?')}, ` +
+                        `fingerprint ${String(detail.currentFingerprint ?? '?')}). Nothing to do.\n`),
+                    exit: EXIT.OK
+                };
+            }
+            const kept = keepWords();
+            if (io.stdout.isTTY) {
+                return refusalOf(result, matches +
+                    `The block now stands at revision ${String(detail.currentRevisionNo ?? '?')}, fingerprint ` +
+                    `${String(detail.currentFingerprint ?? '?')}. Nothing was written. ${keptWhere(kept)} ` +
+                    `Read it with ${renderRunHint(['get', 'memory', positionals[0]])}, re-apply your change to ` +
+                    'those words, and update again with that fingerprint — or replace them on purpose with ' +
+                    '--overwrite --reason "...".\n' +
+                    (typeof current.content === 'string'
+                        ? `\n${sanitizeForTerminal(current.content, Infinity)}\n`
+                        : ''));
+            }
+            io.stdout.write(`${JSON.stringify({ ...result.body, draftPath: kept.draftPath, wordsPath: kept.wordsPath ?? null, draft: editDraft().fields })}\n`);
+            return refusalOf(result, matches);
+        }
+        if (overwrite && result.exit !== EXIT.USAGE && result.exit !== EXIT.NOAUTH) {
+            const path = keepRequest();
+            return refusalOf(result, matches +
+                `The request is kept at ${path}. Once the cause above is settled, resend it exactly with ${retryWords(path)}\n`);
+        }
+        return refusalOf(result, matches);
+    }
+    let address;
+    if (io.stdout.isTTY && !('visibility' in result.data)) {
+        address = await composeAddressFor(cfg, io, accessToken, result.data);
+    }
+    const changed = [
+        sendTitle ? 'title' : undefined,
+        sendAiSummary ? 'ai summary' : undefined,
+        sendContent ? 'words' : undefined,
+        sendIntent ? 'intent' : undefined,
+        clearIntent ? 'intent (cleared)' : undefined
+    ]
+        .filter((c) => c !== undefined)
+        .join(' and ');
+    emit(io, result.data, result.rawText, (m) => 'visibility' in m
+        ? `Updated ${changed}.\n\n${formatBlockLine(m)}`
+        : `Updated ${changed}.\n\n${formatMemoryDetail(m, address)}`);
+};
+const UPDATE_USAGE = 'Usage: lattris update memory <id> (--base-fingerprint <fp> | --expected-updated-at <time> | --overwrite --reason "...") ' +
+    '[--title "..."] [--ai-summary "..."] [--intent <word>] [--clear-intent] [--allow-banned-words] [--idempotency-key <uuid>]';
+//# sourceMappingURL=update.js.map

package/dist/memory/views.js

@@ -0,0 +1,138 @@
+import { formatAudiences } from "../render/rows.js";
+import { sanitizeForTerminal } from "../render/text.js";
+import { stripTrailingSlash } from "../store/environment.js";
+export const formatDeletedLine = (b) => `${b.id}  ${b.deletedAt ?? '-'}  rev ${b.revisionNo ?? '-'}  ${b.fingerprint ?? '-'}  ${sanitizeForTerminal(b.title ?? '(untitled)')}`;
+export const formatDeletedPage = (page) => page.items.map((i) => formatDeletedLine(i)).join('\n');
+export const formatBlockLine = (b) => b.ownerHandle === undefined
+    ? `${b.id}  ${b.handle}  ${b.capturedAt}  ${b.intent ?? '-'}  ${b.visibility.public ? 'public' : '-'}  ${sanitizeForTerminal(b.title ?? '(untitled)')}`
+    : `${b.id}  ${b.handle}  ${b.capturedAt}  by ${sanitizeForTerminal(b.ownerDisplayName ?? b.ownerHandle)} (@${b.ownerHandle})  ${b.consented ? 'on graph' : 'off graph'}  ${sanitizeForTerminal(b.title ?? '(untitled)')}`;
+const SLUG_MAX = 60;
+const slugify = (title) => (title ?? '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, SLUG_MAX)
+    .replace(/-+$/g, '');
+export const composeAddress = (webUrl, personHandle, block) => {
+    const slug = slugify(block.title);
+    const ref = slug ? `${slug}-${block.handle}` : block.handle;
+    return `${webUrl}/by/${personHandle}/memories/${ref}`;
+};
+export const parseWebsiteMemoryAddress = (webUrl, value) => {
+    try {
+        const base = new URL(webUrl);
+        const address = new URL(value);
+        if (address.origin !== base.origin || address.username || address.password)
+            return undefined;
+        const basePath = stripTrailingSlash(base.pathname);
+        const route = address.pathname.slice(basePath.length);
+        if (!address.pathname.startsWith(`${basePath}/by/`))
+            return undefined;
+        const parts = route.split('/');
+        if (parts.length !== 5 || parts[1] !== 'by' || parts[3] !== 'memories')
+            return undefined;
+        const ownerHandle = decodeURIComponent(parts[2]);
+        const ref = decodeURIComponent(parts[4]);
+        if (!ownerHandle || !ref || ownerHandle.includes('/') || ref.includes('/'))
+            return undefined;
+        return { ownerHandle, ref };
+    }
+    catch {
+        return undefined;
+    }
+};
+export const ownHandleFor = async (cfg, io, accessToken) => {
+    try {
+        const me = await io.api(accessToken, `${cfg.apiUrl}/person/me`);
+        if (!me.ok)
+            return undefined;
+        const { handle } = me.data;
+        return typeof handle === 'string' && handle.length > 0 ? handle : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const composeAddressFor = async (cfg, io, accessToken, block) => {
+    const handle = await ownHandleFor(cfg, io, accessToken);
+    return handle ? composeAddress(cfg.webUrl, handle, block) : undefined;
+};
+export const formatSessionTurn = (t) => {
+    const header = `[${t.position}] ${sanitizeForTerminal(t.speaker)}${t.saidAt ? `  ${t.saidAt}` : ''}`;
+    const body = sanitizeForTerminal(t.text, Infinity);
+    return t.kind === 'compaction-summary'
+        ? `── compaction boundary ──\n${header}\n${body}`
+        : `${header}\n${body}`;
+};
+export const formatMemoryDetail = (m, address) => {
+    const lines = [`id           ${m.id}`, `handle       ${m.handle}`, `type         ${m.type}`];
+    if (m.intent)
+        lines.push(`intent       ${m.intent}`);
+    lines.push(`capturedAt   ${m.capturedAt}`);
+    if (m.title)
+        lines.push(`title        ${sanitizeForTerminal(m.title)}`);
+    if (m.source)
+        lines.push(`source       ${sanitizeForTerminal(m.source)}`);
+    lines.push(`audiences    ${formatAudiences(m.audiences)}`);
+    if (m.fingerprint)
+        lines.push(`fingerprint  ${m.fingerprint}`);
+    if (m.revisionNo)
+        lines.push(`revisionNo   ${m.revisionNo}`);
+    if (m.structureHash)
+        lines.push(`structure    ${m.structureHash}`);
+    if (m.deletedAt)
+        lines.push(`deletedAt    ${m.deletedAt}`);
+    if (address)
+        lines.push(`address      ${address}`);
+    if (Array.isArray(m.turns)) {
+        lines.push('', m.turns.map((t) => formatSessionTurn(t)).join('\n\n'));
+    }
+    else {
+        lines.push('', sanitizeForTerminal(m.content ?? '', Infinity));
+    }
+    return lines.join('\n');
+};
+export const formatMemoryPage = (page) => page.items.map((i) => formatBlockLine(i)).join('\n');
+export const formatFindingAid = (a) => {
+    const lines = [`id           ${a.id}`, `handle       ${a.handle}`, `type         ${a.type}`];
+    if (a.title)
+        lines.push(`title        ${sanitizeForTerminal(a.title)}`);
+    if (a.aiSummary)
+        lines.push(`aiSummary    ${sanitizeForTerminal(a.aiSummary, Infinity)}`);
+    if (a.fingerprint)
+        lines.push(`fingerprint  ${a.fingerprint}`);
+    if (a.revisionNo)
+        lines.push(`revisionNo   ${a.revisionNo}`);
+    if (a.structureHash)
+        lines.push(`structure    ${a.structureHash}`);
+    return lines.join('\n');
+};
+export const formatWalkLink = (l) => {
+    const arrow = l.direction === 'out' ? '\u2192' : '\u2190';
+    const title = l.node.title ? `  ${sanitizeForTerminal(l.node.title)}` : '';
+    const reason = l.reason ? `  \u2014 ${sanitizeForTerminal(l.reason, Infinity)}` : '';
+    const dir = l.direction === 'out' ? 'out' : 'in ';
+    return `${dir} ${sanitizeForTerminal(l.verb)} ${arrow} ${l.node.handle} (${l.node.type})${title}${reason}`;
+};
+export const formatNodeWalk = (w, address) => {
+    const parts = [
+        'capturedAt' in w.node ? formatMemoryDetail(w.node, address) : formatFindingAid(w.node)
+    ];
+    if (w.links !== undefined) {
+        parts.push('', w.links.length === 0
+            ? 'links        (none)'
+            : `links\n${w.links.map((l) => `  ${formatWalkLink(l)}`).join('\n')}`);
+    }
+    if (w.walk !== undefined) {
+        for (const n of w.walk) {
+            const title = n.node.title ? `  ${sanitizeForTerminal(n.node.title)}` : '';
+            parts.push('', `\u2500\u2500 ${n.node.handle} (${n.node.type})${title}`);
+            if (n.node.aiSummary)
+                parts.push(`   ${sanitizeForTerminal(n.node.aiSummary, Infinity)}`);
+            for (const l of n.links)
+                parts.push(`   ${formatWalkLink(l)}`);
+        }
+    }
+    return parts.join('\n');
+};
+//# sourceMappingURL=views.js.map

package/dist/nouns/consent.js

@@ -0,0 +1,29 @@
+export const CONSENT_HELP = [
+    'consent — choose whether a memory shared with you appears on your graph.',
+    '',
+    'Usage:',
+    '  lattris consent <id-or-prefix>',
+    '  lattris consent <id-or-prefix> --withdraw',
+    '',
+    'The choice is yours alone. Withdrawing a share hides the block regardless;',
+    'if its owner shares it again later, your previous choice still stands.'
+].join('\n');
+export const consent = {
+    verb: 'consent',
+    form: {
+        usage: 'Usage: lattris consent <id-or-prefix> [--withdraw]',
+        switches: ['--withdraw'],
+        positionals: 1,
+        idPositionals: [0],
+        request: {
+            method: 'PUT',
+            path: '/memories/{p0}/consent',
+            body: { consented: { switch: '--withdraw', value: false, otherwise: true } }
+        },
+        ambiguousRefusal: true,
+        render: (state, typed) => state.consented
+            ? `Memory ${typed.positionals[0]} may appear on your graph.`
+            : `Memory ${typed.positionals[0]} will stay off your graph.`
+    }
+};
+//# sourceMappingURL=consent.js.map