synthesisui 0.16.261 → 0.16.264

package/dist/memory/contract.js

@@ -0,0 +1,106 @@
+/**
+ * O CONTRATO DA MEMÓRIA - e é a ÚNICA coisa desta feature que existe nos dois lados.
+ *
+ * O CLI é publicado standalone e não pode importar os contratos da plataforma, então este arquivo é
+ * um GÊMEO BYTE-IDÊNTICO de `apps/web/src/lib/memory/contract.ts`, garantido por spec - o mesmo
+ * padrão de `frontier-kind.ts`.
+ *
+ * A REGRA QUE DECIDE O QUE ENTRA AQUI (dono, 20/08):
+ *
+ *     contrato pode ser duplicado e verificado; LÓGICA nunca.
+ *
+ * Entram tipos, enums, códigos de recusa e a metadata declarativa dos predicados. NÃO entram
+ * `evaluate`, `compareProgress`, `canonicalize`, `recall` nem qualquer função que decida algo: cada
+ * uma dessas tem um dono só, e duplicar semântica é como duas implementações começam a divergir sem
+ * ninguém perceber.
+ *
+ * E a divisão que este arquivo serve:
+ *
+ *     O CLI OBSERVA E TESTEMUNHA.   A PLATAFORMA LEMBRA E DECIDE O EFEITO DA EVIDÊNCIA.
+ */
+export const CATALOGUE = {
+    reference_replaced: {
+        needs: ["from", "to"],
+        requiresAlive: ["subject"],
+        requiresReadableStyles: false,
+    },
+    inbound_references_zero: {
+        needs: [],
+        requiresAlive: [],
+        requiresReadableStyles: false,
+        progress: { field: "remaining", direction: "decrease" },
+    },
+    reference_present: {
+        needs: ["to"],
+        requiresAlive: ["subject"],
+        requiresReadableStyles: false,
+    },
+    reference_absent: {
+        needs: ["from"],
+        requiresAlive: ["subject"],
+        requiresReadableStyles: false,
+    },
+    token_present: {
+        needs: ["to"],
+        requiresAlive: [],
+        requiresReadableStyles: true,
+    },
+    token_absent: {
+        needs: ["from"],
+        requiresAlive: [],
+        requiresReadableStyles: true,
+    },
+    component_present: {
+        needs: [],
+        requiresAlive: [],
+        requiresReadableStyles: false,
+    },
+    component_absent: {
+        needs: [],
+        requiresAlive: [],
+        requiresReadableStyles: false,
+    },
+};
+export const DECLARABLE = [
+    "developer_declared",
+    "agent_inferred",
+    "imported",
+];
+/**
+ * AS TAREFAS, LISTA FECHADA - derivada do que a plataforma JÁ MEDE.
+ *
+ * Mesma regra do catálogo: a linguagem cresce quando a capacidade de medição cresce.
+ */
+export const TASKS = [
+    "tokens",
+    "spacing",
+    "typography",
+    "contrast",
+    "accessibility",
+    "migration",
+];
+/**
+ * O QUE O AGENTE NÃO PODE PROPOR: "ele pode propor fatos, nunca a autoridade dos fatos".
+ *
+ * `verdict` e `snapshotId` entraram nesta lista quando a fronteira de medição passou a existir: um
+ * agente que pudesse enviar `verdict: "met"` se concederia a autoridade de ter medido.
+ */
+export const DERIVED_FIELDS = [
+    "owner",
+    "fingerprint",
+    "confidence",
+    "authority",
+    "rung",
+    "status",
+    "measuredAt",
+    "measured_at",
+    "lastProgressAt",
+    "lastMeasuredAt",
+    "evidenceSource",
+    "resolution",
+    "active",
+    "verdict",
+    "progress",
+    "snapshotId",
+    "snapshot_id",
+];

package/dist/memory/observation.js

@@ -0,0 +1,77 @@
+/**
+ * A PONTE ENTRE O CENSO E O AVALIADOR - e ela é LOOKUP, não varredura.
+ *
+ * Uma condição de saída é avaliada quando existe medição (`import`, `sync`, `doctor`), e nesse
+ * momento o censo já está em memória: doze estados abertos são doze consultas a estruturas que a
+ * medição acabou de produzir. É por isso que isto cabe no `sync` e NUNCA no hook, que roda depois
+ * de cada escrita com orçamento de ~50ms e sem rede.
+ *
+ * Cada campo aqui responde a uma pergunta do catálogo, e todos vêm de coisas que o censo já
+ * carregava antes deste recurso existir:
+ *
+ *     composes        `looks[X].composes` - 206 das 323 receitas do dono carregam
+ *     hasRecipe       as chaves de `looks`
+ *     refusedByGate   `skipped` - 400 recusas naquele censo, com o motivo de cada uma
+ *     tokenDeclared   `declared`
+ *     tokenUses       `observed`, que já traz `count` e `token` por valor
+ *     stylesReadable  `coverage.shapes[].reads` - `sx` e `styled` chegam como "none"
+ */
+export function fromCensus(census) {
+    const looks = (census.looks ?? {});
+    const refused = new Map((census.skipped ?? []).map((s) => [
+        s.name,
+        { why: s.why, because: s.because },
+    ]));
+    const declared = new Set(Object.keys(census.declared ?? {}));
+    /**
+     * O USO POR TOKEN, e não por valor: `observed` lista o valor com a contagem e o token a que ele
+     * corresponde, então a soma por token é o que responde "alguém ainda usa isto".
+     */
+    const uses = new Map();
+    for (const v of census.observed ?? []) {
+        const token = v.token;
+        if (!token)
+            continue;
+        uses.set(token, (uses.get(token) ?? 0) + (v.count ?? 0));
+    }
+    /**
+     * A ÂNCORA: alguma forma de escrever estilo está sendo lida de verdade?
+     *
+     * `reads: "none"` é uma forma que o pipeline VÊ e não interpreta. Se todas as formas presentes
+     * neste projeto forem dessas, a ausência de um token não é remoção - é a lacuna de leitura que o
+     * relatório já declara em outro lugar.
+     */
+    const shapes = census.coverage?.shapes ?? [];
+    const readable = shapes.length === 0 || shapes.some((s) => s.reads !== "none");
+    /**
+     * O ÍNDICE INVERSO, montado UMA vez por medição: quem compõe cada alvo.
+     *
+     * É o que responde a população de uma migração sem varrer o censo por estado aberto - doze
+     * estados abertos continuam sendo doze consultas.
+     */
+    const inbound = new Map();
+    for (const [name, look] of Object.entries(looks)) {
+        for (const ref of look?.composes ?? []) {
+            const list = inbound.get(ref);
+            if (list)
+                list.push(name);
+            else
+                inbound.set(ref, [name]);
+        }
+    }
+    const known = new Set([...Object.keys(looks), ...inbound.keys()]);
+    return {
+        composes: (name) => {
+            const look = looks[name];
+            if (!look)
+                return null;
+            return look.composes ?? [];
+        },
+        hasRecipe: (name) => Boolean(looks[name]),
+        refusedByGate: (name) => refused.get(name) ?? null,
+        tokenDeclared: (token) => declared.has(token),
+        tokenUses: (token) => uses.get(token) ?? 0,
+        inboundRefs: (target) => known.has(target) ? (inbound.get(target) ?? []) : null,
+        stylesReadable: () => readable,
+    };
+}

package/dist/memory/predicate.js

@@ -0,0 +1,243 @@
+/**
+ * AS CONDIÇÕES DE SAÍDA DE UM TRABALHO, e o catálogo é FECHADO.
+ *
+ * Um work-state ("estamos migrando o Checkout para o novo Button") só é memória confiável se a
+ * própria realidade do repositório puder encerrá-lo. Sem isso ele fica aberto para sempre e passa a
+ * mentir com autoridade: três semanas depois o agente lê "estamos migrando" e age em cima disso.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * O PRINCÍPIO QUE GOVERNA O CRESCIMENTO DESTE ARQUIVO
+ *
+ * A linguagem das condições cresce quando a CAPACIDADE DE MEDIÇÃO cresce, nunca quando alguém
+ * imagina um caso de uso. Um predicado sem medição por trás é uma promessa que o observador não
+ * pode cumprir - e a alternativa que isto recusa é escrever uma linguagem de consulta dentro do
+ * produto, que começa com dois operadores e em seis meses é uma linguagem de programação.
+ *
+ * ─────────────────────────────────────────────────────────────────────────
+ * TRÊS ESTADOS, E NÃO DOIS - é o que impede o falso positivo de conclusão
+ *
+ * Toda condição negativa é satisfeita por duas coisas OPOSTAS: o trabalho terminou, ou o sujeito
+ * desapareceu. Este defeito já custou uma correção neste produto em outra forma - apagar um sistema
+ * fazia toda classe de bug dele virar "resolvida" sem ninguém consertar nada -, e a lição foi que
+ * `fixed` passou a exigir testemunha em vez de ser inferido de "a contagem zerou".
+ *
+ * Então o veredito é `met`, `unmet` ou INDETERMINADO. E há TRÊS causas de indeterminação, medidas no
+ * monorepo do dono em 20/08:
+ *
+ *   1. o sujeito saiu do inventário            -> pode ter sido deletado
+ *   2. o PORTÃO recusou o componente            -> 400 recusas naquele censo, com 7 motivos
+ *      (`no-styling` 190, `route` 137, `provider` 45, ...). `AddUserIcon` é recusado por
+ *      "renders but decides nothing about how anything looks" - ele EXISTE no repositório e não
+ *      tem receita. Ausência do inventário não é ausência do repositório.
+ *   3. a forma que declararia aquilo não é lida -> `sx` (14 arquivos) e `styled` (1) chegam com
+ *      `reads: "none"`. Um token declarado ali nunca foi lido, e chamar isso de "removido" é
+ *      transformar ignorância em prova.
+ *
+ * Quando a plataforma não consegue saber, ela representa que não sabe. Indeterminado vira
+ * `orphaned` no work-state, que pede uma pessoa - e é REVERSÍVEL, porque a capacidade de medição
+ * pode voltar.
+ */
+import { CATALOGUE, } from "./contract.js";
+/**
+ * PODE ESTE TRABALHO NASCER COM ESTA CONDIÇÃO? - validado na CRIAÇÃO, não na avaliação.
+ *
+ * Uma condição que nunca poderia ser verdadeira não é uma condição que falha depois: é um estado
+ * órfão desde o nascimento. Medido: 206 de 323 receitas carregam `composes`; as outras 117 são
+ * folhas, e um predicado de referência sobre uma folha nunca teria resposta.
+ */
+export function validateCondition(condition, obs) {
+    const contract = CATALOGUE[condition.type];
+    if (!contract)
+        return {
+            ok: false,
+            because: `"${condition.type}" is not a predicate this platform measures.`,
+        };
+    if (!condition.subject.trim())
+        return {
+            ok: false,
+            because: "A condition needs a subject - whose property is being checked.",
+        };
+    for (const field of contract.needs) {
+        if (!condition[field]?.trim())
+            return {
+                ok: false,
+                because: `\`${condition.type}\` needs \`${field}\` - without it the condition cannot be answered.`,
+            };
+    }
+    /**
+     * `reference_absent` COM UM ALVO NOVO É UMA TRANSIÇÃO MAL DECLARADA, e ela é recusada aqui.
+     *
+     * É uma regra de FORMA, não de intenção: quem informou para onde está migrando já tem a evidência
+     * positiva na mão, e pedir a versão fraca só pode piorar a prova.
+     */
+    if (condition.type === "reference_absent" && condition.to?.trim())
+        return {
+            ok: false,
+            because: "You named where this is going, so use `reference_replaced` - proving the old reference is gone does not prove the new one arrived.",
+        };
+    /**
+     * A SÉTIMA RECUSA: um predicado cuja capacidade de observação este projeto não oferece não pode ser
+     * registrado. A âncora é "consigo ver referências ENTRANTES para este identificador?", nunca "ele
+     * está no inventário" - medido: 119 alvos são compostos por alguém e não têm receita, 37 deles
+     * recusados pelo portão.
+     */
+    if (condition.type === "inbound_references_zero" &&
+        obs.inboundRefs(condition.subject) === null)
+        return {
+            ok: false,
+            because: `nothing in this measurement knows \`${condition.subject}\`, so the number of components composing it cannot be observed here.`,
+        };
+    if (condition.type.startsWith("reference_") &&
+        condition.type !== "inbound_references_zero" &&
+        obs.composes(condition.subject) === null)
+        return {
+            ok: false,
+            because: `\`${condition.subject}\` has no readable recipe, so nothing can be observed about what it references.`,
+        };
+    return { ok: true };
+}
+/** As referências de um componente - a comparação é por nome exato. */
+const refs = (obs, name) => obs.composes(name);
+export function evaluate(condition, obs) {
+    const contract = CATALOGUE[condition.type];
+    const { subject, from, to } = condition;
+    /**
+     * A ÂNCORA PRIMEIRO, porque ela decide se a pergunta é respondível - e não a resposta.
+     */
+    if (contract.requiresReadableStyles && !obs.stylesReadable())
+        return {
+            state: "indeterminate",
+            reason: "unreadable",
+            because: "no style form in this project is being read, so an absent token means we did not look - not that it is gone",
+        };
+    /** O que o contrato exige vivo, checado antes de qualquer `met`. */
+    for (const role of contract.requiresAlive) {
+        const name = role === "subject" ? subject : to;
+        if (!name)
+            continue;
+        if (obs.hasRecipe(name))
+            continue;
+        const refused = obs.refusedByGate(name);
+        if (refused)
+            return {
+                state: "indeterminate",
+                reason: "gate-refused",
+                because: `\`${name}\` is not in the inventory because the gate left it out (${refused.why}) - it exists in the repository, so its absence proves nothing about this work`,
+            };
+        return {
+            state: "indeterminate",
+            reason: "subject-gone",
+            because: `\`${name}\` is no longer in the inventory - this condition cannot say whether the work finished or the component went away`,
+        };
+    }
+    switch (condition.type) {
+        case "reference_replaced": {
+            const list = refs(obs, subject) ?? [];
+            const oldGone = !list.includes(from);
+            const newThere = list.includes(to);
+            if (oldGone && newThere)
+                return {
+                    state: "met",
+                    because: `\`${subject}\` no longer references \`${from}\` and now references \`${to}\``,
+                };
+            return {
+                state: "unmet",
+                because: oldGone
+                    ? `\`${subject}\` dropped \`${from}\` but does not reference \`${to}\` yet`
+                    : `\`${subject}\` still references \`${from}\``,
+            };
+        }
+        /**
+         * A ÚNICA AVALIAÇÃO QUE DEVOLVE ASSINATURA. O alvo pode ter sumido do inventário e continuar
+         * sendo composto por alguém - por isso a resposta é sobre os SÍTIOS, não sobre o inventário.
+         */
+        case "inbound_references_zero": {
+            const sites = obs.inboundRefs(subject);
+            if (sites === null)
+                return {
+                    state: "indeterminate",
+                    reason: "subject-gone",
+                    because: `nothing in this measurement knows \`${subject}\`, so its retirement cannot be observed`,
+                };
+            return sites.length === 0
+                ? {
+                    state: "met",
+                    because: `no component composes \`${subject}\` any more`,
+                    progress: { remaining: 0 },
+                }
+                : {
+                    state: "unmet",
+                    because: `${sites.length} component${sites.length === 1 ? "" : "s"} still compose${sites.length === 1 ? "s" : ""} \`${subject}\``,
+                    progress: { remaining: sites.length },
+                };
+        }
+        case "reference_present": {
+            const list = refs(obs, subject) ?? [];
+            return list.includes(to)
+                ? { state: "met", because: `\`${subject}\` references \`${to}\`` }
+                : {
+                    state: "unmet",
+                    because: `\`${subject}\` does not reference \`${to}\``,
+                };
+        }
+        case "reference_absent": {
+            const list = refs(obs, subject) ?? [];
+            return list.includes(from)
+                ? {
+                    state: "unmet",
+                    because: `\`${subject}\` still references \`${from}\``,
+                }
+                : {
+                    state: "met",
+                    because: `\`${subject}\` no longer references \`${from}\``,
+                };
+        }
+        case "token_present": {
+            const token = to;
+            return obs.tokenDeclared(token)
+                ? { state: "met", because: `\`${token}\` is declared` }
+                : { state: "unmet", because: `\`${token}\` is not declared yet` };
+        }
+        case "token_absent": {
+            const token = from;
+            const uses = obs.tokenUses(token);
+            if (obs.tokenDeclared(token))
+                return { state: "unmet", because: `\`${token}\` is still declared` };
+            return uses > 0
+                ? {
+                    state: "unmet",
+                    because: `\`${token}\` is undeclared but still used in ${uses} place${uses === 1 ? "" : "s"}`,
+                }
+                : {
+                    state: "met",
+                    because: `\`${token}\` is neither declared nor used`,
+                };
+        }
+        case "component_present":
+            return obs.hasRecipe(subject)
+                ? { state: "met", because: `\`${subject}\` is in the inventory` }
+                : { state: "unmet", because: `\`${subject}\` is not in the inventory` };
+        /**
+         * A AUSÊNCIA DE COMPONENTE É A MAIS ARMADILHADA DAS SETE, e por isso ela checa o portão antes
+         * de responder: `AddUserIcon` sai do inventário por "no-styling" e continua no repositório.
+         */
+        case "component_absent": {
+            if (obs.hasRecipe(subject))
+                return {
+                    state: "unmet",
+                    because: `\`${subject}\` is still in the inventory`,
+                };
+            const refused = obs.refusedByGate(subject);
+            if (refused)
+                return {
+                    state: "indeterminate",
+                    reason: "gate-refused",
+                    because: `\`${subject}\` left the inventory because the gate refused it (${refused.why}), not because it was removed`,
+                };
+            return {
+                state: "met",
+                because: `\`${subject}\` is not in the inventory`,
+            };
+        }
+    }
+}

package/dist/memory/recall.js

@@ -0,0 +1,161 @@
+/**
+ * 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/report.js

@@ -0,0 +1,31 @@
+import { measure, snapshotOf } from "./snapshot.js";
+export async function reportMeasurement(args) {
+    const answer = await args.open().catch((e) => ({
+        ok: false,
+        reason: "error",
+        detail: e instanceof Error ? e.message : String(e),
+    }));
+    if (!answer.ok) {
+        if (answer.reason === "not-installed")
+            return { measured: 0, skipped: "not-installed" };
+        return {
+            measured: 0,
+            skipped: null,
+            failed: {
+                ...(answer.status ? { status: answer.status } : {}),
+                ...(answer.detail ? { detail: answer.detail } : {}),
+            },
+        };
+    }
+    if (answer.open.length === 0)
+        return { measured: 0, skipped: "no-open-work" };
+    const snapshot = snapshotOf({
+        at: args.at,
+        ...(args.cli ? { cli: args.cli } : {}),
+        ...(args.interpretation ? { interpretation: args.interpretation } : {}),
+        ...(args.scope ? { scope: args.scope } : {}),
+    });
+    const { verdicts } = measure(answer.open, args.obs, snapshot);
+    await args.send({ snapshot, verdicts });
+    return { measured: verdicts.length, skipped: null };
+}

package/dist/memory/snapshot.js

@@ -0,0 +1,47 @@
+import { createHash } from "node:crypto";
+import { evaluate } from "./predicate.js";
+export function snapshotOf(input) {
+    const id = createHash("sha256")
+        .update([
+        input.cli ?? "",
+        input.interpretation ?? "",
+        input.scope ?? "",
+        input.at,
+    ].join("|"))
+        .digest("hex")
+        .slice(0, 16);
+    return {
+        id,
+        at: input.at,
+        by: {
+            ...(input.cli ? { cli: input.cli } : {}),
+            ...(input.interpretation ? { interpretation: input.interpretation } : {}),
+        },
+        ...(input.scope ? { scope: input.scope } : {}),
+    };
+}
+/**
+ * O QUE O CLIENTE MANDA PELO CANAL DE MEDIÇÃO - veredictos, nunca o censo.
+ *
+ * A plataforma não precisa saber QUAIS eram os 32 componentes que ainda compõem o `Loader`: precisa
+ * saber que eram 32, medidos por qual leitor, em qual snapshot. Menos dado atravessando, menos
+ * acoplamento entre versões, e menos exposição do repositório de quem confiou na gente.
+ *
+ * Todos os veredictos de uma execução saem do MESMO snapshot: é o que impede dois estados avaliados
+ * juntos de enxergarem repositórios diferentes.
+ */
+export function measure(conditions, obs, snapshot) {
+    return {
+        snapshot,
+        verdicts: conditions.map(({ id, exit }) => ({
+            id,
+            snapshotId: snapshot.id,
+            predicate: exit.type,
+            subject: exit.subject,
+            ...(exit.from ? { from: exit.from } : {}),
+            ...(exit.to ? { to: exit.to } : {}),
+            verdict: evaluate(exit, obs),
+            by: snapshot.by,
+        })),
+    };
+}