@sellable/mcp 0.1.259 → 0.1.261

package/skills/create-post/references/post-validation.md

@@ -11,6 +11,17 @@ Every saved draft needs a validation receipt. A draft without this receipt is no
 - `candidateHooksConsidered`
 - `selectedHook`
 - `selectedHookWhy`
+- `preDraftNarrativeOutline`
+- `preDraftStructureBrief` as a legacy compatibility alias when older drafts or
+  downstream readers still expect it
+- `selectedSourceTemplate`
+- `postPositioningBreakdown`
+- `viralPostOutline`
+- `hookToBodyPromiseMap`
+- `bodyExpressionCandidates`
+- `combinedBodyPlan`
+- `visibleFlowTrace` when the user asked for whole-flow, debug, or
+  step-by-step mode
 - `proofClaimsUsed`
 - `proofClaimSources`
 - `storyFilesConsulted`
@@ -18,6 +29,9 @@ Every saved draft needs a validation receipt. A draft without this receipt is no
 - `voiceRulesApplied`
 - `marketBeliefAudit`
 - `premiseValueAudit`
+- `mobileScanabilityAudit`
+- `templateAdaptationAudit`
+- `abstractionToConcreteRewriteAudit`
 - `linkedinPreviewAudit`
 - `simplifierConcreteLanguageAudit`
 - `antiAiAudit`
@@ -74,9 +88,13 @@ Each candidate should include:
 
 - hook text
 - selected premise
+- selected source template or no-template rationale
 - premise tension opened
 - reader value implied
 - source pattern
+- hook-to-body promise
+- see-more tension
+- curiosity debt
 - score
 - char count including newlines and first-line / first-two-line preview measurements
 - physical line count, content line count, longest nonblank line, and blank-line risk
@@ -93,12 +111,48 @@ After the first draft:
 1. remove unsupported claims
 2. verify the draft is anchored to the selected market belief and controversy
 3. verify the real story/scene, tension, and reader value are visible early
-4. tighten the hook
-5. simplify abstract phrasing
-6. replace generic language with concrete words only when supported
-7. preserve the user's actual story and point
-8. remove AI tells
-9. re-check LinkedIn preview fit after edits
+4. verify the body repays the selected hook's curiosity debt
+5. verify the final post follows the selected positioning sequence or explains
+   why it departed from the template
+6. tighten the hook
+7. simplify abstract phrasing
+8. replace generic language with concrete words only when supported
+9. preserve the user's actual story and point
+10. remove AI tells
+11. re-check LinkedIn preview fit after edits
+
+## Visible Flow Trace Audit
+
+When the user asks to see the whole flow, run the process step by step, validate
+that it is working, or debug a bad output, the validation receipt must preserve a
+`visibleFlowTrace`.
+
+Record:
+
+- `mode`: visible_whole_flow_debug
+- `checkpointStatuses`: each checkpoint marked `pass`, `weak`, `fail`, or
+  `blocked`
+- `checkpointOutputs`: the concrete output shown to the user for each
+  checkpoint
+- `qualityBreak`: the first checkpoint that made the draft weak, if any
+- `downstreamEffect`: how that break affected the hook, premise, body, or ready
+  status
+- `userVisibleBeforeSave`: yes | no
+- `draftSavedDespiteWeakness`: yes | no
+- `reasonDraftSaved`: why a `needs_revision` draft was still worth saving, if
+  it was saved
+
+Save as `needs_revision` when:
+
+- the trace was not shown before draft prose in visible debug mode
+- the body-expression lab was summarized after the fact instead of generating
+  real candidates before prose
+- a weak premise, missing proof, or wrong source template produced a bad body
+- the final response claims the workflow worked only because artifacts were
+  saved
+
+Do not mark a run successful unless the visible trace, final draft, and saved
+receipt all agree on the same quality state.
 
 ## Premise Value Audit
 
@@ -116,15 +170,128 @@ Record:
 - `readerValue`: what the reader learns, sees differently, or can do
 - `proofAvailable`: source-backed proof used
 - `proofMissing`: claims intentionally avoided or requiring user input
+- `preDraftNarrativeOutline`: hierarchical `I.`, `A.`, `i.` outline showing
+  hook debt, thesis, operating model, working body patterns adapted, narrative
+  beats, scan path, proof claims, and abstractions to remove
+- `preDraftStructureBrief`: legacy compatibility alias only; the canonical
+  artifact is `preDraftNarrativeOutline`
 - `premiseQualityGates`: pass/fail for `specific_scene_or_pattern`,
   `clear_reader`, `visible_tension`, `reader_value`, `credible_speaker`,
-  `proof_safety`, and `market_heat`
+  `proof_safety`, `market_heat`, and `pre_draft_narrative_outline`
 - `bodyOutline`: how the body delivers the premise before prose
+- `viralPostOutline`: the selected narrative structure, including beat jobs
+- `hookToBodyPromiseMap`: how the body repays the hook's open loop
+- `combinedBodyPlan`: which body-expression lines were kept, rewritten, or cut
 
 If the draft has no specific scene or observed pattern, no visible tension, or
 no reader value beyond "this is interesting," save as `needs_revision`. Do not
 mark it `ready` because the hook passes preview limits.
 
+## Pre-Draft Narrative Outline Audit
+
+Before a draft can be `ready`, validate that the narrative outline was locked
+before the body was written.
+
+Record:
+
+- `hook`: selected hook plus mobile/desktop rendered preview verdict
+- `thesis`: one sentence the post defends
+- `readerBeingTaught`: specific reader and why the post is written for them
+- `coreEquationOrMechanism`: the operating idea being taught
+- `keyDefinitions`: concrete definitions and examples for terms the reader
+  could misunderstand
+- `proofClaims`: claims, sources, and public-safety status
+- `sourceTemplateOrNoTemplateRationale`
+- `workingBodyPatternsAdapted`: body pattern name, beat order, why it worked,
+  what gets borrowed, and what must not be copied
+- `hierarchicalNarrativeBeats`: `I.`, `A.`, `i.` outline of the final post's
+  argument, examples, proof, and line/section shapes
+- `mobileScanPath`: what a skimmer understands from the hook, separators,
+  section labels, numbers, and close
+- `sectionOutline`: legacy summary of section order plus the job of each
+  section; do not substitute this for `hierarchicalNarrativeBeats`
+- `bodyPromiseAfterSeeMore`: what the body immediately repays
+- `abstractionsToRemove`: abstract phrases and their concrete replacements
+- `userCorrectionsApplied`: user corrections applied to the outline before
+  prose
+
+Save as `needs_revision` when the draft was written before the narrative
+outline, when the outline is a flat checklist instead of hierarchical
+`I.`, `A.`, `i.` notation, when the outline does not match the final prose, when
+working body patterns are unnamed or vaguely borrowed, when the mobile scan path
+is unclear, or when key terms are left abstract.
+
+## Mobile Scanability Audit
+
+A LinkedIn post must still teach the main idea when a reader scans it.
+
+Record:
+
+- `scanVisibleFrom`: hook, separators, numbered labels, ranges/numbers, example
+  prompts, and close
+- `readerGetsWithoutReadingEveryWord`: the specific takeaway a skimmer gets
+- `sectionSeparators`: present | absent | not_needed
+- `sectionLabels`: concrete | abstract | missing
+- `numbersOrProofVisible`: yes | no
+- `mobileLineLengthRisk`: pass | warn | fail
+- `skimVerdict`: pass | needs_revision
+
+Save as `needs_revision` when a skimmer cannot understand the thesis, hierarchy,
+or practical next action.
+
+## Abstraction-To-Concrete Rewrite Audit
+
+Record every meaningful abstraction found in the draft and the concrete
+replacement. Do not merely say "made concrete."
+
+Use this format:
+
+```text
+abstractionToConcreteRewriteAudit:
+1.
+  original:
+  issue:
+  replacement:
+  source:
+  kept_or_cut:
+```
+
+Common abstractions to flag:
+
+- vague nouns such as `signal`, `market`, `attention`, `system`, `quality`,
+  `context`, `machine`, or `workflow` when the sentence does not name the actual
+  source, action, number, or object
+- broad persona labels used as lead sources
+- "warm" without explaining what made the source warm
+- "offer" without explaining why the recipient would believe or want it
+- "learning" without naming what metric changes the next decision
+
+Do not make language concrete by inventing facts. If the concrete replacement
+requires missing proof, ask the user or save as `needs_revision`.
+
+## Template Adaptation Audit
+
+Before a draft can be `ready`, validate that source posts were converted into
+templates rather than copied.
+
+Record:
+
+- `selectedSourceTemplate`: source, template name, and why it fits
+- `positioningSequenceBorrowed`: category sequence being adapted
+- `viralPostOutlineBorrowed`: beat sequence being adapted
+- `lineShapesBorrowed`: reusable line shapes, not copied wording
+- `userStoryInputsUsed`: source-backed user facts filling the template
+- `userProofInputsUsed`: source-backed user proof filling the template
+- `forbiddenBorrowingAvoided`: source proof, jokes, personal context, status,
+  phrases, or examples not used
+- `hookToBodyRepayment`: whether the body answers the hook's curiosity debt
+- `bodyExpressionCandidatesReviewed`: which variants were tested and what won
+- `copyingRisk`: pass | needs_revision | blocked
+
+Save as `needs_revision` when the draft copies outside wording, borrows outside
+proof, keeps a source template's status without equivalent user authority, or
+uses a hook whose promised body payoff is not delivered.
+
 ## Market Belief Audit
 
 Before a draft can be `ready`, validate that it is not merely an internally
@@ -259,7 +426,9 @@ If the necessary proof or story is missing, ask the user or return blocked/retry
 
 Use:
 
-- `ready` only when proof, voice, anti-AI, and concrete-language gates pass
+- `ready` only when proof, voice, anti-AI, concrete-language, pre-draft
+  structure, mobile-scanability, hook-to-body repayment, and
+  template-adaptation gates pass
 - `needs_revision` when a draft exists but a gate failed
 - `blocked` when required context is missing
 - `retry-needed` when a tool/package/search failure blocked the pipeline

package/skills/create-post/references/premise-development.md

@@ -1,16 +1,42 @@
-# Premise Development
+# Premise Development V2
 
 A strong post is not an idea with a better hook. A strong post is a valuable
 premise wrapped in a sharp opening.
 
-Use this stage after market/hook research and before hook candidates. Do not
-generate hook candidates until at least one `Premise Card` exists.
+Use this stage after market/hook research and before hook candidates. V2 premise
+development also consumes the source post templates from hook research:
+post positioning breakdowns, viral-post outlines, hook-to-body promise maps, and
+body expression inputs.
+
+Do not generate hook candidates until at least one `Premise Card` exists and at
+least one source template has either been selected or explicitly rejected as a
+poor fit.
 
 ## Goal
 
 Turn the raw idea into a real story, observed tension, or useful argument that a
 specific reader would care about.
 
+Use this post tension framework when evaluating whether the premise can hold
+attention:
+
+```text
+Belief -> Contradiction -> Stakes -> Proof -> Mechanism -> Reframe -> Useful Move
+```
+
+- `Belief`: what the reader already thinks or wants to be true
+- `Contradiction`: what the source story reveals that does not fit the belief
+- `Stakes`: what the reader loses if they keep believing the old version
+- `Proof`: the scene, number, repeated pattern, or concrete artifact that makes
+  the contradiction credible
+- `Mechanism`: why the thing actually works or fails
+- `Reframe`: the sharper way to see the problem after the mechanism is clear
+- `Useful Move`: what the reader can do, notice, stop doing, or test next
+
+A post feels "edge of seat" when the hook creates a contradiction the target
+reader cares about, the body delays the answer only while adding proof, and each
+beat either raises tension or repays tension. If a beat does neither, cut it.
+
 The premise must answer:
 
 - who this is for
@@ -22,6 +48,8 @@ The premise must answer:
 - why now
 - why this user can credibly say it
 - what proof is available and what proof is missing
+- which source template, if any, should shape the narrative
+- which positioning sequence the user's post should follow
 
 If the premise has no real scene, no tension, and no reader value, stop before
 drafting. Ask for the missing story or save only a `needs_revision` premise
@@ -96,11 +124,23 @@ proof missing:
 best frame:
 story | contrarian take | teardown | founder confession | future thesis | lesson
 
+source template fit:
+<selected source template name or none>
+
+positioning sequence to test:
+<Category -> Category -> Category -> ...>
+
+viral outline to adapt:
+<beat names from selected source template, rewritten for this user's story>
+
 hook territories:
 - <territory 1>
 - <territory 2>
 - <territory 3>
 
+body expression inputs:
+- <line shape, proof slot, story beat, mechanism explanation, or closing move>
+
 risk:
 <why this premise might still be weak>
 
@@ -108,6 +148,210 @@ score:
 <1-100 with short reason>
 ```
 
+## Template-Aware Premise Selection
+
+Do not treat source templates as decoration. A source template is useful only
+when its narrative engine matches something the user can credibly say.
+
+For each premise card, compare it against the selected keeper templates from
+hook research:
+
+```text
+Template fit check:
+premise:
+source_template:
+template narrative engine:
+matching user story/proof:
+missing user story/proof:
+positioning sequence fit:
+hook promise fit:
+body payoff fit:
+voice fit:
+borrow:
+do not borrow:
+fit verdict: strong | partial | weak | reject
+```
+
+Reject a template when it depends on source-specific proof, celebrity reach,
+personal context the user does not have, or a body structure that would force a
+fake story. Prefer a less viral template that fits the user's real proof over a
+more viral template that requires borrowed authority.
+
+## Viral Narrative Structure
+
+Once a premise and source template are selected, create the user's viral-post
+outline before writing body prose.
+
+Use this format:
+
+```text
+User viral-post outline:
+selected_premise:
+selected_source_template:
+hook_promise:
+see_more_tension:
+body_payoff:
+positioning_sequence:
+  <Category> -> <Category> -> <Category> -> ...
+
+beats:
+1.
+  beat_name:
+  narrative_job:
+  user_story_or_proof:
+  positioning_categories:
+  reader_state_before:
+  reader_state_after:
+  line_shape_to_test:
+  proof_safety:
+```
+
+The outline should preserve the source template's useful narrative jobs while
+replacing all source-specific proof, scenes, status, jokes, and examples with
+the user's material.
+
+## Body Expression Lab
+
+After the selected hook and viral-post outline exist, generate body expression
+candidates before writing the final draft. This is where the system tests
+different ways to express the same structure.
+
+Generate 5-8 body expression candidates. Every candidate must use:
+
+- the same selected hook or hook territory
+- the same selected premise
+- the same viral-post outline
+- the same positioning sequence
+- only user-sourced story and proof
+
+Each candidate should vary the expression, not the facts:
+
+```text
+Body expression candidate:
+name:
+expression_strategy:
+opening_after_hook:
+beat_lines:
+  1. <line or paragraph>
+  2. <line or paragraph>
+positioning_sequence_coverage:
+hook_promise_repaid:
+best_lines:
+weak_lines:
+proof_risk:
+voice_risk:
+score:
+```
+
+Useful expression strategies:
+
+- plain field guide
+- founder confession
+- proof-first roadmap
+- teardown then replacement
+- scene then lesson
+- enemy naming then mechanism
+- compact build-in-public note
+
+Do not create candidates by changing the claim. Create candidates by changing
+line order, amount of scene, proof placement, rhythm, and how the mechanism is
+explained.
+
+## Combine Pass
+
+After body expression candidates are scored, combine the best parts into one
+draft outline before prose.
+
+Record:
+
+```text
+Combined body plan:
+selected_hook:
+selected_expression_parts:
+lines_kept:
+lines_rewritten:
+lines_cut:
+positioning_sequence_final:
+hook_promise_repayment:
+proof_gaps_remaining:
+why_this_combination_wins:
+```
+
+If no candidate repays the hook promise with real user proof, return to premise
+development or ask the user for the missing story. Do not save a `ready` draft.
+
+## Pre-Draft Narrative Outline
+
+Before final prose, produce a compact `Pre-Draft Narrative Outline`. This is the
+user-visible argument skeleton that lets the user confirm what the post is
+trying to say, in what order, and which proven body shapes are being adapted
+before the system writes body copy.
+
+Use this format:
+
+```text
+Pre-Draft Narrative Outline
+I. Hook and click debt
+   A. Selected hook: <selected hook>
+   B. Rendered mobile preview verdict: <pass | warn | fail + why>
+   C. What "see more" must repay: <the open loop the first body beat must answer>
+
+II. Thesis the post will defend
+   A. One-sentence thesis: <the post's operating claim>
+   B. Reader being taught: <specific audience, not a broad persona>
+   C. Why this reader cares now: <timely pain, belief, or decision>
+
+III. Operating model
+   A. Core equation or mechanism: <the model the post teaches>
+   B. Key definitions:
+      i. <term>: <plain definition + concrete examples>
+      ii. <term>: <plain definition + concrete examples>
+
+IV. Body shape borrowed from posts that worked
+   A. Selected source template or no-template rationale: <source or rationale>
+   B. Working body pattern(s) being adapted:
+      i. <pattern name>: <beat order and why it works>
+      ii. <pattern name>: <beat order and why it works>
+   C. What gets borrowed:
+      i. <narrative job, sequence, transition, or proof order>
+   D. What must not be copied:
+      i. <source wording, creator-specific proof, joke, or context>
+
+V. Narrative beats
+   A. Beat 1: <job, reader state before/after, example/proof>
+      i. Line shape or section label: <how it will appear>
+      ii. Concrete examples: <examples/numbers>
+   B. Beat 2: <job, reader state before/after, example/proof>
+      i. Line shape or section label: <how it will appear>
+      ii. Concrete examples: <examples/numbers>
+   C. Beat 3: <job, reader state before/after, example/proof>
+      i. Line shape or section label: <how it will appear>
+      ii. Concrete examples: <examples/numbers>
+
+VI. Scan path and proof safety
+   A. Mobile scan path: <what skimmers learn from labels/numbers/close>
+   B. Proof claims:
+      i. <claim>: <source + public-safety status>
+   C. Abstractions to remove:
+      i. <abstract phrase> -> <concrete replacement>
+   D. Draft risks: <risk and how to avoid it>
+```
+
+Quality gate:
+
+- The outline must explain the post before the draft exists.
+- The outline must be useful to a reader who only scans the finished post.
+- The outline must include proof claims and risk before prose.
+- The outline must define any operating terms that could be misunderstood.
+- The outline must use `I.`, `A.`, and `i.` hierarchy. A flat field list fails.
+- If the post is adapting bodies that worked, the outline must name the body
+  pattern and what beat order, proof order, or transition logic is being
+  borrowed.
+- If the post is a field guide, the narrative beats must show the hierarchy
+  before prose, such as best-to-worst, highest-to-lowest intent, or
+  source-to-outcome.
+- If the outline cannot be made concrete, return to premise development.
+
 ## Premise Quality Gate
 
 A premise can move to hook generation only when it passes all of these:
@@ -119,6 +363,9 @@ A premise can move to hook generation only when it passes all of these:
 - `credible_speaker`: pass
 - `proof_safety`: pass
 - `market_heat`: pass or explained
+- `template_fit`: pass or explicitly no-template
+- `hook_to_body_repayment`: pass
+- `pre_draft_narrative_outline`: pass
 
 If any gate fails:
 
@@ -137,8 +384,11 @@ For each hook candidate, include:
 - which tension it opens
 - which reader value it implies
 - whether the real scene appears in the first screen or shortly after
+- source template or no-template rationale
+- hook promise the body must repay
 
 Reject hooks that are accurate but do not reveal the premise's tension or value.
+Reject hooks that create a promise the selected viral-post outline cannot repay.
 
 ## Body Relationship
 
@@ -155,5 +405,6 @@ body outline:
 7. close returns to the premise without summarizing
 ```
 
-If this outline cannot be filled without inventing proof, return to premise
-development.
+Replace this generic outline with the selected viral-post outline when a source
+template is available. If the outline cannot be filled without inventing proof,
+return to premise development.

package/skills/research/config.json

@@ -0,0 +1,9 @@
+{
+  "parallelMode": "wide",
+  "agentCount": 6,
+  "maxToolCallsPerAgent": 2,
+  "senderMaxAgents": 2,
+  "senderMaxToolCallsPerAgent": 3,
+  "progressMode": true,
+  "debugMode": true
+}