The chain has no decision with that sequence number.
+{{else}}
+{{with .Detail}}
+
Decision {{.Row.Seq}}
+
+ {{outcome .Row.Outcome}}
+ decided by the {{.Row.Layer}} layer for {{.Row.Namespace}}/{{.Row.Workload}} at {{ts .Row.Time}}.
+ {{if .Row.Held}}No human has decided it yet.{{end}}
+
Each decision gets an Ed25519-signed receipt that links to the one before it. This page checks the chain in the dashboard process against a trust root you pinned.
{{if .User}}
diff --git a/docs/architecture/demo-dashboard.md b/docs/architecture/demo-dashboard.md
new file mode 100644
index 0000000..f4f54f6
--- /dev/null
+++ b/docs/architecture/demo-dashboard.md
@@ -0,0 +1,73 @@
+# Demo dashboard
+
+Status: iteration 1 shipped. The summary tiles landed on `/decisions`, not on `/`. The existing `/` workload dashboard is unchanged. Follow-ups: per-namespace filtering, a paged export from the writer, an approvals queue with edit on these pages.
+
+## Problem
+
+The operator now makes layered decisions and signs a receipt for each one. A buyer cannot see any of it without a terminal. `agentctl-web` exists, but it shows workloads, cost and status. It shows nothing from the decision architecture.
+
+## What exists today
+
+- `cmd/agentctl-web`: Go, `html/template`, vendored htmx, no external assets. Token auth through TokenReview and SubjectAccessReview. CSRF and audit middleware. Chart block `webUI`, default off.
+- Workload list, describe, approve and reject. Approvals are stamped with the web service account (`docs/approvals.md`).
+- A demo page that runs without a cluster (`--demo`).
+- The receipt-writer serves `GET /v1/export`, `/v1/head` and `/v1/approvals` behind a bearer token. `pkg/receipts.ReadExport` and `VerifyExport` read and verify an export.
+
+## Goal
+
+One screen flow that shows, from real receipts, what the operator decided and why. It must run in two places.
+
+1. Offline from an export directory. No cluster, no network. This is the booth path.
+2. In the cluster, next to the operator, reading the receipt-writer.
+
+## Non-goals
+
+- No hosted service, no telemetry, no external fonts or scripts. The ADR keeps the plane air-gapped.
+- No write path beyond the approve and reject buttons that already exist.
+- No new data store. The receipt chain is the source of truth.
+- No claim about the runtime-adapter path or execution outcomes. They are not receipted. The UI says so.
+
+## Views
+
+| Path | Shows | Source |
+|------|-------|--------|
+| `/decisions` | Summary tiles, chain status, a fixed "not covered" panel, and the timeline. Seq, time, workload, action, deciding layer, outcome, reason codes. Filter by outcome. | records in the export |
+| `/decisions/{seq}` | One decision. Layers and reasons, observed data classes and host, packs, threshold mode, model block (mode, risk, threshold, base and final outcome), approval block, chain link and signer. | one record and its receipt |
+| `/receipts` | Chain head, count, signer, verification result with the reason on failure, completeness against the signed manifest, link to download the export. | `VerifyExport` |
+
+
+Verification runs in the web process against a pinned trust root. The page never trusts the export's own `trust.json`. Without a pinned root the page says "consistency only" and shows no PASS badge. This matches `agentctl dataset verify`.
+
+Privacy matches the receipts. Records hold hashes and class names, not raw params. The UI shows only what the record holds. All text goes through `safeText` and the template escaper.
+
+## Design
+
+- `pkg/decisionview`: loads an `Export` from a directory or the writer, verifies it, and builds view models. No HTTP, no templates. Table-driven tests with the existing export fixtures.
+- `cmd/agentctl-web`: new handlers and templates. Flags `--export-dir`, `--writer-url`, `--writer-token-file`, `--trust-root`. The offline mode needs no kubeconfig and no auth, and binds to localhost unless told otherwise.
+- Chart `webUI.receipts`: writer URL, token secret, trust root ConfigMap. A NetworkPolicy rule lets the web pod reach the writer. The writer ingress rule admits the web pod.
+- Refresh: htmx polls the summary every 5 seconds. Reads are cached for 2 seconds to protect the writer.
+
+## Loop
+
+Each step is small, verified and committed on its own. Stop when every done check passes.
+
+1. Data layer `pkg/decisionview`. Done when tests cover timeline, detail, chain failure and unpinned mode.
+2. Handlers and templates for `/decisions`, `/decisions/{seq}`, `/receipts`. Done when handler tests assert content, escaping and no external host in any page.
+3. Summary tiles and the "not covered" panel on `/decisions`.
+4. Chart wiring and `helm unittest` cases.
+5. Offline demo: `make demo-dashboard` serves a fixture export. Screenshot check with Playwright at 375 and 1280 px.
+6. Docs: `docs/dashboard.md`, CHANGELOG, BLOCKERS.
+
+## Done checks
+
+- `go build`, `go vet`, `make lint`, `go test` for the touched packages.
+- `helm unittest charts`.
+- Offline demo shows PASS for a pinned root and a visible FAIL after one byte of a record changes.
+- No request leaves localhost in offline mode.
+- Copilot review has no open finding.
+
+## Risks
+
+- The writer can be slow or down. The page shows the error and the last good data age. It never shows stale data as fresh.
+- A large chain. Paginate the timeline at 100 rows. Verify once per refresh, not per request.
+- Pending approvals live in workload status, not in the receipt chain. The approvals view keeps using the existing handlers.
diff --git a/docs/dashboard.md b/docs/dashboard.md
new file mode 100644
index 0000000..c309c4e
--- /dev/null
+++ b/docs/dashboard.md
@@ -0,0 +1,72 @@
+# Decision dashboard
+
+The dashboard shows what the operator decided and whether you can trust it. It reads signed receipts. It runs offline from an export, or in the cluster next to the operator.
+
+## Run it offline
+
+No cluster and no network.
+
+```sh
+make demo-dashboard
+```
+
+This writes a sample export with a fixed demo key and serves it on `http://127.0.0.1:8090`. The sample has allowed actions, a deny by an invariant, a deny by a policy pack, an approved and a rejected escalation, one decision still waiting for a human, and a shadow-mode model score.
+
+To serve your own export:
+
+```sh
+agentctl receipts export --writer http://localhost:8080 --token-file ./token --out ./export
+agentctl-web --export-dir ./export --trust-root ./pinned-trust.json
+```
+
+Offline mode binds to localhost unless you pass `--addr`. It has no login. Do not expose it.
+
+## Pages
+
+| Path | Shows |
+|------|-------|
+| `/decisions` | Chain status, counts, and a timeline of decisions, newest first. Filter by outcome. Refreshes every 5 seconds. |
+| `/decisions/{seq}` | One decision: the deciding layer, each finding, what the platform observed, what was declared, what the agent claimed, the model block, a human decision, and the receipt hashes. |
+| `/receipts` | Chain head, receipts verified, signed manifest, completeness, and whether the trust root is pinned. |
+
+The chain status block shows on every page. The "Not covered" list shows on `/decisions` and `/receipts`. It names what receipts do not cover: the runtime-adapter path, execution outcomes, Argo approval gates, and the live approval queue.
+
+## What the badge means
+
+The dashboard verifies the chain itself. It does not take the export's word.
+
+| Badge | Meaning |
+|-------|---------|
+| Verified | Signatures check out under a pinned key and a signed manifest proves nothing was removed. |
+| Partial | Signatures check out under a pinned key. Nothing proves later receipts were not removed. |
+| Consistent only | The chain is consistent, but the trust root came from the export itself. Nobody is authenticated. |
+| Failed | A signature, a link, or a record does not check out. The rows are not trustworthy. |
+
+Pin a trust root with `--trust-root`. Without it the badge never says Verified. This is the same rule as `agentctl dataset verify`.
+
+## Run it in the cluster
+
+Turn on the web UI and the receipt-writer together:
+
+```sh
+helm upgrade --install agentic-operator charts \
+ --set webUI.enabled=true \
+ --set global.receipts.enabled=true \
+ --set global.receipts.signingKey.existingSecret=receipt-signing-key \
+ --set global.receipts.trustRoot.existingConfigMap=receipt-trust-root
+```
+
+The chart passes the writer URL, the token file and the pinned trust root to `agentctl-web`. It also lets the web pods reach the writer through its NetworkPolicy. The Decisions and Receipts links appear in the navigation. Pages sit behind the same token login as the rest of the web UI.
+
+Without `global.receipts.trustRoot.existingConfigMap` the pages work, but the badge reads Consistent only.
+
+## What it does not do
+
+- It reads receipts. It does not write them. Approve and reject still use the workload pages.
+- The live approval queue is the workload status, not the chain. A held decision already has a `require_approval` receipt, so it shows on the timeline as awaiting approval. The human decision joins the chain later.
+- Decision records hold hashes, class names and a host. The pages show nothing more, so they cannot show raw payloads.
+- Any signed-in user who can reach the pages sees every decision. There is no per-namespace filter yet.
+
+## Load and size
+
+The page asks the writer for a full export. It caches the result for 2 seconds and keeps the last good result if a refresh fails, with a visible notice. The timeline shows 100 rows at a time. Very long chains need a paged export from the writer. That is not built.
diff --git a/pkg/decisionview/decisionview.go b/pkg/decisionview/decisionview.go
new file mode 100644
index 0000000..7167c14
--- /dev/null
+++ b/pkg/decisionview/decisionview.go
@@ -0,0 +1,303 @@
+/*
+Copyright 2026 Clawdlinux.
+Licensed under the Apache License, Version 2.0.
+*/
+
+// Package decisionview turns a receipt export into the views the dashboard
+// shows. It has no HTTP and no templates. It never trusts an export's own
+// trust root: a view is only marked authenticated when the caller pins keys.
+package decisionview
+
+import (
+ "context"
+ "encoding/hex"
+ "encoding/json"
+ "fmt"
+ "sort"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/Clawdlinux/agentgate/pkg/receiptspec"
+
+ "github.com/Clawdlinux/agentic-operator-core/pkg/receipts"
+)
+
+// Source loads one export.
+type Source interface {
+ Load(ctx context.Context) (receipts.Export, error)
+}
+
+// DirSource reads an export directory or bundle file.
+type DirSource string
+
+// Load implements Source.
+func (d DirSource) Load(context.Context) (receipts.Export, error) {
+ return receipts.ReadExport(string(d))
+}
+
+// WriterSource reads the export from a receipt-writer.
+type WriterSource struct{ Writer *receipts.RemoteWriter }
+
+// Load implements Source.
+func (s WriterSource) Load(ctx context.Context) (receipts.Export, error) {
+ return s.Writer.Export(ctx)
+}
+
+// Status is the one word a page shows for the chain.
+type Status string
+
+const (
+ // StatusVerified: authenticated under a pinned key and proven complete.
+ StatusVerified Status = "verified"
+ // StatusPartial: authenticated, but no signed manifest proves completeness.
+ StatusPartial Status = "partial"
+ // StatusConsistent: internally consistent, but the trust root came from the
+ // export itself, so nobody is authenticated.
+ StatusConsistent Status = "consistent"
+ // StatusFailed: verification failed or the export could not be read.
+ StatusFailed Status = "failed"
+)
+
+// Verification is the result of checking an export.
+type Verification struct {
+ Authenticated bool
+ ChainOK bool
+ HasManifest bool
+ Complete bool
+ TotalReceipts int
+ VerifiedCount int
+ HeadSeq uint64
+ HeadHash string
+ FailedAtSeq uint64
+ Reason string
+ RecordsBound int
+ RecordFailures []receipts.RecordFailure
+ // Error is set when the export could not be read or verified at all.
+ Error string
+}
+
+// Status folds the verification into one word.
+func (v Verification) Status() Status {
+ switch {
+ case v.Error != "" || !v.ChainOK || len(v.RecordFailures) > 0:
+ return StatusFailed
+ case !v.Authenticated:
+ return StatusConsistent
+ case v.Complete:
+ return StatusVerified
+ default:
+ return StatusPartial
+ }
+}
+
+// Row is one line of the decision timeline.
+type Row struct {
+ Seq uint64
+ Time time.Time
+ Namespace string
+ Workload string
+ Action string
+ Layer string
+ Outcome string
+ ReasonCodes []string
+ // HumanLabel is set on layer "human" rows: approve, reject or edit.
+ HumanLabel string
+ // Held is true for a require_approval row no human decision has answered.
+ Held bool
+}
+
+// Summary counts the decisions for the home page.
+type Summary struct {
+ Total int
+ ByOutcome map[string]int
+ ByLayer map[string]int
+ Held int
+ Human int
+ ModelModes []string
+}
+
+// Detail is one decision with its receipt link.
+type Detail struct {
+ Row Row
+ Record receipts.DecisionRecord
+ PrevHash string
+ EntryHash string
+ SignerKID string
+}
+
+// View is everything the pages need, built from one export.
+type View struct {
+ Rows []Row // newest first
+ Summary Summary
+ Verification Verification
+ LoadedAt time.Time
+ // Err is the last load error when the view is a cached earlier result.
+ Err string
+
+ details map[uint64]Detail
+}
+
+// Detail returns the decision with the given receipt sequence.
+func (v View) Detail(seq uint64) (Detail, bool) {
+ d, ok := v.details[seq]
+ return d, ok
+}
+
+// Build verifies e and builds a view. trusted are keys pinned out of band. With
+// none, the export's own trust root is used and the view is not authenticated.
+func Build(e receipts.Export, trusted []receiptspec.TrustedKey, now time.Time) View {
+ v := View{LoadedAt: now, details: map[uint64]Detail{}}
+ rep, err := receipts.VerifyExport(e, trusted)
+ if err != nil {
+ v.Verification = Verification{Error: err.Error()}
+ return v
+ }
+ v.Verification = Verification{
+ Authenticated: len(trusted) > 0,
+ ChainOK: rep.Chain.OK,
+ HasManifest: rep.HasManifest,
+ Complete: rep.Complete(),
+ TotalReceipts: rep.Chain.TotalReceipts,
+ VerifiedCount: rep.Chain.VerifiedCount,
+ HeadSeq: rep.Chain.HeadSeq,
+ HeadHash: hex.EncodeToString(rep.Chain.HeadEntryHash[:]),
+ FailedAtSeq: rep.Chain.FailedAtSeq,
+ Reason: string(rep.Chain.Reason),
+ RecordsBound: rep.RecordsBound,
+ RecordFailures: rep.RecordFailures,
+ }
+
+ bundle, err := receiptspec.ReadJSONL(strings.NewReader(e.ReceiptsJSONL))
+ if err != nil {
+ v.Verification.Error = err.Error()
+ return v
+ }
+ records := map[uint64]receipts.DecisionRecord{}
+ for _, line := range strings.Split(e.RecordsJSONL, "\n") {
+ line = strings.TrimSpace(line)
+ if line == "" {
+ continue
+ }
+ var rl receipts.RecordLine
+ if json.Unmarshal([]byte(line), &rl) != nil {
+ continue
+ }
+ var rec receipts.DecisionRecord
+ if json.Unmarshal(rl.Record, &rec) != nil {
+ continue
+ }
+ records[rl.Seq] = rec
+ }
+
+ answered := map[uint64]bool{}
+ for _, rec := range records {
+ if rec.Approval != nil {
+ answered[rec.Approval.OriginalSeq] = true
+ }
+ }
+
+ modes := map[string]bool{}
+ sum := Summary{ByOutcome: map[string]int{}, ByLayer: map[string]int{}}
+ for _, r := range bundle.Receipts {
+ rec, ok := records[r.Seq]
+ if !ok {
+ continue
+ }
+ row := Row{
+ Seq: r.Seq,
+ Time: time.Unix(0, int64(r.TimestampUnixNS)).UTC(),
+ Namespace: rec.Workload.Namespace,
+ Workload: rec.Workload.Name,
+ Action: rec.Action,
+ Layer: rec.Layer,
+ Outcome: rec.Outcome,
+ ReasonCodes: reasonCodes(rec),
+ Held: rec.Outcome == "require_approval" && !answered[r.Seq],
+ }
+ if rec.Approval != nil {
+ row.HumanLabel = rec.Approval.Label
+ sum.Human++
+ }
+ if rec.Model != nil && rec.Model.Mode != "" {
+ modes[rec.Model.Mode] = true
+ }
+ sum.Total++
+ sum.ByOutcome[row.Outcome]++
+ sum.ByLayer[row.Layer]++
+ if row.Held {
+ sum.Held++
+ }
+ v.Rows = append(v.Rows, row)
+ v.details[r.Seq] = Detail{
+ Row: row,
+ Record: rec,
+ PrevHash: hex.EncodeToString(r.PrevHash[:]),
+ EntryHash: hex.EncodeToString(r.EntryHash[:]),
+ SignerKID: r.SignerKID,
+ }
+ }
+ sort.SliceStable(v.Rows, func(i, j int) bool { return v.Rows[i].Seq > v.Rows[j].Seq })
+ for m := range modes {
+ sum.ModelModes = append(sum.ModelModes, m)
+ }
+ sort.Strings(sum.ModelModes)
+ v.Summary = sum
+ return v
+}
+
+func reasonCodes(rec receipts.DecisionRecord) []string {
+ seen := map[string]bool{}
+ out := []string{}
+ for _, r := range rec.Reasons {
+ if !seen[r.RuleID] {
+ seen[r.RuleID] = true
+ out = append(out, r.RuleID)
+ }
+ }
+ sort.Strings(out)
+ return out
+}
+
+// Loader loads, verifies and caches a view. A failed refresh keeps the last
+// good view and sets Err, so a page can say the data is old instead of
+// showing it as fresh.
+type Loader struct {
+ Source Source
+ Trusted []receiptspec.TrustedKey
+ TTL time.Duration
+ Now func() time.Time
+
+ mu sync.Mutex
+ last View
+ have bool // last holds a view built from a real export
+ lastTry time.Time // when the source was last asked, success or not
+}
+
+// Current returns the cached view or reloads it when older than TTL. A failed
+// refresh is cached for the TTL too, so an outage costs one source call per
+// TTL instead of one per request.
+func (l *Loader) Current(ctx context.Context) View {
+ l.mu.Lock()
+ defer l.mu.Unlock()
+ now := time.Now
+ if l.Now != nil {
+ now = l.Now
+ }
+ if !l.lastTry.IsZero() && now().Sub(l.lastTry) < l.TTL {
+ return l.last
+ }
+ l.lastTry = now()
+ e, err := l.Source.Load(ctx)
+ if err != nil {
+ if l.have {
+ l.last.Err = fmt.Sprintf("refresh failed: %v", err)
+ return l.last
+ }
+ l.last = View{LoadedAt: l.lastTry, Verification: Verification{Error: err.Error()}, Err: err.Error()}
+ return l.last
+ }
+ l.last = Build(e, l.Trusted, l.lastTry)
+ l.have = true
+ return l.last
+}
diff --git a/pkg/decisionview/decisionview_test.go b/pkg/decisionview/decisionview_test.go
new file mode 100644
index 0000000..7b2bd96
--- /dev/null
+++ b/pkg/decisionview/decisionview_test.go
@@ -0,0 +1,211 @@
+/*
+Copyright 2026 Clawdlinux.
+Licensed under the Apache License, Version 2.0.
+*/
+
+package decisionview_test
+
+import (
+ "bytes"
+ "context"
+ "crypto/ed25519"
+ "errors"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/Clawdlinux/agentgate/pkg/receiptspec"
+
+ "github.com/Clawdlinux/agentic-operator-core/pkg/decision"
+ "github.com/Clawdlinux/agentic-operator-core/pkg/decisionview"
+ "github.com/Clawdlinux/agentic-operator-core/pkg/receipts"
+)
+
+// fixture returns an export with three decisions: an escalated one that a
+// human approved, a deny by invariant, and an escalated one still held.
+func fixture(t *testing.T) (receipts.Export, receiptspec.TrustedKey) {
+ t.Helper()
+ w, err := receipts.OpenLocal(t.TempDir(), ed25519.NewKeyFromSeed(bytes.Repeat([]byte{4}, 32)))
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { _ = w.Close() })
+ ctx := context.Background()
+ wl := receipts.Workload{Namespace: "ns", Name: "wl", UID: "uid"}
+
+ add := func(action string, layers decision.Layers, res decision.Result) {
+ rec, err := receipts.NewDecisionRecord(receipts.Params{Workload: wl, Action: action, Layers: layers, Result: res})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := w.Append(ctx, rec); err != nil {
+ t.Fatal(err)
+ }
+ }
+ add("scale", decision.Layers{ThresholdReasons: []string{"low confidence"}},
+ decision.Result{Outcome: decision.RequireApproval, Layer: decision.LayerThreshold})
+ human, err := receipts.NewHumanRecord(receipts.HumanParams{Workload: wl, Action: "scale", Approval: receipts.Approval{
+ Label: receipts.LabelApprove, Approver: "alice", ApproverSHA256: strings.Repeat("a", 64), PendingID: "p1", OriginalSeq: 1,
+ }})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := w.Append(ctx, human); err != nil {
+ t.Fatal(err)
+ }
+ add("delete_all", decision.Layers{Invariants: []string{"INV-01: credential in the payload"}},
+ decision.Result{Outcome: decision.Deny, Layer: decision.LayerInvariant})
+ add("restart", decision.Layers{ThresholdReasons: []string{"low confidence"}},
+ decision.Result{Outcome: decision.RequireApproval, Layer: decision.LayerThreshold})
+
+ e, err := w.Export()
+ if err != nil {
+ t.Fatal(err)
+ }
+ return e, w.TrustedKey()
+}
+
+var now = time.Date(2026, 10, 2, 0, 0, 0, 0, time.UTC)
+
+func TestBuildVerifiedTimeline(t *testing.T) {
+ e, key := fixture(t)
+ v := decisionview.Build(e, []receiptspec.TrustedKey{key}, now)
+
+ if got := v.Verification.Status(); got != decisionview.StatusVerified {
+ t.Fatalf("status = %s (%+v)", got, v.Verification)
+ }
+ if !v.Verification.Authenticated || !v.Verification.Complete || v.Verification.HeadSeq != 4 {
+ t.Fatalf("verification = %+v", v.Verification)
+ }
+ if len(v.Rows) != 4 || v.Rows[0].Seq != 4 || v.Rows[3].Seq != 1 {
+ t.Fatalf("rows not newest first: %+v", v.Rows)
+ }
+ s := v.Summary
+ if s.Total != 4 || s.ByOutcome["deny"] != 1 || s.Human != 1 {
+ t.Fatalf("summary = %+v", s)
+ }
+ // Seq 1 was answered by the human record, seq 4 is still held.
+ if s.Held != 1 || !v.Rows[0].Held || v.Rows[3].Held {
+ t.Fatalf("held = %d, rows %+v", s.Held, v.Rows)
+ }
+ deny := v.Rows[1]
+ if deny.Outcome != "deny" || deny.Layer != "invariant" || len(deny.ReasonCodes) != 1 || deny.ReasonCodes[0] != "INV-01" {
+ t.Fatalf("deny row = %+v", deny)
+ }
+ if h := v.Rows[2]; h.HumanLabel != "approve" || h.Layer != "human" {
+ t.Fatalf("human row = %+v", h)
+ }
+ d, ok := v.Detail(2)
+ if !ok || d.SignerKID != key.KID || len(d.EntryHash) != 64 || d.Record.Approval == nil {
+ t.Fatalf("detail = %+v ok=%v", d, ok)
+ }
+ if _, ok := v.Detail(99); ok {
+ t.Fatal("detail for a missing seq")
+ }
+}
+
+func TestBuildWithoutPinnedRootIsOnlyConsistent(t *testing.T) {
+ e, _ := fixture(t)
+ v := decisionview.Build(e, nil, now)
+ if got := v.Verification.Status(); got != decisionview.StatusConsistent || v.Verification.Authenticated {
+ t.Fatalf("status = %s authenticated = %v", got, v.Verification.Authenticated)
+ }
+}
+
+func TestBuildWrongPinnedKeyFails(t *testing.T) {
+ e, _ := fixture(t)
+ other := ed25519.NewKeyFromSeed(bytes.Repeat([]byte{9}, 32)).Public().(ed25519.PublicKey)
+ wrong := receiptspec.TrustedKey{KID: receiptspec.ComputeKID(other), PublicKey: other}
+ v := decisionview.Build(e, []receiptspec.TrustedKey{wrong}, now)
+ if got := v.Verification.Status(); got != decisionview.StatusFailed {
+ t.Fatalf("status = %s (%+v)", got, v.Verification)
+ }
+}
+
+func TestBuildTamperedRecordFails(t *testing.T) {
+ e, key := fixture(t)
+ e.RecordsJSONL = strings.Replace(e.RecordsJSONL, `"outcome":"deny"`, `"outcome":"allow"`, 1)
+ v := decisionview.Build(e, []receiptspec.TrustedKey{key}, now)
+ if got := v.Verification.Status(); got != decisionview.StatusFailed {
+ t.Fatalf("status = %s", got)
+ }
+ if len(v.Verification.RecordFailures) != 1 || v.Verification.RecordFailures[0].Reason != receipts.ReasonRecordMismatch {
+ t.Fatalf("record failures = %+v", v.Verification.RecordFailures)
+ }
+}
+
+func TestBuildTruncatedChainIsPartial(t *testing.T) {
+ e, key := fixture(t)
+ v := decisionview.Build(receipts.StripToPrefix(e, 1), []receiptspec.TrustedKey{key}, now)
+ if got := v.Verification.Status(); got != decisionview.StatusPartial {
+ t.Fatalf("status = %s (%+v)", got, v.Verification)
+ }
+ if len(v.Rows) != 3 {
+ t.Fatalf("rows = %d, want 3", len(v.Rows))
+ }
+}
+
+func TestBuildGarbageExport(t *testing.T) {
+ v := decisionview.Build(receipts.Export{ReceiptsJSONL: "not json\n"}, nil, now)
+ if v.Verification.Status() != decisionview.StatusFailed || v.Verification.Error == "" {
+ t.Fatalf("verification = %+v", v.Verification)
+ }
+ if len(v.Rows) != 0 {
+ t.Fatalf("rows from a broken export: %+v", v.Rows)
+ }
+}
+
+type countingSource struct {
+ e receipts.Export
+ err error
+ loads int
+}
+
+func (c *countingSource) Load(context.Context) (receipts.Export, error) {
+ c.loads++
+ return c.e, c.err
+}
+
+func TestLoaderCachesAndKeepsLastGoodOnFailure(t *testing.T) {
+ e, key := fixture(t)
+ src := &countingSource{e: e}
+ clock := now
+ l := &decisionview.Loader{Source: src, Trusted: []receiptspec.TrustedKey{key}, TTL: 2 * time.Second, Now: func() time.Time { return clock }}
+
+ if v := l.Current(context.Background()); v.Err != "" || len(v.Rows) != 4 {
+ t.Fatalf("first view = %+v", v)
+ }
+ clock = clock.Add(time.Second)
+ l.Current(context.Background())
+ if src.loads != 1 {
+ t.Fatalf("loads = %d, want 1 inside the TTL", src.loads)
+ }
+
+ clock = clock.Add(5 * time.Second)
+ src.err = errors.New("writer down")
+ v := l.Current(context.Background())
+ if v.Err == "" || len(v.Rows) != 4 || !v.LoadedAt.Equal(now) {
+ t.Fatalf("stale view = err %q rows %d loadedAt %v", v.Err, len(v.Rows), v.LoadedAt)
+ }
+ // A failure is cached for the TTL, so an outage does not hit the source per request.
+ loadsBefore := src.loads
+ l.Current(context.Background())
+ l.Current(context.Background())
+ if src.loads != loadsBefore {
+ t.Fatalf("loads = %d, want %d: failure must be cached inside the TTL", src.loads, loadsBefore)
+ }
+ // A recovered writer clears the error once the TTL passes.
+ src.err = nil
+ clock = clock.Add(3 * time.Second)
+ if v := l.Current(context.Background()); v.Err != "" || !v.LoadedAt.Equal(clock) {
+ t.Fatalf("recovered view = %+v", v)
+ }
+}
+
+func TestLoaderWithNothingLoadedReportsTheError(t *testing.T) {
+ l := &decisionview.Loader{Source: &countingSource{err: errors.New("no writer")}, TTL: time.Second}
+ v := l.Current(context.Background())
+ if v.Err == "" || v.Verification.Status() != decisionview.StatusFailed || len(v.Rows) != 0 {
+ t.Fatalf("view = %+v", v)
+ }
+}
diff --git a/tools/demo-export/main.go b/tools/demo-export/main.go
new file mode 100644
index 0000000..759c9b9
--- /dev/null
+++ b/tools/demo-export/main.go
@@ -0,0 +1,150 @@
+/*
+Copyright 2026 Clawdlinux.
+Licensed under the Apache License, Version 2.0.
+*/
+
+// Command demo-export writes a sample receipt export for the decision
+// dashboard. It signs with a fixed demo key, so the output is for demos only.
+//
+// go run ./tools/demo-export -out ./demo-dashboard
+// agentctl-web --export-dir ./demo-dashboard/export --trust-root ./demo-dashboard/pinned-trust.json
+package main
+
+import (
+ "bytes"
+ "context"
+ "crypto/ed25519"
+ "flag"
+ "fmt"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/Clawdlinux/agentic-operator-core/pkg/decision"
+ "github.com/Clawdlinux/agentic-operator-core/pkg/decision/input"
+ "github.com/Clawdlinux/agentic-operator-core/pkg/receipts"
+)
+
+func main() {
+ out := flag.String("out", "demo-dashboard", "output directory")
+ flag.Parse()
+ if err := run(*out); err != nil {
+ fmt.Fprintln(os.Stderr, "demo-export:", err)
+ os.Exit(1)
+ }
+}
+
+func f64(v float64) *float64 { return &v }
+
+func run(out string) error {
+ work, err := os.MkdirTemp("", "demo-export-*")
+ if err != nil {
+ return err
+ }
+ defer func() { _ = os.RemoveAll(work) }()
+
+ // Fixed seed: demo only. Never use it for real receipts.
+ w, err := receipts.OpenLocal(work, ed25519.NewKeyFromSeed(bytes.Repeat([]byte("clawdlinux-demo!"), 2)))
+ if err != nil {
+ return err
+ }
+ defer func() { _ = w.Close() }()
+ ctx := context.Background()
+ wl := receipts.Workload{Namespace: "support", Name: "refund-triage", UID: "demo-uid-1"}
+ declared := input.Declared{
+ Purpose: "Triage refund tickets",
+ DecisionType: "assisted",
+ AllowedDataClasses: []string{"email"},
+ AllowedDestinations: []string{"tickets.internal"},
+ }
+
+ add := func(action string, in input.Input, layers decision.Layers, res decision.Result, packs []string, model *receipts.Model) (uint64, error) {
+ rec, err := receipts.NewDecisionRecord(receipts.Params{
+ Workload: wl, Action: action, Input: in, Layers: layers, Result: res,
+ PolicyPacks: packs, ThresholdMode: "strict", Model: model,
+ })
+ if err != nil {
+ return 0, err
+ }
+ r, err := w.Append(ctx, rec)
+ return r.Seq, err
+ }
+ human := func(action, label, pending string, orig uint64, edited []string) error {
+ rec, err := receipts.NewHumanRecord(receipts.HumanParams{
+ Workload: wl, Action: action, ThresholdMode: "strict",
+ Approval: receipts.Approval{
+ Label: label, Approver: "reviewer@example.test", ApproverSHA256: strings.Repeat("b", 64),
+ PendingID: pending, OriginalSeq: orig, EditedFields: edited,
+ },
+ })
+ if err != nil {
+ return err
+ }
+ _, err = w.Append(ctx, rec)
+ return err
+ }
+ obs := func(host string, classes ...string) input.Input {
+ return input.Input{
+ Declared: declared,
+ Observed: input.Observed{Destination: host, DataClasses: classes, Tool: "http", PriorActionCount: 3},
+ Claimed: input.AgentClaimed{Confidence: f64(0.97)},
+ }
+ }
+ allow := decision.Result{Outcome: decision.Allow, Layer: decision.LayerThreshold}
+ held := decision.Result{Outcome: decision.RequireApproval, Layer: decision.LayerThreshold}
+ lowConf := decision.Layers{ThresholdReasons: []string{"Low confidence (0.71) action requires human approval (threshold: 0.95)"}}
+
+ if _, err := add("get_ticket", obs("tickets.internal", "email"), decision.Layers{ThresholdAllowed: true}, allow, nil, nil); err != nil {
+ return err
+ }
+ if _, err := add("export_customers", obs("files.example.test"),
+ decision.Layers{Invariants: []string{"INV-01: credential found in the payload"}},
+ decision.Result{Outcome: decision.Deny, Layer: decision.LayerInvariant}, nil, nil); err != nil {
+ return err
+ }
+ if _, err := add("send_summary", obs("mail.example.test", "email", "phone"),
+ decision.Layers{PackDeny: []string{"dpdp-in/DPDP-02: personal data sent to a host outside the declared destinations"}},
+ decision.Result{Outcome: decision.Deny, Layer: decision.LayerPack}, []string{"dpdp-in@v0.1.0"}, nil); err != nil {
+ return err
+ }
+ refund, err := add("issue_refund", obs("tickets.internal", "email"), lowConf, held, nil, nil)
+ if err != nil {
+ return err
+ }
+ if err := human("issue_refund", receipts.LabelApprove, "pend-1", refund, nil); err != nil {
+ return err
+ }
+ bulk, err := add("bulk_delete_tickets", obs("tickets.internal", "email"), lowConf, held, nil, nil)
+ if err != nil {
+ return err
+ }
+ if err := human("bulk_delete_tickets", receipts.LabelReject, "pend-2", bulk, nil); err != nil {
+ return err
+ }
+ if _, err := add("update_policy", obs("tickets.internal"), lowConf, held, nil, nil); err != nil {
+ return err
+ }
+ score := decision.Score{
+ ModelID: "decision-lr", Version: "0.1.0", FeatureSpec: "v1", ThresholdMicro: 600000,
+ RiskMicro: 180000, ClaimedRiskMicro: 120000, BaselineRiskMicro: 180000,
+ OptionMicro: map[string]int64{"allow": 820000, "require_approval": 180000},
+ ReasonCodes: []string{"prior_actions_bucket"},
+ }
+ model := receipts.NewModelBlock(decision.ModelShadow, score, nil, allow, allow)
+ if _, err := add("close_ticket", obs("tickets.internal", "email"), decision.Layers{ThresholdAllowed: true}, allow, nil, &model); err != nil {
+ return err
+ }
+
+ e, err := w.Export()
+ if err != nil {
+ return err
+ }
+ if err := e.WriteDir(filepath.Join(out, "export")); err != nil {
+ return err
+ }
+ if err := os.WriteFile(filepath.Join(out, "pinned-trust.json"), e.TrustRoot, 0o600); err != nil {
+ return err
+ }
+ fmt.Printf("wrote %s/export and %s/pinned-trust.json (demo key, not for real use)\n", out, out)
+ return nil
+}