Rfp Assemble

RFP Assemble

Take the reviewed, gate-passed responses from rfp-review and produce a branded, buyer-format submission package, a cover letter, and an analytics report — with full provenance embedded so every answer traces back to a KB source or a generated+reviewed record.

1. When to Use

Use rfp-assemble after rfp-review has signed off every response and rfp-gates has marked all three mandatory gates (Security Completeness, Legal Review, Pricing Approval) as Approved. Typical phrasings: "assemble the RFP response", "build the submission package", "finalize the RFP", "create the analytics report for exec review", "produce the buyer-format deliverable", "assemble the bid".

Do NOT use for…

Parsing / classifying incoming RFP → rfp-intake. Bid / no-bid decision → rfp-fit-assessment. Drafting individual responses → rfp-respond. Running the three quality gates → rfp-gates. Human review of flagged items → rfp-review. Adding corrections to the knowledge base → rfp-answer-bank. Raw file rendering from a manifest → built-in docx / xlsx / pdf.

If any gate is not Approved, or any response is still flagged for review, stop and hand control back to rfp-gates or rfp-review. This skill never assembles unapproved content.

2. Inputs and Outputs

Required inputs

Produced outputs

3. Workflow Overview

  Reviewed + Gate + Corrections + Metadata
                    |
                    v
          assemble_document.py  (emits manifest JSON)
                    |
      +-------------+-------------+
      v             v             v
   docx skill    xlsx skill    pdf skill
      +-------------+-------------+
                    |
                    v
        generate_analytics_report.py
                    |
                    v
           package_submission.py
                    |
                    v
              render-ui dashboard

4. Step-by-Step Procedure

Step 1. Pre-flight checks

Verify: every question has a reviewed response; all three gates show status: Approved; no response is pending or flagged; required_format is known; branding tokens are present. On failure, emit a structured error record and halt — never attempt partial assembly.

Step 2. Choose deliverable format

See references/deliverable-formats.md. Short version: Word template → word; Excel questionnaire → excel; read-only / signed submission → pdf; Ariba / Coupa / Jaggaer portal → portal (CSV / JSON / XML); no template → word (default).

Step 3. Build the manifest

python scripts/assemble_document.py \
  --responses working/reviewed_responses.json \
  --format <word|excel|pdf|portal> \
  --template <template_path> \
  --output working/assembled_manifest.json

The manifest describes sections, ordering, content blocks, style hints, cover letter path, and the provenance appendix. It does not write Word / Excel / PDF bytes — those come from the built-in skills.

Step 4. Render the submission file

Invoke the appropriate built-in skill against assembled_manifest.json: Word narrative → docx; Excel questionnaire → xlsx; flattened PDF → pdf (or Word → PDF); portal CSV / JSON / XML → direct stdlib write.

Step 5. Populate cover letter

Read assets/cover-letter-template.md, substitute placeholders from RFP metadata, then render via the pdf skill to working/cover_letter.pdf.

Step 6. Generate analytics report

python scripts/generate_analytics_report.py \
  --responses working/reviewed_responses.json \
  --gate-audit working/gate_audit.json \
  --corrections working/corrections.json \
  --metadata working/rfp_metadata.json \
  --output working/analytics_report.json

Then render via docx (read-only report) or pptx (exec deck) using the structure in references/analytics-report-template.md.

Step 7. Package the submission

python scripts/package_submission.py \
  --assembled working/assembled.docx \
  --cover-letter working/cover_letter.pdf \
  --analytics working/analytics_report.docx \
  --attachments working/attachments/*.pdf \
  --output output/submission_package.zip

Step 8. Delivery gate

After packaging, the skill caller must run Glob output/submission_package.zip to confirm the artefact exists. Never tell the user "done" unless the file is present on disk.

Step 9. Final dashboard

Call mcp__core__render_ui with submission status (ready yes/no), package checksum and size, links to all artefacts, and a summary of match rate, gate outcomes, and SME hours saved.

5. Deliverable Format Summary

See references/deliverable-formats.md. Key rules: Word — Cover letter → Exec summary → Company overview → Technical → Security → Commercial → Appendices → Provenance appendix. Excel — one sheet per category, one row per question, provenance as extra columns. PDF — same ordering as Word, flattened, locked, signed footer. Portal CSV — columns per buyer spec (Ariba / Coupa / Jaggaer), provenance metadata sidecar file.

6. Branding

See references/branding-guide.md. Branding tokens live in a JSON file supplied by the organisation. The skill never hard-codes colours or fonts. Tokens cover typography (heading scale, body font), colour palette (heading accent, table banding, chart colours), logo (cover, header, footer), and footer text (legal name, registration, confidentiality marker). Applied consistently across cover letter, submission file, and analytics report.

7. Analytics Report

See references/analytics-report-template.md. Sections: exec summary, match rate breakdown (HIGH / MEDIUM / LOW), confidence donut, gate outcomes, effort metrics (SME hours saved), learning-loop stats, provenance audit, trend comparison vs prior RFPs. All arithmetic lives in scripts/generate_analytics_report.py — never rely on the LM for numeric aggregation.

8. Provenance

See references/provenance-tracking.md. Every assembled response carries: response_id, question_id, source (bank_entry:KB-0925 or generated+reviewed), tier (HIGH / MEDIUM / LOW), reviewer, review_status, last_updated (ISO-8601).

Embedding per format: Word — appendix + Word comments on tricky answers; Excel — extra columns per row; PDF — flattened appendix; Portal CSV — side-car manifest.json with the ZIP.

Audit requirement: provenance appendix row count must equal the total question count. assemble_document.py fails the build if they disagree.

9. Troubleshooting

10. Built-In Skills Used

11. Audit Log

Every step of assembly writes a structured event to output/rfp-<rfp_id>/audit-log.xlsx. The audit log is itself included as an artefact inside the final record set (see section 12).

Events are appended via the shared helper: audit-log-schema.md (full schema) and append_audit.py (append helper). The audit log is included as an artefact IN the record set (artefact #10) — a single zip contains both the submission and the full trace of how it was built.

12. Record Set

The output of rfp-assemble is not a single document — it is a RECORD SET: a cohesive, inspectable, durable collection of every artefact produced during the RFP lifecycle. This is what makes the swarm auditable end-to-end.

Manifest of artefacts

Record set composition (ASCII diagram)

            output/rfp-<rfp_id>/  (zipped on packaging)
 +-----------------------------------------------------------+
 |  INPUT PROVENANCE            AUTOMATED PIPELINE OUTPUT    |
 |  [1] original-rfp.*          [4] drafted-responses.xlsx   |
 |  [2] question-bank.xlsx      [5] gate-audit.xlsx          |
 |  [3] fit-memo.docx           [6] corrections-log.xlsx     |
 |                                                           |
 |  ASSEMBLE (this skill) OUTPUT                             |
 |  [7] submission.(docx|xlsx|pdf|csv)                       |
 |  [8] cover-letter.pdf                                     |
 |  [9] analytics-report.(docx|pptx)                         |
 |                                                           |
 |  SHARED / INDEX                                           |
 |  [10] audit-log.xlsx                                      |
 |  [11] manifest.json   <-- index of 1..10                  |
 +-----------------------------------------------------------+
                       |
                       v
       record-set-<rfp_id>.zip   (sha256 recorded in manifest)

Properties of the record set

• Storage: all artefacts live in output/rfp-<rfp_id>/ and are zipped into record-set-<rfp_id>.zip.
• Integrity: every artefact is sha256-hashed; manifest.json records hash, size, author, created_at.
• Retention: durable record of the RFP's entire lifecycle — kept for the buyer's required retention period (typically 7 years commercial, longer for public-sector).
• Inspectability: any stakeholder can trace any answer back to its KB source, reviewer, approver, and timestamp without re-running the pipeline.
• Self-contained: includes both the submission and the audit log that explains how every byte in the submission was produced.

13. Adaptive Card Dashboard

Assembly is surfaced to the user through a sequence of Adaptive Cards rendered via the Cowork Adaptive Cards built-in.

The "Submit to buyer portal" CTA does not trigger an automated upload — the human deal lead performs the actual submission; the card merely deep-links to the zip and to the buyer portal URL.

14. Related Skills

RFP chain

rfp-intake -> rfp-fit-assessment -> rfp-respond -> rfp-gates
          -> rfp-review -> THIS SKILL -> [human submits]

This skill is the terminal step of the automated pipeline. It consumes artefacts from every upstream skill and packages them as the record set. A human performs the actual submission to the buyer portal — the swarm never submits on behalf of the organisation.

Cowork built-ins leveraged

See section 10 for the full mapping: Word, Excel, PDF, PowerPoint, Adaptive Cards, Email, Communications, Deep Research, and Enterprise Search are all invoked by this skill during assembly, packaging, and stakeholder notification.

Cross-links

Deliverable formats references/deliverable-formats.md · Branding references/branding-guide.md · Analytics references/analytics-report-template.md · Provenance references/provenance-tracking.md · Cover letter assets/cover-letter-template.md · Disclaimer assets/disclaimer-footer.md

Design note: this skill treats the final deliverable as a traceable, auditable record set — not just a document. Every byte either traces to a KB source or to a logged generated+reviewed decision. That is the contract this skill holds with the wider RFP Agent Swarm.