Przejdź do treści
Biblioteka skilli
DevOps i chmura · Testowanie

deployment-readback-verification

/deployment-readback-verification

Dowodzi, że wdrożenie działa, czytając serwowany artefakt, porównując sumy kontrolne i nie ufając samemu zwrotowi.

Repozytorium
routeros-muse ↗
Licencja
MIT
Ostatnia zmiana repozytorium
04.11.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 04.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Dowodzi, że wdrożenie działa, czytając serwowany artefakt, porównując sumy kontrolne i nie ufając samemu zwrotowi.

Wyzwalacze z opisu

is it live?
Oryginalny opis (EN)

Prove a deploy by reading the served artifact: deploy log separate from source, reload per target, hash-compare read-back, never trust the return. Use when: deploying dashboards, configs, or served code to any target; asking 'is it live?'; debugging serve-vs-source mismatches.

Jak działa

  1. Part 1 — The checklist (deployed means read back)
  2. Part 2 — Skill doc
Sekcje z nagłówków SKILL.md, w oryginale · 230 linii, 1 479 słów
Podgląd SKILL.md
---
name: deployment-readback-verification
description: "Prove a deploy by reading the served artifact: deploy log separate from source, reload per target, hash-compare read-back, never trust the return. Use when: deploying dashboards, configs, or served code to any target; asking 'is it live?'; debugging serve-vs-source mismatches."
topics: [deployment, verification, redaction]
tested: none
---

# `deployment-readback-verification` skill (record → reload → read → compare) [template v1 draft]

Promoted from an /app end-to-end proof
(served + read back), the container deploy recipe
(home-router-container §3), and the never-trust-the-return
finding (False return, flow proceeded). No
secrets below; hashes travel, contents stay targeted.

## Part 1 — The checklist (deployed means read back)

Run top to bottom. Editing source never proves deployment.
The corollary proven on CHR: a success return never proves it
either — only the served artifact, read back, counts.

1. Record the deploy separately from the source (§0): artifact,
   hash, time, target, reload action — the deploy log.
2. Reload per the target's semantics (§1): container, /app,
   disk-synced, each reloads differently — run YOUR target's.
3. Read back the SERVED artifact (§2): over the serving path,
   not the source path — and compare hashes.
4. Reconcile or roll (§3): match closes, mismatch debugs by
   layer, deploys never linger unverified.

### 0. Record (the deploy log is not the source log)

From home-router-container §3 (read this session): build
off-router (canonical source in git/desktop — never author on
the router), then record the deployment SEPARATELY: artifact,
version/hash, time, target path, reload action taken.

- Source says what SHOULD serve; the deploy log says what WAS
  PUT where, when, and how it was activated. One cannot
  substitute for the other — the gap between them is exactly
  where "but I deployed it" incidents live.
- Hash at record time (sha256 of the artifact bytes): the
  read-back (§2) compares against THIS, not against a
  re-read of source (source may have moved since).
- Served-code rule rides here (home-router-container §3 step 2):
  router-served dashboard/proxy code MUST be npm-compatible,
  no Bun-isms — review diffs against the rule BEFORE the
  deploy record is written. A Bun-ism fails the review like
  a secret in a commit.
- Transfer mechanics (home-router-container §3 step 3 + friction notes):
  centrs transfer, minding first-attempt 0-byte (retry
  `--force`) and SFTP pinning. Transfer-log "ok"
  is a claim about BYTES MOVED, not about serving — it
  opens the deploy record, it never closes it.

### 1. Reload (each target its own semantics)

Editing/transferring never activates: every serving target has
a reload step, and skipping it serves the OLD artifact with a
NEW deploy record — the classic mismatch.

- **Container HTTP** (proven on CHR): nginx:alpine served 200
  "Welcome to nginx!" after pull + start; node:alpine
  executed on request. Reload = container (re)start per the
  container lifecycle (config changes via `configs:` need
  the recreate path — a config edit beside a running
  container serves stale until recreated).
- **/app** (proven end-to-end on CHR): `/app/set use-https=no`
  → app pulls, runs, serves; t26-hello-node served HTTP 200
  `t26-ok`. Reload = the /app state machine (set/start);
  watch `.about` for the REAL error (native-api may hide
  pending/transitory ones — a listen may be needed).
- **Disk-synced surfaces** (collected: container-render-surface
  + disk-sync): file copy + served-by-container (self-pull
  or agent-push). Reload = whatever re-reads: container
  restart, app re-pull, or the sync tick — NAME it in the
  deploy record; "the sync handles it" is not a reload
  action (anti-drive-live: sync-haunted phrases).
- **Published ports**: /app created the correct
  dstnat rule (host:8080 → container:80) but router-side
  fetch to :8080 refused — router-originated packets bypass
  dstnat. Published-path verification happens at RULE level
  on CHR; packet-level needs hardware or a host forward.
  Record WHICH level the proof reached.

### 2. Read back (served path, hash compare)

The end-to-end shape: served HTTP 200 `t26-ok`, read back
router-side via `/tool/fetch` to the container IP. Generalize:

- Read over the SERVING path: HTTP fetch for HTTP artifacts
  (router-side `/tool/fetch` to the container/app address),
  file read for file-served artifacts (`:put [/file/get …]`
  proven on a twin with exact byte sizes). Never "verify" by
  re-reading the SOURCE, the transfer log, or the return
  code — those aren't the served thing.
- Compare HASHES (record-time sha256 vs read-back sha256):
  equality closes, inequality debugs. Byte counts travel
  alongside (401 B real, exact) — size mismatch with
  hash match is impossible; size match with hash mismatch
  is corruption with confidence.
- Redaction rides the read-back (topics: redaction): served
  artifacts get the tiering test (pre-publish-scrub sensitivity tiers) —
  a dashboard that serves a secret is a leak with a URL.
  The read-back that proves deployment ALSO proves
  servability-safety, same bytes, second verdict.
- NEVER TRUST THE RETURN (debugging note, load-bearing):
  the first `use-https=no` set returned False yet the flow
  proceeded. Returns lie in both directions (false False,
  false True) — the read-back is the only truth. Any
  procedure that branches on a return without a read-back
  is pending, not proven.

### 3. Reconcile (match closes, mismatch layers)

- MATCH (hashes equal over the serving path): close the
  deploy record with the read-back cited (time + path +
  hash). The deploy is DONE — say so, short sentence,
  pointer to the record.
- MISMATCH: debug by layer, in order — (1) reload skipped?
  (§1: most common — old artifact serving), (2) wrong
  target? (path/version skew between record and server),
  (3) transfer short? (0-byte class — re-transfer +
  re-read), (4) serving stale cache? (restart/re-pull the
  server, not the source), (5) read the wrong path?
  (your fetch != the served route — dstnat-bypass class).
  Fix the layer, re-record, re-read. Never edit the record
  to match the read — the record describes the ATTEMPT.
- Deploy tracked in the session close (home-router-container
  §7: record any deployments) + operations deployments log
  (templates/network/operations/deployments.md): the fleet's deploy
  history is one list, per-artifact entries, each closed
  by its read-back. Unclosed entries are drift until
  proven (capture-drift-hygiene).
- Rollback = a new deploy record (old artifact hash,
  new time, same reload + read-back): rollbacks verify
  like deploys because they ARE deploys. "Rolled back"
  without a read-back is a wish.

## Part 2 — Skill doc

### Trigger

Load when: deploying anything served (dashboard, config,
proxy, page, file tree); "is it live?" questions; served
content looks stale or wrong; designing a deploy pipeline.
(Entry-skill + capability-probe pattern.)

### Prereqs

- Artifact built + hashed off-router (source canonical
  elsewhere — home-router-container §3 step 1).
- Target's reload semantics known (§1 row) BEFORE the
  transfer — deploying without knowing the reload is
  half a plan.
- Read-back path available (`/tool/fetch` router-side,
  HTTP from the consumer side, or file read) + the
  expected hash in hand.

### Access

- Deploys are writes: approval per item, staging where
  the target allows (twin-first for the procedure per
  change-apply; the /app shape is proven on CHR).
- Production /app + container lifecycle needs
  the developer (owner-hands for enablement semantics;
  agent verifies after, home-router-container §2).
- Read-backs are reads: free anywhere, any time — and
  the ONLY deploy proof, so run them generously.

### Envs

| Name | Use |
|---|---|
| (none) | Transfers + reloads + fetches take CLI shape; no environment. |

### Outputs

- Deploy record: artifact + hash + time + target path +
  reload action + read-back (hash match cited).
- Mismatch debug trail (when: layer found + fix + re-proof).
- Fleet deploy-history entry (operations/deployments.md).
- Servability-safety verdict (redaction tiering on the
  served bytes).

### Verification

- Hash equality over the SERVING path, quoted (record hash
  vs read-back hash — both values, not "match ✓" alone…
  well, the values' shapes where secret-adjacent).
- Reload action named + confirmed (container state, /app
  `.about`, sync tick — per target, not assumed).
- Published paths: level stated (rule-level vs
  packet-level — the dstnat lesson).
- Deploy history entry closed with the read-back pointer;
  no open-ended "deployed" claims anywhere.

### Recovery

- False-False return (flow proceeded): ignore the return,
  run the read-back. Returns are hints.
- False-True return (flow didn't): the read-back catches
  it (stale hash) — then debug by layer (§3), starting
  with reload-skipped.
- Stale-forever (reloads don't take): suspect the wrong
  target (two containers, old + new) or a stuck server
  (recreate, don't poke) — identify by served-hash
  fingerprinting, then fix decisively.
- Deploy record lost (source moved, hash unknown): re-hash
  the CURRENT source, note the skew honestly (record hash
  ≠ deploy hash — the read-back still proves CURRENT
  serving, not the original deploy), re-record going
  forward.

### Limits

- SECTION-VS-STANDALONE (answered
  here with source): home-router-container §3 IS the
  container deploy recipe (record + rule + transfer +
  read-back) — this skill generalizes it across targets
  (/app, disk-synced, published ports) with reload
  semantics + the never-trust-the-return proof. home-router-container
  keeps its recipe (home-specific); this is the
  cross-home procedure homes cite. No duplication: it
  specializes, this generalizes.
- The proof is CHR (/app + containers on CHR free):
  published-path packet level + hardware serve paths need
  hardware proof (rule-level verified, packets pending).
- Reload rows for disk-synced surfaces collected
  (container-render-surface), not executed here: first disk-synced
  deploy grounds its row.
- Hash-compare proves BYTES served, not MEANING served:
  a correct-hash dashboard with wrong data is a data bug
  past this skill's verdict — the read-back proves the
  pipe, the content needs its own eyes.

Wersje

W bazie nie ma innych skilli o nazwie deployment-readback-verification.

Migawka bazy z 13.11.2026 · wersja paczki 1e0d2445db71 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90container-render-surface
    Udostępnia prostą stronę statusu z routera przez wdrożenie YAML, sprawdza ją odczytem i usuwa ją, przywracając stan sprzed wdrożenia.
  • 100vercel-deploy
    Wdraża aplikacje i strony na Vercel na prośbę o deploy, link do wdrożenia lub wdrożenie preview.
  • 100vercel-deploy
    Wdraża aplikacje i strony na Vercel na prośbę o deploy, link do wdrożenia lub wdrożenie preview.
  • 100deploy
    Wdraża znany artefakt lub konfigurację do wybranego środowiska, sprawdza działanie usługi i wykonuje autoryzowane cofnięcie wdrożenia.
  • 100deploy-to-vercel
    Wdraża aplikacje i strony internetowe na Vercel, na przykład na prośbę o wdrożenie, link do działającej wersji albo wdrożenie podglądowe.
  • 100deploy-to-vercel
    Wdraża aplikacje i strony internetowe na Vercel, na przykład na prośbę o wdrożenie, link do działającej wersji albo wdrożenie podglądowe.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.