@sema-agent/core 7.50.1 → 7.51.0

package/dist/core/ask-origin.d.ts

@@ -53,8 +53,8 @@ import type { ContainmentFace } from "../tools/fs/containment-face.js";
  *    reads a word, an unterminated quote, a syntax error — the answer's `reason`): whether one of those
  *    rows forbids this call is unknown, so an allow tightens to an ask a person must clear and no automatic
  *    lane may answer. A store (or a partition of it) that could not be READ is this word too — a row inside it
- *    may forbid the call and nobody can tell — with the class `governance_unavailable` instead of the releasable
- *    `rule_unreadable`, both bypass-immune; the run also carries one `permission.rule_store_unavailable` notice.
+ *    may forbid the call and nobody can tell. Both carry the class `rule_unreadable` (bypass-immune); the run also
+ *    carries one `permission.rule_store_unavailable` notice.
  *  - `hook` — a deployment's PreToolUse screening face raised or co-raised the ask; the word is
  *    engine-stamped at the fold and is the deployment's own per-call adjudication.
  *  - `ask_rule` — an EXPLICIT `ask` permission rule matched: a person's standing "ask me each time",
@@ -103,13 +103,12 @@ export interface AskOriginFacts {
     readonly org: "rule" | "unavailable" | undefined;
     /** The gate's own record of its persisted-rule lane's READ: the store was read, but THIS CALL could not be read
      *  against the person's deny/ask rows (the lane's answer carried the lexer's reason) — the origin
-     *  `rule_store_unavailable`, the class `rule_unreadable` (bypass-immune, like the store form's). Absent: the lane read the call, or the store
+     *  `rule_store_unavailable`, the class `rule_unreadable`. Absent: the lane read the call, or the store
      *  could not be read (see {@link ruleStoreUnreadable}). Written only by the gate. */
     readonly ruleCallUnreadable?: boolean;
     /** The gate's own record of the same read when a PARTITION of the store (or all of it) could not be read: a deny / ask
-     *  row inside it may forbid this call and nobody can tell — the same origin `rule_store_unavailable`, the
-     *  bypass-immune class `governance_unavailable` (a source of governance that cannot be read: only a person answers).
-     *  Exclusive with {@link ruleCallUnreadable}. Written only by the gate. */
+     *  row inside it may forbid this call and nobody can tell — the same origin and the same class as {@link ruleCallUnreadable}.
+     *  Exclusive with it. Written only by the gate. */
     readonly ruleStoreUnreadable?: boolean;
     /** Which of the gate's OWN post-fold stations minted the standing ask, if one did — again the gate's
      *  record of its own layer (a station replaces an `allow` wholesale, so at most one fires per pass),
@@ -156,6 +155,15 @@ export declare function stampAskOrigin<T extends Extract<PermissionResult, {
 }>>(decision: T, facts: AskOriginFacts, classification: AskClassification): T & {
     origin: AskOrigin;
 } & AskClassMembers;
+/**
+ * WHY an approval card offers no persisted allow rule, one word per reason — the closed set of `ruleOffersAbsence`
+ * on the ask and its park twin, written by the one offer factory: `mandated` (no persisted rule may clear the ask),
+ * `allow_outranked` (an allow-layer member already matched this call and the question outranks it), `ask_rule_matched`
+ * (an explicit `ask` rule matched: it keeps asking), `lane_cannot_speak` (a rule could clear the ask and the lane has no
+ * text for this call). The first three are {@link ruleClearanceOf}'s doors.
+ */
+export declare const RULE_OFFERS_ABSENCES: readonly ["mandated", "allow_outranked", "ask_rule_matched", "lane_cannot_speak"];
+export type RuleOffersAbsence = (typeof RULE_OFFERS_ABSENCES)[number];
 /**
  * CAN a persisted allow rule clear this ask — and, if not, which door closed? ONE derivation with TWO
  * readers, which is the whole point of the shape: the approval card's `ruleOffersAbsence` word and the
@@ -177,20 +185,20 @@ export declare function stampAskOrigin<T extends Extract<PermissionResult, {
  *    approver and this task's rule lane never adjudicates it;
  *  · the bit already stamped on the ask, which no layer below the mint may clear (tightening-only).
  *
- * And the SHADOW doors, which are not mandates: an allow-layer member already matched and is outranked
- * (`allowRuleShadowed`), or the person's explicit "ask me each time" rule matched
- * (`matchedAskRule`). A rule minted from such a card silences nothing, so the lane offers none — but
+ * And two doors that are not mandates, each its own word: an allow-layer member already matched and is outranked
+ * (`allowRuleShadowed` ⇒ `allow_outranked`), or the person's explicit "ask me each time" rule matched
+ * (`matchedAskRule` ⇒ `ask_rule_matched`). A rule minted from such a card silences nothing, so the lane offers none — but
  * the reason is that a RULE is already speaking, not that the question is beyond rules, and a surface
  * that auto-answers by posture is not crossing a mandate when it answers one.
  *
  * FOUR named readings of the one pass, because four callers need four different things and taking
  * the wrong one is how this boundary drifts:
- *  · `word` — the DISCLOSED reason, first door wins, in the display order the card has always used
- *    (governance, the shadow, the hook, the ask rule, the two ancestor doors, then the marks). Display
+ *  · `word` — the DISCLOSED reason ({@link RuleOffersAbsence}), first door wins, in the display order the card has always
+ *    used (governance, the outranked allow, the hook, the ask rule, the two ancestor doors, then the marks). Display
  *    only. A structural door the offer factory owns (no lane wired, a tool it does not speak for, a
  *    task that cannot hold a rule) is decided BEFORE this and is deliberately silent;
  *  · `mandated` — the FACT the ask carries as its own member. Read off the whole mandate set, so which
- *    door is DISPLAYED cannot change it: an ask that is both shadowed and mandated is mandated;
+ *    door is DISPLAYED cannot change it: an ask that is both outranked and mandated is mandated;
  *  · `ruleMayClear` — the ENFORCEMENT reading the gate's clearing arms take. It is `mandated` plus the
  *    person's explicit `ask` rule, and deliberately NOT `word !== undefined`: `allowRuleShadowed`
  *    is an ACCOUNT of a refusal that already happened, display-only by contract, and reading it as a
@@ -201,7 +209,7 @@ export declare function stampAskOrigin<T extends Extract<PermissionResult, {
  *    not one word.
  */
 export declare function ruleClearanceOf(ask: RuleClearanceFacts | undefined, marks: Omit<MandateMarks, "probeMandated">): {
-    word?: "mandated" | "shadowed";
+    word?: Exclude<RuleOffersAbsence, "lane_cannot_speak">;
     mandated: boolean;
     ruleMayClear: boolean;
     mandate?: PersistedRuleMandate;
@@ -347,7 +355,7 @@ export declare function mandateDisclosureOf(mandate: PersistedRuleMandate | unde
  * in {@link irreversibilityMandateOf} which {@link safetyAxisOf} shares: such a write is not an irreversible action, and
  * its park stays budgetable.
  *
- * Two consumers, one derivation: the gate's silencing arm (a matching rule is disclosed as shadowed
+ * Two consumers, one derivation: the gate's silencing arm (a matching rule is disclosed as outranked
  * instead of clearing the ask) and the runner's suggestion factory (a mandated ask offers no
  * "stop asking me this" option — a rule minted from it would never clear it). A drift between the
  * two would let a card offer a rule the lane then refuses to honor. The per-call member reaches both
@@ -379,7 +387,7 @@ export interface MandateMarks {
     targetUnresolved?: boolean;
     /** The pass's own record that the probe was consulted and did not answer (`GatePass.probeUnanswered`):
      *  the boundary is unknown, which no standing yes may stand in for. The runner's suggestion factory does
-     *  not see the pass and never passes it — a card may offer a rule the lane then discloses as shadowed
+     *  not see the pass and never passes it — a card may offer a rule the lane then discloses as outranked
      *  (loud, never a silent override), the same drift window the `matchedAskRule` conjunct already has. */
     probeUnanswered?: boolean;
 }
@@ -467,11 +475,12 @@ export type ToolMarkSource = "deployment" | "mcp_annotation" | "a2a_default";
  * working directory — or an ancestor of one): the reference implementation's dangerous-removal breaker, which no mode,
  * allow rule or classifier answers. `unverifiable_delete` is its sibling for a target the command text cannot resolve;
  * `unverifiable_shell_text` is a shell handed text the command does not spell (a program's output, a substitution, a
- * file's content, an argv a stream fills in): the engine cannot read what that shell will execute. Its row is
- * `unverifiable_delete`'s save the classifier column — such a shell was `dangerous_delete` before it had a word of its own,
- * and the classifier did not answer that.
+ * file's content, an argv a stream fills in): the engine cannot read what that shell will execute. The three read one
+ * row ({@link REMOVAL_BREAKER_ROW}).
+ * `rule_unreadable` is a rule that may govern the call and cannot be read for it: the organization's snapshot, a partition of
+ * the person's store, or this call against a deny / ask row (the lexer's word, a content row, the read station's rows).
  */
-export declare const ASK_CLASSES: readonly ["content_question", "hook", "ancestor", "dangerous_delete", "unverifiable_delete", "unverifiable_shell_text", "transcript_write", "org_rule", "governance_unavailable", "rule_unreadable", "ask_rule", "denial_limit_fallback", "classifier_no_ruling", "requires_user_interaction", "operator_forced", "shell_floor", "target_unresolved", "probe", "write_protection", "tool_marks_mcp", "tool_marks_a2a", "policy_rra", "artifact_shared_read", "mode", "unstated", "ordinary"];
+export declare const ASK_CLASSES: readonly ["content_question", "hook", "ancestor", "dangerous_delete", "unverifiable_delete", "unverifiable_shell_text", "transcript_write", "org_rule", "rule_unreadable", "ask_rule", "denial_limit_fallback", "classifier_no_ruling", "requires_user_interaction", "operator_forced", "shell_floor", "target_unresolved", "probe", "write_protection", "tool_marks_mcp", "tool_marks_a2a", "policy_rra", "artifact_shared_read", "mode", "unstated", "ordinary"];
 export type AskClass = (typeof ASK_CLASSES)[number];
 /** Membership test for {@link AskClass} — the word crosses the wire on `tool_end.gate.disposition`. */
 export declare function isAskClass(v: unknown): v is AskClass;
@@ -531,27 +540,27 @@ export declare const MODE_ARBITRATION: {
         readonly ruleMayClear: false;
         readonly hookAskFloor: false;
     };
-    readonly dangerous_delete: {
+    readonly dangerous_delete: Readonly<{
         readonly bypassImmune: true;
         readonly classifierEligible: false;
         readonly sandboxAdmission: false;
         readonly ruleMayClear: false;
         readonly hookAskFloor: true;
-    };
-    readonly unverifiable_delete: {
+    }>;
+    readonly unverifiable_delete: Readonly<{
         readonly bypassImmune: true;
-        readonly classifierEligible: true;
+        readonly classifierEligible: false;
         readonly sandboxAdmission: false;
         readonly ruleMayClear: false;
         readonly hookAskFloor: true;
-    };
-    readonly unverifiable_shell_text: {
+    }>;
+    readonly unverifiable_shell_text: Readonly<{
         readonly bypassImmune: true;
         readonly classifierEligible: false;
         readonly sandboxAdmission: false;
         readonly ruleMayClear: false;
         readonly hookAskFloor: true;
-    };
+    }>;
     readonly transcript_write: {
         readonly bypassImmune: false;
         readonly classifierEligible: true;
@@ -566,13 +575,6 @@ export declare const MODE_ARBITRATION: {
         readonly ruleMayClear: false;
         readonly hookAskFloor: false;
     };
-    readonly governance_unavailable: {
-        readonly bypassImmune: true;
-        readonly classifierEligible: false;
-        readonly sandboxAdmission: false;
-        readonly ruleMayClear: false;
-        readonly hookAskFloor: false;
-    };
     readonly rule_unreadable: {
         readonly bypassImmune: true;
         readonly classifierEligible: false;

package/dist/core/ask-origin.js

@@ -23,6 +23,7 @@ export function stampAskOrigin(decision, facts, classification) {
     const { probeReadRootCandidate: _withdrawn, ...kept } = mandated;
     return { ...kept, origin, ...classed };
 }
+export const RULE_OFFERS_ABSENCES = Object.freeze(["mandated", "allow_outranked", "ask_rule_matched", "lane_cannot_speak"]);
 export function ruleClearanceOf(ask, marks) {
     const marksWord = persistedRuleMandateOf({ ...marks, probeMandated: ask?.probeMandated === true });
     const foldedDoor = (ask?.foldedAskClasses ?? []).some((c) => !MODE_ARBITRATION[c].ruleMayClear);
@@ -34,7 +35,7 @@ export function ruleClearanceOf(ask, marks) {
         if (ask?.requiresRealApproval === true)
             return "mandated";
         if (Array.isArray(ask?.allowRuleShadowed) && ask.allowRuleShadowed.length > 0)
-            return "shadowed";
+            return "allow_outranked";
         if (ask?.decisionReason === "hook")
             return "mandated";
         if (ask?.decisionReason === "mode" || foldedDoor)
@@ -42,7 +43,7 @@ export function ruleClearanceOf(ask, marks) {
         if (ask?.authoredBy === "deployment")
             return "mandated";
         if (ask?.matchedAskRule !== undefined)
-            return "shadowed";
+            return "ask_rule_matched";
         if (ask?.inheritedUnresolved === true)
             return "mandated";
         if (ask?.ancestorResolved === true)
@@ -177,7 +178,6 @@ export const ASK_CLASSES = Object.freeze([
     "unverifiable_shell_text",
     "transcript_write",
     "org_rule",
-    "governance_unavailable",
     "rule_unreadable",
     "ask_rule",
     "denial_limit_fallback",
@@ -200,16 +200,16 @@ const ASK_CLASS_SET = new Set(ASK_CLASSES);
 export function isAskClass(v) {
     return ASK_CLASS_SET.has(v);
 }
+const REMOVAL_BREAKER_ROW = Object.freeze({ bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true });
 export const MODE_ARBITRATION = {
     content_question: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true },
     hook: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false },
     ancestor: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false },
-    dangerous_delete: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true },
-    unverifiable_delete: { bypassImmune: true, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true },
-    unverifiable_shell_text: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true },
+    dangerous_delete: REMOVAL_BREAKER_ROW,
+    unverifiable_delete: REMOVAL_BREAKER_ROW,
+    unverifiable_shell_text: REMOVAL_BREAKER_ROW,
     transcript_write: { bypassImmune: false, classifierEligible: true, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true },
     org_rule: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false },
-    governance_unavailable: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false },
     rule_unreadable: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false },
     ask_rule: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: true },
     denial_limit_fallback: { bypassImmune: true, classifierEligible: false, sandboxAdmission: false, ruleMayClear: false, hookAskFloor: false },
@@ -237,7 +237,7 @@ function bypassImmuneOn(c, face) {
     return MODE_ARBITRATION[c].bypassImmune && !(face === "shell" && RELEASED_ON_SHELL_FACE.has(c));
 }
 const CLASSIFIER_WITHHELD_ON_ROOTS = new Set(["probe"]);
-export const RRA_EXPLAINERS = new Set(["dangerous_delete", "unverifiable_delete", "unverifiable_shell_text", "transcript_write", "org_rule", "governance_unavailable", "rule_unreadable", "denial_limit_fallback", "classifier_no_ruling", "ancestor", "artifact_shared_read", "requires_user_interaction"]);
+export const RRA_EXPLAINERS = new Set(["dangerous_delete", "unverifiable_delete", "unverifiable_shell_text", "transcript_write", "org_rule", "rule_unreadable", "denial_limit_fallback", "classifier_no_ruling", "ancestor", "artifact_shared_read", "requires_user_interaction"]);
 const RELEASABLE_BY_FACE = Object.freeze({
     shell: Object.freeze(ASK_CLASSES.filter((c) => !bypassImmuneOn(c, "shell"))),
     other: Object.freeze(ASK_CLASSES.filter((c) => !bypassImmuneOn(c, "other"))),
@@ -316,9 +316,7 @@ export function classifyAsk(d, facts) {
         classes.add("ancestor");
     if (facts.org === "rule")
         classes.add("org_rule");
-    if (facts.org === "unavailable" || facts.ruleStoreUnreadable === true)
-        classes.add("governance_unavailable");
-    if (facts.ruleCallUnreadable === true)
+    if (facts.org === "unavailable" || facts.ruleStoreUnreadable === true || facts.ruleCallUnreadable === true)
         classes.add("rule_unreadable");
     const marks = facts.mandateMarks;
     if (marks.requiresUserInteraction === true)

package/dist/core/checkpoint-requirements.d.ts

@@ -290,6 +290,9 @@ export declare const PENDING_ACTION_REQUIREMENTS: {
         readonly boundGrants: {
             readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
         };
+        readonly boundGrantAbsence: {
+            readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+        };
         readonly capabilityId: {
             readonly digest: "decision-read";
         };
@@ -784,6 +787,9 @@ export declare const CHECKPOINT_REQUIREMENTS: {
                 readonly boundGrants: {
                     readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
                 };
+                readonly boundGrantAbsence: {
+                    readonly ignorable: "shown, never decided (card, listing, transcript or reported count): every read of the name renders, carries transcript or counts";
+                };
                 readonly capabilityId: {
                     readonly digest: "decision-read";
                 };

package/dist/core/checkpoint-requirements.js

@@ -114,6 +114,7 @@ export const PENDING_ACTION_REQUIREMENTS = {
         boundInputHash: DECISION_READ,
         boundGrantDigest: { word: "skill_card_binding" },
         boundGrants: SHOWN,
+        boundGrantAbsence: SHOWN,
         capabilityId: DECISION_READ,
         contractId: DECISION_READ,
         shapeDigest: DECISION_READ,

package/dist/core/checkpoint-store.d.ts

@@ -10,6 +10,7 @@ import type { WorkspaceHandle } from "./remote-env.js";
 import type { SessionPermissionRules } from "./session-policy-store.js";
 import type { NestedUsageAccum, PermissionMode, ShellGateDoctrine, TaskResult } from "./types.js";
 import type { ActiveWorktreeSession } from "../internal/harness-types.js";
+import type { ReopenReason } from "./resume-startup-cause.js";
 /**
  * design/45 — the **durable-checkpoint** primitive: cross-process / resumable `suspend`/`resume`.
  *
@@ -768,23 +769,13 @@ export type PendingAction = {
      *  — the PARK twin of `AskRequest.ruleOffersAbsence`, minted by the SAME one factory as
      *  {@link ruleOffers} so the parked card and the live card cannot answer differently. Present ⇔
      *  the rule-offer lane is in play for this call and has nothing to give, naming which door
-     *  closed: `"mandated"` (no persisted rule could ever clear this ask — a real-approval demand,
-     *  the tool's own mandate marks, a hook-raised ask, an ancestor's authority, or — #502 — a
-     *  demotion this CALL's reversibility probe declared structural, which for the built-in shell
-     *  probe means a read outside the directories the session declared; an inbox must NOT point at
-     *  rule-writing on this arm — "allow rules silence the classifier's questions, never a mandated
-     *  one" — nor at a directory grant: the subpath-rule family exists, but the out-of-root arm has
-     *  no clearing configuration in this version, so a grant minted in answer to this line would
-     *  never take effect where it was minted; confirming the call is the whole of what a person can
-     *  do about it),
-     *  `"shadowed"` (a rule the person already wrote is
-     *  speaking and does not clear it), `"lane_cannot_speak"` (this card has no rule to offer — the
-     *  grammar has no text for the command, or the card's array-order contract declines to present
-     *  the one text that exists; it is NOT a claim that no rule could ever be written).
-     *  Mutually exclusive with {@link ruleOffers}. ABSENCE is not a claim — it also covers
-     *  "there are offers" and the structural doors (no lane wired, another tool, a task that cannot
-     *  hold a rule) — so read presence. See the synchronous seat's doc for the full contract. */
-    ruleOffersAbsence?: "mandated" | "lane_cannot_speak" | "shadowed";
+     *  closed, one word of {@link import("./ask-origin.js").RULE_OFFERS_ABSENCES} per reason (`"mandated"`:
+     *  an inbox must NOT point at rule-writing nor at a directory grant on this arm — confirming the call
+     *  is the whole of what a person can do about it). Mutually exclusive with {@link ruleOffers}.
+     *  ABSENCE is not a claim — it also covers "there are offers" and the structural doors (no lane
+     *  wired, another tool, a task that cannot hold a rule) — so read presence. See the synchronous
+     *  seat's doc for the full contract. */
+    ruleOffersAbsence?: import("./ask-origin.js").RuleOffersAbsence;
     /** design/382 §2.4 (adversarial-review r3; additive — no checkpoint-version bump, the
      *  `previewWithheld` precedent: an optional field an older reader ignores and the resume
      *  path never reads) — the PARK twin of `AskRequest.execCwd`, minted by the SAME factory as
@@ -807,7 +798,7 @@ export type PendingAction = {
      *  Minted from the SAME facts object the row's rule-offer factory reads, through
      *  {@link import("./ask-origin.js").askMandateMember} (the live card's derivation). Three independent
      *  facts: {@link requiresRealApproval} (only a person — implies this one), this one (no rule), and
-     *  {@link ruleOffersAbsence} (what the offer lane has to give: silent off its tool and wiring, `"shadowed"`
+     *  {@link ruleOffersAbsence} (what the offer lane has to give: silent off its tool and wiring, `"ask_rule_matched"`
      *  when a person's rule also speaks — never a substitute for this one). Display metadata: no gate, CAS or
      *  resume path reads it. */
     mandated?: true;
@@ -856,6 +847,8 @@ export type PendingAction = {
     boundGrantDigest?: string;
     /** The value {@link boundGrantDigest} hashes — the card's twin of `AskRequest.boundGrants`, minted by the same factory; written exactly when the digest is. Display metadata (additive, no version bump): the resume judges the digest alone. */
     boundGrants?: import("./skill-grant-binding.js").BoundSkillGrants;
+    /** The PARK twin of `AskRequest.boundGrantAbsence`, minted by the same factory: written exactly when the digest is not. Display metadata. */
+    boundGrantAbsence?: import("./skill-grant-binding.js").BoundGrantAbsence;
     /**
      * design/388 §2.5 boundary ② (B18; additive — no checkpoint-version bump, the `previewWithheld`
      * precedent: an optional group an older reader ignores): the IDENTITY of the row the park minted
@@ -1602,22 +1595,8 @@ export interface ResolvedOutcome {
      *  (`when` differs per replay; the record is a consequence of the decision, not its substance). */
     gateOutcome?: import("./gate-outcome.js").GateOutcome;
 }
-/**
- * design/80 D-1: why a consumed checkpoint was {@link CheckpointStore.reopen | reopened} (resolved →
- * pending). The reason drives re-resume validation (§3 invariant #1): an `env_failed` reopen is a SYSTEM
- * RETRY of the ALREADY-APPROVED action — the re-resume MUST replay the persisted {@link ResolvedOutcome}
- * winner, never a new vote — while a `tool_unavailable` reopen (the action could not run, may now be
- * invalid — P-7) lets a human RE-DECIDE with the tool present, so a fresh operator decision IS allowed.
- *
- * `constraint_rejected` (F-012 L3) carries the same FRESH-REDECISION semantics as `tool_unavailable`:
- * a resolve was retracted because its decided INPUT failed a constraint re-adjudication (a frozen
- * ancestor projection / resume-edit policy denied the approver's edit) — the ask itself is unconsumed,
- * so the returned-to-pending row takes a fresh operator decision, never a forced replay of the
- * rejected one. Core's own edit re-adjudication runs PRE-CAS (nothing to reopen there); this reason
- * exists for a deployment lane that discovers the same rejection only after its own resolve landed
- * and must return the row to pending without inventing an out-of-vocabulary reason.
- */
-export type ReopenReason = "env_failed" | "tool_unavailable" | "constraint_rejected";
+/** Why a consumed checkpoint was reopened — declared beside the one table that picks it. */
+export { REOPEN_REASONS, type ReopenReason } from "./resume-startup-cause.js";
 /**
  * design/80 D-1 (atomicity fix): the optimistic-concurrency precondition a {@link CheckpointStore.resolve}
  * caller passes so its CAS is atomic with the validation it did against an earlier `get()` snapshot. The
@@ -2013,6 +1992,8 @@ export interface CheckpointSummary {
     boundGrantDigest?: string;
     /** The row's `boundGrants` — a fresh copy of the skill and its two lists, published only when it hashes to {@link boundGrantDigest} (never a list beside a digest that binds another). Deployment text: render with contextual escaping. ECHO-ONLY. */
     boundGrants?: import("./skill-grant-binding.js").BoundSkillGrants;
+    /** Every `tool_approval` summary carries {@link boundGrantDigest} or this, never both: the row's word when it is a member and the row has no digest, else `unreadable` (the row does not say what it binds). ECHO-ONLY. */
+    boundGrantAbsence?: import("./skill-grant-binding.js").BoundGrantAbsence;
     /** The row's `PendingAction.tool_approval.origin`, projected for the same one-call reason: a card
      *  rendered by the ask's origin word must not re-open the row to learn it. Echoed ONLY when the stored
      *  value is a member of the closed set ({@link import("./ask-origin.js").isAskOrigin}) — a bad value

package/dist/core/checkpoint-store.js

@@ -7,7 +7,7 @@ import { isAskOrigin, isPersistedRuleMandate } from "./ask-origin.js";
 import { readBoundBinding } from "./skill-grant-binding.js";
 import { checkpointExecutionRecorded, executionRecordDisposition, ExecutionOutcomeConflictError, } from "./checkpoint-execution-record.js";
 import { renderUntrustedCommandText, stripFormatCharacters } from "./permission-rule-model.js";
-import { redactSecrets } from "./untrusted-egress.js";
+import { egressText } from "./untrusted-egress.js";
 import { steerReplayRefusal } from "./steer-replay.js";
 import { isToolApprovalCard } from "./tool-face.js";
 import { isPermissionMode } from "./ask-origin.js";
@@ -131,7 +131,7 @@ export function buildRiskDescriptor(input) {
         if (shell || toolName === "Bash") {
             const cmd = isPlainRecord(args) ? safeDataValue(args, "command") : undefined;
             if (typeof cmd === "string" && cmd.length > 0)
-                summary = renderUntrustedCommandText(stripFormatCharacters(redactSecrets(cmd)), SUMMARY_CMD_MAX);
+                summary = renderUntrustedCommandText(stripFormatCharacters(egressText("same-principal", cmd)), SUMMARY_CMD_MAX);
             const bg = isPlainRecord(args) ? safeDataValue(args, "run_in_background") : undefined;
             if (bg === true)
                 summary = `[background persistent process — no per-step recheck] ${summary ?? ""}`.trimEnd();
@@ -146,7 +146,7 @@ export function buildRiskDescriptor(input) {
                     if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
                         const encDigest = (s) => s.replace(/%/g, "%25").replace(/=/g, "%3D").replace(/ /g, "%20");
                         const k = encDigest(renderUntrustedCommandText(key, 40));
-                        const val = encDigest(renderUntrustedCommandText(stripFormatCharacters(redactSecrets(String(v))), SUMMARY_VALUE_MAX));
+                        const val = encDigest(renderUntrustedCommandText(stripFormatCharacters(egressText("same-principal", String(v))), SUMMARY_VALUE_MAX));
                         parts.push(`${k}=${val}`);
                     }
                 }
@@ -247,6 +247,7 @@ export function remainingTokens(ledger) {
         return 0;
     return Math.max(0, total - (spent ?? 0));
 }
+export { REOPEN_REASONS } from "./resume-startup-cause.js";
 export function summarizeCheckpoint(cp) {
     const riskDescriptor = cp.gate.kind === "human" || cp.gate.kind === "irreversible_ask" ? cp.gate.riskDescriptor : undefined;
     const severity = riskDescriptor !== undefined ? riskSeverity(riskDescriptor.axes) : undefined;
@@ -300,7 +301,7 @@ export function summarizeCheckpoint(cp) {
             const why = tool?.classifierNoRuling;
             return { ...(isAskOrigin(origin) ? { origin } : {}), ...(isPersistedRuleMandate(mandate) ? { mandate } : {}), ...(isAutoModeFallbackCause(why) ? { classifierNoRuling: why } : {}) };
         })(),
-        ...readBoundBinding(tool),
+        ...(tool !== undefined ? readBoundBinding(tool) : {}),
         ...(hasBidi ? { hasBidiControls: true } : {}),
     };
 }

package/dist/core/classifier-unavailable-arm.d.ts

@@ -3,8 +3,8 @@
  * budget ran out — `error` / `timeout` — or it replied with no verdict at all — `parse_error`) — shared by both classifier
  * stations, the leg's gate and an ancestor's frozen classifier in the policy fold, so the rule is written once.
  *
- * ONE fork, on the APPROVAL SEAT (does an ask this station hands on reach a person — a live approver, or a durable park):
- * with one, the ask goes on carrying why (`classifierNoRuling`, its text saying it too), and a person decides — never
+ * ONE fork, on the APPROVAL ROUTE the station states (`ApprovalRoute`, the one seat decision — `live_approver`,
+ * `durable_park` or `none`): with a person on the route, the ask goes on carrying why (`classifierNoRuling`, its text saying it too), and a person decides — never
  * counted (a person's refusal of it is a person's); without one, an unavailable classification is refused with CC's `x1t`
  * sentence (its FORM, `unavailable`, attested on the deny) and is never counted, while a reply with no verdict goes back to
  * the station's ruling path (`counted`): refused with its own sentence and counted on the denial limit, so the bound falls
@@ -18,22 +18,26 @@
 import { type AutoModeClassifierRound, type AutoModeDenialTracker, type AutoModeFallbackCause, type UnarmedDenialLimitFallback } from "./auto-mode.js";
 import { type PermissionResult, type ResolvedAsk, type ToolCallRequest } from "./tool-policy.js";
 import type { Settlement } from "./gate-outcome.js";
-/** Where a classification that did not rule sent the call: `asked` = on to the approval seat, `denied` = refused. */
+import type { ApprovalRoute } from "./wiring-manifest.js";
+/** Where a classification that did not rule sent the call: `asked` = on to the approval seat, `denied` = refused — the
+ *  projection of the route ({@link classifierUnavailableDispositionOf}), never a second reading of it. */
 export type ClassifierUnavailableDisposition = "asked" | "denied";
+/** The disposition a route projects: a route with a person on it is `asked`, `none` is `denied`. */
+export declare function classifierUnavailableDispositionOf(route: ApprovalRoute): ClassifierUnavailableDisposition;
 /** What the stations' observer receives — the facts the `classifier.unavailable` notice is composed from. `cause` is why
  *  the classification did not rule ({@link AutoModeFallbackCause}: `error` / `timeout`, or `parse_error` for a reply with no
- *  verdict). */
+ *  verdict); `route` is where the station sent the call (the disposition the notice's detail carries is its projection). */
 export interface ClassifierUnavailableInfo {
     toolName: string;
     toolCallId: string;
     cause: AutoModeFallbackCause;
-    disposition: ClassifierUnavailableDisposition;
+    route: ApprovalRoute;
 }
 export type ClassifierUnavailableObserver = (info: ClassifierUnavailableInfo) => void;
-/** The station's two facts for the fork: whether an ask it hands on reaches a person (`true` only — anything else is
- *  no seat), and who hears it. */
+/** The station's two facts for the fork: the route an ask it hands on takes (`approvalRouteOf` / `frozenApproverRoute` —
+ *  a value outside the two person routes, or none stated, is `none`), and who hears it. */
 export interface ClassifierUnavailableSeat {
-    approvalSeat?: boolean;
+    route?: ApprovalRoute;
     onUnavailable?: ClassifierUnavailableObserver;
 }
 /** The arm the fork chose: the ask to hand on, the refusal, or — a reply with no verdict and no seat — the station's own

package/dist/core/classifier-unavailable-arm.js

@@ -1,11 +1,16 @@
 import { classifierNoRulingAskMessage, classifierUnavailableDenyMessage } from "./auto-mode.js";
 import { attest } from "./tool-policy.js";
+export function classifierUnavailableDispositionOf(route) {
+    return route === "none" ? "denied" : "asked";
+}
+const routeOfSeat = (seat) => (seat?.route === "live_approver" || seat?.route === "durable_park" ? seat.route : "none");
 export function classifierNoRulingArm(args) {
     const { ask, req, cause } = args;
-    const seated = args.seat?.approvalSeat === true;
+    const route = routeOfSeat(args.seat);
+    const seated = route !== "none";
     if (!args.aborted) {
         try {
-            args.seat?.onUnavailable?.({ toolName: req.toolName, toolCallId: req.toolCallId, cause, disposition: seated ? "asked" : "denied" });
+            args.seat?.onUnavailable?.({ toolName: req.toolName, toolCallId: req.toolCallId, cause, route });
         }
         catch {
         }

package/dist/core/credential-vocabulary.d.ts

@@ -115,8 +115,9 @@ export interface EnvNameView {
     /** A credential word in its position, case-insensitive. */
     readonly credentialWord: RegExp;
     readonly connectionStringName: RegExp;
-    /** The counted plurals as a regex source (a plural no count word touches). */
-    readonly countedPlural: string;
+    /** A credential word that is a whole `_` segment of a name (every position but `embedded`; a counted plural no count
+     *  word touches), as a regex source. */
+    readonly segmentWord: string;
     readonly tokenPrefix: RegExp;
 }
 export declare function envNameView(vocabulary: CredentialVocabulary): EnvNameView;

package/dist/core/credential-vocabulary.js

@@ -8,8 +8,10 @@ const PLAIN_QUOTES = [`"`, `'`, `"`, `'`, `"`, `'`, `%22`, `%2
 const ESCAPED_QUOTES = [`"`, `'`, `x22`, `x27`, `u0022`, `u0027`, `042`, `047`];
 const BACKSLASHES = String.raw `\\{1,${ESCAPE_DEPTH}}`;
 const QUOTE = `(?:${PLAIN_QUOTES.join("|")}|${BACKSLASHES}(?:${ESCAPED_QUOTES.join("|")}))`;
+const WORD_START = `(?:(?<![A-Za-z0-9])|(?<=${QUOTE}))`;
 const AFTER_CLOSING_QUOTE = String.raw `(?:[\s,}\]:]|["']|$)`;
-const GLUED_RUN = `${VALUE_CHAR}*(?:(?<!\\\\)|(?!\\\\{0,${ESCAPE_DEPTH}}["']))`;
+const VALUE_RUN_END = `(?:(?<!\\\\)|(?!\\\\{0,${ESCAPE_DEPTH}}["']))`;
+const GLUED_RUN = `${VALUE_CHAR}*${VALUE_RUN_END}`;
 const pairedValue = (open, close) => `${open}(?!${AFTER_CLOSING_QUOTE})[^\\n]{0,${QUOTED_VALUE_MAX}}?${close}`;
 const QUOTED_VALUE = [
     ...PLAIN_QUOTES.map((q) => pairedValue(q, q)),
@@ -17,29 +19,35 @@ const QUOTED_VALUE = [
     `${QUOTE}(?!${AFTER_CLOSING_QUOTE})${GLUED_RUN}`,
 ].join("|");
 const BEARER_TAIL = `(?:(?!${QUOTE})\\S${GLUED_RUN}|(?<==)(?:${QUOTED_VALUE}))`;
+const HEADER_PARAM = String.raw `=[ \t]*(\\{0,${ESCAPE_DEPTH}})(["'])(?:(?!(?<!\\)\2\3)[^\r\n])*(?:(?<!\\)\2\3(?=[\s,;]|\\{0,${ESCAPE_DEPTH}}["']|$)|(?=[\r\n]|$))`;
+const HEADER_VALUE = String.raw `(?:[A-Za-z][A-Za-z0-9!#$%&*+.^_|~-]*[ \t]+)?(?:${HEADER_PARAM}|[^\s"',]|[ \t]*,[ \t]*(?=[^\s"',])|[ \t]+(?==)|(?<==)[ \t]+(?=[^\s"',]))+${VALUE_RUN_END}`;
+const headed = (body, flags = "g") => new RegExp(`${WORD_START}${body}`, flags);
 export const CREDENTIAL_VOCABULARY = {
     values: [
-        { id: "github-token", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: new RegExp(`(?<![A-Za-z0-9])gh[opsur][-_]${VENDOR_BODY}`, "g"), strict: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}\b/ },
-        { id: "github-fine-grained-pat", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: new RegExp(`(?<![A-Za-z0-9])github_pat[-_]${VENDOR_BODY}`, "g"), strict: /\bgithub_pat_[A-Za-z0-9_]{60,}\b/ },
-        { id: "openai-api-key", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: new RegExp(`(?<![A-Za-z0-9])sk-${VENDOR_BODY}`, "g"), strict: /\bsk-(?:ant-(?:api03-)?|proj-)?[A-Za-z0-9_]{20,}\b/ },
-        { id: "stripe-secret-key", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: new RegExp(`(?<![A-Za-z0-9])(?:sk_|rk[-_])${VENDOR_BODY}`, "g"), strict: /\b[sr]k_(?:live|test)_[A-Za-z0-9]{24,}\b/ },
-        { id: "stripe-publishable-key", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: new RegExp(`(?<![A-Za-z0-9])pk[-_]${VENDOR_BODY}`, "g") },
-        { id: "gitlab-pat", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: /(?<![A-Za-z0-9])glpat-[A-Za-z0-9_-]{20,}/g },
-        { id: "google-api-key", kind: "prefixed-token", source: "arg-summary", confidence: "high", match: /(?<![A-Za-z0-9])AIza[A-Za-z0-9_-]{20,}/g, strict: /\bAIza[0-9A-Za-z_-]{35}\b/ },
-        { id: "slack-token", kind: "prefixed-token", source: "arg-summary", confidence: "high", match: /(?<![A-Za-z0-9])xox[baprs]-[A-Za-z0-9-]{10,}/g, strict: /\bxox[baprs]-(?:[A-Za-z0-9]+-){1,3}[A-Za-z0-9]{16,}\b/ },
-        { id: "aws-access-key-id", kind: "prefixed-token", source: "arg-summary", confidence: "high", match: /(?<![A-Za-z0-9])(?:AKIA|ASIA)[0-9A-Z]{12,}/g, strict: /\bAKIA[0-9A-Z]{16}\b/ },
-        { id: "huggingface-token", kind: "prefixed-token", source: "arg-summary", confidence: "high", match: /(?<![A-Za-z0-9])hf_[A-Za-z0-9]{20,}/g, strict: /\bhf_(?=[A-Za-z0-9]*[0-9])[A-Za-z0-9]{20,}\b/ },
-        { id: "jwt", kind: "jwt", source: "arg-summary", confidence: "high", match: /(?<![A-Za-z0-9])eyJ[A-Za-z0-9._-]{20,}/g, strict: /\beyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]{16,}\b/ },
+        { id: "github-token", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: headed(`gh[opsur][-_]${VENDOR_BODY}`), strict: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}\b/ },
+        { id: "github-fine-grained-pat", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: headed(`github_pat[-_]${VENDOR_BODY}`), strict: /\bgithub_pat_[A-Za-z0-9_]{60,}\b/ },
+        { id: "openai-api-key", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: headed(`sk-${VENDOR_BODY}`), strict: /\bsk-(?:ant-(?:api03-)?|proj-)?[A-Za-z0-9_]{20,}\b/ },
+        { id: "stripe-secret-key", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: headed(`(?:sk_|rk[-_])${VENDOR_BODY}`), strict: /\b[sr]k_(?:live|test)_[A-Za-z0-9]{24,}\b/ },
+        { id: "stripe-publishable-key", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: headed(`pk[-_]${VENDOR_BODY}`) },
+        { id: "gitlab-pat", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: headed("glpat-[A-Za-z0-9_-]{20,}") },
+        { id: "npm-access-token", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: headed("npm_[A-Za-z0-9]{36,}") },
+        { id: "google-oauth-access-token", kind: "prefixed-token", source: "arg-summary", confidence: "high", pass: "vendor-prefixed", match: headed(String.raw `ya29\.[A-Za-z0-9_.-]{20,}`) },
+        { id: "google-api-key", kind: "prefixed-token", source: "arg-summary", confidence: "high", match: headed("AIza[A-Za-z0-9_-]{20,}"), strict: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+        { id: "slack-token", kind: "prefixed-token", source: "arg-summary", confidence: "high", match: headed("xox[baprs]-[A-Za-z0-9-]{10,}"), strict: /\bxox[baprs]-(?:[A-Za-z0-9]+-){1,3}[A-Za-z0-9]{16,}\b/ },
+        { id: "aws-access-key-id", kind: "prefixed-token", source: "arg-summary", confidence: "high", match: headed("(?:A3T[A-Z0-9]|AKIA|ASIA|ABIA|ACCA)[0-9A-Z]{12,}"), strict: /\bAKIA[0-9A-Z]{16}\b/ },
+        { id: "huggingface-token", kind: "prefixed-token", source: "arg-summary", confidence: "high", match: headed("hf_[A-Za-z0-9]{20,}"), strict: /\bhf_(?=[A-Za-z0-9]*[0-9])[A-Za-z0-9]{20,}\b/ },
+        { id: "jwt", kind: "jwt", source: "arg-summary", confidence: "high", match: headed("eyJ[A-Za-z0-9._-]{20,}"), strict: /\beyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]{16,}\b/ },
         { id: "private-key", kind: "private-key-block", source: "arg-summary", confidence: "high", match: /-----BEGIN[ A-Z0-9]*PRIVATE KEY(?: BLOCK)?-----[\s\S]*?(?:-----END[ A-Z0-9]*PRIVATE KEY(?: BLOCK)?-----|$)/g, strict: /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----/ },
-        { id: "bearer-token", kind: "bearer-token", source: "arg-summary", confidence: "high", match: new RegExp(String.raw `(?<![A-Za-z0-9])()[Bb][Ee][Aa][Rr][Ee][Rr]\s+[A-Za-z0-9._~+/-]{8,}=*(?:${BEARER_TAIL})?`, "g"), strict: /\bAuthorization:\s*Bearer\s+(?=[A-Za-z0-9._~+/-]*[0-9])[A-Za-z0-9._~+/-]{20,}=*/ },
+        { id: "bearer-token", kind: "bearer-token", source: "arg-summary", confidence: "high", match: headed(String.raw `()[Bb][Ee][Aa][Rr][Ee][Rr]\s+[A-Za-z0-9._~+/-]{8,}=*(?:${BEARER_TAIL})?`), strict: /\bAuthorization:\s*Bearer\s+(?=[A-Za-z0-9._~+/-]*[0-9])[A-Za-z0-9._~+/-]{20,}=*/ },
+        { id: "authorization-header", kind: "authorization-header", source: "arg-summary", confidence: "high", match: headed(String.raw `(authorization(?:\\{0,${ESCAPE_DEPTH}}["'])?[ \t]*[=:][ \t]*(?:\\{0,${ESCAPE_DEPTH}}["'])?)${HEADER_VALUE}`, "gi") },
         { id: "azure-storage-account-key", kind: "prefixed-token", source: "arg-summary", confidence: "high", match: /(AccountKey=)[A-Za-z0-9+/]{40,}={0,2}/g, strict: /AccountKey=[A-Za-z0-9+/]{40,}={0,2}/ },
-        { id: "keyword-value", kind: "keyword-value", source: "arg-summary", confidence: "medium", match: new RegExp(String.raw `(?<![A-Za-z0-9])((?:token|secret|key|password|passwd|credential|authorization)["']?\s*[=:]\s*["']?)${VALUE_CHAR}{4,}`, "gi") },
+        { id: "keyword-value", kind: "keyword-value", source: "arg-summary", confidence: "medium", match: headed(String.raw `((?:token|secret|key|password|passwd|credential)["']?\s*[=:]\s*["']?)${VALUE_CHAR}{4,}${VALUE_RUN_END}`, "gi") },
         { id: "url-userinfo", kind: "url-credentials", source: "untrusted-egress", confidence: "medium", match: new RegExp(String.raw `(${URI_SCHEME_SOURCE}:\/\/)((?:[^/\s"'@]*@)+)`, "gi") },
         { id: "signed-url-param", kind: "signed-url-param", source: "untrusted-egress", confidence: "high", match: /([?&#](?:sig|signature|sas|code)=)[^&\s"'#]+/gi },
     ],
     words: [
         ...["TOKEN", "SECRET", "PASSWORD", "PASSWD", "PASSPHRASE", "KEY"].map((word) => ({ word, position: "leading" })),
-        { word: "AUTH", position: "leading", recordKeys: ["AUTHORIZATION"] },
+        { word: "AUTH", position: "leading", recordKeys: ["AUTHORIZATION", "AUTHENTICATION", "OAUTH", "AUTHN", "AUTHZ"] },
         ...["COOKIE", "PAT", "DSN", "WEBHOOK", "CREDENTIAL", "CREDENTIALS", "CREDS", "APIKEY", "ACCESSKEY", "SECRETKEY", "ACCOUNTKEY", "PRIVATEKEY", "AUTHKEY", "SSHKEY", "SIGNINGKEY", "MASTERKEY", "DEPLOYKEY", "ENCRYPTIONKEY", "PGPASSWORD", "SSHPASS"].map((word) => ({ word, position: "leading" })),
         ...["KEY", "SECRET", "PASSWORD", "CREDENTIAL"].map((word) => ({ word, position: "plural" })),
         { word: "TOKEN", position: "counted-plural" },
@@ -109,10 +117,11 @@ function credentialWordPattern(countWords, rows) {
         ...(separated.length > 0 ? [`_(${separated.join("|")})`] : []),
         ...(embedded.length > 0 ? [`(${embedded.join("|")})`] : []),
     ];
-    return { credentialWord: new RegExp(`(${positions.join("|")})(?=$|[_0-9])`, "i"), countedPlural };
+    const segmentWord = `(?:${[...at("leading"), ...at("plural").map((w) => `${w}S`), ...separated, countedPlural].join("|")})`;
+    return { credentialWord: new RegExp(`(${positions.join("|")})(?=$|[_0-9])`, "i"), segmentWord };
 }
 export function envNameView(vocabulary) {
-    const { credentialWord, countedPlural } = credentialWordPattern(vocabulary.countWords, vocabulary.words);
+    const { credentialWord, segmentWord } = credentialWordPattern(vocabulary.countWords, vocabulary.words);
     return {
         exactNames: new Set(vocabulary.exactEnvNames.flatMap((name) => [name, `INPUT_${name}`])),
         nonSecretExactNames: new Set(vocabulary.nonSecretExactNames),
@@ -120,7 +129,7 @@ export function envNameView(vocabulary) {
         nonCredentialPrefix: vocabulary.nonCredentialPrefix,
         credentialWord,
         connectionStringName: vocabulary.connectionStringName,
-        countedPlural,
+        segmentWord,
         tokenPrefix: vocabulary.tokenPrefix,
     };
 }