@jungjaehoon/mama-os 0.28.5 → 0.29.0

package/dist/evidence/effects.d.ts

@@ -0,0 +1,107 @@
+/** What kind of durable change happened. Closed on purpose - see the module note. */
+export type EffectKind = 'task_create' | 'task_update' | 'report_update' | 'report_publish' | 'memory_write' | 'wiki_write';
+/** What it happened to. */
+export type EffectTarget = 'task' | 'report_slot' | 'memory' | 'wiki_page';
+/** Whether the change could name what caused it. */
+export type CauseState = 'attributed' | 'unattributed';
+/** Fields every durable change carries, whether or not it can name a cause. */
+export interface ChangeInput {
+    /**
+     * The model run that produced the change, so it is traceable to a transcript.
+     * Null when no model run did - a host-internal write is not made more honest by
+     * inventing a run id for it.
+     */
+    runId?: string | null;
+    /** Evidence channel this change concerns, when it concerns one. */
+    channelId?: string | null;
+    kind: EffectKind;
+    targetType: EffectTarget;
+    targetId: string;
+    /** The written payload; hashed, never stored, so the ledger cannot leak content. */
+    payload: unknown;
+    atMs: number;
+}
+export interface EffectInput extends ChangeInput {
+    /** Events that caused it. Must not be empty. */
+    sourceEventIds: readonly string[];
+}
+export interface EffectRecord {
+    id: number;
+    runId: string | null;
+    channelId: string | null;
+    causeState: CauseState;
+    sourceEventIds: string[];
+    kind: EffectKind;
+    targetType: EffectTarget;
+    targetId: string;
+    payloadHash: string;
+    atMs: number;
+}
+/**
+ * Whether a value can serve as a cause at all.
+ *
+ * Callers ask before writing rather than discovering it as a constraint violation,
+ * because the answer changes what they record, not whether they may proceed: a malformed
+ * cause makes a change unattributed, it does not make the change illegitimate. Legacy
+ * rows really do carry 400-character source identifiers, and refusing to let the operator
+ * update a work item because its upstream id is the wrong shape would be enforcement
+ * bought with the owner's work.
+ */
+export declare function isUsableCause(value: string | null | undefined): value is string;
+export declare const EVIDENCE_EFFECTS_DDL: string;
+interface EffectAdapter {
+    prepare(sql: string): {
+        run(...params: unknown[]): {
+            lastInsertRowid?: number | bigint;
+        };
+        all(...params: unknown[]): unknown[];
+    };
+}
+export declare function ensureEffectLedger(adapter: EffectAdapter): void;
+export declare class EffectWithoutCauseError extends Error {
+    constructor(kind: EffectKind, targetId: string);
+}
+/** Stable hash of what was written. The ledger proves a change happened, not what it said. */
+export declare function payloadHash(payload: unknown): string;
+/**
+ * Record a durable change.
+ *
+ * Throws rather than returning a failure when the cause is missing. A caller that wrote
+ * something and then could not say why must not proceed as if the write were accounted
+ * for - silently skipping the ledger row is how 1,169 runs closed as `done` while five
+ * receipts existed.
+ */
+export declare function recordEffect(adapter: EffectAdapter, input: EffectInput): number;
+/**
+ * Record a durable change that could not name what caused it.
+ *
+ * Deliberately a separate function with an uncomfortable name. Every call is an admission
+ * that the system changed something it cannot explain, and the point is that the count of
+ * these is visible next to the count of real effects rather than absent from both.
+ */
+export declare function recordUnattributedChange(adapter: EffectAdapter, input: ChangeInput): number;
+export interface EffectQuery {
+    runId?: string;
+    targetType?: EffectTarget;
+    targetId?: string;
+    causeState?: CauseState;
+    sinceMs?: number;
+    limit?: number;
+}
+/** Read effects back, newest first - the substrate a report projects from. */
+export declare function listEffects(adapter: EffectAdapter, query?: EffectQuery): EffectRecord[];
+export interface ChangeCoverage {
+    /** Changes that named the events behind them. */
+    attributed: number;
+    /** Changes the system made and could not explain. */
+    unattributed: number;
+}
+/**
+ * How much of what the system changed rests on evidence.
+ *
+ * The single number this ledger exists to make answerable, and the one the previous shape
+ * of the system could not produce at all.
+ */
+export declare function changeCoverage(adapter: EffectAdapter, sinceMs?: number, targetType?: EffectTarget): ChangeCoverage;
+export {};
+//# sourceMappingURL=effects.d.ts.map

package/dist/evidence/effects.d.ts.map

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

package/dist/evidence/effects.js

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectWithoutCauseError = exports.EVIDENCE_EFFECTS_DDL = void 0;
+exports.isUsableCause = isUsableCause;
+exports.ensureEffectLedger = ensureEffectLedger;
+exports.payloadHash = payloadHash;
+exports.recordEffect = recordEffect;
+exports.recordUnattributedChange = recordUnattributedChange;
+exports.listEffects = listEffects;
+exports.changeCoverage = changeCoverage;
+/**
+ * Every durable change, and what caused it.
+ *
+ * This is the half the system never had. Measured over ten days: 1,471 workorders ran,
+ * 1,169 of them closed as `done`, and FIVE durable effect receipts exist - all five inside
+ * one eleven-minute window a week earlier. `done` meant "the run finished", not "something
+ * changed", and nothing downstream could tell the difference. The peer system recorded
+ * 1,080 effects over the same kind of window, every one of them naming the events that
+ * caused it, and its reports are projections of that table rather than prose assembled
+ * from whatever a model happened to read.
+ *
+ * So the rule here is narrow and total:
+ *
+ * A CHANGE THAT CANNOT NAME ITS CAUSE IS NOT RECORDED AS ONE. `source_event_ids` is NOT
+ * NULL and must be non-empty, enforced by the schema rather than by callers remembering.
+ * The tempting softening - allow an empty array "for now" - is exactly how the effect
+ * table becomes a second log: it would fill with rows that prove nothing, and the first
+ * question anyone asks of it ("what made this happen?") would have no answer for most of
+ * them. If a write genuinely has no observed cause, that is worth discovering, not
+ * papering over.
+ *
+ * The kinds are a closed set for the same reason the peer's are: an open `effect_kind`
+ * column drifts into free text within a month, and then counting what the system actually
+ * did requires reading strings. Adding a kind should be a deliberate edit here.
+ *
+ * ONE TABLE, BOTH NUMBERS. A change that could not name a cause is still recorded here,
+ * marked `unattributed` and holding an empty cause list that the schema forces to stay
+ * empty. This is not the softening warned about above - `recordEffect` still refuses a
+ * causeless effect, and a writer has to call `recordUnattributedChange` by name to admit
+ * one. It is here because the failure this whole redesign keeps finding is a numerator
+ * with no denominator. Split across two tables, "every effect names its cause" is true by
+ * construction and means nothing; in one table the ratio is a single GROUP BY.
+ *
+ * WHAT THIS TABLE DOES NOT YET ANSWER, stated plainly so nobody reads more into the
+ * number than it holds: the "1,169 done, five receipts" comparison needs RUNS beside
+ * CHANGES, and runs still live in `operator_tasks`. `changeCoverage` answers "of the
+ * changes recorded, how many rest on evidence" - not "how many runs changed anything".
+ * The join that answers the second question needs the run id on both sides, and only one
+ * side carries it today.
+ *
+ * Recording the unattributed change rather than refusing the write follows the operating
+ * rule this system runs under: enforce only what is irreversible or externally visible,
+ * and make everything else loud. A task row is neither, so the ledger observes it.
+ *
+ * A CAUSE IS AN EVENT ID, and the schema checks the shape rather than trusting the helper
+ * to have filtered - `[""]`, `[null]`, `[0]` and a 200 KB string are all "non-empty
+ * arrays" and all lies. What the schema still cannot check is whether the id names an
+ * event that exists and is readable: the event index lives in a different database. A
+ * cited cause that resolves to nothing is a fabricated citation, and catching those is the
+ * next thing this needs.
+ */
+const node_crypto_1 = require("node:crypto");
+const EFFECT_KINDS = [
+    'task_create',
+    'task_update',
+    'report_update',
+    'report_publish',
+    'memory_write',
+    'wiki_write',
+];
+const EFFECT_TARGETS = ['task', 'report_slot', 'memory', 'wiki_page'];
+/** Long enough for any upstream id, short enough that the column cannot carry content. */
+const MAX_EVENT_ID_LENGTH = 200;
+const PAYLOAD_HASH_LENGTH = 32;
+/**
+ * Whether a value can serve as a cause at all.
+ *
+ * Callers ask before writing rather than discovering it as a constraint violation,
+ * because the answer changes what they record, not whether they may proceed: a malformed
+ * cause makes a change unattributed, it does not make the change illegitimate. Legacy
+ * rows really do carry 400-character source identifiers, and refusing to let the operator
+ * update a work item because its upstream id is the wrong shape would be enforcement
+ * bought with the owner's work.
+ */
+function isUsableCause(value) {
+    if (typeof value !== 'string')
+        return false;
+    const trimmed = value.trim();
+    return trimmed.length > 0 && trimmed.length <= MAX_EVENT_ID_LENGTH;
+}
+const quoted = (values) => values.map((v) => `'${v}'`).join(', ');
+exports.EVIDENCE_EFFECTS_DDL = `
+  CREATE TABLE IF NOT EXISTS evidence_effects (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT,
+    channel_id TEXT,
+    cause_state TEXT NOT NULL CHECK (cause_state IN ('attributed', 'unattributed')),
+    source_event_ids_json TEXT NOT NULL
+      CHECK (
+        json_valid(source_event_ids_json)
+        AND (
+          (cause_state = 'attributed' AND json_array_length(source_event_ids_json) >= 1)
+          OR (cause_state = 'unattributed' AND json_array_length(source_event_ids_json) = 0)
+        )
+      ),
+    effect_kind TEXT NOT NULL CHECK (effect_kind IN (${quoted(EFFECT_KINDS)})),
+    target_type TEXT NOT NULL CHECK (target_type IN (${quoted(EFFECT_TARGETS)})),
+    target_id TEXT NOT NULL CHECK (length(trim(target_id)) > 0),
+    payload_hash TEXT NOT NULL CHECK (length(payload_hash) = ${PAYLOAD_HASH_LENGTH}),
+    created_at INTEGER NOT NULL CHECK (typeof(created_at) = 'integer' AND created_at >= 0)
+  )
+`;
+/**
+ * Per-element shape of the cause list.
+ *
+ * A trigger rather than a CHECK because SQLite forbids subqueries in CHECK, and checking
+ * each element needs `json_each`. Without this the column enforces only "non-empty array",
+ * which `[""]` and `[null]` and `[0]` all satisfy while naming nothing.
+ *
+ * The length bound is not cosmetic: an unbounded cause id turns an audit ledger into a
+ * content channel, which is the one thing the payload is hashed to avoid.
+ */
+const EVIDENCE_EFFECTS_CAUSE_TRIGGER = `
+  CREATE TRIGGER IF NOT EXISTS evidence_effects_cause_shape
+  BEFORE INSERT ON evidence_effects
+  WHEN EXISTS (
+    SELECT 1 FROM json_each(NEW.source_event_ids_json)
+     WHERE json_each.type <> 'text'
+        OR trim(json_each.value) = ''
+        OR length(json_each.value) > ${MAX_EVENT_ID_LENGTH}
+  )
+  BEGIN
+    SELECT RAISE(ABORT, 'evidence_effects: a cause must be a non-empty event id');
+  END
+`;
+const INDEXES = [
+    `CREATE INDEX IF NOT EXISTS idx_evidence_effects_run
+     ON evidence_effects(run_id, created_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_evidence_effects_target
+     ON evidence_effects(target_type, target_id, created_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_evidence_effects_channel
+     ON evidence_effects(channel_id, created_at DESC)`,
+    // Coverage is meant to be cheap enough that nobody has an excuse not to look.
+    `CREATE INDEX IF NOT EXISTS idx_evidence_effects_coverage
+     ON evidence_effects(created_at DESC, cause_state)`,
+];
+function ensureEffectLedger(adapter) {
+    adapter.prepare(exports.EVIDENCE_EFFECTS_DDL).run();
+    adapter.prepare(EVIDENCE_EFFECTS_CAUSE_TRIGGER).run();
+    for (const sql of INDEXES) {
+        adapter.prepare(sql).run();
+    }
+}
+class EffectWithoutCauseError extends Error {
+    constructor(kind, targetId) {
+        super(`Refusing to record ${kind} on ${targetId} with no source events: a change that cannot name its cause is not an effect.`);
+        this.name = 'EffectWithoutCauseError';
+    }
+}
+exports.EffectWithoutCauseError = EffectWithoutCauseError;
+/** Stable hash of what was written. The ledger proves a change happened, not what it said. */
+function payloadHash(payload) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify(payload ?? null))
+        .digest('hex')
+        .slice(0, PAYLOAD_HASH_LENGTH);
+}
+/**
+ * Record a durable change.
+ *
+ * Throws rather than returning a failure when the cause is missing. A caller that wrote
+ * something and then could not say why must not proceed as if the write were accounted
+ * for - silently skipping the ledger row is how 1,169 runs closed as `done` while five
+ * receipts existed.
+ */
+function recordEffect(adapter, input) {
+    const sourceEventIds = [
+        ...new Set(input.sourceEventIds.filter(isUsableCause).map((id) => id.trim())),
+    ];
+    if (sourceEventIds.length === 0) {
+        throw new EffectWithoutCauseError(input.kind, input.targetId);
+    }
+    return insertChange(adapter, input, 'attributed', sourceEventIds);
+}
+/**
+ * Record a durable change that could not name what caused it.
+ *
+ * Deliberately a separate function with an uncomfortable name. Every call is an admission
+ * that the system changed something it cannot explain, and the point is that the count of
+ * these is visible next to the count of real effects rather than absent from both.
+ */
+function recordUnattributedChange(adapter, input) {
+    return insertChange(adapter, input, 'unattributed', []);
+}
+function insertChange(adapter, input, causeState, sourceEventIds) {
+    const result = adapter
+        .prepare(`INSERT INTO evidence_effects
+         (run_id, channel_id, cause_state, source_event_ids_json,
+          effect_kind, target_type, target_id, payload_hash, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(input.runId ?? null, input.channelId ?? null, causeState, JSON.stringify(sourceEventIds), input.kind, input.targetType, input.targetId, payloadHash(input.payload), input.atMs);
+    return Number(result.lastInsertRowid ?? 0);
+}
+/** Read effects back, newest first - the substrate a report projects from. */
+function listEffects(adapter, query = {}) {
+    const clauses = [];
+    const params = [];
+    if (query.runId !== undefined) {
+        clauses.push('run_id = ?');
+        params.push(query.runId);
+    }
+    if (query.targetType !== undefined) {
+        clauses.push('target_type = ?');
+        params.push(query.targetType);
+    }
+    if (query.targetId !== undefined) {
+        clauses.push('target_id = ?');
+        params.push(query.targetId);
+    }
+    if (query.causeState !== undefined) {
+        clauses.push('cause_state = ?');
+        params.push(query.causeState);
+    }
+    if (query.sinceMs !== undefined) {
+        clauses.push('created_at >= ?');
+        params.push(query.sinceMs);
+    }
+    params.push(Math.min(Math.max(query.limit ?? 200, 1), 1000));
+    const rows = adapter
+        .prepare(`SELECT * FROM evidence_effects
+        ${clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : ''}
+        ORDER BY created_at DESC, id DESC
+        LIMIT ?`)
+        .all(...params);
+    return rows.map((row) => ({
+        id: Number(row.id),
+        runId: typeof row.run_id === 'string' ? row.run_id : null,
+        channelId: typeof row.channel_id === 'string' ? row.channel_id : null,
+        causeState: String(row.cause_state),
+        sourceEventIds: JSON.parse(String(row.source_event_ids_json)),
+        kind: String(row.effect_kind),
+        targetType: String(row.target_type),
+        targetId: String(row.target_id),
+        payloadHash: String(row.payload_hash),
+        atMs: Number(row.created_at),
+    }));
+}
+/**
+ * How much of what the system changed rests on evidence.
+ *
+ * The single number this ledger exists to make answerable, and the one the previous shape
+ * of the system could not produce at all.
+ */
+function changeCoverage(adapter, sinceMs, targetType) {
+    // Coverage must describe the same population as the rows a caller is looking at, or the
+    // two halves of one answer disagree and the reader cannot tell which is wrong.
+    const clauses = [];
+    const params = [];
+    if (sinceMs !== undefined) {
+        clauses.push('created_at >= ?');
+        params.push(sinceMs);
+    }
+    if (targetType !== undefined) {
+        clauses.push('target_type = ?');
+        params.push(targetType);
+    }
+    const rows = adapter
+        .prepare(`SELECT cause_state, COUNT(*) AS n FROM evidence_effects
+        ${clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : ''}
+        GROUP BY cause_state`)
+        .all(...params);
+    const coverage = { attributed: 0, unattributed: 0 };
+    for (const row of rows) {
+        if (row.cause_state === 'attributed')
+            coverage.attributed = Number(row.n);
+        if (row.cause_state === 'unattributed')
+            coverage.unattributed = Number(row.n);
+    }
+    return coverage;
+}
+//# sourceMappingURL=effects.js.map

package/dist/evidence/effects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects.js","sourceRoot":"","sources":["../../src/evidence/effects.ts"],"names":[],"mappings":";;;AAiIA,sCAIC;AAqED,gDAMC;AAYD,kCAKC;AAUD,oCAQC;AASD,4DAEC;AAuCD,kCA8CC;AAeD,wCA8BC;AAhYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,6CAAyC;AAqDzC,MAAM,YAAY,GAA0B;IAC1C,aAAa;IACb,aAAa;IACb,eAAe;IACf,gBAAgB;IAChB,cAAc;IACd,YAAY;CACb,CAAC;AAEF,MAAM,cAAc,GAA4B,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;AAE/F,0FAA0F;AAC1F,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAChC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAE/B;;;;;;;;;GASG;AACH,SAAgB,aAAa,CAAC,KAAgC;IAC5D,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,CAAC,MAAM,IAAI,mBAAmB,CAAC;AACrE,CAAC;AAED,MAAM,MAAM,GAAG,CAAC,MAAyB,EAAU,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEhF,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;uDAcmB,MAAM,CAAC,YAAY,CAAC;uDACpB,MAAM,CAAC,cAAc,CAAC;;+DAEd,mBAAmB;;;CAGjF,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,8BAA8B,GAAG;;;;;;;uCAOA,mBAAmB;;;;;CAKzD,CAAC;AAEF,MAAM,OAAO,GAAG;IACd;kDACgD;IAChD;kEACgE;IAChE;sDACoD;IACpD,8EAA8E;IAC9E;uDACqD;CACtD,CAAC;AASF,SAAgB,kBAAkB,CAAC,OAAsB;IACvD,OAAO,CAAC,OAAO,CAAC,4BAAoB,CAAC,CAAC,GAAG,EAAE,CAAC;IAC5C,OAAO,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAC,GAAG,EAAE,CAAC;IACtD,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC1B,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;IAC7B,CAAC;AACH,CAAC;AAED,MAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,IAAgB,EAAE,QAAgB;QAC5C,KAAK,CACH,sBAAsB,IAAI,OAAO,QAAQ,+EAA+E,CACzH,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF;AAPD,0DAOC;AAED,8FAA8F;AAC9F,SAAgB,WAAW,CAAC,OAAgB;IAC1C,OAAO,IAAA,wBAAU,EAAC,QAAQ,CAAC;SACxB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC;SACvC,MAAM,CAAC,KAAK,CAAC;SACb,KAAK,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,YAAY,CAAC,OAAsB,EAAE,KAAkB;IACrE,MAAM,cAAc,GAAG;QACrB,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;KAC9E,CAAC;IACF,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChC,MAAM,IAAI,uBAAuB,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,YAAY,CAAC,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;AACpE,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,wBAAwB,CAAC,OAAsB,EAAE,KAAkB;IACjF,OAAO,YAAY,CAAC,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC;AAC1D,CAAC;AAED,SAAS,YAAY,CACnB,OAAsB,EACtB,KAAkB,EAClB,UAAsB,EACtB,cAAiC;IAEjC,MAAM,MAAM,GAAG,OAAO;SACnB,OAAO,CACN;;;0CAGoC,CACrC;SACA,GAAG,CACF,KAAK,CAAC,KAAK,IAAI,IAAI,EACnB,KAAK,CAAC,SAAS,IAAI,IAAI,EACvB,UAAU,EACV,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,EAC9B,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,QAAQ,EACd,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,EAC1B,KAAK,CAAC,IAAI,CACX,CAAC;IACJ,OAAO,MAAM,CAAC,MAAM,CAAC,eAAe,IAAI,CAAC,CAAC,CAAC;AAC7C,CAAC;AAWD,8EAA8E;AAC9E,SAAgB,WAAW,CAAC,OAAsB,EAAE,QAAqB,EAAE;IACzE,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,MAAM,MAAM,GAAc,EAAE,CAAC;IAC7B,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC3B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IACD,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACnC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAChC,CAAC;IACD,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;QACjC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC9B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IACD,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACnC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAChC,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;IAE7D,MAAM,IAAI,GAAG,OAAO;SACjB,OAAO,CACN;UACI,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE;;gBAEpD,CACX;SACA,GAAG,CAAC,GAAG,MAAM,CAAmC,CAAC;IAEpD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACxB,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QAClB,KAAK,EAAE,OAAO,GAAG,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI;QACzD,SAAS,EAAE,OAAO,GAAG,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI;QACrE,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,WAAW,CAAe;QACjD,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAa;QACzE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,WAAW,CAAe;QAC3C,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,WAAW,CAAiB;QACnD,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;QAC/B,WAAW,EAAE,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC;QACrC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC;KAC7B,CAAC,CAAC,CAAC;AACN,CAAC;AASD;;;;;GAKG;AACH,SAAgB,cAAc,CAC5B,OAAsB,EACtB,OAAgB,EAChB,UAAyB;IAEzB,wFAAwF;IACxF,+EAA+E;IAC/E,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,MAAM,MAAM,GAAc,EAAE,CAAC;IAC7B,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IACD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC1B,CAAC;IACD,MAAM,IAAI,GAAG,OAAO;SACjB,OAAO,CACN;UACI,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE;6BACvC,CACxB;SACA,GAAG,CAAC,GAAG,MAAM,CAAmC,CAAC;IACpD,MAAM,QAAQ,GAAmB,EAAE,UAAU,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;IACpE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,GAAG,CAAC,WAAW,KAAK,YAAY;YAAE,QAAQ,CAAC,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC1E,IAAI,GAAG,CAAC,WAAW,KAAK,cAAc;YAAE,QAAQ,CAAC,YAAY,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/evidence/read.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The live grant: which connectors and channels this system was told to look at.
+ *
+ * This file used to also carry a boolean visibility predicate and a SQL reader of its own -
+ * a third and fourth compiled copy of a rule whose whole point was that there be one. Both
+ * had zero callers, which is worse than a live copy rather than better: nothing exercises
+ * them, so nothing notices when they drift, and they sit there looking authoritative until
+ * someone reads one and believes it. They are deleted. The rule lives in mama-core's
+ * channel-grant.ts, where its two used forms sit adjacent with a differential between them.
+ *
+ * What remains here is the part that is genuinely local: turning the owner's connector
+ * config into a grant, and narrowing that grant to what one envelope may read.
+ *
+ * WHY A GRANT AT ALL. The path it replaced returned ZERO rows out of 30,671 in production,
+ * blocked four separate ways at once: a project window whose column was null on every row,
+ * a tenant partition with exactly one value, a scope-id namespace that shared nothing with
+ * the one callers hold, and a legacy escape hatch gated shut whenever any specific scope
+ * was present - which is always. Each was individually fatal, so this is a replacement and
+ * not a repair.
+ *
+ * An event is visible when the caller was granted its connector and its channel. Both come
+ * from `(source_connector, channel)`, which every indexed row carries with no nulls, and
+ * which is the SAME key the connector config declares its channels under. The old path
+ * invented a third naming layer on top of that key, populated it 37% of the time, and then
+ * filtered on it.
+ */
+import type { ChannelGrant } from '@jungjaehoon/mama-core/context-compile';
+/**
+ * Build a grant from the connector config, which already names every channel.
+ *
+ * A connector present with an EMPTY channel list is denied rather than granted everything -
+ * that rule is stated and enforced in `isChannelGranted`, which is the only place it lives.
+ */
+export declare function grantFromConnectorConfig(config: unknown): ChannelGrant;
+/**
+ * The live grant, read fresh on every call.
+ *
+ * Not cached at boot: the owner adds and removes channels while the daemon runs, and a
+ * grant captured once would keep reading a channel after it was removed - the failure
+ * mode where turning something off does not turn it off.
+ */
+export declare function liveBoundaryChannels(): ChannelGrant;
+/**
+ * Narrow the configured grant to what THIS envelope may read.
+ *
+ * Two independent narrowings, and the second is the whole reason this exists rather than a
+ * one-line filter:
+ *
+ * 1. Connector - the envelope's `raw_connectors` is the standing permission.
+ *
+ * 2. CHANNEL - when the envelope names channel scopes, only those channels are readable.
+ *    Raw visibility used to be decided by the scope columns, so a per-message envelope
+ *    scoped to one channel could not reach another. Deciding it by connector alone silently
+ *    dropped that isolation: reactive envelopes for two channels of the same connector
+ *    carry identical `raw_connectors`, so every such run could have compiled 500-character
+ *    excerpts out of every other configured channel of that connector. The scope columns
+ *    were the wrong mechanism - populated on 37% of rows in three namespaces - but the
+ *    isolation they attempted is real, and it belongs here, where the envelope's own
+ *    channel scopes state it exactly.
+ *
+ * An envelope with no channel scope is a run that was never bound to one (a report, a
+ * scheduled worker), and it keeps the connector-level ceiling.
+ *
+ * CALLERS MUST PASS THE ENVELOPE'S OWN SCOPES, never a caller-requested subset. A request
+ * may narrow what it asks for; it must not be able to widen its grant by asking for less.
+ * Two surfaces got that wrong before it was written down here.
+ */
+export declare function narrowGrantToEnvelope(configured: ChannelGrant, visibility: {
+    connectors: readonly string[];
+    scopes: readonly {
+        kind: string;
+        id: string;
+    }[];
+}): ChannelGrant;
+//# sourceMappingURL=read.d.ts.map

package/dist/evidence/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/evidence/read.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC;AAG3E;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,YAAY,CAqBtE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,YAAY,CAMnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,YAAY,EACxB,UAAU,EAAE;IACV,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,MAAM,EAAE,SAAS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACjD,GACA,YAAY,CA0Bd"}

package/dist/evidence/read.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grantFromConnectorConfig = grantFromConnectorConfig;
+exports.liveBoundaryChannels = liveBoundaryChannels;
+exports.narrowGrantToEnvelope = narrowGrantToEnvelope;
+const config_loader_js_1 = require("../connectors/config-loader.js");
+/**
+ * Build a grant from the connector config, which already names every channel.
+ *
+ * A connector present with an EMPTY channel list is denied rather than granted everything -
+ * that rule is stated and enforced in `isChannelGranted`, which is the only place it lives.
+ */
+function grantFromConnectorConfig(config) {
+    const grant = {};
+    if (config === null || typeof config !== 'object') {
+        return grant;
+    }
+    for (const [connector, raw] of Object.entries(config)) {
+        if (raw === null || typeof raw !== 'object') {
+            continue;
+        }
+        const entry = raw;
+        // A disabled connector is not a grant. Reading its history because rows survive
+        // disabling would make "off" mean "off for new data only".
+        if (entry.enabled === false) {
+            continue;
+        }
+        if (entry.channels === null || typeof entry.channels !== 'object') {
+            continue;
+        }
+        grant[connector] = Object.keys(entry.channels);
+    }
+    return grant;
+}
+/**
+ * The live grant, read fresh on every call.
+ *
+ * Not cached at boot: the owner adds and removes channels while the daemon runs, and a
+ * grant captured once would keep reading a channel after it was removed - the failure
+ * mode where turning something off does not turn it off.
+ */
+function liveBoundaryChannels() {
+    const loaded = (0, config_loader_js_1.loadConnectorConfig)();
+    // A config that cannot be read is not a grant. Falling back to "everything" on a parse
+    // error is how a read path ends up wider precisely when the configuration is broken.
+    if (!loaded.ok)
+        return {};
+    return grantFromConnectorConfig(loaded.config);
+}
+/**
+ * Narrow the configured grant to what THIS envelope may read.
+ *
+ * Two independent narrowings, and the second is the whole reason this exists rather than a
+ * one-line filter:
+ *
+ * 1. Connector - the envelope's `raw_connectors` is the standing permission.
+ *
+ * 2. CHANNEL - when the envelope names channel scopes, only those channels are readable.
+ *    Raw visibility used to be decided by the scope columns, so a per-message envelope
+ *    scoped to one channel could not reach another. Deciding it by connector alone silently
+ *    dropped that isolation: reactive envelopes for two channels of the same connector
+ *    carry identical `raw_connectors`, so every such run could have compiled 500-character
+ *    excerpts out of every other configured channel of that connector. The scope columns
+ *    were the wrong mechanism - populated on 37% of rows in three namespaces - but the
+ *    isolation they attempted is real, and it belongs here, where the envelope's own
+ *    channel scopes state it exactly.
+ *
+ * An envelope with no channel scope is a run that was never bound to one (a report, a
+ * scheduled worker), and it keeps the connector-level ceiling.
+ *
+ * CALLERS MUST PASS THE ENVELOPE'S OWN SCOPES, never a caller-requested subset. A request
+ * may narrow what it asks for; it must not be able to widen its grant by asking for less.
+ * Two surfaces got that wrong before it was written down here.
+ */
+function narrowGrantToEnvelope(configured, visibility) {
+    // Channel scope ids are `<connector>:<channelId>` (deriveMemoryScopes). Split on the
+    // FIRST separator only: channel ids contain colons of their own.
+    const scopedChannels = new Map();
+    for (const scope of visibility.scopes) {
+        if (scope.kind !== 'channel')
+            continue;
+        const separator = scope.id.indexOf(':');
+        if (separator <= 0)
+            continue;
+        const connector = scope.id.slice(0, separator);
+        const channelId = scope.id.slice(separator + 1);
+        if (channelId.length === 0)
+            continue;
+        const existing = scopedChannels.get(connector) ?? new Set();
+        existing.add(channelId);
+        scopedChannels.set(connector, existing);
+    }
+    const narrowed = {};
+    for (const [connector, channels] of Object.entries(configured)) {
+        if (!visibility.connectors.includes(connector))
+            continue;
+        const bound = scopedChannels.get(connector);
+        // A channel scope naming no configured channel leaves the connector with an empty
+        // grant, which reads nothing. That is the correct answer: the run is bound to a channel
+        // this system was not told to look at.
+        narrowed[connector] = bound ? channels.filter((channel) => bound.has(channel)) : channels;
+    }
+    return narrowed;
+}
+//# sourceMappingURL=read.js.map

package/dist/evidence/read.js.map

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

package/dist/gateways/base-gateway.d.ts

@@ -5,14 +5,34 @@
  * Platform-specific behavior is implemented via abstract methods and properties.
  */
 import type { Gateway, GatewayEvent, GatewayEventHandler, GatewayConfig, MessageSource } from './types.js';
-import { MessageRouter } from './message-router.js';
+import type { SessionDirectory, TurnProcessor } from './turn-contract.js';
 export interface BaseGatewayOptions {
-    messageRouter: MessageRouter;
+    /**
+     * How a turn is processed. Required, because this is what a user-facing surface
+     * actually needs; the concrete router is an extra capability, not the dependency.
+     */
+    turnProcessor: TurnProcessor;
+    /**
+     * Optional, and narrow. Only surfaces that read session data for their own display
+     * concerns - naming a channel, listing what is active - ask for this. It is not a
+     * router: a surface that serves turns cannot reach past the contract through it.
+     */
+    sessionDirectory?: SessionDirectory;
     config?: Partial<GatewayConfig>;
 }
 export declare abstract class BaseGateway implements Gateway {
     abstract readonly source: MessageSource;
-    protected messageRouter: MessageRouter;
+    protected sessionDirectory?: SessionDirectory;
+    /**
+     * The turn seam, shared by every user-facing surface.
+     *
+     * Telegram, Discord and Slack are ONE role - the place a person reaches the agent - so
+     * the boundary belongs here rather than to any one of them. Connectors are not turn
+     * sources at all; they are data the agent reads, and they never pass through here.
+     *
+     * Required: a surface that serves turns needs this and nothing else.
+     */
+    protected turnProcessor: TurnProcessor;
     protected eventHandlers: GatewayEventHandler[];
     protected connected: boolean;
     constructor(options: BaseGatewayOptions);

package/dist/gateways/base-gateway.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-gateway.d.ts","sourceRoot":"","sources":["../../src/gateways/base-gateway.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,OAAO,EACP,YAAY,EACZ,mBAAmB,EACnB,aAAa,EACb,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,aAAa,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CACjC;AAED,8BAAsB,WAAY,YAAW,OAAO;IAClD,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAExC,SAAS,CAAC,aAAa,EAAE,aAAa,CAAC;IACvC,SAAS,CAAC,aAAa,EAAE,mBAAmB,EAAE,CAAM;IACpD,SAAS,CAAC,SAAS,UAAS;gBAEhB,OAAO,EAAE,kBAAkB;IAMvC,QAAQ,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAC/B,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IACpE,QAAQ,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAEvF,0EAA0E;IAC1E,SAAS,CAAC,QAAQ,KAAK,cAAc,IAAI,MAAM,GAAG,IAAI,CAAC;IAIvD,WAAW,IAAI,OAAO;IAItB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAI3C,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAU9C,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAIvD"}
+{"version":3,"file":"base-gateway.d.ts","sourceRoot":"","sources":["../../src/gateways/base-gateway.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,OAAO,EACP,YAAY,EACZ,mBAAmB,EACnB,aAAa,EACb,aAAa,EACd,MAAM,YAAY,CAAC;AAGpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAE1E,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,aAAa,EAAE,aAAa,CAAC;IAC7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CACjC;AAED,8BAAsB,WAAY,YAAW,OAAO;IAClD,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAExC,SAAS,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAC9C;;;;;;;;OAQG;IACH,SAAS,CAAC,aAAa,EAAE,aAAa,CAAC;IACvC,SAAS,CAAC,aAAa,EAAE,mBAAmB,EAAE,CAAM;IACpD,SAAS,CAAC,SAAS,UAAS;gBAEhB,OAAO,EAAE,kBAAkB;IASvC,QAAQ,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAC/B,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IACpE,QAAQ,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAEvF,0EAA0E;IAC1E,SAAS,CAAC,QAAQ,KAAK,cAAc,IAAI,MAAM,GAAG,IAAI,CAAC;IAIvD,WAAW,IAAI,OAAO;IAItB,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAI3C,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAU9C,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAIvD"}