synthesisui 0.16.381 → 0.16.383

package/dist/commands/import.js

@@ -35,7 +35,7 @@ import { parseSchemeBlocks } from "../doctor/scheme-blocks.js";
 import { describeSignals, emptySignals, finishSignals, readSignalsInto, } from "../doctor/signals.js";
 import { sketchOf } from "../doctor/sketch.js";
 import { describeForeign, readStyleIslands, } from "../doctor/style-island.js";
-import { buildLedger, describeLedger, } from "../doctor/style-ledger.js";
+import { buildLedger, describeLedger, sampledForUpload, } from "../doctor/style-ledger.js";
 import { MUI_DEFAULT_SPACING, readStyledComponents, spacingOf, } from "../doctor/style-props.js";
 import { buildTable } from "../doctor/tokens.js";
 import { definitionSpan, parseClass, readInlineStyle, rootClasses, rootTag, transcribe, } from "../doctor/transcribe.js";
@@ -419,6 +419,32 @@ const SKIPPED_CAP = 4096;
  * envelhecer sozinha significa dois denominadores diferentes para a mesma palavra na mesma saída.
  */
 const SHOWS_A_COMPONENT = /(\.(spec|test|stories)\.[a-z]+$|__tests__\/|(^|\/)\.storybook\/)/;
+/**
+ * O NOME DO REPOSITÓRIO DE ONDE ESTA MEDIÇÃO SAIU - e não o da pasta que ela varreu.
+ *
+ * O QUE ACONTECIA: em modo biblioteca o chamador mede `join(root, "packages/ui")`, então a
+ * procedência dizia `ui`. Todo monorepo do mundo tem um `packages/ui`, e o campo que existe
+ * exatamente para distinguir dois repositórios parecidos passava a não distinguir nenhum -
+ * fazendo o oposto do que o comentário ao lado dele promete.
+ *
+ * MEDIDO em 05/09 pelo caminho real do `import --dry`, sobre uma cópia do repositório do dono:
+ * sem escopo grava `codelevel-monorepo`; com `--scope packages/ui` gravava `ui`. E o escopo é o
+ * caso do MONOREPO, que é justamente onde a ambiguidade existe.
+ *
+ * O ESCOPO JÁ VIAJA NO CAMPO DELE, então a raiz sai por subtração, e não por um parâmetro novo:
+ * um `projectRoot` opcional seria esquecido pelo terceiro chamador, e este campo é do tipo que
+ * ninguém confere. Quando o caminho não termina no escopo - um chamador que rotule de outro jeito
+ * -, o nome continua sendo o da pasta medida, que é o comportamento de sempre.
+ */
+function repoNameOf(root, scopeLabel) {
+    const full = resolve(root);
+    if (!scopeLabel)
+        return basename(full);
+    const suffix = sep + scopeLabel.split("/").join(sep);
+    if (!full.endsWith(suffix))
+        return basename(full);
+    return basename(full.slice(0, -suffix.length)) || basename(full);
+}
 export async function takeCensus(root, opts) {
     /**
      * O RELATÓRIO SÓ SAI QUANDO ALGUÉM O PEDIU - `say` cala quando o chamador é uma RE-medição.
@@ -2776,7 +2802,10 @@ export async function takeCensus(root, opts) {
          * A PROCEDÊNCIA, GRAVADA - ver `measured` no tipo. `basename` e não o caminho: o nome da pasta
          * distingue dois monorepos parecidos sem mandar o diretório pessoal dele para o nosso servidor.
          */
-        measured: { repo: basename(resolve(root)), at: new Date().toISOString() },
+        measured: {
+            repo: repoNameOf(root, scopeLabel),
+            at: new Date().toISOString(),
+        },
         ...(scopeLabel ? { scope: scopeLabel } : {}),
         /**
          * O DENOMINADOR DO FORA - ver `outside-scope.ts`.
@@ -4466,8 +4495,17 @@ export async function runImport(opts) {
          * ler `_synthesisui/ds/<slug>/.lock`, que num import não existe de qualquer forma. Todo campo do
          * payload é opcional, então o que falta simplesmente não viaja - em vez de o conjunto todo faltar.
          */
+        /**
+         * O QUE SOBE É AMOSTRA; O QUE FICA NO REPOSITÓRIO DELE É INTEIRO - `INV-COLETA-18`.
+         *
+         * `sampledForUpload` aplica o teto AQUI, depois de o censo já ter sido gravado em
+         * `_synthesisui/census.json`. O tamanho deste corpo não muda em byte nenhum - é o mesmo 4 096
+         * de sempre -, e o que muda é que o arquivo dele deixou de ser podado por um limite nosso.
+         */
         body: JSON.stringify({
-            census,
+            census: census.ledger
+                ? { ...census, ledger: sampledForUpload(census.ledger) }
+                : census,
             name: chosen,
             ...(opts.group ? { group: opts.group } : {}),
             ...(repoAtImport ? { repo: repoAtImport } : {}),

package/dist/commands/sync.js

@@ -6,6 +6,7 @@ import { readToken, resolveRegistry } from "../config.js";
 import { inherit, readDeclaredForms, } from "../doctor/declared-forms.js";
 import { markSent, readEvents } from "../doctor/ledger.js";
 import { checkableName, closeRequest, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
+import { sampledForUpload } from "../doctor/style-ledger.js";
 import { describeDelta, fingerprintReadings, readSyncMark, writeSyncMark, } from "../last-sync.js";
 import { measuredScope, rememberScope } from "../measured-scope.js";
 import { fromCensus } from "../memory/observation.js";
@@ -556,7 +557,18 @@ export async function remeasure(args) {
             "content-type": "application/json",
             Authorization: `Bearer ${token}`,
         },
-        body: JSON.stringify({ census }),
+        /**
+         * O QUE SOBE É AMOSTRA; O QUE FICA NO REPOSITÓRIO DELE É INTEIRO - `INV-COLETA-18`.
+         *
+         * A gravação em `_synthesisui/census.json` acontece acima, e ela leva o ledger COMPLETO: é dali
+         * que `gaps` e a skill `sui-reader` tiram a forma, o lugar e o texto de cada declaração que
+         * nenhum leitor entendeu. O teto vale só para o nosso lado, e o tamanho deste corpo não muda.
+         */
+        body: JSON.stringify({
+            census: census.ledger
+                ? { ...census, ledger: sampledForUpload(census.ledger) }
+                : census,
+        }),
     }).catch(() => null);
     if (!res?.ok) {
         console.log(body(res

package/dist/doctor/style-ledger.js

@@ -291,12 +291,11 @@ declared) {
              * declarado e um teto silencioso. Inverter as duas linhas devolve o defeito.
              */
             group.distinctTexts.add(f.text);
-            if (group.unreadable.length < DISTINCT_CAP)
-                group.unreadable.push({
-                    file: f.file,
-                    line: f.line,
-                    text: f.text.replace(/\s+/g, " ").trim().slice(0, 400),
-                });
+            group.unreadable.push({
+                file: f.file,
+                line: f.line,
+                text: f.text.replace(/\s+/g, " ").trim().slice(0, 400),
+            });
         }
         groups.set(key, group);
     }
@@ -413,17 +412,27 @@ values) {
          *
          * O QUE ELA NÃO FAZ é prometer o desfecho - mesma correção que `shape-not-read` recebeu em
          * 24/08. Ela diz quantos textos viajam e o que isso significa para um leitor que a gente
-         * publique depois; para onde vai o resto depende de uma decisão de tamanho de censo que não é
-         * do cliente e ainda não foi tomada.
+         * publique depois.
+         *
+         * ─────────────────────────────────────────────────────────────────────────
+         * E EM 06/09 ELA TROCOU DE SENTIDO, porque o teto trocou de lado - `INV-COLETA-18`.
+         *
+         * A frase antiga dizia *"de N textos, 4096 viajam"* sobre um arquivo que TAMBÉM estava podado:
+         * o corte acontecia na construção, então o `census.json` dele levava os mesmos 4096. Agora o
+         * arquivo dele leva todos, e o que é amostrado é só o que sobe para nós.
+         *
+         * A CONDIÇÃO PASSOU A SER O TETO, e não `unreadable.length`: aquele campo agora vale `distinct`
+         * sempre, então a comparação antiga nunca seria verdadeira e a frase sumiria em silêncio - uma
+         * lacuna declarada virando lacuna calada por efeito colateral, que é o oposto da lei 8.
          */
-        if (g.distinct !== undefined && g.distinct > g.unreadable.length)
+        if (g.distinct !== undefined && g.distinct > DISTINCT_CAP)
             lines.push(
             /**
              * `census` ERA O NOSSO NOME NA TELA DELE - trocado por "the measurement we already have",
              * que é o que a palavra significa do lado dele. Pego pela régua de `INV-VOC-05` no dia em
              * que `doctor/` entrou nela (03/09).
              */
-            `      of ${g.distinct} distinct texts here, ${g.unreadable.length} travel with the measurement we already have - a reader we publish later reaches those without you running this again, and the remaining ${g.distinct - g.unreadable.length} need another scan`);
+            `      all ${g.distinct} distinct texts stay in the measurement file in your repository - the ${g.distinct - DISTINCT_CAP} past the first ${DISTINCT_CAP} did not travel to us, so a reader we publish later reaches those only after another scan`);
         for (const e of g.examples)
             lines.push(`      ${e.file}:${e.line}  ${e.text.slice(0, 80)}`);
     }
@@ -445,3 +454,39 @@ export function describeValueRuler(values) {
         `Of the ${values.seen} class declarations on your components, ${values.structure} are structure (layout plumbing, not design decisions). Of the ${decisions} design decisions, ${closed} are interpreted${values.answered > 0 ? ` (${values.answered} of them answered by you)` : ""} - ${percent}%.`,
     ];
 }
+/**
+ * O CORTE, APLICADO DEPOIS DA BIFURCAÇÃO - fecha o `pending` de `INV-COLETA-18`.
+ *
+ * A REGRA, do dono (05/09): *"coisas que a gente não interpreta a gente continua enviando para o
+ * usuário, para o agente saber o que fazer"*. Falhar em ler degrada a NOSSA metade; nunca o insumo
+ * dele.
+ *
+ * O QUE ACONTECIA. `buildLedger` cortava em `DISTINCT_CAP` durante a CONSTRUÇÃO, e o objeto podado
+ * era o mesmo que ia para os dois lados: gravado em `_synthesisui/census.json` na máquina dele E
+ * enviado ao nosso banco. Um teto que existe pelo NOSSO custo de armazenamento estava podando o
+ * arquivo de onde o agente DELE tira a forma, o lugar e o texto. Medido em 03/09, com o teto solto:
+ *
+ *     web-subscribe            component-not-admitted   9 722 distintos, 4 096 viajavam   58% fora
+ *     web-subscribe            shape-not-read           8 016 distintos, 4 096 viajavam   49% fora
+ *     frontend-hub/dashboard   component-not-admitted   6 394 distintos, 4 096 viajavam   36% fora
+ *
+ * AGORA A CONSTRUÇÃO GUARDA TUDO e quem chama decide. O disco dele recebe o ledger inteiro; o corpo
+ * do POST passa por aqui. O tamanho do que sobe não muda em byte nenhum - é o mesmo 4 096 de antes.
+ *
+ * E `distinct` NÃO É RECALCULADO aqui, de propósito: ele conta os distintos que a MEDIÇÃO viu, e é
+ * exatamente a diferença entre ele e `unreadable.length` que diz ao servidor que a lista recebida é
+ * amostra. Recalcular apagaria a única evidência do corte - o defeito que `INV-COB-14` protege.
+ *
+ * O TETO DAS FORMAS entra junto porque responde à mesma pergunta e ao mesmo custo: `formsTotal`
+ * continua dizendo quantas existem.
+ */
+export function sampledForUpload(ledger) {
+    return {
+        ...ledger,
+        unread: ledger.unread.map((group) => ({
+            ...group,
+            unreadable: group.unreadable.slice(0, DISTINCT_CAP),
+            ...(group.forms ? { forms: group.forms.slice(0, FORM_CAP) } : {}),
+        })),
+    };
+}

package/dist/install-marks.js

@@ -680,7 +680,18 @@ export const CHECKER_SINCE = "0.16.378";
  * posição de conteúdo. Um censo medido antes desta versão conta como deriva o que a folha do app
  * nem alcança - e o número do cliente é a promessa.
  */
-export const READER_SINCE = "0.16.381";
+/**
+ * 0.16.381 -> 0.16.383 em 06/09: o censo produzido MUDA, e do lado DELE. `DISTINCT_CAP` cortava os
+ * textos durante a construção do ledger, então o mesmo objeto podado era gravado em
+ * `_synthesisui/census.json` na máquina dele e enviado para nós - um teto que existe pelo NOSSO
+ * custo podando o insumo DELE (`INV-COLETA-18`). Agora `buildLedger` guarda tudo e o corte é
+ * aplicado só no corpo do POST. Um censo medido antes desta versão tem o arquivo dele podado em
+ * todo grupo acima de 4 096 textos distintos, e só um `sync` traz o resto.
+ * QUEM NÃO É AFETADO: quem não tem nenhum grupo acima de 4 096 - o `sync` daquele repositório não
+ * muda um byte. Medido em 06/09: `frontend-hub/apps/web-dashboard` tem UM grupo acima (6 393), e
+ * `packages/ui` e `apps/web-review` nenhum.
+ */
+export const READER_SINCE = "0.16.383";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synthesisui",
-  "version": "0.16.381",
+  "version": "0.16.383",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {
@@ -29,7 +29,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && chmod +x dist/index.js",
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && chmod +x dist/index.js",
     "dev": "tsx src/index.ts",
     "prepublishOnly": "npm run build",
     "test": "vitest run",

package/dist/mcp-approval.js

@@ -1,111 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-/**
- * AS FERRAMENTAS DECLARADAS E ESPERANDO APROVAÇÃO - o portão que matou um import inteiro.
- *
- * O QUE O CLIENTE GANHA: a sessão em que a aprovação está pendente é a sessão que lhe diz isso.
- * Antes ele descobria no meio do import, quando o agente já tinha medido o repositório e não tinha
- * como continuar.
- *
- * MEDIDO em 03/09, no segundo import real do dono. Ele rodou `import my design system`, o agente
- * mediu 262 arquivos, leu 78 componentes, descreveu a paleta dele - e parou:
- *
- *     synthesisui: npx synthesisui@latest mcp - ⏸ Pending approval
- *
- * O playbook do import é SERVIDO pelo MCP, então sem aprovação não há import: só medição. E o
- * `connect` avisa - em uma linha cinza, a terceira de um bloco secundário. Um portão que interrompe
- * a jornada principal não pode ser anunciado como nota de pé de página.
- *
- * A ORIGEM DO DADO. O Claude Code guarda a decisão no `~/.claude.json`, por projeto:
- *
- *     enabledMcpjsonServers    aprovados
- *     disabledMcpjsonServers   recusados
- *
- * Um servidor declarado no `.mcp.json` que não está em nenhuma das duas listas está PENDENTE - e é
- * exatamente o estado dele. Medido: as duas listas vazias, para aquele projeto.
- *
- * SÓ LEITURA, NUNCA ESCRITA. Aquele arquivo é a configuração pessoal dele e vale para todos os
- * projetos dele - a mesma fronteira do `.zshrc`, que este produto só atravessa perguntando.
- * Escrever a aprovação por ele seria decidir em nome dele sobre um portão de segurança.
- *
- * E CALA QUANDO NÃO SABE. Arquivo ausente, JSON que não parseia, projeto sem entrada, formato
- * diferente do que a gente conhece: em todos, resposta `null` e nenhuma linha na tela. Um aviso
- * baseado num formato que mudou é pior que silêncio, porque manda a pessoa procurar um botão que
- * talvez não exista mais.
- */
-/** O nome do nosso servidor no `.mcp.json` - ver `wireMcpAt`. */
-const SERVER = "synthesisui";
-/**
- * `true` quando o nosso servidor está declarado no repositório e a decisão dele ainda não foi
- * tomada. `null` quando não há como saber - e aí quem chama não diz nada.
- */
-export async function mcpAwaitingApproval(root, home) {
-    const declared = await readFile(join(root, ".mcp.json"), "utf8").then((raw) => {
-        try {
-            const j = JSON.parse(raw);
-            return Boolean(j.mcpServers && SERVER in j.mcpServers);
-        }
-        catch {
-            return null;
-        }
-    }, () => false);
-    /** Sem declaração não há aprovação pendente: o caso é OUTRO, e o `connect` já o cobre. */
-    if (declared !== true)
-        return declared === null ? null : false;
-    const raw = await readFile(join(home, ".claude.json"), "utf8").catch(() => null);
-    if (raw == null)
-        return null;
-    let conf;
-    try {
-        conf = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    const entry = conf.projects?.[root];
-    /**
-     * SEM ENTRADA PARA ESTE PROJETO a pessoa provavelmente nunca abriu o agente aqui - e aí não há
-     * aprovação pendente, há uma sessão que ainda não aconteceu. Dizer "aprove" a quem não foi
-     * perguntado é inventar um estado.
-     */
-    if (!entry)
-        return null;
-    const enabled = entry.enabledMcpjsonServers;
-    const disabled = entry.disabledMcpjsonServers;
-    /** Formato diferente do que a gente conhece: silêncio, nunca um palpite. */
-    if (!Array.isArray(enabled) || !Array.isArray(disabled))
-        return null;
-    /** Recusado explicitamente é um estado REAL, e é o único que este arquivo registra com certeza. */
-    if (disabled.includes(SERVER))
-        return true;
-    if (enabled.includes(SERVER))
-        return false;
-    /**
-     * AUSENTE DAS DUAS LISTAS É "NÃO SEI", E TRATÁ-LO COMO "PENDENTE" FOI O DEFEITO.
-     *
-     * A premissa desta função era: *"um servidor declarado que não está em nenhuma das duas listas
-     * está PENDENTE - medido, as duas listas vazias para aquele projeto"*. A medição existiu e estava
-     * certa sobre aquele projeto; a INFERÊNCIA não, porque ninguém mediu a outra metade.
-     *
-     * REMEDIDO em 04/09, na máquina do dono, nos SETE projetos que declaram este servidor: as duas
-     * listas estão vazias em TODOS - incluindo o `codelevel-monorepo`, onde o import inteiro rodou no
-     * dia anterior com o MCP servindo o playbook. Estado byte a byte idêntico entre "funciona" e
-     * "está pendente": a leitura não distinguia nada, era uma constante disfarçada de sinal.
-     *
-     * E procurei o registro em todas as casas antes de concluir - `~/.claude.json`,
-     * `.claude/settings.json`, `.claude/settings.local.json`, `.mcp.json` e `~/.claude/`. A aprovação
-     * de um servidor do `.mcp.json` não é gravada em nenhuma delas. `hasTrustDialogAccepted` é o
-     * diálogo do PROJETO, e `mcp-needs-auth-cache.json` é dos servidores do claude.ai.
-     *
-     * O CUSTO DE AFIRMAR SEM SABER, e ele não foi teórico: esta linha chega ao contexto do agente em
-     * toda abertura de sessão (`align` no `SessionStart`). Em 04/09 o dono pediu *"import my design
-     * system"*, o agente leu o aviso, acreditou nele e RECUSOU a jornada principal - mandou rodar
-     * `/mcp` num projeto cujas ferramentas estavam disponíveis. O defeito que o aviso existia para
-     * evitar era o agente parar sem saber por quê; o aviso passou a ser a causa dele.
-     *
-     * Então volta a valer a regra que o cabeçalho deste módulo sempre declarou - *"cala quando não
-     * sabe"* -, e quem observa se as ferramentas chegaram é o AGENTE, que sabe quais tem. A instrução
-     * mora no playbook, endereçada a ele.
-     */
-    return null;
-}

package/dist/memory/recall.js

@@ -1,161 +0,0 @@
-/**
- * QUANTO DA MEMÓRIA MERECE ENTRAR NO CONTEXTO AGORA - e a resposta é explicável linha por linha.
- *
- * ─────────────────────────────────────────────────────────────────────────
- * FILTRO, ORDEM, ORÇAMENTO - nesta ordem, e nenhum score
- *
- * A alternativa considerada e recusada era `relevância × confiança × especificidade`. Ela responde
- * ao mesmo pedido e cobra um preço que só aparece no primeiro dia em que a memória atrapalha: o
- * desenvolvedor pergunta *"por que essa regra apareceu e aquela não"*, e um produto de três floats
- * não tem resposta. Um filtro booleano tem.
- *
- * Confiança responde "quanto acreditamos nisto". Relevância responde "quanto isto importa para o
- * que estou fazendo agora". São perguntas diferentes, e a segunda é um FILTRO de contrato fechado,
- * nunca um peso.
- *
- * ─────────────────────────────────────────────────────────────────────────
- * A INVARIANTE 5 (dono, 20/08): ORÇAMENTO NÃO PODE MUDAR SEMÂNTICA
- *
- * Duas decisões sobre o mesmo assunto formam um GRUPO indivisível. Se só uma couber, ela não entra
- * sozinha - entregar metade de uma discussão como se fosse a visão inteira é reintroduzir
- * contradição silenciosa por causa do orçamento, que é o defeito que o co-escopo existe para
- * impedir. Ou o grupo entra inteiro, ou ele é declarado omitido.
- *
- * ─────────────────────────────────────────────────────────────────────────
- * CO-ESCOPO NÃO É CONTRADIÇÃO, e a diferença é dita em voz alta
- *
- * Duas regras no mesmo `applies` e `kind` não são necessariamente contraditórias: são duas decisões
- * que merecem aparecer juntas. Ver que duas FRASES se contradizem é leitura de linguagem, ou seja
- * IA, e isso está fora do v1 de propósito. O que este arquivo promete é co-escopo, e é isso que a
- * resposta diz - prometer um detector de contradição que não existe seria a lacuna calada que a
- * lei 8 proíbe.
- */
-/**
- * AS TAREFAS, LISTA FECHADA - derivada do que a plataforma JÁ MEDE, nunca de casos imaginados.
- *
- * Mesma regra do catálogo de predicados: a linguagem cresce quando a capacidade de medição cresce.
- * Estas seis existem porque há medição por trás de cada uma - as três categorias de otimização, o
- * contraste que o doctor calcula, a acessibilidade que os anéis medem, e a migração, que é o que os
- * predicados de transição observam.
- */
-export const TASKS = [
-    "tokens",
-    "spacing",
-    "typography",
-    "contrast",
-    "accessibility",
-    "migration",
-];
-/** ~4 caracteres por token: aproximação suficiente para um teto, e barata. */
-const cost = (m) => Math.ceil(m.text.length / 4) + 8;
-const norm = (v) => v.trim().toLowerCase();
-/**
- * A STACK É O ÚNICO FILTRO QUE MANTÉM O QUE NÃO CONSEGUE JULGAR.
- *
- * Uma regra cuja condição não bate é removida, porque obedecê-la seria um erro. Uma que a gente não
- * consegue avaliar - a stack veio vazia, ou ela nomeia algo que não detectamos - FICA, porque uma
- * regra que ninguém pode julgar é mais segura presente que silenciosamente ausente. São duas
- * situações diferentes e elas ganham respostas diferentes.
- */
-const stackHolds = (m, stack) => {
-    if (m.when.length === 0)
-        return true;
-    if (!stack || stack.length === 0)
-        return true;
-    const has = new Set(stack.map(norm));
-    return m.when.some((w) => has.has(norm(w)));
-};
-/** Especificidade: a relação vence o componente, que vence o sistema - e sai do dado, sem peso. */
-const specificity = (m) => m.applies.length >= 2 ? 3 : m.applies.length === 1 ? 2 : 1;
-const RUNG_ORDER = { fact: 0, habit: 1, candidate: 2 };
-/**
- * A CHAVE DO GRUPO: o sujeito estruturado quando existe, senão o escopo mais o tipo de regra.
- *
- * Sem sujeito o agrupamento é mais largo e pode juntar coisas que só dividem o escopo - e é por
- * isso que a resposta diz "há mais de uma decisão neste escopo" em vez de afirmar conflito.
- */
-const groupKey = (m) => m.subject
-    ? `subject:${norm(m.subject)}`
-    : `scope:${m.applies.map(norm).sort().join("+")}|${m.kind}`;
-export function recall(all, ask) {
-    const omitted = new Map();
-    const drop = (why) => omitted.set(why, (omitted.get(why) ?? 0) + 1);
-    const wantScope = (ask.scope ?? []).map(norm);
-    const kept = all.filter((m) => {
-        if (!stackHolds(m, ask.stack))
-            return drop("stack"), false;
-        if (ask.family && m.family && norm(m.family) !== norm(ask.family))
-            return drop("family"), false;
-        if (ask.task &&
-            m.tasks &&
-            m.tasks.length > 0 &&
-            !m.tasks.includes(ask.task))
-            return drop("task"), false;
-        /**
-         * ESCOPO: uma regra DO SISTEMA vale sempre - ela é o que governa tudo. Uma regra de componente
-         * só entra quando aquele componente está em jogo.
-         */
-        if (m.applies.length > 0 && wantScope.length > 0) {
-            const touches = m.applies.some((a) => wantScope.includes(norm(a)));
-            if (!touches)
-                return drop("scope"), false;
-        }
-        return true;
-    });
-    /** Ordem: mais específico, depois degrau, depois confiança, e decisão antes de rationale. */
-    const ranked = [...kept].sort((a, b) => {
-        if (a.type !== b.type)
-            return a.type === "decision" ? -1 : 1;
-        const s = specificity(b) - specificity(a);
-        if (s !== 0)
-            return s;
-        const r = RUNG_ORDER[a.rung] - RUNG_ORDER[b.rung];
-        if (r !== 0)
-            return r;
-        return b.confidence - a.confidence;
-    });
-    /**
-     * O ORÇAMENTO É GASTO POR GRUPO, nunca por item - é a invariante 5.
-     *
-     * Os grupos entram na ordem do seu melhor membro, e um grupo que não cabe INTEIRO não entra:
-     * metade de uma discussão lida como a visão completa.
-     */
-    const order = [];
-    const byGroup = new Map();
-    for (const m of ranked) {
-        const key = groupKey(m);
-        if (!byGroup.has(key)) {
-            byGroup.set(key, []);
-            order.push(key);
-        }
-        byGroup.get(key)?.push(m);
-    }
-    const carried = [];
-    const groups = [];
-    let spent = 0;
-    for (const key of order) {
-        const members = byGroup.get(key) ?? [];
-        const price = members.reduce((n, m) => n + cost(m), 0);
-        if (spent + price > ask.budget) {
-            for (const _ of members)
-                drop("budget");
-            continue;
-        }
-        spent += price;
-        carried.push(...members);
-        if (members.length > 1)
-            groups.push({ key, members: members.map((m) => m.id) });
-    }
-    const cut = [...omitted.entries()].map(([by, count]) => ({ by, count }));
-    const total = all.length;
-    const parts = cut.map(({ by, count }) => `${count} by ${by}`).join(", ");
-    const conflictNote = groups.length > 0
-        ? ` ${groups.length} group${groups.length === 1 ? "" : "s"} carry more than one decision on the same subject - they travel together, and this is co-scope, not a claim that they contradict.`
-        : "";
-    return {
-        carried,
-        groups,
-        omitted: cut,
-        because: `${carried.length} of ${total} carried within ${ask.budget} tokens${parts ? `; left out: ${parts}` : ""}.${conflictNote}`,
-    };
-}

package/dist/memory/work-state.js

@@ -1,131 +0,0 @@
-/** Dias distintos com medição, sem progresso, antes de o estado adormecer. */
-export const DORMANT_AFTER_MEASURED_DAYS = 3;
-const day = (iso) => iso.slice(0, 10);
-/** Estados que uma medição não move mais. Uma regressão é um trabalho NOVO, não este voltando. */
-const SETTLED = new Set(["completed", "abandoned"]);
-/**
- * O QUE A MEDIÇÃO FAZ COM UM ESTADO - a única porta por onde `completed` e `orphaned` entram.
- *
- * PROGRESSO É O VEREDITO TER MUDADO, e isso é determinístico sem guardar o repositório inteiro: o
- * `because` de um predicado de transição sai de "still references X" para "dropped X but does not
- * reference Y yet" quando metade do trabalho aconteceu. Comparar o veredito anterior com o atual
- * captura isso sem inventar heurística de diff.
- */
-export function onMeasurement(state, verdict, at, by, dormantAfter = DORMANT_AFTER_MEASURED_DAYS) {
-    if (SETTLED.has(state.status))
-        return state;
-    /**
-     * INVARIANTE 1 e 2, no mesmo lugar: indeterminado NÃO PODE concluir, e ficar órfão preserva
-     * tudo. `lastVerdict` não é sobrescrito - a última coisa que a gente soube de verdade sobrevive
-     * ao período em que a gente deixou de saber.
-     */
-    if (verdict.state === "indeterminate")
-        return {
-            ...state,
-            status: "orphaned",
-            lastMeasuredAt: at,
-            by: by ?? state.by,
-            resolution: {
-                type: "orphaned",
-                source: "measurement",
-                at,
-                reason: `${verdict.reason}: ${verdict.because}`,
-            },
-        };
-    const progressed = !state.lastVerdict ||
-        state.lastVerdict.state !== verdict.state ||
-        state.lastVerdict.because !== verdict.because;
-    if (verdict.state === "met")
-        return {
-            ...state,
-            status: "completed",
-            evidenceSource: "measurement",
-            lastMeasuredAt: at,
-            lastProgressAt: at,
-            measuredDays: [],
-            lastVerdict: { state: "met", because: verdict.because },
-            by: by ?? state.by,
-            resolution: {
-                type: "completed",
-                source: "measurement",
-                at,
-                reason: verdict.because,
-            },
-        };
-    /**
-     * INVARIANTE 3: uma medição nova NÃO acorda um estado dormente. Só progresso acorda - senão
-     * rodar `sync` faria todo trabalho parado parecer vivo outra vez.
-     */
-    if (progressed)
-        return {
-            ...state,
-            status: "active",
-            evidenceSource: "measurement",
-            lastMeasuredAt: at,
-            lastProgressAt: at,
-            measuredDays: [],
-            lastVerdict: { state: "unmet", because: verdict.because },
-            by: by ?? state.by,
-            /** Um estado que estava órfão e voltou a ser mensurável perde a resolução antiga. */
-            ...(state.status === "orphaned" ? { resolution: undefined } : {}),
-        };
-    const days = state.measuredDays.includes(day(at))
-        ? state.measuredDays
-        : [...state.measuredDays, day(at)];
-    return {
-        ...state,
-        status: days.length >= dormantAfter
-            ? "dormant"
-            : state.status === "orphaned"
-                ? "active"
-                : state.status,
-        evidenceSource: "measurement",
-        lastMeasuredAt: at,
-        measuredDays: days,
-        lastVerdict: { state: "unmet", because: verdict.because },
-        by: by ?? state.by,
-        ...(state.status === "orphaned" ? { resolution: undefined } : {}),
-    };
-}
-/** A ÚNICA porta para `abandoned`, e ela é uma pessoa. */
-export function declareAbandoned(state, by, at, reason) {
-    return {
-        ...state,
-        status: "abandoned",
-        resolution: {
-            type: "abandoned",
-            source: "developer",
-            at,
-            ...(reason ? { reason } : {}),
-        },
-    };
-}
-/**
- * COMO O RECALL FALA DE UM ESTADO - invariante 4.
- *
- * Um estado que o agente criou e que ninguém mediu é hipótese, e a frase tem que dizer isso. Um
- * estado medido há seis dias é a última coisa que a gente sabe, não o que está acontecendo agora.
- */
-export function authorityOf(state) {
-    if (state.createdBy === "agent" && state.evidenceSource === "none")
-        return {
-            authority: "hypothesis",
-            label: "hypothesis, written by an agent and never measured",
-        };
-    if (!state.lastMeasuredAt)
-        return { authority: "hypothesis", label: "declared, not measured yet" };
-    if (state.status === "orphaned")
-        return {
-            authority: "last-known",
-            label: `last known before it became unmeasurable on ${day(state.lastMeasuredAt)}`,
-        };
-    if (state.status === "dormant")
-        return {
-            authority: "last-known",
-            label: `no progress observed since ${state.lastProgressAt ? day(state.lastProgressAt) : day(state.createdAt)}`,
-        };
-    return {
-        authority: "confirmed",
-        label: `measured ${day(state.lastMeasuredAt)}`,
-    };
-}