From ac923b504651600d66935d387d576cba64c6d724 Mon Sep 17 00:00:00 2001
From: David Bon-Salomon <62355986+David-BS@users.noreply.github.com>
Date: Sat, 6 Jun 2026 18:22:25 +0200
Subject: [PATCH] feat(posting-brief): posting brief generator at intake
 (0.20.0)

---
 CHANGELOG.md                                  |  14 +
 SKILL.md                                      |  14 +-
 modules/posting-brief-generator/GUIDE.md      | 162 ++++++++++
 .../references/posting_brief_structure.md     |  70 +++++
 .../scripts/generate_posting_brief.py         | 282 ++++++++++++++++++
 .../scripts/md_to_pdf.py                      | 161 ++++++++++
 references/assistant_flow.md                  |   6 +
 tests/test_examples.py                        |   6 +-
 tests/test_posting_brief.py                   | 209 +++++++++++++
 tooling/build_samples.py                      |  44 +++
 10 files changed, 959 insertions(+), 9 deletions(-)
 create mode 100644 modules/posting-brief-generator/GUIDE.md
 create mode 100644 modules/posting-brief-generator/references/posting_brief_structure.md
 create mode 100644 modules/posting-brief-generator/scripts/generate_posting_brief.py
 create mode 100644 modules/posting-brief-generator/scripts/md_to_pdf.py
 create mode 100644 tests/test_posting_brief.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f102410..b9ac77e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,20 @@ fix → patch (`0.3.x`); feature addition → minor (`0.x.0`).
 > Ajouté → Added · Modifié → Changed · Corrigé → Fixed · Déprécié → Deprecated ·
 > Supprimé → Removed · Sécurité → Security · Validé → Validated · Documentation → Documentation.
 
+## [0.20.0] — 2026-06-06
+
+### Added
+- **Posting brief (PB-1) — new `posting-brief-generator` sub-module.** At application intake, the orchestrator now produces a Markdown **posting brief** (job-posting dossier) automatically and **first**, before the widget's six deliverables — it is **not** a selection-widget choice. Content: a header (company, position, recruiter, city, capture date, source URL, posting language), the **verbatim** posting body, and a short model-extracted **digest** (key requirements + application deadline). It reuses the offer already read in the single global analysis, so it adds no separate offer read and nothing to the time-to-widget. Generated via `generate_posting_brief.py`; optional styled PDF via the module's `md_to_pdf.py` (also part of the end-of-run PDF batch). Eighth sub-module of the suite.
+- **Script-owned filename** for the brief: `generate_posting_brief.py --output-dir <dir>` builds `Posting_Brief_<Company>_<Position>_<YYYYMMDD>.md` and prints the path (read it to present the file). `--output-path` is accepted as a fallback (gallery / back-compat). The **capture date** is stamped by the script (today's local date; `--timezone` resolved by the model with a safe `Europe/Paris` fallback — same model=zone / script=clock boundary as the tracker), never model-supplied.
+- **Tracker id `posting_brief`** recorded in the `deliverables` column at `add_to_tracker`.
+
+### Changed
+- **Surface contract (LNG-2):** the brief's section/field labels are model-supplied in the run language via `--labels-json` (exact 13-key set; missing/extra rejected). Structure, `print` output and the verbatim body stay script-owned. Critical fields (`company_name`, `job_title`, `posting_body`) are guarded by the neutral `__MISSING__` sentinel → exit 2 (the model asks, never invents), the same contract as `fill_cover_letter`.
+- **Orchestration (`SKILL.md`):** STEP 4 generates the brief first (idempotent — skipped if a `Posting_Brief_*` already exists for the application, STEP 2; regenerated only on an explicit request); STEP 7 includes it in the PDF batch; module map and the sub-module count (7 → 8) updated. `references/assistant_flow.md` documents the out-of-widget `posting_brief` id.
+
+### Tests
+- **`tests/test_posting_brief.py`** (new): ISO-639-1 form accept/reject, exact label-set (missing/extra) rejection, required-field and `__MISSING__`/empty critical-field rejection (exit 2), the **script-owned filename + printed-path** invariant, the `--output-path` fallback, and `resolve_timezone` valid/fallback. The brief is also added to the acceptance gallery (`tooling/build_samples.py`).
+
 ## [0.19.0] — 2026-06-06
 
 ### Changed
diff --git a/SKILL.md b/SKILL.md
index 2e4e8e8..4baa637 100644
--- a/SKILL.md
+++ b/SKILL.md
@@ -1,15 +1,15 @@
 ---
 name: candidate-suite
-version: 0.19.0
+version: 0.20.0
 updated: 2026-06-06
 description: "All-in-one suite for preparing job applications and interviews, bundled as a single module: cover letter, interview prep, application summary, strategic playbook, one-page reference card, and application tracking, plus candidate-profile configuration. Single entry point: it shows a selection widget, then generates each deliverable through its sub-module's script. Use whenever the user wants to apply for a role, prepare an application or an interview, get tools for a job posting, configure the skill or update their CV or profile, generate a cover letter, produce a summary, playbook, or reference card, track applications or view their application dashboard (e.g. asking where their applications stand), or makes any open-ended request for job-application help. These are intents, not required wordings: match the user's intent regardless of the language the request is written in."
 ---
 
 # candidate-suite
 
-`Version 0.16.6 — 2026-06-05`
+`Version 0.20.0 — 2026-06-06`
 
-**candidate-suite** is an **all-in-one** suite: a single module to install that bundles the orchestrator (this root) and 7 specialized sub-modules. Faced with a job-application request, this skill shows a **selection widget** that turns the vague request into an explicit command, then generates each deliverable through the relevant sub-module's script. **Nothing is written by hand.**
+**candidate-suite** is an **all-in-one** suite: a single module to install that bundles the orchestrator (this root) and 8 specialized sub-modules. Faced with a job-application request, this skill shows a **selection widget** that turns the vague request into an explicit command, then generates each deliverable through the relevant sub-module's script. **Nothing is written by hand.**
 
 ## 🗺️ Suite architecture — path convention (READ FIRST)
 
@@ -28,6 +28,7 @@ The modules' Python code is unchanged: each script receives all its paths as arg
 | Deliverable / need | Module | Main script |
 |---|---|---|
 | Profile / CV / signature / templates config | `modules/candidate-config` | `setup_workflow.py`, `setup_signature.py`, `generate_templates.py` |
+| Posting brief (auto at intake) | `modules/posting-brief-generator` | `generate_posting_brief.py` (+ `md_to_pdf.py`) |
 | Strategic playbook | `modules/strategic-playbook-generator` | `generate_playbook.py` (+ `md_to_pdf.py`) |
 | Application summary | `modules/application-summary-generator` | `generate_application_summary.py` (+ `md_to_pdf.py`) |
 | Interview prep | `modules/interview-prep-generator` | `generate_interview_prep.py` (+ `md_to_pdf.py`) |
@@ -70,7 +71,7 @@ How a chosen language is *realized* (register, idiom, dates, numbers, spacing, l
 5. **Gather the relevant memory items** for the widget block (if memory is active): name/profile, CV, address, ongoing applications, preferences. Each item has `id`, `label`, `value`. Present as "non-exhaustive," never as an audit.
 
 ### STEP 2 — Already-produced deliverables
-Look in `/mnt/user-data/outputs/` for already-generated deliverables (`Strategic_Playbook_*`, `Application_Summary_*`, `Interview_Prep_*`, `Cover_Letter_*`, `Quick_Reference_*`) to pre-check / grey out the boxes.
+Look in `/mnt/user-data/outputs/` for already-generated deliverables (`Strategic_Playbook_*`, `Application_Summary_*`, `Interview_Prep_*`, `Cover_Letter_*`, `Quick_Reference_*`) to pre-check / grey out the boxes. Also note any `Posting_Brief_*` for this application: it is **not** a widget box, but its presence makes the auto-intake brief (STEP 4) idempotent — don't regenerate it.
 
 ### STEP 3 — Show the widget
 ```bash
@@ -102,7 +103,8 @@ Input arrives one of two **equivalent** ways: (a) the **Generate click** — the
    - **Circulate the value:** pass it as `--language <code>` to each script below (letter = confirmed **offer** language; help-docs = **working** language, or the override). any ISO 639-1 code works (**L6**): there are no per-language assets anymore — the scripts are language-agnostic and the model supplies the labels/strings in the run language.
    - **Beyond `--language` (labels contract — L6):** each deliverable's **structure labels** are produced **by the model in the run language** and passed to its script — `--labels-json '{...}'` for the four `.md` generators (the script enforces the **exact** key set — no invented/omitted section), and `subject_label` / `greeting` / `closing` in the letter's `--data-json`. See each module `GUIDE.md` + `references/language_style_generic.md`.
    - **Persist (letter only, opportunistic):** when the letter language was confirmed and the application is (or is being) added to the tracker, write it to the tracker `language` column for silent reuse on resume. Letter-only without a tracker → persist nothing. Help-doc language is **never** persisted.
-4. **Generate each chosen deliverable**, in the mandatory order below, **through the module's script** (never by hand). Read the module's `GUIDE.md` for the details, and prefix its paths with `modules/<name>/`:
+4. **First, automatically generate the posting brief** (PB-1) — it is **not** a widget choice — then **generate each chosen deliverable**, in the mandatory order below, **through the module's script** (never by hand). Read the module's `GUIDE.md` for the details, and prefix its paths with `modules/<name>/`:
+   - `posting_brief` → `modules/posting-brief-generator` (**automatic, first, not a widget box**) — produced from a job posting at intake, **reusing the offer already read in the single global analysis** (sub-step 3), so it adds no separate offer read and nothing to the time-to-widget. Header + **verbatim** body + model-extracted digest (key requirements / deadline). The capture date and the **filename are script-owned** (`--output-dir`, read the printed path; never hand-compose `--output-path`). **Idempotent**: skip if a `Posting_Brief_<company>_<position>_*` already exists in outputs (STEP 2); regenerate only on an explicit request. Present it via `present_files`, and record its id `posting_brief` in the tracker `deliverables` (at `add_to_tracker`). Trigger = the presence of a job posting (the same trigger as the STEP 8 title); pure config actions produce no brief. Details: its `GUIDE.md`.
    - `strategic_playbook` → `modules/strategic-playbook-generator`
    - `application_summary` → `modules/application-summary-generator`
    - `interview_prep` → `modules/interview-prep-generator`
@@ -112,7 +114,7 @@ Input arrives one of two **equivalent** ways: (a) the **Generate click** — the
 5. Respect the dependencies (reference card after the documents it condenses).
 6. No intermediate validation between deliverables.
 7. Offer PDF export at the end, then, if the user agrees, generate the PDFs of **all** produced deliverables:
-   - `.md` deliverables (playbook, summary, interview prep, reference card) → the relevant module's `md_to_pdf.py`;
+   - `.md` deliverables (posting brief, playbook, summary, interview prep, reference card) → the relevant module's `md_to_pdf.py`;
    - **cover letter `.docx`** (#7) → `python modules/cover-letter-generator/scripts/docx_to_pdf.py --input <letter.docx> --output <letter.pdf>` (LibreOffice; if unavailable the script exits with code 3 and the letter stays usable as `.docx`). Don't forget the letter in the PDF batch.
 8. **Suggest the canonical conversation title** `📋 YYYY-MM-DD - Company - Position`, **systematically as soon as a deliverable is generated from a job description** — whatever the flow: full guided flow **OR** creation of a single specific document. The trigger is the **presence of a job description** (so not pure configuration actions: profile, signature, which are tied to no posting). **Title date = date of first activity if the application is already tracked, otherwise today's date** (candidate's local date — same locale resolution as the tracker timestamp) → a **time-stable title** (resuming on another day suggests the same title). It is a **suggestion for the user to apply**: the assistant **cannot rename** the conversation itself. This marker makes it findable in the **sidebar** (on desktop, conversation links aren't clickable). If the conversation already has this name, the suggestion lands correctly — zero cost.
 
diff --git a/modules/posting-brief-generator/GUIDE.md b/modules/posting-brief-generator/GUIDE.md
new file mode 100644
index 0000000..d3cc5ae
--- /dev/null
+++ b/modules/posting-brief-generator/GUIDE.md
@@ -0,0 +1,162 @@
+> **⚠️ MODULE OF THE "candidate-suite" SUITE — PATH RELOCATION**
+> This module lives in `modules/posting-brief-generator/`. All the relative paths below
+> (`scripts/…`, `references/…`) are relative to THIS folder.
+> From the suite root: prefix them with `modules/posting-brief-generator/`
+> (e.g. `python modules/posting-brief-generator/scripts/<script>.py …`), or change into
+> `modules/posting-brief-generator/` before running. The scripts' code is UNCHANGED:
+> they receive all their paths as arguments, nothing is hard-coded.
+
+---
+name: posting-brief-generator
+description: Generates a job-posting brief (dossier) in Markdown captured at application intake: header (company, position, recruiter, city, capture date, source, language), the verbatim posting body, and a short model-extracted digest (key requirements + deadline). Produced automatically when an application is opened; can be regenerated on explicit request.
+---
+
+# Posting brief generator
+
+Generates a **posting brief** — the job-posting dossier captured at application
+**intake**. It is an internal working document (not an outgoing deliverable):
+it preserves the offer so the application keeps a single, durable reference.
+
+## ⚠️ EXECUTION RULE (NON-NEGOTIABLE)
+
+This module produces its deliverable ONLY via its Python scripts. Never write the final document "by hand" with `create_file`. Claude's role: PREPARE the content (JSON), then RUN the `generate_posting_brief.py` script, then offer/run `md_to_pdf.py`.
+
+- ✅ Extract the content → build the JSON → run the script
+- ❌ DO NOT `create_file` a hand-written .md
+- ❌ DO NOT invent an output format different from the script's
+
+## ⚠️ AUTOMATIC AT INTAKE — NOT A WIDGET CHOICE
+
+Unlike the six standard deliverables, the posting brief is **not** a selection-widget
+checkbox. The orchestrator (SKILL STEP 4) produces it **automatically, first**, as soon
+as an application is opened from a job posting, reusing the offer already read in the
+single global analysis. It is **idempotent**: skip it if a `Posting_Brief_<Company>_<Position>_*`
+already exists in `/mnt/user-data/outputs/` for this application. Regenerate it only on an
+**explicit** user request ("redo the posting brief", "capture this offer again").
+
+## ⚠️ FUNDAMENTAL RULES
+
+1. **Prerequisite**: a job posting (raw text or URL). No CV / config is required — the
+   brief is about the *offer*, not the candidate.
+
+2. **Output format = Markdown (.md)** in `/mnt/user-data/outputs/`. Offer the PDF export
+   afterwards (it is also included in the orchestrator's end-of-run PDF batch, STEP 7).
+
+3. **Filename is SCRIPT-OWNED**: pass `--output-dir /mnt/user-data/outputs` and let the
+   script build `Posting_Brief_<Company>_<Position>_<YYYYMMDD>.md` and **print the path**.
+   Read the printed path to present the file. Never hand-compose `--output-path`.
+
+4. **Verbatim body**: `posting_body` is the offer text **copied as-is** (not summarized,
+   not rephrased). The digest is *in addition*, never a replacement.
+
+5. **Extraction = the model's job**, in any language, **no regex**. Header fields and the
+   digest (key requirements, deadline) are read from the offer by you.
+
+6. **Critical fields** (`company_name`, `job_title`, `posting_body`) must be real values:
+   the script refuses (exit 2) an empty value or the neutral sentinel `__MISSING__` — ask
+   the user, never invent.
+
+## Overview
+
+### Inputs
+- **Job posting**: raw text OR URL (the orchestrator already has it from the global analysis)
+
+### Outputs
+- **`.md` file** in `/mnt/user-data/outputs/` (the brief)
+- **`.pdf` file** optional (offered after the .md / batch in STEP 7)
+- **Naming** (script-owned): `Posting_Brief_<Company>_<Position>_<YYYYMMDD>.md`
+
+### Tracker
+The brief's id is **`posting_brief`**. When the application is added to the tracker
+(`add_to_tracker`), include `posting_brief` in the `deliverables` list.
+
+## Structure labels (produced by the model — L6)
+
+This generator does **not** hard-code per-language labels. **You** produce the section/field
+labels **in the run language** (the working/conversation language) and pass them as
+`--labels-json '{...}'` (alongside `--data-json` and `--language`). The script enforces the
+**exact** key set below — a missing or extra key is rejected (anti-hallucination guardrail:
+the structure is fixed, only the wording is yours).
+
+**Required keys** (exact set, 13): `title`, `s_meta`, `l_company`, `l_position`,
+`l_recruiter`, `l_city`, `l_captured`, `l_source`, `l_language`, `s_digest`,
+`sub_requirements`, `sub_deadline`, `s_posting`
+
+Each value is the label for that slot, **written by the model directly in the run language,
+by intent** — there is **no per-language phrase table** (L6). Render each label from what it
+*is* (e.g. `title` = names the document as a job-posting brief/dossier; `s_posting` = the full
+job posting; `sub_deadline` = application deadline). **Never transliterate an English label.**
+See `modules/cover-letter-generator/references/language_style_generic.md` for register / locale
+conventions.
+
+## Workflow
+
+### STEP 1 — Get the posting
+- **Raw text** → continue
+- **URL** → `web_fetch`; if it fails → ask for a copy-paste
+
+### STEP 2 — Extract (model, no regex)
+From the offer, read out:
+- **Header**: `company_name`, `job_title`, `recruiter_name` / `recruiter_title` (if any),
+  `city` (if any), `source_url` (if any), `posting_language` (human-readable, e.g. "English").
+- **Digest**: `requirements` (the key requirements, a short list), `deadline` (if stated).
+- **Body**: `posting_body` = the offer text **verbatim**.
+
+The capture date is **not** yours: the script stamps today's local date (resolve the IANA
+timezone the same way as the tracker — candidate's city → session locale → fallback — and pass
+`--timezone`).
+
+### STEP 3 — Generate the .md
+
+Build the JSON and run:
+```bash
+python scripts/generate_posting_brief.py \
+  --language <code> \
+  --output-dir /mnt/user-data/outputs \
+  --data-json '<full_json>' \
+  --labels-json '<labels_json — exact key set, values localized in the run language>' \
+  --timezone <IANA, e.g. Europe/Paris>
+```
+
+**Read the printed path** and present the `.md` with `present_files`.
+
+### STEP 4 — Offer the PDF export
+
+**After presenting the .md, offer**:
+```
+The posting brief is ready in Markdown. Would you also like a PDF version?
+```
+If yes (or as part of the orchestrator's end-of-run PDF batch), run:
+```bash
+python scripts/md_to_pdf.py \
+  --input /mnt/user-data/outputs/<filename>.md \
+  --output /mnt/user-data/outputs/<filename>.pdf \
+  --title "<deliverable title>"
+```
+Present the `.pdf` with `present_files`.
+
+## Supported user commands
+
+- *(automatic)*: produced first by the orchestrator at intake (SKILL STEP 4)
+- `"Redo the posting brief"` / `"Capture this offer again"`: regenerate
+- `"Export the brief to PDF"`: convert an existing .md
+
+## Available scripts
+
+| Script | Usage |
+|--------|-------|
+| `generate_posting_brief.py --language X --output-dir DIR --data-json '...' --labels-json '...' [--timezone TZ]` | Generates the .md (script-owned filename) |
+| `md_to_pdf.py --input X.md --output X.pdf [--title "..."]` | Converts .md → styled PDF |
+
+## References
+
+- `references/posting_brief_structure.md`: detailed structure of the brief
+
+## Important rules
+
+- **AUTOMATIC at intake**, first; **idempotent** (skip if already present); regenerate only on explicit request
+- **.md format** in `/mnt/user-data/outputs/`; offer the PDF after
+- **Filename is script-owned** (`--output-dir`, read the printed path)
+- **Body verbatim**; the digest is additive
+- **Extraction by the model**, any language, **no regex**
+- **Critical fields** empty / `__MISSING__` → exit 2: ask, never invent
diff --git a/modules/posting-brief-generator/references/posting_brief_structure.md b/modules/posting-brief-generator/references/posting_brief_structure.md
new file mode 100644
index 0000000..9db310d
--- /dev/null
+++ b/modules/posting-brief-generator/references/posting_brief_structure.md
@@ -0,0 +1,70 @@
+# Structure of the posting brief
+
+The posting brief is the job-posting dossier captured at application **intake**.
+It is an internal working document: it preserves the offer (so the application
+keeps one durable reference) and adds a short, model-extracted digest.
+
+Three sections, in this fixed order.
+
+## Section 1 — Header ("at a glance")
+
+A compact key/value list. Field labels come from `--labels-json`; values come
+from `--data-json`, except the **capture date**, which the script stamps itself.
+
+| Slot | Label key | Value source | Notes |
+|------|-----------|--------------|-------|
+| Company | `l_company` | `company_name` | **critical** (empty / `__MISSING__` → exit 2) |
+| Position | `l_position` | `job_title` | **critical** |
+| Recruiter | `l_recruiter` | `recruiter_name` (+ `recruiter_title`) | optional → `—` if absent |
+| City | `l_city` | `city` | optional → `—` |
+| Captured | `l_captured` | *script* (today, local date, `YYYY-MM-DD`) | never model-supplied |
+| Source | `l_source` | `source_url` | optional → `—` |
+| Language | `l_language` | `posting_language` | human-readable, e.g. "English" |
+
+The header section title is `s_meta`.
+
+## Section 2 — Digest (model-extracted)
+
+Section title `s_digest`, with two sub-sections:
+
+- **Key requirements** (`sub_requirements`): `requirements`, a short list of the
+  offer's must-haves (a handful of bullets, the model's reading of the posting —
+  not a copy of every line). Distinctive and concrete, not generic.
+- **Deadline** (`sub_deadline`): `deadline` if the offer states one, else `—`.
+
+The digest is **additive**: it never replaces the verbatim body below.
+
+## Section 3 — Posting (verbatim)
+
+Section title `s_posting`. The value is `posting_body`: the offer text **copied
+as-is** — not summarized, not rephrased, not truncated. This is the archival
+purpose of the brief. If the offer came from a URL, this is the fetched text.
+
+`posting_body` is **critical** (empty / `__MISSING__` → exit 2): without the
+offer there is nothing to capture.
+
+## Example header (EN)
+
+```
+## At a glance
+- **Company:** Acme Financial Group
+- **Position:** Head of Engineering
+- **Recruiter:** Jane Smith, Head of Talent
+- **City:** Paris
+- **Captured:** 2026-06-06
+- **Source:** https://careers.example.com/head-of-engineering
+- **Language:** English
+```
+
+## Example digest (EN)
+
+```
+## Digest
+### Key requirements
+- 10+ years leading engineering organizations at scale
+- Proven payments / fintech platform modernization
+- Fluent French and English
+
+### Application deadline
+30 June 2026
+```
diff --git a/modules/posting-brief-generator/scripts/generate_posting_brief.py b/modules/posting-brief-generator/scripts/generate_posting_brief.py
new file mode 100644
index 0000000..2ae3136
--- /dev/null
+++ b/modules/posting-brief-generator/scripts/generate_posting_brief.py
@@ -0,0 +1,282 @@
+"""
+Generates a Markdown "posting brief" — the job-posting dossier captured at
+application intake (PB-1).
+
+The brief is an internal working document, not an outgoing deliverable: it
+records the offer so the application has a single, durable reference. It holds
+a header (company, position, recruiter, city, capture date, source URL, posting
+language), the *verbatim* posting body, and a short model-extracted digest (key
+requirements + deadline).
+
+Usage (filename is SCRIPT-OWNED — prefer --output-dir):
+    python generate_posting_brief.py \\
+        --language en|fr \\
+        --output-dir /mnt/user-data/outputs \\
+        --data-json '<json_string>' \\
+        --labels-json '<json_string>' \\
+        [--timezone Europe/Paris]
+
+    # --output-path is accepted as a fallback (e.g. the acceptance gallery),
+    # but hand-composed names are discouraged: the script names the file from
+    # (company, position, capture date) so the format never drifts.
+
+The --data-json JSON must contain:
+    - company_name, job_title          (critical: empty / __MISSING__ -> exit 2)
+    - posting_body                      (critical: the offer text, verbatim)
+    - posting_language                  (human-readable, e.g. "English")
+    - requirements : [str, ...]         (key requirements, model-extracted)
+    - recruiter_name (opt), recruiter_title (opt), city (opt),
+      source_url (opt), deadline (opt)
+
+The capture date is built BY THE SCRIPT (today's local date for the candidate,
+resolved via --timezone, ISO YYYY-MM-DD) — never supplied by the model, so it
+cannot drift or be invented. The same date is used in the filename.
+
+Extraction (header fields, digest) is the MODEL's job; there is no regex.
+"""
+
+import argparse
+import json
+import re
+import sys
+from datetime import datetime
+from pathlib import Path
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+# Language-neutral sentinel for a critical field the model could not fill
+# (same contract as fill_cover_letter, LNG-2 S3b): empty or sentinel -> exit 2.
+# The model asks the user; it never invents company / position / posting body.
+MISSING_SENTINEL = "__MISSING__"
+
+# Fixed label set = the deliverable's STRUCTURE. The model supplies the localized
+# VALUES via --labels-json (target language); the script only enforces that the
+# key set is EXACTLY this — no invented or omitted section (anti-hallucination
+# guardrail). The structure is fixed; only the linguistic realization is the model's.
+REQUIRED_LABELS = {
+    "title",
+    "s_meta",
+    "l_company",
+    "l_position",
+    "l_recruiter",
+    "l_city",
+    "l_captured",
+    "l_source",
+    "l_language",
+    "s_digest",
+    "sub_requirements",
+    "sub_deadline",
+    "s_posting",
+}
+
+
+def iso639_1(value):
+    """Validate --language as an ISO 639-1 *form*: two lowercase letters.
+
+    Open by design (LNG-1 L5) — no maintained list, no external dependency.
+    Post-L6 there is no per-language lock: the generator validates the
+    model-provided label *key set* (`--labels-json`), not the language.
+    `--language` is form-validated metadata only; any ISO code works.
+    """
+    if not re.fullmatch(r"[a-z]{2}", value or ""):
+        raise argparse.ArgumentTypeError(
+            f"--language must be a 2-letter ISO 639-1 code (lowercase), e.g. en, fr; got: {value!r}"
+        )
+    return value
+
+
+def resolve_timezone(name):
+    """Resolve an IANA timezone name to a ZoneInfo, with a safe fallback.
+
+    The model resolves the candidate's locale to an IANA name and passes it; the
+    script only strikes the clock (model = zone, script = clock — same boundary
+    as manage_tracker). An unknown/empty name warns and falls back to
+    Europe/Paris so a capture date is never the reason generation fails.
+    """
+    if name:
+        try:
+            return ZoneInfo(name)
+        except (ZoneInfoNotFoundError, ValueError):
+            print(
+                f"⚠️  Unknown timezone {name!r}; falling back to Europe/Paris.",
+                file=sys.stderr,
+            )
+    return ZoneInfo("Europe/Paris")
+
+
+def _slug(value):
+    """ASCII-safe filename token: keep word characters, collapse the rest to '-'."""
+    s = re.sub(r"[^\w]+", "-", (value or "").strip(), flags=re.UNICODE)
+    return s.strip("-") or "untitled"
+
+
+def resolve_output_path(args, company, position, captured_date):
+    """Decide the output path. SCRIPT-OWNED naming (DRV/script-owned discipline).
+
+    - If --output-path is provided, respect it (fallback / gallery / back-compat).
+    - Otherwise build `Posting_Brief_<Company>_<Position>_<YYYYMMDD>.md` in
+      --output-dir (default: current folder). The model never hand-composes it.
+    """
+    explicit = getattr(args, "output_path", None)
+    if explicit:
+        return str(explicit)
+    out_dir = getattr(args, "output_dir", None) or "."
+    stamp = captured_date.replace("-", "")
+    name = f"Posting_Brief_{_slug(company)}_{_slug(position)}_{stamp}.md"
+    return str(Path(out_dir) / name)
+
+
+def _is_missing(value):
+    """A critical field is missing if it is empty or the language-neutral sentinel."""
+    return not value or str(value).strip() in ("", MISSING_SENTINEL)
+
+
+def generate_brief_md(labels, data, captured_date):
+    """Generates the complete Markdown content."""
+    t = labels
+    parts = []
+
+    parts.append(f"# {t['title']}\n")
+
+    # === HEADER (at a glance) ===
+    parts.append(f"## {t['s_meta']}\n")
+    recruiter_name = data.get("recruiter_name", "").strip()
+    recruiter_title = data.get("recruiter_title", "").strip()
+    if recruiter_name and recruiter_title:
+        recruiter = f"{recruiter_name}, {recruiter_title}"
+    else:
+        recruiter = recruiter_name or recruiter_title or "—"
+    rows = [
+        (t["l_company"], data.get("company_name", "")),
+        (t["l_position"], data.get("job_title", "")),
+        (t["l_recruiter"], recruiter),
+        (t["l_city"], data.get("city", "").strip() or "—"),
+        (t["l_captured"], captured_date),
+        (t["l_source"], data.get("source_url", "").strip() or "—"),
+        (t["l_language"], data.get("posting_language", "").strip() or "—"),
+    ]
+    for label, value in rows:
+        parts.append(f"- **{label}:** {value}")
+    parts.append("")
+
+    # === DIGEST (model-extracted) ===
+    parts.append(f"## {t['s_digest']}\n")
+    parts.append(f"### {t['sub_requirements']}\n")
+    for req in data.get("requirements", []):
+        parts.append(f"- {req}")
+    parts.append("")
+    parts.append(f"### {t['sub_deadline']}\n")
+    parts.append(f"{data.get('deadline', '').strip() or '—'}\n")
+
+    # === POSTING (verbatim body) ===
+    parts.append(f"## {t['s_posting']}\n")
+    parts.append(data.get("posting_body", ""))
+
+    return "\n".join(parts)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generates a job-posting brief (dossier) in Markdown"
+    )
+    parser.add_argument(
+        "--language",
+        required=True,
+        type=iso639_1,
+        metavar="LANG",
+        help="ISO 639-1 language code (lowercase), e.g. en, fr",
+    )
+    parser.add_argument(
+        "--output-dir",
+        help="Output directory (the filename is built by the script)",
+    )
+    parser.add_argument(
+        "--output-path",
+        help="Explicit output .md path (fallback; hand-composed names discouraged)",
+    )
+    parser.add_argument("--data-json", required=True)
+    parser.add_argument(
+        "--labels-json",
+        required=True,
+        help="JSON object of structure labels in the target language (exact key set required)",
+    )
+    parser.add_argument(
+        "--timezone",
+        default=None,
+        help="IANA timezone for the capture date (e.g. Europe/Paris); safe fallback if unknown",
+    )
+
+    args = parser.parse_args()
+
+    if not args.output_dir and not args.output_path:
+        print("❌ Provide --output-dir (preferred) or --output-path.", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        data = json.loads(args.data_json)
+    except json.JSONDecodeError as e:
+        print(f"❌ Invalid JSON: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        labels = json.loads(args.labels_json)
+    except json.JSONDecodeError as e:
+        print(f"❌ Invalid JSON (labels): {e}", file=sys.stderr)
+        sys.exit(1)
+    if not isinstance(labels, dict) or set(labels) != REQUIRED_LABELS:
+        got = set(labels) if isinstance(labels, dict) else set()
+        print(
+            f"❌ Invalid labels — missing: {sorted(REQUIRED_LABELS - got)}; extra: {sorted(got - REQUIRED_LABELS)}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    required = [
+        "company_name",
+        "job_title",
+        "posting_language",
+        "requirements",
+        "posting_body",
+    ]
+    missing = [f for f in required if f not in data]
+    if missing:
+        print(f"❌ Missing required fields: {missing}", file=sys.stderr)
+        sys.exit(1)
+
+    # Critical fields must be real values — never empty, never the sentinel.
+    # The model asks the user instead of inventing a company / position / body.
+    critical = ["company_name", "job_title", "posting_body"]
+    bad = [f for f in critical if _is_missing(data.get(f))]
+    if bad:
+        print(
+            f"❌ Critical field(s) empty or unresolved ({MISSING_SENTINEL}): {bad}. "
+            "Ask the user — do not invent.",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+
+    tz = resolve_timezone(args.timezone)
+    captured_date = datetime.now(tz).strftime("%Y-%m-%d")
+
+    md_content = generate_brief_md(labels, data, captured_date)
+
+    output_path = Path(
+        resolve_output_path(
+            args, data["company_name"], data["job_title"], captured_date
+        )
+    )
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(md_content, encoding="utf-8")
+
+    print(f"✅ Posting brief (Markdown) generated: {output_path}")
+    print(f"   {output_path}")
+    print(f"   - captured: {captured_date}")
+    print(f"   - {len(data.get('requirements', []))} key requirement(s)")
+    print(f"   - posting body: {len(data.get('posting_body', ''))} chars (verbatim)")
+    print("\n💡 To export to PDF:")
+    print(
+        f"   python md_to_pdf.py --input {output_path} --output {output_path.with_suffix('.pdf')}"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/modules/posting-brief-generator/scripts/md_to_pdf.py b/modules/posting-brief-generator/scripts/md_to_pdf.py
new file mode 100644
index 0000000..7a95033
--- /dev/null
+++ b/modules/posting-brief-generator/scripts/md_to_pdf.py
@@ -0,0 +1,161 @@
+"""
+Converts a posting-brief Markdown file into a styled PDF, applying the
+application documents' visual identity (same palette as the other deliverables).
+
+Usage:
+    python md_to_pdf.py --input <file.md> --output <file.pdf> [--title "Title"]
+
+This is a deliberately lighter converter than the other modules': the posting
+brief has no tips or semantic (+/-) bullets, only headings, a header list and
+the verbatim posting body. No hard-coded rendered label — fully language-neutral.
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+import markdown
+
+# === PALETTE (shared with the other deliverables) ===
+TITLE_COLOR = "#1F4E79"  # Navy blue
+GREY_COLOR = "#595959"  # Slate grey
+
+
+def build_css():
+    """Generates the visual-identity CSS (subset shared with the other PDFs)."""
+    return f"""
+    @page {{
+        size: A4;
+        margin: 2cm 2.2cm;
+    }}
+    body {{
+        font-family: 'Aptos', 'Segoe UI', 'Calibri', 'Helvetica Neue', Arial, sans-serif;
+        font-size: 11pt;
+        line-height: 1.5;
+        color: #1a1a1a;
+    }}
+    h1 {{
+        color: {TITLE_COLOR};
+        font-size: 21pt;
+        font-weight: bold;
+        margin-bottom: 4px;
+        margin-top: 0;
+    }}
+    h2 {{
+        color: {TITLE_COLOR};
+        font-size: 15pt;
+        font-weight: bold;
+        margin-top: 22px;
+        margin-bottom: 8px;
+        border-bottom: 1px solid #d9e1ec;
+        padding-bottom: 3px;
+    }}
+    h3 {{
+        font-size: 12.5pt;
+        font-weight: bold;
+        margin-top: 14px;
+        margin-bottom: 6px;
+    }}
+    p {{
+        margin: 6px 0;
+        text-align: justify;
+    }}
+    ul, ol {{
+        margin: 6px 0;
+        padding-left: 22px;
+    }}
+    li {{
+        margin: 4px 0;
+        text-align: justify;
+    }}
+    strong {{ font-weight: bold; }}
+    em {{ font-style: italic; }}
+    blockquote {{
+        border-left: 3px solid #d9e1ec;
+        margin: 8px 0;
+        padding-left: 12px;
+        color: {GREY_COLOR};
+    }}
+    code {{
+        background-color: #f4f4f4;
+        padding: 1px 4px;
+        border-radius: 3px;
+        font-family: 'Consolas', 'Courier New', monospace;
+        font-size: 10pt;
+    }}
+    """
+
+
+def convert(input_path, output_path, title=None):
+    """Converts the Markdown into a styled PDF."""
+    input_path = Path(input_path)
+    if not input_path.exists():
+        print(f"❌ File not found: {input_path}", file=sys.stderr)
+        sys.exit(1)
+
+    md_text = input_path.read_text(encoding="utf-8")
+    html_body = markdown.markdown(md_text, extensions=["extra", "sane_lists", "nl2br"])
+
+    doc_title = title or input_path.stem
+    full_html = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>{doc_title}</title>
+<style>{build_css()}</style>
+</head>
+<body>
+{html_body}
+</body>
+</html>"""
+
+    html_tmp = input_path.with_suffix(".tmp.html")
+    html_tmp.write_text(full_html, encoding="utf-8")
+
+    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+    result = subprocess.run(
+        [
+            "wkhtmltopdf",
+            "--quiet",
+            "--encoding",
+            "utf-8",
+            "--enable-local-file-access",
+            "--margin-top",
+            "18mm",
+            "--margin-bottom",
+            "16mm",
+            "--margin-left",
+            "0",
+            "--margin-right",
+            "0",
+            str(html_tmp),
+            str(output_path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+
+    html_tmp.unlink(missing_ok=True)
+
+    if result.returncode != 0:
+        print(f"❌ wkhtmltopdf error: {result.stderr}", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"✅ PDF generated: {output_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Converts a posting-brief Markdown file into a styled PDF"
+    )
+    parser.add_argument("--input", required=True, help="Source .md file")
+    parser.add_argument("--output", required=True, help="Output .pdf file")
+    parser.add_argument("--title", default=None, help="Document title (metadata)")
+    args = parser.parse_args()
+
+    convert(args.input, args.output, args.title)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/references/assistant_flow.md b/references/assistant_flow.md
index 27ff436..0fbd345 100644
--- a/references/assistant_flow.md
+++ b/references/assistant_flow.md
@@ -37,6 +37,12 @@ Open-ended request
 | quick_reference | quick-reference-generator | condenses the others → second to last |
 | add_to_tracker | application-tracker | always last |
 
+> **Out-of-widget id — `posting_brief`.** The posting brief (`posting-brief-generator`) is
+> produced **automatically at intake**, not through the widget and not as a slot in the order
+> above: the orchestrator generates it **first** (before `strategic_playbook`), from the offer
+> already read in the single global analysis. Its id `posting_brief` is recorded in the tracker
+> `deliverables` like any other deliverable. See SKILL STEP 4 and the module `GUIDE.md`.
+
 ## Enforced generation order
 
 `strategic_playbook → application_summary → interview_prep → cover_letter →
diff --git a/tests/test_examples.py b/tests/test_examples.py
index 5b9010b..4760942 100644
--- a/tests/test_examples.py
+++ b/tests/test_examples.py
@@ -84,10 +84,10 @@ def test_unsigned_lorem_letter_has_no_signature(tmp_path):
 @pytest.mark.needs_libreoffice
 def test_build_all_produces_full_gallery(tmp_path):
     names = {p.name for p in BS.build_all(tmp_path)}
-    assert len(names) == 16
+    assert len(names) == 18
     assert sum(n.endswith(".docx") for n in names) == 2  # signed + unsigned
-    assert sum(n.endswith(".pdf") for n in names) == 6  # 2 letters + 4 generators
-    assert sum(n.endswith(".md") for n in names) == 4
+    assert sum(n.endswith(".pdf") for n in names) == 7  # 2 letters + 5 generators
+    assert sum(n.endswith(".md") for n in names) == 5  # posting brief + 4 others
     assert sum(n.endswith(".html") for n in names) == 4
 
 
diff --git a/tests/test_posting_brief.py b/tests/test_posting_brief.py
new file mode 100644
index 0000000..6ab030b
--- /dev/null
+++ b/tests/test_posting_brief.py
@@ -0,0 +1,209 @@
+"""Tier 1 — posting-brief generator (PB-1).
+
+Functional guarantees under test: the generator enforces its contract before
+producing anything (exact interface label set, ISO-639-1 language *form*,
+required content fields), refuses an empty/sentinel critical field (exit 2,
+the model must ask not invent), and OWNS its filename — given --output-dir it
+builds `Posting_Brief_<Company>_<Position>_<YYYYMMDD>.md` and prints the path.
+The capture timezone resolves to a safe fallback rather than crashing.
+"""
+
+import argparse
+import json
+
+import pytest
+
+from _helpers import load_module, run_cli
+
+REL = "modules/posting-brief-generator/scripts/generate_posting_brief.py"
+
+
+def _valid_labels():
+    """A complete label set with dummy values, derived from the script itself."""
+    return {k: k for k in load_module(REL).REQUIRED_LABELS}
+
+
+def _valid_data(**overrides):
+    d = {
+        "company_name": "Acme Financial Group",
+        "job_title": "Head of Engineering",
+        "posting_language": "English",
+        "requirements": ["10+ years leadership", "Payments modernization"],
+        "posting_body": "Acme is hiring a Head of Engineering. Apply by 30 June 2026.",
+    }
+    d.update(overrides)
+    return d
+
+
+# --- language form validation (pure helper, imported) ---------------------- #
+
+
+@pytest.mark.parametrize("code", ["en", "fr", "de", "ja"])
+def test_validate_language_accepts_iso_form(code):
+    assert load_module(REL).iso639_1(code) == code
+
+
+@pytest.mark.parametrize("bad", ["EN", "e", "eng", "f1", "", "en-US"])
+def test_validate_language_rejects_non_iso_form(bad):
+    with pytest.raises((ValueError, argparse.ArgumentTypeError)):
+        load_module(REL).iso639_1(bad)
+
+
+# --- timezone resolution (pure helper) ------------------------------------- #
+
+
+def test_resolve_timezone_valid_and_safe_fallback():
+    m = load_module(REL)
+    assert m.resolve_timezone("Europe/Paris").key == "Europe/Paris"
+    # empty / None / invalid never raise — they fall back, so name generation
+    # is never the reason the brief fails (same floor as the tracker, 0.17.0).
+    assert m.resolve_timezone("").key == "Europe/Paris"
+    assert m.resolve_timezone(None).key == "Europe/Paris"
+    assert m.resolve_timezone("Nope/Nowhere").key == "Europe/Paris"
+
+
+# --- label-set + required-field contract (subprocess) ---------------------- #
+
+
+def test_missing_label_key_is_rejected(tmp_path):
+    keys = list(load_module(REL).REQUIRED_LABELS)
+    labels = {k: k for k in keys[1:]}  # drop one
+    proc = run_cli(
+        REL,
+        "--language",
+        "en",
+        "--output-dir",
+        str(tmp_path),
+        "--data-json",
+        "{}",
+        "--labels-json",
+        json.dumps(labels),
+    )
+    assert proc.returncode != 0
+
+
+def test_extra_label_key_is_rejected(tmp_path):
+    labels = _valid_labels()
+    labels["__bogus_key__"] = "x"
+    proc = run_cli(
+        REL,
+        "--language",
+        "en",
+        "--output-dir",
+        str(tmp_path),
+        "--data-json",
+        "{}",
+        "--labels-json",
+        json.dumps(labels),
+    )
+    assert proc.returncode != 0
+
+
+def test_missing_required_data_is_rejected(tmp_path):
+    proc = run_cli(
+        REL,
+        "--language",
+        "en",
+        "--output-dir",
+        str(tmp_path),
+        "--data-json",
+        "{}",
+        "--labels-json",
+        json.dumps(_valid_labels()),
+    )
+    assert proc.returncode != 0  # complete label set, but no content fields
+
+
+def test_invalid_language_form_is_rejected_by_cli(tmp_path):
+    proc = run_cli(
+        REL,
+        "--language",
+        "EN",
+        "--output-dir",
+        str(tmp_path),
+        "--data-json",
+        "{}",
+        "--labels-json",
+        json.dumps(_valid_labels()),
+    )
+    assert proc.returncode == 2  # argparse type-validation error
+
+
+def test_requires_an_output_target():
+    proc = run_cli(
+        REL,
+        "--language",
+        "en",
+        "--data-json",
+        json.dumps(_valid_data()),
+        "--labels-json",
+        json.dumps(_valid_labels()),
+    )
+    assert proc.returncode != 0  # neither --output-dir nor --output-path
+
+
+# --- critical-field sentinel (LNG-2 S3b contract) -------------------------- #
+
+
+@pytest.mark.parametrize("field", ["company_name", "job_title", "posting_body"])
+@pytest.mark.parametrize("bad", ["__MISSING__", ""])
+def test_critical_field_empty_or_sentinel_is_rejected(field, bad, tmp_path):
+    proc = run_cli(
+        REL,
+        "--language",
+        "en",
+        "--output-dir",
+        str(tmp_path),
+        "--data-json",
+        json.dumps(_valid_data(**{field: bad})),
+        "--labels-json",
+        json.dumps(_valid_labels()),
+    )
+    assert proc.returncode == 2  # ask the user, never invent
+    assert not list(tmp_path.glob("*.md"))  # nothing written
+
+
+# --- script-owned filename (DRV / script-owned discipline) ----------------- #
+
+
+def test_script_owned_filename_and_printed_path(tmp_path):
+    proc = run_cli(
+        REL,
+        "--language",
+        "en",
+        "--output-dir",
+        str(tmp_path),
+        "--data-json",
+        json.dumps(_valid_data()),
+        "--labels-json",
+        json.dumps(_valid_labels()),
+    )
+    assert proc.returncode == 0, proc.stderr
+
+    files = list(tmp_path.glob("Posting_Brief_*.md"))
+    assert len(files) == 1  # the script named it itself
+    name = files[0].name
+    assert "Acme" in name and "Head" in name  # company + position slugged in
+    assert name.endswith(".md")
+    assert files[0].name in proc.stdout  # path printed for present_files
+
+    text = files[0].read_text(encoding="utf-8")
+    assert "Acme Financial Group" in text  # header
+    assert "Apply by 30 June 2026" in text  # verbatim body preserved
+
+
+def test_output_path_fallback_is_honored(tmp_path):
+    out = tmp_path / "explicit.md"
+    proc = run_cli(
+        REL,
+        "--language",
+        "en",
+        "--output-path",
+        str(out),
+        "--data-json",
+        json.dumps(_valid_data()),
+        "--labels-json",
+        json.dumps(_valid_labels()),
+    )
+    assert proc.returncode == 0, proc.stderr
+    assert out.exists()  # explicit path respected (gallery / back-compat)
diff --git a/tooling/build_samples.py b/tooling/build_samples.py
index 93df3f3..7090d75 100644
--- a/tooling/build_samples.py
+++ b/tooling/build_samples.py
@@ -236,6 +236,50 @@ def wrap_html(fragment, title):
 }
 
 _GENERATORS = {
+    "00_posting_brief": {
+        "module": "posting-brief-generator",
+        "labels": {
+            "title": "Job Posting Brief",
+            "s_meta": "At a glance",
+            "l_company": "Company",
+            "l_position": "Position",
+            "l_recruiter": "Recruiter",
+            "l_city": "City",
+            "l_captured": "Captured",
+            "l_source": "Source",
+            "l_language": "Language",
+            "s_digest": "Digest",
+            "sub_requirements": "Key requirements",
+            "sub_deadline": "Application deadline",
+            "s_posting": "Job posting",
+        },
+        "data": {
+            "company_name": "Acme Financial Group",
+            "job_title": "Head of Engineering",
+            "posting_language": "English",
+            "recruiter_name": "Jane Smith",
+            "recruiter_title": "Head of Talent",
+            "city": "Paris",
+            "source_url": "https://careers.example.com/head-of-engineering",
+            "requirements": [
+                "10+ years leading engineering organizations at scale",
+                "Proven payments / fintech platform modernization",
+                "Fluent French and English",
+            ],
+            "deadline": "30 June 2026",
+            "posting_body": (
+                "Acme Financial Group is hiring a Head of Engineering to lead the "
+                "modernization of its European payments platform.\n\n"
+                "You will own the platform roadmap, lead ~150 engineers across "
+                "product squads, and partner with Product and Risk to deliver "
+                "reliable, scalable payment flows.\n\n"
+                "Requirements: 10+ years leading engineering organizations at "
+                "scale; a track record of payments or fintech platform "
+                "modernization; fluency in French and English.\n\n"
+                "Location: Paris. Applications close on 30 June 2026."
+            ),
+        },
+    },
     "03_application_summary": {
         "module": "application-summary-generator",
         "labels": {