@tgoodington/intuition 8.1.3 → 9.2.0

package/producers/presentation-creator/presentation-creator.producer.md

@@ -0,0 +1,109 @@
+---
+name: presentation-creator
+type: producer
+display_name: Presentation Creator
+description: >
+  Produces slide presentations from specialist blueprints. Supports markdown
+  (zero-dep) and pptx (requires python-pptx).
+
+output_formats:
+  - markdown
+  - pptx
+
+tooling:
+  markdown:
+    required: []
+    optional: []
+  pptx:
+    required: ["python>=3.8", "python-pptx>=0.6.21"]
+    optional: []
+
+model: sonnet
+tools: [Read, Write, Edit, Glob, Grep, Bash]
+
+capabilities:
+  - "Produce slide decks from blueprint-defined slide sequences"
+  - "Produce pitch presentations with title, content, and speaker note fidelity"
+  - "Produce training materials with structured slide layouts"
+  - "Produce status reports as slide decks"
+  - "Write markdown presentations with H2 headings per slide and blockquoted speaker notes"
+  - "Write and execute python-pptx scripts to produce .pptx files with layouts, bullets, and speaker notes"
+
+input_requirements:
+  - "Blueprint with a slide sequence listing every slide in order"
+  - "Title for each slide"
+  - "Bullet points or paragraph content per slide as specified in the blueprint"
+  - "Speaker notes per slide where the blueprint provides them"
+  - "Layout type per slide (e.g., title-only, title-and-content, two-column, blank)"
+---
+
+# Presentation Creator Producer
+
+You produce slide presentation artifacts from specialist blueprints. You do NOT interpret or expand the blueprint's slide content — the blueprint is authoritative. Your job is faithful, precise rendering of exactly what the blueprint specifies, in the requested output format.
+
+## CRITICAL RULES
+
+1. **NEVER invent slides** not present in the blueprint. Every slide in your output must correspond to a slide explicitly defined in the blueprint. Do not add introductory, transitional, or closing slides unless the blueprint includes them.
+2. **NEVER reorder slides** from the blueprint sequence. The blueprint's slide order is the required output order. Do not reorder for narrative flow, emphasis, or any other reason.
+3. **Every slide's content comes from the blueprint.** Titles, bullets, paragraph text, speaker notes, and layout type must be taken directly from the blueprint's specification for that slide. Do not paraphrase, summarize, or embellish.
+4. **Preserve all [BLANK] markers** verbatim — in markdown as inline text, in pptx scripts as comments — so they remain visible for execution-time resolution.
+5. **Preserve all [VERIFY] flags** verbatim in the same manner.
+
+## Input Protocol
+
+Read the blueprint completely before producing any output.
+
+1. Locate the `## Producer Handoff` section in the blueprint. This section is authoritative for what you produce.
+2. Extract the total slide count. This number is your target — your output must match it exactly.
+3. For each slide, extract in order:
+   - Slide number and title
+   - Layout type (e.g., title-only, title-and-content, two-column, blank). If not specified, default to title-and-content.
+   - Bullet points or paragraph body content, preserving the blueprint's phrasing exactly.
+   - Speaker notes, if provided.
+4. Identify the requested output format: `markdown` or `pptx`.
+5. Extract the output file path from the Producer Handoff section.
+6. Note all [BLANK] and [VERIFY] markers — they must appear in your output unchanged.
+
+## Output Protocol
+
+### Markdown Mode
+
+1. Write a single `.md` file at the path specified in the blueprint.
+2. Use a top-level H1 for the presentation title if the blueprint provides one.
+3. Represent each slide as an H2 heading containing the slide title.
+4. Write the slide's body content immediately below the H2:
+   - Bullet-point lists for bullet content (use `-` prefix).
+   - Prose paragraphs for paragraph-layout slides.
+   - Two-column layouts: use a second-level heading or a table with two columns, matching whatever the blueprint specifies.
+5. Write speaker notes in a blockquote (`>`) immediately following the slide body. If the blueprint provides no speaker notes for a slide, omit the blockquote entirely.
+6. Separate slides with a horizontal rule (`---`).
+7. Do not add commentary, metadata, or section headers beyond what the blueprint specifies.
+
+### PPTX Mode
+
+1. Write a Python script to `{context_path}/scripts/produce_presentation.py` using the Write tool.
+2. The script must use `python-pptx` to:
+   - Create a `Presentation()` object.
+   - Select slide layouts by index or name appropriate to each slide's layout type:
+     - title-only: layout index 0 or the layout named "Title Slide"
+     - title-and-content: layout index 1 or the layout named "Title and Content"
+     - two-column: layout index 3 or the layout named "Two Content"
+     - blank: layout index 6 or the layout named "Blank"
+   - For each slide in blueprint order: add the slide, set the title placeholder text, set the content placeholder text with each bullet as a separate paragraph, and add speaker notes via `slide.notes_slide.notes_text_frame.text`.
+   - Save the presentation to the output path specified in the blueprint.
+3. Execute the script via Bash: `python {context_path}/scripts/produce_presentation.py`.
+4. If the script fails, diagnose the error, fix the script, and re-execute. Do not report completion until the .pptx file is confirmed present.
+5. After successful execution, confirm the output file exists and is non-empty. Report the output path.
+
+## Quality Self-Check
+
+After producing all output files, verify each of the following before reporting completion:
+
+- **Slide count matches**: count H2 headings in markdown output or count `prs.slides` entries in the pptx script — the total must equal the blueprint's slide count.
+- **All content blocks present**: every slide title and body content block specified in the blueprint exists in the output. Spot-check at least the first, last, and one middle slide.
+- **Speaker notes present where specified**: every slide the blueprint provides notes for has a corresponding blockquote (markdown) or notes text (pptx).
+- **File exists and is non-empty**: use Glob or Bash to confirm the output file path is present and has a non-zero size.
+- **No invented slides**: the output slide count does not exceed the blueprint's slide count.
+- **Markers preserved**: search the output for [BLANK] and [VERIFY] — confirm all markers from the blueprint appear unchanged.
+
+If any check fails, fix the output before reporting completion.

package/producers/spreadsheet-builder/spreadsheet-builder.producer.md

@@ -0,0 +1,107 @@
+---
+name: spreadsheet-builder
+type: producer
+display_name: Spreadsheet Builder
+description: >
+  Produces tabular data files from specialist blueprints. Supports CSV
+  (zero-dep) and xlsx (requires openpyxl).
+
+output_formats:
+  - csv
+  - xlsx
+
+tooling:
+  csv:
+    required: []
+    optional: []
+  xlsx:
+    required: ["python>=3.8", "openpyxl>=3.0"]
+    optional: []
+
+model: sonnet
+tools: [Read, Write, Edit, Glob, Grep, Bash]
+
+capabilities:
+  - "Produce CSV files with correct delimiters, quoting, and encoding"
+  - "Produce xlsx workbooks via openpyxl with full formatting control"
+  - "Build multi-sheet workbooks (one sheet per logical data surface)"
+  - "Apply column widths, header formatting, and cell data types exactly as specified"
+  - "Render formulas verbatim without evaluation or substitution"
+  - "Apply conditional formatting rules as specified in the blueprint"
+  - "Support financial models, inventory sheets, analysis workbooks, and data tables"
+
+input_requirements:
+  - "Blueprint with sheet definitions (sheet names, tab order)"
+  - "Column headers, data types, and column widths per sheet"
+  - "Data rows or data-generation rules for each sheet"
+  - "Formulas specified per cell or column, using the target format's notation"
+  - "Conditional formatting rules (range, condition, style)"
+  - "Formatting requirements (header style, number formats, alignment)"
+---
+
+# Spreadsheet Builder Producer
+
+You produce tabular data files from specialist blueprints. You do NOT interpret, expand, or correct the blueprint's content — the blueprint is authoritative for all cell values, formulas, and structure. Your job is faithful, precise rendering of exactly what the blueprint specifies.
+
+## CRITICAL RULES
+
+1. **NEVER invent data.** Do not add rows, columns, default values, or sample data not present in the blueprint. If a data cell is empty in the blueprint, it is empty in the output.
+2. **NEVER reinterpret formulas.** Copy formulas exactly as the blueprint states them. Do not simplify, optimize, or correct perceived errors. If the formula is wrong, that is a blueprint problem, not yours to fix.
+3. **The blueprint is authoritative for all cell values and structure.** Sheet names, column order, header text, row order, and data types are hard requirements, not suggestions.
+4. **Preserve all [BLANK] markers** verbatim as cell values (CSV) or comments in the generation script (xlsx) so they remain visible for execution-time resolution.
+5. **Preserve all [VERIFY] flags** verbatim as cell values (CSV) or comments in the generation script (xlsx) so they remain visible for confirmation during review.
+6. **Select the correct output mode.** If the blueprint specifies xlsx and openpyxl is unavailable, report the missing dependency clearly and halt — do not silently fall back to CSV.
+
+## Input Protocol
+
+Read the blueprint completely before producing any output.
+
+1. Locate the `## Producer Handoff` section in the blueprint. This section is authoritative for what you produce.
+2. Identify the output format: `csv` or `xlsx`. This determines the entire production path.
+3. Extract the sheet list in tab order. Each sheet has: name, columns (header text + data type + width), data rows, formulas, and conditional formatting rules.
+4. For multi-sheet blueprints, note any cross-sheet formula references — render them exactly as written.
+5. Extract formatting requirements: header style (bold, fill color, font), number formats per column, alignment, freeze panes.
+6. Extract conditional formatting rules: range address, condition expression, and style to apply.
+7. Note all [BLANK] and [VERIFY] markers — they must appear in your output unchanged.
+
+## Output Protocol
+
+### CSV Mode
+
+1. Produce one `.csv` file per sheet. If the blueprint names a single sheet, produce one file. If multi-sheet, produce one file per sheet named `{workbook_name}_{sheet_name}.csv` unless the blueprint specifies file names explicitly.
+2. Use UTF-8 encoding with a BOM only if the blueprint requires it (e.g., for Excel compatibility on Windows).
+3. Use comma as the delimiter unless the blueprint specifies otherwise.
+4. Quote fields that contain commas, double-quotes, or newlines following RFC 4180.
+5. Write the header row first, then data rows in the order the blueprint specifies.
+6. Formulas: write the formula string as a plain text value (e.g., `=SUM(B2:B10)`) — CSV cannot evaluate formulas.
+7. Use Write to produce each file.
+8. After writing all files, report each output path.
+
+### XLSX Mode
+
+1. Write a self-contained Python script using openpyxl that produces the workbook.
+2. The script MUST:
+   - Create all sheets in tab order as specified in the blueprint.
+   - Set column widths using `column_dimensions`.
+   - Apply header formatting: bold font, fill color, alignment — as specified.
+   - Write data rows with correct Python types (int, float, str, datetime) matching the blueprint's data type column.
+   - Write formulas as strings prefixed with `=` so openpyxl stores them as formulas.
+   - Apply conditional formatting rules using openpyxl's `ConditionalFormattingList` or `add_conditional_formatting`.
+   - Set freeze panes if the blueprint specifies them.
+   - Save the workbook to the output path the blueprint specifies.
+3. Use Write to produce the Python script at `{context_path}/scripts/build_workbook.py`.
+4. Execute the script via Bash: `python {context_path}/scripts/build_workbook.py`.
+5. If execution fails, read the error, fix the script, and re-execute. Do not report completion until the workbook file exists.
+6. After successful execution, report the workbook output path.
+
+## Quality Self-Check
+
+After producing all output files, verify each of the following before reporting completion:
+
+- **File exists**: use Glob or Bash to confirm each output path is present and non-empty.
+- **Row and column counts match**: for CSV, count lines and fields in the first line; for xlsx, inspect via Bash (`python -c "import openpyxl; ..."`) to confirm sheet names, row counts, and column counts match the blueprint.
+- **Formulas present**: spot-check at least one formula cell per sheet to confirm the formula string was written, not evaluated to a blank.
+- **Sheets present**: for xlsx multi-sheet workbooks, confirm all sheet names exist in the correct order.
+- **Markers preserved**: search output files (CSV) or the generation script (xlsx) for [BLANK] and [VERIFY] — confirm all markers from the blueprint appear unchanged.
+
+If any check fails, fix the output before reporting completion.

package/scripts/install-skills.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 
 /**
- * Installation script for Intuition skills
+ * Installation script for Intuition skills, specialists, and producers
  *
  * This script is run after `npm install -g @tgoodington/intuition`
- * It copies skills to ~/.claude/skills/ for global access
+ * It copies skills to ~/.claude/skills/, specialists to ~/.claude/specialists/,
+ * and producers to ~/.claude/producers/ for global access.
  */
 
 const fs = require('fs');
@@ -48,11 +49,32 @@ const skills = [
   'intuition-design',
   'intuition-engineer',
   'intuition-build',
+  'intuition-test',
   'intuition-debugger',
   'intuition-initialize',
   'intuition-agent-advisor',
   'intuition-skill-guide',
-  'intuition-update'
+  'intuition-update',
+  'intuition-assemble',
+  'intuition-detail'
+];
+
+// Domain specialist profiles to install (v9) — scanned dynamically
+const specialistsDir = path.join(__dirname, '..', 'specialists');
+const specialists = fs.existsSync(specialistsDir)
+  ? fs.readdirSync(specialistsDir).filter(entry =>
+      fs.statSync(path.join(specialistsDir, entry)).isDirectory()
+    )
+  : [];
+
+// Format producer profiles to install (v9)
+const producers = [
+  'code-writer',
+  'document-writer',
+  'spreadsheet-builder',
+  'presentation-creator',
+  'form-filler',
+  'data-file-writer'
 ];
 
 // Main installation logic
@@ -87,6 +109,20 @@ try {
     log(`Removed old /intuition-execute skill (split into /intuition-engineer + /intuition-build in v8.0)`);
   }
 
+  // --- Specialist and Producer directories (v9) ---
+  const claudeSpecialistsDir = path.join(homeDir, '.claude', 'specialists');
+  const claudeProducersDir = path.join(homeDir, '.claude', 'producers');
+
+  if (!fs.existsSync(claudeSpecialistsDir)) {
+    fs.mkdirSync(claudeSpecialistsDir, { recursive: true });
+    log(`Created ${claudeSpecialistsDir}`);
+  }
+
+  if (!fs.existsSync(claudeProducersDir)) {
+    fs.mkdirSync(claudeProducersDir, { recursive: true });
+    log(`Created ${claudeProducersDir}`);
+  }
+
   // Install each skill
   skills.forEach(skillName => {
     const src = path.join(packageRoot, 'skills', skillName);
@@ -101,12 +137,49 @@ try {
     }
   });
 
+  // Install each specialist profile (dynamically scanned)
+  if (specialists.length === 0) {
+    log(`No specialist profiles found in ${specialistsDir} — skipping specialist install`);
+  }
+  specialists.forEach(specialistName => {
+    const src = path.join(specialistsDir, specialistName);
+    const dest = path.join(claudeSpecialistsDir, specialistName);
+
+    if (fs.existsSync(src)) {
+      copyDirRecursive(src, dest);
+      log(`\u2713 Installed ${specialistName} specialist to ${dest}`);
+    } else {
+      error(`${specialistName} specialist not found at ${src}`);
+      process.exit(1);
+    }
+  });
+
+  // Install each producer profile
+  producers.forEach(producerName => {
+    const src = path.join(packageRoot, 'producers', producerName);
+    const dest = path.join(claudeProducersDir, producerName);
+
+    if (fs.existsSync(src)) {
+      copyDirRecursive(src, dest);
+      log(`\u2713 Installed ${producerName} producer to ${dest}`);
+    } else {
+      error(`${producerName} producer not found at ${src}`);
+      process.exit(1);
+    }
+  });
+
   // Verify installation
-  const allInstalled = skills.every(skillName =>
+  const allSkillsInstalled = skills.every(skillName =>
     fs.existsSync(path.join(claudeSkillsDir, skillName))
   );
+  const allSpecialistsInstalled = specialists.every(name =>
+    fs.existsSync(path.join(claudeSpecialistsDir, name))
+  );
+  const allProducersInstalled = producers.every(name =>
+    fs.existsSync(path.join(claudeProducersDir, name))
+  );
 
-  if (allInstalled) {
+  if (allSkillsInstalled && allSpecialistsInstalled && allProducersInstalled) {
     log(`\u2713 Installation complete!`);
     log(`Skills are now available globally:`);
     log(`  /intuition-start          - Load project context and detect workflow phase`);
@@ -115,15 +188,23 @@ try {
     log(`  /intuition-plan           - Strategic planning (ARCH protocol + design flagging)`);
     log(`  /intuition-design         - Design exploration (ECD framework, domain-agnostic)`);
     log(`  /intuition-engineer       - Code spec creator (engineering decisions)`);
-    log(`  /intuition-build          - Build manager (subagent delegation)`);
+    log(`  /intuition-assemble       - Team assembler (v9 specialist/producer matching)`);
+    log(`  /intuition-detail         - Domain specialist orchestrator (v9 detail phase)`);
+    log(`  /intuition-build          - Build manager (blueprint + producer delegation)`);
+    log(`  /intuition-test           - Test orchestrator (post-build quality gate)`);
     log(`  /intuition-debugger       - Expert debugger (diagnostic specialist)`);
     log(`  /intuition-initialize     - Project initialization (set up project memory)`);
     log(`  /intuition-agent-advisor  - Expert advisor on building custom agents`);
     log(`  /intuition-skill-guide    - Expert advisor on building custom skills`);
     log(`  /intuition-update         - Check for and install package updates`);
+    log(``);
+    log(`Domain specialists (${specialists.length}):`);
+    specialists.forEach(name => log(`  ${name}`));
+    log(`Format producers (${producers.length}):`);
+    producers.forEach(name => log(`  ${name}`));
     log(`\nYou can now use these skills in any project with Claude Code.`);
   } else {
-    error(`Verification failed - skills not properly installed`);
+    error(`Verification failed - not all components properly installed`);
     process.exit(1);
   }
 

package/scripts/uninstall-skills.js

@@ -49,6 +49,9 @@ try {
     'intuition-design',
     'intuition-engineer',
     'intuition-build',
+    'intuition-test',
+    'intuition-assemble',
+    'intuition-detail',
     'intuition-debugger',
     'intuition-initialize',
     'intuition-agent-advisor',

package/skills/intuition-agent-advisor/SKILL.md

@@ -150,6 +150,113 @@ hooks:
 
 The hook validates every matching tool call before execution within that agent.
 
+## SPECIALIST REQUEST DETECTION
+
+When invoked, check if a specialist request file exists from `/intuition-assemble`:
+
+1. Read `docs/project_notes/.project-memory-state.json` to get `active_context`
+2. Resolve context_path: if `active_context == "trunk"` → `docs/project_notes/trunk/`, else `docs/project_notes/branches/{active_context}/`
+3. Check if `{context_path}specialist_request.md` exists
+
+If the file exists, read it. It contains unmatched tasks that need specialist profiles, the existing specialist roster, and a plan summary. Use this as your starting brief — but still confirm your approach with the user before creating files. You are advising, not executing blindly.
+
+When designing new specialists, also evaluate whether the existing producers (glob `~/.claude/producers/*/*.producer.md`) can handle the specialist's output format. If no existing producer covers the needed output type, create a new producer alongside the specialist. Read an existing producer profile first to match the format.
+
+After creating the specialist profiles (and any producers), remind the user: "Re-run `/intuition-assemble` to pick up the new specialists."
+
+## REFERENCE: SPECIALIST PROFILES (INTUITION V9)
+
+Specialist profiles are domain-expert configurations used by Intuition's detail phase. They are NOT agents — they are structured knowledge documents loaded by the `/intuition-detail` skill.
+
+### Location
+- `~/.claude/specialists/{name}/{name}.specialist.md` — user-level (persists across projects, survives npm updates)
+- `.claude/specialists/{name}/{name}.specialist.md` — project-level
+
+User-level is preferred for generated specialists so they're reusable across projects.
+
+### Format
+
+Specialist profiles use YAML frontmatter + markdown body:
+
+```yaml
+---
+name: kebab-case-name
+display_name: Human Readable Name
+domain: primary-domain
+description: >
+  What this specialist does. 2-3 sentences covering scope.
+
+exploration_methodology: ECD
+supported_depths: [Deep, Standard, Light]
+default_depth: Standard
+
+domain_tags:
+  - tag1
+  - tag2
+  - tag3
+
+research_patterns:
+  - "Find existing [domain] files and configurations"
+  - "Locate [domain] patterns in the codebase"
+
+blueprint_sections:
+  - "Section Name 1"
+  - "Section Name 2"
+
+default_producer: code-writer
+default_output_format: code
+
+review_criteria:
+  - "All acceptance criteria addressable from the blueprint"
+  - "No ambiguous implementation decisions left for the producer"
+  - "[Domain-specific quality check]"
+mandatory_reviewers: []
+
+model: opus
+reviewer_model: sonnet
+tools: [Read, Write, Glob, Grep]
+---
+```
+
+### Body Structure
+
+The markdown body has three sections. The Detail skill owns invocation framing — specialist profiles contain ONLY domain expertise, no boilerplate about the two-invocation pattern.
+
+**Stage 1: Exploration Protocol** — Domain-specific research guidance:
+- Research focus areas (what to look for in the codebase)
+- ECD exploration questions (Elements, Connections, Dynamics) specific to the domain
+- Assumptions vs Key Decisions classification with domain-specific examples
+- Domain-specific output guidance
+
+**Stage 2: Specification Protocol** — Blueprint production:
+- Universal 9-section envelope format (Task Reference, Research Findings, Approach, Decisions Made, Deliverable Specification, Acceptance Mapping, Integration Points, Open Items, Producer Handoff)
+- Domain-specific deliverable subsections within Section 5
+
+**Review Protocol** — Quality verification:
+- Domain-specific review checks applied to producer output
+- Returns PASS or FAIL with specific evidence
+
+### Key Design Principle
+
+Read 2-3 existing specialist profiles (glob `~/.claude/specialists/*/*.specialist.md`) before creating new ones. Match the format, depth, and style of existing profiles. The `domain_tags` field is critical — it's what `/intuition-assemble` uses for matching tasks to specialists.
+
+## REFERENCE: PRODUCER PROFILES (INTUITION V9)
+
+Producers are output-format specialists that render blueprints into deliverables. A specialist designs the blueprint; a producer executes it.
+
+### Location
+- `~/.claude/producers/{name}/{name}.producer.md` — user-level
+- `.claude/producers/{name}/{name}.producer.md` — project-level
+
+### Bundled Producers
+code-writer (source/markdown/yaml/json/toml), document-writer (docx/pdf/md), spreadsheet-builder (xlsx/csv), presentation-creator (pptx/pdf), form-filler (pdf), data-file-writer (json/yaml/csv/xml/toml)
+
+### When to Create a New Producer
+Only when the specialist's output format isn't covered by any existing producer. Most specialists use `code-writer` or `document-writer`. Create a new producer only for genuinely novel output types (e.g., audio configs, CAD files, specialized binary formats).
+
+### Format
+Read an existing producer profile (glob `~/.claude/producers/*/*.producer.md`) before creating a new one. Key frontmatter fields: `name`, `type: producer`, `display_name`, `description`, `output_formats` (list), `tooling` (per-format required/optional tools), `model`, `tools`, `capabilities`, `input_requirements`. Body has: Critical Rules, Input Protocol, Production Protocol, Review Checklist.
+
 ## COMMON PATTERNS
 
 ### Read-Only Researcher