pae/crimson_leaf_publishing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(clp): build full CLP agent roster, templates, and skills library

Browse Source 
- 8 company agents: Lyra (intake), Selene (CEO), Atlas (research),
  Nova (publishing ops), Iris (author), Devon (dev editor),
  Lane (line editor), Cora (continuity editor)
- 19 additional templates (20 total): blog, recipe, short_story,
  book pipeline, ai_article, planning, boardroom, quick, project_index
- 5 skill guides: YA, Romance, SciFi, Blog, Recipe writing
- Rewritten charter and business plan

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
David Baity
2026-03-12 01:14:51 -04:00
parent d6b2c94135
commit 50749f8e2b
52 changed files with 3276 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
templates/InputFromUser.yml
View File

@@ -1,5 +1,5 @@
name: InputFromUser
description: "Intake — translate operator intent into structured work for Nova."
description: "Human interface agent — translate user intent into structured work."
debug: true
system: agent_prompt
@@ -16,27 +16,86 @@ sections:
steps:
- type: think
scene: |
You are the named agent receiving a message from the operator.
You are the named agent receiving a message from the operator via the interface.
A single message may contain multiple instructions or subjects at once.
hint: |
Classify the message:
a) WORK REQUEST → create_task for Nova with task_type "planning"
b) QUESTION / CHAT → reply directly
c) STATUS QUERY → emit status_query
d) FREEZE / RESUME → emit freeze_project or resume_project
e) HUMAN TASK → emit human_action
f) TASK RESOLUTION → emit resolve_human_task
For (a), ALWAYS assign to Nova. You route, Nova decides.
Your ONLY job is to route this message to the right place.
You do NOT decide what work to do. You do NOT pick templates. You do NOT assign agents.
The CEO (Selene) will receive this message and decide the workflow.
Classify the message into ONE of these categories:
a) WORK REQUEST — the operator wants something done (write, research, build, plan, etc.)
Create ONE task for Selene with task_type "planning". Include the full message as the description.
b) SIMPLE QUESTION / CHAT — just a question or conversational remark.
Reply directly. Do NOT create a task.
c) STATUS QUERY — operator asks what is happening, what is pending, what is done.
Emit status_query.
d) PROJECT FREEZE / RESUME — operator says pause/freeze/hold or resume/thaw.
Emit freeze_project or resume_project.
e) HUMAN TASK — operator says a person needs to do something manually.
Emit human_action.
f) HUMAN TASK RESOLUTION — operator says "I did X", "here is Y".
Emit resolve_human_task.
g) COMPANY CREATION — operator wants to create a new company
(e.g. "Create a company X", "Start company Y", "Set up a new company called Z").
- If the operator provided an explicit company name:
Emit procure_company with name, slug, and business_plan extracted from the message.
The slug must be lowercase kebab-case (e.g. "Crimson Leaf Publishing" → "crimson-leaf-publishing").
The business_plan should capture the description/focus from the message (may be empty string if none given).
Do NOT route this to Selene. Do NOT create a planning task.
- If NO company name was provided:
Do NOT emit procure_company.
Instead, reply directly with a name suggestion based on the description.
Format: "Company name must be provided. Based on your description, I suggest **{Suggested Name}** (`{suggested-slug}`). Reply with the name you'd like to use."
h) AGENT HIRE REQUEST — operator wants to hire one or more agents for the team
(e.g. "hire a Writer", "add a Researcher and Strategist", "we need a Designer and a Developer").
- Emit ONE `hire_agent` action PER agent role requested.
- Set `task_type` to the role name (e.g. "Writer", "Researcher", "Strategist").
- Set `context` to any extra description about the role (optional — use empty string if none given).
- Do NOT route to Selene. Do NOT create a planning task.
CRITICAL: For category (a), ALWAYS assign to Selene with task_type "planning".
Do NOT try to decide the right agent, template, or workflow yourself.
Selene is the CEO. She decides. You route.
For category (g) with a name, emit procure_company directly — Selene is NOT involved.
For category (g) without a name, reply only — do NOT create any task or action.
For category (h), emit one hire_agent action per role — Selene is NOT involved.
OUTPUT FORMAT: Your response IS the user-facing reply. Write it directly.
- For work requests: "Task Created: [task name]"
- For company creation: "Company creation initiated: [company name]"
- For agent hire: "Agent hired: [role]" (one line per agent)
- For questions/chat: answer directly
- For status queries, freeze/resume, human tasks: brief one-line confirmation
Do NOT use [did: ...] notation. Do NOT add explanations. One sentence per action.
- type: package
packet_type: IntakeResponse
schema:
actions:
- type: "create_task|save_nugget|status_query|human_action|resolve_human_task|freeze_project|resume_project"
task_name: "string"
description: "string"
- type: "create_task|save_nugget|status_query|human_action|resolve_human_task|freeze_project|resume_project|procure_company|hire_agent"
task_name: "string — short name (create_task only)"
description: "string — the operator's full message verbatim, plus project context (create_task only)"
agents:
- "Nova"
task_type: "planning"
- "Selene"
task_type: "planning or role name (planning for create_task; role name e.g. Writer for hire_agent)"
note: "string — insight to store (save_nugget only)"
subject: "string — what to look up (status_query only)"
user_name: "string — sender name (status_query briefing only)"
task_id: "string — task UUID (resolve_human_task only)"
duration: "string — e.g. '2w' (freeze_project only)"
company_name: "string — full company name as stated by operator (procure_company only)"
company_slug: "string — kebab-case slug derived from name (procure_company only)"
business_plan: "string — description/focus extracted from operator message (procure_company only, may be empty)"
context: "string — additional role context (hire_agent only, may be empty)"
- type: reply
target: discussion

83
templates/ai_article_plan.yml Normal file
View File

@@ -0,0 +1,83 @@
name: ai_article_plan
description: "Plan a 10-article series — select topics, write briefs, spawn 10 writing tasks for Iris."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
sections:
- agent
- project
- history
- rag
- deliverables
- message
- instructions
steps:
- type: think
hint: |
You have research deliverables above. Read the project description to understand
the audience and subject matter.
Design a SERIES PLAN for exactly 10 standalone articles (5-minute reads, ~800-1000 words).
You choose the topics. Aim for variety — cover different angles so a wide range of readers
each find something valuable.
For EACH article define:
- ARTICLE TITLE
- TARGET READER: one sentence
- THE HOOK: the real problem they face that opens the article
- THE PROMISE: the one thing they walk away knowing
- KEY POINTS: 3-4 specific, concrete points
- CALL TO ACTION: one thing they can do this week
- TONE NOTES: anything specific to this reader or topic
Write the complete SERIES PLAN now.
- type: document
filename: "{{task_name_slug}}"
- type: package
packet_type: IntakeResponse
hint: |
Convert the series plan into exactly 10 create_task actions for Iris.
RULES:
- Exactly 10 actions
- task_name: "Write Article N: [Title]" where N is 1 through 10
- agent_name: "Iris"
- task_type: "ai_article_write"
- description: Full brief for this article (hook, promise, key points, CTA, tone).
Begin: "You are writing Article N of the series."
End: "Word count: 800-1000 words. Standalone — no assumed knowledge of other articles."
- depends_on: "" (all parallel)
JSON array of exactly 10 objects. No prose.
schema:
actions:
- type: create_task
task_name: "string"
agent_name: "string"
task_type: "ai_article_write"
description: "string"
depends_on: "string"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 60
deliverable_type: coordination
criteria:
completeness:
weight: 40
description: "All required sections and elements present"
structure:
weight: 35
description: "Logical organization and hierarchy"
actionability:
weight: 25
description: "Clear enough for execution without guessing"

95
templates/ai_article_research.yml Normal file
View File

@@ -0,0 +1,95 @@
name: ai_article_research
description: "Research the article series topic — live search + synthesis + spawn article plan task."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
sections:
- agent
- project
- history
- rag
- prior_results
- message
- instructions
builders:
prior_results: |
*** WEB SEARCH RESULTS ***
{steps[1].text}
(If the above is empty, use your expert training knowledge.)
steps:
- type: think
hint: |
Read the project description and the message above carefully.
Identify the best search query to find current, real-world information on this topic.
State your reasoning, then on the last line write:
SEARCH QUERY: [your query here]
Query rules: 3-8 words. Specific. Current year preferred.
- type: tool
capability: Tool_WebSearcher
input_from: last_text
- type: think
hint: |
Using the search results above (or your training knowledge if unavailable), write a
RESEARCH BRIEF on the topic from the project description.
Cover as many relevant angles and subtopics as you can find real evidence for.
For each angle: what is happening, what problem it solves, one concrete result.
End with a SERIES RECOMMENDATION section proposing exactly 10 article topics.
For each topic: working title, target reader, the one thing they will learn.
- type: document
filename: "{{task_name_slug}}"
- type: package
packet_type: IntakeResponse
hint: |
Create exactly ONE follow-up task.
- task_name: "Plan Article Series"
- agent_name: "Atlas"
- task_type: "ai_article_plan"
- description: "Using the research deliverable, plan exactly 10 standalone articles for
this series. Each article is a 5-minute read (~800-1000 words) for the target audience
described in the project. You choose the topics based on the research. Then spawn 10
ai_article_write tasks for Iris."
- depends_on: ""
schema:
actions:
- type: create_task
task_name: "string"
agent_name: "string"
task_type: "string"
description: "string"
depends_on: "string"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 65
deliverable_type: coordination
criteria:
accuracy:
weight: 35
description: "Facts are correct and verifiable"
thoroughness:
weight: 30
description: "Topic covered in sufficient depth"
source_quality:
weight: 20
description: "Sources are credible and relevant"
organization:
weight: 15
description: "Findings are well-structured"

74
templates/ai_article_write.yml Normal file
View File

@@ -0,0 +1,74 @@
name: ai_article_write
description: "Write one standalone article from a brief — draft, polish, deliver."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
sections:
- agent
- project
- history
- rag
- deliverables
- message
- rejection_feedback
- instructions
steps:
- type: think
max_tokens: 4000
hint: |
Your task message contains the article brief. Follow it exactly.
Before writing, confirm: title, target reader, hook, promise, key points, call to action.
Write the full article:
- # Title as H1
- One-line subhead
- Opening hook: first sentence drops reader into a real scenario
- 3-4 body sections with bold subheadings, short paragraphs
- At least one concrete number (dollars, time, percentage) per section
- "Try This Week" section: one specific, free or low-cost action
- Memorable closing line
Peer-to-peer tone. Not a pitch. Not a lecture.
Word count: 800-1000 words.
- type: think
max_tokens: 4000
model: power
hint: |
Read your draft as the target reader would on their phone.
Cut warmup. Cut vague generalities. Cut brochure-speak.
Every paragraph earns its place or it goes.
Call to action must be doable this week.
Word count 800-1000.
Output ONLY the polished final article starting with # [Title]. No commentary.
- type: document
filename: "{{task_name_slug}}"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 80
deliverable_type: consumer
criteria:
narrative_flow:
weight: 30
description: "Story progresses naturally with good pacing"
character_voice:
weight: 25
description: "Characters are distinct and consistent"
prose_quality:
weight: 25
description: "Writing is polished and engaging"
continuity:
weight: 20
description: "Consistent with prior chapters and canon"

88
templates/blog_research.yml Normal file
View File

@@ -0,0 +1,88 @@
name: blog_research
description: "Research a blog topic — live web search + synthesis + spawn a blog_write task."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
sections:
- agent
- project
- history
- rag
- prior_results
- message
- instructions
builders:
prior_results: |
*** WEB SEARCH RESULTS ***
{steps[1].text}
(If the above is empty, use your expert training knowledge to answer this question.)
steps:
- type: think
hint: |
You are researching a blog topic for the project described above.
Read the project description and current message carefully.
Identify the single best search query to find current, real-world information
or recent discussion on this topic.
State your reasoning, then on the last line write:
SEARCH QUERY: [your query here]
Query rules: 3–8 words. Specific. Current year preferred.
- type: tool
capability: Tool_WebSearcher
input_from: last_text
- type: think
hint: |
Using the search results above (or your training knowledge if unavailable),
write a CONTENT BRIEF for this blog post.
Structure the brief as:
TOPIC: [clear one-line topic statement]
TARGET READER: [who is this for — one sentence]
THE HOOK: [the real problem or curiosity that opens the article]
THE PROMISE: [the one thing the reader walks away knowing or able to do]
KEY POINTS: [3–5 specific, concrete points to cover]
TONE: [voice and register — e.g. "conversational, peer-to-peer", "authoritative and warm"]
WORD COUNT TARGET: [800–2000 words depending on depth]
CALL TO ACTION: [one concrete thing the reader can do this week]
SOURCES: [any key URLs or references from the search results]
- type: document
filename: "{{task_name_slug}}-brief"
- type: spawn
task_type: blog_write
task_name: "Write Blog: {project.name}"
agent: Iris
prompt_from: last_text
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 65
deliverable_type: coordination
criteria:
accuracy:
weight: 35
description: "Facts are correct and verifiable"
thoroughness:
weight: 30
description: "Topic covered with sufficient depth and specificity"
source_quality:
weight: 20
description: "Sources are credible and relevant"
organization:
weight: 15
description: "Brief is well-structured and actionable"

89
templates/blog_write.yml Normal file
View File

@@ -0,0 +1,89 @@
name: blog_write
description: "Write a standalone blog post — draft, polish, deliver."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
sections:
- agent
- project
- history
- rag
- deliverables
- message
- rejection_feedback
- instructions
steps:
- type: think
max_tokens: 4000
hint: |
Your task message contains the blog content brief. Follow it exactly.
Before writing, confirm:
- TOPIC and TARGET READER
- HOOK: the first sentence drops the reader into a real scenario or provocative question
- PROMISE: the one thing they walk away with
- KEY POINTS to cover
- TONE and WORD COUNT TARGET
- CALL TO ACTION
Write the full blog post:
- # Title as H1 (make it specific and curiosity-driven, not generic)
- Optional subhead in italics
- Opening hook: first 2–3 sentences pull the reader in immediately
- Body: 3–5 sections with bold subheadings, short readable paragraphs
- At least one concrete example, number, or real scenario per section
- "Try This Week" or equivalent action section before the closing
- Memorable closing line that reinforces the promise
Tone rules:
- Peer-to-peer. Write like a knowledgeable friend, not a corporate brochure.
- Use "you" and "your" — not "one" or "the reader."
- Short sentences preferred. No filler paragraphs.
- No listicles of 10+ items without grouping them into themes.
- type: think
max_tokens: 4000
model: power
hint: |
Read your draft as the target reader would on their phone.
Apply these editorial passes in sequence:
1. CUT — eliminate any warmup sentences, vague generalities, or brochure-speak
2. SHARPEN — every subheading should be scannable and specific
3. HOOK CHECK — does the opening pull in the first two sentences?
4. CTA CHECK — is the call to action specific and doable this week?
5. VOICE CHECK — does it sound human and direct throughout?
Target word count: stay within the specified range. Quality over quantity.
Output ONLY the polished final blog post starting with # [Title].
No commentary, no "Pass 2" label, no preamble.
- type: document
filename: "{{task_name_slug}}"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 80
deliverable_type: consumer
criteria:
hook_strength:
weight: 30
description: "Opening immediately engages the target reader"
prose_quality:
weight: 30
description: "Writing is clear, direct, and human — no brochure-speak"
substance:
weight: 25
description: "Content is specific, useful, and backed by real examples"
structure:
weight: 15
description: "Scannable format with clear flow from hook to CTA"

53
templates/boardroom.yml Normal file
View File

@@ -0,0 +1,53 @@
name: boardroom
description: "Iterative boardroom — rotating chair, agents debate until consensus or max 3 rounds."
debug: true
system: agent_prompt
# Each participant's identity loaded using identity.md only (not full RAG dump).
participant_prompt:
- "= identity.md"
# Sections injected into every think step prompt for this template.
sections:
- agent
- project
- history
- participants
- participants_prompt
- message
- instructions
steps:
- type: think
max_tokens: 16000
rotate_participants: true
loop:
max_iterations: 3
hint: |
You are {agent.name}. This is round {task.iteration} of the boardroom discussion.
You are in a room with {agent_roster}.
The whole room is talking — everyone contributes to this debate. You are not lecturing.
You are writing YOUR perspective on what the group discussed this round.
Think of it as your meeting notes: what was said, who pushed back, what you argued,
what you think of the arguments you heard, where you agree or disagree.
You have read the prior rounds above — react to them. Challenge what you disagree with.
Build on what resonates. Speak in your own voice. Make your case.
When the group has genuinely reached consensus across all perspectives, include exactly:
"consensus_reached: true"
If debate should continue, do NOT include that line.
- type: think
max_tokens: 8000
agent: first_available
hint: |
Synthesize the boardroom transcript into a clear recommendation.
Surface consensus, note unresolved tensions, and end with a concrete next step.
- type: close
rag_update: false
adjudication:
enabled: false

168
templates/book_chapter.yml Normal file
View File

@@ -0,0 +1,168 @@
name: book_chapter
description: "Write one chapter — continuity check, draft, deepen, then spawn editorial review."
debug: true
system: agent_prompt
requires:
- genre_name
- genre_audience
- prose_style
- chapter_target_words
- chapter_ref
agent_prompt:
- "= identity.md"
- "agent.rag.json"
sections:
- agent
- project
- history
- rag
- deliverables
- message
- rejection_feedback
- instructions
steps:
- type: think
hint: |
PASS 0 — BIBLE & CONTINUITY CHECK (do this FIRST, before drafting)
GENRE: {genre_name} | AUDIENCE: {genre_audience}
PROSE STYLE GUIDE: {prose_style}
TARGET CHAPTER LENGTH: ~{chapter_target_words} words
⚠️ CRITICAL: Your task name tells you EXACTLY which chapter to write.
Look at the CURRENT MESSAGE — write THAT chapter and ONLY that chapter.
Do NOT write Chapter 1 unless the message explicitly says "Chapter 1".
STEP 1 — READ THE OUTLINE / CHARACTER BIBLE:
Look at PROJECT DELIVERABLES for the outline file (it contains the Character Bible
if this is a fiction project, and the Chapter Outline for all projects).
Extract and record:
- Protagonist: exact name, voice description, age (if fiction)
- Love interest and supporting characters: exact names and roles (if fiction)
- World rules / constraints (if paranormal or speculative)
- This chapter's summary, emotional beat, and closing hook from the outline
If no outline/bible is available, use the character names and project details
from the task description above — be CONSISTENT throughout the book.
STEP 2 — FIND THE PREVIOUS CHAPTER:
Look at PROJECT DELIVERABLES for the chapter that comes BEFORE this one.
If no previous chapter exists (this IS Chapter 1), skip to STEP 4.
STEP 3 — QUOTE THE ENDING:
Copy the LAST 2–3 sentences of the previous chapter here, word for word.
Label them: "PREVIOUS CHAPTER ENDED WITH: ..."
Your new chapter MUST pick up from this exact moment.
STEP 4 — PLAN YOUR CHAPTER:
State your plan:
- CHAPTER: Exact chapter number and title (from the task message)
- POV CHARACTER: Whose perspective are we in?
- FIRST LINE: How does this chapter begin, continuing from the previous ending?
- EMOTIONAL ARC: What does the protagonist feel at start vs end?
- CHAPTER GOAL: What plot event MUST happen here?
- CLOSING HOOK: Exact last image or line that makes readers continue?
Now write the full draft chapter following the prose style guide above.
Be consistent with ALL character names and world rules from the bible.
- type: think
model: power
hint: |
PASS 2 — DEEPEN & SHARPEN
Read your draft critically through an editor's eyes:
- Does the first line continue naturally from the previous chapter's ending?
- Does the opening hook land in the first two lines?
- Are ALL character names consistent with the bible/outline?
- Is every dialogue exchange tight and voice-distinct between characters?
- Are there any "telling" moments that should be "showing"?
- Does every scene beat move the story forward OR reveal character?
- Is the closing hook specific and compelling, not generic?
- Does the prose match the genre style guide above?
- Is the chapter at the target length? ({chapter_target_words} words — write the full chapter)
Rewrite the COMPLETE final chapter incorporating all improvements.
Output ONLY the polished chapter text — no commentary, no "Pass 2" headings.
Start directly with the chapter title and opening line.
- type: document
filename: "chapter-{chapter_ref}"
- type: package
hint: |
The chapter has been written and committed. Now spawn the three independent editorial reviewers
and the roundtable debate. Use the exact task_names shown — the roundtable depends_on all three.
schema:
chapter_text: string
spawn:
- task_type: chapter_review
task_name: "Review (Devon): {chapter_ref}"
agent_name: Devon
priority: 6
context:
chapter_text: "{chapter_text}"
review_focus: developmental
genre_name: "{genre_name}"
genre_audience: "{genre_audience}"
chapter_ref: "{chapter_ref}"
- task_type: chapter_review
task_name: "Review (Lane): {chapter_ref}"
agent_name: Lane
priority: 6
context:
chapter_text: "{chapter_text}"
review_focus: line
genre_name: "{genre_name}"
genre_audience: "{genre_audience}"
chapter_ref: "{chapter_ref}"
- task_type: chapter_review
task_name: "Review (Cora): {chapter_ref}"
agent_name: Cora
priority: 6
context:
chapter_text: "{chapter_text}"
review_focus: continuity
genre_name: "{genre_name}"
genre_audience: "{genre_audience}"
chapter_ref: "{chapter_ref}"
- task_type: chapter_roundtable
task_name: "Roundtable: {chapter_ref}"
agents: [Devon, Lane, Cora]
priority: 7
context:
chapter_text: "{chapter_text}"
genre_name: "{genre_name}"
genre_audience: "{genre_audience}"
chapter_ref: "{chapter_ref}"
depends_on:
- "Review (Devon): {chapter_ref}"
- "Review (Lane): {chapter_ref}"
- "Review (Cora): {chapter_ref}"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 80
deliverable_type: consumer
criteria:
narrative_flow:
weight: 30
description: "Story progresses naturally with good pacing"
character_voice:
weight: 25
description: "Characters are distinct and consistent"
prose_quality:
weight: 25
description: "Writing is polished and engaging"
continuity:
weight: 20
description: "Consistent with prior chapters and canon"

122
templates/book_editorial.yml Normal file
View File

@@ -0,0 +1,122 @@
name: book_editorial
description: "Editorial boardroom — agents review the full manuscript, debate quality, and produce written editorial notes."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
participant_prompt:
- "= identity.md"
sections:
- agent
- project
- history
- rag
- deliverables
- participants
- participants_prompt
- message
- rejection_feedback
- instructions
steps:
- type: think
rotate_participants: true
loop:
max_iterations: 3
hint: |
You are {agent.name}. This is the editorial review boardroom for the manuscript.
TASK: Review all completed chapters (look in PROJECT DELIVERABLES — files named
"final-chapter-*.md"). Read them carefully as a professional editor would.
For each round, discuss:
1. CONTINUITY — Does each chapter open by continuing the previous chapter's cliffhanger?
Quote specific chapter-to-chapter handoffs that work well or need repair.
2. CHARACTER VOICE — Are POV voices distinct across chapters?
Call out any chapters where the voice felt off.
3. WATTPAD HOOKS — Do chapters open with a strong hook that stops a teen scrolling?
Which openings are weakest and need a rewrite?
4. PACING — Any chapters that drag or that rush past important emotional beats?
5. CLIFFHANGERS — Which chapter endings are strong? Which are weak or generic?
6. SERIES HOOK — Does the final chapter end in a way that makes readers desperate for the next book?
Speak in your own professional voice. Debate. Challenge each other.
When the editorial team has reached consensus on the manuscript's strengths and
key revision priorities, include exactly: "consensus_reached: true"
- type: think
hint: |
You are the lead editor synthesizing the boardroom transcript into formal editorial notes.
Write a professional EDITORIAL REPORT for Shadow Heir (Book 1) covering:
## Editorial Report: Shadow Heir — Book 1
### Alpha Publishing | Lead Author: Iris
**OVERALL ASSESSMENT**
(1-2 paragraphs on the manuscript's readiness for Wattpad publication)
**STRENGTHS** (specific, with chapter references)
**REVISION PRIORITIES** (ranked 1–5, most critical first)
- For each: what the issue is, which chapters are affected, suggested fix
**CONTINUITY CHECK** (chapter-by-chapter handoff assessment)
**CHARACTER VOICE CONSISTENCY** (Elara vs Kai POV analysis)
**WATTPAD READINESS SCORE** (out of 10, with reasoning)
**RECOMMENDED NEXT STEPS** (in order of priority)
- type: document
filename: "{{task_name_slug}}"
- type: package
packet_type: IntakeResponse
hint: |
You are the Project Manager. The editorial report above lists REVISION PRIORITIES ranked 1–5.
Convert each revision priority into a sequential create_task action for Iris.
After all revision tasks, add ONE final task to compile the project index.
Rules for revision tasks:
- One action per revision priority (up to 5)
- task_name format: "Revise: [short issue name]" (e.g., "Revise: POV Handoff Bridges")
- agent_name: "Iris"
- task_type: "book_chapter"
- description: Include the specific issue, affected chapters, and suggested fix from the editorial report.
Start with: "EDITORIAL REVISION — [Priority N]: [issue]. Affected chapters: [chapters]. Fix: [fix]."
- depends_on: the exact task_name of the PREVIOUS revision task (empty string for the first revision)
Final task (always add this LAST):
- task_name: "Compile Project Index"
- agent_name: "Nova"
- task_type: "project_index"
- description: "Compile the final MANUSCRIPT-README.md index of all project deliverables, revisions, and publication status."
- depends_on: the exact task_name of the LAST revision task
schema:
actions:
- type: create_task
task_name: "string"
agent_name: "string"
task_type: "string"
description: "string"
depends_on: "string"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 65
deliverable_type: coordination
criteria:
specificity:
weight: 40
description: "Feedback references specific issues, not vague"
actionability:
weight: 35
description: "Suggestions are concrete and implementable"
coverage:
weight: 25
description: "All major aspects of the work are addressed"

190
templates/book_outline.yml Normal file
View File

@@ -0,0 +1,190 @@
name: book_outline
description: "Boardroom debate to lock the book concept, produce a character bible (for fiction) + full chapter outline, then spawn chapter writing tasks."
debug: true
system: agent_prompt
context_builders:
- markov_names
participant_prompt:
- "= identity.md"
agent_prompt:
- "= identity.md"
sections:
- agent
- project
- history
- rag
- deliverables
- participants
- participants_prompt
- message
- instructions
steps:
- type: think
rotate_participants: true
loop:
max_iterations: 4
hint: |
You are {agent.name}. This is round {task.iteration} of the creative boardroom.
GENRE: {genre_name} | AUDIENCE: {genre_audience}
STRUCTURE GUIDE: {outline_structure}
The room is deciding on ONE book concept to write. The trend research
is in the DELIVERABLES and RAG above — everyone has read it.
═══════════════════════════════════════════════
PRE-ASSIGNED CHARACTER NAMES (fiction projects — use these exactly)
═══════════════════════════════════════════════
These names were generated for this project. Do NOT substitute generic defaults
like Jax, Elara, Ryder, Quinn, Lyra, Knox, or Zane.
Protagonist: {protagonist_name}
Love interest: {love_interest_name}
Antagonist: {antagonist_name}
Supporting: {supporting_1}, {supporting_2}, {supporting_3}
Setting/Town: {place_name}
(Non-fiction projects: ignore the character names above — they are not applicable.)
═══════════════════════════════════════════════
From YOUR area of expertise, argue for (or against) a specific concept:
- Which of the research concepts has the strongest hook for this audience?
- What protagonist archetype will readers obsess over?
- What central conflict creates the best chapter-to-chapter tension?
- What's the opening chapter hook that makes a reader continue?
- What should the chapter length and structure be?
React to what prior speakers argued. Push back on weak ideas. Build on strong ones.
Be specific — no vague enthusiasm. Name the concept, argue WHY.
When the group has agreed on ONE specific concept (title, hook, protagonist, conflict, structure):
"consensus_reached: true"
- type: think
agent: first_available
hint: |
The boardroom has selected a concept. Synthesize all rounds above into a
COMPLETE BOOK OUTLINE document.
═══════════════════════════════════════════════
PART 1: CHARACTER BIBLE (fiction only — omit entirely for non-fiction)
═══════════════════════════════════════════════
If this is a fiction project, write a Character Bible FIRST:
# [Book Title] — Character Bible
## {protagonist_name}
- Age:
- Voice: [describe the internal narrative voice — e.g., "sardonic, first-person, teen"]
- Background: [2 sentences]
- Want: [what they think they want]
- Need: [what they actually need to grow]
- Fatal flaw: [the trait that creates conflict]
- Speech pattern: [how they talk — with examples]
## {love_interest_name}
- Age:
- Role in story:
- Why readers root for them:
- Dynamic with protagonist:
- Secret or wound they carry:
## {antagonist_name}
- Type: [person / institution / supernatural / internal]
- Motivation:
- How they challenge the protagonist:
## Supporting Characters
- {supporting_1}: [role and relationship to protagonist]
- {supporting_2}: [role and relationship to protagonist]
- {supporting_3}: [role and relationship to protagonist]
## World Rules (if paranormal/fantasy/speculative)
- [Powers, systems, constraints — be precise]
- [What limits them? What are the costs?]
═══════════════════════════════════════════════
PART 2: CHAPTER OUTLINE (all projects)
═══════════════════════════════════════════════
# [Book Title]
## Concept Summary
- Hook: one sentence that sells the book
- Genre: {genre_name}
- Protagonist: name, age, background, flaw, want vs need
- Antagonist / Central Conflict: what stands in their way
- Setting: world, time, atmosphere
- Format: target chapter length ~{chapter_target_words} words, POV (1st/3rd)
- Target audience: {genre_audience}
## Chapter Outline
For each chapter (target {chapter_count} chapters):
- Chapter N: [Title]
- Summary: 2–3 sentences of what happens
- Emotional beat: what the reader feels
- Hook / cliffhanger: how this chapter ends
## Voice & Tone Guide
Three sentences describing the narrative voice per the style guide below.
PROSE STYLE: {prose_style}
One example opening sentence.
## Publishing Notes
Why this book fits the genre and target audience.
- type: document
filename: "{{task_name_slug}}"
- type: package
packet_type: IntakeResponse
hint: |
You are the Project Manager. The outline above describes a multi-chapter book.
Convert EVERY chapter in the outline into a sequential create_task action for Iris.
Rules:
- One action per chapter (minimum {chapter_count} chapters)
- task_name format: "Write Chapter N: [Chapter Title]"
- agent_name: always "Iris"
- task_type: always "book_chapter"
- description: Include the chapter summary, POV character, emotional beat, and cliffhanger from the outline.
Start with: "You are writing Chapter N of [Book Title]. [chapter summary]. POV: [character name]."
- depends_on: the exact task_name of the PREVIOUS chapter (empty string for Chapter 1)
- chapter_ref: zero-padded two-digit chapter number, e.g. "ch-01", "ch-02", ... "ch-18"
The depends_on chain creates sequential writing — each chapter waits for the previous to be committed.
schema:
actions:
- type: create_task
task_name: "string"
agent_name: "string"
task_type: "string"
description: "string"
depends_on: "string"
context:
genre_name: "{genre_name}"
genre_audience: "{genre_audience}"
prose_style: "{prose_style}"
chapter_target_words: "{chapter_target_words}"
chapter_ref: "string"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 60
deliverable_type: coordination
criteria:
completeness:
weight: 40
description: "All required sections and elements present"
structure:
weight: 35
description: "Logical organization and hierarchy"
actionability:
weight: 25
description: "Clear enough for execution without guessing"

94
templates/book_research.yml Normal file
View File

@@ -0,0 +1,94 @@
name: book_research
description: "Research trends and context for a book — live search + synthesis + documented findings."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
sections:
- agent
- project
- history
- rag
- prior_results
- message
- instructions
builders:
prior_results: |
*** WEB SEARCH RESULTS ***
{steps[1].text}
(If the above is empty, use your expert training knowledge to answer this question.)
steps:
- type: think
hint: |
You are researching the current {genre_name} fiction landscape.
TARGET AUDIENCE: {genre_audience}
GENRE: {genre_name}
RESEARCH FOCUS: {research_focus}
Your mission: identify the single best search query to find what's TRENDING RIGHT NOW
in {genre_name} fiction in 2025–2026.
State your analysis, then on the last line write:
SEARCH QUERY: [your query here]
Query rules: 3–8 words. Specific.
- type: tool
capability: Tool_WebSearcher
input_from: last_text
- type: think
hint: |
You have live search results above (in PRIOR RESULTS).
If the web search results are empty or unavailable, use your expert training knowledge.
Synthesize the findings into an actionable publishing brief for a {genre_name} book:
1. TOP TRENDING — What sub-genres and themes are hot right now? Rank them.
2. AUDIENCE INSIGHTS — What does the target reader ({genre_audience}) demand?
3. STORY MECHANICS — What structural patterns are winning?
4. HOT TOPIC RECOMMENDATIONS — Give 3 distinct book concept seeds, each with:
- Working title
- Core hook (one sentence)
- Protagonist archetype
- Central conflict
- Why it will resonate now
5. COMPETITIVE GAPS — Where is the market undersupplied?
6. SOURCES — Key URLs or references.
- type: document
filename: "{{task_name_slug}}"
- type: spawn
task_type: book_outline
task_name: "Book Outline: {project.name}"
agent: Atlas
message: "{task.message}"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 65
deliverable_type: coordination
criteria:
accuracy:
weight: 35
description: "Facts are correct and verifiable"
thoroughness:
weight: 30
description: "Topic covered in sufficient depth"
source_quality:
weight: 20
description: "Sources are credible and relevant"
organization:
weight: 15
description: "Findings are well-structured"

68
templates/chapter_polish.yml Normal file
View File

@@ -0,0 +1,68 @@
name: chapter_polish
description: >
Iris polishes the chapter using the editorial consensus from the review roundtable.
debug: true
model: power
sections:
- agent
- project
- rag
- deliverables
- message
- instructions
steps:
- type: think
hint: |
You are Iris, a fiction author.
Genre: {genre_name} | Audience: {genre_audience}
Chapter: {task.message}
You have received a full editorial review from three editors.
EDITORIAL CONSENSUS:
{consensus_critique}
KEY CHANGES REQUESTED:
{key_changes}
Devon (Developmental): {devon_final}
Lane (Line Editor): {lane_final}
Cora (Continuity): {cora_final}
VERDICT: {chapter_verdict}
---
ORIGINAL CHAPTER:
{chapter_text}
---
Rewrite the chapter addressing all CONCERNS and KEY CHANGES from the editorial team.
Preserve everything the editors marked as STRENGTHS.
Do not add new plot elements not already present.
Match the genre tone and audience level throughout.
- type: document
filename: "{{task_name_slug}}-polished"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 90
deliverable_type: consumer
criteria:
prose_quality:
weight: 35
description: "Language is refined, no awkward phrasing"
consistency:
weight: 25
description: "Style and tone uniform throughout"
engagement:
weight: 25
description: "Text is compelling and polished"
formatting:
weight: 15
description: "Proper formatting, no artifacts"

53
templates/chapter_review.yml Normal file
View File

@@ -0,0 +1,53 @@
name: chapter_review
description: >
Independent chapter review. Agent reads the chapter and produces a structured
critique in their editorial domain.
debug: true
model: power
agent_prompt:
- system.md
sections:
- project
- rag
- message
- instructions
steps:
- type: think
max_tokens: 4000
hint: |
TARGET AUDIENCE: {genre_audience}
GENRE: {genre_name}
CHAPTER: {chapter_ref}
---
CHAPTER TEXT:
{chapter_text}
---
Write a detailed editorial review from your perspective.
Be specific — cite line numbers or quote passages where relevant.
Structure your review as:
1. STRENGTHS (what is working)
2. CONCERNS (what needs attention, in priority order)
3. VERDICT (pass / revise / rewrite — and why)
- type: reply
target: discussion
style: structured_review
adjudication:
enabled: true
pass_threshold: 65
deliverable_type: coordination
criteria:
specificity:
weight: 40
description: "Feedback references specific issues, not vague"
actionability:
weight: 35
description: "Suggestions are concrete and implementable"
coverage:
weight: 25
description: "All major aspects of the work are addressed"

91
templates/chapter_roundtable.yml Normal file
View File

@@ -0,0 +1,91 @@
name: chapter_roundtable
description: >
Three editors debate the chapter reviews in 2–3 structured rounds.
Each round, each editor responds to the others' most recent positions.
The output is a consensus critique (or documented disagreement) for the polish step.
debug: true
requires:
- chapter_text
- chapter_ref
- genre_name
- genre_audience
participants:
- Devon
- Lane
- Cora
iteration_limit: 3
convergence_signal: "CONSENSUS REACHED"
steps:
- type: think
rotate_participants: true
loop:
max_iterations: 3
hint: |
You are {agent.name}.
{agent.identity}
CHAPTER: {task.message}
GENRE: {genre_name} AUDIENCE: {genre_audience}
---
YOUR REVIEW:
{this_agent_review}
OTHER REVIEWS:
[Devon] {devon_review}
[Lane] {lane_review}
[Cora] {cora_review}
---
Round {task.iteration} of the editorial debate.
Respond to the other editors' most important points.
Where you agree, say so clearly. Where you disagree, argue your position
with evidence from the text. If you have changed your mind, say so.
If the group has reached sufficient consensus for the polish step,
end your response with: CONSENSUS REACHED
- type: package
schema:
consensus_critique: string
chapter_verdict: string
devon_final: string
lane_final: string
cora_final: string
key_changes: list
spawn:
- task_type: chapter_polish
task_name: "Polish: {chapter_ref}"
agent_name: Iris
context:
chapter_text: "{chapter_text}"
consensus_critique: "{consensus_critique}"
key_changes: "{key_changes}"
chapter_verdict: "{chapter_verdict}"
devon_final: "{devon_final}"
lane_final: "{lane_final}"
cora_final: "{cora_final}"
genre_name: "{genre_name}"
genre_audience: "{genre_audience}"
chapter_ref: "{chapter_ref}"
adjudication:
enabled: true
pass_threshold: 60
deliverable_type: coordination
criteria:
completeness:
weight: 40
description: "All viewpoints and concerns addressed"
consensus_clarity:
weight: 35
description: "Clear outcome or decision documented"
actionability:
weight: 25
description: "Next steps are concrete and assignable"

98
templates/planning.yml Normal file
View File

@@ -0,0 +1,98 @@
name: planning
description: "Rotating chair deliberation → structured work breakdown → child tasks created."
debug: true
system: agent_prompt
participant_prompt:
- "= identity.md"
agent_prompt:
- "= identity.md"
sections:
- agent
- project
- history
- rag
- participants
- participants_prompt
- roster
- message
- instructions
steps:
- type: think
rotate_participants: true
loop:
max_iterations: 3
hint: |
You are {agent.name}. This is round {task.iteration} of the planning session.
The group is breaking down this project or task into a concrete work plan.
Write YOUR perspective on the plan from your area of expertise:
- What work streams or tasks need to exist?
- What order do they need to happen in? What depends on what?
- Which agents from the TEAM ROSTER are best suited to each piece?
- What risks, gaps, or open questions do you see?
- What do you agree or disagree with from prior planning rounds above?
Reference these TASK TYPES when recommending work: research_plus, outline, draft, review, roundtable, polish, quick, writing, analysis, brainstorm, code.
Be specific about agent assignments — use EXACT names from the TEAM ROSTER.
ROUNDTABLE CHAIR RULE: For business strategy, planning, or operations roundtables, the chair
must be a business-register agent (Atlas, Selene, Devon, or Lane). Do NOT assign Cassius,
Lyra, or other fiction-specialist agents as chair for business deliverables — their creative
voice will contaminate formal strategy documents with genre-specific jargon.
When the group has genuinely agreed on a complete plan, include exactly:
"consensus_reached: true"
If the plan still has gaps or unresolved assignments, do NOT include that line.
- type: think
agent: first_available
hint: |
Structure the team's agreed plan into a precise task list.
IMPORTANT: Do NOT re-deliberate or reconsider what was agreed above.
Your only job in this step is to serialize the decisions into clean task records.
For each task:
- task_name: short, specific
- description: full detail — enough that the assigned agent can execute without asking
- agents: EXACT name(s) from TEAM ROSTER
- task_type: one of the valid task types listed below
- priority: 1 (critical) to 5 (nice-to-have)
Order tasks correctly — blockers before dependents.
No ambiguous assignments. No placeholder names.
VALID TASK TYPES (use ONLY these exact strings):
research_plus — deep research on a topic
outline — structure or plan for a piece of content
draft — write a complete draft of content
review — critique and give feedback on content
roundtable — multi-voice deliberation for consensus
polish — final editing and refinement
quick — short single-step response
writing — general writing task
planning — sub-planning session
analysis — data or situation analysis
brainstorm — open ideation session
code — software development task
CANONICAL SELECTION RULE: If the plan produces multiple competing drafts of the
same artifact (e.g. three mission statement drafts, two roadmap versions), the plan
MUST include a final "Select Canonical: [artifact]" polish task assigned to Iris or
Atlas that explicitly picks one version, merges the best elements, and archives the
rest. Do NOT leave competing versions unresolved.
DECOMPOSITION RULE: When the deliverable is a batch of similar items (e.g. 10 podcast
scripts, 5 chapters, 8 articles), create ONE individual draft task per item — NOT a
single "write all 10" batch task. A single LLM call cannot produce 10 full-length
scripts. Each episode/chapter/article must be its own task with its own specific
description. The review and polish tasks can still be batched at the end.
- type: package
packet_type: PlanningResponsePacket
schema:
tasks:
- task_name: "string — short descriptive name"
description: "string — full instructions for the assigned agent"
agents:
- "string — EXACT agent name from TEAM ROSTER"
task_type: "string — MUST be a template name from AVAILABLE TASK TEMPLATES"
priority: "integer 1 (critical) to 5 (nice-to-have)"
insert_children: true
- type: close
rag_update: false
adjudication:
enabled: false

93
templates/project_index.yml Normal file
View File

@@ -0,0 +1,93 @@
name: project_index
description: "Compiles a master MANUSCRIPT-README.md index of all project deliverables, revisions, and publication status."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
sections:
- agent
- project
- deliverables
- message
- instructions
steps:
- type: think
hint: |
You are {agent.name}. Compile a comprehensive MANUSCRIPT-README.md for this project.
Look at the PROJECT DELIVERABLES section above — it lists every file committed during this project.
Write a well-structured README that includes:
## [Book Title] — Book 1
**[Company Name] | Author: [Lead Author] | Creative Director: [Creative Director]**
> [Opening hook line from Chapter 1]
Brief pitch (2-3 sentences about the book's concept, genre, and Wattpad appeal).
---
## Publication Status
[Based on the editorial report in deliverables — GO / NO-GO verdict, score if available, date]
---
## Reading Order
A table with columns: Chapter Number | Chapter Title | POV | File
(Pull from the final-chapter-*.md files in deliverables)
---
## Chapter Continuity Chain
A table showing how each chapter connects to the next:
Transition | Previous chapter ends... | Next chapter opens...
(Pull quotes from the actual chapter files)
---
## Revisions Applied
If any revise-*.md files exist in deliverables, list them with what was revised.
---
## Research & Planning Documents
List all non-chapter deliverables (outline, trend report, editorial report, launch strategy, etc.)
---
## Team
A table of agents, roles, and contributions based on the project context.
---
## Iteration History
If earlier draft files exist (write-chapter-*, rewrite-chapter-*, etc.), note them briefly.
---
*Generated by [Company Name] AI team | PAE Multi-Agent System*
- type: document
filename: "MANUSCRIPT-README"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 65
deliverable_type: coordination
criteria:
completeness:
weight: 45
description: "All project deliverables are catalogued"
accuracy:
weight: 35
description: "Details about deliverables and team are correct"
structure:
weight: 20
description: "Index is well-organized and navigable"

27
templates/quick.yml Normal file
View File

@@ -0,0 +1,27 @@
name: quick
description: "Single-pass execution. No review, no planning. Fastest possible response."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
sections:
- agent
- project
- history
- rag
- message
- instructions
steps:
- type: think
hint: |
Execute the assigned task directly and concisely.
Produce your best output in one pass — no preamble, no self-commentary.
Be specific and actionable.
- type: close
rag_update: false
adjudication:
enabled: false

97
templates/recipe_collection_plan.yml Normal file
View File

@@ -0,0 +1,97 @@
name: recipe_collection_plan
description: "Plan a themed recipe collection and spawn individual recipe_develop tasks for Iris."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
sections:
- agent
- project
- history
- rag
- deliverables
- message
- instructions
steps:
- type: think
hint: |
You are planning a recipe collection for the project described above.
Read the project description and current message to understand the collection theme,
cuisine type, target audience, and any constraints.
Design a COMPLETE COLLECTION PLAN. Structure it as:
## Collection Title
[A compelling, specific title for the full collection]
## Collection Brief
[2–3 sentences: who this is for, what culinary territory it covers, what makes it distinct]
## Recipes
For each recipe (aim for 8–12 recipes per collection unless specified otherwise):
### [Recipe N]: [Recipe Name]
- **Concept**: One sentence on the dish — what it is and why it belongs in this collection
- **Unique angle**: What makes this version special (technique, ingredient, twist)
- **Difficulty**: Easy / Medium / Hard
- **Occasion**: When would someone cook this?
- **Brief for Iris**: 2–3 sentences describing exactly what to develop. Include any
specific requirements (e.g., "must be vegan", "uses [key ingredient]", "under 30 minutes").
Ensure variety across:
- Difficulty levels (mix of easy, medium, and one or two harder recipes)
- Meal types (appetizers, mains, sides, desserts if appropriate)
- Time commitment (some quick, some weekend projects)
- Dietary options (include at least one vegetarian or vegan option)
- type: document
filename: "{{task_name_slug}}-collection-plan"
- type: package
packet_type: IntakeResponse
hint: |
Convert every recipe from the collection plan above into a create_task action for Iris.
RULES:
- One action per recipe
- task_name: "Develop Recipe N: [Recipe Name]" where N is 1, 2, 3...
- agent_name: "Iris"
- task_type: "recipe_develop"
- description: Full brief for this recipe. Start with:
"You are developing Recipe N: [Recipe Name] for the [Collection Title] collection.
[Concept]. [Unique angle]. [Occasion].
[The full 'Brief for Iris' text from the plan above.]"
- depends_on: "" (all recipes can be developed in parallel)
Produce one action per recipe. No prose.
schema:
actions:
- type: create_task
task_name: "string"
agent_name: "string"
task_type: "recipe_develop"
description: "string"
depends_on: "string"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 65
deliverable_type: coordination
criteria:
completeness:
weight: 40
description: "All recipes fully defined with clear briefs for execution"
variety:
weight: 35
description: "Collection has good range across difficulty, meal type, and dietary options"
coherence:
weight: 25
description: "Recipes feel like a unified collection with a clear culinary identity"

102
templates/recipe_develop.yml Normal file
View File

@@ -0,0 +1,102 @@
name: recipe_develop
description: "Develop one recipe — concept, headnote, ingredients, method, and variations."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
sections:
- agent
- project
- history
- rag
- deliverables
- message
- rejection_feedback
- instructions
steps:
- type: think
max_tokens: 4000
hint: |
Your task message describes the recipe to develop.
Develop the complete recipe in this exact structure:
# [Recipe Title]
*[One-line descriptor — e.g. "A cozy weeknight pasta with crispy capers and lemon."]
## Headnote
2–4 sentences that tell the story: why this recipe exists, what makes it special,
and one practical tip the cook should know before they start. Sound like a friend
who has made this dish many times. Personal, warm, specific.
**Prep time:** [X] minutes
**Cook time:** [X] minutes
**Total time:** [X] minutes
**Yield:** [X servings]
**Difficulty:** Easy / Medium / Hard
## Ingredients
List in order of use. Use standard measurements (cups, tbsp, tsp, oz, g).
Group into sections (e.g., For the sauce, For the base) if needed.
- [quantity] [ingredient], [preparation note if needed]
## Method
Numbered steps. Each step is one distinct action. Short sentences.
No step should contain more than two actions. Include temperature, timing,
and sensory cues (e.g., "until golden and fragrant, about 3 minutes").
## Variations
Provide 2–3 variations:
- **Make it vegan/vegetarian**: ...
- **Make it gluten-free**: ...
- **Swap for [seasonal/budget alternative]**: ...
## Storage & Reheating
One short paragraph.
## Pairing Suggestion (optional)
One sentence if appropriate (wine, side dish, occasion).
- type: think
model: power
hint: |
Review the recipe critically as a professional recipe developer and editor:
- Is the headnote specific and personal, not generic?
- Are the ingredient quantities realistic and consistent throughout?
- Are the method steps truly one-action-per-step?
- Do the sensory cues (color, smell, texture) help a home cook know when to proceed?
- Are the variations genuinely useful and clearly explained?
- Is the title specific and appetizing (not "Easy Pasta" — be evocative)?
- Is the format clean and scannable?
Rewrite the COMPLETE final recipe incorporating all improvements.
Output ONLY the polished recipe starting with # [Recipe Title]. No commentary.
- type: document
filename: "{{task_name_slug}}"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 80
deliverable_type: consumer
criteria:
completeness:
weight: 30
description: "All required sections present: headnote, ingredients, method, variations"
clarity:
weight: 30
description: "Instructions are unambiguous and executable by a home cook"
voice:
weight: 25
description: "Headnote is warm, personal, and specific — not generic"
precision:
weight: 15
description: "Measurements, times, and sensory cues are accurate and consistent"

97
templates/short_story.yml Normal file
View File

@@ -0,0 +1,97 @@
name: short_story
description: "Write a complete short story — plan, draft, deepen, deliver."
debug: true
system: agent_prompt
agent_prompt:
- "= identity.md"
- "agent.rag.json"
requires:
- genre_name
- genre_audience
- prose_style
sections:
- agent
- project
- history
- rag
- deliverables
- message
- rejection_feedback
- instructions
steps:
- type: think
hint: |
PASS 0 — STORY PLAN (do this before drafting)
GENRE: {genre_name} | AUDIENCE: {genre_audience}
PROSE STYLE: {prose_style}
TARGET LENGTH: 3,000–15,000 words (short story to novelette)
Before writing, plan the story:
TITLE: [Working title]
HOOK: [The first sentence or image that pulls the reader in]
PREMISE: [One sentence — the "what if" or core situation]
PROTAGONIST: [Name, age, voice, fatal flaw, want vs need]
ANTAGONIST / OBSTACLE: [What opposes the protagonist — person, force, or internal]
OPENING: [Where does the story begin? What is the first scene?]
MIDPOINT: [The moment everything changes]
CLIMAX: [The highest point of tension — how it comes to a head]
RESOLUTION: [How it ends — what has changed for the protagonist]
EMOTIONAL CORE: [What does this story make the reader FEEL?]
POINT OF VIEW: [1st / 3rd limited / 3rd omniscient]
TENSE: [Past / present]
Now write the complete first draft.
Follow the prose style guide. Stay in chosen POV throughout.
Show — don't tell. Use dialogue. Use sensory detail.
End with purpose: the final line should feel earned and resonant.
- type: think
model: power
hint: |
PASS 2 — DEEPEN & SHARPEN
Read your draft critically through an editor's eyes:
- Does the opening line hook the reader immediately?
- Is every scene earning its place in the story?
- Are there any "telling" passages that should be "showing"?
- Is the protagonist's want vs need clearly felt (not stated) by the end?
- Is the dialogue tight, voice-distinct, and advancing the story?
- Does the pacing serve the emotional arc? (Slow the key moments. Cut the connective tissue.)
- Is the final line earned and resonant — not a summary?
- Is the prose consistent with the style guide?
- Is the total length appropriate for the story being told?
Rewrite the COMPLETE final story incorporating all improvements.
Output ONLY the polished story starting with the title as # [Title].
No commentary, no "Pass 2" label, no preamble.
- type: document
filename: "{{task_name_slug}}"
- type: close
rag_update: true
adjudication:
enabled: true
pass_threshold: 82
deliverable_type: consumer
criteria:
narrative_arc:
weight: 30
description: "Story has a clear beginning, midpoint, and earned resolution"
prose_quality:
weight: 30
description: "Writing is vivid, specific, and polished throughout"
character:
weight: 25
description: "Protagonist has a distinct voice and undergoes real change"
opening_and_closing:
weight: 15
description: "First and last lines are memorable and purposeful"