@cleocode/core 2026.10.12 → 2026.10.13

package/dist/docs/section-merge.js

@@ -0,0 +1,215 @@
+/**
+ * Section CRDT merge engine — the pure core of the CleoDocs re-architecture
+ * write path (T13355 · spec `cleodocs-rearch-design` §2 option b · D11165).
+ *
+ * Every document section is one Loro document (root `LoroText` named
+ * `content`), persisted as opaque snapshot bytes in the local-only
+ * `section_crdt_states` table. This module is the ONLY production importer of
+ * `llmtxt/crdt-primitives` (the llmtxt WASM-backed Loro primitives); the
+ * store orchestration in `section-write-path.ts` composes these functions
+ * with the canonical `conduit-doc-history.ts` accessors.
+ *
+ * Merge composition (spike finding, T13353): the WASM `crdt_merge_updates`
+ * is LOSSY in llmtxt@2026.5.15 — it returns an empty-doc snapshot for any
+ * input (kryptobaseddev/llmtxt#17, tracked in T13356). All merging here
+ * therefore composes updates via sequential {@link mergeSectionUpdates}
+ * (`crdt_apply_update`), which Loro makes idempotent and convergent:
+ * applying each peer's incremental update in turn yields every edit with an
+ * order-independent final text. `crdt_merge_updates` must NOT be used in the
+ * production path until the upstream fix lands.
+ *
+ * @module
+ * @task T13355
+ * @epic T13340
+ * @saga T13339
+ */
+import { crdt_apply_update, crdt_get_text, crdt_make_incremental_update, crdt_make_state, } from 'llmtxt/crdt-primitives';
+/**
+ * Deterministic section id for a split index. Section ids are positional
+ * (`s0` is the H1 + preamble, `s1` the first `## ` block, …): stable across
+ * devices for the same document shape and independent of heading text.
+ * Positional ids are a known simplification — heading-anchored ids are the
+ * filed follow-up (T13584).
+ *
+ * @param index - The section's position in {@link splitDocIntoSections}.
+ * @returns The section id recorded in `sections_modified`.
+ */
+export function sectionId(index) {
+    return `s${index}`;
+}
+/**
+ * Split a markdown document into sections deterministically: the H1 +
+ * preamble (everything before the first `## ` heading) is section 0; each
+ * `## ` heading starts a new section that runs (with its nested `###`
+ * blocks) to the next `## ` or EOF. Concatenating the sections with
+ * {@link joinSections} reproduces the input byte-for-byte, so the split is
+ * lossless and order-stable.
+ *
+ * @param markdown - The full document text.
+ * @returns The sections in document order.
+ */
+export function splitDocIntoSections(markdown) {
+    const lines = markdown.split('\n');
+    const sections = [];
+    let current = [];
+    for (const line of lines) {
+        if (line.startsWith('## ') && current.length > 0) {
+            sections.push(current.join('\n'));
+            current = [];
+        }
+        current.push(line);
+    }
+    sections.push(current.join('\n'));
+    return sections;
+}
+/**
+ * The inverse of {@link splitDocIntoSections}.
+ *
+ * @param sections - Sections in document order.
+ * @returns The reassembled document text.
+ */
+export function joinSections(sections) {
+    return sections.join('\n');
+}
+/**
+ * Seed a section Loro state from full text (a new or re-based section).
+ *
+ * @param text - The section's full text.
+ * @returns A Loro snapshot encoding the section.
+ */
+export function seedSectionState(text) {
+    return crdt_make_state(text);
+}
+/**
+ * Express one local edit as an incremental Loro update against a base
+ * state. The bundled primitives are append-shaped: the edit is the text to
+ * append to the base section (callers compute it as the tail of the new
+ * text when the old text is a prefix of it).
+ *
+ * @param base - The base section snapshot the edit was authored against.
+ * @param appended - The text the edit appends to the base.
+ * @returns The incremental update (the delta only, not a full snapshot).
+ */
+export function makeSectionEditUpdate(base, appended) {
+    return crdt_make_incremental_update(base, appended);
+}
+/**
+ * Merge incremental section updates onto a base snapshot by sequential
+ * `crdt_apply_update`. This is the production merge composition: Loro import
+ * is idempotent and convergent, so the result carries every applied edit and
+ * is independent of update order. Do NOT replace this with
+ * `crdt_merge_updates` — that WASM export is lossy in llmtxt@2026.5.15
+ * (T13353 spike, T13356, kryptobaseddev/llmtxt#17).
+ *
+ * @param base - The base section snapshot.
+ * @param updates - Peer incremental updates, in any order.
+ * @returns The merged section snapshot.
+ */
+export function mergeSectionUpdates(base, updates) {
+    let state = base;
+    for (const update of updates) {
+        state = crdt_apply_update(state, update);
+    }
+    return state;
+}
+/**
+ * Extract the plain text of a section snapshot.
+ *
+ * @param state - A Loro snapshot from {@link seedSectionState} or {@link mergeSectionUpdates}.
+ * @returns The section's current text.
+ */
+export function sectionStateText(state) {
+    return crdt_get_text(state);
+}
+/**
+ * Apply one section's new text to its stored snapshot.
+ *
+ * `baseText` is the section text the incoming edit was AUTHORED AGAINST —
+ * the caller's concurrency reference (T13674). A base-less write passes the
+ * previous head's section text (single-writer assumption: the writer read
+ * the head and edited it). A write carrying a declared base passes the base
+ * version's section text, so a writer whose fetch predates a concurrent
+ * landing is recognized as stale instead of being mistaken for a
+ * single writer replacing the head.
+ *
+ * While the stored state equals the base text it holds no unlanded edit
+ * relative to what the writer saw, and any difference the writer authored
+ * is an ordinary edit — which the append-shaped primitives cannot express,
+ * so the section is re-seeded from the input and projects EXACTLY
+ * (mid-text replaces and deletions apply verbatim, never a fabricated
+ * concatenation — T13589). When the stored state differs from the base
+ * text, another writer's edit landed after the caller's fetch (T13674):
+ *
+ *   - an incoming edit that is a pure APPEND relative to the common base
+ *     (`nextText` extends `baseText`) composes onto the stored state, so
+ *     both tails survive — this is never a fabrication;
+ *   - any NON-append incoming edit (a replace or delete relative to the
+ *     base) CANNOT be expressed with append-only primitives without
+ *     inventing text, so the function reports `conflicted: true` and keeps
+ *     the stored state untouched. The write path lands the incoming edit as
+ *     its own append-only version row, keeps the stored projection as the
+ *     head, and records the conflict on the head — both versions preserved,
+ *     nothing fabricated.
+ *
+ * Semantics:
+ *
+ *   - `stored === null` (first write of the section): seed a fresh state
+ *     from the new text.
+ *   - The stored text equals the new text: no-op (`changed: false`).
+ *   - `baseText === null` (no base text available for this section — no
+ *     head/base yet, or the reference version's blob is not resolvable
+ *     locally): the single-writer assumption; re-seed from the new text
+ *     (exact).
+ *   - The stored text equals `baseText` (single writer against the
+ *     reference): re-seed from the new text — the input projects exactly,
+ *     deletions included.
+ *   - The stored text differs from `baseText` and the incoming text equals
+ *     `baseText`: the writer authored nothing new; no-op.
+ *   - The stored text differs from `baseText` and the incoming text
+ *     extends `baseText` (append): compose the incoming tail onto the
+ *     stored state; both edits survive, `conflicted: false`.
+ *   - The stored text differs from `baseText` and the incoming edit is a
+ *     non-append relative to `baseText`: `conflicted: true`, stored state
+ *     kept — the write path records the conflict and lands both versions.
+ *
+ * @param stored - The section's stored snapshot, or `null` when none exists.
+ * @param nextText - The section's new full text.
+ * @param baseText - The section's text in the version the incoming edit was
+ *   authored against (previous head for base-less writes, declared base
+ *   otherwise), or `null` when no reference text is available.
+ * @returns The resulting snapshot, whether it changed, and whether the edit
+ *   is a non-append concurrent edit the caller must record as a conflict.
+ * @task T13674 (the baseText reference; T13589/T13595 for the merge shapes)
+ */
+export function applySectionTextEdit(stored, nextText, baseText) {
+    if (stored === null) {
+        return { snapshot: seedSectionState(nextText), changed: true, conflicted: false };
+    }
+    const current = sectionStateText(stored);
+    if (current === nextText) {
+        return { snapshot: stored, changed: false, conflicted: false };
+    }
+    if (baseText === null || current === baseText) {
+        // Single-writer edit: project the input EXACTLY. The primitives can only
+        // append, so a re-seed is the honest encoding of a replace/delete — it
+        // never fabricates a concatenation no writer authored (T13589).
+        return { snapshot: seedSectionState(nextText), changed: true, conflicted: false };
+    }
+    if (nextText === baseText) {
+        // The writer authored nothing beyond the base; the stored (concurrent)
+        // edit stands.
+        return { snapshot: stored, changed: false, conflicted: false };
+    }
+    if (nextText.startsWith(baseText)) {
+        // Concurrent append-append: compose the incoming tail onto the stored
+        // state. Both tails survive and nothing is fabricated (T13585).
+        const update = makeSectionEditUpdate(stored, nextText.slice(baseText.length));
+        return { snapshot: mergeSectionUpdates(stored, [update]), changed: true, conflicted: false };
+    }
+    // Non-append concurrent edit (replace/delete relative to the base): not
+    // expressible with append-only primitives without inventing text — keep
+    // the stored state and let the write path record the conflict, landing
+    // the incoming edit as its own version row (T13595).
+    return { snapshot: stored, changed: false, conflicted: true };
+}
+//# sourceMappingURL=section-merge.js.map

package/dist/docs/section-merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"section-merge.js","sourceRoot":"","sources":["../../src/docs/section-merge.ts"],"names":[],"mappings":"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"}

package/dist/docs/section-write-path.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Docs update write path through the section CRDT merge layer (T13355 ·
+ * spec `cleodocs-rearch-design` §2 option b · D11165).
+ *
+ * Every `cleo docs update` carrying new inline text is projected through
+ * this module after the legacy whole-row write lands (`docs-update.ts`):
+ *
+ *   1. Resolve the doc's immutable uid, adopting a legacy doc into the
+ *      conduit family on first sight ({@link ensureConduitDoc}).
+ *   2. Split the new text into sections and resolve the previous head's
+ *      section texts from its version blob — the single-writer vs.
+ *      concurrent discriminator (T13589).
+ *   3. Apply each section's edit to its local Loro state
+ *      (`section-merge.ts`): while the stored state equals the head's text
+ *      the input projects EXACTLY (re-seed; replaces and deletions apply
+ *      verbatim — the primitives can only append, so re-seeding is the
+ *      honest encoding); a concurrent edit that is a pure append composes
+ *      onto the stored state so both survive (T13585); a concurrent
+ *      NON-append edit is never fabricated into a merge — it is landed as
+ *      its own version row and recorded as a head conflict (T13595).
+ *   4. Read the MERGED text back out of the merged Loro states — never out
+ *      of the input — and write its content-addressed blob so the version
+ *      row's `storage_key` resolves.
+ *   5. Append the merged text as a DAG version row
+ *      (`appendConduitAttachmentVersion`, parent = the previous head's
+ *      version) — history is append-only.
+ *   6. Project the merged text into the current-version row via
+ *      {@link upsertConduitDocHead}: the max-HLC head wins and a losing
+ *      concurrent head is recorded as a conflict, never silently shadowed
+ *      (typed rule `docs.head.max-hlc`).
+ *   7. Rebase the local section states onto the landed version and rebuild
+ *      the derived contributors rollup.
+ *
+ * Steps 1–7 run inside ONE `BEGIN IMMEDIATE` transaction
+ * ({@link withConduitDocWriteTransaction}, T13583): a failure after the
+ * version append rolls everything back, so the next update cannot fork
+ * onto a half-landed projection. The body uses only sync-driver accessors
+ * and sync `node:fs` calls, so no real I/O yield can admit another writer
+ * on the connection mid-transaction (the documented constraint).
+ *
+ * Loro owns LOCAL-ONLY section state; the syncing rows are owned by the
+ * Stage C journal merge engine — one merge authority per table (§2).
+ *
+ * @module
+ * @task T13355
+ * @epic T13340
+ * @saga T13339
+ */
+import { type ConduitAttachmentVersionRow, type UpsertConduitDocHeadResult } from '../store/conduit-doc-history.js';
+/**
+ * TTL granted by the write path's lease acquisitions (seconds). Inside
+ * llmtxt's 1–300 s range; long enough to cover an edit burst, short enough
+ * that a dead session's lease dies quickly (AC4: lease state never outlives
+ * its session without renew).
+ */
+export declare const SECTION_LEASE_TTL_SECONDS = 60;
+/** Input for {@link projectDocUpdateThroughSections}. */
+export interface ProjectDocUpdateInput {
+    /** The doc's live slug (or a known old slug). */
+    readonly slug: string;
+    /** Revision author agent id. */
+    readonly authorAgentId: string;
+    /** The full new document text. */
+    readonly content: string;
+    /**
+     * The session performing the edit. Callers that know their session (tests,
+     * sync apply) pass it explicitly; otherwise the projection resolves the
+     * caller's BOUND session ({@link resolveBoundSession}, gate 16 — never a
+     * bare `getActiveSession()`). With no session the edit proceeds
+     * UNCOORDINATED: leases are per-session state, so there is nothing to
+     * acquire or renew under.
+     */
+    readonly sessionId?: string;
+    /**
+     * The candidate head's HLC (journal wire form). Omit to mint one locally:
+     * the mint ticks forward from this device's last issued HLC and never
+     * lands at or below the stored head, so a local write always advances the
+     * projection. Sync callers pass the remote HLC to exercise the max-HLC
+     * rule.
+     */
+    readonly hlc?: string;
+    /**
+     * Explicit DAG parent (sync apply). Omit to chain onto the current head's
+     * version; `null` forces a root version.
+     */
+    readonly parentVersionUid?: string | null;
+    /**
+     * The section texts of the version this edit was AUTHORED AGAINST
+     * (T13674) — the write path's stale-base discriminator. Callers that
+     * fetched a head and declared it pass its section texts (resolved and
+     * validated before any write); every section is then merged relative to
+     * that base, so an edit authored against a superseded head composes onto
+     * the stored state (append) or records a conflict (non-append) instead of
+     * re-seeding over a concurrent writer's edit. Omit (or null) to assert
+     * single-writer semantics against the previous head — the pre-T13674
+     * behavior.
+     */
+    readonly baseSections?: readonly string[] | null;
+    /** Optional change summary for the version row. */
+    readonly changeSummary?: string;
+}
+/** Outcome of {@link projectDocUpdateThroughSections}. */
+export interface ProjectDocUpdateResult {
+    /** The doc's immutable uid (`conduit_attachments.uid`). */
+    readonly docUid: string;
+    /** Whether this call adopted the doc into the conduit family. */
+    readonly adopted: boolean;
+    /** The merged document text, extracted from the merged Loro states. */
+    readonly mergedText: string;
+    /** Section ids whose state changed in this projection. */
+    readonly sectionsModified: readonly string[];
+    /** The appended DAG version row. */
+    readonly version: ConduitAttachmentVersionRow;
+    /** The head upsert outcome (advanced vs. conflict recorded). */
+    readonly head: UpsertConduitDocHeadResult;
+    /**
+     * The head version uid this projection chained onto (`null` when the doc
+     * had no head yet). Callers that declared a base compare it against their
+     * base to detect a stale merge (T13674).
+     */
+    readonly previousHeadVersionUid: string | null;
+    /**
+     * Non-append concurrent section edits recorded as conflicts (T13595): the
+     * incoming edit could not be composed without fabricating text, so it was
+     * landed as its own version row (append-only history preserves both) while
+     * the head keeps the stored projection.
+     */
+    readonly conflicts: readonly SectionConflict[];
+    /**
+     * Advisory lease notices (T13356): sections this edit touched are leased
+     * by ANOTHER live session. The edit proceeded anyway — leases are
+     * advisory ("409 is a social signal, not a hard lock", llmtxt T285).
+     */
+    readonly leaseNotices: readonly SectionLeaseNotice[];
+}
+/** One recorded non-append concurrent section edit (T13595). */
+export interface SectionConflict {
+    /** The section that could not be merged. */
+    readonly sectionId: string;
+    /** The version row carrying the incoming (authored) edit — the loser. */
+    readonly incomingVersionUid: string;
+    /** The projection version row the head kept — the winner. */
+    readonly projectionVersionUid: string;
+}
+/** One advisory lease notice (T13356): the section is leased elsewhere. */
+export interface SectionLeaseNotice {
+    /** The leased section the edit touched. */
+    readonly sectionId: string;
+    /** The current holder agent id. */
+    readonly holder: string;
+    /** The current holder's session id. */
+    readonly sessionId: string;
+    /** When the blocking lease expires without renew (ISO-8601). */
+    readonly expiresAt: string;
+}
+/**
+ * Project one docs update through the section CRDT merge layer.
+ *
+ * The whole projection — adopt, section-state writes, version append, head
+ * upsert, rebase, contributors rebuild — is one transaction
+ * ({@link withConduitDocWriteTransaction}); the merged text is read back
+ * from the merged Loro states, so concurrent same-base section edits both
+ * survive into the version row and the head projection.
+ *
+ * Lease coordination (T13356, ADVISORY): before the transaction, the
+ * projection resolves the caller's session (input, else the bound session,
+ * gate 16) and acquires/renews a lease for every section the edit touches.
+ * A section leased by another live session yields a {@link SectionLeaseNotice}
+ * — the 409 equivalent as data. The edit PROCEEDS regardless: "409 is a
+ * social signal, not a hard lock" (llmtxt T285); the CRDT layer guarantees
+ * nothing is lost when coordination fails. Leases acquired for a projection
+ * that then rolls back are released, so a failed edit leaves no stale claim.
+ *
+ * @param projectRoot - Absolute path to the CLEO project root.
+ * @param input - The update facts.
+ * @returns The merge outcome.
+ */
+export declare function projectDocUpdateThroughSections(projectRoot: string, input: ProjectDocUpdateInput): Promise<ProjectDocUpdateResult>;
+/**
+ * Release every section lease this session holds for a doc — the "release
+ * on completion" path of T13356 AC2: a session calls this when it finishes
+ * editing the doc, so the sections are free for the next editor before the
+ * TTL would have expired them.
+ *
+ * @param projectRoot - Absolute path to the CLEO project root.
+ * @param slug - The doc's live slug (leases are keyed by it).
+ * @param sessionId - The finishing session (only its own leases are released).
+ * @returns The section ids released.
+ */
+export declare function releaseSectionLeases(projectRoot: string, slug: string, sessionId: string): Promise<string[]>;
+//# sourceMappingURL=section-write-path.d.ts.map

package/dist/docs/section-write-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"section-write-path.d.ts","sourceRoot":"","sources":["../../src/docs/section-write-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAMH,OAAO,EAEL,KAAK,2BAA2B,EAShC,KAAK,0BAA0B,EAIhC,MAAM,iCAAiC,CAAC;AAgBzC;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,yDAAyD;AACzD,MAAM,WAAW,qBAAqB;IACpC,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IACjD,mDAAmD;IACnD,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,0DAA0D;AAC1D,MAAM,WAAW,sBAAsB;IACrC,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,oCAAoC;IACpC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAC;IAC/C;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACtD;AAED,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,6DAA6D;IAC7D,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;CACvC;AAED,2EAA2E;AAC3E,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mCAAmC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uCAAuC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AA2GD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,+BAA+B,CACnD,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,qBAAqB,GAC3B,OAAO,CAAC,sBAAsB,CAAC,CAoOjC;AAYD;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnB"}