soulbridge 0.0.26 → 0.0.100

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

@@ -0,0 +1,18 @@
+/**
+ * The profile dimension vocabulary, declared once.
+ *
+ * A dimension is a noun we ship to two model stages and to the merge parser: the
+ * classifier decides which lens a lesson belongs to, the merge decides which lens a
+ * line belongs to, and the parser rejects anything else. Those three must agree, so
+ * the names AND their admission criteria live here and nowhere else — prompts render
+ * this, they do not retype it.
+ *
+ * The definitions are borrowed from measurement traditions on purpose:
+ * 价值观 ← Schwartz; 人际关系 ← interpersonal circumplex (warmth × dominance);
+ * 生活兴趣 ← RIASEC; 情绪 ← core affect. 边界 has no taxonomy — it quotes the words.
+ * These are admission criteria for a sentence, not a personality theory.
+ */
+export declare const PROFILE_DIMENSIONS: readonly ['价值观', '工作方式', '沟通偏好', '情绪', '人际关系', '生活兴趣', '边界'];
+export type ProfileDimension = (typeof PROFILE_DIMENSIONS)[number];
+/** What counts as a line in each dimension, and what does not. */
+export declare const PROFILE_DIMENSION_DEFINITIONS: Record<ProfileDimension, string>;

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

@@ -0,0 +1,33 @@
+/**
+ * The profile dimension vocabulary, declared once.
+ *
+ * A dimension is a noun we ship to two model stages and to the merge parser: the
+ * classifier decides which lens a lesson belongs to, the merge decides which lens a
+ * line belongs to, and the parser rejects anything else. Those three must agree, so
+ * the names AND their admission criteria live here and nowhere else — prompts render
+ * this, they do not retype it.
+ *
+ * The definitions are borrowed from measurement traditions on purpose:
+ * 价值观 ← Schwartz; 人际关系 ← interpersonal circumplex (warmth × dominance);
+ * 生活兴趣 ← RIASEC; 情绪 ← core affect. 边界 has no taxonomy — it quotes the words.
+ * These are admission criteria for a sentence, not a personality theory.
+ */
+export const PROFILE_DIMENSIONS = [
+    '价值观',
+    '工作方式',
+    '沟通偏好',
+    '情绪',
+    '人际关系',
+    '生活兴趣',
+    '边界',
+];
+/** What counts as a line in each dimension, and what does not. */
+export const PROFILE_DIMENSION_DEFINITIONS = {
+    价值观: '超越具体情境、值得追求的目标（Schwartz）。"想把事做对"算；"这个接口用 POST"不算。',
+    工作方式: '面对任务时的稳定做法。"先验证再动手"算；"这次改了 A 文件"不算。',
+    沟通偏好: '希望信息以什么形式、什么节奏出现。"整轮对话当整体"算。',
+    情绪: '对具体事件的感受与强度。"被反复确认会烦"算；"今天天气"不算。',
+    人际关系: '与特定人的位置和距离（温暖 × 支配）。"她最近压力大"算。',
+    生活兴趣: '自愿投入时间的事。"喜欢爬山"算。',
+    边界: '明确说过的"不要"。没有公认分类学，必须贴着原话，不许概括。',
+};

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

@@ -0,0 +1,70 @@
+/**
+ * Value domains that both the code and the model must agree on — data only.
+ *
+ * ADR 0027 splits work by *who decides*: the model decides meaning, the code decides
+ * shape. The failures that motivated this file were all shape decisions the code made
+ * on the model's behalf: a slot value that "looks like a name" became an entity, an
+ * entity without a type defaulted to `person`, and the same holder column carried both
+ * keywords and entity ids.
+ *
+ * Rules that come from this file (checked by health-check §12):
+ *   1. A domain's values are listed here once; other modules import them.
+ *   2. No semantic field may have a default value in code — a default *is* a decision,
+ *      and decisions belong to the model or to the caller.
+ *   3. A slot value becomes an entity reference only when it is explicitly marked with
+ *      SLOT_ENTITY_MARKER. Syntax never implies semantics.
+ *
+ * Keep this module free of functions: it is rendered into prompts and compared against
+ * live data, so it must stay inert.
+ */
+/** What an entity can be. The same set the store accepts. */
+export declare const ENTITY_TYPES: readonly ['person', 'thing', 'place', 'self'];
+/** `holder` either names a layer or points at the entity whose mind holds the fact. */
+export declare const HOLDER_WORDS: readonly ['world', 'self'];
+/** A slot value is text unless it starts with this marker. */
+export declare const SLOT_ENTITY_MARKER = "@";
+/**
+ * What a fact is *for* — chosen by the model from a closed set.
+ *
+ * `type_name` stays free text ("裁员", "BOM 教训"); this field is the structural answer to
+ * "which consumer reads it", so code no longer routes by matching a Chinese label:
+ *   observation → retrieval
+ *   judgment    → retrieval + profile input
+ *   rule        → injected when its trigger fires
+ *   profile     → injected every turn (after merge)
+ *   promise     → commitment tracking
+ *   lesson      → rule candidate / anchor
+ */
+export declare const FACT_ROLES: readonly ['observation', 'judgment', 'rule', 'profile', 'promise', 'lesson'];
+/**
+ * Where a fact is in its life — written by code, never by the model.
+ *
+ * `raw` is the exchange itself (turns), `candidate` is held but not injected, `active` is in
+ * use, `retracted` is kept for the record and read by nothing. `superseded` was the old name
+ * for `retracted`; the migration maps it.
+ */
+export declare const FACT_STATES: readonly ['raw', 'candidate', 'active', 'retracted'];
+/** Old status values → new ones. Kept here so the migration and the reader agree. */
+export declare const FACT_STATE_MIGRATION: {
+    readonly none: 'active';
+    readonly open: 'active';
+    readonly kept: 'active';
+    readonly broken: 'retracted';
+    readonly superseded: 'retracted';
+};
+/**
+ * The old Chinese type labels mapped to structural roles.
+ *
+ * `type_name` used to be the only place that said what a fact was, and rows written before the
+ * role column still carry it. One table, used by the writer (new rows get a role), by the reader
+ * fallback, and by the migration script — so the three cannot disagree.
+ */
+export declare const LEGACY_ROLE_BY_TYPE: {
+    readonly 规则: 'rule';
+    readonly 画像: 'profile';
+    readonly 结论: 'judgment';
+    readonly 判断: 'judgment';
+    readonly 决定: 'judgment';
+    readonly 承诺: 'promise';
+    readonly 教训: 'lesson';
+};

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

@@ -0,0 +1,70 @@
+/**
+ * Value domains that both the code and the model must agree on — data only.
+ *
+ * ADR 0027 splits work by *who decides*: the model decides meaning, the code decides
+ * shape. The failures that motivated this file were all shape decisions the code made
+ * on the model's behalf: a slot value that "looks like a name" became an entity, an
+ * entity without a type defaulted to `person`, and the same holder column carried both
+ * keywords and entity ids.
+ *
+ * Rules that come from this file (checked by health-check §12):
+ *   1. A domain's values are listed here once; other modules import them.
+ *   2. No semantic field may have a default value in code — a default *is* a decision,
+ *      and decisions belong to the model or to the caller.
+ *   3. A slot value becomes an entity reference only when it is explicitly marked with
+ *      SLOT_ENTITY_MARKER. Syntax never implies semantics.
+ *
+ * Keep this module free of functions: it is rendered into prompts and compared against
+ * live data, so it must stay inert.
+ */
+/** What an entity can be. The same set the store accepts. */
+export const ENTITY_TYPES = ['person', 'thing', 'place', 'self'];
+/** `holder` either names a layer or points at the entity whose mind holds the fact. */
+export const HOLDER_WORDS = ['world', 'self'];
+/** A slot value is text unless it starts with this marker. */
+export const SLOT_ENTITY_MARKER = '@';
+/**
+ * What a fact is *for* — chosen by the model from a closed set.
+ *
+ * `type_name` stays free text ("裁员", "BOM 教训"); this field is the structural answer to
+ * "which consumer reads it", so code no longer routes by matching a Chinese label:
+ *   observation → retrieval
+ *   judgment    → retrieval + profile input
+ *   rule        → injected when its trigger fires
+ *   profile     → injected every turn (after merge)
+ *   promise     → commitment tracking
+ *   lesson      → rule candidate / anchor
+ */
+export const FACT_ROLES = ['observation', 'judgment', 'rule', 'profile', 'promise', 'lesson'];
+/**
+ * Where a fact is in its life — written by code, never by the model.
+ *
+ * `raw` is the exchange itself (turns), `candidate` is held but not injected, `active` is in
+ * use, `retracted` is kept for the record and read by nothing. `superseded` was the old name
+ * for `retracted`; the migration maps it.
+ */
+export const FACT_STATES = ['raw', 'candidate', 'active', 'retracted'];
+/** Old status values → new ones. Kept here so the migration and the reader agree. */
+export const FACT_STATE_MIGRATION = {
+    none: 'active',
+    open: 'active',
+    kept: 'active',
+    broken: 'retracted',
+    superseded: 'retracted',
+};
+/**
+ * The old Chinese type labels mapped to structural roles.
+ *
+ * `type_name` used to be the only place that said what a fact was, and rows written before the
+ * role column still carry it. One table, used by the writer (new rows get a role), by the reader
+ * fallback, and by the migration script — so the three cannot disagree.
+ */
+export const LEGACY_ROLE_BY_TYPE = {
+    规则: 'rule',
+    画像: 'profile',
+    结论: 'judgment',
+    判断: 'judgment',
+    决定: 'judgment',
+    承诺: 'promise',
+    教训: 'lesson',
+};

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

@@ -0,0 +1,22 @@
+/**
+ * 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 declare const CLASSIFY_LABELS: {
+    readonly rule: '规则';
+    readonly profile: '画像';
+    readonly pending: '待修';
+};
+export type ClassifyLabel = (typeof CLASSIFY_LABELS)[keyof typeof CLASSIFY_LABELS];
+/** The judgment a conclusion is stored as. */
+export declare const CONCLUSION_TYPE = "\u7ED3\u8BBA";
+/**
+ * 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 declare const ANCHOR_TYPES: readonly string[];

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[];