@open-everywhere/core 0.1.0

package/dist/agent/identity/binding.d.ts

@@ -0,0 +1,567 @@
+import type { SessionMode } from "../access/resolver.js";
+import { type BridgedIdentity } from "./binding-bridge.js";
+import { type SurfaceTrust } from "./trust.js";
+import type { Domain } from "../memory/domain.js";
+/** Whether a surface's learnings may flow up to shared (workspace/domain) memory. */
+export type Visibility = "public" | "private";
+/**
+ * Whether a surface is INSIDE the trust boundary (members are all in-org) or reaches
+ * OUTSIDE it (externally shared / Slack Connect / guest members). This is a SEPARATE
+ * dimension from visibility: a private channel is still internal; an externally-shared
+ * channel is external even if "public" within the workspace.
+ *
+ * It selects the shared-memory layer (memory/resolve.ts): an `external` channel routes to
+ * the read-only `public` pseudo-domain instead of an internal domain, because surfacing
+ * internal memory to an outsider is a serious leak. For a DM, `trust` means "is the DM
+ * PARTNER internal?" — it picks the DM's shared read layer (internal → `dm`, external →
+ * `public`); the per-user DB silo is granted regardless. The gate is fail-closed: when
+ * trust can't be positively determined on a real platform (including any DM partner, which
+ * we can't yet verify), treat as `external`. See docs/capabilities/memory.md "external/guest gate".
+ */
+export type Trust = "internal" | "external";
+export interface SurfaceBinding {
+    /**
+     * The TENANT — the outermost partition key (Claude Tag's "org"). One deployment
+     * serves one org today (declared in agent/identity/surfaces.ts, default "default"); a hosted, multi-tenant
+     * deployment resolves it per-request (Slack workspace → org lookup, an auth claim, …),
+     * which is a dedicated resolver, not this env read — so org is resolved here in
+     * bindFrom, not in a per-platform mapper (those translate per-message identity).
+     * Every durable store partitions by this: SQLite/Postgres as the `org_id` column
+     * (+ RLS), git as the top-level directory.
+     */
+    readonly org: string;
+    readonly platform: string;
+    readonly workspace: string;
+    readonly surface: string;
+    /**
+     * The surface segment to use for DOMAIN + SPEND grain when it differs from `surface`
+     * — today only a Discord THREAD, whose `surface` is the thread's own channel id while
+     * domains and spend caps are declared against the PARENT channel (backlog item 22:
+     * Slack threads share the channel's surface key, so on Slack the two grains coincide
+     * and this is absent). Consumers that resolve a channel→domain hop (memory, RBAC,
+     * access bundles, model routes) or account/gate spend use `domainSurface ?? surface`;
+     * everything CONVERSATIONAL (sessions, engagement, reply targets, the partition
+     * surfaceKey that names memory working-copy dirs) deliberately stays on `surface` —
+     * a thread keeps its own conversational identity, it just belongs to its parent's
+     * domain and budget. Sanitized like `surface` (it becomes a storage/scope key segment).
+     */
+    readonly domainSurface?: string;
+    readonly mode: SessionMode;
+    /**
+     * TRUE when {@link mode} was RESOLVED — a platform mapper answered with one, or the operator
+     * declared it on `OE_MODE`. ABSENT means the mode is a GAP-FILL: nothing answered, and `channel`
+     * is the default that keeps every reader working (OPE-1867).
+     *
+     * 🔴 IT IS ONLY AS TRUTHFUL AS THE MAPPER, AND TODAY ONLY TEAMS ANSWERS HONESTLY. The flag says
+     * a mapper RETURNED a mode, not that the mapper was sure of it. `teamsResolvedMode` returns
+     * undefined for a conversation scope it cannot read, so Teams reports its own ignorance;
+     * `slackMode` still ends `return "channel"` for an activity with neither a `channel_type` nor a
+     * `D`-prefixed id, so Slack reports a default as a resolution. The residual exposure there is
+     * small — a Slack DM id starts with `D`, which that mapper's earlier arm catches — but do not
+     * read this flag as "every mapper reports provenance". Giving a mapper the Teams treatment is one
+     * function per bundle, and the next one to be written should follow `teamsResolvedMode`, never
+     * `slackMode`'s tail.
+     *
+     * 🔴 `mode` IS ALWAYS A USABLE VALUE, AND THIS IS THE ONLY WAY TO TELL THE TWO APART. Most
+     * readers want the gap-filled value and should keep reading `mode` alone — a room is the right
+     * assumption for visibility, trust and routing, all of which fail closed on their own terms.
+     * The reader that must NOT accept a default is the one that PUBLISHES the surface: a turn the
+     * mapper could not classify may be a one-to-one conversation, and naming it in a report posted
+     * into a room is the disclosure this flag exists to prevent. `hooks/spend.ts` `turnSurfaceMode`
+     * is that reader — it returns undefined here, and the row masks as `(unclassified)`.
+     *
+     * Absent therefore FAILS CLOSED for disclosure, which is why it is a positive flag rather than a
+     * `modeGapFilled` negative: a construction site that forgets it masks, it does not publish.
+     */
+    readonly modeResolved?: true;
+    readonly visibility: Visibility;
+    /**
+     * Trust boundary of the surface (internal vs external/guest). Gates ALL shared
+     * memory in the memory resolver (memory/resolve.ts) — fail-closed to `external`.
+     */
+    readonly trust: Trust;
+    /** The operator's own declaration for this room, in the declaration's vocabulary (internal or public), or undefined when they declared nothing. It is NOT trust: trust is a join in which the mapper's verdict outranks the declaration, so a gate that must ask whether the operator vouched that everyone here is a member reads this field instead. */
+    readonly declaredTrust?: SurfaceTrust;
+    readonly principalId?: string;
+    /** TRUE when principalId is attribution rather than an actor: the attested creator of a routine fire, or an unattended origin with nobody to name. Every read that turns an identity into a PERMISSION goes through actingPrincipalId, which answers undefined here; reads that only say WHO keep using principalId. */
+    readonly principalAttested?: true;
+    /** Channel-adapter target for proactive post-back (e.g. `{ channelId }`). */
+    readonly target?: Readonly<Record<string, unknown>>;
+    /**
+     * The thread this turn is anchored on, when the platform has one (Slack: the auth
+     * attributes' `thread_ts`, which Eve's adapter falls back to the triggering message's
+     * own ts — so a channel mention always carries it). Lets a tool post its side-effects
+     * (approval cards etc.) into the SAME thread as the agent's reply instead of as a
+     * fresh top-level channel message. NOT part of `target` deliberately: routine
+     * post-backs target the channel (a fresh message), never an old thread.
+     */
+    readonly threadTs?: string;
+    /** The engagement-registry key of this conversation. A mapper sets it only where the platform's key is not the Slack-shaped threadTs, never by reusing threadTs (about twenty consumers read that field as a Slack thread_ts API parameter), and it is not sanitized, because it must match the key the platform's ingress wrote byte for byte. */
+    readonly engagementKey?: string;
+    /** The room-grain engagement key, for a platform whose wake gate also watches the whole room. It is the stop anchor of last resort, reached only when the engagementKey mark found no row, so a mapper publishes it only where the platform stores a room-grain wake row; it is not sanitized, like engagementKey. */
+    readonly roomEngagementKey?: string;
+    /**
+     * The id of the message this turn is anchored on, for a platform whose reply anchor is NOT a
+     * Slack-shaped `threadTs` (OPE-671). `hooks/turn-anchor.ts` reads `threadTs` first and falls back
+     * to this field, so the ✋ stop-hand reaction (and the anchor row a reaction event resolves by)
+     * gets a real per-message id on Discord instead of always being empty.
+     *
+     * 🔴 A SEPARATE FIELD, for the SAME reason `engagementKey` is (OPE-661): reusing `threadTs` for a
+     * Discord message id would corrupt the ~twenty consumers that read it as a Slack thread_ts API
+     * parameter. A mapper sets this only where `threadTs` is absent and a real triggering-message id
+     * is known — Discord's gateway relay path; absent on a slash-command interaction (no message) and
+     * on Slack (its anchor is already `threadTs`).
+     */
+    readonly anchorMessageId?: string;
+    /** The container id the stop registry keys this turn's conversation by, when the platform's container is not the post-back target's channelId (Linear an issue, GitHub an issue or PR thread, Teams a reply chain). It is a separate field because about fifteen consumers read target.channelId as a chat channel to post into, and it is PREFERRED over target.channelId when a mapper sets both. */
+    readonly anchorChannelId?: string;
+}
+interface AuthPrincipal {
+    readonly attributes?: Readonly<Record<string, string | readonly string[]>>;
+    readonly principalId?: string;
+    readonly principalType?: string;
+    /** eve's own name for the credential family that produced this slot ("app" on a schedule fire).
+     *  Read ONLY by {@link isScheduleOriginatedAuth}; every other derivation keys on attributes. */
+    readonly authenticator?: string;
+}
+export interface BindableContext {
+    readonly session?: {
+        readonly auth?: {
+            readonly current?: AuthPrincipal | null;
+            readonly initiator?: AuthPrincipal | null;
+        } | null;
+        /**
+         * eve's TYPED parent linkage, present on a DELEGATED CHILD run and on nothing else
+         * (`SessionParent`, seeded into the child's context by execution/runtime-context.js from the run
+         * input execution/subagent-tool.js built). Declared here — not only on hooks/spend.ts's
+         * `DelegatableContext` — because since OPE-393 it is a security discriminator read by the grain
+         * override, the delegation leaf rule, the wake/addressing neutralisation, the memory
+         * single-writer rule and the egress identical-binding invariant, all of which take a plain
+         * `BindableContext`. Host-set and model-unreachable: `buildSubagentRunInput` destructures only
+         * `message`/`outputSchema` off the model's action, so nothing a model writes can produce it.
+         */
+        readonly parent?: {
+            readonly sessionId?: string;
+            readonly callId?: string;
+            readonly rootSessionId?: string;
+        };
+        /** This session's own durable id, distinct from parent.sessionId above. It is named id because every eve context that carries it names it id, and turn.id is session-scoped (turn_0, turn_1, and so on), so a caller that needs a unique per-turn key pairs the two. */
+        readonly id?: string;
+    };
+    readonly channel?: {
+        readonly kind?: string;
+        readonly continuationToken?: string;
+    };
+}
+/**
+ * The same GROUP-rung key from a workspace key a caller ALREADY holds — the shape a gate reading a
+ * resolved partition has (OPE-1538: the Teams single-window privacy floor). Exported so the rung has
+ * ONE spelling: a gate that composed `${workspaceKey}/${group}` by hand would drift from the binding
+ * the moment either side's validation changed, and the two must agree or a `public` group carve-out
+ * demotes on one plane and not the other. Returns `undefined` on a malformed group, fail-closed.
+ */
+export declare function trustGroupKeyFor(workspaceKey: string, group: string | undefined): string | undefined;
+/** The one sanitiser for a platform id used as a key segment: the surface key, the memory partition, the domain roster, every audit row and a resource grant all use this spelling, and a second copy of the charset is how two of them drift apart. It is idempotent, and the 100-character clamp is its only lossy step. */
+export declare function surfaceKeySegment(value: string | undefined): string;
+export { deploymentOrg } from "./deployment-identity.js";
+export declare function authPrincipalId(ctx: BindableContext): string | undefined;
+/** Host-set: the STORED creator principal an autonomous fire is bound as ({@link SurfaceBinding.principalAttested}). */
+export declare const FIRE_PRINCIPAL_ATTR = "oe_fire_principal";
+/** Host-set: the LIVE per-fire verdict on that creator's CURRENT standing. POSITIVE-ONLY — the only
+ *  value that means anything is the literal `"internal"`; absent/anything else is fail-closed. */
+export declare const FIRE_PRINCIPAL_TRUST_ATTR = "oe_fire_principal_trust";
+/** Host-set marker that a trigger produced this session and nobody is acting on it; only the literal true counts, and every fire-auth bag builder stamps it. It exists beside the creator stamp because a webhook fire or a creator-less routine row has nobody to name, and it affects the attestation flag only, never trust. */
+export declare const FIRE_UNATTENDED_ATTR = "oe_fire_unattended";
+/** The attested creator id this delivery carries, when it carries one. Use it for AUDIT DETAIL only and never as the reply's author, because the schedule or service principal stays the actor a fired turn speaks as; it is undefined on an ordinary human turn, on a webhook fire and on a creator-less routine row, where there is genuinely nobody to name. */
+export declare function attestedFireCreatorId(ctx: BindableContext): string | undefined;
+export declare const SCHEDULE_APP_AUTHENTICATOR = "app";
+export declare const SCHEDULE_APP_PRINCIPAL_ID = "eve:app";
+export declare const SCHEDULE_APP_PRINCIPAL_TYPE = "runtime";
+/** The auth slot {@link isScheduleOriginatedAuth} reads — structural, so a caller holding a raw eve
+ *  slot (hooks/fire-carriage.ts) needs no eve type import to pass it. */
+interface ScheduleAuthSlot {
+    readonly authenticator?: unknown;
+    readonly principalId?: unknown;
+    readonly principalType?: unknown;
+}
+/**
+ * Was this session started by a SCHEDULE handler? Mirrors eve's own `isScheduleAppAuth` predicate —
+ * all three fields, never the attributes — so a session that merely looks app-shaped cannot answer
+ * yes, and so the answer survives a fire that arrives with an empty attribute bag.
+ */
+export declare function isScheduleOriginatedAuth(auth: ScheduleAuthSlot | null | undefined): boolean;
+/**
+ * The principal ACTING on this turn — `binding.principalId` unless it is merely ATTESTED, in which
+ * case there is no acting human and the answer is `undefined`.
+ *
+ * 🔴 THIS IS THE AUTHORITY FENCE (OPE-269). Call it — never `binding.principalId` — anywhere an
+ * identity is about to become a PERMISSION: admin standing (access/roles.ts), the personal
+ * connector universe (`dm:<principal>`, access/request.ts), and the "a human is in the room asking
+ * for this" gates on routine-mutating tools. `principalId` itself stays the honest answer to WHO,
+ * which is what audit rows, the spend ledger and an approval card's "asked by" line need.
+ *
+ * Deliberately a function over the binding rather than a second field: a field would be one more
+ * thing every SurfaceBinding literal has to remember to set correctly, and forgetting it would
+ * fail OPEN. This derives the answer from the flag the ONE constructor (bindFrom) sets.
+ */
+export declare function actingPrincipalId(binding: SurfaceBinding): string | undefined;
+/**
+ * IS NOBODY WATCHING THIS TURN? `true` on a routine/webhook/cron fire, `false` on a live human turn.
+ * The binding-taking form; `access/request.ts` `unattendedOf(ctx)` is the ctx-taking twin, and the
+ * pair mirrors {@link actingPrincipalId} / `actingPrincipalIdOf` deliberately.
+ *
+ * 🔴 THIS IS A SECURITY CONTROL (OPE-440). The approver chain turns `ask` into `deny` when it reads
+ * `true`, so "ask when nobody can answer" IS "deny". Every approval site derives the value through
+ * this function or its twin, and `lint:principal-gate` rule 5 refuses any other spelling — reading
+ * `binding.principalId` here would answer "a human is present" for every fire, because a fire binds
+ * as its routine's attested creator.
+ */
+export declare function unattendedFrom(binding: SurfaceBinding): boolean;
+export interface RawIdentity {
+    readonly workspace?: string;
+    readonly surface?: string;
+    /** Domain/spend-grain surface segment when it differs (see SurfaceBinding.domainSurface). */
+    readonly domainSurface?: string;
+    readonly mode?: SessionMode;
+    readonly visibility?: Visibility;
+    /** Trust boundary; a mapper that can't determine it leaves it undefined → bindFrom
+     *  fails closed to `external` for real platforms (internal only for local/dev). */
+    readonly trust?: Trust;
+    /**
+     * For a DM: set true iff the mapper POSITIVELY verified the partner's trust (a real
+     * users.info-style lookup). When false/absent, bindFrom fails the DM closed to external.
+     * Lets a verified DM partner light up the `dm` shared layer while unverifiable platforms
+     * stay safe. Ignored for channels (their trust is already authoritative or fail-closed).
+     */
+    readonly trustVerified?: boolean;
+    /** The group rung between the tenant and the surface, as a marked segment of the form marker:id, set by a mapper only where such a container exists (Teams contributes its team id). The marker is the mapper's and never core's, core validates the shape alone, and a malformed value contributes no group key, so the rung is simply absent. */
+    readonly trustGroup?: string;
+    /** The enterprise rung above the tenant, for a platform that groups several workspaces under one organisation (Slack Enterprise Grid). A mapper sets the raw id and core spells it, an unspellable value contributes no key, and this is the LOWEST rung, so it never overrides the workspace line beneath it. */
+    readonly trustEnterprise?: string;
+    readonly principalId?: string;
+    readonly target?: Readonly<Record<string, unknown>>;
+    readonly threadTs?: string;
+    /** The engagement-registry key of this conversation, when the platform does not key it by
+     *  `threadTs` (see {@link SurfaceBinding.engagementKey}). Absent on Slack — its registry key IS
+     *  the thread ts. */
+    readonly engagementKey?: string;
+    /** The ROOM-GRAIN engagement key, for a platform whose wake gate also watches the whole room
+     *  (see {@link SurfaceBinding.roomEngagementKey}). Teams only. */
+    readonly roomEngagementKey?: string;
+    /** The stop-hand anchor message id, when the platform does not anchor by `threadTs` (see
+     *  {@link SurfaceBinding.anchorMessageId}). Absent on Slack — its anchor IS the thread ts. */
+    readonly anchorMessageId?: string;
+    /** The stop registry's CONTAINER id, when the platform's container is not the post-back target's
+     *  `channelId` (see {@link SurfaceBinding.anchorChannelId}). Absent on Slack and Discord. */
+    readonly anchorChannelId?: string;
+}
+/** A platform's identity mapper. IdentityMapper is the outward-facing name a provider bundle registers against; Mapper is the terse in-file alias. */
+export type IdentityMapper = (ctx: BindableContext) => RawIdentity;
+/** Register or replace one platform's identity mapper. A provider bundle calls this once at boot, so adding a platform needs no downstream change. */
+export declare function registerIdentityMapper(platform: string, mapper: IdentityMapper): void;
+/**
+ * Every platform that has REGISTERED a mapper, sorted. Read by `lint:surface-parity` to hold the
+ * §7.1 identity-mapper row to what the bundles actually registered. Distinct from asking `bindFrom`
+ * about a platform, which answers for every string by falling back to `bindLocal`.
+ */
+export declare function registeredIdentityMapperPlatforms(): readonly string[];
+/**
+ * Resolve the full surface binding from runtime context. Platform is `channel.kind`
+ * (the channel's `kindHint`, e.g. "slack") or OE_PLATFORM, defaulting to
+ * "local". The platform's mapper supplies identity; anything it leaves undefined
+ * falls back to env stand-ins, then to stable defaults (so the key stays constant
+ * across `eve dev` runs and cross-session recall is testable today).
+ */
+/** eve exposes a channel kind in two forms: the bare platform inside tool and step contexts, and a namespaced channel:slack inside lifecycle and hook contexts. Every kind comparison goes through platformFromKind, because a raw equality check silently fails in hook contexts; that bug shipped once, as the identity line falling back to generic. */
+/** eve derives a session's kind from the channel file's slug, not from its kindHint, so a platform served by a file not named after it binds as the slug and misses the mapper registry (measured 2026-07-06: gateway sessions bound as discord-gateway). Alias every such channel file in identity/platform.ts. */
+/** eve's framework channel kind for a built-in/declared subagent child (`FRAMEWORK_CHANNEL_KINDS`). */
+export declare const SUBAGENT_CHANNEL_KIND = "subagent";
+/** The PARENT session id eve's typed linkage names, or undefined on a root run. Read through a local
+ *  cast (the {@link currentTurnId} precedent) so no eve type reaches this module. */
+export declare function subagentParentSessionId(ctx: BindableContext): string | undefined;
+/** The seat a delegated worker was spawned from: eve's rootSessionId, or the immediate parent.sessionId when the linkage names no root. A verb whose effect belongs to the CONVERSATION keys on this and not on currentSessionId, which names the one-shot run that ends before a person answers; it reads eve's typed session.parent only, never the continuation token, whose greedy subagent parse yields a scope key that names no session. */
+export declare function delegationRootSessionId(ctx: BindableContext): string | undefined;
+/**
+ * Is THIS context an eve-minted SUBAGENT CHILD run (built-in `agent` or a declared subagent)?
+ * See the block above for the three discriminators and why the OR is the safe shape. PURE and
+ * fail-soft — never throws, so it is callable from every gate that must narrow on it.
+ */
+export declare function isSubagentChildContext(ctx: BindableContext): boolean;
+export declare function channelPlatform(ctx: BindableContext): string | undefined;
+/** Is this context a session on the synthetic single-window `unified` channel (channels/
+ *  unified.ts)? Checks the RAW kind — deliberately NOT {@link channelPlatform}, which resolves a
+ *  unified session to its per-delivery ORIGIN platform (that is its job). Used by the reply
+ *  tool to select its map-addressed unified variant. */
+export declare function isUnifiedWindowContext(ctx: BindableContext): boolean;
+/**
+ * The origin surface of the delivery driving this turn, resolvable from a tool-execute context, which carries no channel object at all, so every gate written against ctx.channel answers undefined inside an execute.
+ * The three arms weaken in order: channelPlatform, the per-delivery platform stamp, then bindFrom. local is not an origin and reports undefined, which a caller treats as a REFUSAL, never as a pass.
+ */
+export declare function turnOriginPlatform(ctx: BindableContext): string | undefined;
+/**
+ * The wake id of the delivery driving THIS turn (the `oe_wake_id` auth stamp
+ * channels/unified-window.ts writes). eve rewrites `session.auth.current` from each delivery's
+ * auth and coalesces a multi-delivery turn to the LAST delivery's auth, so this is the current
+ * turn's wake — the authority fence the single-window reply tool validates against so a model
+ * can't target a wakeId from a prior turn or another conversation.
+ *
+ * THIS IS THE TURN'S ADDRESS, and three classes of turn are refused one here rather than at each of
+ * the many consumers: a subagent child (OPE-393), a background-task settlement that has read a
+ * terminal view (OPE-585 — it answers under the TASK's own id), and a settlement that has read none
+ * (OPE-597 — it answers `undefined`). Undefined off the single-window path too (no stamp). */
+export declare function currentWakeId(ctx: BindableContext): string | undefined;
+/**
+ * The RAW `oe_wake_id` auth stamp, with every override in {@link currentWakeId} bypassed.
+ *
+ * Two callers, both of which want the stamp as a FACT rather than as an address:
+ *   • the `unified.task_wake` audit row's `inheritedWakeId` field — the stale id the turn would
+ *     otherwise have replied under, which is what makes the defect countable after the fix;
+ *   • {@link deliveryStampOf}, as its fallback.
+ *
+ * 🔴 NEVER USE THIS TO ADDRESS A REPLY. It is exactly the value OPE-393, OPE-585 and OPE-597 each
+ * decided a turn may not speak under; {@link currentWakeId} is the only reader that answers that
+ * question.
+ *
+ * 🔴 ONE READER USES IT TO NAME, NEVER TO POST (OPE-1869), and the distinction is the whole licence.
+ * `hooks/spawn-taint.ts` offers this stamp as a delegated read's SECOND provenance address, because
+ * the seat REPLIES under it while the settling turn answers under the task's own minted wake. It is
+ * not a post target there and it is not trusted on sight: `channels/delegated-provenance.ts`
+ * `delegatedSecondAddress` reads both wake rows back and admits the stamp only where they resolve to
+ * the same conversation — which is what keeps OPE-585's "whichever conversation ran last" out.
+ */
+export declare function inheritedWakeStampOf(ctx: BindableContext): string | undefined;
+/** The per-delivery discriminator the turn boundary compares: a value byte-identical to the previous turn's proves this turn brought no delivery of its own. It falls back to the raw wake stamp for a bag written before the nonce existed, and it stays pure and override-free, because the boundary must read what eve delivered rather than what a later edge installed. */
+export declare function deliveryStampOf(ctx: BindableContext): string | undefined;
+/** The eve turn id, read off the session handle rather than the auth bag. It is turn-constant, and undefined outside an active turn compares unequal to any stored id, so the same-turn re-accept fence fails closed; it is present on tool and hook callback contexts but ABSENT on the step.started resolver context, where a caller falls back to the resolver event's own turnId field. */
+export declare function currentTurnId(ctx: BindableContext): string | undefined;
+/** This session's own durable id; sessionId is a defensive fallback that no measured eve context uses. Pair it with currentTurnId for a unique key, because eve mints turn ids as turn_0, turn_1 and so on, so two warm sessions collide on turn number alone. */
+export declare function currentSessionId(ctx: BindableContext): string | undefined;
+/**
+ * The BARE window token of the session THIS delivery woke (the host-set `oe_window_token` stamp,
+ * channels/unified-window.ts OE_WINDOW_TOKEN_ATTR — stamped by divertToUnifiedWindow on every
+ * delivery). The FALLBACK identity channel for `ctx.channel.continuationToken`, which is
+ * session-static and can be ABSENT at tool-execute time on a resumed seat (the live-found
+ * 2026-07-16 refusal on a legitimate standing window) — per-wake auth attributes are fresh on
+ * every delivery, exactly like the oe_grain stamp that survived the same turn. Host-set only,
+ * unforgeable (§AUTH-ATTRIBUTE PROVENANCE, channels/unified-window.ts); the stamp names the
+ * DISPATCHED-TO session (a task worker's stamp is its task
+ * token), so grain/recursion classification over it stays truthful. Undefined off the
+ * single-window path (no stamp).
+ */
+export declare function currentWindowToken(ctx: BindableContext): string | undefined;
+/**
+ * The bare session/window token THIS turn runs under — the key a per-session "Approve for session"
+ * memo is stored/consulted under (OPE-53 pr.open, OPE-11 connector writes). Prefers the live
+ * continuation token (namespace-stripped), falling back to the host-set window-token stamp
+ * ({@link currentWindowToken}) — `ctx.channel` can be blank at tool-execute on a resumed seat.
+ * Undefined ⇒ the turn's session can't be identified, so session-approval is simply never
+ * offered/consulted for it (safe: a card is always minted). Shared by open_pull_request.ts's
+ * propose path so the key is derived identically wherever it is consulted.
+ *
+ * TASK-grain wakes collapse to their PARENT window ({@link sessionGrantKeyFromToken}): on the
+ * unified topology every wake runs in a spawned task session whose token embeds the wakeId, so
+ * keying the memo on the raw token made every wake a different "session" and a grant could never
+ * be seen again (live-caught 2026-07-25: S-PR-SESSION leg 2 drew a fresh card on a granted window).
+ * The conversation the human granted is the WINDOW; the task is plumbing.
+ */
+export declare function proposingSessionId(ctx: BindableContext): string | undefined;
+/**
+ * The ADDRESSING of the delivery driving THIS turn (`oe_addressing`, written by
+ * channels/unified-window.ts stampUnifiedWindowAuth ONLY for an addressed `direct-mention` wake).
+ * It marks the wake as OWED a reply, which is what the envelope tells the seat. It is NOT a delivery
+ * path: since OPE-1982 the unified channel's completion handler drops a turn's closing prose on EVERY
+ * addressing and re-drives it once towards the `reply` tool, so it no longer selects a route.
+ * 🔴 IT IS STILL LOAD-BEARING IN THREE PLACES, and reading it as audit-only is how a later change
+ * moves a tool gate without noticing: it classifies the drop row's `addressing` field (an owed
+ * answer nobody received stays countable apart from ambient chatter); `hooks/job-posture.ts` reads
+ * `direct-mention` as a HUMAN PRINCIPAL in the turn, which feeds the job-session tool restriction;
+ * and `access/analytics-scope.ts`'s `isAmbientNonAddressedTurn` degrades analytics rows mode to
+ * aggregates without it. Undefined off the single-window path or for a non-addressed (watch) wake.
+ */
+export declare function currentTurnAddressing(ctx: BindableContext): string | undefined;
+/**
+ * Was the delivery driving THIS turn ADDRESSED to the agent (a `direct`/addressed wake — @mention,
+ * DM, or a surface's name-drop), as opposed to a judged/ambient/channel-watch wake? Reads the
+ * host-set `oe_addressed` auth stamp a surface dispatch writes on its direct wakes (identity/
+ * bot-name.ts OE_ADDRESSED_ATTR), OR the single-window `oe_addressing="direct-mention"`/`"direct"`
+ * stamp (stampUnifiedWindowAuth) which already means addressed.
+ *
+ * 🔴 AUTHORITATIVE AND FAIL-CLOSED. This is the signal the link-claim hook gates its relaxed
+ * `link <code>` recognition on (hooks/link-claim.ts): an addressed single-author body may carry a
+ * leading address token, a judged multi-author ENVELOPE may not (that is the F1 attack surface). The
+ * stamp is HOST-SET (§AUTH-ATTRIBUTE PROVENANCE, channels/unified-window.ts) — a model or untrusted
+ * body cannot forge it — and a MISSING stamp reads as NOT addressed ⇒ the strict whole-message anchor
+ * applies ⇒ nothing regresses on a surface that has not (yet) stamped it.
+ */
+export declare function currentTurnAddressed(ctx: BindableContext): boolean;
+/** The platform-resolved integration name stamped on THIS delivery's auth (identity/bot-name.ts
+ *  OE_BOT_NAME_ATTR), when a surface with a live integration name set it (Notion). Feeds the
+ *  addressed link-claim recogniser's name-token set so a name-drop that matches the deployment's
+ *  ACTUAL integration name is stripped even without OE_AGENT_* configured. Undefined ⇒ the recogniser
+ *  falls back to the env/brand tokens only. */
+export declare function currentTurnBotName(ctx: BindableContext): string | undefined;
+/**
+ * The Linear ISSUE the delivery driving THIS turn is anchored to (`issue_id`, falling back to
+ * `issue_identifier`) — the authoritative per-wake issue the surface's identity capture stowed
+ * (channels/linear-identity.ts buildLinearAuth), the SAME source the Linear supervisor's turn.started
+ * reply-target snapshot reads. This is the DEFAULT issue for read_linear_issue: unlike Notion (whose
+ * binding.surface IS the page being read), a Linear session's `surface` is the TEAM (the silo grain,
+ * see bindLinear) — the CONTAINER, not the entity — so `bindFrom(ctx).surface` is the wrong default
+ * (it would fetch a team id as an issue). The issue lives in the auth attributes, not `surface`;
+ * reading it here is the authoritative anchor, NOT a guess derived from the team. Undefined when no
+ * issue was stamped (e.g. a unified turn whose stamp omits it) ⇒ the tool requires an explicit arg.
+ */
+export declare function currentTurnIssue(ctx: BindableContext): string | undefined;
+/**
+ * The Notion PAGE the delivery driving THIS turn is anchored to — `page_id`, the raw per-wake stamp
+ * the surface's identity capture stows (channels/notion-identity.ts, whose `pageId` is "the page the
+ * comment lives on").
+ *
+ * 🔴 THE RAW ATTRIBUTE, NOT `bindFrom(ctx).surface`, AND THE DIFFERENCE IS THE POINT. A Notion
+ * session's `surface` IS the page, but it is the SANITIZED partition segment — `seg()`-passed, and
+ * defaulted to a placeholder on an under-identified event — so it is a partition key, not an id you
+ * can compare against one a Notion API call returned. `channels/read-reach.ts` compares exactly that
+ * way, to decide whether a record's id already appeared in the room, so it needs the id the host
+ * stamped. Undefined on every turn woken somewhere other than a Notion page.
+ */
+export declare function currentTurnPage(ctx: BindableContext): string | undefined;
+/** The raw Linear organization id off this turn's auth attributes: the credential SELECTOR a Linear tool call needs, because a Linear token is workspace-scoped and the exact organization id is the registry key. It is deliberately not the binding's sanitized workspace segment, and it is undefined when this turn stamped no organization, where the caller falls back to the org-free credential chain. */
+export declare function currentTurnOrganization(ctx: BindableContext): string | undefined;
+/**
+ * The GitHub issue/PR the delivery driving THIS turn is anchored to — owner + repo + exactly one of
+ * issue/PR number, read off THIS turn's RAW auth attributes rather than a stored session-open
+ * snapshot, so a unified session's per-delivery GitHub turn resolves its OWN anchor (mirrors
+ * {@link currentTurnIssue}'s Linear counterpart). Reads the same attributes bindGitHub interprets,
+ * but DIRECTLY (not via the resolved binding.target) so it stays CORE-SELF-CONTAINED after the
+ * github chat-surface mapper moved into @open-everywhere/provider-github (OPE-114 stage 4): the
+ * githubEntityAdapter / SCM plane stay in core and must not depend on a bundle registration. The
+ * platform gate is kind-derived (bindFrom's platform comes from the channel kind, not the mapper).
+ * Undefined when this turn isn't a GitHub delivery, or the webhook carried no owner/repo/number —
+ * the caller (entity-ref default resolution) then requires an explicit ref rather than guessing.
+ */
+export declare function currentTurnGithubTarget(ctx: BindableContext): {
+    owner: string;
+    repo: string;
+    number: number;
+    isPr: boolean;
+} | undefined;
+/**
+ * Per-turn surface fence for a per-surface read tool, called inside execute: a cross-surface session carries turns from several surfaces while the session.started mount gate saw only the opener's origin, so this requires THIS turn's origin to equal the tool's surface and throws on anything else.
+ * It fails closed hard: a turn whose origin cannot be named at all is refused, never waved through.
+ */
+/** OPE-732 — thrown by {@link assertTurnSurface}. Lets the five async call sites distinguish this
+ *  fence's refusal from any other thrown Error (without parsing message text) and audit it before
+ *  rethrowing. `assertTurnSurface` itself stays PURE and synchronous — no store access, no signature
+ *  change — the audit write happens at each async caller. Deliberately no `.name` override: `String(err)`
+ *  stays "Error: …", so every existing message-regex `assert.throws` assertion is unaffected. */
+export declare class TurnOriginFenceError extends Error {
+    readonly surface: string;
+    constructor(message: string, surface: string);
+}
+export declare function assertTurnSurface(ctx: BindableContext, surface: string): void;
+/**
+ * The GRAIN of a session — what sets its HANDS (window-tool-gating-design §D/§S3). A STANDING ambient
+ * watcher (the unified window / a per-channel or ticketing supervisor / the root DM seat) narrows to
+ * conversational hands and delegates heavy work; a THREAD seat (a persistent conversational presence
+ * spawned by spawn_thread_session, Stage T2) is likewise narrow; only a TASK (thread-scoped worker,
+ * the one-shot spawn) keeps the FULL wide-hands kit. Grain — not source count —
+ * determines the toolset (the invariant that supersedes `sources.length===1 ⇒ full`).
+ *
+ * NATIVE (a raw `@mention` seat) WAS a full-kit grain (Stage C); under the narrowing (flag
+ * delegation.oneshotAgent) it is a CONVERSATIONAL-ROOT grain that delegates through `agent`, so it
+ * LOSES the wide hands (see access/window-gate-manifest.ts `fullKit()`). The grain enum is unchanged; what
+ * moved is wide-hands membership. Conversational-root grains = standing/native/thread; the ONLY grain
+ * with wide hands is `task` (the one-shot worker — a credential-correct new session, both agent modes).
+ */
+export type WindowGrain = "standing" | "task" | "native" | "thread";
+/**
+ * The grain the HOST STAMPED on this delivery, unreconciled, or `undefined` when no stamp reads as a grain.
+ *
+ * 🔴 IT IS NOT {@link windowGrainOf}, AND THE DIFFERENCE IS THE POINT. On a DELEGATED CHILD, `windowGrainOf`
+ * answers `task` by the subagent-child override, while eve copies the PARENT's whole auth bag into the child —
+ * so the stamp there describes the SEAT the worker was spawned from, and this is the one reader of that fact.
+ * A caller asking what THIS session's own hands are takes `windowGrainOf` and never this: the reconciliation
+ * below (the spoof/bug guard) is exactly what this function skips.
+ *
+ * Host-set and model-unreachable (channels/unified-window.ts §AUTH-ATTRIBUTE PROVENANCE). An unrecognised value
+ * answers `undefined` rather than a guess, so a caller must state what it does with an unreadable stamp.
+ */
+export declare function stampedWindowGrainOf(ctx: BindableContext): WindowGrain | undefined;
+/**
+ * The grain of THIS session. PRIMARY = the host-stamped `oe_grain` auth attribute
+ * (channels/unified-window.ts stampUnifiedWindowAuth / channels/unified.ts dispatchTaskWindow) — set
+ * by OE host code at dispatch, never model-authored, so it is unforgeable and stable for the session's
+ * life (verified + source-cited ONCE in channels/unified-window.ts §AUTH-ATTRIBUTE PROVENANCE). BACKSTOP = {@link classifyTokenGrain} (the token shape). PURE — a function of the stamp and the
+ * token only (no eve, no store) — so each grain is mint-and-assert testable, exactly as §S3 requires.
+ *
+ * SPOOF/BUG guard, fail-CLOSED to NARROW: if the stamp claims a FULL grain (task/native) while the
+ * token independently classifies a NARROWER grain, the wider claim LOSES. A stamped task grain on a
+ * non-task token is a bug, not a capability grant.
+ *
+ * The one deliberate exception is the DEGRADATION case: a blank/unreadable token (the known
+ * session.started degradation, §S3 fragile point) is NOT a positive narrow signal — it is the ABSENCE
+ * of the token, so the stamp stays primary (a legit async worker whose `t/` token degraded keeps its
+ * `task` grain). This is why the guard distinguishes an ABSENT/blank token (stamp wins) from a token
+ * that is PRESENT and positively classifies `native` (a real `cse_…` @mention seat — a `task` stamp
+ * there is a bug/forge, since a legit worker always rides a `t/` token — so it is narrowed). Closes the
+ * T2 asymmetry the adversarial review flagged (F2): `task` on a present native token no longer keeps
+ * wide hands, WITHOUT regressing the degraded-worker path (blank token).
+ */
+export declare function windowGrainOf(ctx: BindableContext): WindowGrain;
+/**
+ * The short WORKER TASK LABEL stamped on a task-window worker's OPENING delivery (OPE-508, the reply
+ * display-name/prefix TIER signal) — a PURE read of the `oe_task_label` auth attribute, mirroring
+ * {@link windowGrainOf}'s attribute-read style but with no token-shape backstop (there is no text to
+ * recover from a token — only the host stamp carries it). Undefined on every non-worker turn, and on
+ * a worker turn woken by a LATER message in its own thread (the stamp is not re-derived on a resumed
+ * wake, unlike `oe_grain` — see channels/unified-window.ts's OE_TASK_LABEL_ATTR header). Callers that
+ * need a bracket on every worker turn regardless fall back to a generic label when this is undefined
+ * — see channels/turn-delivery.ts's {@link ReplierLabel}-producing `replierLabelFor`.
+ */
+export declare function windowTaskLabelOf(ctx: BindableContext): string | undefined;
+/** The sources vector stamped on THIS delivery: a pure read of the host-set stamp, with no config and no store. Undefined when the stamp is absent, on a normal non-unified session or a resumed pre-stamp session, and the caller then picks the fallback. */
+export declare function windowSourcesOf(ctx: BindableContext): readonly string[] | undefined;
+/** The sources vector for this session, fail-closed: the host stamp first, then a recompute from the continuation token's window and domain plus the domain config, then the single origin platform, never empty and never a wider set. domains is injected so the resolver stays pure and testable. */
+export declare function resolveWindowSources(ctx: BindableContext, domains: readonly Domain[]): readonly string[];
+/** Resolve a bridged, identity-less context through the same platform hop the live path uses. That heals a stamped raw channel slug and adds the unified-to-origin hop, so the bridged fallback binds the REAL origin surface instead of unified, which resolved no mapper and desynced memory writes from reads on the very channel the bridge exists to keep in sync. */
+export declare function bindBridged(bridged: BridgedIdentity): {
+    platform: string;
+    raw: RawIdentity;
+};
+/**
+ * Does this context carry a PLATFORM IDENTITY of its own — a workspace or a surface its platform
+ * mapper can read off the delivered auth attributes?
+ *
+ * This is the exact question {@link bindFrom}'s bridged fallback asks, exported because it is also
+ * the question {@link refreshBindingStamp} asks on both sides of its downgrade test.
+ * A bag can be non-empty and still answer FALSE: the OE window stamps (`oe_platform`, `oe_wake_id`,
+ * `oe_grain`, `oe_window_token`, `oe_sources`) are host metadata about the delivery, not the
+ * platform's own identity attributes (Slack's `team_id`/`channel_id`, Discord's `guild_id`, …).
+ */
+export declare function carriesPlatformIdentity(ctx: BindableContext): boolean;
+/** The one production entry point for the binding bridge. A stamp that names a surface may not be replaced by a context that names none, but the rule is a DOWNGRADE test only: the same bag carries a fire's attested creator and unattended marker, and refusing an identity-less fire's write would hand its tool contexts an ATTENDED reading. */
+export declare function refreshBindingStamp(ctx: BindableContext): "stamped" | "kept";
+/** What one {@link healDeliveryIdentity} pass did. `unwritable` is the LOUD arm and the only one a
+ *  caller should report: the write WAS attempted and the read-back says it did not land (a frozen or
+ *  cloned bag). `no-delivery` is its quiet twin — there was no auth slot to write to at all, which is
+ *  every context that never carried a delivery. */
+export type DeliveryHealOutcome = "not-needed" | "healed" | "no-stamp" | "cross-platform" | "no-delivery" | "unwritable";
+/**
+ * Write the session's established platform identity back onto THIS delivery's auth attributes, so a subagent child's verbatim inherited copy sees the identity the seat already binds.
+ * It can only restore, never escalate: it runs only when the delivery names no surface, writes only keys the bag lacks, repeats bindFrom's cross-platform fence, and derives its answer from a read-back, so a frozen or cloned bag reports unwritable rather than a false healed.
+ */
+export declare function healDeliveryIdentity(ctx: BindableContext): DeliveryHealOutcome;
+/**
+ * The fail-closed backstop for a child that lost its parent's binding: the heal depends on a mutation of an eve-owned object surviving into the child, and a release that freezes or clones the bag takes it away silently, leaving the child on the org-default partition with no grants and the wrong memory partition.
+ * Narrow on purpose: true only when the inherited platform stamp resolves a REGISTERED mapper and the child still names no surface, so eve dev, evals and unit contexts can never trip it.
+ */
+export declare function subagentBindingLost(ctx: BindableContext): boolean;
+/**
+ * Does {@link bindFrom} answer this context with the `subagent/…/unresolved` sentinel, and why?
+ * `undefined` for every context that is not a delegated child, or that holds its dispatch binding.
+ * `no-context` is the eve-context-scope class (OPE-2106): the slot holds the binding, but the caller
+ * runs outside eve's context and cannot read it. `empty` is a child whose slot holds nothing.
+ */
+export declare function delegatedBindingUnresolved(ctx: BindableContext): "empty" | "no-context" | undefined;
+export declare function bindFrom(ctx: BindableContext): SurfaceBinding;
+//# sourceMappingURL=binding.d.ts.map

package/dist/agent/identity/binding.d.ts.map

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