lattris 0.1.4 → 0.2.1

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

@@ -0,0 +1,171 @@
+import { formatContact, groupsNotBuilt, isGroupWord, resolveContact, waitsForNameLines } from "../render/rows.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+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;
+    if (flags.title !== undefined)
+        body.title = flags.title;
+    if (flags.capturedAt !== undefined)
+        body.capturedAt = flags.capturedAt;
+    withShares(body, shares);
+    if (flags.contributor !== undefined)
+        body.contributor = flags.contributor;
+    if (flags.aiSummary !== undefined)
+        body.aiSummary = flags.aiSummary;
+    if (allowBannedWords)
+        body.allowBannedWords = true;
+    return body;
+};
+export const formatSaved = (b, address) => {
+    const lines = [`Saved memory ${b.id}  (type: ${b.type})`];
+    if (b.intent)
+        lines.push(`  intent       ${b.intent}`);
+    if (b.title)
+        lines.push(`  title        ${sanitizeForTerminal(b.title)}`);
+    if (b.aiSummary)
+        lines.push(`  aiSummary    ${sanitizeForTerminal(b.aiSummary, Infinity)}`);
+    lines.push(`  capturedAt   ${b.capturedAt}`);
+    if (b.fingerprint)
+        lines.push(`  fingerprint  ${b.fingerprint}`);
+    if (b.revisionNo)
+        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 = {
+    '--idempotency-key': 'idempotencyKey',
+    '--type': 'type',
+    '--intent': 'intent',
+    '--title': 'title',
+    '--captured-at': 'capturedAt',
+    '--source': 'source',
+    '--conversation-id': 'conversationId',
+    '--extends': 'extends',
+    '--from': 'from',
+    '--continues-from': 'continuesFrom',
+    '--forked-from': 'forkedFrom',
+    '--ai-summary': 'aiSummary',
+    '--contributor': 'contributor',
+    '--linked-from': 'linkedFrom',
+    '--links-to': 'linksTo',
+    '--verb': 'verb',
+    '--reason': 'reason'
+};
+export const SESSION_ONLY_FLAGS = [
+    ['--source', 'source'],
+    ['--conversation-id', 'conversationId'],
+    ['--extends', 'extends'],
+    ['--from', 'from'],
+    ['--continues-from', 'continuesFrom'],
+    ['--forked-from', 'forkedFrom']
+];
+export const retryWords = (path) => renderRunHint(['resend', path]);
+//# sourceMappingURL=capture-common.js.map

package/dist/memory/capture-help.js

@@ -0,0 +1,195 @@
+export const CAPTURE_INDEX = [
+    "capture — keep a record of what's real.",
+    '',
+    'Types:',
+    '  note        written words — --type defaults to it',
+    '  session     a conversation with an AI, kept as an append-only ledger',
+    '  recording   audio, its source, and its transcript',
+    '  rows        rows of a dataset, newline-delimited JSON',
+    '',
+    'Go one word deeper:',
+    '  lattris capture memory                       how to save a note (capture note accepted too)',
+    '  echo "…" | lattris capture memory            save one',
+    '  lattris capture memory --type session        how to save a conversation (capture session accepted too)',
+    '  lattris capture session <transcript.jsonl>   save a Claude Code conversation, whole chain',
+    '  lattris capture recording                    how to save audio + transcript',
+    '  lattris capture rows                         how to save rows into a dataset',
+    '',
+    'To read what you have kept: lattris get memories',
+    ''
+].join('\n');
+export const CAPTURE_NOTE_HELP = `capture — keep a record of what's real.
+
+Better information leads to better decisions. So aim for the record that's as close
+to true as it can be right now — every word one they'd read back and recognise as
+their own.
+
+Nothing is saved until they've seen exactly what will be saved and said yes. That yes
+is them deciding this is worth keeping, in these words.
+
+The intent says how far they've taken it. Don't push for a higher intent — help them
+get the record closer to personal truth, and the intent follows. Effort spent
+producing a record is not distance travelled with it: a long summary nobody has read
+back is still no intent.
+
+No intent is fine, and common — it means held, not yet placed. A two-word note to
+self and a careful research summary both sit here. It's kept, and it's found later.
+It just doesn't speak for who they are, and that's what the intents are for.
+
+If it came from somewhere else, say so in the words.
+
+Offer a one-line title — what this is about. It's how they'll find it later.
+
+Which intent? Take the first that fits.
+
+already done it                              → action
+choosing what will happen, and why           → decision
+their own words, and they stand behind it    → truth
+reviewed it and agree with it                → learning
+what they observed or thought at the time    → noticed
+none of these                                → no intent
+
+Examples
+
+action      "Cancelled the gym membership."
+decision    "We're moving in March — the school run is killing us."
+truth       "I am the problem, therefore I am the solution."
+learning    "Sleep matters more than the extra hour of work."
+noticed     "Mum seemed quieter than usual today."
+            "I think I've been avoiding that call."
+no intent   "That thing about the school waiting list — look into it."
+            "Summary of the article on sleep — haven't decided what I make of it."
+
+to save     text arrives on stdin — no quoting; up to 5MB.
+
+            lattris capture                          which forms exist
+            lattris capture memory                   prints this (capture note accepted too)
+            echo "..." | lattris capture memory      saves it, no intent
+
+              --type         <name>   optional; default note (session is the other form)
+              --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   <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;
+                                       correctable forever (up to 2000 chars).
+
+              --allow-banned-words    optional; keep flagged wording deliberately.
+                                       Without it, certain words in the text or
+                                       title refuse, and the refusal names every
+                                       word found — rephrase first, override only
+                                       when the wording is meant.
+
+              --linked-from  <id>     optional; the EXISTING memory points at the
+                                       new one (how the new one becomes reachable
+                                       from the tree). Full id or a >=4-char
+                                       prefix. Requires --verb and --reason.
+              --links-to     <id>     optional; the NEW memory points outward at
+                                       an existing one. FULL id only (the wire
+                                       addresses the edge by it). Requires --verb
+                                       and --reason. One direction per capture —
+                                       a second edge is its own \`lattris link\`.
+              --verb         <verb>   with a direction flag; the server's registry
+                                       owns the vocabulary — an unknown verb
+                                       refuses with the accepted set for the pair.
+              --reason       <text>   with a direction flag; required, one line —
+                                       written to the future walker: when is this
+                                       edge worth following. Never invented.
+
+              --contributor  <uuid>   optional; whose expression this is — a contact id.
+                                       The block is attributed to that person's voice.
+                                       Correctable later via PATCH (provenance, not authorship).
+
+            saved → prints the id and what was stored.
+
+            a conversation is a different form: lattris capture memory --type session`;
+export const CAPTURE_SESSION_HELP = `capture session — keep a conversation as a ledger.
+
+One context EPOCH is one block: the dialogue as it occurred — who spoke, what they
+said, when — kept append-only; a turn, once written, never changes. Save at any
+checkpoint, as often as wanted; only what's new lands. The server decides
+create-vs-extend from the words themselves — send the thread, read the receipt.
+
+When the context resets (a compaction, or a new-file restart), the conversation
+CHAINS: save the next epoch as its OWN block with --continues-from naming the
+previous epoch's block id (from your own prior receipt) — the compaction summary
+rides as the new block's opening kind:"compaction-summary" marker turn, so every
+block reads self-contained. Appending forever into one block stays available via
+--extends. Blocks stay chapter-sized; the chain is the conversation.
+
+From a Claude Code transcript, the WHOLE chain lands in one command:
+
+  lattris capture session <transcript.jsonl> [--title "…"] [--ai-summary "…"]
+
+It extracts the conversation deterministically (the active path only — dead
+rewind branches excluded, tool noise and thinking stripped; a compaction
+boundary opens a new epoch) and materialises every epoch oldest-first: extends
+where a prior save exists, creates-and-links where one doesn't, saves a fork
+where the words diverged — server-verified, receipts cached, idempotent: run
+it as often as wanted. --title and --ai-summary apply to the live epoch's
+save; every other flag below belongs to the stdin form (the drive derives
+those facts itself). Prints one receipt line per epoch. With a transcript
+file named, stdin is ignored entirely — the file is the content — so the
+command works the same under a pipe as at a terminal.
+
+For any other source, turns arrive on stdin as a JSON array, in order:
+
+  [{"speaker":"user","text":"…","saidAt":"2026-08-20T10:00:00Z"}, …]
+
+speaker and text are required (they ARE a turn's identity); saidAt, kind
+("compaction-summary" opens a post-reset epoch), externalMessageId and
+externalParentMessageId are optional. Strip tool noise before saving — the record
+is the conversation, not the machinery.
+
+  echo "$TURNS" | lattris capture memory --type session
+
+    --title            <text>  optional; one line — proposed at save, stays correctable
+    --ai-summary       <text>  optional; the AI-written abstract beside the title —
+                               a finding aid, never the record; correctable forever
+    --intent           <name>  optional; default none
+    --captured-at      <time>  optional; when the conversation happened (backfill door)
+    --source           <name>  optional; where — claude-code, chatgpt, codex
+    --conversation-id  <id>    optional; the vendor's own conversation id. It only
+                               NOMINATES prior saves for verification — the words decide
+    --extends          <id>    optional; a block id from a prior save — the receipt that
+                               makes a partial thread lawful
+    --from             <n>     optional; the position the thread starts at (default 0 —
+                               the whole thread; nonzero requires --extends)
+    --continues-from   <id>    optional; the PREVIOUS epoch's block id — the new block
+                               and its continued_as link land together
+    --as-new                   save as a deliberate NEW block, bypassing conversation-id
+                               matching — the fork capture after a divergence refusal
+    --forked-from      <id>    optional; with --as-new only: the origin this thread
+                               rewound from. The server verifies the claim against the
+                               words (a real shared prefix AND a real divergence)
+                               before the forked_into link exists
+    --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       <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
+person confirms it is its own record.
+
+saved → prints the receipt: the id, the outcome (created | extended | unchanged),
+and the stored turn count — the position a later partial save resumes from.`;
+//# sourceMappingURL=capture-help.js.map

package/dist/memory/capture-note.js

@@ -0,0 +1,200 @@
+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, 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";
+import { emit } from "../render/output.js";
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { 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";
+const edgeBody = (verb, toBlockId, reason) => ({
+    verb,
+    toBlockId,
+    reason
+});
+export const asksForSessionForm = (args) => {
+    let last;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--type') {
+            last = args[i + 1];
+            i++;
+        }
+        else if (args[i].startsWith('--type=')) {
+            last = args[i].slice('--type='.length);
+        }
+    }
+    return last === 'session';
+};
+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 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;
+    if (early !== undefined && isRefusal(early))
+        return early;
+    const content = io.stdin.isTTY || positionals.length > 0 ? '' : await io.stdin.read();
+    if (content.length === 0 && positionals.length === 0) {
+        io.stdout.write(`${asksForSessionForm(args) ? CAPTURE_SESSION_HELP : CAPTURE_NOTE_HELP}\n`);
+        return;
+    }
+    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)) {
+            return refusal(`--contributor must be a valid UUID (contact id): ${flags.contributor}\n`);
+        }
+    }
+    const type = flags.type ?? 'note';
+    if (type !== 'note' && type !== 'session') {
+        return refusal(`Unknown type: ${type}. Accepted: note, session.\n`);
+    }
+    if (type === 'session') {
+        if (allowBanned) {
+            return refusal(`--allow-banned-words applies to note captures only.\n`);
+        }
+        for (const [name, key] of [
+            ['--linked-from', 'linkedFrom'],
+            ['--links-to', 'linksTo'],
+            ['--verb', 'verb'],
+            ['--reason', 'reason']
+        ]) {
+            if (flags[key] !== undefined) {
+                return refusal(`${name} applies to note captures only.\n`);
+            }
+        }
+        if (positionals.length > 1) {
+            return refusal(`Unexpected argument: ${positionals[1]}\n`);
+        }
+        if (positionals.length === 1) {
+            return captureSessionTranscript(cfg, io, positionals[0], flags, asNew, sharesNamed);
+        }
+        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`);
+    }
+    for (const [name, key] of SESSION_ONLY_FLAGS) {
+        if (flags[key] !== undefined) {
+            return refusal(`${name} applies to --type session only.\n`);
+        }
+    }
+    if (asNew) {
+        return refusal(`--as-new applies to --type session only.\n`);
+    }
+    if (flags.linkedFrom !== undefined && flags.linksTo !== undefined) {
+        return refusal(`--linked-from and --links-to are two different edges — capture with one, then \`lattris link\` the other.\n`);
+    }
+    const direction = flags.linkedFrom !== undefined || flags.linksTo !== undefined;
+    if (direction) {
+        const missing = [
+            flags.verb === undefined ? '--verb' : undefined,
+            flags.reason === undefined ? '--reason' : undefined
+        ].filter((n) => n !== undefined);
+        if (missing.length > 0) {
+            return refusal(`${flags.linkedFrom !== undefined ? '--linked-from' : '--links-to'} requires ${missing.join(' and ')}.\n`);
+        }
+    }
+    else if (flags.verb !== undefined || flags.reason !== undefined) {
+        return refusal(`${flags.verb !== undefined ? '--verb' : '--reason'} rides a link — pass --linked-from or --links-to with it.\n`);
+    }
+    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 (taken.shareWith.length > 0 && !yes) {
+        return refusal(needsYesWords('memory', allowWords(taken.shareWith)));
+    }
+    const identity = early ?? requireWriteIdentity(io.store, io.stdin.isTTY);
+    if (isRefusal(identity))
+        return identity;
+    if (flags.idempotencyKey !== undefined && !isUuidKey(flags.idempotencyKey)) {
+        return refusal(`--idempotency-key must be the UUID a draft printed: ${flags.idempotencyKey}\n`);
+    }
+    const idempotencyKey = flags.idempotencyKey ?? randomUUID();
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    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,
+        sessionId: identity.sessionId,
+        agentLabel: identity.agentLabel,
+        body: createBody
+    };
+    const keepDraft = () => saveRequestDraft(io.store, 'create', requestDraft);
+    let result;
+    try {
+        result = await io.api(accessToken, `${cfg.apiUrl}/memories/notes`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...noteWriteHeaders(identity, idempotencyKey)
+            },
+            body: JSON.stringify(createBody)
+        });
+    }
+    catch (e) {
+        const path = keepDraft();
+        return refusal(`The response was lost (${sanitizeForTerminal(e instanceof Error ? e.message : String(e))}). ` +
+            `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 makes no second note.\n', EXIT.GENERIC);
+    }
+    if (!result.ok) {
+        if (result.exit === EXIT.USAGE || result.exit === EXIT.NOAUTH)
+            return refusalOf(result);
+        const path = keepDraft();
+        return refusalOf(result, `The request is kept at ${path}. Once the cause above is settled, resend it exactly with ${retryWords(path)}\n`);
+    }
+    const record = result.data;
+    const address = await composeAddressFor(cfg, io, accessToken, record);
+    const { href, ...fields } = record;
+    const receipt = {
+        ...fields,
+        ...(href === undefined ? {} : { href }),
+        ...(address === undefined ? {} : { address })
+    };
+    emit(io, receipt, JSON.stringify(receipt), () => formatSaved(record, address));
+    if (flags.linkedFrom !== undefined || flags.linksTo !== undefined) {
+        const fromRef = flags.linkedFrom ?? record.id;
+        const toId = flags.linkedFrom !== undefined ? record.id : flags.linksTo;
+        const edge = await io.api(accessToken, `${cfg.apiUrl}/memories/${encodeURIComponent(fromRef)}/edges`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(edgeBody(flags.verb, toId, flags.reason))
+        });
+        if (!edge.ok) {
+            return refusalOf(edge, ambiguousText(edge.body) +
+                `The memory was saved; only the link was not made. Finish it with:\n` +
+                `  ${renderRunHint(['link', fromRef, toId, '--verb', flags.verb, '--reason', flags.reason])}\n`);
+        }
+        io.stdout.write(`\n${formatEdgeReceipt('Linked.', edge.data)}\n`);
+    }
+};
+//# sourceMappingURL=capture-note.js.map