first commit

kanban/main.py

@@ -0,0 +1,557 @@
+"""
+Kanban da sala de DTF — roda no servidor da fábrica, rede interna.
+
+Princípio: o KANBAN é a única interface. O operador move o card aqui e as
+pastas do servidor seguem sozinhas — ninguém abre o Explorer.
+Decidido em 30/08/2026: não existe watchdog de pastas. Movimento feito fora do
+kanban não é suportado.
+
+A fila é sempre por HORÁRIO DE CHEGADA: quem chegou primeiro fica em cima.
+Mover o card grava o movimento, move o arquivo, enfileira o marcador no Tiny
+e o WhatsApp ao cliente. Ninguém abre o Tiny para atualizar nada.
+
+O log de movimentos é gravado SEMPRE, mesmo se o Tiny estiver fora do ar.
+A medição de tempo por etapa nunca depende de API de terceiro.
+
+Rodar:
+    uvicorn main:app --host 0.0.0.0 --port 8080
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sqlite3
+import threading
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse, RedirectResponse
+from pydantic import BaseModel
+
+import tiny
+import whats
+
+BANCO = Path(os.environ.get("KANBAN_DB", r"C:\dtf\kanban.db"))
+RAIZ = Path(os.environ.get("PASTA_DTF", r"\\servidor\DTF"))
+
+# O KANBAN é a fonte de verdade da operação. O marcador no Tiny existe só para
+# quem NÃO abre o kanban: comercial atendendo cliente no telefone, expedição
+# conferindo se o DTF saiu, e o Marcus olhando pelo celular fora da fábrica.
+#
+# Por isso o Tiny recebe o estágio grosso, não o detalhe fino:
+#   está sendo feito · travou · ficou pronto
+#
+# Três chamadas por pedido em vez de sete. A 213 pedidos/dia, são 640 requisições
+# em vez de 1.500 — folga no limite da API e menos job para o TI monitorar.
+COLUNAS = [
+    ("aut", "Aguardando autorização", "05_AUTORIZACAO", None,          False),  # só retrabalho
+    ("rec", "Arte recebida",      "00_ARTE_RECEBIDA",  None,           False),
+    ("tra", "Arte tratada",       "10_ARTE_TRATADA",   None,           False),
+    ("apc", "Aprovação de cor",   "15_APROVACAO_COR",  "DTF-PROVA-COR",False),
+    ("fil", "Fila de impressão",  "20_FILA_IMPRESSAO", None,           False),
+    ("imp", "Imprimindo",         "30_IMPRIMINDO",     "DTF-PRODUCAO", False),
+    ("cor", "Correção",           "40_CORRECAO",       "CORRECAO DTF", False),
+    ("fin", "Finalizado",         "60_FINALIZADO",     "DTF-PRONTO",   False),
+]
+# A sala só IMPRIME o filme — quem aplica na peça é o cliente.
+# Por isso não existe coluna de aplicação nem causa de retrabalho por aplicação.
+IDS = [c[0] for c in COLUNAS]
+INFO = {c[0]: c for c in COLUNAS}
+AVISA_CLIENTE = {"apc": "prova_cor", "imp": "producao",
+                 "cor": "correcao", "fin": "concluido"}
+
+app = FastAPI(title="Kanban DTF")
+
+# ---------------------------------------------------------------------------
+# Distribuição entre as máquinas — POR PUXADA, não por empurro
+# ---------------------------------------------------------------------------
+# O sistema NÃO decide qual máquina roda qual pedido. A fila é única, por
+# horário de chegada, e a máquina que termina puxa o próximo.
+#
+# Empurrar exigiria adivinhar qual máquina estará livre daqui a duas horas. Se
+# uma travar, a fila dela para enquanto outra fica ociosa, e alguém remaneja na
+# mão. Por puxada nunca desbalanceia.
+#
+# Para o operador: um botão "puxar próximo". O arquivo já vem com o spot pronto
+# do robô — ele só abre no Flexi e roda.
+# Ajustado em 02/09/2026 pelo Thales e Alexandre:
+#   "reserva de 15 min é demais, no máx 3 min"
+#   "pedido por vez" — não puxar lote de trabalho
+RESERVA_MIN = 3           # sem entrar em Imprimindo nesse prazo, volta para a fila
+PUXAR_ATE_MIN = 0         # 0 = um pedido por vez, como a sala pediu
+
+
+class Puxar(BaseModel):
+    maquina: int
+    usuario: str
+    minutos: int = PUXAR_ATE_MIN
+
+
+@app.post("/api/puxar")
+def puxar(p: Puxar):
+    """
+    A máquina puxa o próximo da fila. Reserva por 15 min e move o arquivo para
+    a hot folder daquela máquina — o FlexiPRINT processa sozinho de lá.
+    """
+    agora = datetime.now()
+    limite = (agora - timedelta(minutes=RESERVA_MIN)).isoformat(timespec="seconds")
+    pegos, minutos = [], 0
+
+    with con() as c:
+        # solta reservas vencidas antes de distribuir
+        c.execute("UPDATE card SET reservado_por=NULL, reservado_em=NULL "
+                  "WHERE reservado_em IS NOT NULL AND reservado_em < ?", (limite,))
+
+        fila = c.execute(
+            "SELECT * FROM card WHERE coluna='fil' AND reservado_por IS NULL "
+            "ORDER BY desde").fetchall()          # sempre por horário de chegada
+
+        for card in fila:
+            # estimativa de máquina: o campo do card manda; sem ele, calcula pelos metros
+            mm = card["minutos_maquina"] or round(card["metros"] / 20 * 60)
+            if pegos:                      # um pedido por vez
+                break
+            c.execute("UPDATE card SET reservado_por=?, reservado_em=?, maquina=? "
+                      "WHERE arte_id=?",
+                      (f"Maq {p.maquina}", agora.isoformat(timespec="seconds"),
+                       f"Maq {p.maquina}", card["arte_id"]))
+            mover_arquivos(card["pedido"], "20_FILA_IMPRESSAO", f"30_MAQ{p.maquina}")
+            pegos.append({"pedido": card["pedido"], "metros": card["metros"],
+                          "minutos": mm})
+            minutos += mm
+
+    return {"maquina": f"Maq {p.maquina}", "pedidos": pegos,
+            "minutos_total": minutos,
+            "reserva_expira_em": RESERVA_MIN}
+
+
+@app.post("/api/devolver")
+def devolver(arte_id: int, usuario: str):
+    """
+    Máquina travou no meio. O pedido volta ao TOPO da fila, não ao fim —
+    ele já esperou uma vez.
+    """
+    with con() as c:
+        card = c.execute("SELECT * FROM card WHERE arte_id=?", (arte_id,)).fetchone()
+        if not card:
+            raise HTTPException(404)
+        maq = (card["maquina"] or "Maq 1").replace("Maq ", "")
+        mover_arquivos(card["pedido"], f"30_MAQ{maq}", "20_FILA_IMPRESSAO")
+        # desde antigo = volta para o topo da ordem por horário de chegada
+        c.execute("UPDATE card SET coluna='fil', reservado_por=NULL, "
+                  "reservado_em=NULL, maquina=NULL WHERE arte_id=?", (arte_id,))
+        c.execute("""INSERT INTO movimento
+            (arte_id,pedido,de,para,entrou_em,saiu_em,segundos,usuario,maquina)
+            VALUES (?,?,?,?,?,?,?,?,?)""",
+            (arte_id, card["pedido"], "imp", "fil", card["desde"],
+             datetime.now().isoformat(timespec="seconds"), 0, usuario, card["maquina"]))
+    return {"ok": True, "voltou_ao_topo": True}
+
+
+# ---------------------------------------------------------------------------
+# Aprovação de cor — evita o retrabalho em vez de repor depois
+# ---------------------------------------------------------------------------
+# Imprime uma amostra pequena, fotografa e manda ao cliente. Ele aprova, e só
+# então o pedido vai para a fila. Custa centímetros de filme e evita metros.
+#
+# Dispara sozinho em três situações:
+PROVA_METROS = 10.0        # arquivo grande: erro de cor custa caro
+PROVA_CLIENTE_NOVO = True  # primeiro pedido do cliente
+# cores fora do gamut CMYK, que quase nunca saem como o cliente vê na tela
+PROVA_CORES_TENSAS = {
+    "vermelho_saturado", "laranja", "verde_vivo", "azul_royal",
+    "roxo", "tom_de_pele", "cinza_neutro",
+}
+
+
+def precisa_prova_cor(metros: float, cliente_novo: bool,
+                      cores_detectadas: set[str]) -> tuple[bool, str]:
+    if metros >= PROVA_METROS:
+        return True, f"arquivo de {metros:.1f} m"
+    if cliente_novo and PROVA_CLIENTE_NOVO:
+        return True, "primeiro pedido do cliente"
+    tensas = cores_detectadas & PROVA_CORES_TENSAS
+    if tensas:
+        return True, "cor fora do gamut: " + ", ".join(sorted(tensas))
+    return False, ""
+
+# ---------------------------------------------------------------------------
+# Retrabalho — SKU CRRMP.TX.100CM
+# ---------------------------------------------------------------------------
+# A causa é obrigatória e define quem absorve o custo. Sem ela o card não anda.
+CAUSAS = {
+    "arte_cliente":  ("Arte ruim aprovada pelo cliente", "cliente"),
+    "tratamento":    ("Erro de tratamento",              "casa"),
+    "impressao":     ("Falha de impressão",              "casa"),
+    "perfil_cor":    ("Perfil de cor",                   "casa"),
+    "pedido":        ("Erro de pedido",                  "casa"),
+}
+
+# Quem abre e quem autoriza são pessoas diferentes, de propósito.
+#
+#   MAYANA abre e CLASSIFICA a causa. Ela conhece o cliente e sabe se a
+#   reclamação procede. A causa fica TRAVADA depois de aberta.
+#
+#   THALES ou ALEXANDRE autorizam. O retrabalho da casa entra na meta e na
+#   remuneração deles — então têm incentivo real para questionar o que não
+#   procede. É controle natural, não burocracia.
+#
+# Por que a causa não pode ser mudada por quem autoriza: com o indicador
+# atrelado a bônus, existiria incentivo para reclassificar falha de máquina
+# como "arte do cliente". Quem discorda CONTESTA, e a contestação fica
+# registrada com quem pediu e quem decidiu.
+ABRE = "mayana"
+AUTORIZA = ("thales", "alexandre")
+
+# Alçada por metragem. Cada metro custa R$ 4,94 de insumo mais tempo de máquina.
+ALCADA = [(15.0, "sala"), (float("inf"), "financeiro")]
+# Meta por causa, não meta única. Cada um responde pelo que controla.
+# 0,4% em cada uma das quatro causas da casa = 1,6% no total.
+#
+# Perfil de cor é causa PRÓPRIA, separada de falha de impressão. Cor errada é o
+# retrabalho mais comum de DTF e quase nunca é defeito de máquina: ou a arte
+# veio em CMYK, ou o monitor do cliente não é calibrado, ou o perfil da
+# impressora está desatualizado. Só o terceiro é da casa — e separando dá para
+# saber quanto é cada coisa.
+META_POR_CAUSA = {
+    "impressao":    (0.4, "Thales e Alexandre"),
+    "perfil_cor":   (0.4, "Thales e Alexandre"),
+    "tratamento":   (0.4, "designers"),
+    "pedido":       (0.4, "comercial"),
+    "arte_cliente": (None, None),   # reposição comercial: fora da meta
+}
+# soma das metas da casa = 1,6%
+TETO_MES_PCT = 6.0        # acima disso tudo sobe uma alçada
+TETO_CLIENTE_PCT = 10.0   # cliente acima disso fica sinalizado no painel
+
+
+def quem_autoriza(metros: float, vez: int, pct_mes: float) -> str:
+    """Reincidência e teto do mês sobem a alçada automaticamente."""
+    if vez >= 3:
+        return "diretoria"
+    nivel = next(n for lim, n in ALCADA if metros <= lim)
+    if vez == 2:
+        nivel = {"sala": "financeiro"}.get(nivel, "diretoria")
+    if pct_mes > TETO_MES_PCT:
+        nivel = {"sala": "financeiro", "financeiro": "diretoria"}.get(nivel, "diretoria")
+    return nivel
+
+
+def conta_na_meta(causa: str) -> bool:
+    """Só o retrabalho da casa entra na meta. O do cliente, não."""
+    return CAUSAS[causa][1] == "casa"
+
+
+@app.get("/api/relatorio/retrabalho")
+def retrabalho(dias: int = 30):
+    """
+    Retrabalho por causa, com responsável e meta.
+    Base para a bonificação: cada equipe é medida só pelo que controla.
+    """
+    with con() as c:
+        total = c.execute(
+            "SELECT COUNT(*) n FROM card WHERE desde >= date('now', ?)",
+            (f"-{dias} days",)).fetchone()["n"] or 1
+        linhas = c.execute("""
+            SELECT causa, COUNT(*) n, SUM(metros) m
+            FROM retrabalho WHERE aberto_em >= date('now', ?)
+            GROUP BY causa""", (f"-{dias} days",)).fetchall()
+
+    saida, casa = [], 0.0
+    for r in linhas:
+        pct = r["n"] / total * 100
+        meta, quem = META_POR_CAUSA.get(r["causa"], (None, None))
+        if conta_na_meta(r["causa"]):
+            casa += pct
+        saida.append({
+            "causa": r["causa"], "descricao": CAUSAS[r["causa"]][0],
+            "responsavel": quem, "pedidos": r["n"], "metros": r["m"],
+            "pct": round(pct, 2), "meta": meta,
+            "bate": None if meta is None else pct <= meta,
+        })
+    return {"por_causa": saida, "total_casa_pct": round(casa, 2),
+            "meta_casa_pct": round(sum(m for m, _ in META_POR_CAUSA.values()
+                                       if m is not None), 2)}
+
+# --------------------------------------------------------------------------
+def con():
+    c = sqlite3.connect(BANCO, timeout=10)
+    c.row_factory = sqlite3.Row
+    return c
+
+
+def criar_tabelas() -> None:
+    with con() as c:
+        c.executescript("""
+        CREATE TABLE IF NOT EXISTS card(
+            arte_id INTEGER PRIMARY KEY, pedido TEXT, cliente TEXT, metros REAL,
+            coluna TEXT DEFAULT 'rec', desde TEXT, maquina TEXT, partes INTEGER,
+            reservado_por TEXT, reservado_em TEXT,
+            minutos_maquina INTEGER);   -- estimativa; herda os marcadores 30min/1h/3h
+        CREATE TABLE IF NOT EXISTS movimento(
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            arte_id INTEGER, pedido TEXT, de TEXT, para TEXT,
+            entrou_em TEXT, saiu_em TEXT, segundos INTEGER,
+            usuario TEXT, maquina TEXT);
+        CREATE TABLE IF NOT EXISTS job(
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            tipo TEXT, payload TEXT, tentativas INTEGER DEFAULT 0,
+            proxima_em REAL, erro TEXT, feito INTEGER DEFAULT 0);
+        CREATE INDEX IF NOT EXISTS ix_mov_arte ON movimento(arte_id);
+        CREATE INDEX IF NOT EXISTS ix_job_fila ON job(feito, proxima_em);
+        """)
+
+
+criar_tabelas()
+
+
+# --------------------------------------------------------------------------
+class Mover(BaseModel):
+    arte_id: int
+    para: str
+    usuario: str
+    maquina: str | None = None
+
+
+@app.get("/api/quadro")
+def quadro():
+    agora = datetime.now()
+    with con() as c:
+        cards = c.execute("SELECT * FROM card ORDER BY desde").fetchall()
+
+    saida = {i: [] for i in IDS}
+    for r in cards:
+        desde = datetime.fromisoformat(r["desde"])
+        saida[r["coluna"]].append({
+            "arte_id": r["arte_id"], "pedido": r["pedido"], "cliente": r["cliente"],
+            "metros": r["metros"], "maquina": r["maquina"], "partes": r["partes"],
+            "desde": r["desde"],
+            "parado_seg": int((agora - desde).total_seconds()),
+            "minutos_maquina": round(r["metros"] / 20 * 60),   # 20 m/h por máquina
+        })
+    return {"colunas": [{"id": c[0], "nome": c[1]} for c in COLUNAS], "cards": saida}
+
+
+@app.post("/api/mover")
+def mover(m: Mover):
+    if m.para not in IDS:
+        raise HTTPException(400, "coluna inválida")
+
+    agora = datetime.now()
+    with con() as c:
+        card = c.execute("SELECT * FROM card WHERE arte_id=?", (m.arte_id,)).fetchone()
+        if not card:
+            raise HTTPException(404, "card não encontrado")
+        if card["coluna"] == m.para:
+            return {"ok": True, "sem_mudanca": True}
+
+        de = card["coluna"]
+        desde = datetime.fromisoformat(card["desde"])
+
+        # 1. o movimento é gravado ANTES de qualquer integração externa
+        c.execute("""INSERT INTO movimento
+            (arte_id,pedido,de,para,entrou_em,saiu_em,segundos,usuario,maquina)
+            VALUES (?,?,?,?,?,?,?,?,?)""",
+            (m.arte_id, card["pedido"], de, m.para, card["desde"],
+             agora.isoformat(timespec="seconds"),
+             int((agora - desde).total_seconds()), m.usuario,
+             m.maquina or card["maquina"]))
+
+        c.execute("UPDATE card SET coluna=?, desde=?, maquina=COALESCE(?,maquina) "
+                  "WHERE arte_id=?",
+                  (m.para, agora.isoformat(timespec="seconds"), m.maquina, m.arte_id))
+
+        # 2. arquivo acompanha o card
+        mover_arquivos(card["pedido"], INFO[de][2], INFO[m.para][2])
+
+        # 3. jobs: marcador no Tiny e WhatsApp
+        # a máquina fica só no kanban — no Tiny basta saber que entrou em produção
+        marcador = INFO[m.para][3]
+        if marcador:
+            enfileirar(c, "tiny_marcador",
+                       {"pedido": card["pedido"], "marcador": marcador})
+        if m.para in AVISA_CLIENTE:
+            enfileirar(c, "whats",
+                       {"pedido": card["pedido"], "tipo": AVISA_CLIENTE[m.para]})
+
+    return {"ok": True, "de": de, "para": m.para}
+
+
+def mover_arquivos(pedido: str, pasta_de: str, pasta_para: str) -> None:
+    origem, destino = RAIZ / pasta_de, RAIZ / pasta_para
+    destino.mkdir(parents=True, exist_ok=True)
+    for f in origem.glob(f"{pedido}_*"):
+        shutil.move(str(f), str(destino / f.name))
+
+
+# --------------------------------------------------------------------------
+# Fila de jobs — tabela simples, sem Redis nem Celery
+# --------------------------------------------------------------------------
+def enfileirar(c, tipo: str, payload: dict) -> None:
+    c.execute("INSERT INTO job(tipo,payload,proxima_em) VALUES (?,?,?)",
+              (tipo, json.dumps(payload), time.time()))
+
+
+ESPERA = [60, 300, 1800]   # 1 min, 5 min, 30 min
+
+
+def worker() -> None:
+    while True:
+        try:
+            with con() as c:
+                job = c.execute(
+                    "SELECT * FROM job WHERE feito=0 AND proxima_em<=? "
+                    "ORDER BY id LIMIT 1", (time.time(),)).fetchone()
+                if not job:
+                    time.sleep(3)
+                    continue
+
+                p = json.loads(job["payload"])
+                try:
+                    if job["tipo"] == "tiny_marcador":
+                        tiny.marcador(p["pedido"], p["marcador"])
+                    elif job["tipo"] == "whats":
+                        whats.avisar(p["pedido"], p["tipo"])
+                    c.execute("UPDATE job SET feito=1 WHERE id=?", (job["id"],))
+                except Exception as e:
+                    n = job["tentativas"] + 1
+                    if n > len(ESPERA):
+                        c.execute("UPDATE job SET feito=1, erro=? WHERE id=?",
+                                  (f"desistiu: {e}", job["id"]))
+                        # TODO: alertar o TI
+                    else:
+                        c.execute(
+                            "UPDATE job SET tentativas=?, proxima_em=?, erro=? WHERE id=?",
+                            (n, time.time() + ESPERA[n - 1], str(e), job["id"]))
+        except Exception:
+            time.sleep(5)
+
+
+threading.Thread(target=worker, daemon=True).start()
+
+
+# --------------------------------------------------------------------------
+# QR do carimbo aponta para cá
+# --------------------------------------------------------------------------
+@app.get("/p/{pedido}")
+def abrir_card(pedido: str):
+    """A revisão bipa o QR do filme e cai direto no card."""
+    with con() as c:
+        card = c.execute("SELECT arte_id FROM card WHERE pedido=?", (pedido,)).fetchone()
+    if not card:
+        raise HTTPException(404, "pedido não encontrado no kanban")
+    return RedirectResponse(f"/?card={card['arte_id']}")
+
+
+@app.get("/api/pedido/{pedido}")
+def trilha(pedido: str):
+    """Tempo em cada etapa e quanto do total foi só esperando."""
+    PARADO = {"rec", "tra", "fil", "cor"}
+    with con() as c:
+        movs = c.execute(
+            "SELECT * FROM movimento WHERE pedido=? ORDER BY id", (pedido,)).fetchall()
+        card = c.execute("SELECT * FROM card WHERE pedido=?", (pedido,)).fetchone()
+    if not card:
+        raise HTTPException(404)
+
+    agora = int((datetime.now() - datetime.fromisoformat(card["desde"])).total_seconds())
+    etapas = [{"coluna": m["de"], "nome": INFO[m["de"]][1], "segundos": m["segundos"]}
+              for m in movs]
+    etapas.append({"coluna": card["coluna"], "nome": INFO[card["coluna"]][1],
+                   "segundos": agora, "atual": True})
+
+    total = sum(e["segundos"] for e in etapas)
+    esperando = sum(e["segundos"] for e in etapas if e["coluna"] in PARADO)
+    return {"pedido": pedido, "cliente": card["cliente"], "metros": card["metros"],
+            "etapas": etapas, "total_seg": total, "esperando_seg": esperando}
+
+
+PERIODOS = {"hoje": 1, "7": 7, "30": 30, "mes": 30, "ant": 60}
+
+
+@app.get("/api/relatorio/impressao")
+def tempo_impressao(dias: int = 7):
+    """
+    Tempo médio de impressão e velocidade real por máquina.
+    Sai da coluna 'imp' da tabela movimento, cruzada com os metros do card.
+    É este número que diz se 20 m/h é a velocidade real ou só a de catálogo.
+    """
+    with con() as c:
+        linhas = c.execute("""
+            SELECT m.maquina, COUNT(*) n,
+                   AVG(m.segundos) media_seg,
+                   SUM(c.metros) metros,
+                   SUM(m.segundos) total_seg
+            FROM movimento m JOIN card c ON c.arte_id = m.arte_id
+            WHERE m.de = 'imp' AND m.saiu_em >= date('now', ?)
+            GROUP BY m.maquina""", (f"-{dias} days",)).fetchall()
+    saida = []
+    for r in linhas:
+        horas = (r["total_seg"] or 0) / 3600
+        saida.append({
+            "maquina": r["maquina"], "pedidos": r["n"],
+            "media_min": round((r["media_seg"] or 0) / 60),
+            "metros": round(r["metros"] or 0, 1),
+            "m_por_hora": round((r["metros"] or 0) / horas, 1) if horas else None,
+        })
+    return saida
+
+
+# Depósito do Tiny para onde o insumo é transferido antes de imprimir.
+# A Altus também VENDE insumo, então esse depósito separa o que é consumo
+# interno do que é revenda. Confirmar o nome exato no cadastro do Tiny.
+DEPOSITO_IMPRESSAO = "Sala DTF"
+SKU_FILME = "DTF.FILME.57"
+
+
+@app.get("/api/relatorio/aproveitamento")
+def aproveitamento(dias: int = 30):
+    """
+    Quanto do filme transferido virou metro faturado.
+
+    Compra-se rolo de 100 m e imprime-se cerca de 90, por acerto de máquina,
+    prova de cor, refile e sobra de ponta. Cada ponto percentual vale cerca de
+    R$ 980/mês no volume atual.
+
+    NÃO exige apontamento novo na sala: o consumo já é registrado hoje, quando
+    o insumo é transferido para o depósito de impressão no Tiny. Este endpoint
+    só lê a movimentação desse depósito.
+    """
+    fat = 0.0
+    with con() as c:
+        fat = c.execute(
+            "SELECT SUM(metros) m FROM card WHERE coluna='fin' AND desde >= date('now', ?)",
+            (f"-{dias} days",)).fetchone()["m"] or 0
+
+    cons = tiny.transferido_para_deposito(
+        sku=SKU_FILME, deposito=DEPOSITO_IMPRESSAO, dias=dias)
+
+    pct = fat / cons * 100 if cons else None
+    return {"metros_faturados": round(fat, 1),
+            "metros_de_filme": round(cons, 1),
+            "fonte": f"transferências para o depósito {DEPOSITO_IMPRESSAO} no Tiny",
+            "aproveitamento_pct": round(pct, 1) if pct else None,
+            "valor_do_ponto_mes": 980}
+
+
+@app.get("/api/relatorio/etapas")
+def relatorio(dias: int = 7):
+    """Tempo médio por etapa. É o número que hoje não existe em lugar nenhum."""
+    with con() as c:
+        linhas = c.execute("""
+            SELECT de, COUNT(*) n, AVG(segundos) media, MAX(segundos) pior
+            FROM movimento
+            WHERE saiu_em >= date('now', ?)
+            GROUP BY de""", (f"-{dias} days",)).fetchall()
+    return [{"coluna": r["de"], "nome": INFO[r["de"]][1], "movimentos": r["n"],
+             "media_min": round(r["media"] / 60), "pior_min": round(r["pior"] / 60)}
+            for r in linhas]
+
+
+@app.get("/")
+def index():
+    return FileResponse("static/kanban.html")

kanban/static/kanban.html

@@ -0,0 +1,271 @@
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>DTF · sala de impressão</title>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@500;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
+<style>
+:root{--bg:#0B0D10;--card:#15181D;--card2:#1C2026;--linha:#282C34;--tx:#EDEBE6;--fraco:#7C828C;
+ --ciano:#00B8DA;--magenta:#E0357C;--amarelo:#EFB700;--branco:#EDEBE6;--verde:#48B072;
+ --alerta:#E0642A;--roxo:#8E7CE8}
+*{box-sizing:border-box;margin:0;padding:0}
+body{background:var(--bg);color:var(--tx);font-family:"IBM Plex Mono",ui-monospace,monospace;
+ font-size:14px;line-height:1.45;-webkit-font-smoothing:antialiased;padding:16px 14px 34px}
+h1,h2{font-family:"Space Grotesk",system-ui,sans-serif;letter-spacing:-.02em}
+.topo{display:flex;align-items:baseline;gap:14px;flex-wrap:wrap;margin-bottom:6px}
+h1{font-size:23px;font-weight:700}
+.sub{color:var(--fraco);font-size:12px}
+.rel{margin-left:auto;font-family:"Space Grotesk",sans-serif;font-size:19px;font-weight:700;color:var(--ciano)}
+
+.aviso{background:#152026;border:1px solid #24404A;border-left:3px solid var(--ciano);
+ border-radius:0 8px 8px 0;padding:10px 14px;font-size:12.5px;color:#B9CBD2;margin:10px 0 14px}
+.aviso b{color:var(--ciano);font-family:"Space Grotesk",sans-serif}
+
+/* máquinas */
+.maqs{display:grid;grid-template-columns:repeat(6,1fr);gap:8px;margin-bottom:14px}
+@media(max-width:900px){.maqs{grid-template-columns:repeat(3,1fr)}}
+.mq{background:var(--card);border:1px solid var(--linha);border-radius:9px;padding:11px 12px;position:relative}
+.mq.ocup{border-color:var(--alerta)}
+.mq .luz{width:11px;height:11px;border-radius:50%;position:absolute;top:11px;right:11px;background:var(--verde)}
+.mq.ocup .luz{background:var(--alerta);box-shadow:0 0 0 3px rgba(224,100,42,.2)}
+.mq b{font-family:"Space Grotesk",sans-serif;font-size:13px;display:block;margin-bottom:4px}
+.mq .st{font-size:10.5px;color:var(--fraco);line-height:1.4;min-height:28px}
+.mq button{margin-top:8px;width:100%;font-family:inherit;font-size:11px;padding:6px;border-radius:6px;
+ border:1px solid var(--linha);background:var(--card2);color:var(--fraco);cursor:pointer}
+.mq.livre button{background:var(--ciano);border-color:var(--ciano);color:#03181D;font-weight:600}
+.mq.livre button:hover{filter:brightness(1.1)}
+.mq.ocup button{opacity:.4;cursor:default}
+
+/* kpis */
+.kpis{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:9px;margin-bottom:14px}
+.k{background:var(--card);border:1px solid var(--linha);border-radius:9px;padding:11px 14px;border-left:3px solid var(--c,var(--linha))}
+.k dt{font-size:10px;letter-spacing:.15em;text-transform:uppercase;color:var(--fraco);margin-bottom:3px}
+.k dd{font-family:"Space Grotesk",sans-serif;font-size:23px;font-weight:700}
+.k dd small{font-size:12px;color:var(--fraco);font-weight:400;font-family:"IBM Plex Mono",monospace}
+
+/* kanban */
+.kan{display:grid;grid-template-columns:repeat(7,minmax(140px,1fr));gap:8px;overflow-x:auto;padding-bottom:16px}
+@media(max-width:1200px){.kan{grid-template-columns:repeat(7,168px)}}
+.col{background:var(--card);border:1px solid var(--linha);border-radius:9px;display:flex;flex-direction:column;min-height:250px}
+.col.alvo{border-color:var(--ciano);background:#101820}
+.ch{padding:10px 11px 8px;border-bottom:1px solid var(--linha)}
+.ch b{font-family:"Space Grotesk",sans-serif;font-size:12px;display:block}
+.ch b .p{display:inline-block;width:7px;height:7px;border-radius:50%;margin-right:6px;background:var(--cc)}
+.ch small{font-size:10px;color:var(--fraco)}
+.cb{padding:8px;display:flex;flex-direction:column;gap:6px;flex:1}
+.vazio{color:var(--fraco);font-size:10.5px;text-align:center;padding:14px 4px}
+.cd{background:var(--card2);border:1px solid var(--linha);border-left:3px solid var(--cc);
+ border-radius:5px;padding:8px 9px;cursor:grab;font-size:11px}
+.cd:active{cursor:grabbing}
+.cd.arrasta{opacity:.35}
+.cd b{display:block;font-family:"Space Grotesk",sans-serif;font-size:12.5px}
+.cd .cli{color:var(--fraco);font-size:10px;margin:1px 0 5px}
+.cd .l{display:flex;justify-content:space-between;font-size:10px}
+.cd .l i{font-style:normal;color:var(--fraco)}
+.cd .mq2{display:inline-block;font-size:9px;padding:1px 5px;border-radius:3px;background:var(--linha);margin-top:4px}
+.cd.q .l i{color:var(--amarelo)}
+.cd.r{border-left-color:var(--alerta)}
+.cd.r .l i{color:var(--alerta)}
+
+.rod{margin-top:14px;display:flex;gap:9px;align-items:center;flex-wrap:wrap;color:var(--fraco);font-size:11.5px}
+.rod button{font-family:inherit;font-size:11.5px;padding:7px 12px;border-radius:7px;
+ border:1px solid var(--linha);background:none;color:var(--fraco);cursor:pointer}
+.rod button:hover{border-color:var(--ciano);color:var(--ciano)}
+@media(prefers-reduced-motion:reduce){*{transition:none!important}}
+</style>
+</head>
+<body>
+
+<div class="topo">
+  <h1>Kanban da sala de DTF</h1>
+  <span class="sub" id="ctx">carregando…</span>
+  <span class="rel" id="hora">—</span>
+</div>
+
+<div class="aviso" id="aviso" style="display:none"></div>
+
+<div class="maqs" id="maqs"></div>
+<dl class="kpis" id="kpis"></dl>
+<div class="kan" id="kan"></div>
+
+<div class="rod">
+  <button id="atualizar">Atualizar</button>
+  <span id="msg"></span>
+</div>
+
+<script>
+const COLS=[
+ {id:'rec', nome:'Arte recebida',   cor:'var(--ciano)'},
+ {id:'tra', nome:'Arte tratada',    cor:'var(--magenta)'},
+ {id:'cor2',nome:'Prova de cor',    cor:'var(--roxo)'},
+ {id:'fil', nome:'Fila',            cor:'var(--amarelo)'},
+ {id:'imp', nome:'Imprimindo',      cor:'var(--branco)'},
+ {id:'cor', nome:'Correção',        cor:'var(--alerta)'},
+ {id:'fin', nome:'Finalizado',      cor:'var(--verde)'}
+];
+const API='';                 // mesma origem do PCP
+const USUARIO=window.PCP_USUARIO || 'operador';
+const MAQUINA=new URLSearchParams(location.search).get('maq');  // ?maq=4
+const PARADO=['rec','tra','cor2','fil','cor'];
+const H=36e5, M=6e4;
+let cards=[], maquinas=[], erro=false;
+
+async function api(rota,opt){
+  const r=await fetch(API+rota,{headers:{'Content-Type':'application/json'},...opt});
+  if(!r.ok){
+    let m='erro '+r.status;
+    try{ m=(await r.json()).detail || m; }catch(e){}
+    throw new Error(m);
+  }
+  return r.status===204? null : r.json();
+}
+async function carregar(){
+  try{
+    const d=await api('/api/quadro');
+    cards=[]; maquinas=d.maquinas||[];
+    Object.entries(d.cards||{}).forEach(([col,lista])=>
+      lista.forEach(c=>cards.push({
+        id:String(c.arte_id), pedido:c.pedido, cli:c.cliente,
+        m:c.metros, min:c.minutos_maquina || Math.round(c.metros/20*60),
+        col, desde:Date.parse(c.desde), maq:c.maquina? +String(c.maquina).replace(/\D/g,''):null
+      })));
+    erro=false; esconderAviso();
+  }catch(e){
+    erro=true; mostrarAviso('Sem conexão com o servidor — '+e.message+'. A tela não está atualizando.');
+  }
+  pinta();
+}
+function mostrarAviso(t){
+  const a=document.getElementById('aviso');
+  a.style.display='block'; a.innerHTML='<b>Atenção</b> '+t;
+}
+function esconderAviso(){ document.getElementById('aviso').style.display='none'; }
+function salvar(){ /* estado vive no servidor */ }
+
+async function puxar(n){
+  try{
+    const r=await api('/api/puxar',{method:'POST',
+      body:JSON.stringify({maquina:n, usuario:USUARIO})});
+    msg('Maq '+n+' puxou o #'+r.pedido+' · '+r.minutos+' min · reserva de '+r.reserva_expira_em+' min');
+  }catch(e){ msg(e.message); }
+  carregar();
+}
+async function mover(arte_id,para,maq){
+  try{
+    await api('/api/mover',{method:'POST',
+      body:JSON.stringify({arte_id:+arte_id, para, usuario:USUARIO, maquina:maq||null})});
+  }catch(e){ msg(e.message); }
+  carregar();
+}
+async function devolver(arte_id){
+  try{
+    await api('/api/devolver',{method:'POST',
+      body:JSON.stringify({arte_id:+arte_id, usuario:USUARIO})});
+    msg('devolvido ao topo da fila');
+  }catch(e){ msg(e.message); }
+  carregar();
+}
+
+function pintaMaqs(){
+  const el=document.getElementById('maqs'); el.innerHTML='';
+  for(let n=1;n<=6;n++){
+    const info=maquinas.find(x=>x.n===n) || {};
+    const job=cards.find(c=>c.col==='imp' && c.maq===n) ||
+              (info.ocupada? {pedido:info.pedido,m:info.metros,desde:Date.now()-(info.rodando_seg||0)*1000}:null);
+    if(MAQUINA && String(n)!==MAQUINA) continue;
+    const d=document.createElement('div');
+    d.className='mq '+(job?'ocup':'livre');
+    d.innerHTML='<span class="luz"></span><b>Maq '+n+'</b>'+
+      '<div class="st">'+(job
+        ? '#'+job.pedido+' · '+job.m.toFixed(1).replace('.',',')+' m<br>rodando há '+dur(Date.now()-job.desde)
+        : 'livre<br>&nbsp;')+'</div>'+
+      '<button '+(job?'disabled':'')+'>'+(job?'ocupada':'puxar próximo')+'</button>';
+    if(!job) d.querySelector('button').addEventListener('click',()=>puxar(n));
+    el.appendChild(d);
+  }
+}
+function puxar(n){
+  const fila=cards.filter(c=>c.col==='fil').sort((a,b)=>a.desde-b.desde);
+  if(!fila.length) return msg('a fila está vazia');
+  const c=fila[0];
+  c.col='imp'; c.maq=n; c.desde=Date.now();
+  salvar(); pinta();
+  msg('Maq '+n+' puxou o #'+c.pedido+' — o mais antigo da fila');
+}
+function pintaKpis(){
+  const fila=cards.filter(c=>['rec','tra','cor2','fil'].includes(c.col));
+  const mf=fila.reduce((s,c)=>s+c.m,0), mn=fila.reduce((s,c)=>s+c.min,0);
+  const feito=cards.filter(c=>c.col==='fin').reduce((s,c)=>s+c.m,0);
+  const livres=[1,2,3,4,5,6].filter(n=>!cards.some(c=>c.col==='imp'&&c.maq===n)).length;
+  const cap=20*6*4.5;   // 6 máquinas, 20 m/h, 4h30 restantes
+  const risco=cards.filter(c=>PARADO.includes(c.col)&&Date.now()-c.desde>3*H).length;
+  const k=[
+   ['Na fila',       mf.toFixed(1).replace('.',',')+' <small>m</small>','var(--amarelo)'],
+   ['Minutos de máquina', mn+' <small>min</small>','var(--amarelo)'],
+   ['Capacidade até 20h', Math.round(cap)+' <small>m</small>', mf>cap?'var(--alerta)':'var(--verde)'],
+   ['Máquinas livres',livres+' <small>de 6</small>','var(--ciano)'],
+   ['Impresso hoje', feito.toFixed(1).replace('.',',')+' <small>m</small>','var(--verde)'],
+   ['Parados +3h',   risco+' <small>pedido'+(risco===1?'':'s')+'</small>', risco?'var(--alerta)':'var(--verde)']
+  ];
+  document.getElementById('kpis').innerHTML=k.map(x=>
+    '<div class="k" style="--c:'+x[2]+'"><dt>'+x[0]+'</dt><dd>'+x[1]+'</dd></div>').join('');
+}
+function pinta(){
+  pintaMaqs(); pintaKpis();
+  const agora=Date.now(), el=document.getElementById('kan'); el.innerHTML='';
+  COLS.forEach(col=>{
+    const its=cards.filter(c=>c.col===col.id).sort((a,b)=>a.desde-b.desde);
+    const mt=its.reduce((s,c)=>s+c.m,0);
+    const d=document.createElement('div');
+    d.className='col'; d.dataset.col=col.id; d.style.setProperty('--cc',col.cor);
+    d.innerHTML='<div class="ch"><b><span class="p"></span>'+col.nome+'</b>'+
+      '<small>'+its.length+' · '+mt.toFixed(1).replace('.',',')+' m</small></div><div class="cb"></div>';
+    const cb=d.querySelector('.cb');
+    if(!its.length) cb.innerHTML='<div class="vazio">—</div>';
+    its.forEach(c=>{
+      const p=agora-c.desde, fin=col.id==='fin';
+      const cl=fin?'':(p>3*H?' r':(p>1*H?' q':''));
+      const e=document.createElement('div');
+      e.className='cd'+cl; e.draggable=true; e.dataset.id=c.id;
+      e.innerHTML='<b>#'+c.pedido+'</b><div class="cli">'+c.cli+'</div>'+
+        '<div class="l"><i>'+(fin?'concluído':'há '+dur(p))+'</i>'+
+        '<span>'+c.m.toFixed(1).replace('.',',')+' m · '+c.min+' min</span></div>'+
+        (c.maq?'<span class="mq2">Maq '+c.maq+'</span>':'');
+      e.addEventListener('dragstart',ev=>{ev.dataTransfer.setData('text/plain',c.id);e.classList.add('arrasta')});
+      e.addEventListener('dragend',()=>e.classList.remove('arrasta'));
+      cb.appendChild(e);
+    });
+    d.addEventListener('dragover',ev=>{ev.preventDefault();d.classList.add('alvo')});
+    d.addEventListener('dragleave',()=>d.classList.remove('alvo'));
+    d.addEventListener('drop',ev=>{
+      ev.preventDefault(); d.classList.remove('alvo');
+      const c=cards.find(x=>x.id===ev.dataTransfer.getData('text/plain'));
+      if(!c||c.col===col.id) return;
+      if(c.col==='imp'&&col.id==='fil') return devolver(c.id);
+      let maq=null;
+      if(col.id==='imp'){
+        maq=[1,2,3,4,5,6].find(n=>!cards.some(x=>x.col==='imp'&&x.maq===n));
+        if(!maq) return msg('todas as máquinas estão ocupadas');
+      }
+      mover(c.id,col.id,maq);
+    });
+    el.appendChild(d);
+  });
+}
+document.getElementById('atualizar').addEventListener('click',carregar);
+document.getElementById('ctx').textContent =
+  MAQUINA ? 'Maq '+MAQUINA+' · '+USUARIO : 'visão geral · '+USUARIO;
+function tic(){
+  document.getElementById('hora').textContent=
+    new Date().toLocaleTimeString('pt-BR',{hour:'2-digit',minute:'2-digit'});
+}
+tic(); setInterval(tic,30000);
+setInterval(pinta,30000);      // relógio dos cards
+setInterval(carregar,15000);   // busca o estado no servidor
+carregar();
+</script>
+</body>
+</html>

kanban/tiny.py

@@ -0,0 +1,89 @@
+"""
+Cliente da API do Tiny (Olist) — v3, OAuth2 client credentials.
+
+ATENÇÃO Wagner: confirmar na documentação oficial antes de subir:
+  - o endpoint exato de marcadores do pedido
+  - o limite de requisições por minuto (dimensiona o worker)
+  - se o refresh token expira e com que frequência
+Este módulo isola a API: se o endpoint mudar, muda só aqui.
+"""
+from __future__ import annotations
+
+import os
+import time
+
+import httpx
+
+BASE = os.environ.get("TINY_BASE", "https://api.tiny.com.br/public-api/v3")
+CLIENT_ID = os.environ["TINY_CLIENT_ID"]
+CLIENT_SECRET = os.environ["TINY_CLIENT_SECRET"]
+TOKEN_URL = os.environ["TINY_TOKEN_URL"]
+
+_token: dict = {"valor": None, "expira": 0.0}
+
+
+def _acesso() -> str:
+    if _token["valor"] and time.time() < _token["expira"] - 60:
+        return _token["valor"]
+    r = httpx.post(TOKEN_URL, data={
+        "grant_type": "client_credentials",
+        "client_id": CLIENT_ID,
+        "client_secret": CLIENT_SECRET,
+    }, timeout=20)
+    r.raise_for_status()
+    d = r.json()
+    _token["valor"] = d["access_token"]
+    _token["expira"] = time.time() + d.get("expires_in", 3600)
+    return _token["valor"]
+
+
+def _headers() -> dict:
+    return {"Authorization": f"Bearer {_acesso()}", "Content-Type": "application/json"}
+
+
+def buscar_pedido(numero: str) -> dict:
+    r = httpx.get(f"{BASE}/pedidos", params={"numero": numero},
+                  headers=_headers(), timeout=20)
+    r.raise_for_status()
+    itens = r.json().get("itens") or []
+    if not itens:
+        raise LookupError(f"pedido {numero} não encontrado no Tiny")
+    return itens[0]
+
+
+def transferido_para_deposito(sku: str, deposito: str, dias: int) -> float:
+    """
+    Soma o que foi transferido para o depósito de impressão no período.
+
+    A Altus já faz essa transferência hoje, porque também revende insumo — o
+    depósito separa consumo interno de revenda. Por isso o aproveitamento sai
+    de graça: nenhum apontamento novo na sala.
+
+    ATENÇÃO Wagner: confirmar o endpoint de movimentações de estoque por
+    depósito na API v3 e o nome exato do depósito no cadastro.
+    """
+    r = httpx.get(
+        f"{BASE}/estoque/movimentacoes",
+        params={"codigo": sku, "deposito": deposito, "dias": dias, "tipo": "E"},
+        headers=_headers(), timeout=30,
+    )
+    r.raise_for_status()
+    return sum(float(m.get("quantidade", 0)) for m in r.json().get("itens", []))
+
+
+def marcador(numero: str, marcador: str) -> None:
+    """
+    Troca o marcador do pedido. Substitui os marcadores de etapa do DTF,
+    preservando marcadores de outra natureza (multiempresa, VALE, Troca...).
+    """
+    pedido = buscar_pedido(numero)
+    atuais = [m["descricao"] for m in pedido.get("marcadores", [])]
+    # só três marcadores de etapa vivem no Tiny; o resto do fluxo é do kanban
+    ETAPAS = {"DTF-RECEBIDA", "DTF-PRODUCAO", "CORRECAO DTF", "DTF-PRONTO"}
+    mantem = [m for m in atuais if m not in ETAPAS]
+    novos = mantem + [marcador]
+
+    r = httpx.put(f"{BASE}/pedidos/{pedido['id']}/marcadores",
+                  json={"marcadores": [{"descricao": m} for m in novos]},
+                  headers=_headers(), timeout=20)
+    r.raise_for_status()

kanban/whats.py

@@ -0,0 +1,68 @@
+"""
+Envio de WhatsApp. Três avisos ao cliente, não sete:
+  aprovada · em produção · finalizada    (+ correção, a única que pede resposta)
+
+Provedor definido por WHATS_PROVEDOR = meta | zapi
+A API oficial da Meta exige template aprovado para mensagem iniciada por nós.
+"""
+from __future__ import annotations
+
+import os
+
+import httpx
+
+PROVEDOR = os.environ.get("WHATS_PROVEDOR", "meta")
+TOKEN = os.environ.get("WHATS_TOKEN", "")
+NUMERO_ID = os.environ.get("WHATS_NUMERO_ID", "")
+ZAPI_URL = os.environ.get("ZAPI_URL", "")
+
+TEXTOS = {
+    "prova_cor": ("Antes de imprimir o pedido {pedido} inteiro, fizemos uma amostra "
+                  "de cor. Confira a foto e responda APROVO para seguirmos. A cor no "
+                  "filme pode variar em relação ao seu monitor."),
+    "producao": "Seu pedido {pedido} entrou em produção. Avisamos quando ficar pronto.",
+    "concluido": "Pedido {pedido} finalizado e pronto para retirada ou envio.",
+    "correcao": "Precisamos de um ajuste na arte do pedido {pedido}: {motivo}",
+}
+
+
+def _enviar(telefone: str, texto: str) -> None:
+    if PROVEDOR == "zapi":
+        httpx.post(ZAPI_URL, json={"phone": telefone, "message": texto}, timeout=20)
+        return
+    httpx.post(
+        f"https://graph.facebook.com/v20.0/{NUMERO_ID}/messages",
+        headers={"Authorization": f"Bearer {TOKEN}"},
+        json={"messaging_product": "whatsapp", "to": telefone,
+              "type": "text", "text": {"body": texto}},
+        timeout=20,
+    ).raise_for_status()
+
+
+def enviar_link(telefone: str, pedido: str, link: str) -> None:
+    _enviar(telefone,
+            f"Pedido {pedido} confirmado. Envie sua arte por aqui: {link}\n"
+            "O link vale por 7 dias. Gabarito 57 × 97 cm, PNG 300 DPI com fundo "
+            "transparente.")
+
+
+def enviar_aprovacao(pedido, r) -> None:
+    n = len(r.partes)
+    _enviar(pedido.telefone if hasattr(pedido, "telefone") else "",
+            f"Arte do pedido {pedido.numero_tiny} aprovada. "
+            f"{r.metros_totais:.2f} m em {n} arquivo{'s' if n > 1 else ''}. "
+            "Entrou na fila de impressão.".replace(".", ",", 1))
+
+
+def enviar_recusa(pedido, motivo: str) -> None:
+    _enviar(getattr(pedido, "telefone", ""),
+            f"A arte do pedido {pedido.numero_tiny} precisa de ajuste: {motivo}\n"
+            "O prazo só começa a contar depois que a arte for aprovada.")
+
+
+def avisar(pedido: str, tipo: str, motivo: str = "") -> None:
+    # o telefone vem do cadastro do pedido no Tiny
+    import tiny
+    p = tiny.buscar_pedido(pedido)
+    telefone = (p.get("cliente") or {}).get("fone", "")
+    _enviar(telefone, TEXTOS[tipo].format(pedido=pedido, motivo=motivo))