lattris 0.1.4 → 0.2.0

package/dist/memory/capture-common.js

@@ -0,0 +1,67 @@
+import { renderRunHint, sanitizeForTerminal } from "../render/text.js";
+export const buildCreateNoteBody = (content, flags, allowBannedWords = false) => {
+    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;
+    if (flags.shareWith !== undefined)
+        body.audience = flags.shareWith;
+    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}`);
+    return lines.join('\n');
+};
+export const CAPTURE_MEMORY_FLAG_NAMES = {
+    '--idempotency-key': 'idempotencyKey',
+    '--type': 'type',
+    '--intent': 'intent',
+    '--title': 'title',
+    '--captured-at': 'capturedAt',
+    '--share-with': 'shareWith',
+    '--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]);
+export const SHARE_AUDIENCES = ['public'];
+//# sourceMappingURL=capture-common.js.map

package/dist/memory/capture-help.js

@@ -0,0 +1,186 @@
+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   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.
+
+              --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       public  optional; public from birth — requires --yes, same law
+                               as a note
+    --yes                      confirms save AND publish 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,190 @@
+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_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 { flags, positionals, unknown } = parseArgs(CAPTURE_MEMORY_FLAG_NAMES, args.filter((a) => a !== '--yes' && a !== '--as-new' && a !== '--allow-banned-words'));
+    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) {
+        return refusal(`Unknown flag: ${unknown}\n`);
+    }
+    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);
+        }
+        return captureSession(cfg, io, content, flags, { yes, asNew });
+    }
+    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 (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');
+        }
+    }
+    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;
+    const createBody = buildCreateNoteBody(content, flags, allowBanned);
+    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

package/dist/memory/capture-session.js

@@ -0,0 +1,166 @@
+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 { emit } from "../render/output.js";
+import { sanitizeForTerminal } from "../render/text.js";
+import { classifyApiError } from "../request/door.js";
+import { EXIT, refusal } from "../store/exit.js";
+import { refusalOf } from "../request/api-fetch.js";
+import { signedIn } from "../request/access-token.js";
+export const formatSavedSession = (r) => {
+    const lines = [
+        `Saved session ${r.block.id}  (outcome: ${r.outcome}, turns stored: ${r.turnCount})`
+    ];
+    if (r.block.title)
+        lines.push(`  title        ${sanitizeForTerminal(r.block.title)}`);
+    lines.push(`  capturedAt   ${r.block.capturedAt}`);
+    return lines.join('\n');
+};
+export const buildCaptureSessionBody = (turns, flags, asNew) => {
+    const body = { turns };
+    if (flags.title !== undefined)
+        body.title = flags.title;
+    if (flags.intent !== undefined)
+        body.intent = flags.intent;
+    if (flags.capturedAt !== undefined)
+        body.capturedAt = flags.capturedAt;
+    if (flags.source !== undefined)
+        body.source = flags.source;
+    if (flags.conversationId !== undefined)
+        body.externalConversationId = flags.conversationId;
+    if (flags.extends !== undefined)
+        body.extends = flags.extends;
+    if (flags.from !== undefined)
+        body.from = Number(flags.from);
+    if (asNew)
+        body.asNewBlock = true;
+    if (flags.shareWith !== undefined)
+        body.audience = flags.shareWith;
+    if (flags.continuesFrom !== undefined)
+        body.continuesFrom = flags.continuesFrom;
+    if (flags.forkedFrom !== undefined)
+        body.forkedFrom = flags.forkedFrom;
+    if (flags.aiSummary !== undefined)
+        body.aiSummary = flags.aiSummary;
+    if (flags.contributor !== undefined)
+        body.contributor = flags.contributor;
+    return body;
+};
+export const captureSession = async (cfg, io, content, flags, opts) => {
+    let turns;
+    try {
+        turns = JSON.parse(content);
+    }
+    catch {
+        return refusal('stdin must be a JSON array of turns — [{"speaker":"user","text":"…"}, …]. ' +
+            'Run `lattris capture memory --type session` for the form.\n');
+    }
+    if (!Array.isArray(turns) || turns.length === 0) {
+        return refusal('stdin must be a NON-EMPTY JSON array of turns — a session is at least one turn.\n');
+    }
+    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');
+        }
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    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))
+    });
+    if (!result.ok)
+        return refusalOf(result);
+    io.stdout.write(`${formatSavedSession(result.data)}\n`);
+};
+const TRANSCRIPT_INAPPLICABLE_FLAGS = [
+    ['--intent', 'intent'],
+    ['--captured-at', 'capturedAt'],
+    ['--share-with', 'shareWith'],
+    ['--source', 'source'],
+    ['--conversation-id', 'conversationId'],
+    ['--extends', 'extends'],
+    ['--from', 'from'],
+    ['--continues-from', 'continuesFrom'],
+    ['--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) => {
+    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 (asNew) {
+        return refusal('--as-new does not apply when capturing from a transcript — a fork is detected ' +
+            'and saved by the drive itself.\n');
+    }
+    let jsonl;
+    try {
+        jsonl = io.store.files.readFileSync(file, 'utf8');
+    }
+    catch (e) {
+        const code = e.code ?? 'error';
+        return refusal(`Cannot read transcript ${file} (${code}).\n`);
+    }
+    const chain = extractChain(jsonl);
+    const shapeLine = chain.shape === 'subagent'
+        ? `Read a subagent transcript (agent ${chain.agentId ?? '?'}): ${chain.epochs.length} epoch(s).\n`
+        : `Read a main-session transcript: ${chain.epochs.length} epoch(s).\n`;
+    if (chain.shape === 'subagent' || io.stdout.isTTY)
+        io.stderr.write(shapeLine);
+    if (chain.epochs.length === 0) {
+        return refusal('No dialogue found on the active path — nothing to save.\n', EXIT.GENERIC);
+    }
+    const accessToken = await signedIn(io, cfg);
+    if (typeof accessToken !== 'string')
+        return accessToken;
+    const save = async (body) => {
+        const res = await io.api(accessToken, `${cfg.apiUrl}/memories/sessions`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        });
+        const text = res.rawText;
+        let parsed;
+        try {
+            const b = JSON.parse(text);
+            parsed = b && typeof b === 'object' ? b : {};
+        }
+        catch {
+            parsed = { message: text.slice(0, 200) };
+        }
+        return { status: res.status, body: parsed };
+    };
+    const receipts = loadReceipts(io.store, chain.conversationId);
+    let results;
+    try {
+        results = await driveChain(chain, receipts, { title: flags.title, aiSummary: flags.aiSummary, contributor: flags.contributor }, save);
+    }
+    catch (e) {
+        if (e instanceof ChainSaveError) {
+            const { message, next, exit } = classifyApiError(e.status, e.body);
+            return {
+                message: '',
+                exit,
+                answer: { kind: 'door', message: `epoch ${e.epoch}: ${message}`, next }
+            };
+        }
+        throw e;
+    }
+    saveReceipts(io.store, chain.conversationId, receipts);
+    emit(io, results, JSON.stringify(results), (rs) => rs.map(formatChainEpoch).join('\n'));
+};
+//# sourceMappingURL=capture-session.js.map