@zaip-ai/cli 4.5.0 → 4.6.0

package/templates/.agents/dashboard/apps/frontend/src/ReconciliationFeedback.dom.test.ts

@@ -0,0 +1,130 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+describe("ReconciliationFeedback browser interactions", () => {
+  it("bounds large results, preserves all entries, traps/restores focus, and supports empty/English states", async () => {
+    const browserRequire = createRequire(
+      fileURLToPath(new URL("../../../tests/e2e/package.json", import.meta.url)),
+    );
+    const esbuild = browserRequire("esbuild");
+    const { chromium, expect: browserExpect } = browserRequire("@playwright/test");
+    const harness = await esbuild.build({
+      bundle: true,
+      loader: { ".css": "empty" },
+      format: "iife",
+      platform: "browser",
+      write: false,
+      stdin: {
+        contents: `
+          import React, { useState } from "react";
+          import { createRoot } from "react-dom/client";
+          import { ReconciliationFeedback } from "./ReconciliationFeedback.js";
+          import { reconciliationFeedbackFixtures as fixtures } from "./reconciliation-feedback-fixtures.js";
+          function Harness() {
+            const [mode, setMode] = useState("large");
+            const [visible, setVisible] = useState(true);
+            const [locale, setLocale] = useState("pt-BR");
+            return <><button onClick={() => { setMode("mixed"); setVisible(true); }}>Mixed</button>
+              <button onClick={() => { setMode("empty"); setLocale("en-US"); setVisible(true); }}>Empty English</button>
+              {visible && <ReconciliationFeedback result={fixtures[mode]} locale={locale} onDismiss={() => setVisible(false)} />}</>;
+          }
+          createRoot(document.getElementById("root")).render(<Harness />);
+        `,
+        loader: "tsx",
+        resolveDir: fileURLToPath(new URL(".", import.meta.url)),
+        sourcefile: "reconciliation-harness.tsx",
+      },
+    });
+    const browser = await chromium.launch({ headless: true });
+    try {
+      const page = await browser.newPage({ viewport: { width: 360, height: 320 } });
+      const errors: string[] = [];
+      page.on("pageerror", (error: Error) => errors.push(error.message));
+      await page.setContent('<main id="root"></main>');
+      await page.addStyleTag({
+        content: readFileSync(new URL("./styles.css", import.meta.url), "utf8"),
+      });
+      await page.addStyleTag({
+        content: readFileSync(new URL("./reconciliation-feedback.css", import.meta.url), "utf8"),
+      });
+      await page.addScriptTag({ content: harness.outputFiles[0].text });
+      const status = page.getByRole("status");
+      await browserExpect(status).toContainText("Outros estados registrados: 120");
+      await browserExpect(status).not.toContainText("LONG-ID");
+      const summaryBounds = await page.locator(".app-reconciliation-result").boundingBox();
+      if (!summaryBounds) throw new Error("Summary must have visible bounds");
+      expect(summaryBounds.y).toBeGreaterThanOrEqual(0);
+      expect(summaryBounds.y + summaryBounds.height).toBeLessThanOrEqual(320);
+      await page.getByRole("button", { name: "Veja mais" }).click();
+      const dialog = page.getByRole("dialog", { name: "Resultado da reconciliação manual" });
+      await browserExpect(dialog).toBeVisible();
+      await browserExpect(dialog.locator("li")).toHaveCount(122);
+      expect(await dialog.boundingBox()).toEqual({ x: 0, y: 0, width: 360, height: 320 });
+      expect(await page.evaluate(() => document.body.style.overflow)).toBe("hidden");
+      expect(
+        await dialog.evaluate((element: HTMLElement) => element.scrollWidth <= element.clientWidth),
+      ).toBe(true);
+      const scroll = dialog.getByRole("region", { name: "Itens da reconciliação", exact: true });
+      expect(
+        await scroll.evaluate(
+          (element: HTMLElement) =>
+            element.scrollWidth <= element.clientWidth &&
+            element.scrollHeight > element.clientHeight,
+        ),
+      ).toBe(true);
+      await page.keyboard.press("Shift+Tab");
+      expect(await page.evaluate(() => document.activeElement?.closest("dialog") !== null)).toBe(
+        true,
+      );
+      for (let index = 0; index < 5; index++) {
+        await page.keyboard.press("Tab");
+        expect(await page.evaluate(() => document.activeElement?.closest("dialog") !== null)).toBe(
+          true,
+        );
+      }
+      await scroll.evaluate((element: HTMLElement) => {
+        element.scrollTop = element.scrollHeight;
+      });
+      await browserExpect(
+        dialog.getByText("A invocação ainda está em execução.", { exact: false }),
+      ).toBeVisible();
+      await page.keyboard.press("Escape");
+      await browserExpect(dialog).toHaveCount(0);
+      await browserExpect(page.getByRole("button", { name: "Veja mais" })).toBeFocused();
+      expect(await page.evaluate(() => document.body.style.overflow)).toBe("");
+      await page.getByRole("button", { name: "Mixed", exact: true }).click();
+      await page.getByRole("button", { name: "Veja mais" }).click();
+      await browserExpect(dialog).toContainText("Desfechos bloqueados aparecem somente");
+      await browserExpect(dialog.locator("code").filter({ hasText: "TASK-BLOCKED" })).toHaveCount(
+        1,
+      );
+      await dialog.getByText("Motivo original", { exact: true }).first().click();
+      await browserExpect(
+        dialog.getByText("Host terminated without delivery evidence.", { exact: true }),
+      ).toBeVisible();
+      await browserExpect(dialog).toContainText("Motivo não informado.");
+      await browserExpect(dialog).toContainText("An unrecognized reason stays intact.");
+      await page.getByRole("button", { name: "Fechar detalhes" }).click();
+      await browserExpect(page.getByRole("button", { name: "Veja mais" })).toBeFocused();
+      await page.getByRole("button", { name: "Fechar", exact: true }).click();
+      await browserExpect(status).toHaveCount(0);
+      await page.getByRole("button", { name: "Empty English" }).click();
+      await browserExpect(status).toContainText(
+        "Other recorded outcomes: 0 · Blocked outcomes: 0 · Not reconciled: 0",
+      );
+      await page.getByRole("button", { name: "View details" }).click();
+      await browserExpect(page.getByRole("dialog")).toContainText("Blocked outcomes appear only");
+      await browserExpect(
+        page.getByText("No items in this category.", { exact: true }),
+      ).toHaveCount(3);
+      await page.getByRole("button", { name: "Close details" }).click();
+      await page.getByRole("button", { name: "Dismiss" }).click();
+      await browserExpect(status).toHaveCount(0);
+      expect(errors).toEqual([]);
+    } finally {
+      await browser.close();
+    }
+  }, 60_000);
+});

package/templates/.agents/dashboard/apps/frontend/src/ReconciliationFeedback.tsx

@@ -0,0 +1,226 @@
+import { useEffect, useId, useRef, useState } from "react";
+import type { ReconciliationResult } from "./dashboard-api.js";
+import {
+  type ReconciliationLocale,
+  reconciliationCounts,
+  reconciliationReason,
+  reconciliationRecordedItems,
+  reconciliationStatus,
+} from "./reconciliation-feedback-model.js";
+import "./reconciliation-feedback.css";
+
+export function ReconciliationFeedback({
+  result,
+  locale,
+  onDismiss,
+}: {
+  result: ReconciliationResult;
+  locale: ReconciliationLocale;
+  onDismiss: () => void;
+}) {
+  const [detailsOpen, setDetailsOpen] = useState(false);
+  const triggerRef = useRef<HTMLButtonElement>(null);
+  const pt = locale === "pt-BR";
+  const counts = reconciliationCounts(result);
+  const title = pt ? "Resultado da reconciliação manual" : "Manual reconciliation result";
+  const labels = {
+    reconciled: pt ? "Outros estados registrados" : "Other recorded outcomes",
+    blocked: pt ? "Desfechos bloqueados" : "Blocked outcomes",
+    notReconciled: pt ? "Não reconciliados" : "Not reconciled",
+  };
+  const summary = `${labels.reconciled}: ${counts.reconciled} · ${labels.blocked}: ${counts.blocked} · ${labels.notReconciled}: ${counts.notReconciled}`;
+
+  return (
+    <>
+      <section className="app-reconciliation-result" aria-label={title}>
+        <div role="status" aria-live="polite" aria-atomic="true">
+          <strong>{title}</strong>
+          <p>{summary}</p>
+        </div>
+        <div className="app-reconciliation-actions">
+          <button
+            ref={triggerRef}
+            type="button"
+            aria-haspopup="dialog"
+            onClick={() => setDetailsOpen(true)}
+          >
+            {pt ? "Veja mais" : "View details"}
+          </button>
+          <button type="button" onClick={onDismiss}>
+            {pt ? "Fechar" : "Dismiss"}
+          </button>
+        </div>
+      </section>
+      {detailsOpen ? (
+        <ReconciliationDetails
+          result={result}
+          locale={locale}
+          title={title}
+          summary={summary}
+          labels={labels}
+          onClose={() => setDetailsOpen(false)}
+          restoreFocus={() => triggerRef.current?.focus({ preventScroll: true })}
+        />
+      ) : null}
+    </>
+  );
+}
+
+function ReconciliationDetails({
+  result,
+  locale,
+  title,
+  summary,
+  labels,
+  onClose,
+  restoreFocus,
+}: {
+  result: ReconciliationResult;
+  locale: ReconciliationLocale;
+  title: string;
+  summary: string;
+  labels: { reconciled: string; blocked: string; notReconciled: string };
+  onClose: () => void;
+  restoreFocus: () => void;
+}) {
+  const dialogRef = useRef<HTMLDialogElement>(null);
+  const restoreFocusRef = useRef(restoreFocus);
+  const titleId = useId();
+  const pt = locale === "pt-BR";
+  // Native modal dialogs make background content inert and contain keyboard focus.
+  useEffect(() => {
+    const dialog = dialogRef.current;
+    if (!dialog) return;
+    const previousOverflow = document.body.style.overflow;
+    dialog.showModal();
+    document.body.style.overflow = "hidden";
+    return () => {
+      dialog.close();
+      document.body.style.overflow = previousOverflow;
+      restoreFocusRef.current();
+    };
+    // The opener is stable for this dialog's lifetime; locale/result changes
+    // update its content without reopening it or changing focus.
+  }, []);
+
+  const groups = [
+    {
+      label: labels.reconciled,
+      items: reconciliationRecordedItems(result),
+      reasons: true,
+    },
+    { label: labels.blocked, items: result.blocked, reasons: true },
+    { label: labels.notReconciled, items: result.not_reconciled, reasons: true },
+  ];
+  return (
+    <dialog
+      ref={dialogRef}
+      className="app-reconciliation-dialog"
+      aria-labelledby={titleId}
+      aria-modal="true"
+      onCancel={(event) => {
+        event.preventDefault();
+        onClose();
+      }}
+      onKeyDown={(event) => {
+        if (event.key !== "Tab") return;
+        const focusable = Array.from(
+          event.currentTarget.querySelectorAll<HTMLElement>(
+            'button:not(:disabled), summary, [tabindex="0"]',
+          ),
+        ).filter((element) => element.getClientRects().length > 0);
+        const first = focusable[0];
+        const last = focusable[focusable.length - 1];
+        if (event.shiftKey && document.activeElement === first) {
+          event.preventDefault();
+          last?.focus();
+        } else if (!event.shiftKey && document.activeElement === last) {
+          event.preventDefault();
+          first?.focus();
+        }
+      }}
+    >
+      <header>
+        <h2 id={titleId}>{title}</h2>
+        <button type="button" onClick={onClose}>
+          {pt ? "Fechar detalhes" : "Close details"}
+        </button>
+      </header>
+      <section
+        className="app-reconciliation-details"
+        // biome-ignore lint/a11y/noNoninteractiveTabindex: Scrollable content must support keyboard scrolling.
+        tabIndex={0}
+        aria-label={pt ? "Itens da reconciliação" : "Reconciliation items"}
+      >
+        <p>{summary}</p>
+        <p>
+          {pt
+            ? "A reconciliação registra o estado real de cada item. Desfechos bloqueados aparecem somente na categoria de bloqueios; um estado registrado não significa entrega concluída."
+            : "Reconciliation records each item's actual state. Blocked outcomes appear only in the blocked category; a recorded state does not imply completed delivery."}
+        </p>
+        <p>
+          {pt
+            ? "Última telemetria indica a coleta de tokens medidos. Registrar estados ou atualizar o snapshot sem novos tokens não altera esse horário."
+            : "Last telemetry means measured token collection. Recording states or refreshing the snapshot without new tokens does not change that time."}
+        </p>
+        {result.diagnostics ? (
+          <p>
+            {pt ? "Reconciliação executada em" : "Reconciliation executed at"}{" "}
+            {new Intl.DateTimeFormat(locale, { dateStyle: "short", timeStyle: "medium" }).format(
+              new Date(result.diagnostics.completed_at),
+            )}
+            {" · Job: "}
+            <code>{result.diagnostics.job_id}</code>
+            {" · "}
+            {pt ? "Logs" : "Logs"}: <code>{result.diagnostics.log_directory}</code>
+          </p>
+        ) : null}
+        <p>
+          {pt
+            ? "Invocações ainda em execução são preservadas intencionalmente. Permanecer não reconciliado por esse motivo não indica falha do comando."
+            : "Invocations that are still running are intentionally preserved. Remaining unreconciled for this reason does not indicate a command failure."}
+        </p>
+        {groups.map((group) => (
+          <section key={group.label} aria-label={group.label}>
+            <h3>
+              {group.label} ({group.items.length})
+            </h3>
+            {group.items.length === 0 ? (
+              <p>{pt ? "Nenhum item nesta categoria." : "No items in this category."}</p>
+            ) : (
+              <ul>
+                {keyedReconciliationItems(group.items).map(({ item, key }) => (
+                  <li key={key}>
+                    <code>{item.id}</code>
+                    {"status" in item && typeof item.status === "string" ? (
+                      <p>{reconciliationStatus(item.status, locale)}</p>
+                    ) : null}
+                    {group.reasons ? <p>{reconciliationReason(item.reason, locale)}</p> : null}
+                    {group.reasons &&
+                    item.reason !== null &&
+                    reconciliationReason(item.reason, locale) !== item.reason ? (
+                      <details>
+                        <summary>{pt ? "Motivo original" : "Original reason"}</summary>
+                        <p>{item.reason}</p>
+                      </details>
+                    ) : null}
+                  </li>
+                ))}
+              </ul>
+            )}
+          </section>
+        ))}
+      </section>
+    </dialog>
+  );
+}
+
+function keyedReconciliationItems(items: Array<{ id: string; reason: string | null }>) {
+  const occurrences = new Map<string, number>();
+  return items.map((item) => {
+    const identity = JSON.stringify([item.id, item.reason]);
+    const occurrence = (occurrences.get(identity) ?? 0) + 1;
+    occurrences.set(identity, occurrence);
+    return { item, key: `${identity}:${occurrence}` };
+  });
+}

package/templates/.agents/dashboard/apps/frontend/src/dashboard-api-sqlite-view.ts

@@ -0,0 +1,45 @@
+import type { CostPeriodAverages } from "@zaip-ai/dashboard-cost-monitor/contracts";
+
+export type SqliteViewName =
+  | "cost_monitor_daily"
+  | "cost_monitor_monthly"
+  | "cost_monitor_annual"
+  | "cost_monitor_overview_view"
+  | "cost_monitor_executions"
+  | "cost_monitor_agent_invocations"
+  | "cost_monitor_zaip_agents"
+  | "cost_monitor_models"
+  | "cost_monitor_providers"
+  | "cost_monitor_tasks"
+  | "cost_monitor_specs"
+  | "cost_monitor_prds"
+  | "cost_monitor_conversations"
+  | "operations_work_list"
+  | "operations_work_kanban"
+  | "operations_executions"
+  | "operations_agent_invocations"
+  | "operations_conversations"
+  | "operations_decisions"
+  | "operations_changes"
+  | "operations_daily"
+  | "operations_monthly"
+  | "operations_annual"
+  | "first_fold_overview"
+  | "first_fold_task_status"
+  | "first_fold_task_risk"
+  | "first_fold_top_tasks"
+  | "first_fold_task"
+  | "first_fold_spec"
+  | "first_fold_prd";
+
+export interface SqliteViewPage {
+  data_source: "sqlite_read_model";
+  view: SqliteViewName;
+  offset: number;
+  limit: number;
+  total_count: number;
+  has_more: boolean;
+  totals?: Record<string, unknown>;
+  period_averages?: Record<"BRL" | "USD", CostPeriodAverages>;
+  rows: Array<Record<string, unknown>>;
+}

package/templates/.agents/dashboard/apps/frontend/src/dashboard-api.test.ts

@@ -139,6 +139,21 @@ describe("DashboardApiClient readiness", () => {
     vi.unstubAllGlobals();
   });
 
+  it("requests recent telemetry with an authenticated command when the browser opens", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn(
+      async () => new Response(JSON.stringify({ snapshot_state: "updating" }), { status: 202 }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    await expect(new DashboardApiClient("session").captureTelemetry()).resolves.toEqual({
+      snapshot_state: "updating",
+    });
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/v2/capture-telemetry",
+      expect.objectContaining({ method: "POST", headers: { "x-zaip-session": "session" } }),
+    );
+  });
+
   it("reads a committed snapshot revision through the authenticated GET endpoint", async () => {
     vi.stubGlobal("window", globalThis);
     const fetchMock = vi.fn(

package/templates/.agents/dashboard/apps/frontend/src/dashboard-api.ts

@@ -3,10 +3,7 @@ import type { ProjectOverview } from "./dashboard-project-overview.js";
 export type { ProjectOverview } from "./dashboard-project-overview.js";
 
 import { type ApiErrorPayload, dashboardApiPaths } from "@zaip-ai/dashboard-contracts";
-import type {
-  CostMonitorProjection,
-  CostPeriodAverages,
-} from "@zaip-ai/dashboard-cost-monitor/contracts";
+import type { CostMonitorProjection } from "@zaip-ai/dashboard-cost-monitor/contracts";
 import type {
   ChangeProjection,
   DashboardTaskProjection,
@@ -25,53 +22,14 @@ import type {
   PricingCatalog,
   ProjectConfigSettings,
 } from "./dashboard-api-settings.js";
+import type { SqliteViewName, SqliteViewPage } from "./dashboard-api-sqlite-view.js";
 import type { DashboardIdentityResponse } from "./dashboard-identity.js";
+
+export type { SqliteViewName, SqliteViewPage } from "./dashboard-api-sqlite-view.js";
 export interface ReconciliationBlockedItem {
   id: string;
   reason: string | null;
 }
-export type SqliteViewName =
-  | "cost_monitor_daily"
-  | "cost_monitor_monthly"
-  | "cost_monitor_annual"
-  | "cost_monitor_overview_view"
-  | "cost_monitor_executions"
-  | "cost_monitor_agent_invocations"
-  | "cost_monitor_zaip_agents"
-  | "cost_monitor_models"
-  | "cost_monitor_providers"
-  | "cost_monitor_tasks"
-  | "cost_monitor_specs"
-  | "cost_monitor_prds"
-  | "cost_monitor_conversations"
-  | "operations_work_list"
-  | "operations_work_kanban"
-  | "operations_executions"
-  | "operations_agent_invocations"
-  | "operations_conversations"
-  | "operations_decisions"
-  | "operations_changes"
-  | "operations_daily"
-  | "operations_monthly"
-  | "operations_annual"
-  | "first_fold_overview"
-  | "first_fold_task_status"
-  | "first_fold_task_risk"
-  | "first_fold_top_tasks"
-  | "first_fold_task"
-  | "first_fold_spec"
-  | "first_fold_prd";
-export interface SqliteViewPage {
-  data_source: "sqlite_read_model";
-  view: SqliteViewName;
-  offset: number;
-  limit: number;
-  total_count: number;
-  has_more: boolean;
-  totals?: Record<string, unknown>;
-  period_averages?: Record<"BRL" | "USD", CostPeriodAverages>;
-  rows: Array<Record<string, unknown>>;
-}
 export type OperationsScope = "quick" | "overview" | "detail";
 export type WorkBoardStage =
   | "definition"
@@ -224,6 +182,15 @@ export interface ReconciliationResult {
   reconciled_ids: string[];
   blocked: ReconciliationBlockedItem[];
   not_reconciled: ReconciliationBlockedItem[];
+  outcomes?: Array<ReconciliationBlockedItem & { status: string }>;
+  diagnostics?: {
+    job_id: string;
+    started_at: string;
+    completed_at: string;
+    log_directory: string;
+    projection_updated_at: string | null;
+    latest_token_collected_at: string | null;
+  };
 }
 
 export interface CostMonitorFilters {
@@ -245,6 +212,10 @@ export class DashboardApiClient {
     return this.get("/api/v2/ready");
   }
 
+  captureTelemetry(): Promise<{ snapshot_state: "current" | "updating" }> {
+    return this.post("/api/v2/capture-telemetry");
+  }
+
   /**
    * Lightweight, workspace-level metadata. This deliberately stays outside
    * the aggregate snapshot so the first Operations paint remains compact.

package/templates/.agents/dashboard/apps/frontend/src/reconciliation-feedback-fixtures.ts

@@ -0,0 +1,23 @@
+import type { ReconciliationResult } from "./dashboard-api.js";
+
+/** Stable specimens shared by catalog and regression tests, with no API calls. */
+export const reconciliationFeedbackFixtures = {
+  empty: { reconciled_ids: [], blocked: [], not_reconciled: [] },
+  mixed: {
+    reconciled_ids: ["TASK-RECONCILED", "TASK-BLOCKED"],
+    blocked: [{ id: "TASK-BLOCKED", reason: "Host terminated without delivery evidence." }],
+    not_reconciled: [
+      { id: "RUN-ACTIVE", reason: "Invocation is still running." },
+      { id: "RUN-UNKNOWN", reason: null },
+      { id: "RUN-UNRECOGNIZED", reason: "An unrecognized reason stays intact." },
+    ],
+  },
+  large: {
+    reconciled_ids: Array.from(
+      { length: 120 },
+      (_, index) => `TASK-${index}-${"LONG-ID-".repeat(24)}`,
+    ),
+    blocked: [{ id: "TASK-LONG-BLOCKED", reason: "unbroken-original-reason".repeat(100) }],
+    not_reconciled: [{ id: "RUN-ACTIVE", reason: "Invocation is still running." }],
+  },
+} satisfies Record<string, ReconciliationResult>;

package/templates/.agents/dashboard/apps/frontend/src/reconciliation-feedback-model.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { reconciliationFeedbackFixtures as fixtures } from "./reconciliation-feedback-fixtures.js";
+import {
+  reconciliationCounts,
+  reconciliationReason,
+  reconciliationRecordedItems,
+  reconciliationStatus,
+} from "./reconciliation-feedback-model.js";
+
+describe("reconciliation feedback semantics", () => {
+  it("displays each persisted outcome once without inferring success", () => {
+    expect(reconciliationCounts(fixtures.mixed)).toEqual({
+      reconciled: 1,
+      blocked: 1,
+      notReconciled: 3,
+    });
+    expect(fixtures.mixed.reconciled_ids).toContain(fixtures.mixed.blocked[0]?.id);
+    expect(reconciliationCounts(fixtures.empty)).toEqual({
+      reconciled: 0,
+      blocked: 0,
+      notReconciled: 0,
+    });
+  });
+  it("reports the screenshot's failed Run and three blocked owners as distinct outcomes", () => {
+    const blocked = ["TASK-X", "CHG-X", "EXEC-X"].map((id) => ({ id, reason: "repair required" }));
+    const result = {
+      reconciled_ids: ["RUN-X", ...blocked.map((item) => item.id)],
+      blocked,
+      not_reconciled: [],
+      outcomes: [{ id: "RUN-X", status: "failed", reason: "orphaned" }],
+    };
+    expect(reconciliationCounts(result)).toEqual({ reconciled: 1, blocked: 3, notReconciled: 0 });
+    expect(reconciliationRecordedItems(result)).toEqual([
+      { id: "RUN-X", status: "failed", reason: "orphaned" },
+    ]);
+    expect(reconciliationStatus("failed", "pt-BR")).toBe("Falha técnica");
+    expect(
+      reconciliationReason(
+        "Explicit orphan reconciliation found no active host invocation or terminal work outcome; repair is required before resuming (Run RUN-X).",
+        "pt-BR",
+      ),
+    ).toContain("exige reparo e validação");
+  });
+  it("explains intentional running preservation in Portuguese and keeps unknown/null truthful", () => {
+    expect(reconciliationReason("Invocation is still running.", "pt-BR")).toContain(
+      "preservada intencionalmente",
+    );
+    expect(reconciliationReason("Invocation is still running", "pt-BR")).toContain(
+      "não indica falha",
+    );
+    expect(reconciliationReason("Invocation is still running.", "en-US")).toBe(
+      "Invocation is still running.",
+    );
+    expect(reconciliationReason("unrecognized", "pt-BR")).toBe("unrecognized");
+    expect(reconciliationReason(null, "pt-BR")).toBe("Motivo não informado.");
+    expect(reconciliationReason(null, "en-US")).toBe("No reason provided.");
+  });
+  it("translates exact orphaned execution outcomes while preserving the execution ID", () => {
+    expect(
+      reconciliationReason(
+        "Execution EXEC-LONG has no active orchestrator agent call after the reconciliation grace period.",
+        "pt-BR",
+      ),
+    ).toContain("A execução EXEC-LONG não tem uma chamada");
+    expect(
+      reconciliationReason("Execution orphaned after the reconciliation grace period.", "pt-BR"),
+    ).toContain("período de tolerância");
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/reconciliation-feedback-model.ts

@@ -0,0 +1,59 @@
+import type { ReconciliationResult } from "./dashboard-api.js";
+
+export type ReconciliationLocale = "pt-BR" | "en-US";
+
+export function reconciliationCounts(result: ReconciliationResult) {
+  const blockedIds = new Set(result.blocked.map((item) => item.id));
+  return {
+    reconciled: result.reconciled_ids.filter((id) => !blockedIds.has(id)).length,
+    blocked: result.blocked.length,
+    notReconciled: result.not_reconciled.length,
+  };
+}
+
+export function reconciliationRecordedItems(result: ReconciliationResult) {
+  const blockedIds = new Set(result.blocked.map((item) => item.id));
+  return result.reconciled_ids
+    .filter((id) => !blockedIds.has(id))
+    .map((id) => {
+      const outcome = result.outcomes?.find((item) => item.id === id);
+      return { id, reason: outcome?.reason ?? null, status: outcome?.status ?? null };
+    });
+}
+
+export function reconciliationStatus(status: string | null, locale: ReconciliationLocale) {
+  const statuses: Record<string, string> = {
+    completed: "Concluído",
+    delivered: "Entregue",
+    failed: "Falha técnica",
+    blocked: "Bloqueado",
+    cancelled: "Cancelado",
+  };
+  return status === null ? "" : locale === "pt-BR" ? (statuses[status] ?? status) : status;
+}
+
+const portugueseReasons: Record<string, string> = {
+  "Invocation is still running":
+    "A invocação ainda está em execução. Foi preservada intencionalmente; isso não indica falha do comando.",
+  "Host terminated without delivery evidence": "O host encerrou sem evidências de entrega.",
+  "Host interrupted": "O host foi interrompido.",
+  "Child attempt stopped": "A tentativa do subagente foi encerrada.",
+  "Execution orphaned after the reconciliation grace period":
+    "A execução ficou sem orquestrador ativo após o período de tolerância da reconciliação.",
+};
+
+export function reconciliationReason(reason: string | null, locale: ReconciliationLocale): string {
+  if (reason === null) return locale === "pt-BR" ? "Motivo não informado." : "No reason provided.";
+  if (locale === "en-US") return reason;
+  const orphan = reason.match(
+    /^Explicit orphan reconciliation found no active host invocation or terminal work outcome; repair is required before resuming \(Run (\S+)\)\.$/,
+  );
+  if (orphan)
+    return `A Run ${orphan[1]} ficou sem invocação ativa do host e sem evidência de um desfecho de entrega. A reconciliação registrou a interrupção; a entrega exige reparo e validação antes de retomar.`;
+  const orphanedExecution = reason.match(
+    /^Execution (\S+) has no active orchestrator agent call after the reconciliation grace period\.?$/,
+  );
+  if (orphanedExecution)
+    return `A execução ${orphanedExecution[1]} não tem uma chamada de agente orquestrador ativa após o período de tolerância da reconciliação.`;
+  return portugueseReasons[reason.trim().replace(/\.$/, "")] ?? reason;
+}