@ciromaciel/contract 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ciromaciel/contract",
-    "version": "1.0.3",
+    "version": "1.0.4",
     "license": "MIT",
     "type": "module",
     "description": "A single response envelope, a closed catalogue of error codes, and helpers that make answering outside it impossible.",

package/src/plan/notice.js

@@ -22,66 +22,45 @@
  * @param {object} cfg    Where the secret and the Payments URL live.
  * @param {string} ownerId
  * @param {object} [copy] Product wording. `product` is the name a person reads
- *                        ("RiLiGar Auth"), `keeps` is what goes on working,
+ *                        ("Infrastructure Auth"), `keeps` is what goes on working,
  *                        `frozen` is what does not.
- * @returns {Promise<{state: 'active'|'none'|'unknown', plan: string|null,
+ * @param {number} [current] How many resources the owner has now. Without it,
+ *                        an owner with no plan gets no notice.
+ * @returns {Promise<{state: 'active'|'free'|'none'|'unknown', plan: string|null,
  *   limit: number|null, message: string|null}>}
  */
-export async function getPlanNotice(gate, cfg, ownerId, copy = {}) {
+export async function getPlanNotice(gate, cfg, ownerId, copy = {}, current = null) {
     const ent = await gate.getEntitlements(cfg, ownerId)
-
-    // `Infinity` does not survive JSON.stringify — it becomes `null` silently.
-    // Converting on purpose is what keeps the wire honest.
     const limit = ent.limit === Infinity ? null : ent.limit
-
-    // Could not ask: say nothing. Dunning somebody because our OWN billing call
-    // timed out is worse than staying quiet for the length of an outage.
     if (ent.unknown) return { state: 'unknown', plan: null, limit: null, message: null }
-
     if (ent.subscribed) return { state: 'active', plan: ent.plan, limit, message: null }
-
     /*
-     * ONE MESSAGE, WRITTEN ONCE, for both surfaces — a banner and an MCP
-     * warning that disagree is how a customer ends up arguing with support
-     * about which is true.
-     *
-     * IT SAYS WHAT STILL WORKS BEFORE WHAT DOES NOT. The first question of
-     * anyone who sees this is "did my users just go down?", and an answer that
-     * opens with the refusal makes them assume the worst.
-     *
-     * Portuguese, because this is the one string here a person reads.
+     * NO PLAN IS NOT A PROBLEM TO REPORT. Since the free floor became one
+     * resource (2026-09-17), an owner with no plan is simply on the free tier,
+     * and telling them "your subscription is not active" reads as a billing
+     * failure they never had. The notice speaks only when the free tier is
+     * actually full — and it can only know that from `current`, so without it
+     * there is no notice: the refusal on creation already says what to do.
      */
+    if (typeof current !== 'number' || limit === null || current < limit) {
+        return { state: 'free', plan: ent.plan, limit, message: null }
+    }
     const product = copy.product || 'este produto'
     const keeps = copy.keeps || 'O que você já criou continua funcionando'
     const frozen = copy.frozen || 'apenas a criação de novos recursos está bloqueada'
-
     return {
         state: 'none',
         plan: ent.plan,
         limit,
-        message: `Sua assinatura do ${product} não está ativa. ${keeps} — ${frozen} até a regularização do pagamento.`,
+        message: `O plano gratuito do ${product} chegou ao limite. ${keeps} — ${frozen}. Assine para criar mais.`,
     }
 }
 
-/**
- * Attaches the notice to an MCP tool result, without ever refusing it.
- *
- * IT TRAVELS AS A FIELD, NOT AS PROSE. The stack's MCP rule is that
- * `content[0].text` is the `JSON.stringify` of the same object in
- * `structuredContent`. Appending a second text block would break that mirror,
- * and a client reading one field would disagree with one reading the other.
- *
- * ERRORS ARE LEFT ALONE: an `isError` result already carries the reason the
- * agent needs, and billing copy on top of a permission failure buries it.
- *
- * AND IT NEVER BREAKS A TOOL CALL — the notice is decoration, so an unreachable
- * Payments or an outright throw both leave the result untouched.
- */
-export async function withPlanNotice(result, gate, cfg, ownerId, copy) {
+export async function withPlanNotice(result, gate, cfg, ownerId, copy, current = null) {
     if (!result || result.isError || !result.structuredContent) return result
 
     try {
-        const notice = await getPlanNotice(gate, cfg, ownerId, copy)
+        const notice = await getPlanNotice(gate, cfg, ownerId, copy, current)
         if (notice.state !== 'none') return result
 
         const payload = { ...result.structuredContent, planNotice: notice }