@open-everywhere/core 0.1.0

package/dist/agent/routines/declared-permissions.d.ts

@@ -0,0 +1,302 @@
+import { type Routine } from "./routine.js";
+/** The routine a declared permission hangs off — id + generation is all any of this needs. */
+type PermissionedRoutine = Pick<Routine, "id" | "promptGeneration">;
+/**
+ * The `expiresAt` a declared permission is written with. A session memo's TTL is a GC bound because
+ * the session token's generation is the real death mechanism; a declared permission's death
+ * mechanism is the generation in {@link routinePermissionKey} plus explicit revocation, and a TTL on
+ * top of that would be a THIRD one nobody asked for — it would silently disarm a standing permission
+ * mid-night and turn the 03:00 fire this ticket exists to unblock back into a card nobody clicks. So the row carries a
+ * far-future sentinel: it never satisfies the prune-on-write predicate (`expires_at <= now`), and it
+ * reads in the table as what it is — no expiry.
+ */
+export declare const ROUTINE_PERMISSION_NO_EXPIRY = "9999-12-31T23:59:59.999Z";
+/**
+ * How many permissions one creation card may declare. A card a human will not read is not a gate
+ * (the same argument routine-lifecycle.ts's CARD_PROMPT_CHARS makes about prompt text), and the
+ * declared set is the ONLY thing on that card granting standing unattended authority — so a
+ * shotgun declaration is refused at the tool rather than rendered as a wall nobody audits.
+ */
+export declare const MAX_DECLARED_PERMISSIONS = 6;
+/**
+ * Validate a model-proposed declaration, returning the memo KINDS it maps onto. Throws with the
+ * legal vocabulary named — the same create-time-is-the-primary-gate posture `validateSubscription`
+ * takes for event filters: a declaration that could never grant anything must be refused where the
+ * author can fix it, never armed and left inert on the card.
+ *
+ * Duplicates collapse (the memo table is keyed per kind, so declaring one tool twice is one row
+ * either way and rendering it twice would only pad the card).
+ *
+ * 🔴 A DESTRUCTIVE-TIER TOOL IS REFUSED HERE, and this is the DECLARED half of DESTRUCTIVE-NEVER.
+ * The per-tool vocabulary can spell `tool:notion__delete_page`; the fence would never lift it, so
+ * writing the row would put a line on the arming card promising authority the runtime withholds.
+ * The classifier used is the STATIC one (access/consequence.ts), not `effectiveConnectorOpTier`.
+ * 🔴 THE STATIC TIER IS NO LONGER A LOWER BOUND ON THE SEAM (OPE-1321): a consumer arm may LOWER a
+ * verdict as far as `write`, so the seam can answer `write` where this check says `destructive`. The
+ * two checks are therefore independent refusals, not one bounding the other, and the direction here
+ * is the conservative one — this refuses the declaration outright, so no row is ever minted and the
+ * fence's lift is unreachable for it. Keeping the static read also keeps the property the next
+ * sentence names: a declaration must not be refused on one deployment's config and allowed on
+ * another's. The converse residual stands and is the
+ * fence's to hold — a `write` verb a deployment's bundle RAISES to destructive declares cleanly
+ * here and is refused at lift time instead. (Bundles ARE readable at propose time — they register at
+ * boot, agent/lib/register-config.ts — so reading the STATIC tier is a deliberate choice, not an
+ * absence: reading the effective tier here would refuse a tool on one deployment's bundle config
+ * that the fence lifts on another.)
+ *
+ * 🔴 THE RESIDUAL IS NO LONGER SILENT (OPE-1307), AND IT IS STILL NOT REFUSED HERE. A `write` verb a
+ * deployment's bundle RAISES to destructive still declares cleanly at THIS layer, for the reason the
+ * paragraph above gives: the throw is model-facing and must not depend on one deployment's bundle
+ * config. What changed is the two moments AFTER it, both of which happen on the deployment whose
+ * bundles decide the answer — {@link describeDeclaredPermissions} renders the raise on the arming
+ * card, so the human reads "grants nothing here" BEFORE they click, and
+ * {@link armDeclaredRoutinePermissions} writes no row and audits the skip. The fence
+ * (connections/connector-auth.ts) is untouched: it is still the only reader of the effective tier at
+ * lift time, and it still refuses. See {@link namesBundleRaisedTool}.
+ */
+export declare function declaredPermissionKinds(declared: readonly string[]): string[];
+/** Would the fence refuse this declaration's tool on tier grounds, whatever row exists? True for a
+ *  DELETE-tier verb and for an unrecognised one, which `classifyConnectorOpTier` fails closed to the
+ *  same tier. Both cases render a card line naming authority the runtime withholds, which is why
+ *  neither is written.
+ *
+ *  EXPORTED for `routines/permission-card.ts` (OPE-1357), which must apply the SAME test before it
+ *  plans a card: a card offering a declaration this arming path would refuse promises a human
+ *  something the fence breaks on every fire. One spelling of the tier rule, read by both. */
+export declare function namesUnliftableTool(trimmed: string): boolean;
+/**
+ * Does THIS DEPLOYMENT's bundle CONFIGURATION raise this declaration's tool to the delete tier — so
+ * the row would be written, rendered on the card, and then refused by the fence on every fire?
+ *
+ * 🔴 THIS IS THE OPE-1307 RESIDUAL, AND IT IS A DIFFERENT QUESTION FROM {@link namesUnliftableTool}.
+ * That one asks the STATIC classifier, and its answer is the same on every deployment — which is
+ * exactly why it is the one the model-facing throw reads. This one asks the DECLARED half of the
+ * seam (`connectorOpTierParts(tool).declared`, access/connector-op-gating.ts), which is this
+ * deployment's `connectorOps` config and nothing else. A tool both agree on is not interesting here:
+ * the static test already refused it. The set this names is precisely
+ * `static ≠ destructive AND declared = destructive` — the verb that declares cleanly and lifts
+ * nothing, which the human previously armed and was never told about.
+ *
+ * 🔴 THE DECLARED HALF, NOT `effectiveConnectorOpTier`, AND THE DIFFERENCE IS LOAD-BEARING. The
+ * effective tier is `base ⊕ consumer arm ⊕ declared`, and a registered `AppConfig.connectorOpTier`
+ * arm can raise a verdict too. Reading the whole seam here would be wrong twice over. It would make
+ * the card copy and the audit row FALSE — they name the bundle config, and an operator sent to their
+ * `connectorOps.destructive` list would not find the op there. And a consumer arm's verdict is PER
+ * CALL: the slot's contract asks only that an arm answer the same way within one process, so an arm
+ * that reads a cache built at boot may answer differently in the next process, and the same frozen
+ * card would skip the row on one delivery and write it on the next. A config declaration has
+ * neither property: it registers at boot and answers the same way every time.
+ *
+ * 🔴 SO AN ARM-RAISED VERB IS NOT COVERED HERE, DELIBERATELY, and the fence is where it belongs. The
+ * fence reads the effective tier itself at lift time and refuses on its own terms — which is the
+ * right place for a per-call verdict, and the only place that can see one. What this function buys
+ * is the case that IS stable enough to put on a human's card before they click.
+ *
+ * 🔴 IT IS A DIAGNOSIS, NOT A SECOND FENCE. Nothing here decides whether a call may proceed. Note
+ * that `declared` is joined LAST in `connectorOpTierParts`, so a declared `destructive` makes the
+ * effective tier destructive whatever an arm answered: everything this names really is unliftable.
+ *
+ * TOTAL. A config read that throws must not break an arming click on a routine that is already
+ * durably added. A throw answers `false`, which is exactly today's behaviour: the row is written and
+ * the fence refuses it, silently, as it did before.
+ */
+export declare function namesBundleRaisedTool(trimmed: string): boolean;
+/** The audit row for a declaration this deployment's bundle configuration raises out of reach
+ *  (OPE-1307). Ids and enums only — the declaration string is model-authored, but it is the very
+ *  thing an operator has to read to fix this, and it is already rendered verbatim on the card a
+ *  human clicked, so it carries. No prompt text and no target ever does. */
+export declare const ROUTINE_PERMISSION_NEVER_LIFTS_ACTION = "routine.permission_never_lifts";
+/**
+ * The audit actions the declared-permission plane writes: one when a creation-card click ARMS the
+ * declared set (approvals/routine-create.ts), one when `revoke_routine_permissions` withdraws it.
+ *
+ * 🔴 BOTH VALUES ARE PERSISTED AND NEITHER MOVES (OPE-1303). Rows carrying `routine.grant` and
+ * `routine.grants_revoked` sit in deployed audit chains, and the chain is append-only and
+ * hash-linked — a renamed action would not rewrite one row, it would only stop every reader from
+ * finding the old ones. So the vocabulary sweep named the constants for what the plane calls the
+ * thing (a DECLARED PERMISSION) and left the strings alone. Read the constant, never the literal.
+ */
+export declare const ROUTINE_PERMISSIONS_ARMED_ACTION = "routine.grant";
+export declare const ROUTINE_PERMISSIONS_REVOKED_ACTION = "routine.grants_revoked";
+/**
+ * The declarations a click did NOT arm, so the arming outcome can name them rather than leaving a
+ * human to believe a permission is live.
+ *
+ * 🔴 IT IS DECLARED MINUS GRANTED, never the vocabulary check alone. THREE things stop a declared
+ * permission becoming a live row, and a clause that walks only the first one affirmatively misleads
+ * on the other two — on a TAINTED card carrying one legacy string it would name that one string and
+ * imply the rest armed, when nothing armed at all:
+ *   • this build's vocabulary or the tier check refuses it ({@link armablePermissionKinds} skips it);
+ *   • the proposal was TAINTED, so {@link armDeclaredRoutinePermissions} wrote nothing;
+ *   • the row write failed, and that function degrades per row rather than failing the click.
+ * `granted` is what that function actually WROTE, which is the only reading that sees all three.
+ * A legacy `connector:<slug>` string lands here after the per-tool re-key.
+ */
+export declare function unarmedDeclarations(declared: readonly string[], granted: readonly string[]): string[];
+/**
+ * The declared set as the arming card renders it: plain language, in the declaration's order.
+ *
+ * 🔴 EVERY DECLARATION GETS A LINE, and none of them over-promises. Those are two rules, and the
+ * function used to break both. It rendered ONLY the declarations `routinePermissionKind` mapped,
+ * so a card carrying nothing else showed NO permission line at all — the human read an ordinary
+ * card and never learned the model had declared anything. That is the failure the sibling renderer
+ * ({@link describeDeclaredPermissionKind}) names as the one it must not have: silently hiding a row is worse
+ * than an ugly row. A card FREEZES its declaration strings and is clicked later, possibly after a
+ * deploy that changed the vocabulary — the per-tool re-key is exactly such a change, so a card
+ * frozen with the superseded `connector:<slug>` spelling is a live shape, not a hypothetical.
+ *
+ * So a declaration this build cannot map renders as an explicit `unrecognised declaration` line
+ * instead of vanishing. It names the frozen text and promises nothing.
+ *
+ * The other half is {@link namesUnliftableTool}, applied here exactly as {@link
+ * armablePermissionKinds} applies it. A destructive-tier tool is refused at propose time, but the
+ * tier is read from a classifier a later deploy can change: a verb that declared cleanly can be
+ * DELETE-tier by the time the frozen card renders. Rendering it as `use the "…" tool` would then
+ * name standing authority the fence refuses on every fire — the same over-promise `describeDeclaredPermissionKind`
+ * removed from the legacy arm. It renders as lifting nothing instead.
+ *
+ * 🔴 A BUNDLE-RAISED TOOL GETS ITS OWN LINE (OPE-1307), and this is the moment the residual stops
+ * being silent. The card is what a human reads BEFORE they click, so it is the only place the
+ * warning can still change their mind. The line names the deployment, not the tool's nature — the
+ * same verb on a deployment without that bundle declaration lifts perfectly well, and a line saying
+ * otherwise would be false there.
+ *
+ * The direction stays UNDER-PROMISE throughout: a line here may say a declaration buys less than a
+ * click will write, never more.
+ *
+ * 🔴 EACH LINE IS A NOUN PHRASE, because ONE list feeds TWO sentence frames in
+ * approvals/routine-create.ts `permissionLines`, and this function cannot see which one it is
+ * filling. The armed frame reads "may, without asking: <lines>"; the TAINTED frame reads "asked for
+ * standing permission to <lines> — NOT granted". A line that opened with a bare "nothing" satisfied
+ * the first frame and made the second one FALSE — it said the model asked for nothing, when the
+ * model asked for the very string being echoed. So a non-arming line NAMES the declaration first and
+ * carries "(grants nothing)" as a trailing qualifier, which is true in both frames. Read both
+ * renderings before changing this wording.
+ */
+export declare function describeDeclaredPermissions(declared: readonly string[]): string[];
+/**
+ * Write the DECLARED set as standing grants, at ARM time (the human's click on the creation card),
+ * returning the kinds actually written. Returns `[]` — writing nothing — when the proposal was
+ * TAINTED: a routine authored in a turn that had ingested untrusted content starts from zero
+ * standing authority even if a human arms it, exactly as approvals/routine-lifecycle.ts describes
+ * for an edit. The routine itself is still armed; it simply asks when it fires.
+ *
+ * Best-effort per row, deliberately: the routine is already durably added by the time this runs, and
+ * a failed grant write degrades to "it will ask a human", which is the safe direction. Failing the
+ * whole click over it would leave an armed routine and a card rendered FAILED. That is why the
+ * kinds come from {@link armablePermissionKinds} and not from {@link declaredPermissionKinds} — a
+ * frozen card can name a declaration this build no longer accepts, and the throw would be exactly
+ * the failure this paragraph rules out.
+ *
+ * 🔴 THE BUNDLE-RAISED SKIP IS AUDITED BY THE CALLER (OPE-1307), not here. The row belongs in the
+ * arming partition beside the sibling {@link ROUTINE_PERMISSIONS_ARMED_ACTION} row, and this
+ * function is handed an org and a
+ * routine rather than a partition — writing it here would file it under an invented one. So the
+ * caller reads {@link bundleRaisedDeclarations} and writes
+ * {@link ROUTINE_PERMISSION_NEVER_LIFTS_ACTION} itself (approvals/routine-create.ts).
+ */
+export declare function armDeclaredRoutinePermissions(input: {
+    readonly org: string;
+    readonly routine: PermissionedRoutine;
+    readonly declared: readonly string[];
+    readonly grantedBy: string;
+    readonly tainted: boolean;
+    readonly nowIso: string;
+}): Promise<string[]>;
+/**
+ * The declarations THIS DEPLOYMENT's bundles raise to the delete tier — the set
+ * {@link armDeclaredRoutinePermissions} skips, in the declaration's own spelling.
+ *
+ * The caller writes the {@link ROUTINE_PERMISSION_NEVER_LIFTS_ACTION} row from this, in the arming
+ * partition. Pure and total: `namesBundleRaisedTool` swallows an unreadable bundle read, so this
+ * answers `[]` on a deployment whose config cannot be read — which is exactly the pre-OPE-1307
+ * behaviour, silence, rather than a throw on a click that has already armed a routine.
+ */
+export declare function bundleRaisedDeclarations(declared: readonly string[]): string[];
+/**
+ * The declarations that name a STANDING UNATTENDED WRITE, in the declaration's own spelling: a
+ * declared `pr.open`, and a connector tool whose tier is not `read`. Empty when the set declares
+ * only reads.
+ *
+ * 🔴 THIS IS THE HUMAN-ONLY CLASS (OPE-2101 and OPE-2103, Tommy rulings 2026-09-23). The armed
+ * approval judge may not lift a `routine.create` that declares one of these: a person's click on the
+ * creation card is the only lift. The approver chain reads this set to decide whether the judge is
+ * eligible at all (access/approver-chain.ts `judgeHumanOnlyReason`).
+ *
+ * FAIL CLOSED, in two ways. A tool counts when EITHER the static classifier or this deployment's
+ * effective tier says it is not a read, so a bundle that raises a read verb to a write is covered.
+ * A tier read that throws counts the tool as a write. A string the vocabulary does not accept is
+ * skipped: it can arm nothing, and create_routine refuses it before the card exists.
+ */
+export declare function declaredStandingWrites(declared: readonly string[]): string[];
+/**
+ * The routine's live permission KINDS read under a permission key that is already RESOLVED — the
+ * same rows {@link routinePermissionKinds} answers, addressed by the key instead of by the routine.
+ *
+ * It exists for the FIRE-TIME TOOLSET PROJECTION (OPE-2135, hooks/fire-toolset.ts). A fire carries
+ * its key stamped on its own auth bag (`routines/routine.ts routinePermissionKeyStamped`) and never carries the
+ * routine row, so the sibling readers above cannot serve it: reconstructing `{id, promptGeneration}`
+ * from the key would spell the generation a second time, and a fire whose generation the two
+ * spellings disagreed about would project a toolset off a key no gate reads.
+ *
+ * Both filters below are why this is not an open-coded store read at the call site. Fails SOFT to an
+ * empty list, like every other reader on this plane: the direction is "the routine holds less than
+ * it might", which projects no tool rather than one no row permits.
+ */
+export declare function permissionKindsUnderKey(org: string, permissionKey: string, nowIso: string): Promise<string[]>;
+/**
+ * The routine's live permission KINDS — the raw memo kinds, not their descriptions.
+ *
+ * It exists for the PRE-RUN COLLECTOR check (OPE-151, routines/collector.ts): a collector runs under
+ * the routine's declared permission and nothing wider, so the dispatcher has to compare the
+ * collector's tool against the kinds the routine actually holds. {@link listRoutinePermissions}
+ * cannot serve that — it renders each kind as prose for a human, and matching on prose would make a
+ * permission check depend on the wording of a card.
+ *
+ * It reads the LIVE rows, so a revoked permission stops its collector on the very next fire, and it
+ * fails SOFT to an empty list for the reason {@link listRoutinePermissions} does: the direction is
+ * "the routine holds less than it might", which refuses a collector rather than running one.
+ */
+export declare function routinePermissionKinds(org: string, routine: PermissionedRoutine, nowIso: string): Promise<string[]>;
+/**
+ * The routine's CURRENT standing set in plain language — what a human declared on the creation
+ * card, plus what a human later approved on a permission card (OPE-1290). Both are the same row
+ * shape under the same key.
+ *
+ * Fails SOFT to an empty list: `list_routines` must still answer the schedule question when the
+ * grant read fails. That direction is safe for the reader (it under-reports authority in a view,
+ * never over-reports it) and it is the same posture readRoutineForensics takes.
+ */
+export declare function listRoutinePermissions(org: string, routine: PermissionedRoutine, nowIso: string): Promise<string[]>;
+/**
+ * Withdraw the routine's WHOLE declared standing set without touching the routine row — the
+ * channel-side off switch for the authority alone.
+ *
+ * 🔴 TWO COUNTS, AND THEY ANSWER DIFFERENT QUESTIONS. `permissions` is how much AUTHORITY went, and
+ * it is what a human is told ("no longer has standing permission to …"); `rows` is how much this
+ * call actually DELETED. They diverge because the delete is by key, so it also takes the permission
+ * card's asked/declined markers (OPE-1290) — a revoke is a clean slate, and the routine may ask
+ * again on its next fire. Collapsing them into one number breaks one caller or the other: reporting
+ * `rows` names authority that was never held, and gating an audit row on `permissions` would let a
+ * call that destroyed a human's durable "never ask me again" leave no trace at all.
+ */
+export declare function revokeRoutinePermissions(org: string, routine: PermissionedRoutine): Promise<{
+    permissions: number;
+    rows: number;
+}>;
+/**
+ * ONE-SHOT: delete every inert legacy `connector.op:<slug>` row this org holds under a routine
+ * grant key. Returns how many rows went (OPE-1308).
+ *
+ * 🔴 IT WITHDRAWS NO AUTHORITY, WHICH IS WHY IT MAY RUN UNATTENDED. Nothing reads a
+ * `connector.op:` row on any code path — the per-tool re-key refuses the shape rather than widening
+ * it — so these rows lift nothing and never did. They persist only because the routine grain
+ * carries a far-future expiry sentinel, so the prune-on-write GC never reaches them.
+ *
+ * Deliberately NOT folded into `revokeRoutinePermissions`: that call answers for ONE routine and
+ * must stay a withdrawal of that routine's authority, while this is an org-wide clean-up of dead
+ * records. `packages/core/scripts/sweep-legacy-connector-op-rows.ts` is the operator's entry point.
+ */
+export declare function sweepLegacyConnectorOpRows(org: string): Promise<number>;
+export {};
+//# sourceMappingURL=declared-permissions.d.ts.map

package/dist/agent/routines/declared-permissions.d.ts.map

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