@open-everywhere/core 0.1.0

package/dist/agent/channels/channel-key.js

@@ -0,0 +1,53 @@
+// channel-key — the platform-blind address the model uses for one conversational container: `ch_` plus base64url of `<platform>:<container>`.
+// It is a reversible ADDRESS, never a secret and never a capability: holding a key grants nothing, and every read still passes the window-sources gate, the per-turn origin fence and the domain allowlist.
+export const CHANNEL_KEY_PREFIX = "ch_";
+/** base64url, no padding — the alphabet is `[A-Za-z0-9_-]`, so a key is one word in any render,
+ *  never needs escaping in XML, and survives a copy through a model's own output unchanged. */
+function b64url(s) {
+    return Buffer.from(s, "utf8").toString("base64").replace(/\+/gu, "-").replace(/\//gu, "_").replace(/=+$/u, "");
+}
+/**
+ * Mint the channel key for one container.
+ * Fail-soft: the pure wake renderer must never throw, so an empty platform or container returns the container id unchanged instead of a key that decodes to nothing.
+ */
+export function encodeChannelKey(platform, container) {
+    if (!container)
+        return "";
+    if (!platform)
+        return container;
+    return `${CHANNEL_KEY_PREFIX}${b64url(`${platform}:${container}`)}`;
+}
+/**
+ * Read a channel key back to its (platform, container) pair, or `null` for anything that is not one.
+ * Strict: a non-canonical body, a missing `:` or an empty side all answer `null`, so the caller refuses instead of guessing a platform.
+ */
+export function decodeChannelKey(key) {
+    if (!key.startsWith(CHANNEL_KEY_PREFIX))
+        return null;
+    const body = key.slice(CHANNEL_KEY_PREFIX.length);
+    if (!body || !/^[A-Za-z0-9_-]+$/u.test(body))
+        return null;
+    let decoded;
+    try {
+        decoded = Buffer.from(body.replace(/-/gu, "+").replace(/_/gu, "/"), "base64").toString("utf8");
+    }
+    catch {
+        return null;
+    }
+    // Canonicality: base64 decoding is lenient (it drops trailing bits), so re-encode and compare.
+    // Two different keys must never name one container.
+    if (b64url(decoded) !== body)
+        return null;
+    const sep = decoded.indexOf(":");
+    if (sep <= 0)
+        return null; // no separator, or an empty platform
+    const platform = decoded.slice(0, sep);
+    const container = decoded.slice(sep + 1);
+    if (!container)
+        return null;
+    return { platform, container };
+}
+export function isChannelKey(s) {
+    return decodeChannelKey(s) !== null;
+}
+//# sourceMappingURL=channel-key.js.map

package/dist/agent/channels/channel-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-key.js","sourceRoot":"","sources":["../../../agent/channels/channel-key.ts"],"names":[],"mappings":"AAAA,8IAA8I;AAC9I,4MAA4M;AAE5M,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,CAAC;AASxC;+FAC+F;AAC/F,SAAS,MAAM,CAAC,CAAS;IACvB,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AACjH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAgB,EAAE,SAAiB;IAClE,IAAI,CAAC,SAAS;QAAE,OAAO,EAAE,CAAC;IAC1B,IAAI,CAAC,QAAQ;QAAE,OAAO,SAAS,CAAC;IAChC,OAAO,GAAG,kBAAkB,GAAG,MAAM,CAAC,GAAG,QAAQ,IAAI,SAAS,EAAE,CAAC,EAAE,CAAC;AACtE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAW;IAC1C,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,kBAAkB,CAAC;QAAE,OAAO,IAAI,CAAC;IACrD,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAClD,IAAI,CAAC,IAAI,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1D,IAAI,OAAe,CAAC;IACpB,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACjG,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;IACD,+FAA+F;IAC/F,oDAAoD;IACpD,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAC1C,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,GAAG,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC,CAAC,qCAAqC;IAChE,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IACvC,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IACzC,IAAI,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAC5B,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,CAAS;IACpC,OAAO,gBAAgB,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AACtC,CAAC"}

package/dist/agent/channels/channel-read.d.ts

@@ -0,0 +1,203 @@
+import { type BindableContext } from "../identity/binding.js";
+import type { Domain } from "../memory/domain.js";
+import type { IngestionSource } from "../access/taint-tiers.js";
+import { ChannelScopeError } from "./read-scope-error.js";
+import { type ReadScopeAuditDeps } from "./read-scope-audit.js";
+import { type ReadSpool } from "./read-spool.js";
+export { ChannelScopeError };
+/** One read message rendered to a compact, model-friendly line — the least-common-denominator every adapter normalizes to. */
+export interface RenderedLine {
+    readonly author: string;
+    readonly ts: string;
+    readonly text: string;
+    /**
+     * The author's raw PLATFORM id — a Slack `U…`, a Discord snowflake, a Teams Entra object id. It is what the non-member probe keys on, and it is deliberately NOT `author`, which is a RENDERED DISPLAY STRING chosen for the model and cannot be parsed back into an identity.
+     * ABSENT for an author the adapter could not attribute. It never reaches the model: the read verbs project `{ author, ts, text }` into their output and this field stops at the adapter boundary.
+     */
+    readonly authorId?: string;
+    /** This line was written by a MACHINE (a bot / app / the agent itself). Excluded from the
+     *  non-member probe, mirroring access/taint-signal.ts's deliberate exclusion of the `relay` tier:
+     *  a bot is below a member but is not a person outside the org. */
+    readonly bot?: boolean;
+    /**
+     * The moment THIS line's fact was fetched. Set by an adapter that stamps dated reads; absent is the honest answer for a surface that has no read time, and it never invents one.
+     * Unlike `authorId` and `bot`, this REACHES the model: the render ages a HISTORY line against it and states it in the provenance line.
+     */
+    readonly readAt?: string;
+    /**
+     * This line IS the container's LIVE state, a ticket's current status, and not a message in its history. Set only by an adapter whose payload distinguishes a live field from history.
+     * Absent — the default, and every line on a chat surface — means this line is HISTORY.
+     */
+    readonly live?: boolean;
+}
+/** A channel read's structured result — it carries `platform` so the neutral render can pick the label and the untrusted-wrap source. */
+export interface ChannelReadResult {
+    readonly platform: string;
+    readonly channel: string;
+    readonly count: number;
+    readonly messages: readonly RenderedLine[];
+    /** A POSITIVELY-REFUTED non-member authored at least one message in this page, AND that body reached the model — it rides into the read verb's `IngestionSource` and marks the turn there. Set ONLY when true, and absent under `withhold`, where the body never reached the model; see {@link gradeAndProject}. */
+    readonly authoredByNonMember?: boolean;
+    /** The fetch returned exactly the page size it asked for, so older history may exist beyond this page. POSITIVE-ONLY, absent when the fetch came back short. It feeds the coverage-disclosure line {@link renderChannelBody} appends, so a partial read can never render identically to a complete one. */
+    readonly possiblyIncomplete?: boolean;
+    /** WHY, as data rather than prose folded into the note — read only when `possiblyIncomplete` is `true`. See {@link AdapterReadFetch.partialReason}. */
+    readonly partialReason?: string;
+    /** See {@link ChannelReadOutput.spool}. Present only on a page the inline cap trimmed. */
+    readonly spool?: ReadSpool;
+}
+/** A thread read's structured result — as {@link ChannelReadResult} plus the thread id. */
+export interface ThreadReadResult {
+    readonly platform: string;
+    readonly channel: string;
+    readonly thread_ts: string;
+    readonly count: number;
+    readonly messages: readonly RenderedLine[];
+    /** See {@link ChannelReadResult.authoredByNonMember}. */
+    readonly authoredByNonMember?: boolean;
+    /** See {@link ChannelReadResult.possiblyIncomplete}. */
+    readonly possiblyIncomplete?: boolean;
+    /** See {@link ChannelReadResult.partialReason}. */
+    readonly partialReason?: string;
+    /** See {@link ChannelReadOutput.spool}. */
+    readonly spool?: ReadSpool;
+}
+/** The address ONE turn's wake names, in the ids that surface's own read calls take (OPE-929).
+ *  `container` is what {@link ReadAdapter.readChannel} receives; `threadRoot` is
+ *  {@link ReadAdapter.readThread}'s second id, absent on a top-level turn. */
+export interface WakeReadAddress {
+    readonly container: string;
+    readonly threadRoot?: string;
+}
+/**
+ * An adapter's OWN answer to "does more exist beyond this page?", carried beside the lines it fetched. An adapter with nothing to add keeps returning the bare {@link RenderedLine} array, unchanged.
+ * Some vendor APIs hand the fact back for free, and the LINE COUNT alone cannot see it: a container-shaped read can fetch a page at the vendor's own ceiling and still return a SHORT list of renderable lines, which is exactly the shape core's line-count heuristic reads as "complete".
+ */
+export interface AdapterReadFetch {
+    readonly lines: readonly RenderedLine[];
+    /**
+     * `true` ⇒ the coverage note fires however few lines came back, because the adapter KNOWS more exists; `false` ⇒ the note is suppressed even on a page that landed exactly on the caller's limit, because the adapter KNOWS this page is everything.
+     * The field absent ⇒ no opinion, and core's line-count heuristic decides.
+     */
+    readonly possiblyIncomplete?: boolean;
+    /** WHY, as data rather than prose folded into the note — a vendor page limit, a permission-trimmed thread. Free text, surfaced verbatim in the rendered coverage note, and read only when `possiblyIncomplete` is `true`. */
+    readonly partialReason?: string;
+}
+/**
+ * A surface's read adapter: fetch, allowlist-gated, a channel's or a thread's recent messages into the neutral {@link RenderedLine} array.
+ * Injected `deps` — a fetch seam — default to the live transport, so the tool calls with no args while a test injects a canned transport.
+ */
+export interface ReadAdapter {
+    readonly platform: string;
+    /** May return the bare lines, no opinion on coverage, or {@link AdapterReadFetch}, the lines plus the adapter's own coverage fact. Additive: an adapter that predates this type still satisfies it unchanged. */
+    readChannel(ctx: BindableContext, channel: string, limit?: number): Promise<readonly RenderedLine[] | AdapterReadFetch>;
+    readThread(ctx: BindableContext, channel: string, threadTs: string, limit?: number): Promise<readonly RenderedLine[] | AdapterReadFetch>;
+    /**
+     * 🔴 WHICH CONTAINER, and which thread root, does THIS turn's wake name, in the exact ids {@link readChannel} and {@link readThread} take? REQUIRED, and a bundle that omits it does not compile: the address is resolved host-side from the turn's binding, no two surfaces spell it the same way, and a core-side guess would fetch the WRONG ROOM rather than fail. PURE and SYNCHRONOUS — it reads the binding, never the network.
+     * It returns `undefined` when this turn names no readable container, and the caller then refuses loudly rather than guessing an id. `threadRoot` absent ⇒ this turn is at the TOP LEVEL of its container, which `read_thread` refuses on rather than reading the channel under a thread read's name.
+     */
+    wakeAddress(ctx: BindableContext): WakeReadAddress | undefined;
+    /**
+     * 🔴 WHICH of this page's authors is POSITIVELY REFUTED as a non-member? IT RETURNS IDS, NOT A PAGE BOOLEAN, because the one answer has TWO consumers: the turn MARK and the author GRAIN. Every chat surface answers through the shared join in channels/read-author-trust.ts, and what the surface supplies is its own per-author evidence.
+     * OPTIONAL, and its absence is a real answer rather than a gap — a surface with no author-grain evidence contributes nothing. It must never throw: {@link adapterRefutedAuthorIds} catches, and its answer is the empty set.
+     */
+    refutedAuthorIds?(ctx: BindableContext, lines: readonly RenderedLine[]): Promise<readonly string[]>;
+}
+/** PURE allowlist resolver — own surface + the domain's `platform` channels. Injected `surfaceKey` +
+ *  `domains` (no fs/config) so it is unit-testable. */
+export declare function allowedSurfaceIdsFrom(surfaceKey: string, platform: string, domains: readonly Domain[]): {
+    ids: Set<string>;
+    domain?: string;
+};
+/** Assert a requested surface id is readable by this session on `platform` — else AUDIT the refusal and throw, fail closed, with the same {@link ChannelScopeError} the slack reader raises. */
+export declare function assertSurfaceAllowed(ctx: BindableContext, platform: string, surfaceId: string, deps?: ReadScopeAuditDeps): Promise<void>;
+/**
+ * Register, or replace, one surface's read adapter. Exported so a provider bundle, or a test's fake platform, registers the same way every shipped surface does.
+ * It keeps the exported SUPPORTED_READ_PLATFORMS view LIVE: a boot-registered bundle platform must appear in the "supported" error copy, and `Object.keys` at module load would freeze it out.
+ */
+export declare function registerReadAdapter(adapter: ReadAdapter): void;
+/** Back-compat read-only view of the registry — the SAME object the registry above mutates,
+ *  under its original exported name/type. */
+export declare const READ_ADAPTERS: Readonly<Record<string, ReadAdapter>>;
+/** The surfaces the generic read verbs support (for the "not supported" message) — a LIVE view
+ *  over the registry (mutated by registerReadAdapter), so bundle-registered platforms appear. */
+export declare const SUPPORTED_READ_PLATFORMS: readonly string[];
+/** The LIVE supported-surface list (reflects bundle-registered adapters registered after load). */
+export declare function supportedReadPlatforms(): readonly string[];
+/**
+ * Thrown by {@link resolveReadAdapter}'s TOPOLOGY gate, so an async call site can tell this refusal from any other thrown Error and audit it before rethrowing.
+ * Deliberately NO `.name` override: `String(err)` stays "Error: …", which is what the message-regex assertions on this gate match.
+ */
+export declare class WindowSourcesRefusalError extends Error {
+    readonly platform: string;
+    constructor(message: string, platform: string);
+}
+/** Resolve the platform and adapter for a read, running the execute-time source, fence and support gates. `targetPlatform` defaults to the turn's ORIGIN surface. It throws, fail-closed, on any gate. */
+export declare function resolveReadAdapter(ctx: BindableContext, targetPlatform: string | undefined, domains: readonly Domain[]): {
+    platform: string;
+    adapter: ReadAdapter;
+};
+/**
+ * ONE read line as it LEAVES a read verb — the model-facing projection of {@link RenderedLine}, with the grading fields `authorId` and `bot` dropped.
+ * Deliberately MUTABLE: the tools' zod `outputSchema` infers a mutable array, and a `readonly` result would not satisfy it.
+ */
+export interface ReadOutputLine {
+    author: string;
+    ts: string;
+    text: string;
+    /** See {@link RenderedLine.readAt}. Carried through, unlike `authorId` and `bot`, because the render states it in the provenance line. */
+    readAt?: string;
+    /** See {@link RenderedLine.live}. */
+    live?: boolean;
+}
+/** A channel read's execute output — {@link ChannelReadResult} in the exact shape read_channel's
+ *  `outputSchema` infers. Assignable to ChannelReadResult, so the render functions take it as-is. */
+export interface ChannelReadOutput {
+    platform: string;
+    channel: string;
+    count: number;
+    messages: ReadOutputLine[];
+    authoredByNonMember?: boolean;
+    /** See {@link ChannelReadResult.possiblyIncomplete}. */
+    possiblyIncomplete?: boolean;
+    /** See {@link ChannelReadResult.partialReason}. */
+    partialReason?: string;
+    /**
+     * Set only when the page busted the inline cap and was trimmed. `count` stays the FETCHED length while `messages` holds only what fits, so the two disagreeing IS the signal.
+     * {@link spoolNote} is what explains the disagreement to the model.
+     */
+    spool?: ReadSpool;
+}
+/** A thread read's execute output — as {@link ChannelReadOutput} plus the thread id. */
+export interface ThreadReadOutput extends ChannelReadOutput {
+    thread_ts: string;
+}
+/** Fetch + grade a channel read. `platform` is the resolved platform from {@link resolveReadAdapter}. */
+export declare function readChannelResult(ctx: BindableContext, platform: string, adapter: ReadAdapter, channel: string, limit?: number): Promise<ChannelReadOutput>;
+/** Fetch + grade a thread read — {@link readChannelResult} with the thread id carried through. */
+export declare function readThreadResult(ctx: BindableContext, platform: string, adapter: ReadAdapter, channel: string, threadTs: string, limit?: number): Promise<ThreadReadOutput>;
+/**
+ * The `IngestionSource` a chat read declares — the ONE place the table's metadata branch is fed, so `read_channel` and `read_thread` cannot declare it differently.
+ * POSITIVE-ONLY: an ungraded or member-only read declares exactly what it always declared.
+ */
+export declare function chatReadIngestion(label: string, out: {
+    readonly authoredByNonMember?: boolean;
+}): IngestionSource;
+/**
+ * Re-address a read result to the model in the OPAQUE CHANNEL KEY it was asked for. The result still carries the platform's own container id, because that is what the adapter fetched with, and the two render helpers below interpolate that id into the body and the provenance label.
+ * Without this the model would hold a raw id that no read verb accepts — one place with two names, which is the whole defect the key removes. EVERY read verb calls this, so one place has exactly one name on every path.
+ */
+export declare function keyedReadResult<T extends {
+    readonly platform: string;
+    readonly channel: string;
+}>(out: T): T;
+/** The channel-read body — one rendering for every platform when the page came back under the
+ *  fetch's page size; a coverage note is appended when it did not. */
+export declare function renderChannelBody(out: ChannelReadResult): string;
+/** The channel-read untrusted-wrap source label — the platform, the word "channel", then the container. */
+export declare function channelReadSource(out: ChannelReadResult): string;
+/** The thread-read body — one rendering for every platform when the page came back under the
+ *  fetch's page size; a coverage note is appended when it did not. */
+export declare function renderThreadBody(out: ThreadReadResult): string;
+/** The thread-read untrusted-wrap source label — the platform, the word "thread", then the container and the thread id. */
+export declare function threadReadSource(out: ThreadReadResult): string;
+//# sourceMappingURL=channel-read.d.ts.map

package/dist/agent/channels/channel-read.d.ts.map

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

package/dist/agent/channels/channel-read.js

@@ -0,0 +1,294 @@
+// channel-read — the platform-NEUTRAL channel/thread READ core behind the generic read verbs: a neutral execute-chain gate plus a neutral render, with one per-surface FETCH ADAPTER that turns a vendor API into normalized lines. Only the FETCH is per-surface, and the renderer is parameterised by `platform` alone, so a new surface gets the same output shape for free.
+// FAIL-CLOSED ON BOTH AXES: the per-surface allowlist is the ADAPTER's job — the domain's channel list IS the allowlist — and a surface with no registered adapter fails LOUD with a "not supported" error rather than faking a read.
+import { turnOriginPlatform, assertTurnSurface, resolveWindowSources, } from "../identity/binding.js";
+import { domainForChannel, domainRoster, externalPolicyOverrideFor } from "../memory/domain.js";
+import { resolvePartition } from "../memory/partition.js";
+import { getConfig } from "../access/config.js";
+// The author grain, for the READ side of `withhold`. A VALUE import is safe in THIS direction: access/external-policy.ts is a leaf over settings/identity/taint-signal and imports nothing under channels/ except types.
+// The ban that module's own header states runs the OTHER way — it must not value-import memory/domain or access/config.
+import { resolveExternalPolicy, shippedExternalPolicy, WITHHELD_BODY_MARKER } from "../access/external-policy.js";
+// The domain-scope error, in its own module: teams-read.ts and this file import each other, so the shared class needs a cycle-free home. It is re-exported here for the existing import sites.
+import { ChannelScopeError } from "./read-scope-error.js";
+// The opaque channel key a read result is ADDRESSED BY on the way out — the read verbs take no address in. A pure leaf, so it closes no init-order cycle.
+import { encodeChannelKey } from "./channel-key.js";
+import { auditChannelReadRefusal } from "./read-scope-audit.js";
+// OPE-829 — the oversize-read spool. The dependency runs ONE way as a value: this file imports the
+// note renderer, and read-spool.ts imports only TYPES back, so no module-init cycle exists.
+import { spoolNote } from "./read-spool.js";
+import { admitProviderRegistration } from "../access/provider-selection.js";
+// The shared age arithmetic — a pure leaf with no imports of its own, so importing it here closes no cycle.
+import { ageAtRead } from "../access/dated-read.js";
+import { redactMachineLinkCodes } from "../identity/link-challenge.js";
+export { ChannelScopeError };
+const EMPTY_REFUTED = new Set();
+/** Ask an adapter's optional non-member probe, fail-OPEN on absence and on any throw. Module-private
+ *  and the ONE call site for the optional member, so "no probe" and "a broken probe" cannot diverge. */
+async function adapterRefutedAuthorIds(adapter, ctx, lines) {
+    if (adapter.refutedAuthorIds === undefined)
+        return EMPTY_REFUTED;
+    try {
+        return new Set(await adapter.refutedAuthorIds(ctx, lines));
+    }
+    catch {
+        return EMPTY_REFUTED; // a grading failure must never fail the read it grades
+    }
+}
+// The platform-parameterised domain allowlist: the session's own surface, always readable because it is where the agent is engaged, plus every domain channel whose fully-qualified key (`platform/workspace/surface`) is on `platform`.
+// Slack keeps its own bespoke assert for a byte-identical error; this one serves every other surface.
+/** The surface id (`platform/workspace/surface` → `surface`) for `platform`, or null for another
+ *  platform's key. */
+function surfaceIdFromKey(key, platform) {
+    const parts = key.split("/");
+    if (parts.length !== 3 || parts[0] !== platform)
+        return null;
+    return parts[2] || null;
+}
+/** PURE allowlist resolver — own surface + the domain's `platform` channels. Injected `surfaceKey` +
+ *  `domains` (no fs/config) so it is unit-testable. */
+export function allowedSurfaceIdsFrom(surfaceKey, platform, domains) {
+    const ids = new Set();
+    const own = surfaceIdFromKey(surfaceKey, platform);
+    if (own)
+        ids.add(own);
+    const domain = domainForChannel(surfaceKey, domains);
+    if (domain) {
+        for (const key of domainRoster(domain)) {
+            const id = surfaceIdFromKey(key, platform);
+            if (id)
+                ids.add(id);
+        }
+    }
+    return { ids, domain: domain?.name };
+}
+/** Assert a requested surface id is readable by this session on `platform` — else AUDIT the refusal and throw, fail closed, with the same {@link ChannelScopeError} the slack reader raises. */
+export async function assertSurfaceAllowed(ctx, platform, surfaceId, deps) {
+    const p = resolvePartition(ctx);
+    const domains = getConfig().loadDomains();
+    const { ids, domain } = allowedSurfaceIdsFrom(p.surfaceKey, platform, domains);
+    if (ids.has(surfaceId))
+        return;
+    await auditChannelReadRefusal(ctx, { platform, surfaceId, callerKey: p.surfaceKey, callerDomain: domain, domains }, deps);
+    const scope = domain ? `domain "${domain}"` : "this channel's (no multi-channel domain)";
+    throw new ChannelScopeError(`channel "${surfaceId}" is not in ${scope} ${platform} read scope. The agent may only read channels in its ` +
+        `memory domain (memory/config/domains.ts). Add the channel to the domain's \`channels\` to grant it.`);
+}
+// The adapter registry. Every read adapter registers from its own provider bundle and core wires none inline, so a read on an unregistered surface fails LOUD through {@link resolveReadAdapter} and never fakes a result.
+// A module-private registry plus an exported register function, mirroring entity-actions.ts, so a future surface registers itself instead of this file growing another object-literal key. READ_ADAPTERS and SUPPORTED_READ_PLATFORMS keep their original names and shapes — a LIVE view over the same registry — because the read verbs and the adapter tests import them directly.
+const READ_ADAPTER_REGISTRY = {};
+const SUPPORTED_PLATFORMS_LIVE = [];
+/**
+ * Register, or replace, one surface's read adapter. Exported so a provider bundle, or a test's fake platform, registers the same way every shipped surface does.
+ * It keeps the exported SUPPORTED_READ_PLATFORMS view LIVE: a boot-registered bundle platform must appear in the "supported" error copy, and `Object.keys` at module load would freeze it out.
+ */
+export function registerReadAdapter(adapter) {
+    if (!admitProviderRegistration(adapter.platform, "read-adapter"))
+        return;
+    if (!(adapter.platform in READ_ADAPTER_REGISTRY))
+        SUPPORTED_PLATFORMS_LIVE.push(adapter.platform);
+    READ_ADAPTER_REGISTRY[adapter.platform] = adapter;
+}
+/** Back-compat read-only view of the registry — the SAME object the registry above mutates,
+ *  under its original exported name/type. */
+export const READ_ADAPTERS = READ_ADAPTER_REGISTRY;
+/** The surfaces the generic read verbs support (for the "not supported" message) — a LIVE view
+ *  over the registry (mutated by registerReadAdapter), so bundle-registered platforms appear. */
+export const SUPPORTED_READ_PLATFORMS = SUPPORTED_PLATFORMS_LIVE;
+/** The LIVE supported-surface list (reflects bundle-registered adapters registered after load). */
+export function supportedReadPlatforms() {
+    return Object.keys(READ_ADAPTER_REGISTRY);
+}
+// The neutral EXECUTE-CHAIN gate — the three predicates a generic read verb enforces per call: the platform is one of this WINDOW'S SOURCES (topology), the per-turn ORIGIN FENCE (a turn reads its own surface, because cross-surface is recall and not a live read), and the surface is SUPPORTED.
+// The domain allowlist fires INSIDE the adapter, after this. Pure but for the injected `domains`.
+/**
+ * Thrown by {@link resolveReadAdapter}'s TOPOLOGY gate, so an async call site can tell this refusal from any other thrown Error and audit it before rethrowing.
+ * Deliberately NO `.name` override: `String(err)` stays "Error: …", which is what the message-regex assertions on this gate match.
+ */
+export class WindowSourcesRefusalError extends Error {
+    platform;
+    constructor(message, platform) {
+        super(message);
+        this.platform = platform;
+    }
+}
+/** Resolve the platform and adapter for a read, running the execute-time source, fence and support gates. `targetPlatform` defaults to the turn's ORIGIN surface. It throws, fail-closed, on any gate. */
+export function resolveReadAdapter(ctx, targetPlatform, domains) {
+    // `turnOriginPlatform`, NOT `channelPlatform`: this function runs only inside a read verb's `execute`, and a tool-execute context carries no `channel` object.
+    // With `channelPlatform` the default answered `undefined` on every call, and the tool refused with "pass `target.platform`" even when the turn plainly had one.
+    const platform = targetPlatform ?? turnOriginPlatform(ctx);
+    if (!platform) {
+        throw new Error("read: couldn't resolve which surface to read — pass `target.platform` (e.g. \"slack\").");
+    }
+    // (1) TOPOLOGY: the platform must be one of this window's sources (fail-closed to the single origin).
+    const sources = resolveWindowSources(ctx, domains);
+    if (!sources.includes(platform)) {
+        throw new WindowSourcesRefusalError(`read: "${platform}" is not one of this window's sources (${sources.join(", ") || "none"}) — ` +
+            "you can only read a surface whose messages fan into this window.", platform);
+    }
+    // (2) PER-TURN ORIGIN FENCE: on a multi-source window this turn may only read its OWN origin surface
+    //     (no-op on a solo window, where mount + origin coincide).
+    assertTurnSurface(ctx, platform);
+    // (3) SUPPORT: a surface with no wired read adapter fails loud and never fakes a read.
+    // Every shipped chat surface registers one, so this arm now covers a DE-SELECTED bundle — the provider-selection gate refused its registration — rather than an unbuilt surface.
+    const adapter = READ_ADAPTERS[platform];
+    if (!adapter) {
+        throw new Error(`read: reading a ${platform} channel is not supported yet (supported: ${supportedReadPlatforms().join(", ")}).`);
+    }
+    return { platform, adapter };
+}
+/**
+ * The AUTHOR GRAIN for this read, resolved ORG DEFAULT ← DOMAIN OVERRIDE. The override key is the SESSION's own surface, not the channel being read, and the two never disagree: the allowlist admits the session's own surface plus the channels of its domain, so a readable target is always inside that same domain.
+ * 🔴 THE FALLBACK IS THE ORG DEFAULT, NOT `taint`. A domain registry this call cannot read loses the OVERRIDE and nothing else. Falling back to a hard `taint` would let an unreadable config turn an org-wide `withhold` off, arriving through the error path.
+ */
+function readAuthorPolicy(ctx) {
+    try {
+        return resolveExternalPolicy(externalPolicyOverrideFor(resolvePartition(ctx).surfaceKey, getConfig().loadDomains()));
+    }
+    catch {
+        return shippedExternalPolicy();
+    }
+}
+/**
+ * 🔴 {@link gradeAndProject} BELOW IS THE READ-SIDE HALF OF `withhold`. The author grain binds the read path and not the wake path alone, because the policy is a statement about a PERSON — "this sender's bytes do not enter" — so a read is the same question through a different door. The consequence is the wake path's, exactly: the line's `text` becomes {@link WITHHELD_BODY_MARKER} and the author and the timestamp stay. It does NOT drop the line, or the model answers a conversation it cannot see, so `count` stays the fetched length.
+ * 🔴 AND A WITHHELD BODY DOES NOT MARK THE TURN. The excluded author's bytes never reached the model, so declaring `authoredByNonMember` would claim an exposure that did not happen. Under the shipped `taint` grain nothing is withheld and the mark is unchanged.
+ */
+/** Split an adapter's return into its lines and its own, possibly absent, coverage answer. A bare array normalizes to "no opinion". Module-private: the two result builders are the only callers. */
+function normalizeAdapterFetch(result) {
+    if (Array.isArray(result))
+        return { lines: result };
+    const fetch = result;
+    return {
+        lines: fetch.lines,
+        ...(fetch.possiblyIncomplete !== undefined ? { possiblyIncomplete: fetch.possiblyIncomplete } : {}),
+        ...(fetch.partialReason !== undefined ? { partialReason: fetch.partialReason } : {}),
+    };
+}
+async function gradeAndProject(ctx, adapter, lines, effectiveLimit, declared) {
+    const refuted = await adapterRefutedAuthorIds(adapter, ctx, lines);
+    // THE ORDER IS A COST DECISION: a page with no refuted author asks the policy nothing, so a read on
+    // the overwhelmingly common path resolves no settings and loads no domain registry of its own.
+    const withholding = refuted.size > 0 && readAuthorPolicy(ctx).authorGrain === "withhold";
+    // 🔴 `bot !== true` IS NOT REDUNDANT with the probe's own machine skip. The probe never PUTS a machine author in the set, but a bot line can carry the same platform id as a refuted human on some surfaces.
+    // "A machine author is never excluded" is the rule the whole author grain states, so it is restated at the point of consequence.
+    const withheld = (m) => withholding && m.bot !== true && m.authorId !== undefined && refuted.has(m.authorId);
+    // THE ADAPTER'S OWN ANSWER WINS WHEN IT HAS ONE, true or false, even where the line count alone would have guessed the other way — a short page the adapter knows is partial, a page on the limit the adapter knows is everything.
+    // `undefined` is the answer for every adapter that returns a bare array, and the line-count heuristic below then decides.
+    const possiblyIncomplete = declared?.possiblyIncomplete !== undefined ? declared.possiblyIncomplete : lines.length >= effectiveLimit;
+    return {
+        count: lines.length,
+        messages: lines.map((m) => ({
+            author: m.author,
+            ts: m.ts,
+            // `bot` covers the agent's own platform posts as well as foreign bots. A human-authored claim
+            // remains byte-identical; a machine copy of either live link code is not allowed into the
+            // structured tool result, its inline render, or the oversize spool file.
+            text: withheld(m) ? WITHHELD_BODY_MARKER : m.bot === true ? redactMachineLinkCodes(m.text) : m.text,
+            // Carried through, unlike `authorId` and `bot`: these two are meant to reach the model, through the render below. POSITIVE-ONLY, so a surface that sets neither projects unchanged.
+            ...(m.readAt !== undefined ? { readAt: m.readAt } : {}),
+            ...(m.live !== undefined ? { live: m.live } : {}),
+        })),
+        ...(refuted.size > 0 && !withholding ? { authoredByNonMember: true } : {}),
+        // `>=` rather than `===` in the heuristic branch, so a surface that ever returns one extra line still reads as "at the ceiling".
+        ...(possiblyIncomplete ? { possiblyIncomplete: true } : {}),
+        // The reason is only meaningful alongside a partial result — an adapter that declares `false`
+        // but still passed a reason (a caller error) never surfaces it.
+        ...(possiblyIncomplete && declared?.partialReason !== undefined ? { partialReason: declared.partialReason } : {}),
+    };
+}
+// The coverage-signal ESTIMATE for a caller that left `limit` unset. It is deliberately NOT threaded into the adapter call below — the fetch still receives the caller's raw `limit`, `undefined` included, so every adapter's own internal default keeps firing and nothing here shadows it.
+// It feeds the `possiblyIncomplete` comparison alone, so a surface whose own default drifts from this costs a stale coverage hint, never a wrong fetch.
+const DEFAULT_CHANNEL_LIMIT_ESTIMATE = 50;
+const DEFAULT_THREAD_LIMIT_ESTIMATE = 100;
+/** Fetch + grade a channel read. `platform` is the resolved platform from {@link resolveReadAdapter}. */
+export async function readChannelResult(ctx, platform, adapter, channel, limit) {
+    const fetched = normalizeAdapterFetch(await adapter.readChannel(ctx, channel, limit));
+    return {
+        platform,
+        channel,
+        ...(await gradeAndProject(ctx, adapter, fetched.lines, limit ?? DEFAULT_CHANNEL_LIMIT_ESTIMATE, fetched)),
+    };
+}
+/** Fetch + grade a thread read — {@link readChannelResult} with the thread id carried through. */
+export async function readThreadResult(ctx, platform, adapter, channel, threadTs, limit) {
+    const fetched = normalizeAdapterFetch(await adapter.readThread(ctx, channel, threadTs, limit));
+    return {
+        platform,
+        channel,
+        thread_ts: threadTs,
+        ...(await gradeAndProject(ctx, adapter, fetched.lines, limit ?? DEFAULT_THREAD_LIMIT_ESTIMATE, fetched)),
+    };
+}
+/**
+ * The `IngestionSource` a chat read declares — the ONE place the table's metadata branch is fed, so `read_channel` and `read_thread` cannot declare it differently.
+ * POSITIVE-ONLY: an ungraded or member-only read declares exactly what it always declared.
+ */
+export function chatReadIngestion(label, out) {
+    return { kind: "chat-message", label, ...(out.authoredByNonMember === true ? { authoredByNonMember: true } : {}) };
+}
+// The coverage-disclosure line, appended when `possiblyIncomplete` is set: the worker instruction alone tells a worker to STATE its coverage, but only the result can tell it the TRUTH to state.
+// Appended AFTER the render and never in place of it, so an under-cap page's body is untouched — and it lives OUTSIDE the untrusted message list, so it can never be read as a channel message. The adapter's own reason is its own clause, so the note still reads as one sentence without it.
+function coverageNote(kind, count, reason) {
+    return `\n\n[coverage: showing the ${count} most recent ${kind === "channel" ? "messages" : "replies"} this fetch could return — older ${kind === "channel" ? "history" : "replies"} may exist beyond this page${reason ? ` (${reason})` : ""}]`;
+}
+// The dated-read contract in the shared render path, so every registered surface can carry it. Both helpers below are additive by construction: a line with no `readAt` and no `live` flag renders exactly as it did before either field existed.
+/**
+ * The inline age suffix for one HISTORY line — the same words the Linear and Notion read tools already render for their own comments.
+ * Absent for the LIVE line, which IS the current state and is not aged, and for any line with no `readAt` — see {@link ageAtRead}'s own "never guesses" rule.
+ */
+function ageSuffix(m) {
+    if (m.live)
+        return "";
+    const age = ageAtRead(m.ts, m.readAt);
+    return age ? ` (${age} before this read)` : "";
+}
+/**
+ * The provenance line — the sentence that fixed a MEASURED soak failure: the model reporting a stale comment's claim as the issue's present state.
+ * It fires only when the page carries a LIVE line, so a surface where every line is history renders nothing here. Additive, never a behaviour change.
+ */
+function provenanceLine(messages) {
+    const live = messages.find((m) => m.live === true && m.readAt !== undefined);
+    if (!live)
+        return "";
+    return (`\n\nRead live at ${live.readAt}: the first line above is the current state. Everything else is ` +
+        "HISTORY — a message's claim about status, approval or progress is not the present state.");
+}
+/**
+ * Re-address a read result to the model in the OPAQUE CHANNEL KEY it was asked for. The result still carries the platform's own container id, because that is what the adapter fetched with, and the two render helpers below interpolate that id into the body and the provenance label.
+ * Without this the model would hold a raw id that no read verb accepts — one place with two names, which is the whole defect the key removes. EVERY read verb calls this, so one place has exactly one name on every path.
+ */
+export function keyedReadResult(out) {
+    return { ...out, channel: encodeChannelKey(out.platform, out.channel) };
+}
+/** The channel-read body — one rendering for every platform when the page came back under the
+ *  fetch's page size; a coverage note is appended when it did not. */
+export function renderChannelBody(out) {
+    if (out.count === 0)
+        return `No readable messages in ${out.channel}.`;
+    const body = `Recent messages in ${out.channel} (oldest first):\n` + out.messages.map((m) => `[${m.author}] ${m.text}${ageSuffix(m)}`).join("\n");
+    // The coverage note is about what the FETCH could not reach; the spool note is about what this RESULT could not carry.
+    // Both can be true of one page and they say different things, so neither replaces the other.
+    const covered = out.possiblyIncomplete ? body + coverageNote("channel", out.count, out.partialReason) : body;
+    // The provenance line goes LAST: it is a statement about the whole page and not a per-message fact, so it sits after every message and after the coverage note.
+    const dated = covered + provenanceLine(out.messages);
+    return out.spool ? dated + spoolNote("channel", out.spool) : dated;
+}
+/** The channel-read untrusted-wrap source label — the platform, the word "channel", then the container. */
+export function channelReadSource(out) {
+    return `${out.platform} channel ${out.channel}`;
+}
+/** The thread-read body — one rendering for every platform when the page came back under the
+ *  fetch's page size; a coverage note is appended when it did not. */
+export function renderThreadBody(out) {
+    if (out.count === 0)
+        return `No readable replies in thread ${out.thread_ts}.`;
+    const body = `Thread ${out.thread_ts} in ${out.channel} (oldest first):\n` + out.messages.map((m) => `[${m.author}] ${m.text}${ageSuffix(m)}`).join("\n");
+    // See {@link renderChannelBody}'s note; the two disclosures are independent.
+    const covered = out.possiblyIncomplete ? body + coverageNote("thread", out.count, out.partialReason) : body;
+    // See {@link renderChannelBody}'s note.
+    const dated = covered + provenanceLine(out.messages);
+    return out.spool ? dated + spoolNote("thread", out.spool) : dated;
+}
+/** The thread-read untrusted-wrap source label — the platform, the word "thread", then the container and the thread id. */
+export function threadReadSource(out) {
+    return `${out.platform} thread ${out.channel}/${out.thread_ts}`;
+}
+//# sourceMappingURL=channel-read.js.map

package/dist/agent/channels/channel-read.js.map

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

package/dist/agent/channels/chat-turn-audit.d.ts

@@ -0,0 +1,9 @@
+import type { Partition } from "../memory/partition.js";
+/** The partition slice an audit row needs — satisfied by resolvePartition's output. */
+export type ChatAuditPartition = Pick<Partition, "org" | "platform" | "workspace" | "surface">;
+/**
+ * Record a chat-surface turn whose final text was the bare NO_REPLY sentinel — the sentinel-route twin of the `reply.no_reply_observed` row tools/no_reply.ts writes. Best-effort: appendAudit never throws.
+ * `sessionId` joins the row back to the transcript; `wakeId` is unified-window-only and is what tells two sentinel rows on one session apart.
+ */
+export declare function auditNoReplySentinelObserved(partition: ChatAuditPartition, sessionId?: string, wakeId?: string): Promise<void>;
+//# sourceMappingURL=chat-turn-audit.d.ts.map

package/dist/agent/channels/chat-turn-audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-turn-audit.d.ts","sourceRoot":"","sources":["../../../agent/channels/chat-turn-audit.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGxD,uFAAuF;AACvF,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,SAAS,EAAE,KAAK,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,CAAC,CAAC;AAE/F;;;GAGG;AACH,wBAAsB,4BAA4B,CAAC,SAAS,EAAE,kBAAkB,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CASpI"}