dl-memo-prescreen

star 0

Builds the multi-slide IC Pre-Screen Memo (.pptx) for Pre-Screen IC (P7) by populating the bundled deck template from the deal's upstream artifacts — the populated Databook, Overland Model, databook narrative, DD-list returns, posting memo, and posting-IC debrief. Use when a deal is heading to Pre-Screen IC and the user asks to "build the pre-screen memo," "populate the IC deck," "draft the IC memo," or to build or update a specific memo section or slide range. Two-turn workflow: scans the deck and confirms scope with the user (Turn 1), then executes a preservation-gated build (Turn 2). Runs in the Claude PowerPoint Add-in (active deck) and Claude Desktop (uploaded or cloned template). Internal-only RESTRICTED deliverable.

jaminator By jaminator schedule Updated 6/10/2026
play_arrow Run Skill in Manus View GitHub

name: dl-memo-prescreen description: > Builds the multi-slide IC Pre-Screen Memo (.pptx) for Pre-Screen IC (P7) by populating the bundled deck template from the deal's upstream artifacts — the populated Databook, Overland Model, databook narrative, DD-list returns, posting memo, and posting-IC debrief. Use when a deal is heading to Pre-Screen IC and the user asks to "build the pre-screen memo," "populate the IC deck," "draft the IC memo," or to build or update a specific memo section or slide range. Two-turn workflow: scans the deck and confirms scope with the user (Turn 1), then executes a preservation-gated build (Turn 2). Runs in the Claude PowerPoint Add-in (active deck) and Claude Desktop (uploaded or cloned template). Internal-only RESTRICTED deliverable.

dl-memo-prescreen — Iterative IC Pre-Screen Memo (.pptx)

When to use

Use this skill when a deal is ready for Pre-Screen IC (P7) and at least some subset of the upstream Stage-3 artifacts is available: the populated vS Databook, the chart-restored Databook (optional), per-KPI tabs (optional), the populated vS Overland Model, the databook narrative markdown + JSON, the posting-IC debrief punchlist (RESTRICTED — read here), the outbound DD list + returns, and the final posting memo vF.

The skill composes that upstream chain into a populated multi-slide deck. Use it iteratively across multiple sittings: build Sections 4 + 5 when the workbooks land; build Sections 1 + 7 when the debrief + management materials follow; build Section 3 last when the risk/highlights synthesis is settled.

Do not use this skill to:

  • rebuild any upstream workbook (the analytical workbook skills run first);
  • draft the term sheet (use dl-termsheet — this skill records the indicative deal-terms bucket in its structured output, which the term sheet skill consumes);
  • redact the memo for external distribution (the memo is internal-only RESTRICTED; no outbound version exists).

What the skill produces

  • [Company]_IC_PreScreen_Memo_vS.pptx — the populated .pptx, in place (PowerPoint Add-in mode) or as a deal-named copy cloned from the bundled template (Claude Desktop mode). Every slide outside the build scope is identical to the input deck; slide 1 (the bundled IC Summary scorecard) is identical to the bundled template.
  • [Company]_IC_PreScreen_Memo_vS_MemoPrescreenBuild.json — the build manifest: per-section build state, per-slide build records, the basis-citation audit roster, the data-gaps union, and the indicative-deal-terms block (when Section 1 is in scope).

Global rules

These govern every step below.

  • RESTRICTED, MNPI, internal-only. The memo reads the RESTRICTED IC debrief punchlist and emits RESTRICTED content (IC Feedback Request, per-focus-area diligence findings). Never outbound; no external version.
  • Never fabricate. Every quantitative figure ($ / % / period) in a slide body cites a verifiable basis (a workbook cell, manifest field, memo passage, or verbatim commentary excerpt). A claim that cannot be traced refuses with [INSUFFICIENT DATA — memo claim basis untraceable]. [INSUFFICIENT DATA — <what is missing>] is the only uncertainty marker.
  • Catalog-shaped sections only. The memo has seven sections (the catalog in reference/memo-sections.md). Never invent an eighth section — a bespoke shape escalates instead.
  • Iterative-only. One scope (slide range, section, or full memo) per call. "Build the whole memo, but only the IC Feedback slide for now" is declined — pick one scope mode + target per call.
  • Tone discipline. Bottom-line-on-top, bulletized, assertive-no-qualifier voice with strawman risk framing (reference/memo-tone.md). A forbidden hedge token ("per mgmt.", "in the deal team's view", "likely" / "may" / "could" as a hedge) outside the strawman / commentary carve-outs refuses the build.
  • Upstream is read-only. This skill never modifies an upstream skill's output, script, or contract, and never writes back to the bundled assets/ template.

Reference files (one level deep; load as needed):

  • reference/memo-sections.md — the canonical seven-section catalog: per-section purpose, slide-range defaults, required upstream inputs, content discipline, worked-example references, and the bespoke-shape escalation triggers. Read before Step 4.
  • reference/memo-tone.md — the IC Pre-Screen voice and strawman risk-framing discipline, with worked good/bad rewrites.
  • reference/build-mechanics.md — the construction algorithm: python-pptx mechanics, scope-mode resolution, the hidden _MemoBuild manifest slide, the preservation gate, the normalize-then-compare baseline, re-run idempotence. Read before Step 5.

Dependencies

Install required package: pip install python-pptx

Workflow

Two turns. Copy this checklist and check items off as you go:

IC Pre-Screen Memo build progress:
- [ ] Step 0: Orient (deliverable, RESTRICTED classification, draft signal, no outbound version)
- [ ] Step 1: Resolve the deck_path (active / uploaded / cloned template)
- [ ] Step 2: Scan the deck (scripts/scan_memo.py) — per-section state
- [ ] Step 3 (Turn 1): Surface state + recommend scope; await confirmation
- [ ] Step 4 (Turn 2): Construct build_plan.json from upstream artifacts
- [ ] Step 5: Execute the build (scripts/build_memo.py) — preservation gate
- [ ] Step 6: Emit the build manifest + summarize to user

Step 0 — Orientation

Re-read the Global rules above. The deliverable is the populated .pptx + the build manifest JSON — not a regenerated workbook, not a summary markdown. Confirm the scope inputs you will need at Turn 1: the deck path, the available upstream artifact paths, and the user's scope_mode (slide_range — "rebuild slides 23-27"; section — "rebuild Investment Highlights & Risks"; or full_memo) + scope_target. The project's deal-context slot supplies COMPANY, SPONSOR, INDICATIVE STRUCTURE (for the indicative-deal-terms block), SHAREPOINT DEAL FOLDER, and the ACTIVE DOCUMENT INDEX fallback.

Step 1 — Resolve the deck_path

PowerPoint Add-in mode (active-deck): the Add-in supplies the active deck's path; use it directly.

Claude Desktop mode (uploaded or cloned):

  • If the user uploaded a [Company]_IC_PreScreen_Memo_vS.pptx, use that path.
  • Else, clone assets/ic-memo-template.pptx to [Company]_IC_PreScreen_Memo_vS.pptx (the bundled template is cloned, never written back to).

The bundled assets/ic-memo-template.pptx is the style donor: slide layouts, theme, fonts, table styles, AND the IC Summary scorecard at slide 1 are copied from it. Slide 1 stays unchanged against the bundled template — an explicit preservation-gate invariant.

Step 2 — Scan the deck (existing-section dedup)

python scripts/scan_memo.py <deck_path> --out memo_inventory.json

Reads the deck via python-pptx, classifies every slide into one of the seven sections via the title-regex catalog, locates the hidden _MemoBuild manifest slide (if present), and emits memo_inventory.json carrying:

  • per-section state (built / partial / absent / escalated);
  • the slide range from title-parse + the manifest's declared range (mismatch ⇒ manifest_state = "drifted");
  • the scorecard's presence at slide 1;
  • the unclassified slides (titles that match no section regex).

A manifest_state = "drifted" finding surfaces to the user — the user chooses to (a) trust title-parse, (b) trust the manifest, or (c) abort and inspect manually.

Step 3 — Turn 1: surface state + recommend scope

Surface to the user:

  • The current state of each of the seven sections (with slide range for built / partial sections).
  • The available upstream artifacts (Databook? Model? Narrative? Posting memo? IC debrief? DD list returns?). Look in the project files, the chat uploads, then the Microsoft 365 connector; missing required artifacts for a proposed scope ⇒ surface [INSUFFICIENT DATA — <required upstream> not available for <section_id>]. Never treat a connector error as a found artifact.
  • The proposed scope — ask: "Would you like me to draft or update a selected slide range, a memo section, or the entire memo?" Surface up to three concrete recommendations, each with rationale, e.g.:
    • "Section 3 — Investment Highlights & Risks — narrative consideration/critical items + DD list returns present; recommended next."
    • "Sections 4 + 5 — Financial Summary + Projection Models — the Databook + Overland Model are populated; build the quantitative spine."
    • "Full memo — every upstream is present; single atomic build."

Wait for user confirmation before any build.

Step 4 — Turn 2: construct the build_plan

Once the user confirms a scope (scope_mode + scope_target), construct build_plan.json from:

  • Upstream manifest projections — each upstream skill emits a JSON manifest the build plan reads: Databook financials (historical IS rows, EBITDA bridge, NWC quarterly, seasonality); Overland Model (case drivers for the three cases, scenario outputs, debt outstanding, valuation EBITDA); databook narrative (narrative items, data gaps, commentary sources, basis records); posting-IC debrief (final rating, what was discussed, initial DD seed focus areas); Initial DD list (returns, outstanding items).
  • Posting memo Sections 1–3 / 9 text — read from the .docx (project files → chat uploads → Microsoft 365 connector).
  • Per-slide content payloads — derived from the seven-section catalog per the chosen scope. Each slide carries kind + layout + title + body items + (for risk slides) the strawman block.
  • Basis records — the deduplicated audit roster. Every quantitative claim emitted into a slide body resolves to a basis citation in this list.
  • Data gaps — the union of upstream escalations / insufficiency markers across the consumed artifacts. Never silently drop one.
  • Indicative deal terms — populated when Section 1 (Executive Summary) is in scope; carries the Transaction Overview S&U + Pro Forma Cap + Draft Indicative Terms fields consumed by dl-termsheet at P8.

Step 5 — Execute the build (the preservation gate)

python scripts/build_memo.py <deck_path> --plan build_plan.json \
    --template assets/ic-memo-template.pptx --out <deck_path>

The build path:

  • Creates the normalize-then-compare baseline by re-saving the input deck untouched through python-pptx.
  • Resolves the scope (reference/build-mechanics.md §2).
  • Adds slides using layouts from the bundled template; never modifies pre-existing slides (the add-only invariant).
  • Renders each slide's body items: paragraph / bullet list → text frame; table → native table; chart → native PPT chart shapes (image-embed fallback recorded as a contingency).
  • Writes per-slide basis-citation references into the build manifest.
  • For risk slides, verifies the strawman structure inline: the strawman phrasing stem, the one-sentence consequence bridge, ≥ 2 named ordered mitigants with basis citations.
  • Tone-pass: scans every slide body for forbidden hedge tokens; a hedge outside the strawman / commentary carve-outs refuses the build.
  • Updates the hidden _MemoBuild manifest slide (creates if absent).
  • Runs the machine-verified preservation gate in memory before any file is written. The gate's six checks: every out-of-scope slide unchanged against the baseline; every quantitative claim carries a verifiable basis citation; every risk slide carries the three-part strawman structure; every built section carries the catalog's required slides; the scorecard slide is identical to the bundled template; the _MemoBuild manifest records the new per-section state truthfully.
  • Writes the deal-named vS copy on PASS; refuses with no output on any violation. The input deck is unchanged on refusal.

Step 6 — Structured output + summarize to user

The build manifest is the skill's structured output; the build script consumes only the documented manifest projection. Internal capture fields (classification, review state, escalations) are recorded on the manifest but never reach external consumers. The output is always pending human review; the skill never approves or finalizes.

Summarize to the user: per-section state transitions (e.g., executive_summary: absent → built); basis-record count + data-gap count; whether the indicative-deal-terms block was populated; preservation-gate status (all checks pass = file written; any check fails = no file written).

Iterative re-runs

A second invocation with the same scope_mode + scope_target + input signature returns scope_already_built (idempotence). To force a re-build, pass --rebuild to build_memo.py. Surface the scope_already_built refusal to the user before invoking the script.

Escalation

Halt with a named reason and no output (recorded on the manifest) when:

  • a catalog-shaped section needs a bespoke shape (per-section escalation triggers in reference/memo-sections.md);
  • a quantitative claim cannot trace to a verifiable basis;
  • a risk slide's strawman structure cannot be assembled with ≥ 2 named ordered mitigants;
  • a required upstream artifact is absent for the chosen scope;
  • the manifest is drifted and the user has not chosen a reconciliation path;
  • a slide_range scope spans 3+ sections;
  • a forbidden hedge token appears outside the carve-outs;
  • any preservation-gate check fails on the in-memory pre-write pass.

Never auto-decide a bespoke shape; never fabricate a basis; never write a file when any gate check fails.

Degrees of freedom

  • Low (scripted): scope resolution, layout selection, the preservation gate, the tone-pass regex, the baseline. Deterministic.
  • Medium (judgment): each slide's content body (synthesis from upstream basis facts + posting memo prose + IC debrief); strawman risk phrasing; mitigant ordering; severity classification on consumed narrative items; the indicative-deal-terms field population.
  • High (escalate): any non-catalog section shape, tone violation, basis-less claim, or missing required upstream — refer to an analyst.

Classification & review state

The Pre-Screen memo is RESTRICTED, MNPI, internal deal-team only — never forwarded to a co-lender, LP, or any external party. The output is a draft pending human review: the draft signal is the vS filename suffix plus the pending-review flag on the build manifest — no [DRAFT — HUMAN REVIEW REQUIRED] banner in any slide body, because the deck is an in-place-edited production template and a banner would corrupt the IC-distributed PDF. A deal-team reviewer approves; never approve, finalize, or distribute. Use [INSUFFICIENT DATA — <what is missing>] for any gap — never fabricate.

Runtime

The scan and build scripts run where Python is available: Claude Desktop or claude.ai with code execution enabled. In the PowerPoint Add-in, the skill has a documented active-deck path — the add-in supplies the open deck's path and the same two-turn workflow applies to it. When the SharePoint deal folder is scanned for upstream artifacts, use the Microsoft 365 connector with fully-qualified Server:tool names; confirm the server name at first invocation, and degrade to the project's document index when the connector is unavailable. Scope discussion and section drafting review work anywhere.

Install via CLI
npx skills add https://github.com/jaminator/DL-Skills-Library --skill dl-memo-prescreen
Repository Details
star Stars 0
call_split Forks 0
navigation Branch main
article Path SKILL.md
More from Creator
jaminator
jaminator Explore all skills →