lattris 0.2.0 → 0.2.1

package/dist/build.json

@@ -1,4 +1 @@
-{
-  "commit": "8b66c9fde9fb6cd5cf716c08fa0e1ed1234c0651",
-  "builtAt": "2026-09-27T23:55:25.807Z"
-}
+{"commit":"6045dca8f744658deeee2c8dfd61fe1aed6a619b","builtAt":"2026-10-03T04:07:32Z"}

package/dist/dispatch-form.js

@@ -1,12 +1,12 @@
 import { audiencesOf } from "./nouns/index.js";
 import { emit } from "./render/output.js";
 import { confirmAction } from "./render/prompt.js";
-import { ambiguousText, formatContact } from "./render/rows.js";
+import { ambiguousText, formatContact, groupsNotBuilt, isGroupWord } from "./render/rows.js";
 import { renderRunHint, sanitizeForTerminal } from "./render/text.js";
 import { signedIn } from "./request/access-token.js";
 import { refusalOf } from "./request/api-fetch.js";
 import { EXIT, isRefusal } from "./store/exit.js";
-import { buildBody, describeAudience, fillIn, readWords, refuse, resolveContact, urlOf } from "./dispatch-words.js";
+import { buildBody, describeAudience, fillIn, fillPath, readWords, refuse, resolveContact, urlOf } from "./dispatch-words.js";
 export const runForm = async (cfg, io, form, rest) => {
     const typed = readWords(form, rest);
     if (isRefusal(typed))
@@ -34,6 +34,8 @@ export const runForm = async (cfg, io, form, rest) => {
     if (steps.requireFlag && typed.flags[steps.requireFlag.key] === undefined) {
         return refuse(steps.requireFlag.message);
     }
+    if (selector !== undefined && isGroupWord(selector))
+        return refuse(groupsNotBuilt(selector));
     if (steps.pipedNeedsYes && !io.stdin.isTTY && !typed.on.has('--yes')) {
         return refuse(steps.pipedNeedsYes.message);
     }
@@ -53,8 +55,17 @@ export const runForm = async (cfg, io, form, rest) => {
     if (typeof accessToken !== 'string')
         return accessToken;
     let missingName;
+    const reserved = [
+        ...(steps.contact?.publicWord === undefined ? [] : [steps.contact.publicWord]),
+        ...(steps.contact?.reserved ?? [])
+    ];
+    const refusedWord = selector !== undefined ? steps.contact?.refusedWords?.[selector] : undefined;
+    if (refusedWord !== undefined)
+        return refuse(refusedWord);
     const wantsPublic = steps.contact?.publicWord !== undefined && selector === steps.contact.publicWord;
-    if (steps.contact && selector !== undefined && !wantsPublic) {
+    if (selector !== undefined && reserved.includes(selector))
+        context.reserved = selector;
+    if (steps.contact && selector !== undefined && context.reserved === undefined) {
         const contacts = await io.api(accessToken, `${cfg.apiUrl}/contacts`);
         if (!contacts.ok)
             return refusalOf(contacts);
@@ -108,6 +119,7 @@ export const runForm = async (cfg, io, form, rest) => {
             name,
             title: sanitizeForTerminal(context.memory?.title ?? '(untitled)'),
             'memory.id': context.memory?.id ?? '',
+            'contact.id': context.contact?.id ?? '',
             audience: context.contact?.displayName ?? describeAudience(selector ?? '')
         });
         const answer = await confirmAction(io, question);
@@ -134,19 +146,28 @@ export const runForm = async (cfg, io, form, rest) => {
         context.createdContact = true;
         body = buildBody(form, typed, stdin, context);
     }
-    else if (context.contact !== undefined || wantsPublic) {
+    else if (context.contact !== undefined || wantsPublic || context.reserved !== undefined) {
         body = buildBody(form, typed, stdin, context);
     }
     const url = urlOf(cfg.apiUrl, form, typed, stdin, context);
-    const result = await io.api(accessToken, url, body === undefined
+    const send = (at) => io.api(accessToken, at, body === undefined
         ? { method: form.request.method }
         : {
             method: form.request.method,
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(body)
         });
+    let result = await send(url);
+    const fallback = form.request.fallback;
+    if (!result.ok &&
+        fallback !== undefined &&
+        result.status === fallback.status &&
+        context.contact?.claimedPersonId) {
+        result = await send(new URL(`${cfg.apiUrl}${fillPath(fallback.path, typed, context)}`));
+    }
     if (!result.ok) {
-        return refusalOf(result, form.ambiguousRefusal ? ambiguousText(result.body) : '');
+        return refusalOf(result, (form.ambiguousRefusal ? ambiguousText(result.body) : '') +
+            (form.refusalWords?.(result.body, context) ?? ''));
     }
     const typedView = context;
     if (form.pickFromList) {

package/dist/dispatch-words.js

@@ -1,3 +1,4 @@
+import { resolveContact } from "./render/rows.js";
 import { renderRunHint } from "./render/text.js";
 import { parseArgs } from "./request/flags.js";
 import { EXIT, refusal } from "./store/exit.js";
@@ -84,6 +85,9 @@ export const valueOf = (source, typed, stdin, context) => {
     return typed.on.has(source.switch) ? source.value : source.otherwise;
 };
 export const buildBody = (form, typed, stdin, context) => {
+    if (context.reserved !== undefined && form.request.bodyFor?.[context.reserved]) {
+        return form.request.bodyFor[context.reserved];
+    }
     if (form.request.bodyWithPublic && context.contact === undefined) {
         return form.request.bodyWithPublic;
     }
@@ -99,16 +103,16 @@ export const buildBody = (form, typed, stdin, context) => {
     }
     return body;
 };
-export const pathOf = (form, typed, context) => {
-    const template = form.request.pathWithPublic && context.contact === undefined
+export const pathOf = (form, typed, context) => fillPath((context.reserved !== undefined && form.request.pathFor?.[context.reserved]) ||
+    (form.request.pathWithPublic && context.contact === undefined
         ? form.request.pathWithPublic
-        : form.request.path;
-    return template
-        .replace(/\{(--[a-z-]+):([^}]*)\}/g, (_m, name, text) => typed.on.has(name) ? text : '')
-        .replace(/\{p(\d+)\}/g, (_m, i) => encodeURIComponent(typed.positionals[Number(i)] ?? ''))
-        .replace('{memory.id}', encodeURIComponent(context.memory?.id ?? typed.positionals[0] ?? ''))
-        .replace('{contact.claimedPersonId}', () => encodeURIComponent(String(context.contact?.claimedPersonId ?? '')));
-};
+        : form.request.path), typed, context);
+export const fillPath = (template, typed, context) => template
+    .replace(/\{(--[a-z-]+):([^}]*)\}/g, (_m, name, text) => typed.on.has(name) ? text : '')
+    .replace(/\{p(\d+)\}/g, (_m, i) => encodeURIComponent(typed.positionals[Number(i)] ?? ''))
+    .replace('{memory.id}', encodeURIComponent(context.memory?.id ?? typed.positionals[0] ?? ''))
+    .replace('{contact.claimedPersonId}', () => encodeURIComponent(String(context.contact?.claimedPersonId ?? '')))
+    .replace('{contact.id}', () => encodeURIComponent(String(context.contact?.id ?? '')));
 export const urlOf = (apiUrl, form, typed, stdin, context) => {
     const url = new URL(`${apiUrl}${pathOf(form, typed, context)}`);
     for (const [key, sources] of Object.entries(form.request.query ?? {})) {
@@ -120,18 +124,10 @@ export const urlOf = (apiUrl, form, typed, stdin, context) => {
     }
     return url;
 };
-export const resolveContact = (contacts, selector) => {
-    if (isUuidKey(selector)) {
-        const contact = contacts.find((c) => c.id.toLowerCase() === selector.toLowerCase());
-        return contact ? { kind: 'found', contact } : { kind: 'missing-id' };
-    }
-    const folded = selector.toLowerCase();
-    const matches = contacts.filter((c) => c.displayName.toLowerCase() === folded);
-    if (matches.length === 1)
-        return { kind: 'found', contact: matches[0] };
-    if (matches.length > 1)
-        return { kind: 'ambiguous', matches };
-    return { kind: 'missing-name', displayName: selector };
-};
-export const describeAudience = (audience) => audience === 'public' ? 'public — anyone, including people without accounts' : audience;
+export { resolveContact };
+export const describeAudience = (audience) => audience === 'public'
+    ? 'public — anyone, including people without accounts'
+    : audience === 'all-contacts'
+        ? 'all your contacts'
+        : audience;
 //# sourceMappingURL=dispatch-words.js.map

package/dist/memory/access.js

@@ -0,0 +1,88 @@
+import { HELP_TOKENS, parseArgs } from "../request/flags.js";
+import { emit } from "../render/output.js";
+import { ambiguousText, describeForContact, formatAccessRow, formatContact, resolveContact } from "../render/rows.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+import { signedIn } from "../request/access-token.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { EXIT, refusal } from "../store/exit.js";
+export const GET_ACCESS_HELP = [
+    'get access — may one contact, or one phone number, see a memory of yours,',
+    'and because of which share.',
+    '',
+    'Usage:',
+    '  lattris get access <memory-id-or-prefix> --for <contact | number>',
+    '',
+    '  --for   an exact contact name or id from `lattris contact list`, or a',
+    '          phone number in full international form (+ then digits). A',
+    '          number no contact holds is a stranger, who sees public memories',
+    '          only.',
+    '',
+    'Answers open or shut, and the rows that decided it: the denies that reach',
+    'the contact when one does, the allows that reach them when open, or',
+    'nothing when nothing is set.'
+].join('\n');
+const ACCESS_FLAGS = { '--for': 'for' };
+const isPhoneWord = (word) => word.startsWith('+');
+const formatAccessDecision = (d, asked) => {
+    const who = d.forContact === null
+        ? sanitizeForTerminal(asked)
+        : sanitizeForTerminal(d.forContact.displayName);
+    const stranger = d.forContact === null ? ` (${describeForContact(null, asked)})` : '';
+    const verdict = d.open
+        ? `open — ${who} may see it${stranger}`
+        : `shut — ${who} may not see it${stranger}`;
+    const because = d.decidedBy.length === 0
+        ? d.forContact === null
+            ? 'because: no public share'
+            : 'because: nothing is set for them'
+        : `because: ${d.decidedBy.map(formatAccessRow).join('; ')}`;
+    return `${verdict}\n${because}`;
+};
+export const contactIdFor = async (cfg, io, accessToken, word) => {
+    const contacts = await io.api(accessToken, `${cfg.apiUrl}/contacts`);
+    if (!contacts.ok)
+        return refusalOf(contacts);
+    const shown = sanitizeForTerminal(word);
+    const resolution = resolveContact(contacts.data, word.trim());
+    if (resolution.kind === 'ambiguous') {
+        const list = resolution.matches.map((c) => `  ${formatContact(c)}`).join('\n');
+        return refusal(`${shown} matches more than one of your contacts:\n${list}\nUse a contact id instead.\n`);
+    }
+    if (resolution.kind !== 'found') {
+        return refusal(`No contact ${shown} among yours. ${renderRunHint(['contact', 'list'])} shows them.\n`, EXIT.GENERIC);
+    }
+    return { id: resolution.contact.id };
+};
+export const getAccess = async (cfg, io, rest) => {
+    if (rest.length === 0 || rest.some((t) => HELP_TOKENS.has(t))) {
+        io.stdout.write(`${GET_ACCESS_HELP}\n`);
+        return;
+    }
+    const { flags, positionals, unknown, notAnId } = parseArgs(ACCESS_FLAGS, rest, [0]);
+    if (unknown)
+        return refusal(`Unknown flag: ${unknown}\n`);
+    if (notAnId)
+        return refusal(notAnId);
+    if (positionals.length !== 1 || flags.for === undefined) {
+        return refusal(`Usage: lattris get access <memory-id-or-prefix> --for <contact | number>\n`);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const url = new URL(`${cfg.apiUrl}/memories/${encodeURIComponent(positionals[0])}/access`);
+    if (isPhoneWord(flags.for)) {
+        url.searchParams.set('forPhone', flags.for);
+    }
+    else {
+        const contact = await contactIdFor(cfg, io, accessToken, flags.for);
+        if ('exit' in contact)
+            return contact;
+        url.searchParams.set('forContact', contact.id);
+    }
+    const result = await io.api(accessToken, url);
+    if (!result.ok)
+        return refusalOf(result, ambiguousText(result.body));
+    const asked = flags.for;
+    emit(io, result.data, result.rawText, (d) => formatAccessDecision(d, asked));
+};
+//# sourceMappingURL=access.js.map

package/dist/memory/capture-common.js

@@ -1,5 +1,110 @@
+import { formatContact, groupsNotBuilt, isGroupWord, resolveContact, waitsForNameLines } from "../render/rows.js";
 import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
-export const buildCreateNoteBody = (content, flags, allowBannedWords = false) => {
+import { refusalOf } from "../request/api-fetch.js";
+import { EXIT, refusal } from "../store/exit.js";
+const PUBLIC_WORDS = 'public — anyone, including people without accounts';
+export const takeShareFlags = (args) => {
+    const rest = [];
+    const shareWith = [];
+    const deny = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const eq = arg.indexOf('=');
+        const name = eq === -1 ? arg : arg.slice(0, eq);
+        if (name !== '--share-with' && name !== '--deny') {
+            rest.push(arg);
+            continue;
+        }
+        let value;
+        if (eq !== -1)
+            value = arg.slice(eq + 1);
+        else {
+            value = args[i + 1];
+            if (value === undefined || value.startsWith('--')) {
+                return { rest, shareWith, deny, unknown: name };
+            }
+            i++;
+        }
+        (name === '--share-with' ? shareWith : deny).push(value);
+    }
+    return { rest, shareWith, deny };
+};
+export const checkShareWords = (shareWith, deny) => {
+    const group = [...shareWith, ...deny].find(isGroupWord);
+    if (group !== undefined)
+        return refusal(groupsNotBuilt(group));
+    if (deny.includes('public')) {
+        return refusal('public cannot be denied: --deny names a contact or all-contacts. Leave --share-with public off to keep it private.\n');
+    }
+    const seen = new Set();
+    for (const word of [...shareWith, ...deny]) {
+        const key = word.trim().toLowerCase();
+        if (seen.has(key)) {
+            return refusal(`${sanitizeForTerminal(word)} is named twice — name each audience once, with one effect.\n`);
+        }
+        seen.add(key);
+    }
+    return undefined;
+};
+export const allowWords = (shareWith) => shareWith.map((w) => w === 'public'
+    ? PUBLIC_WORDS
+    : w === 'all-contacts'
+        ? 'all your contacts'
+        : sanitizeForTerminal(w));
+const sharePhrase = (allows) => allows.length === 1 && allows[0] === PUBLIC_WORDS
+    ? `make it ${PUBLIC_WORDS}`
+    : `share it with ${allows.join(', ')}`;
+export const needsYesWords = (noun, allows) => {
+    const arrived = noun === 'session' ? 'the turns' : 'the content';
+    return (`This will save the ${noun} AND ${sharePhrase(allows)}. There is no prompt here (${arrived} already ` +
+        'arrived on a pipe) — pass --yes once the person has confirmed both facts.\n');
+};
+export const resolveBornShares = async (cfg, io, accessToken, shareWith, deny) => {
+    const shares = { access: [], allows: allowWords(shareWith) };
+    const words = [
+        ...shareWith.map((w) => [w, 'allow']),
+        ...deny.map((w) => [w, 'deny'])
+    ];
+    let contacts;
+    for (const [word, effect] of words) {
+        if (word === 'public') {
+            shares.audience = 'public';
+            continue;
+        }
+        if (word === 'all-contacts') {
+            shares.access.push({ kind: 'all_contacts', effect });
+            continue;
+        }
+        if (contacts === undefined) {
+            const read = await io.api(accessToken, `${cfg.apiUrl}/contacts`);
+            if (!read.ok)
+                return refusalOf(read);
+            contacts = read.data;
+        }
+        const shown = sanitizeForTerminal(word);
+        const resolution = resolveContact(contacts, word.trim());
+        if (resolution.kind === 'ambiguous') {
+            const list = resolution.matches.map((c) => `  ${formatContact(c)}`).join('\n');
+            return refusal(`${shown} matches more than one of your contacts:\n${list}\nUse a contact id instead.\n`);
+        }
+        if (resolution.kind !== 'found') {
+            return refusal(`No contact ${shown} among yours. ${renderRunHint(['contact', 'list'])} shows them.\n`, EXIT.GENERIC);
+        }
+        if (shares.access.some((a) => a.kind === 'contact' && a.contactId === resolution.contact.id)) {
+            return refusal(`${shown} is named twice — name each audience once, with one effect.\n`);
+        }
+        shares.access.push({ kind: 'contact', contactId: resolution.contact.id, effect });
+    }
+    return shares;
+};
+export const isRefusalValue = (value) => typeof value === 'object' && value !== null && 'exit' in value && 'message' in value;
+export const withShares = (body, shares) => {
+    if (shares?.audience !== undefined)
+        body.audience = shares.audience;
+    if (shares !== undefined && shares.access.length > 0)
+        body.access = shares.access;
+};
+export const buildCreateNoteBody = (content, flags, allowBannedWords = false, shares) => {
     const body = { content };
     if (flags.intent !== undefined)
         body.intent = flags.intent;
@@ -7,8 +112,7 @@ export const buildCreateNoteBody = (content, flags, allowBannedWords = false) =>
         body.title = flags.title;
     if (flags.capturedAt !== undefined)
         body.capturedAt = flags.capturedAt;
-    if (flags.shareWith !== undefined)
-        body.audience = flags.shareWith;
+    withShares(body, shares);
     if (flags.contributor !== undefined)
         body.contributor = flags.contributor;
     if (flags.aiSummary !== undefined)
@@ -32,6 +136,8 @@ export const formatSaved = (b, address) => {
         lines.push(`  revisionNo   ${b.revisionNo}`);
     if (address)
         lines.push(`  address      ${address}`);
+    for (const sentence of waitsForNameLines(b.access))
+        lines.push(`  website      ${sentence}`);
     return lines.join('\n');
 };
 export const CAPTURE_MEMORY_FLAG_NAMES = {
@@ -40,7 +146,6 @@ export const CAPTURE_MEMORY_FLAG_NAMES = {
     '--intent': 'intent',
     '--title': 'title',
     '--captured-at': 'capturedAt',
-    '--share-with': 'shareWith',
     '--source': 'source',
     '--conversation-id': 'conversationId',
     '--extends': 'extends',
@@ -63,5 +168,4 @@ export const SESSION_ONLY_FLAGS = [
     ['--forked-from', 'forkedFrom']
 ];
 export const retryWords = (path) => renderRunHint(['resend', path]);
-export const SHARE_AUDIENCES = ['public'];
 //# sourceMappingURL=capture-common.js.map

package/dist/memory/capture-help.js

@@ -70,12 +70,18 @@ to save     text arrives on stdin — no quoting; up to 5MB.
               --intent       <name>   optional; default none
               --title        <text>   optional; one line, what this is about
               --captured-at  <time>   optional; when it happened, if not now
-              --share-with   public   optional; makes it public immediately — one
-                                       confirmation covers both facts. Omit to stay
-                                       private (the default). Requires --yes: there
-                                       is no prompt here, the content already
-                                       arrived on a pipe — pass it once the person
-                                       has confirmed both saving AND publishing.
+              --share-with   <who>    optional, repeatable; who may see it from birth:
+                                       public, all-contacts, or one of your contacts
+                                       by name or id; group:<name> is reserved for
+                                       groups, which are not built yet. Omit to stay private (the
+                                       default). Requires --yes: there is no prompt
+                                       here, the content already arrived on a pipe —
+                                       pass it once the person has confirmed both
+                                       saving AND sharing.
+              --deny         <who>    optional, repeatable; who may not, whatever else
+                                       allows it: all-contacts or one contact. Needs
+                                       no --yes. public cannot be denied, and a deny
+                                       beside --share-with public is refused.
 
               --ai-summary   <text>   optional; an AI-written abstract beside the
                                        title — a finding aid, never the record;
@@ -173,9 +179,12 @@ is the conversation, not the machinery.
     --contributor       <uuid>  optional; whose expression — a contact id, attributed
                                to that person's voice. Applied to EVERY epoch in a
                                transcript chain (re-running heals older epochs too)
-    --share-with       public  optional; public from birth — requires --yes, same law
-                               as a note
-    --yes                      confirms save AND publish together
+    --share-with       <who>   optional, repeatable; public, all-contacts or a contact,
+                               from birth — requires --yes, same law as a note;
+                               group:<name> is reserved for groups, not built yet
+    --deny             <who>   optional, repeatable; all-contacts or a contact shut out
+                               from birth, whatever else allows it
+    --yes                      confirms save AND share together
 
 A divergence refusal (the thread differs from the stored session) means a fork:
 nothing was written; re-run with --as-new --forked-from <that block> once the

package/dist/memory/capture-note.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { ambiguousText, formatEdgeReceipt } from "../render/rows.js";
 import { parseArgs } from "../request/flags.js";
-import { CAPTURE_MEMORY_FLAG_NAMES, SESSION_ONLY_FLAGS, SHARE_AUDIENCES, buildCreateNoteBody, formatSaved, retryWords } from "../memory/capture-common.js";
+import { CAPTURE_MEMORY_FLAG_NAMES, SESSION_ONLY_FLAGS, allowWords, buildCreateNoteBody, checkShareWords, formatSaved, isRefusalValue, needsYesWords, resolveBornShares, retryWords, takeShareFlags } from "../memory/capture-common.js";
 import { CAPTURE_NOTE_HELP, CAPTURE_SESSION_HELP } from "../memory/capture-help.js";
 import { captureSession, captureSessionTranscript } from "../memory/capture-session.js";
 import { composeAddressFor } from "../memory/views.js";
@@ -34,7 +34,9 @@ export const captureMemory = async (cfg, io, args) => {
     const yes = args.includes('--yes');
     const asNew = args.includes('--as-new');
     const allowBanned = args.includes('--allow-banned-words');
-    const { flags, positionals, unknown } = parseArgs(CAPTURE_MEMORY_FLAG_NAMES, args.filter((a) => a !== '--yes' && a !== '--as-new' && a !== '--allow-banned-words'));
+    const taken = takeShareFlags(args.filter((a) => a !== '--yes' && a !== '--as-new' && a !== '--allow-banned-words'));
+    const { flags, positionals, unknown } = parseArgs(CAPTURE_MEMORY_FLAG_NAMES, taken.rest);
+    const sharesNamed = taken.shareWith.length > 0 || taken.deny.length > 0;
     const piped = !io.stdin.isTTY && positionals.length === 0;
     const wantsNote = !asksForSessionForm(args) && (flags.type ?? 'note') === 'note';
     const early = piped && wantsNote ? requireWriteIdentity(io.store, io.stdin.isTTY) : undefined;
@@ -45,9 +47,12 @@ export const captureMemory = async (cfg, io, args) => {
         io.stdout.write(`${asksForSessionForm(args) ? CAPTURE_SESSION_HELP : CAPTURE_NOTE_HELP}\n`);
         return;
     }
-    if (unknown) {
-        return refusal(`Unknown flag: ${unknown}\n`);
+    if (unknown ?? taken.unknown) {
+        return refusal(`Unknown flag: ${unknown ?? taken.unknown}\n`);
     }
+    const badShareWords = checkShareWords(taken.shareWith, taken.deny);
+    if (badShareWords)
+        return badShareWords;
     if (flags.contributor !== undefined) {
         const UUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
         if (!UUID_SHAPE.test(flags.contributor)) {
@@ -76,9 +81,14 @@ export const captureMemory = async (cfg, io, args) => {
             return refusal(`Unexpected argument: ${positionals[1]}\n`);
         }
         if (positionals.length === 1) {
-            return captureSessionTranscript(cfg, io, positionals[0], flags, asNew);
+            return captureSessionTranscript(cfg, io, positionals[0], flags, asNew, sharesNamed);
         }
-        return captureSession(cfg, io, content, flags, { yes, asNew });
+        return captureSession(cfg, io, content, flags, {
+            yes,
+            asNew,
+            shareWith: taken.shareWith,
+            deny: taken.deny
+        });
     }
     if (positionals.length > 0) {
         return refusal(`Unexpected argument: ${positionals[0]}\n`);
@@ -110,15 +120,8 @@ export const captureMemory = async (cfg, io, args) => {
     if (flags.linksTo !== undefined && !isUuidKey(flags.linksTo)) {
         return refusal(`--links-to must be the FULL block id (the wire addresses the edge by it; it does not search): ${flags.linksTo}\n`);
     }
-    if (flags.shareWith !== undefined) {
-        if (!SHARE_AUDIENCES.includes(flags.shareWith)) {
-            return refusal(`Unknown audience: ${flags.shareWith}. Accepted: ${SHARE_AUDIENCES.join(', ')}\n`);
-        }
-        if (!yes) {
-            return refusal('This will save the memory AND make it public — anyone, including people ' +
-                'without accounts. There is no prompt here (the content already arrived on ' +
-                'a pipe) — pass --yes once the person has confirmed both facts.\n');
-        }
+    if (taken.shareWith.length > 0 && !yes) {
+        return refusal(needsYesWords('memory', allowWords(taken.shareWith)));
     }
     const identity = early ?? requireWriteIdentity(io.store, io.stdin.isTTY);
     if (isRefusal(identity))
@@ -130,7 +133,14 @@ export const captureMemory = async (cfg, io, args) => {
     const accessToken = await signedIn(io, cfg);
     if (typeof accessToken !== 'string')
         return accessToken;
-    const createBody = buildCreateNoteBody(content, flags, allowBanned);
+    let shares;
+    if (sharesNamed) {
+        const resolved = await resolveBornShares(cfg, io, accessToken, taken.shareWith, taken.deny);
+        if (isRefusalValue(resolved))
+            return resolved;
+        shares = resolved;
+    }
+    const createBody = buildCreateNoteBody(content, flags, allowBanned, shares);
     const requestDraft = {
         door: 'POST /memories/notes',
         idempotencyKey,

package/dist/memory/capture-session.js

@@ -1,7 +1,7 @@
 import { extractChain } from "./extract-claude-jsonl.js";
 import { ChainSaveError, driveChain } from "./save-session-chain.js";
 import { loadReceipts, saveReceipts } from "../store/chains.js";
-import { SHARE_AUDIENCES } from "../memory/capture-common.js";
+import { allowWords, isRefusalValue, needsYesWords, resolveBornShares, withShares } from "../memory/capture-common.js";
 import { emit } from "../render/output.js";
 import { sanitizeForTerminal } from "../render/text.js";
 import { classifyApiError } from "../request/door.js";
@@ -17,7 +17,7 @@ export const formatSavedSession = (r) => {
     lines.push(`  capturedAt   ${r.block.capturedAt}`);
     return lines.join('\n');
 };
-export const buildCaptureSessionBody = (turns, flags, asNew) => {
+export const buildCaptureSessionBody = (turns, flags, asNew, shares) => {
     const body = { turns };
     if (flags.title !== undefined)
         body.title = flags.title;
@@ -35,8 +35,7 @@ export const buildCaptureSessionBody = (turns, flags, asNew) => {
         body.from = Number(flags.from);
     if (asNew)
         body.asNewBlock = true;
-    if (flags.shareWith !== undefined)
-        body.audience = flags.shareWith;
+    withShares(body, shares);
     if (flags.continuesFrom !== undefined)
         body.continuesFrom = flags.continuesFrom;
     if (flags.forkedFrom !== undefined)
@@ -62,23 +61,23 @@ export const captureSession = async (cfg, io, content, flags, opts) => {
     if (flags.from !== undefined && !/^\d+$/.test(flags.from)) {
         return refusal(`--from must be a non-negative integer, got: ${flags.from}\n`);
     }
-    if (flags.shareWith !== undefined) {
-        if (!SHARE_AUDIENCES.includes(flags.shareWith)) {
-            return refusal(`Unknown audience: ${flags.shareWith}. Accepted: ${SHARE_AUDIENCES.join(', ')}\n`);
-        }
-        if (!opts.yes) {
-            return refusal('This will save the session AND make it public — anyone, including people ' +
-                'without accounts. There is no prompt here (the turns already arrived on ' +
-                'a pipe) — pass --yes once the person has confirmed both facts.\n');
-        }
+    if (opts.shareWith.length > 0 && !opts.yes) {
+        return refusal(needsYesWords('session', allowWords(opts.shareWith)));
     }
     const accessToken = await signedIn(io, cfg);
     if (typeof accessToken !== 'string')
         return accessToken;
+    let shares;
+    if (opts.shareWith.length > 0 || opts.deny.length > 0) {
+        const resolved = await resolveBornShares(cfg, io, accessToken, opts.shareWith, opts.deny);
+        if (isRefusalValue(resolved))
+            return resolved;
+        shares = resolved;
+    }
     const result = await io.api(accessToken, `${cfg.apiUrl}/memories/sessions`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(buildCaptureSessionBody(turns, flags, opts.asNew))
+        body: JSON.stringify(buildCaptureSessionBody(turns, flags, opts.asNew, shares))
     });
     if (!result.ok)
         return refusalOf(result);
@@ -87,7 +86,6 @@ export const captureSession = async (cfg, io, content, flags, opts) => {
 const TRANSCRIPT_INAPPLICABLE_FLAGS = [
     ['--intent', 'intent'],
     ['--captured-at', 'capturedAt'],
-    ['--share-with', 'shareWith'],
     ['--source', 'source'],
     ['--conversation-id', 'conversationId'],
     ['--extends', 'extends'],
@@ -96,13 +94,17 @@ const TRANSCRIPT_INAPPLICABLE_FLAGS = [
     ['--forked-from', 'forkedFrom']
 ];
 const formatChainEpoch = (r) => `epoch ${r.epoch}: ${r.outcome}${r.forked ? ' (forked)' : ''} — block ${r.blockId}, ${r.turnCount} turns stored`;
-export const captureSessionTranscript = async (cfg, io, file, flags, asNew) => {
+export const captureSessionTranscript = async (cfg, io, file, flags, asNew, sharesNamed = false) => {
     for (const [name, key] of TRANSCRIPT_INAPPLICABLE_FLAGS) {
         if (flags[key] !== undefined) {
             return refusal(`${name} does not apply when capturing from a transcript — the chain drive ` +
                 `derives it. Only --title and --ai-summary ride this form.\n`);
         }
     }
+    if (sharesNamed) {
+        return refusal('--share-with and --deny do not apply when capturing from a transcript — the chain ' +
+            'drive derives it. Only --title and --ai-summary ride this form.\n');
+    }
     if (asNew) {
         return refusal('--as-new does not apply when capturing from a transcript — a fork is detected ' +
             'and saved by the drive itself.\n');

package/dist/memory/get-help.js

@@ -7,15 +7,17 @@ export const GET_HELP = [
     '  history    one note\u2019s history: every change, newest first, and the head fingerprint',
     '  deleted    your deleted items, with the fingerprint restore and erase need',
     '  questions  the questions left on your tree, open first',
+    '  access     may one contact, or one number, see a memory, and because of what',
     '',
     'Usage:',
-    '  lattris get memories [--shared-with-me] [--q <words>] [--type <name>] [--intent <name>] [--with <audience>] [--limit <n>] [--cursor <token>] [--content 0|1]',
+    '  lattris get memories [--shared-with-me] [--q <words>] [--type <name>] [--intent <name>] [--with <audience>] [--for <contact> | --for-phone <number>] [--limit <n>] [--cursor <token>] [--content 0|1]',
     '  lattris get memories --by <owner-handle> [--limit <n>] [--cursor <token>] [--content 0|1]',
     '  lattris get memory <website-address|id> [--by <owner-handle>] [--links 0|1] [--depth <n>] [--content 0|1]',
     '  lattris get memory <id-or-prefix> --revision <n>      one revision, as history kept it',
     '  lattris get history <id-or-prefix> [--limit <n>] [--before <operation-id>]',
     '  lattris get deleted [--limit <n>] [--cursor <token>]',
     '  lattris get questions [--mine]',
+    '  lattris get access <memory-id-or-prefix> --for <contact | number>',
     '',
     '  --q        <words>   only memories whose title or content contains these words,',
     '                       matched as one literal phrase, case-insensitive. Needs 3+',
@@ -32,6 +34,12 @@ export const GET_HELP = [
     '                       session needs it, while a full address carries it',
     '  --shared-with-me     list memories other people granted to you; each row',
     '                       names its owner and whether it is on your graph',
+    '  --for      <contact> what one of your contacts may see of your memories: an',
+    '                       exact name or id from `lattris contact list`. The rows',
+    '                       carry what they would see; the first line names them',
+    '  --for-phone <number> the same for a phone number in full international',
+    '                       form; a number no contact holds is a stranger, who',
+    '                       sees public memories only',
     '',
     '  --links    0|1       edges on the one memory (default 1): direction, verb,',
     '                       reason, and each neighbour\u2019s finding aid. --links 0',
@@ -53,6 +61,7 @@ export const GET_HELP = [
     'Every read of a note prints its fingerprint (the head of its history) and',
     'revisionNo; every read prints structureHash, a hash of the block\u2019s links and',
     'grants as this reader sees them. An edit sends the fingerprint back as --base-fingerprint.',
+    'Your own read of a memory also prints `access`: every allow and deny on it.',
     '',
     "A memory's web address is <site>/by/<owner-handle>/memories/<slug>-<memory-handle>.",
     'A /by read asks for JSON with Accept: application/json; it sends a bearer',