pi-fold 1.0.2 → 1.0.4

package/extensions/lib/persistence.ts

@@ -22,8 +22,11 @@ import {
   EXPAND_LEASE_GENERATIONS,
   MAX_ADVISORY_DELIVERIES_PER_MILESTONE,
   MAX_EXPAND_LEASES,
+  MAX_LAST_CALL_TEXT_BYTES,
   MAX_PENDING_MARKS,
-  SURFACING_MAX_LOG_RECORDS,
+  MAX_THRESHOLD_NOTICE_TEXT_BYTES,
+  MAX_THRESHOLD_NOTICES,
+  SURFACING_MAX_LEDGER_RECORDS,
 } from "./policy.ts";
 import type {
   ActiveContextCheckpointV2,
@@ -32,6 +35,7 @@ import type {
   ActiveContextStateWireV2,
   ActiveFold,
   AdvisoryMilestone,
+  BriefOverride,
   BriefProvenance,
   FoldKind,
   FoldPart,
@@ -54,8 +58,8 @@ export const PREPARED_FOLD_KEYS = [
 export const ACTIVE_STATE_KEYS = ["version", "sessionId", "revision", "folds", "expanded", "protected"] as const;
 export const FOLD_RECORD_REF_KEYS = ["id", "sha256"] as const;
 export const FOLD_RECORD_ENTRY_KEYS = ["version", "sessionId", "foldId", "recordSha256", "fold"] as const;
-export const SURFACING_RECORD_KEYS = ["source", "id", "score", "ordinal", "outcome"] as const;
-export const SURFACING_OUTCOMES = Object.freeze(["shown", "accept", "reject"] as const);
+export const SURFACING_RECORD_KEYS = ["id", "surfaced", "taken", "ordinal", "outcome"] as const;
+export const SURFACING_OUTCOMES = Object.freeze(["shown", "acted", "used", "ignored"] as const);
 export const PENDING_FOLD_MARK_KEYS = [
   "mark", "id", "kind", "parts", "brief", "briefProvenance", "origin", "ordinal",
 ] as const;
@@ -81,18 +85,21 @@ export function validTokensSinceToolFold(value: unknown): value is number {
 
 export function validSurfacingRecord(value: unknown): value is SurfacingRecord {
   if (!exactRecord(value, SURFACING_RECORD_KEYS)) return false;
-  const score = ownValue(value, "score");
-  return typeof ownValue(value, "source") === "string" && Boolean(ownValue(value, "source")) &&
-    typeof ownValue(value, "id") === "string" && Boolean(ownValue(value, "id")) &&
-    typeof score === "number" && Number.isFinite(score) && Number(score) >= 0 && Number(score) <= 1 &&
+  const surfaced = ownValue(value, "surfaced");
+  const taken = ownValue(value, "taken");
+  return typeof ownValue(value, "id") === "string" && Boolean(ownValue(value, "id")) &&
+    Number.isSafeInteger(surfaced) && Number(surfaced) > 0 &&
+    Number.isSafeInteger(taken) && Number(taken) >= 0 && Number(taken) <= Number(surfaced) &&
     Number.isSafeInteger(ownValue(value, "ordinal")) && Number(ownValue(value, "ordinal")) >= 0 &&
     SURFACING_OUTCOMES.includes(ownValue(value, "outcome") as SurfacingRecord["outcome"]);
 }
 
+/** One record per fold: a duplicate id is a ledger that forgot an ignore. */
 export function parseSurfacingLog(value: unknown): SurfacingRecord[] {
   const records = denseOwnArrayValues(value);
-  if (!records || records.length > SURFACING_MAX_LOG_RECORDS || !records.every(validSurfacingRecord)) {
-    throw new Error("Invalid active-context surfacing log");
+  if (!records || records.length > SURFACING_MAX_LEDGER_RECORDS || !records.every(validSurfacingRecord) ||
+      new Set(records.map((record) => (record as SurfacingRecord).id)).size !== records.length) {
+    throw new Error("Invalid active-context surfacing ledger");
   }
   return clone(records) as SurfacingRecord[];
 }
@@ -125,20 +132,41 @@ export function validPendingMark(value: unknown): value is PendingMark {
  * supplied brief obeys, and refused for a fold that is not in the forest, exactly
  * like a pin or a refold mark naming a missing fold.
  */
+/**
+ * A model brief written after the fold committed carries its generator with it, so an
+ * override is either the bare corrected string the agent wrote or that string beside the
+ * attribution. Two shapes, one map: the string form is what every state written before
+ * the upgrade lane existed holds, and it must keep parsing and keep its exact digest.
+ */
+export function briefOverrideText(override: unknown): string | null {
+  if (typeof override === "string") return override;
+  const brief = ownValue(override, "brief");
+  return typeof brief === "string" ? brief : null;
+}
+
 export function parseBriefOverrides(
   value: unknown,
   ids?: ReadonlySet<string>,
-): Record<string, string> {
+): Record<string, BriefOverride> {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("Invalid active-context brief overrides");
   }
   const entries = Object.entries(value as Record<string, unknown>);
+  const validOverride = (override: unknown): boolean => {
+    const brief = briefOverrideText(override);
+    if (typeof brief !== "string" || !brief.trim() ||
+        brief.length > ACTIVE_CONTEXT_POLICY.maxBriefChars) return false;
+    if (typeof override === "string") return true;
+    return exactRecord(override, ["brief", "provenance"]) &&
+      validProvenance(ownValue(override, "provenance"));
+  };
   if (entries.length > MAX_ACTIVE_FOLD_RECORDS ||
-      entries.some(([id, brief]) => !id || typeof brief !== "string" || !brief.trim() ||
-        brief.length > ACTIVE_CONTEXT_POLICY.maxBriefChars || (ids && !ids.has(id)))) {
+      entries.some(([id, override]) => !id || !validOverride(override) || (ids && !ids.has(id)))) {
     throw new Error("Invalid active-context brief overrides");
   }
-  return Object.fromEntries(entries.sort(([left], [right]) => left.localeCompare(right))) as Record<string, string>;
+  return Object.fromEntries(
+    entries.sort(([left], [right]) => left.localeCompare(right)),
+  ) as Record<string, BriefOverride>;
 }
 
 /** The brief a fold PRESENTS: the agent's correction when it made one, else the record's. */
@@ -146,7 +174,23 @@ export function foldBrief(
   fold: Pick<ActiveFold, "id" | "brief">,
   state: Pick<ActiveContextState, "briefs">,
 ): string {
-  return state.briefs?.[fold.id] ?? fold.brief;
+  return briefOverrideText(state.briefs?.[fold.id]) ?? fold.brief;
+}
+
+/**
+ * The provenance a fold PRESENTS. A fold RECORD is immutable, so a brief written after
+ * the commit lives in the override map and its attribution travels with it; without this
+ * lens a model-written upgrade would report the provenance of the brief it replaced.
+ */
+export function foldProvenance(
+  fold: Pick<ActiveFold, "id" | "provenance">,
+  state: Pick<ActiveContextState, "briefs">,
+): BriefProvenance {
+  const override = state.briefs?.[fold.id];
+  const provenance = typeof override === "object" && override
+    ? ownValue(override, "provenance")
+    : undefined;
+  return normalizeLegacyProvenance(provenance ?? fold.provenance);
 }
 
 export function parsePendingMarks(value: unknown): PendingMark[] {
@@ -237,7 +281,12 @@ export function foldMap(state: Pick<ActiveContextState, "folds">): Map<string, A
   return new Map(state.folds.map((fold) => [fold.id, fold]));
 }
 
-export function childFoldIds(fold: ActiveFold): string[] {
+/**
+ * The folds a span names as children. Read off the parts alone, so a PENDING fold mark
+ * answers it too: a mark carries the id its committed fold will get, so the ids here are
+ * exactly the folds that must already exist when this span applies.
+ */
+export function childFoldIds(fold: Pick<ActiveFold, "parts">): string[] {
   return fold.parts.filter((part): part is Extract<FoldPart, { kind: "fold" }> => part.kind === "fold")
     .map((part) => part.foldId);
 }
@@ -260,6 +309,33 @@ export function flattenFoldRefs(fold: ActiveFold, state: Pick<ActiveContextState
   return visit(fold);
 }
 
+/**
+ * Which fold DIRECTLY owns each raw evidence key.
+ *
+ * One derivation, two readers (Shane 2026-08-11). The forest invariant below reads it to
+ * reject a second owner, and the agent-facing candidate builder reads it BEFORE it builds
+ * anything, so a span naming evidence some fold already holds comes back as a refusal
+ * that names the owner instead of this invariant escaping the tool call as an exception.
+ *
+ * The two readings stay distinguishable because the input differs. Called on the folds
+ * already in state it can only throw when the stored forest is itself corrupt, which no
+ * agent input can produce: every state reaches storage through `validateFoldForest`.
+ * Called on a forest that includes a candidate the caller just built, a duplicate means
+ * the REQUEST collided with an existing fold, and that is the refusal case.
+ */
+export function directFoldOwners(folds: readonly ActiveFold[]): Map<string, string> {
+  const owner = new Map<string, string>();
+  for (const fold of folds) {
+    for (const part of fold.parts) {
+      if (part.kind !== "raw") continue;
+      const key = objectRefKey(part.ref);
+      if (owner.has(key)) throw new Error(`Evidence ${part.ref.entryId} has multiple direct fold owners`);
+      owner.set(key, fold.id);
+    }
+  }
+  return owner;
+}
+
 export function validateFoldForest(folds: ActiveFold[]): ActiveFold[] {
   const rawValues = denseOwnArrayValues(folds);
   if (!rawValues || rawValues.some((fold) => !validFoldShape(fold))) {
@@ -275,20 +351,28 @@ export function validateFoldForest(folds: ActiveFold[]): ActiveFold[] {
         (!fold.parts.length || fold.parts.some((part) => part.kind !== "raw" || part.ref.role !== "toolResult"))) {
       throw new Error("Tool-result fold must own one validated assistant batch of tool results");
     }
-    if (fold.kind === "consolidation" && fold.parts.some((part) => part.kind !== "fold")) {
-      throw new Error("Consolidation folds may contain only child folds");
+    // WHAT A PARENT IS, RE-DERIVED UNDER THE COUNT LAW (Shane 2026-08-10).
+    //
+    // Two shape rules stood here and both described the old approximation. "Only child
+    // folds" forbade the raw gaps between children, and a parent's span runs from its
+    // first child to its last one, so the gap material inside it is the parent's or the
+    // span is not a span. "Only chapter or consolidation children" forbade tool-result
+    // children, which was true while a bare tool batch nested through a chapter span;
+    // automatic chapters no longer take placeholders at any count, so that rule would
+    // now leave every tool fold as an obstacle no parent could ever reclaim.
+    //
+    // What survives is the one thing that makes a consolidation a consolidation: it
+    // groups folds. A parent with no child fold is a chapter wearing the wrong name.
+    if (fold.kind === "consolidation" && !fold.parts.some((part) => part.kind === "fold")) {
+      throw new Error("Consolidation folds must contain at least one child fold");
     }
     byId.set(fold.id, fold);
   }
+  directFoldOwners(values);
   const parent = new Map<string, string>();
-  const rawOwner = new Map<string, string>();
   for (const fold of values) {
     for (const part of fold.parts) {
-      if (part.kind === "raw") {
-        const key = objectRefKey(part.ref);
-        if (rawOwner.has(key)) throw new Error(`Evidence ${part.ref.entryId} has multiple direct fold owners`);
-        rawOwner.set(key, fold.id);
-      } else {
+      if (part.kind === "fold") {
         if (!byId.has(part.foldId) || part.foldId === fold.id || parent.has(part.foldId)) {
           throw new Error(`Invalid or multiply owned child fold ${part.foldId}`);
         }
@@ -298,15 +382,6 @@ export function validateFoldForest(folds: ActiveFold[]): ActiveFold[] {
   }
   for (const fold of values) {
     if ((parent.get(fold.id) ?? null) !== fold.parentId) throw new Error(`Fold ${fold.id} parent drift`);
-    for (const childId of childFoldIds(fold)) {
-      const child = byId.get(childId)!;
-      if (fold.kind === "chapter" && child.kind !== "tool-result") {
-        throw new Error(`Chapter ${fold.id} may contain only tool-result folds`);
-      }
-      if (fold.kind === "consolidation" && child.kind === "tool-result") {
-        throw new Error(`Consolidation ${fold.id} may contain only chapter or consolidation folds`);
-      }
-    }
   }
   for (const fold of values) {
     const refs = flattenFoldRefs(fold, { folds: values });
@@ -334,6 +409,9 @@ export function parseActiveContextState(
   // rejecting it here would suspend automatic management on upgrade.
   const hasPinnedPeeks = recordLike && Object.prototype.hasOwnProperty.call(value, "pinnedPeeks");
   const hasBriefs = recordLike && Object.prototype.hasOwnProperty.call(value, "briefs");
+  const hasRider = recordLike && Object.prototype.hasOwnProperty.call(value, "rider");
+  const hasLastCall = recordLike && Object.prototype.hasOwnProperty.call(value, "lastCall");
+  const hasNotices = recordLike && Object.prototype.hasOwnProperty.call(value, "notices");
   const extraKeys = [
     ...(hasPrepared ? ["prepared"] : []),
     ...(hasAdvisory ? ["advisory"] : []),
@@ -343,6 +421,9 @@ export function parseActiveContextState(
     ...(hasPendingMarks ? ["pendingMarks"] : []),
     ...(hasPinnedPeeks ? ["pinnedPeeks"] : []),
     ...(hasBriefs ? ["briefs"] : []),
+    ...(hasRider ? ["rider"] : []),
+    ...(hasLastCall ? ["lastCall"] : []),
+    ...(hasNotices ? ["notices"] : []),
   ];
   if (!exactRecord(value, [...ACTIVE_STATE_KEYS, ...extraKeys])) throw new Error("Invalid active-context state keys");
   const folds = denseOwnArrayValues(ownValue(value, "folds"));
@@ -364,6 +445,15 @@ export function parseActiveContextState(
   if (hasAdvisory && !validAdvisoryState(ownValue(value, "advisory"))) {
     throw new Error("Invalid active-context advisory state");
   }
+  if (hasRider && !validRiderState(ownValue(value, "rider"))) {
+    throw new Error("Invalid active-context rider state");
+  }
+  if (hasLastCall && !validLastCallState(ownValue(value, "lastCall"))) {
+    throw new Error("Invalid active-context last-call state");
+  }
+  if (hasNotices && !validNoticesState(ownValue(value, "notices"))) {
+    throw new Error("Invalid active-context notices state");
+  }
   if (hasTokensSinceToolFold && !validTokensSinceToolFold(ownValue(value, "tokensSinceToolFold"))) {
     throw new Error("Invalid active-context tool-fold cadence");
   }
@@ -397,6 +487,9 @@ export function parseActiveContextState(
     ...(hasAdvisory
       ? { advisory: clone(source.advisory!) }
       : defaultAdvisory ? { advisory: { highWater: 0, delivered: {} } } : {}),
+    ...(hasRider ? { rider: clone(source.rider!) } : {}),
+    ...(hasLastCall ? { lastCall: clone(source.lastCall!) } : {}),
+    ...(hasNotices ? { notices: clone(source.notices!) } : {}),
     ...(hasPrepared ? { prepared: clone(source.prepared!) } : {}),
   };
 }
@@ -515,11 +608,17 @@ export function validateV2ProjectionFields(
   surfacingValue?: unknown,
   pendingMarksValue?: unknown,
   briefsValue?: unknown,
+  riderValue?: unknown,
+  lastCallValue?: unknown,
+  noticesValue?: unknown,
 ): {
   expanded: string[];
   protected: EvidenceRef[];
   prepared?: PreparedFold;
   advisory?: NonNullable<ActiveContextState["advisory"]>;
+  rider?: NonNullable<ActiveContextState["rider"]>;
+  lastCall?: NonNullable<ActiveContextState["lastCall"]>;
+  notices?: NonNullable<ActiveContextState["notices"]>;
   tokensSinceToolFold: number;
   leases: Record<string, number>;
   surfacing: SurfacingRecord[];
@@ -538,6 +637,15 @@ export function validateV2ProjectionFields(
   if (advisoryValue !== undefined && !validAdvisoryState(advisoryValue)) {
     throw new Error("Invalid active-context v2 advisory state");
   }
+  if (riderValue !== undefined && !validRiderState(riderValue)) {
+    throw new Error("Invalid active-context v2 rider state");
+  }
+  if (lastCallValue !== undefined && !validLastCallState(lastCallValue)) {
+    throw new Error("Invalid active-context v2 last-call state");
+  }
+  if (noticesValue !== undefined && !validNoticesState(noticesValue)) {
+    throw new Error("Invalid active-context v2 notices state");
+  }
   if (tokensSinceToolFoldValue !== undefined && !validTokensSinceToolFold(tokensSinceToolFoldValue)) {
     throw new Error("Invalid active-context v2 tool-fold cadence");
   }
@@ -552,6 +660,15 @@ export function validateV2ProjectionFields(
     ...(advisoryValue === undefined ? {} : {
       advisory: clone(advisoryValue) as NonNullable<ActiveContextState["advisory"]>,
     }),
+    ...(riderValue === undefined ? {} : {
+      rider: clone(riderValue) as NonNullable<ActiveContextState["rider"]>,
+    }),
+    ...(lastCallValue === undefined ? {} : {
+      lastCall: clone(lastCallValue) as NonNullable<ActiveContextState["lastCall"]>,
+    }),
+    ...(noticesValue === undefined ? {} : {
+      notices: clone(noticesValue) as NonNullable<ActiveContextState["notices"]>,
+    }),
     tokensSinceToolFold: tokensSinceToolFoldValue === undefined ? 0 : Number(tokensSinceToolFoldValue),
     leases,
     surfacing,
@@ -580,6 +697,12 @@ export function parseActiveContextStateV2(value: unknown, sessionId: string): Ac
     Object.prototype.hasOwnProperty.call(value, "pinnedPeeks"));
   const hasBriefs = Boolean(value && typeof value === "object" &&
     Object.prototype.hasOwnProperty.call(value, "briefs"));
+  const hasRider = Boolean(value && typeof value === "object" &&
+    Object.prototype.hasOwnProperty.call(value, "rider"));
+  const hasLastCall = Boolean(value && typeof value === "object" &&
+    Object.prototype.hasOwnProperty.call(value, "lastCall"));
+  const hasNotices = Boolean(value && typeof value === "object" &&
+    Object.prototype.hasOwnProperty.call(value, "notices"));
   const optionalKeys = [
     ...(hasAdvisory ? ["advisory"] : []),
     ...(hasTokensSinceToolFold ? ["tokensSinceToolFold"] : []),
@@ -588,6 +711,9 @@ export function parseActiveContextStateV2(value: unknown, sessionId: string): Ac
     ...(hasPendingMarks ? ["pendingMarks"] : []),
     ...(hasPinnedPeeks ? ["pinnedPeeks"] : []),
     ...(hasBriefs ? ["briefs"] : []),
+    ...(hasRider ? ["rider"] : []),
+    ...(hasLastCall ? ["lastCall"] : []),
+    ...(hasNotices ? ["notices"] : []),
   ];
   const checkpoint = kind === "checkpoint" &&
     exactRecord(value, [...STATE_CHECKPOINT_V2_KEYS, ...optionalKeys]);
@@ -603,6 +729,7 @@ export function parseActiveContextStateV2(value: unknown, sessionId: string): Ac
     ownValue(value, "expanded"), ownValue(value, "protected"), ownValue(value, "prepared"),
     ownValue(value, "advisory"), ownValue(value, "tokensSinceToolFold"), ownValue(value, "leases"),
     ownValue(value, "surfacing"), ownValue(value, "pendingMarks"), ownValue(value, "briefs"),
+    ownValue(value, "rider"), ownValue(value, "lastCall"), ownValue(value, "notices"),
   );
   if (checkpoint) {
     const refs = denseOwnArrayValues(ownValue(value, "foldRefs"));
@@ -667,7 +794,8 @@ export function stateFromFoldRefs(
   wire: Pick<
     ActiveContextCheckpointV2,
     "sessionId" | "revision" | "expanded" | "protected" | "prepared" | "advisory" |
-      "tokensSinceToolFold" | "leases" | "surfacing" | "pendingMarks" | "briefs"
+      "tokensSinceToolFold" | "leases" | "surfacing" | "pendingMarks" | "briefs" | "rider" |
+      "lastCall" | "notices"
   >,
   refs: FoldRecordRef[],
   records: Map<string, FoldRecordEntry>,
@@ -691,6 +819,9 @@ export function stateFromFoldRefs(
     ...(wire.pendingMarks?.length ? { pendingMarks: clone(wire.pendingMarks) } : {}),
     ...(wire.briefs && Object.keys(wire.briefs).length ? { briefs: clone(wire.briefs) } : {}),
     ...(wire.advisory === undefined ? {} : { advisory: clone(wire.advisory) }),
+    ...(wire.rider === undefined ? {} : { rider: clone(wire.rider) }),
+    ...(wire.lastCall === undefined ? {} : { lastCall: clone(wire.lastCall) }),
+    ...(wire.notices === undefined ? {} : { notices: clone(wire.notices) }),
     ...(wire.prepared === null || wire.prepared === undefined ? {} : { prepared: clone(wire.prepared) }),
   };
   return parseActiveContextState(state, wire.sessionId, false);
@@ -843,6 +974,9 @@ export function makeStateCheckpoint(state: ActiveContextState): ActiveContextChe
     ...(state.pendingMarks?.length ? { pendingMarks: clone(state.pendingMarks) } : {}),
     ...(state.briefs && Object.keys(state.briefs).length ? { briefs: clone(state.briefs) } : {}),
     ...(state.advisory ? { advisory: clone(state.advisory) } : {}),
+    ...(state.rider ? { rider: clone(state.rider) } : {}),
+    ...(state.lastCall ? { lastCall: clone(state.lastCall) } : {}),
+    ...(state.notices ? { notices: clone(state.notices) } : {}),
     stateSha256: semanticStateSha256(state),
   }, state.sessionId) as ActiveContextCheckpointV2;
 }
@@ -880,6 +1014,9 @@ export function makeStateDelta(previous: ActiveContextState, next: ActiveContext
     ...(next.pendingMarks?.length ? { pendingMarks: clone(next.pendingMarks) } : {}),
     ...(next.briefs && Object.keys(next.briefs).length ? { briefs: clone(next.briefs) } : {}),
     ...(next.advisory ? { advisory: clone(next.advisory) } : {}),
+    ...(next.rider ? { rider: clone(next.rider) } : {}),
+    ...(next.lastCall ? { lastCall: clone(next.lastCall) } : {}),
+    ...(next.notices ? { notices: clone(next.notices) } : {}),
     stateSha256: semanticStateSha256(next),
   }, next.sessionId) as ActiveContextDeltaV2;
 }
@@ -892,18 +1029,51 @@ export function protectionSha256(state: Pick<ActiveContextState, "protected">):
   return sha256Value([...state.protected].sort((left, right) => objectRefKey(left).localeCompare(objectRefKey(right))));
 }
 
-export const ADVISORY_BUDGETS: Readonly<Record<AdvisoryMilestone, number>> = Object.freeze({
-  orientation: 1,
-  notice: 2,
-  tools: 2,
-  chapters: 2,
-  urgent: 3,
-});
-
+/**
+ * The milestone vocabulary a persisted `advisory` state field may carry. The delivery
+ * schedule that spent a per-milestone budget is deleted; this list stays because the
+ * state field is written into every state and covered by the state digest, so sealed
+ * runs have to keep parsing. It is its own literal now rather than the key set of the
+ * deleted budget table.
+ */
 export const ADVISORY_MILESTONES = Object.freeze(
-  Object.keys(ADVISORY_BUDGETS) as AdvisoryMilestone[],
+  ["orientation", "notice", "tools", "chapters", "urgent"] as AdvisoryMilestone[],
 );
 
+/** The rider is LITERAL persisted bytes, so the bound is on the stored text itself. */
+export const MAX_RIDER_TEXT_BYTES = 4_096;
+
+export function validRiderState(value: unknown): value is NonNullable<ActiveContextState["rider"]> {
+  if (!exactRecord(value, ["epoch", "text"])) return false;
+  const epoch = ownValue(value, "epoch");
+  const text = ownValue(value, "text");
+  return Number.isSafeInteger(epoch) && Number(epoch) >= 0 &&
+    typeof text === "string" && text.length > 0 && text.length <= MAX_RIDER_TEXT_BYTES;
+}
+
+export function validLastCallState(value: unknown): value is NonNullable<ActiveContextState["lastCall"]> {
+  if (!exactRecord(value, ["exposure", "ordinal", "contextCalls", "agentMarks", "text"])) return false;
+  const text = ownValue(value, "text");
+  return ["exposure", "ordinal", "contextCalls", "agentMarks"].every((field) =>
+    Number.isSafeInteger(ownValue(value, field)) && Number(ownValue(value, field)) >= 0) &&
+    typeof text === "string" && text.length > 0 && text.length <= MAX_LAST_CALL_TEXT_BYTES;
+}
+
+export function validNoticesState(value: unknown): value is NonNullable<ActiveContextState["notices"]> {
+  if (!exactRecord(value, ["fired", "ring"])) return false;
+  const fired = denseOwnArrayValues(ownValue(value, "fired"));
+  const ring = denseOwnArrayValues(ownValue(value, "ring"));
+  if (!fired || !ring || ring.length > MAX_THRESHOLD_NOTICES) return false;
+  if (fired.some((share) => typeof share !== "number" || !Number.isFinite(share) || share <= 0 || share >= 1) ||
+      new Set(fired).size !== fired.length) return false;
+  return ring.every((notice) => exactRecord(notice, ["share", "ordinal", "text"]) &&
+    typeof ownValue(notice, "share") === "number" && Number.isFinite(ownValue(notice, "share")) &&
+    Number(ownValue(notice, "share")) > 0 && Number(ownValue(notice, "share")) < 1 &&
+    Number.isSafeInteger(ownValue(notice, "ordinal")) && Number(ownValue(notice, "ordinal")) >= 0 &&
+    typeof ownValue(notice, "text") === "string" && String(ownValue(notice, "text")).length > 0 &&
+    String(ownValue(notice, "text")).length <= MAX_THRESHOLD_NOTICE_TEXT_BYTES);
+}
+
 export function validAdvisoryState(value: unknown): value is NonNullable<ActiveContextState["advisory"]> {
   const hasArmed = Boolean(value && typeof value === "object" &&
     Object.prototype.hasOwnProperty.call(value, "armed"));