soulbridge 0.0.22 → 0.0.98

package/dist/packages/core/src/config/labels.js

@@ -0,0 +1,21 @@
+/**
+ * The layer names a lesson can be classified into — declared once.
+ *
+ * These labels travel three ways: the classifier is told to emit them, the parser
+ * matches them, and the store writes them as `type_name`. A copy anywhere else means
+ * a rename turns into "one stage writes a label the next stage does not read".
+ */
+export const CLASSIFY_LABELS = {
+    rule: '规则',
+    profile: '画像',
+    pending: '待修',
+};
+/** The judgment a conclusion is stored as. */
+export const CONCLUSION_TYPE = '结论';
+/**
+ * The fact type names that are injected as always-on anchors.
+ *
+ * Kept here because the set is shared by the context builder and by profile/rule
+ * readers; retyping it in a second filter is how a layer silently drops out.
+ */
+export const ANCHOR_TYPES = ['结论', '教训', '原则', '性格'];

package/dist/packages/core/src/config/status.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Fact lifecycle vocabulary — declared once, imported everywhere.
+ *
+ * "superseded" used to be typed out in three files, so renaming it would have left
+ * one filter silently admitting retired facts. Config modules hold data only; the
+ * decoding (SQL binding, filters, prompts) lives in the code that imports this.
+ *
+ * Values match the column defaults in sqlite.ts; changing one is a schema migration,
+ * not a rename.
+ */
+export declare const FACT_STATUS: {
+    /** Written, no lifecycle decision yet. */
+    readonly none: 'none';
+    /** Being worked on (promises, plans). */
+    readonly open: 'open';
+    /** Held. */
+    readonly kept: 'kept';
+    /** Broken (a promise that did not happen). */
+    readonly broken: 'broken';
+    /** Replaced by another fact; kept for the record, never injected. */
+    readonly superseded: 'superseded';
+};
+export type FactStatus = (typeof FACT_STATUS)[keyof typeof FACT_STATUS];
+/** Where a fact came from, in the trust sense (not a type). */
+export declare const FACT_SOURCE: {
+    readonly experienced: 'experienced';
+    readonly told: 'told';
+    readonly inferred: 'inferred';
+};
+export type FactSource = (typeof FACT_SOURCE)[keyof typeof FACT_SOURCE];
+/** How precise a time is. `unknown` is an honest answer, not a failure. */
+export declare const AT_PRECISION: {
+    readonly day: 'day';
+    readonly range: 'range';
+    readonly relative: 'relative';
+    readonly unknown: 'unknown';
+};
+export type AtPrecision = (typeof AT_PRECISION)[keyof typeof AT_PRECISION];
+/**
+ * The legacy `memories` layer's lifecycle.
+ *
+ * It shares the word "superseded" with facts on purpose: one lifecycle concept, one
+ * set of values, one declaration. The table retires (see retirements.json), the
+ * vocabulary does not fork before it does.
+ */
+export declare const MEMORY_STATUS: {
+    readonly active: 'active';
+    readonly superseded: 'superseded';
+    readonly archived: 'archived';
+};
+export type MemoryStatus = (typeof MEMORY_STATUS)[keyof typeof MEMORY_STATUS];

package/dist/packages/core/src/config/status.js

@@ -0,0 +1,47 @@
+/**
+ * Fact lifecycle vocabulary — declared once, imported everywhere.
+ *
+ * "superseded" used to be typed out in three files, so renaming it would have left
+ * one filter silently admitting retired facts. Config modules hold data only; the
+ * decoding (SQL binding, filters, prompts) lives in the code that imports this.
+ *
+ * Values match the column defaults in sqlite.ts; changing one is a schema migration,
+ * not a rename.
+ */
+export const FACT_STATUS = {
+    /** Written, no lifecycle decision yet. */
+    none: 'none',
+    /** Being worked on (promises, plans). */
+    open: 'open',
+    /** Held. */
+    kept: 'kept',
+    /** Broken (a promise that did not happen). */
+    broken: 'broken',
+    /** Replaced by another fact; kept for the record, never injected. */
+    superseded: 'superseded',
+};
+/** Where a fact came from, in the trust sense (not a type). */
+export const FACT_SOURCE = {
+    experienced: 'experienced',
+    told: 'told',
+    inferred: 'inferred',
+};
+/** How precise a time is. `unknown` is an honest answer, not a failure. */
+export const AT_PRECISION = {
+    day: 'day',
+    range: 'range',
+    relative: 'relative',
+    unknown: 'unknown',
+};
+/**
+ * The legacy `memories` layer's lifecycle.
+ *
+ * It shares the word "superseded" with facts on purpose: one lifecycle concept, one
+ * set of values, one declaration. The table retires (see retirements.json), the
+ * vocabulary does not fork before it does.
+ */
+export const MEMORY_STATUS = {
+    active: 'active',
+    superseded: 'superseded',
+    archived: 'archived',
+};

package/dist/packages/core/src/consolidate.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Consolidation: several facts become one conclusion, with the evidence kept.
+ *
+ * Two ideas are borrowed rather than invented here:
+ *
+ *   - AIS / attribution (Rashkin et al. 2021): every sentence must be
+ *     attributable to identified sources. A conclusion cites fact ids, and one
+ *     citation is not enough — that is a fact, not a conclusion.
+ *   - Chain-of-Verification (Dhuliawala et al. 2023): verifying a draft against
+ *     its sources works better when the check is independent of the draft. The
+ *     model writes conclusions in one call and answers "do these facts directly
+ *     support it?" in a second, without the first answer in view.
+ *
+ * The gate below is deliberately deterministic: evidence count, evidence
+ * existence, statement shape, and over-generalisation are all checkable without
+ * a model. The model only does what code cannot — compress meaning.
+ */
+import type { ConclusionDraft, Fact, SlotValue } from './types.ts';
+export interface ConclusionGateInput {
+    draft: ConclusionDraft;
+    /** Facts the model was shown; evidence must come from here. */
+    allowed: Set<string>;
+    /** Existing conclusion the draft claims to replace, if any. */
+    existing?: Fact | null;
+}
+export type ConclusionGateResult = {
+    ok: true;
+    statement: string;
+    evidence: string[];
+    confidence: number;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function gateConclusion(input: ConclusionGateInput): ConclusionGateResult;
+/**
+ * The fact a conclusion becomes.
+ *
+ * No new table: a conclusion is a fact whose type is 结论, whose holder is the
+ * soul itself, and whose evidence is a `fact` slot per citation. That keeps
+ * retrieval, export and supersede working unchanged.
+ *
+ * A conclusion also carries the entities its evidence mentions, under `关于`.
+ * Without that it cannot be recalled when the conversation turns to that person —
+ * the one question the whole layer exists to answer.
+ */
+export declare function conclusionSlots(evidence: string[], entities?: string[]): {
+    slot: string;
+    value: SlotValue;
+}[];
+/**
+ * Parse the draft answer: one conclusion per line.
+ *
+ *   结论: 用户讨厌同一件事反复交代 | 证据=fc_a1,fc_a2 | 置信=0.8 | 取代=fc_c1
+ *   无
+ */
+export declare function parseConclusionDraft(raw: string): ConclusionDraft | null;
+export interface VerificationDraft {
+    verdict: 'supported' | 'partial' | 'unsupported';
+    reason?: string;
+}
+/**
+ * Parse the verification answer:
+ *
+ *   判定: 支持 | 依据=fc_a1,fc_a2 | 理由=两条事实都提到"反复交代"
+ *   判定: 不支持 | 理由=只有 fc_a1 提到，fc_a2 说的是工具切换
+ */
+export declare function parseVerificationDraft(raw: string): VerificationDraft | null;
+/**
+ * Normalise a statement for the one check a rule can make safely.
+ *
+ * This is deliberately narrow: it only catches text that is *the same text*, so a
+ * hit cannot be wrong. Everything about meaning is the model's call, because
+ * "same topic, different words" is exactly where string matching lies.
+ */
+export declare function normalizeStatement(statement: string): string;
+export interface ConclusionRelation {
+    kind: 'duplicate' | 'refine' | 'conflict' | 'unrelated';
+    target?: string;
+    reason?: string;
+}
+/**
+ * Parse the relation check:
+ *
+ *   关系: 重复 fc_abc | 理由=说的是同一件事，只是措辞不同
+ *   关系: 细化 fc_abc | 理由=新结论多了"只在紧急时"
+ *   关系: 矛盾 fc_abc | 理由=一个说喜欢重复讲，一个说讨厌
+ *   关系: 无关
+ *
+ * A named id that we do not hold is not an error — the caller treats it as
+ * unrelated, which only ever writes the new conclusion and never deletes one.
+ */
+export declare function parseRelationDraft(raw: string): ConclusionRelation | null;
+/**
+ * Read a verifier's answer, keeping "we could not read it" separate from "no".
+ *
+ * An empty or unparseable reply is not evidence against a conclusion — it is the
+ * documented stream-gone failure. Collapsing it to `unsupported` silently discards
+ * a draft that was never actually checked (and before this, it also lost the
+ * thread). Only a parsed verdict may drop a conclusion.
+ */
+export declare function readVerification(raw: string): {
+    kind: 'verdict';
+    verdict: VerificationDraft;
+} | {
+    kind: 'retry';
+    reason: string;
+};
+export interface ProfileLine {
+    statement: string;
+    sources: string[];
+    dimension: ProfileDimension;
+}
+/**
+ * The dimensions a profile line can belong to.
+ *
+ * Declared in dimensions.ts so prompts render it instead of retyping the names —
+ * a second copy is how "add an eighth dimension" becomes a silent drift.
+ */
+export { PROFILE_DIMENSIONS } from './config/dimensions.ts';
+export type { ProfileDimension } from './config/dimensions.ts';
+import type { ProfileDimension } from './config/dimensions.ts';
+/**
+ * Parse the merged profile.
+ *
+ * Three things are rejected by code rather than hoped for: a line with no source is
+ * an assumption, a hedged or absolute line is a failed merge, and a fragment is not
+ * a judgment. Near-duplicates are folded, because "the same thing said twice" is the
+ * exact failure the merge exists to fix.
+ *
+ * What code cannot check is direction ("先" becoming "后"). That needs the separate
+ * verification pass, and it is why this parser is not the last gate.
+ */
+export declare function parseProfileMerge(raw: string, allowed: Set<string>, expected?: string): ProfileLine[];
+/**
+ * A merged line is derived: it exists because other lines do.
+ *
+ * Derivedness used to be a slot written by exactly one code path. Any line created
+ * another way was therefore treated as an original and could be merged again, and
+ * re-compressing a compression produces lines thinner than what they came from.
+ * Citing a source is what makes a line derived; the marker is only a cache of that,
+ * so both are read — a line that names its sources can never be merge input.
+ */
+export declare function isDerivedProfileLine(fact: {
+    slots?: {
+        slot: string;
+    }[];
+}): boolean;
+export interface ProfileCandidate {
+    id: string;
+    statement: string;
+    dimension?: string;
+}
+export interface ProfileGroup {
+    /** Empty for candidates that have no dimension yet; they are not merge input. */
+    dimension: string;
+    items: ProfileCandidate[];
+}
+/**
+ * Cut the merge input along dimensions before any model sees it.
+ *
+ * A single call across every dimension welded unrelated judgments into one sentence
+ * ("以目的实现为准，大胆假设、小心求证"). Which judgment belongs to which lens is a
+ * semantic call, but *keeping batches apart* is structure, so code does it: the
+ * model only ever compresses lines that are already about the same thing.
+ *
+ * Unlabelled candidates are their own group. Guessing a dimension to fill a batch
+ * would be invention, and a wrong dimension is worse than a missing line.
+ */
+export declare function groupProfileCandidates(items: ProfileCandidate[]): ProfileGroup[];

package/dist/packages/core/src/consolidate.js

@@ -0,0 +1,311 @@
+/** Words that turn a specific observation into a rule about everything. */
+const ABSOLUTE = /一切|所有|总是|从不|永远|从来|任何人|任何事/g;
+export function gateConclusion(input) {
+    const statement = String(input.draft.statement ?? '').trim();
+    const evidence = [...new Set((input.draft.evidence ?? []).map((id) => String(id).trim()).filter(Boolean))];
+    if (statement.length < 8)
+        return { ok: false, reason: 'statement too short' };
+    if (statement.length > 80)
+        return { ok: false, reason: 'statement too long' };
+    // One citation is an observation. Two is the smallest thing that deserves the
+    // word "conclusion", and it is the rule this whole stage is built on.
+    if (evidence.length < 2)
+        return { ok: false, reason: `needs >=2 evidence (got ${evidence.length})` };
+    const foreign = evidence.filter((id) => !input.allowed.has(id));
+    if (foreign.length > 0)
+        return { ok: false, reason: `evidence not in batch: ${foreign.join(',')}` };
+    // Over-generalisation: an absolute word that also appears in the evidence is
+    // quoting the user; one that appears only in the conclusion is the model
+    // inflating two observations into a rule.
+    const absolute = statement.match(ABSOLUTE);
+    if (absolute) {
+        const quoted = new Set(absolute.filter((word) => input.allowed.size > 0 && input.draft.evidenceText?.includes(word)));
+        const invented = absolute.filter((word) => !quoted.has(word));
+        if (invented.length > 0)
+            return { ok: false, reason: `over-generalised: ${invented.join('、')}` };
+    }
+    const confidence = Math.min(1, Math.max(0, Number(input.draft.confidence ?? 0.6)));
+    return { ok: true, statement, evidence, confidence };
+}
+/**
+ * The fact a conclusion becomes.
+ *
+ * No new table: a conclusion is a fact whose type is 结论, whose holder is the
+ * soul itself, and whose evidence is a `fact` slot per citation. That keeps
+ * retrieval, export and supersede working unchanged.
+ *
+ * A conclusion also carries the entities its evidence mentions, under `关于`.
+ * Without that it cannot be recalled when the conversation turns to that person —
+ * the one question the whole layer exists to answer.
+ */
+export function conclusionSlots(evidence, entities = []) {
+    return [
+        ...evidence.map((factId) => ({ slot: '证据', value: { kind: 'fact', factId } })),
+        ...entities.map((entityId) => ({ slot: '关于', value: { kind: 'entity', entityId } })),
+    ];
+}
+const RECORD = /^结论\s*[:：]\s*(.+)$/;
+const VERDICT = /^判定\s*[:：]\s*(.+)$/;
+/**
+ * Parse the draft answer: one conclusion per line.
+ *
+ *   结论: 用户讨厌同一件事反复交代 | 证据=fc_a1,fc_a2 | 置信=0.8 | 取代=fc_c1
+ *   无
+ */
+export function parseConclusionDraft(raw) {
+    for (const line of String(raw ?? '').split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (/^(无|none|nothing)[。.]?$/i.test(trimmed))
+            return null;
+        const match = RECORD.exec(trimmed);
+        if (!match)
+            continue;
+        const parts = match[1].split('|').map((part) => part.trim());
+        const statement = parts[0] ?? '';
+        const field = (name) => {
+            const hit = parts.slice(1).find((part) => part.startsWith(`${name}=`) || part.startsWith(`${name}：`));
+            return hit?.slice(name.length + 1).trim();
+        };
+        const evidence = (field('证据') ?? '')
+            .split(/[,，、;；\s]+/)
+            .map((id) => id.trim())
+            .filter(Boolean);
+        const confidence = Number(field('置信') ?? field('confidence') ?? '0.6');
+        return {
+            statement,
+            evidence,
+            confidence: Number.isFinite(confidence) ? confidence : 0.6,
+            supersedes: field('取代') || undefined,
+        };
+    }
+    return null;
+}
+/**
+ * Parse the verification answer:
+ *
+ *   判定: 支持 | 依据=fc_a1,fc_a2 | 理由=两条事实都提到"反复交代"
+ *   判定: 不支持 | 理由=只有 fc_a1 提到，fc_a2 说的是工具切换
+ */
+export function parseVerificationDraft(raw) {
+    for (const line of String(raw ?? '').split(/\r?\n/)) {
+        const trimmed = line.trim();
+        const match = VERDICT.exec(trimmed);
+        if (!match)
+            continue;
+        const body = match[1];
+        const reason = /理由\s*[:：=]\s*(.+)$/.exec(body)?.[1]?.trim();
+        const head = body.split('|')[0] ?? '';
+        if (/不支持|unsupported|否/.test(head))
+            return { verdict: 'unsupported', reason };
+        if (/部分|partial/.test(head))
+            return { verdict: 'partial', reason };
+        if (/支持|supported|是/.test(head))
+            return { verdict: 'supported', reason };
+    }
+    return null;
+}
+/* ------------------------------------------------------------------ *
+ * Duplicate handling: the new conclusion vs the conclusions we hold
+ * ------------------------------------------------------------------ */
+/**
+ * Normalise a statement for the one check a rule can make safely.
+ *
+ * This is deliberately narrow: it only catches text that is *the same text*, so a
+ * hit cannot be wrong. Everything about meaning is the model's call, because
+ * "same topic, different words" is exactly where string matching lies.
+ */
+export function normalizeStatement(statement) {
+    return String(statement ?? '')
+        .normalize('NFKC')
+        .toLowerCase()
+        .replace(/[\s，。、；：！？,.;:!?"'“”‘’（）()【】\[\]…—–\-\/\\]+/g, '');
+}
+const RELATION = /^关系\s*[:：]\s*(.+)$/;
+const FACT_ID = /(fc_[a-z0-9_]+)/i;
+/**
+ * Parse the relation check:
+ *
+ *   关系: 重复 fc_abc | 理由=说的是同一件事，只是措辞不同
+ *   关系: 细化 fc_abc | 理由=新结论多了"只在紧急时"
+ *   关系: 矛盾 fc_abc | 理由=一个说喜欢重复讲，一个说讨厌
+ *   关系: 无关
+ *
+ * A named id that we do not hold is not an error — the caller treats it as
+ * unrelated, which only ever writes the new conclusion and never deletes one.
+ */
+export function parseRelationDraft(raw) {
+    for (const line of String(raw ?? '').split(/\r?\n/)) {
+        const match = RELATION.exec(line.trim());
+        if (!match)
+            continue;
+        const body = match[1];
+        const head = body.split('|')[0] ?? '';
+        const target = FACT_ID.exec(body)?.[1];
+        const reason = /理由\s*[:：=]\s*(.+)$/.exec(body)?.[1]?.trim();
+        if (/重复|duplicate/i.test(head))
+            return { kind: 'duplicate', target, reason };
+        if (/细化|refine/i.test(head))
+            return { kind: 'refine', target, reason };
+        if (/矛盾|conflict/i.test(head))
+            return { kind: 'conflict', target, reason };
+        if (/无关|unrelated/i.test(head))
+            return { kind: 'unrelated', reason };
+    }
+    return null;
+}
+/**
+ * Read a verifier's answer, keeping "we could not read it" separate from "no".
+ *
+ * An empty or unparseable reply is not evidence against a conclusion — it is the
+ * documented stream-gone failure. Collapsing it to `unsupported` silently discards
+ * a draft that was never actually checked (and before this, it also lost the
+ * thread). Only a parsed verdict may drop a conclusion.
+ */
+export function readVerification(raw) {
+    const text = String(raw ?? '').trim();
+    if (!text)
+        return { kind: 'retry', reason: 'empty reply' };
+    const verdict = parseVerificationDraft(text);
+    if (!verdict)
+        return { kind: 'retry', reason: 'unparseable verdict' };
+    return { kind: 'verdict', verdict };
+}
+/**
+ * The dimensions a profile line can belong to.
+ *
+ * Declared in dimensions.ts so prompts render it instead of retyping the names —
+ * a second copy is how "add an eighth dimension" becomes a silent drift.
+ */
+export { PROFILE_DIMENSIONS } from './config/dimensions.js';
+import { PROFILE_DIMENSIONS } from './config/dimensions.js';
+const PROFILE_LINE = /^画像\s*[:：]\s*(.+)$/;
+/** Hedged lines describe a mood, not a person; the merge has not happened yet. */
+const PROFILE_HEDGE = /有时候|有时|通常|大部分时候|一般来说|一般说/;
+/** Over-generalisation: no single set of observations supports an "always". */
+const PROFILE_ABSOLUTE = /一切|所有|总是|从不/;
+/** A fragment has no subject; completing it would be invention. */
+const PROFILE_FRAGMENT = /^(每次|因为|然后|所以|但是|而且|并且)/;
+/** One judgment per line. A semicolon is how three unrelated points get welded together. */
+const PROFILE_MULTI_CLAUSE = /[；;]/;
+/** Negation flips the meaning while sharing nearly every bigram. */
+const PROFILE_NEGATION = /[不没别勿非无]/;
+function profileBigrams(text) {
+    const clean = text.replace(/[\s，。、；：！？,.;:!?"'（）()]/g, '');
+    const out = new Set();
+    for (let i = 0; i < clean.length - 1; i += 1)
+        out.add(clean.slice(i, i + 2));
+    return out;
+}
+function profileSimilarity(a, b) {
+    const left = profileBigrams(a);
+    const right = profileBigrams(b);
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let shared = 0;
+    for (const gram of left)
+        if (right.has(gram))
+            shared += 1;
+    return shared / (left.size + right.size - shared);
+}
+/**
+ * Parse the merged profile.
+ *
+ * Three things are rejected by code rather than hoped for: a line with no source is
+ * an assumption, a hedged or absolute line is a failed merge, and a fragment is not
+ * a judgment. Near-duplicates are folded, because "the same thing said twice" is the
+ * exact failure the merge exists to fix.
+ *
+ * What code cannot check is direction ("先" becoming "后"). That needs the separate
+ * verification pass, and it is why this parser is not the last gate.
+ */
+export function parseProfileMerge(raw, allowed, expected) {
+    const out = [];
+    for (const line of String(raw ?? '').split(/\r?\n/)) {
+        const match = PROFILE_LINE.exec(line.trim());
+        if (!match)
+            continue;
+        const [statementPart, ...fields] = match[1].split('|').map((part) => part.trim());
+        const statement = (statementPart ?? '').trim();
+        if (statement.length < 6 || statement.length > 32)
+            continue;
+        if (PROFILE_MULTI_CLAUSE.test(statement))
+            continue;
+        if (PROFILE_HEDGE.test(statement) || PROFILE_ABSOLUTE.test(statement))
+            continue;
+        if (PROFILE_FRAGMENT.test(statement))
+            continue;
+        const dimension = fields
+            .find((field) => field.startsWith('维度'))
+            ?.replace(/^维度\s*[=＝]\s*/, '');
+        if (!dimension || !PROFILE_DIMENSIONS.includes(dimension))
+            continue;
+        // The batch is one dimension by construction; a line that leaves it means the
+        // model mixed two lenses back together, which is the welding the split prevents.
+        if (expected && dimension !== expected)
+            continue;
+        const sourceField = fields.find((field) => field.startsWith('来源'));
+        const sources = (sourceField?.replace(/^来源\s*[=＝]\s*/, '') ?? '')
+            .split(/[,，、;；\s]+/)
+            .map((id) => id.trim())
+            .filter((id) => allowed.has(id));
+        if (sources.length === 0)
+            continue;
+        const duplicate = out.some((kept) => {
+            if (profileSimilarity(kept.statement, statement) < 0.7)
+                return false;
+            // "喜欢爬山" and "不喜欢爬山" share ~0.86 of their bigrams, and folding them
+            // keeps whichever came first — writing the person's preference backwards.
+            // Opposite polarity is never a duplicate: the prompt says a flipped direction
+            // is worse than a missing line.
+            return PROFILE_NEGATION.test(kept.statement) === PROFILE_NEGATION.test(statement);
+        });
+        if (duplicate)
+            continue;
+        out.push({ statement, sources, dimension: dimension });
+    }
+    return out;
+}
+/**
+ * A merged line is derived: it exists because other lines do.
+ *
+ * Derivedness used to be a slot written by exactly one code path. Any line created
+ * another way was therefore treated as an original and could be merged again, and
+ * re-compressing a compression produces lines thinner than what they came from.
+ * Citing a source is what makes a line derived; the marker is only a cache of that,
+ * so both are read — a line that names its sources can never be merge input.
+ */
+export function isDerivedProfileLine(fact) {
+    return (fact.slots ?? []).some((slot) => slot.slot === '来源' || slot.slot === '合并');
+}
+/**
+ * Cut the merge input along dimensions before any model sees it.
+ *
+ * A single call across every dimension welded unrelated judgments into one sentence
+ * ("以目的实现为准，大胆假设、小心求证"). Which judgment belongs to which lens is a
+ * semantic call, but *keeping batches apart* is structure, so code does it: the
+ * model only ever compresses lines that are already about the same thing.
+ *
+ * Unlabelled candidates are their own group. Guessing a dimension to fill a batch
+ * would be invention, and a wrong dimension is worse than a missing line.
+ */
+export function groupProfileCandidates(items) {
+    const order = [];
+    const groups = new Map();
+    for (const item of items) {
+        const known = typeof item.dimension === 'string' && PROFILE_DIMENSIONS.includes(item.dimension);
+        const dimension = known ? item.dimension : '';
+        let bucket = groups.get(dimension);
+        if (!bucket) {
+            bucket = [];
+            groups.set(dimension, bucket);
+            order.push(dimension);
+        }
+        bucket.push(item);
+    }
+    // Biggest group first: it is the one with the most repetition to collapse.
+    return order
+        .map((dimension) => ({ dimension, items: groups.get(dimension) ?? [] }))
+        .sort((a, b) => b.items.length - a.items.length);
+}

package/dist/packages/core/src/context.d.ts

@@ -6,6 +6,8 @@
  *  - every injected memory id is reported in `used`, so injection is auditable
  *  - the affect section is opt-in by confidence, capped in size, and only ever
  *    contains whitelisted sentences (ADR 0014)
+ *  - every dynamic value is escaped before it joins a block: a statement containing
+ *    `</memories>` otherwise ends the envelope and can forge a `<rules>` block
  */
 import type { ContextRequest, ContextResult, Emotion } from './types.ts';
 import type { SoulStore } from './store.ts';