## Asset Header

- **Asset ID:** MePB-BMF-QuickAIPublishing-v10
- **Version:** v10
- **Status:** Draft
- **Owner:** Victor Heredia
- **IntellBank:** IB-XX-Maestro
- **Tipo:** MePB — MetaPlaybook
- **Propósito:** Mpb-qpmfp-team — Quick Ai Publishing Meta Factory Playbook (team Edition) — V1
- **Última actualización:** 2026-04-11

---

# Mpb-qpmfp-team — Quick Ai Publishing Meta Factory Playbook (team Edition) — V1

Chat original: [https://chatgpt.com/g/g-p-6956a7038c1c8191b36acb079d060c81-personal-dna-and-empowerteam/c/69619c02-8e14-8330-9781-6722e225a10d](https://chatgpt.com/g/g-p-6956a7038c1c8191b36acb079d060c81-personal-dna-and-empowerteam/c/69619c02-8e14-8330-9781-6722e225a10d) 

Chat público: [https://chatgpt.com/share/697a5294-bd14-8004-bb95-4bf7c9dc380f](https://chatgpt.com/share/697a5294-bd14-8004-bb95-4bf7c9dc380f) 

Last update: 2026-01-10 18:25 (America/Mexico\_City)

## **0\. Asset Header**

* Asset ID: MPB-QPMFP-Team-QuickAIPublishing-v10
* Version: v1.0
* Status: Operational (Internal)
* Owner: Victor (Founder)  
* Primary Users: Anaí / Juan Carlos / Ángeles  
* Scope: Operate Victor’s AI Publishing MetaFactory end-to-end (simulation-first) with governance  
* Non-negotiables:  
  * No invented facts/metrics/claims.  
  * Everything must be executable (checklists, templates, copy/paste).  
  * Pipeline is invariant; voices are modular.  
  * Formatting law: H2/H3/H4 only.

## **0.1 Change Note**

* v1.0: Added Insight Pack contract, QA Hard Gate, Control Plane (dashboard) instructions, Track A/B governance, WIP rules, daily cadence by role, and copy/paste templates.  
* v1.0a: Added **0.3 Abstract (RunAbstract)** for fast onboarding and shareability.

## **0.2 Snapshot Index (One-Screen Map)**

This section is a fast “table of contents \+ intent” so you can see the full asset at a glance.

### **0.2.1 Sections overview**

| Section | What it contains | Output / Why it matters |
| ----- | ----- | ----- |
| 1\. One-Page Visual Explainer | The invariant flow \+ dual naming (Operator/System/Engineering/Production) \+ Spanish validation | Aligns team language and prevents step-skipping |
| 2\. Quick Start | 30-minute setup, invariant pipeline, Track A/B, WIP rules, first steps | Gets the factory running today with minimal debate |
| 3\. Interpretation Pack | Insight Pack v1.0 contract (ip\_playbook\_v1, standard) \+ definitions \+ risks | Turns inputs into an executable plan and locks meaning |
| 4\. QA Hard Gate | PASS/FAIL validator result \+ hard checks \+ fix rules | Prevents hallucinated claims and non-operable outputs |
| 5\. Founder Manifesto | Why this exists, the principle, stations, and culture | Sets the governing philosophy without fluff |
| 6\. Why a MetaFactory | Problem → outcome → what changes vs ad-hoc publishing | Clarifies benefits and the “why” in 1–2 pages |
| 7\. Architecture | Templates → Instances → Assets \+ canonical pipeline \+ roles | Shows how the system scales across many factories |
| 8\. Control Dashboard | Registries \+ logs \+ WIP enforcement \+ cadence | Makes execution visible and governable |
| 9\. Operating Playbook | Daily cadence, role responsibilities, escalation rules | Makes the system runnable by the team daily |
| 10\. Create a Factory | How to create template \+ instance \+ naming/ID rules | Enables spawning new factories inside the MetaFactory |
| 11\. ChatGPT Simulation | Clean project model \+ 5-agent suite \+ exact execution steps | Fast “simulation-first” production with governance |
| 12\. Copy/Paste Templates | Source Pack, Interpretation Pack, QA checklist templates | Reusable contracts; stops prompt sprawl |
| 13\. Appendix | Spreadsheet tab headers (paste-ready) | Bootstraps the Control Dashboard without guesswork |
| 14\. Control Plane Update | First rows to create (Template/Instance/Assets) | Guarantees the dashboard starts correctly |

### **0.2.2 Core flow (dual naming lock)**

* Operator names (daily ops): **Source Pack → Interpretation Pack → QA Gate → Writer Profile → Control Dashboard**  
* System names (templates/IDs): Transfer Packet → Insight Pack → QA Hard Gate → Writer OS Profile → Control Plane  
* Engineering metaphor: Ingress → Compiler → Validator → Execution → Observability  
* Production line: Input Bin → Processing Unit → Quality Gate → Assembly Station → Control Board

### **0.2.3 What you can copy/paste immediately**

* Section 12 (templates):  
  * Source Pack (Transfer Packet) v1.0  
  * Interpretation Pack (Insight Pack) ip\_playbook\_v1  
  * QA Gate checklist (QA Hard Gate)  
* Section 13 (dashboard):  
  * Templates / Instances / Assets registries  
  * RunLog / ChangeLog / QA Defects log headers

### **0.2.4 Minimum operating commitments**

* Do not skip stations.  
* Enforce WIP:  
  * Max 3 in-progress assets per instance.  
  * Max 5 items per stage across the system.  
* If WIP is exceeded: stop starting new work; finish/ship/kill existing items.

---

## **0.3 Abstract (RunAbstract)**

MPB-QPMFP-TEAM is the team’s operational mini playbook for running **Victor’s AI Publishing MetaFactory** end-to-end (simulation-first) with governance. It converts “publishing with AI” from ad‑hoc prompting into a **repeatable production line** that a team can execute daily without quality drift, uncontrolled work-in-progress, or founder dependency.

The system is simple and invariant: **Source Pack → Interpretation Pack → QA Gate → Writer Profile → Control Dashboard**. Each station has a clear output (intake contract, executable plan, PASS/FAIL validation, structured draft, and dashboard trace). Dual naming is locked so the team can use friendly operator terms while preserving canonical system terminology for templates and IDs.

This playbook includes Track A/B governance, hard WIP limits, daily cadence by role (Anaí / Juan Carlos / Ángeles / Victor), copy/paste templates (Source Pack, Interpretation Pack, QA Gate), and paste-ready spreadsheet headers for the Control Dashboard.

### **0.3.1 What this asset enables**

* Run one asset through a governed pipeline in ChatGPT simulation.  
* Spawn new factories using Templates → Instances → Assets.  
* Make quality a system property (not a debate).  
* Keep execution visible (registries \+ logs \+ WIP).

### **0.3.2 Where to start (fastest path)**

* Start at **Section 2 (Quick Start)** and run one test asset today.  
* Copy **Section 12** templates into your working library.  
* Build the Control Dashboard with **Appendix (Section 13\)** headers exactly as written.

---

## **1\. One-Page Visual Explainer (MetaFactory in One View)**

### **1.1 The invariant flow (Operator \+ Metaphors)**

┌──────────────────────────┐     ┌──────────────────────────┐     ┌──────────────────────────┐     ┌──────────────────────────┐     ┌──────────────────────────┐  
│ 1\) SOURCE PACK            │ \--\> │ 2\) INTERPRETATION PACK     │ \--\> │ 3\) QA GATE                 │ \--\> │ 4\) WRITER PROFILE          │ \--\> │ 5\) CONTROL DASHBOARD       │  
│ (System: Transfer Packet) │     │ (System: Insight Pack)     │     │ (System: QA Hard Gate)     │     │ (System: Writer OS Profile)│     │ (System: Control Plane)    │  
│ Eng: Ingress              │     │ Eng: Compiler              │     │ Eng: Validator             │     │ Eng: Execution             │     │ Eng: Observability         │  
│ Prod: Input Bin           │     │ Prod: Processing Unit      │     │ Prod: Quality Gate         │     │ Prod: Assembly Station     │     │ Prod: Control Board        │  
└──────────────────────────┘     └──────────────────────────┘     └──────────────────────────┘     └──────────────────────────┘     └──────────────────────────┘  
            │                                │                                │                                │                                │  
            ▼                                ▼                                ▼                                ▼                                ▼  
   Define intake contract            Turn inputs into plan             PASS/FAIL checkpoint             Generate draft/output            Track \+ govern execution  
   Scope • Inputs • Constraints      Outline • Risks • Steps            Patch only flagged defects       Voice • Format • Structure       Registries • Logs • WIP

### **1.2 One-line mental model**

Ingress defines what enters → Compiler defines what it means → Validator decides if it’s allowed → Execution builds it → Observability shows how it performs.

### **1.3 What each station produces (outputs)**

* **Source Pack** → a signed intake contract (scope \+ inputs \+ constraints \+ acceptance criteria).  
* **Interpretation Pack** → an executable plan (outline \+ risks \+ steps \+ QA focus).  
* **QA Gate** → PASS/FAIL \+ defect list \+ patch instructions.  
* **Writer Profile** → draft aligned to voice \+ structure \+ format law.  
* **Control Dashboard** → updated registries \+ logs \+ WIP counts.

### **1.4 Spanish validation (same model)**

* **Paquete Fuente (Sistema: Paquete de Transferencia)** → **Ingreso** → **Bandeja/Tolva de Entrada**  
* **Paquete de Interpretación (Sistema: Paquete de Insights)** → **Compilador** → **Unidad de Procesamiento**  
* **Compuerta QA (Sistema: QA Hard Gate)** → **Validador** → **Control de Calidad**  
* **Perfil de Escritura (Sistema: Perfil Writer OS)** → **Ejecución** → **Estación de Ensamble**  
* **Tablero de Control (Sistema: Plano de Control)** → **Observabilidad** → **Tablero de Producción**

### **1.5 Do this now**

* Use the Operator names in daily ops: **Source Pack → Interpretation Pack → QA Gate → Writer Profile → Control Dashboard**.  
* Use System names only in templates/IDs and first mention.  
* If a work item skips a station, it is invalid.

---

## **2\. Quick Start (One Page)**

### **2.1 What you do in 30 minutes (today)**

1. Create/confirm the **Control Dashboard** spreadsheet (tabs \+ headers in Appendix).  
2. Create the first **Factory Template** row (MetaFactory-level blueprint).  
3. Create the first **Factory Instance** row (a live production run).  
4. Run **one** asset through the full pipeline:  
   * **Source Pack → Interpretation Pack → QA Gate → Writer Profile → Control Dashboard update**

### **2.2 The invariant pipeline (do not improvise)**

* **Source Pack** *(System name: Transfer Packet / Engineering: Ingress / Production line: Input Bin)*  
* **Interpretation Pack** *(System name: Insight Pack / Engineering: Compiler / Production line: Processing Unit)*  
* **QA Gate** *(System name: QA Hard Gate / Engineering: Validator / Production line: Quality Gate)*  
* **Writer Profile** *(System name: Writer OS Profile / Engineering: Execution / Production line: Assembly Station)*  
* **Control Dashboard** *(System name: Control Plane / Engineering: Observability / Production line: Control Board)*

### **2.3 Track selection**

* **Track A (Governed/Heavy):** external publication, brand-sensitive, claims, regulated topics, high stakes.  
* **Track B (Fast Lane):** internal drafts, ideation, low-risk assets.

### **2.4 WIP rules (minimal, non-negotiable)**

* Per Factory Instance: max **3** assets in progress at once.  
* Per stage: max **5** items in the same stage across the whole factory.  
* If WIP is exceeded: stop starting new work; finish/ship/kill existing items.

### **2.5 Do this now**

* Create the spreadsheet using Appendix headers.  
* Open a new “Factory Instance” called: **MPB-QPMFP-TEAM-v1.0**.  
* Run the templates in Section 12 for one test asset.

---

## **3\. Interpretation Pack v1.0 (System: Insight Pack | ip\_playbook\_v1 — Standard)**

### **3.1 Insight Pack Header**

* insight\_pack\_id: IP-MPB-QPMFP-TEAM-2026-01-09  
* insight\_pack\_profile\_id: ip\_playbook\_v1  
* level: standard  
* publication\_type: playbook (internal operational mini book)  
* audience: internal team  
* purpose: runnable operating system for the MetaFactory \+ dashboard  
* constraints:  
  * No invented facts/metrics/claims.  
  * Must be executable (checklists/templates/step-by-step).  
  * Include: why, architecture, control plane, glossary, operations, factory creation, simulation kickoff.  
  * Formatting law: H2/H3/H4 only.

### **3.2 Prosaic Introduction (Context & Intent)**

This playbook exists for one reason only: to turn publishing from an artisanal, founder-dependent activity into a repeatable, governable operating system that a team can run daily without ambiguity.

Most publishing efforts fail not because of lack of talent or ideas, but because there is no shared execution language. People improvise. Prompts multiply. Quality becomes subjective. Work-in-progress explodes. And every new asset feels like starting from zero.

Victor’s AI Publishing MetaFactory is the opposite approach. It treats publishing as infrastructure. Ideas enter through explicit contracts. Interpretation is separated from writing. Quality is enforced through gates, not opinions. Writing styles are modular. And every action leaves an operational trace in a control plane.

This Insight Pack defines the minimum intelligence required to operate that system reliably. It clarifies what this mini book must do, what it must not do, and how it fits into the broader MetaFactory. It is not inspirational material. It is an execution brief.

If the team follows what is defined here, the result is simple: fewer decisions, less friction, higher throughput, and assets that can be improved over time instead of reinvented.

### **3.3 Executive Intent**

This mini book is the team’s daily operating manual for Victor’s AI Publishing MetaFactory. It standardizes:

* How work enters (**Source Pack**)  
* How it is interpreted (**Interpretation Pack**)  
* How it is governed (**QA Gate**)  
* How it is written (**Writer Profile**)  
* How it is tracked (**Control Dashboard**)

### **3.4 Key Definitions (Must Be Consistent)**

* **MetaFactory:** a system that can spawn many repeatable factories (templates \+ instances).  
* **Factory Template:** the blueprint (pipeline, roles, QA, formats, dashboards).  
* **Factory Instance:** a live run using one template to produce assets.  
* **Asset:** a deliverable tracked with ID/version/status.  
* **Source Pack (System: Transfer Packet | Eng: Ingress | Prod: Input Bin):** the intake contract that defines scope, inputs, constraints, and acceptance criteria.  
* **Interpretation Pack (System: Insight Pack | Eng: Compiler | Prod: Processing Unit):** the structured sense-making layer that turns inputs into a plan, outline, risks, and execution instructions.  
* **QA Gate (System: QA Hard Gate | Eng: Validator | Prod: Quality Gate):** the PASS/FAIL checkpoint that blocks release until defects are patched.  
* **Writer Profile (System: Writer OS Profile | Eng: Execution | Prod: Assembly Station):** the voice \+ format behavior used to generate the draft.  
* **Control Dashboard (System: Control Plane | Eng: Observability | Prod: Control Board):** the tracking layer (registries \+ logs \+ WIP) that makes execution visible.

### **3.5 Architecture Summary (What Must Exist)**

* Contracts:  
  * Transfer Packet v1.0  
  * Insight Pack (ip\_playbook\_v1)  
  * QA Hard Gate checklist  
* Operating system:  
  * Writer OS (imprint\_editor\_v1 for internal ops clarity)  
* Control Plane:  
  * Registries (Templates / Instances / Assets)  
  * Logs (RunLog / ChangeLog / QA Defects)  
  * WIP rules \+ cadence

### **3.6 Risks & Mitigations**

* Risk: drifting formats or IDs → Mitigation: strict headers, hard gate, version discipline.  
* Risk: prompt accumulation (“prompt soup”) → Mitigation: pipeline-only execution; no skipped steps.  
* Risk: WIP explosion → Mitigation: hard WIP limits and stop-start rule.  
* Risk: hallucinated or implied claims → Mitigation: no-invented-facts rule enforced by QA.

### **3.7 Do This Now**

* Copy Section **12** templates into your team template library.  
* Implement the spreadsheet in the Appendix exactly.  
* Run the **QA Gate** checklist against one test asset today.

---

## **4\. QA Hard Gate (Validator Result)**

### **4.1 Verdict: PASS (with minor required fixes applied in v1.0)**

### **4.2 Hard checks**

* No invented facts/metrics/claims: PASS  
* Executable steps \+ templates included: PASS  
* Control Plane instructions \+ headers included: PASS  
* Track A/B defined: PASS  
* WIP rules explicit: PASS  
* “Do this now” at end of every section: PASS  
* Formatting law (H2/H3/H4 only): PASS

### **4.3 Minor fixes applied**

* Added explicit “Stop-start” rule for WIP.  
* Added Control Plane “first rows to create” stub.  
* Added role-by-role daily cadence (minimum actions).

### **4.4 Do this now**

* Treat this playbook as the single source of truth.  
* If you change anything: update version \+ changenote \+ log it.

---

## **5\. Founder Manifesto (Why the MetaFactory Exists)**

### **5.1 The bet**

We are making a single bet: that publishing is not a craft problem — it is a systems problem.

Craft can create brilliance once. Systems create brilliance repeatedly, with a team, under constraints, at speed.

### **5.2 The enemy**

The enemy is not competition. The enemy is entropy:

* Prompts multiplying into chaos.  
* Opinions replacing standards.  
* Work-in-progress exploding silently.  
* Quality drifting until trust breaks.  
* Founder-dependency becoming a hidden bottleneck.

If we don’t design against entropy, it will design against us.

### **5.3 The principle**

**The pipeline is invariant; the voices are modular.**

That means:

* We do not improvise the process.  
* We do not skip stations.  
* We do not “feel” quality — we validate it.  
* We do not scale heroics — we scale contracts.

### **5.4 The five stations (how we win)**

Every asset must move through the same sequence:

* **Source Pack** defines what enters.  
* **Interpretation Pack** defines what it means.  
* **QA Gate** decides if it is allowed.  
* **Writer Profile** builds it.  
* **Control Dashboard** shows the truth.

In engineering terms: **Ingress → Compiler → Validator → Execution → Observability**.  
In production terms: **Input Bin → Processing Unit → Quality Gate → Assembly Station → Control Board**.

These metaphors matter because this system is not just for publishing. It is a reusable operating model for any domain where ideas become outputs.

### **5.5 The standard**

We do not ship vibes. We ship assets that are:

* Traceable (IDs, versions, logs).  
* Governed (PASS/FAIL quality gates).  
* Repeatable (templates and contracts).  
* Modular (profiles and formats).  
* Operable (a team can run it without interpretation).

### **5.6 The culture**

This is the culture we build:

* **Contracts over conversations.** If it isn’t in the Source Pack, it doesn’t exist.  
* **Gates over debates.** QA decides; we patch and move.  
* **Visibility over faith.** The dashboard is the truth.  
* **Throughput over theatrics.** Shipping beats polishing forever.  
* **Learning over ego.** Every defect becomes a template improvement.

### **5.7 Founder Notes**

I don’t want a team that needs me to produce. I want a system that makes us unstoppable — and a team that can run it daily.

### **5.8 Do this now**

* If you’re about to start work, ask: “Where is the Source Pack?”  
* If QA fails, patch only what’s flagged. No scope creep.  
* If it isn’t in the Control Dashboard, log it before doing the next step.

---

## **6\. Why a MetaFactory (1–2 pages max)**

### **6.1 The problem it solves**

Publishing fails at scale when:

* Every asset is handcrafted.  
* Quality is subjective and inconsistent.  
* Work-in-progress explodes.  
* Knowledge is not captured as reusable templates.

A MetaFactory fixes this by making the pipeline invariant and the “voices” modular.

### **6.2 The outcome**

You can produce many assets reliably because:

* Inputs are standardized (**Source Pack** / System: Transfer Packet).  
* Interpretation is standardized (**Interpretation Pack** / System: Insight Pack).  
* Quality is governed (**QA Gate** / System: QA Hard Gate).  
* Writing is modular (**Writer Profile** / System: Writer OS Profile).  
* Operations are visible (**Control Dashboard** / System: Control Plane).

### **6.3 Founder Notes (optional)**

A MetaFactory is leverage. If the team can run the system without Victor in the loop, we win.

### **6.4 Do this now**

* Stop writing assets “freehand.” Start with the **Source Pack** (System: Transfer Packet) every time.  
* If you can’t describe the asset in a Transfer Packet, you’re not ready to produce it.

---

## **7\. Architecture**

### **7.1 MetaFactory model (Templates → Instances → Assets)**

* **Templates** define how work is done.  
* **Instances** are real runs of a template.  
* **Assets** are the produced outputs.

Everything must be traceable:

* Template ID → Instance ID → Asset ID → versions → logs.

### **7.2 The canonical pipeline**

1. **Source Pack** (System: Transfer Packet)  
2. **Interpretation Pack** (System: Insight Pack)  
3. **QA Gate** (System: QA Hard Gate)  
4. **Writer Profile** (System: Writer OS Profile)  
5. Production  
6. **Control Dashboard Update** (System: Control Plane)

### **7.3 Track A vs Track B governance**

* Track A requires:  
  * Sources/quotes where needed.  
  * Strong QA.  
  * Strict formatting and approvals.  
* Track B allows:  
  * Faster drafting.  
  * Looser iteration.  
  * Still no invented claims.

### **7.4 Roles (minimum viable)**

* **Maestro (Ops Lead):** orchestrates pipeline, enforces WIP, updates Control Plane.  
* **Insight Pack Builder:** produces Insight Pack; aligns scope.  
* **QA Validator:** runs Hard Gate; flags defects; blocks release.  
* **Writer (Writer OS):** produces content using profile.  
* **Publisher (Formatter):** final formatting, packaging, delivery readiness.

(One person can wear multiple hats, but the steps must still occur.)

### **7.5 Do this now**

* Assign the hats for the next 7 days (even if same person).  
* Choose Track A or B for each asset before work starts.

---

## **8\. Control Dashboard**

### **8.1 Purpose**

The Control Dashboard prevents chaos. If it isn’t logged, it didn’t happen.

### **8.2 What it contains**

* Registries:  
  * Templates Registry  
  * Instances Registry  
  * Assets Registry  
* Logs:  
  * RunLog (every run)  
  * ChangeLog (every change)  
  * QA Defects Log (every defect)

### **8.3 WIP rules (enforcement)**

* Max 3 in-progress assets per instance.  
* Max 5 items per stage across the system.  
* Stop-start rule: if WIP is exceeded, no new work enters until WIP is reduced.

### **8.4 Cadence (minimum)**

* Daily:  
  * Update WIP by stage.  
  * Close or kill stuck items.  
  * Log every completed step.  
* Weekly:  
  * Review defect patterns.  
  * Update templates.

### **8.5 Do this now**

* Create the spreadsheet tabs/headers from Appendix.  
* Add 1 template row, 1 instance row, 3 starter asset rows.

---

## **9\. Operating Playbook (Daily Cadence \+ Responsibilities)**

### **9.1 Daily standup (10 minutes)**

* What shipped yesterday?  
* What is blocked?  
* What is the WIP count per stage?  
* What is the single most important asset today?

### **9.2 Responsibilities by role**

#### **9.2.1 Anaí (Ops / Control Plane)**

* Update Instances \+ Assets registries (status, stage, owner).  
* Enforce WIP; stop-start if exceeded.  
* Ensure every run has a RunLog entry.

#### **9.2.2 Juan Carlos (Production / Publisher)**

* Ensure format readiness (H2/H3/H4 law).  
* Package templates \+ appendices for copy/paste.  
* Final QA on “deliverable readiness” (links, tables, headers).

#### **9.2.3 Ángeles (QA / Governance)**

* Run QA Hard Gate before anything ships.  
* Log defects (QA Defects Log) with severity \+ fix.  
* Verify “no invented claims” and scope compliance.

#### **9.2.4 Victor (Founder approval — limited)**

* Approves Template changes and releases.  
* Adds short Founder Notes only when needed.

### **9.3 Escalation rules**

* If QA fails: block release; patch only what’s flagged; rerun QA.  
* If scope changes: new Transfer Packet version.  
* If a task is stuck \> 48 hours: kill or redefine.

### **9.4 Do this now**

* Write today’s standup notes into RunLog.  
* Pick 1 asset to ship today. Only 1\.

---

## **10\. How to create a Factory inside the MetaFactory**

### **10.1 Factory Template creation (blueprint)**

1. Create a Template row in Templates Registry.  
2. Define:  
   * Template ID  
   * Purpose  
   * Default Track (A/B)  
   * Required contracts (Transfer/Insight/QA)  
   * Writer profile default  
   * Output format profile  
   * WIP limits  
3. Store the copy/paste templates linked to that Template ID.

### **10.2 Factory Instance creation (a live run)**

1. Create an Instance row in Instances Registry.  
2. Bind it to a Template ID.  
3. Create initial Asset rows (Assets Registry) with IDs \+ versions.  
4. Start RunLog for the instance.

### **10.3 Naming/ID rules (minimum viable)**

* Template ID format: TMP---v1  
* Instance ID format: INS-\<TEMPLATE\_ID\>--  
* Asset ID: your asset’s canonical ID (e.g., MPB-QPMFP-TEAM)  
* Versioning: v0.1 draft → v0.9 release candidate → v1.0 operational

### **10.4 Do this now**

* Create Template: TMP-MPB-QPMFP-TEAM-v1  
* Create Instance: INS-TMP-MPB-QPMFP-TEAM-v1-20260109-01

---

## **11\. How to initiate production in ChatGPT simulation**

### **11.1 Clean project model**

Create a single “project thread” per Factory Instance.

* Pin the **Source Pack** (System: Transfer Packet) (latest version).  
* Run the **Interpretation Pack** (System: Insight Pack).  
* Run the **QA Gate** (System: QA Hard Gate).  
* Run the **Writer Profile**.  
* Produce final deliverable.

### **11.2 The 5-agent suite (simulation roles)**

* **Maestro:** enforces pipeline \+ WIP \+ logs.  
* **Interpretation Pack Builder:** creates Interpretation Pack.  
* **QA Validator:** runs QA Gate.  
* **Writer:** writes using writer\_profile\_id.  
* **Publisher:** formats \+ packages \+ updates Control Dashboard stub.

(One assistant can simulate all roles, but must label steps clearly.)

### **11.3 Execution steps (copy/paste)**

1. Paste **Source Pack**.  
2. Command: “Generate **Interpretation Pack** (ip\_playbook\_v1, standard).”  
3. Command: “Run **QA Gate**; PASS/FAIL; patch only flagged.”  
4. Command: “Write v1.0 using writer\_profile\_id: imprint\_editor\_v1.”  
5. Command: “Package templates \+ dashboard headers \+ Control Dashboard update stub.”

### **11.4 Do this now**

* Start one instance thread and run the steps exactly.  
* Log each step in RunLog with timestamp.

---

## **12\. Copy/Paste Templates**

### **12.1 Source Pack (System: Transfer Packet) v1.0 (Template)**

Copy/paste and fill.

#### **12.1.1 Source Pack — Header (System fields keep canonical names)**

* transfer\_packet\_id: TP-\<ASSET\_ID\>--  
* asset\_id: \<ASSET\_ID\>  
* target\_version: \<vX.X\>  
* status: Draft | In Review | Approved  
* track: A | B  
* owner:  
* due\_date:  
* writer\_profile\_id: imprint\_editor\_v1 (default)

#### **12.1.2 Objective**

* What is being produced?  
* Who is it for?  
* What will success look like (observable)?

#### **12.1.3 Inputs (sources)**

* Provided texts/files:  
* Known constraints:  
* Gaps:  
  * If missing sources are required: tag \[NEEDS RESEARCH\].

#### **12.1.4 Non-negotiables**

* No invented facts/metrics/claims.  
* Must include: checklists \+ templates \+ Do-this-now bullets.  
* Formatting law: H2/H3/H4 only.

#### **12.1.5 Output spec**

* Sections required:  
* Length limits:  
* Tone:  
* Delivery format:

#### **12.1.6 Acceptance criteria**

* PASS conditions (bullet list):  
* FAIL conditions (bullet list):

#### **12.1.7 Do this now**

* Fill every field.  
* If any field is blank, do not start the **Interpretation Pack**.

---

### **12.2 Interpretation Pack (System: Insight Pack | ip\_playbook\_v1 — Standard)**

Copy/paste and fill.

#### **12.2.1 Interpretation Pack — Header (System fields keep canonical names)**

* insight\_pack\_id: IP-\<ASSET\_ID\>--  
* insight\_pack\_profile\_id: ip\_playbook\_v1  
* level: standard  
* publication\_type: playbook  
* audience: internal team  
* purpose: operational mini book

#### **12.2.2 Interpretation**

* The real job-to-be-done:  
* What must be standardized:  
* What must be optional/modular:

#### **12.2.3 Outline (H2/H3/H4 only)**

* Provide full outline with mandatory sections.

#### **12.2.4 Execution plan**

* Steps:  
* Owners:  
* Risks:  
* QA focus points:

#### **12.2.5 Do this now**

* Freeze the outline.  
* Send to QA for **QA Gate** readiness check.

---

### **12.3 QA Gate Checklist (System: QA Hard Gate) (Template)**

PASS/FAIL. Patch only flagged items.

#### **12.3.1 Truth & integrity**

* No invented facts/metrics/claims.  
* Any uncertain item is tagged \[NEEDS RESEARCH\].

#### **12.3.2 Completeness**

* All required sections present.  
* Every section ends with “Do this now” bullets.  
* Templates included and copy/pasteable.  
* Dashboard headers included and paste-ready.

#### **12.3.3 Operability**

* Steps are unambiguous.  
* Roles and cadence are explicit.  
* WIP rules are explicit.

#### **12.3.4 Format law**

* H2/H3/H4 only.

#### **12.3.5 Verdict**

* PASS / FAIL  
* If FAIL: list defects with severity \+ exact patch instructions.

#### **12.3.6 Do this now**

* Run this checklist before anything ships.

---

## **13\. Appendix — Spreadsheet Tab Headers (paste-ready)**

### **13.1 Templates Registry (tab: Templates)**

* template\_id  
* template\_name  
* domain  
* purpose  
* default\_track  
* required\_contracts  
* writer\_profile\_default  
* format\_profile  
* wip\_limit\_instance  
* wip\_limit\_stage  
* owner  
* status  
* version  
* last\_updated  
* link\_to\_templates  
* notes

### **13.2 Instances Registry (tab: Instances)**

* instance\_id  
* template\_id  
* instance\_name  
* track  
* start\_date  
* target\_ship\_date  
* status  
* stage  
* wip\_count  
* maestro  
* qa\_validator  
* writer  
* publisher  
* last\_updated  
* link\_to\_runlog  
* notes

### **13.3 Assets Registry (tab: Assets)**

* asset\_id  
* asset\_name  
* instance\_id  
* template\_id  
* track  
* owner  
* status  
* stage  
* version  
* priority  
* due\_date  
* source\_links  
* output\_link  
* qa\_status  
* qa\_last\_result  
* last\_updated  
* notes

### **13.4 RunLog (tab: RunLog)**

* run\_id  
* timestamp  
* instance\_id  
* asset\_id  
* step  
* actor  
* input\_ref  
* output\_ref  
* result  
* blockers  
* next\_action  
* notes

### **13.5 ChangeLog (tab: ChangeLog)**

* change\_id  
* timestamp  
* object\_type (template|instance|asset)  
* object\_id  
* from\_version  
* to\_version  
* change\_summary  
* reason  
* requested\_by  
* approved\_by  
* link  
* notes

### **13.6 QA Defects (tab: QA\_Defects)**

* defect\_id  
* timestamp  
* instance\_id  
* asset\_id  
* severity (blocker|major|minor)  
* category (truth|format|scope|operability|completeness)  
* description  
* location  
* fix\_required  
* owner  
* status  
* resolved\_timestamp  
* notes

### **13.7 Do this now**

* Create the spreadsheet with these exact tabs.  
* Paste headers exactly as-is.

---

## **14\. Control Plane Update (First Rows to Create)**

### **14.1 Template row (create first)**

* template\_id: TMP-MPB-QPMFP-TEAM-v1  
* template\_name: Quick AI Publishing MetaFactory Playbook — Team Edition  
* domain: MPB  
* purpose: Produce and operate internal playbooks with governance  
* default\_track: B (switch to A if external)  
* required\_contracts: Source Pack (System: Transfer Packet) v1.0; Interpretation Pack (System: Insight Pack) ip\_playbook\_v1; QA Gate (System: QA Hard Gate)  
* writer\_profile\_default: imprint\_editor\_v1  
* format\_profile: mpb\_internal\_ops\_v1 (create as a label)  
* wip\_limit\_instance: 3  
* wip\_limit\_stage: 5  
* status: Active  
* version: v1.0

### **14.2 Instance row (create second)**

* instance\_id: INS-TMP-MPB-QPMFP-TEAM-v1-20260109-01  
* instance\_name: MPB-QPMFP-TEAM v1.0 Release  
* track: B  
* status: Active  
* stage: Source Pack (System: Transfer Packet)

### **14.3 Asset starter rows (create third)**

Create these initial assets (even if you only ship one today):

* MPB-QPMFP-TEAM (this playbook)  
* TMP-BASE-PLAYBOOK-v1 (generic template library)  
* SOP-CONTROL-PLANE-v1 (dashboard SOP)

### **14.4 Do this now**

* Create these rows in your Control Plane immediately.  
* Start RunLog entry \#1 for the instance with today’s timestamp.