Reception Report

Documents and decksevalv1.0.2released 2026-09-01workflow: build-loop

The weekly reception review for your social posting. Reconciles published posts with their live feed records (stamping the corpus reference onto any post that lost track of its live copy), builds a per-post engagement ledger of likes, reposts, and replies, compares each post against your account's recent baseline, and reports what landed, what did not, and what to post next — closing with a single one-click action that seeds the next draft from the strongest theme. Covers social media analytics, post performance review, engagement reporting, cadence tracking, Bluesky and X and Instagram metrics, and honest small-sample reading of your feeds. No connected feed? It still writes the ledger from what the workspace knows and names the gap.

Steps

Entry step: reconcile. Each step names the specialist role it wants; the full working prompt is expandable.

Reconcile posts with live recordsomroeperentry

Stamp missing corpusRef links and build the engagement ledger from the synced records.

Show working prompt

You are reconciling our published posts with their live feed records, looking back {{lookbackDays}} days (if that value reads as a raw {{...}} placeholder, use the default: 7).

1. Read `posts/index.json` with `read_file`, then each listed post folder's `post.md` and every file under its `variants/`. Collect every variant whose `status` is `published` or `scheduled`.
2. For each collected variant MISSING a `corpusRef` in its frontmatter: find its live record in the project artifacts under `data/` (`list_artifacts`, then `read_artifact`) by matching the variant's `postId` or `permalink` against the record frontmatter — fall back to matching the opening text. When found, stamp it: call `record_publication` if it is in your function schema; otherwise edit the variant file with `write_file`, adding `corpusRef: <artifacts-relative record path>` (and `publishedAt` from the record when the variant lacks it). Leave variants that already carry `corpusRef` untouched.
3. If there is no `data/` corpus at all, note "no synced corpus — reconciliation skipped" and still write the ledger from what the workspace knows, with unknown metric cells marked `-`.
4. Write the artifact `{{workPath}}/reports/reception-ledger.md` with `write_artifact`: a markdown table, one row per published or scheduled variant, columns `Post` (slug), `Platform`, `Live record` (the corpusRef path or `-`), `Likes`, `Reposts`, `Replies`, `Metrics as of` (the record's `metrics_updated_at`). Copy every count verbatim from its record; use `-` where unknown. Below the table, add one line per reconciliation you performed this run.

When the ledger artifact is written, call `advance_task_step` to move to analyze.

Analyze receptionomroeper

Read the ledger and work out what over- and under-performed against the account's own baseline.

Show working prompt

Read `{{workPath}}/reports/reception-ledger.md` with `read_artifact`. Every number in your analysis must come from that ledger — cite the post slug next to each figure; no other source of numbers is allowed.

Write the artifact `{{workPath}}/reports/reception-analysis.md` with `write_artifact`:

- `## Per-post` — each post against the account's recent baseline. The median of the ledger's like/repost/reply counts is a fine baseline; name the baseline you used.
- `## What worked, what did not` — formats, themes, or posting times that over- or under-performed, each claim tied to specific ledger rows.
- `## Cadence` — posts shipped in the window versus the project's cadence target when the mission or voice guide states one; when none is stated, say so and suggest a target.

Be honest about small samples: with only a handful of posts, call patterns "early signals", never conclusions. When the analysis artifact is written, call `advance_task_step` to move to report.

Write the reception reportomroeper

Scoreboard, three findings, three recommendations, and exactly one one-click next-post action.

Show working prompt

Assemble the reception report from `{{workPath}}/reports/reception-ledger.md` and `{{workPath}}/reports/reception-analysis.md` (read both with `read_artifact`). Cite no number that is not in the ledger.

Write the report to the artifact `{{workPath}}/reports/reception-report-<today YYYY-MM-DD>.md` with `write_artifact` (use today's real date in the filename), then write the exact same content to `{{workPath}}/reports/reception-report-latest.md` — the stable path the completion gate reads. Write the latest file last. Structure:

- `## Scoreboard` — the ledger table trimmed to `Post`, `Platform`, `Likes`, `Reposts`, `Replies`.
- `## Findings` — exactly 3, each one sentence plus one line of supporting evidence from the ledger or analysis.
- `## Recommendations` — exactly 3, each concrete enough to act on this week.
- `## Next post` — one paragraph naming the strongest theme to post about next, followed by EXACTLY ONE ```gezel-action fenced YAML block. Rules for the block: flat YAML keys (only `params` nests one level); a unique `id` slug that stays stable across weekly runs unless the theme changes; short `title`; one-sentence `reason`; never invent craftbook ids — reference only `draft-social-post`, which ships alongside this workflow:

```gezel-action
kind: fire-craftbook
id: next-post-<theme-slug>
title: Draft the next post
reason: <the strongest theme, grounded in the findings>
craftbookId: draft-social-post
params:
  topic: <the suggested topic>
```

When both report files are written, call `advance_task_step` to move to evaluate.

Evaluatereviewer

Grade the report against every criterion. All pass — finish; any fail — loop back to report with the named gaps.

Show working prompt

Open `{{workPath}}/reports/reception-report-latest.md`, `{{workPath}}/reports/reception-analysis.md`, and `{{workPath}}/reports/reception-ledger.md` with `read_artifact` and grade the report. Check EACH criterion and write PASS/FAIL with a one-line reason:

1. The scoreboard covers every ledger row (no post silently dropped).
2. Every number in the report traces to the ledger (spot-check at least three).
3. There are exactly 3 findings, each with evidence.
4. There are exactly 3 recommendations, each actionable this week.
5. There is exactly one ```gezel-action block, it is valid flat YAML, and its `craftbookId` is `draft-social-post` with a `params.topic` seeded from the strongest theme.
6. Small samples are read honestly — early signals, not sweeping conclusions.

Then route — this is the whole point of the loop:

- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: "evaluate", next: "finish" })`.
- **Any criterion FAILS →** write the specific gaps to task notes with `write_task_note`, then call `advance_task_step({ ref, stepId: "evaluate", next: "report" })` to loop back. The report step fixes exactly those gaps.

Never route to finish while a criterion is unmet. After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.

Finishomroeper

Stamp the summary note and stop.

Show working prompt

Write a one-paragraph DONE summary with `write_task_note`: the report artifact paths (the dated file and `{{workPath}}/reports/reception-report-latest.md`), the top finding in one line, how many posts were reconciled this run, and the recommended next topic. Report DONE.

Triggers

Phrases that suggest this craftbook to a crew.

reception report
how did our posts do
social performance review
weekly social report

Source

View this craftbook on GitHub · MIT license