qualia-framework 2.4.9 → 2.5.1

package/framework/qualia-framework/VERSION

@@ -1 +1 @@
-2.4.9
+2.5.1

package/framework/qualia-framework/bin/generate-report-docx.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+"""
+Qualia Report — DOCX Generator
+
+Reads JSON report data from stdin, produces a branded DOCX file.
+
+Usage:
+    echo '{"project": "...", ...}' | python3 generate-report-docx.py /path/to/output.docx
+
+Input JSON schema:
+{
+    "project": "project-name",
+    "user": "Fawzi Goussous",
+    "date": "2026-04-06",
+    "time": "14:30",
+    "branch": "main",
+    "duration": "~3 hours",
+    "phase": "Phase 3 of 6 — Auth Integration",
+    "done": [...],
+    "deviations": [...],
+    "blockers": [...],
+    "next": [...],
+    "commits": [...]
+}
+"""
+
+import json
+import sys
+import os
+from datetime import datetime
+
+from docx import Document
+from docx.shared import Inches, Pt, Cm, RGBColor, Emu
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.enum.table import WD_TABLE_ALIGNMENT
+from docx.oxml.ns import qn, nsdecls
+from docx.oxml import parse_xml
+
+# ─── Brand constants ─────────────────────────────────────────────────────────
+
+TEAL        = RGBColor(0x2A, 0xBF, 0xBF)
+TEAL_DARK   = RGBColor(0x1E, 0x96, 0x96)
+DARK        = RGBColor(0x1A, 0x1A, 0x2E)
+CHARCOAL    = RGBColor(0x2D, 0x2D, 0x3F)
+GRAY        = RGBColor(0x6B, 0x7B, 0x8D)
+LIGHT_GRAY  = RGBColor(0x9A, 0xA5, 0xB0)
+WHITE       = RGBColor(0xFF, 0xFF, 0xFF)
+
+TEAL_HEX       = "2ABFBF"
+TEAL_DARK_HEX  = "1E9696"
+DARK_HEX       = "1A1A2E"
+INFO_BG        = "F0FAFA"
+COMMIT_BG      = "F5F7F9"
+
+LOGO_PATH = os.path.join(os.path.dirname(__file__), "..", "assets", "qualia-logo.png")
+
+FONT_BODY    = "Segoe UI"
+FONT_HEADING = "Segoe UI Semibold"
+FONT_MONO    = "Cascadia Code"
+
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+
+def remove_table_borders(table):
+    """Remove all borders from a table."""
+    tbl = table._tbl
+    tblPr = tbl.tblPr if tbl.tblPr is not None else parse_xml(f'<w:tblPr {nsdecls("w")}/>')
+    borders = parse_xml(
+        f'<w:tblBorders {nsdecls("w")}>'
+        f'  <w:top w:val="none" w:sz="0" w:space="0" w:color="auto"/>'
+        f'  <w:left w:val="none" w:sz="0" w:space="0" w:color="auto"/>'
+        f'  <w:bottom w:val="none" w:sz="0" w:space="0" w:color="auto"/>'
+        f'  <w:right w:val="none" w:sz="0" w:space="0" w:color="auto"/>'
+        f'  <w:insideH w:val="none" w:sz="0" w:space="0" w:color="auto"/>'
+        f'  <w:insideV w:val="none" w:sz="0" w:space="0" w:color="auto"/>'
+        f'</w:tblBorders>'
+    )
+    tblPr.append(borders)
+
+
+def set_cell_shading(cell, color_hex):
+    """Set background color on a table cell."""
+    shading = parse_xml(f'<w:shd {nsdecls("w")} w:fill="{color_hex}"/>')
+    cell._tc.get_or_add_tcPr().append(shading)
+
+
+def set_cell_margins(cell, top=0, bottom=0, left=100, right=100):
+    """Set cell margins in twips."""
+    tc = cell._tc
+    tcPr = tc.get_or_add_tcPr()
+    tcMar = parse_xml(
+        f'<w:tcMar {nsdecls("w")}>'
+        f'  <w:top w:w="{top}" w:type="dxa"/>'
+        f'  <w:bottom w:w="{bottom}" w:type="dxa"/>'
+        f'  <w:start w:w="{left}" w:type="dxa"/>'
+        f'  <w:end w:w="{right}" w:type="dxa"/>'
+        f'</w:tcMar>'
+    )
+    tcMar_old = tcPr.find(qn('w:tcMar'))
+    if tcMar_old is not None:
+        tcPr.remove(tcMar_old)
+    tcPr.append(tcMar)
+
+
+def add_teal_rule(doc, weight=6):
+    """Add a teal horizontal line."""
+    p = doc.add_paragraph()
+    p.paragraph_format.space_before = Pt(2)
+    p.paragraph_format.space_after = Pt(8)
+    pPr = p._p.get_or_add_pPr()
+    pBdr = parse_xml(
+        f'<w:pBdr {nsdecls("w")}>'
+        f'  <w:bottom w:val="single" w:sz="{weight}" w:space="1" w:color="{TEAL_HEX}"/>'
+        f'</w:pBdr>'
+    )
+    pPr.append(pBdr)
+
+
+def add_section_heading(doc, text):
+    """Add a premium section heading with teal left accent."""
+    p = doc.add_paragraph()
+    p.paragraph_format.space_before = Pt(20)
+    p.paragraph_format.space_after = Pt(10)
+    # Left border accent
+    pPr = p._p.get_or_add_pPr()
+    pBdr = parse_xml(
+        f'<w:pBdr {nsdecls("w")}>'
+        f'  <w:left w:val="single" w:sz="18" w:space="8" w:color="{TEAL_HEX}"/>'
+        f'  <w:bottom w:val="single" w:sz="2" w:space="4" w:color="E0E0E0"/>'
+        f'</w:pBdr>'
+    )
+    pPr.append(pBdr)
+    run = p.add_run(text)
+    run.font.name = FONT_HEADING
+    run.font.size = Pt(13)
+    run.font.color.rgb = CHARCOAL
+    run.font.bold = True
+    return p
+
+
+def add_bullet(doc, text):
+    """Add a styled bullet point with teal bullet."""
+    p = doc.add_paragraph()
+    p.paragraph_format.space_after = Pt(5)
+    p.paragraph_format.left_indent = Cm(0.8)
+    # Teal bullet
+    bullet_run = p.add_run("  \u25B8  ")
+    bullet_run.font.name = FONT_BODY
+    bullet_run.font.size = Pt(10)
+    bullet_run.font.color.rgb = TEAL
+    # Text
+    text_run = p.add_run(text)
+    text_run.font.name = FONT_BODY
+    text_run.font.size = Pt(10.5)
+    text_run.font.color.rgb = DARK
+    return p
+
+
+def add_spacer(doc, pts=6):
+    """Add vertical spacing."""
+    p = doc.add_paragraph()
+    p.paragraph_format.space_before = Pt(0)
+    p.paragraph_format.space_after = Pt(pts)
+    run = p.add_run("")
+    run.font.size = Pt(2)
+
+
+# ─── Document builder ────────────────────────────────────────────────────────
+
+def build_report(data, output_path):
+    doc = Document()
+
+    # ── Page setup ──
+    for section in doc.sections:
+        section.top_margin = Cm(1.8)
+        section.bottom_margin = Cm(1.5)
+        section.left_margin = Cm(2.5)
+        section.right_margin = Cm(2.5)
+
+    # ── Page border ──
+    for section in doc.sections:
+        sectPr = section._sectPr
+        pgBorders = parse_xml(
+            f'<w:pgBorders {nsdecls("w")} w:offsetFrom="page">'
+            f'  <w:top w:val="single" w:sz="4" w:space="24" w:color="{TEAL_HEX}"/>'
+            f'  <w:left w:val="single" w:sz="4" w:space="24" w:color="{TEAL_HEX}"/>'
+            f'  <w:bottom w:val="single" w:sz="4" w:space="24" w:color="{TEAL_HEX}"/>'
+            f'  <w:right w:val="single" w:sz="4" w:space="24" w:color="{TEAL_HEX}"/>'
+            f'</w:pgBorders>'
+        )
+        sectPr.append(pgBorders)
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # HEADER — Logo left, Title + subtitle right
+    # ══════════════════════════════════════════════════════════════════════════
+
+    header_table = doc.add_table(rows=1, cols=2)
+    header_table.alignment = WD_TABLE_ALIGNMENT.CENTER
+    header_table.autofit = True
+    remove_table_borders(header_table)
+
+    # Set column widths
+    header_table.columns[0].width = Cm(4)
+    header_table.columns[1].width = Cm(12)
+
+    # Logo
+    logo_cell = header_table.cell(0, 0)
+    logo_p = logo_cell.paragraphs[0]
+    logo_p.alignment = WD_ALIGN_PARAGRAPH.LEFT
+    if os.path.exists(LOGO_PATH):
+        logo_p.add_run().add_picture(LOGO_PATH, width=Cm(2.5))
+
+    # Title block
+    title_cell = header_table.cell(0, 1)
+    # "Session Report" — large teal
+    title_p = title_cell.paragraphs[0]
+    title_p.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+    run = title_p.add_run("Session Report")
+    run.font.name = FONT_HEADING
+    run.font.size = Pt(26)
+    run.font.color.rgb = TEAL
+    run.font.bold = True
+    title_p.paragraph_format.space_after = Pt(2)
+
+    # "QUALIA SOLUTIONS" — subtle uppercase
+    sub_p = title_cell.add_paragraph()
+    sub_p.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+    sub_p.paragraph_format.space_after = Pt(0)
+    run = sub_p.add_run("QUALIA SOLUTIONS")
+    run.font.name = FONT_BODY
+    run.font.size = Pt(9)
+    run.font.color.rgb = LIGHT_GRAY
+    run.font.bold = True
+    # Letter spacing
+    rPr = run._r.get_or_add_rPr()
+    spacing = parse_xml(f'<w:spacing {nsdecls("w")} w:val="60"/>')
+    rPr.append(spacing)
+
+    add_teal_rule(doc, weight=12)
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # INFO CARD — teal-tinted background, 2-column layout
+    # ══════════════════════════════════════════════════════════════════════════
+
+    report_date = data.get("date", datetime.now().strftime("%Y-%m-%d"))
+    report_time = data.get("time", datetime.now().strftime("%H:%M"))
+    user_name = data.get("user", "—")
+
+    info_left = [
+        ("Project",  data.get("project", "—")),
+        ("Prepared by", user_name),
+    ]
+    if data.get("phase"):
+        info_left.append(("Phase", data["phase"]))
+
+    info_right = [
+        ("Date",     report_date),
+        ("Time",     report_time),
+        ("Branch",   data.get("branch", "—")),
+        ("Duration", data.get("duration", "—")),
+    ]
+
+    max_rows = max(len(info_left), len(info_right))
+    info_table = doc.add_table(rows=max_rows, cols=4)
+    info_table.alignment = WD_TABLE_ALIGNMENT.CENTER
+    remove_table_borders(info_table)
+
+    # Shade entire info card
+    for row in info_table.rows:
+        for cell in row.cells:
+            set_cell_shading(cell, INFO_BG)
+            set_cell_margins(cell, top=40, bottom=40, left=120, right=60)
+
+    # Fill left columns
+    for i, (label, value) in enumerate(info_left):
+        # Label
+        cell_l = info_table.cell(i, 0)
+        cell_l.width = Cm(2.8)
+        p = cell_l.paragraphs[0]
+        p.paragraph_format.space_after = Pt(1)
+        run = p.add_run(label)
+        run.font.name = FONT_BODY
+        run.font.size = Pt(9)
+        run.font.color.rgb = GRAY
+        run.font.bold = True
+        # Value
+        cell_v = info_table.cell(i, 1)
+        cell_v.width = Cm(5)
+        p = cell_v.paragraphs[0]
+        p.paragraph_format.space_after = Pt(1)
+        run = p.add_run(value)
+        run.font.name = FONT_BODY
+        run.font.size = Pt(10)
+        run.font.color.rgb = DARK
+        run.font.bold = True if label == "Project" else False
+
+    # Fill right columns
+    for i, (label, value) in enumerate(info_right):
+        cell_l = info_table.cell(i, 2)
+        cell_l.width = Cm(2.2)
+        p = cell_l.paragraphs[0]
+        p.paragraph_format.space_after = Pt(1)
+        run = p.add_run(label)
+        run.font.name = FONT_BODY
+        run.font.size = Pt(9)
+        run.font.color.rgb = GRAY
+        run.font.bold = True
+        cell_v = info_table.cell(i, 3)
+        cell_v.width = Cm(4)
+        p = cell_v.paragraphs[0]
+        p.paragraph_format.space_after = Pt(1)
+        run = p.add_run(value)
+        run.font.name = FONT_BODY
+        run.font.size = Pt(10)
+        run.font.color.rgb = DARK
+
+    add_spacer(doc, 4)
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # BODY SECTIONS
+    # ══════════════════════════════════════════════════════════════════════════
+
+    # ── What Was Done ──
+    done_items = data.get("done", [])
+    if done_items:
+        add_section_heading(doc, "What Was Done")
+        for item in done_items:
+            add_bullet(doc, item)
+
+    # ── Deviations (only if any) ──
+    deviations = data.get("deviations", [])
+    if deviations:
+        add_section_heading(doc, "Deviations")
+        for item in deviations:
+            add_bullet(doc, item)
+
+    # ── Blockers (only if any) ──
+    blockers = data.get("blockers", [])
+    if blockers:
+        add_section_heading(doc, "Blockers")
+        for item in blockers:
+            add_bullet(doc, item)
+
+    # ── Commits (compact card) ──
+    commits = data.get("commits", [])
+    if commits:
+        add_section_heading(doc, "Commits")
+        # Render in a shaded card
+        commit_table = doc.add_table(rows=1, cols=1)
+        commit_table.alignment = WD_TABLE_ALIGNMENT.LEFT
+        remove_table_borders(commit_table)
+        commit_cell = commit_table.cell(0, 0)
+        set_cell_shading(commit_cell, COMMIT_BG)
+        set_cell_margins(commit_cell, top=80, bottom=80, left=160, right=160)
+        # First commit in existing paragraph
+        p = commit_cell.paragraphs[0]
+        p.paragraph_format.space_after = Pt(2)
+        run = p.add_run(commits[0])
+        run.font.name = FONT_MONO
+        run.font.size = Pt(8.5)
+        run.font.color.rgb = GRAY
+        # Remaining commits
+        for c in commits[1:10]:
+            p = commit_cell.add_paragraph()
+            p.paragraph_format.space_after = Pt(2)
+            run = p.add_run(c)
+            run.font.name = FONT_MONO
+            run.font.size = Pt(8.5)
+            run.font.color.rgb = GRAY
+        if len(commits) > 10:
+            p = commit_cell.add_paragraph()
+            run = p.add_run(f"  ... and {len(commits) - 10} more")
+            run.font.name = FONT_BODY
+            run.font.size = Pt(8)
+            run.font.color.rgb = LIGHT_GRAY
+            run.font.italic = True
+
+    # ── Next Steps ──
+    next_items = data.get("next", [])
+    if next_items:
+        add_section_heading(doc, "Next Steps")
+        for item in next_items:
+            add_bullet(doc, item)
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # FOOTER
+    # ══════════════════════════════════════════════════════════════════════════
+
+    add_spacer(doc, 16)
+    add_teal_rule(doc, weight=4)
+
+    footer_p = doc.add_paragraph()
+    footer_p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    footer_p.paragraph_format.space_after = Pt(0)
+
+    run = footer_p.add_run("Qualia Solutions")
+    run.font.name = FONT_HEADING
+    run.font.size = Pt(8)
+    run.font.color.rgb = TEAL
+    run.font.bold = True
+
+    run = footer_p.add_run(f"   \u00B7   {report_date}  {report_time}")
+    run.font.name = FONT_BODY
+    run.font.size = Pt(8)
+    run.font.color.rgb = LIGHT_GRAY
+
+    tagline_p = doc.add_paragraph()
+    tagline_p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    run = tagline_p.add_run("qualia.solutions")
+    run.font.name = FONT_BODY
+    run.font.size = Pt(7)
+    run.font.color.rgb = LIGHT_GRAY
+
+    # ── Save ──
+    doc.save(output_path)
+    return output_path
+
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: echo '{...}' | python3 generate-report-docx.py /path/to/output.docx", file=sys.stderr)
+        sys.exit(1)
+
+    output_path = sys.argv[1]
+    data = json.load(sys.stdin)
+    result = build_report(data, output_path)
+    print(f"Report saved: {result}")

package/framework/skills/qualia-report/SKILL.md

@@ -1,217 +1,166 @@
 ---
 name: qualia-report
-description: "Generate a session work report for owner review — what was assigned, what was done, what deviated, what's next. Use this skill whenever the user says 'report', 'done for today', 'session report', 'log my work', 'what did I do', 'end of day', 'wrapping up', 'signing off', or finishes a working session. Also trigger when user mentions 'daily report', 'status update', 'work summary', or wants to document what they accomplished."
+description: "Generate a session work report as a branded DOCX — simple summary of what was done. Use this skill whenever the user says 'report', 'done for today', 'session report', 'log my work', 'what did I do', 'end of day', 'wrapping up', 'signing off', or finishes a working session. Also trigger when user mentions 'daily report', 'status update', 'work summary', or wants to document what they accomplished."
 ---
 
-# Qualia Report — Session Work Report
+# Qualia Report — Session DOCX Report
 
-Generate a structured report of what was done in this session. This is for the owner to review — assigned vs done, deviations, blockers, and next steps.
+Generate a clean, branded DOCX report of what was done in this session. Simple and clear — what happened, not every detail.
 
 ## Usage
 
-`/qualia-report` — Generate report for current session
-`/qualia-report --week` — Aggregate reports from the last 7 days
-
-## When to Run
-
-The framework should suggest this when:
-- Employee says "done for today", "stopping", "wrapping up", "signing off"
-- Employee has been working for 1+ hours and mentions pausing
-- A phase is completed or verified
-- Before running `/qualia-pause-work` (report first, then pause)
+`/qualia-report` — Generate DOCX report for current session
+`/qualia-report --week` — Aggregate weekly DOCX report
 
 ## Process
 
 ### 1. Gather Session Data
 
-**From git (what actually changed):**
+Run a **single** bash command to collect everything:
+
 ```bash
-# Commits made this session (last N hours or since last report)
-LAST_REPORT=$(ls -t .planning/reports/report-*.md 2>/dev/null | head -1)
+echo "---GIT---"
+LAST_REPORT=$(ls -t .planning/reports/report-*.docx .planning/reports/report-*.md 2>/dev/null | head -1)
 if [ -n "$LAST_REPORT" ]; then
-  SINCE=$(grep -m1 "^Date:" "$LAST_REPORT" | sed 's/^Date: *//')
+  SINCE_DATE=$(stat -c %Y "$LAST_REPORT" 2>/dev/null)
+  SINCE=$(date -d "@$SINCE_DATE" '+%Y-%m-%d %H:%M' 2>/dev/null || echo "8 hours ago")
 else
   SINCE="8 hours ago"
 fi
-git log --oneline --since="$SINCE" --author="$(git config user.name)" 2>/dev/null
-git diff --stat HEAD~5..HEAD 2>/dev/null | tail -5
-```
-
-**From STATE.md (where the project stands):**
-- Current phase and status
-- Progress percentage
-- Assigned to whom
-
-**From ROADMAP.md (what was planned):**
-- Which phase was being worked on
-- What the phase goal is
-- What the success criteria are
-
-**From SUMMARY.md files (if any were created this session):**
-- Phase execution summaries
-- Deviations noted
-- Decisions made
-
-**From UAT.md files (if any were created this session):**
-- Test results
-- Issues found
-
-**From git diff (what files changed):**
-```bash
-git diff --name-only HEAD~5..HEAD 2>/dev/null | head -30
+echo "SINCE:$SINCE"
+echo "---COMMITS---"
+git log --oneline --since="$SINCE" 2>/dev/null | head -20
+echo "---STATS---"
+COMMIT_COUNT=$(git log --oneline --since="$SINCE" 2>/dev/null | wc -l)
+echo "COUNT:$COMMIT_COUNT"
+FIRST=$(git log --format="%ar" --since="$SINCE" 2>/dev/null | tail -1)
+LAST=$(git log --format="%ar" --since="$SINCE" 2>/dev/null | head -1)
+echo "FIRST:$FIRST"
+echo "LAST:$LAST"
+echo "---PROJECT---"
+echo "DIR:$(basename $(pwd))"
+echo "BRANCH:$(git branch --show-current 2>/dev/null)"
+echo "---STATE---"
+test -f .planning/STATE.md && head -20 .planning/STATE.md || echo "no-state"
+echo "---PHASE---"
+test -f .planning/ROADMAP.md && grep -A2 "^## Phase" .planning/ROADMAP.md | head -6 || echo "no-roadmap"
 ```
 
-### 2. Analyze: Assigned vs Done
-
-Compare what ROADMAP.md says the current phase should deliver against what was actually built:
-
-- **Planned:** [from ROADMAP.md phase goal + success criteria]
-- **Completed:** [from commits + SUMMARY.md]
-- **Partially done:** [started but not finished]
-- **Not started:** [planned but untouched]
-- **Unplanned work:** [things done that weren't in the plan]
-
-### 3. Generate Report
-
-Create `.planning/reports/report-{YYYY-MM-DD-HHMM}.md`:
-
-```markdown
-# Session Report
-
-**Project:** {from PROJECT.md or directory name}
-**Date:** {YYYY-MM-DD HH:MM}
-**Employee:** {from STATE.md "Assigned to" or git config user.name}
-**Duration:** {estimated from first to last commit, or "~X hours"}
-**Phase:** {N} of {total} — {phase name}
-
-## What Was Assigned
-
-{Phase goal from ROADMAP.md}
-
-Success criteria:
-1. {criterion 1}
-2. {criterion 2}
-3. {criterion 3}
-
-## What Was Done
-
-{Summary of actual work, derived from commits and file changes}
-
-- {accomplishment 1}
-- {accomplishment 2}
-- {accomplishment 3}
-
-### Files Changed
-{Top 15 files modified, grouped by area}
-
-### Commits
-{List of commits this session}
-
-## Progress
-
-| Criterion | Status |
-|-----------|--------|
-| {criterion 1} | Done / Partial / Not started |
-| {criterion 2} | Done / Partial / Not started |
-| {criterion 3} | Done / Partial / Not started |
-
-**Phase progress:** {X}% → {Y}% (moved {delta}%)
-**Overall project:** {A}% → {B}%
+### 2. Synthesize — Keep It Simple
 
-## Deviations
+From the gathered data, build a **concise** summary. The report should answer:
 
-{Anything done differently from the plan — and why}
+1. **What was done?** — 3-6 bullet points summarizing accomplishments in plain language. Group related commits into single items. Don't list every file changed.
+2. **Any deviations?** — Only include if something was done differently from the plan. Skip this section entirely if everything went as planned.
+3. **Any blockers?** — Only include if something is actually blocked. Skip if none.
+4. **What's next?** — 1-3 clear next actions.
 
-- {deviation 1}: {reason}
+**Tone:** Write for a busy founder reviewing work. Clear, factual, no filler. Each bullet should start with a verb: "Built...", "Fixed...", "Added...", "Refactored..."
 
-{If no deviations: "None — followed the plan."}
+### 3. Generate DOCX
 
-## Blockers & Issues
+Build a JSON object and pipe it to the generator:
 
-{Anything that slowed down or blocked work}
-
-- {blocker 1}: {status — resolved / still blocking}
-
-{If none: "None — clear session."}
-
-## Decisions Made
-
-{Any choices that affect future work}
-
-| Decision | Why | Impact |
-|----------|-----|--------|
-| {choice} | {reason} | {what it affects} |
+```bash
+mkdir -p .planning/reports
 
-## Next Session
+cat <<'REPORT_JSON' | python3 ~/.claude/qualia-framework/bin/generate-report-docx.py ".planning/reports/report-$(date +%Y-%m-%d-%H%M).docx"
+{
+    "project": "<project-name>",
+    "user": "<git config user.name or 'Fawzi Goussous'>",
+    "date": "<YYYY-MM-DD>",
+    "time": "<HH:MM>",
+    "branch": "<current-branch>",
+    "duration": "<estimated from first to last commit, e.g. ~3 hours>",
+    "phase": "<Phase N of M — name, or omit if no .planning>",
+    "done": [
+        "<accomplishment 1>",
+        "<accomplishment 2>",
+        "<accomplishment 3>"
+    ],
+    "deviations": [],
+    "blockers": [],
+    "next": [
+        "<next action 1>",
+        "<next action 2>"
+    ],
+    "commits": [
+        "<hash> <message>",
+        "<hash> <message>"
+    ]
+}
+REPORT_JSON
+```
 
-**What to do next:**
-1. {immediate next action}
-2. {following action}
+**Important:** The JSON must be valid. Escape any quotes in commit messages. Omit `deviations` and `blockers` arrays if empty (the generator handles missing keys gracefully).
 
-**Suggested command:** `/qualia-plan-phase {N}` or `/qualia-execute-phase {N}` etc.
+### 4. Commit & Auto-Upload to ERP
 
----
-*Generated by /qualia-report at {timestamp}*
+```bash
+# Commit the report
+git add .planning/reports/report-*.docx
+git commit -m "report: session report $(date +%Y-%m-%d) — $(basename $(pwd))"
 ```
 
-### 4. Commit Report
+Then **auto-upload** the report to the ERP so it's linked to the employee's active work session. This is mandatory and happens automatically — employees cannot skip or edit the report before it reaches the ERP.
 
 ```bash
-mkdir -p .planning/reports
-git add .planning/reports/report-{timestamp}.md
-git commit -m "report: session report {date} — {employee name}"
-```
-
-### 5. Update STATE.md
+# Auto-upload to ERP
+REPORT_FILE=$(ls -t .planning/reports/report-*.docx 2>/dev/null | head -1)
+EMPLOYEE_EMAIL=$(git config user.email)
+PROJECT_NAME=$(basename $(pwd))
+ERP_URL="https://portal.qualiasolutions.net/api/claude/report-upload"
+API_KEY=$(cat ~/.claude/.env 2>/dev/null | grep CLAUDE_API_KEY | cut -d= -f2 || echo "")
+
+if [ -z "$API_KEY" ]; then
+  # Try from project env
+  API_KEY=$(grep CLAUDE_API_KEY .env.local 2>/dev/null | cut -d= -f2 || echo "")
+fi
 
-Update the `Last activity` and `Last worked by` fields in STATE.md.
+if [ -n "$REPORT_FILE" ] && [ -n "$API_KEY" ]; then
+  UPLOAD_RESULT=$(curl -s -X POST "$ERP_URL" \
+    -H "x-api-key: $API_KEY" \
+    -F "file=@$REPORT_FILE" \
+    -F "employee_email=$EMPLOYEE_EMAIL" \
+    -F "project_name=$PROJECT_NAME")
+  echo "ERP upload: $UPLOAD_RESULT"
+else
+  echo "WARNING: Could not auto-upload report to ERP (missing API key or report file)"
+fi
+```
 
-### 6. Suggest Next Steps
+Then tell the user:
 
-> "Report saved to `.planning/reports/report-{date}.md`"
+> Report saved to `.planning/reports/report-{date}.docx` and **auto-uploaded to ERP**.
 >
-> "Want to also save session context? Run `/qualia-pause-work`"
-> "Ready to keep going? Run `/qualia-plan-phase {N}`"
-
-## Weekly Aggregate (`--week`)
-
-When run with `--week`, reads all reports from the last 7 days and produces a summary:
-
-```markdown
-# Weekly Report — {project name}
-
-**Period:** {date} to {date}
-**Employee:** {name}
-
-## Summary
-
-- **Sessions:** {count}
-- **Phases progressed:** Phase {X} → Phase {Y}
-- **Overall progress:** {A}% → {B}%
-- **Commits:** {total}
-
-## Per-Session Breakdown
+> Your report is now linked to your active work session. When you clock out, it will already be attached.
+>
+> Want to save session context too? Run `/qualia-pause-work`
 
-| Date | Phase | Progress | Key Accomplishment |
-|------|-------|----------|-------------------|
-| {date} | Phase 3 | +15% | Built auth flow |
-| {date} | Phase 3 | +10% | Added RLS policies |
-| {date} | Phase 4 | +5% | Started chat UI |
+### 5. Update STATE.md (if exists)
 
-## Cumulative Deviations
+Update `Last activity` and `Last worked by` fields.
 
-{Any patterns — repeated blockers, scope changes, etc.}
+## Weekly Report (`--week`)
 
-## Blockers Still Open
+When run with `--week`:
 
-{Unresolved from any session}
+1. Read all reports from the last 7 days (check `.planning/reports/`)
+2. Read git log for the full week
+3. Build an aggregate JSON with:
+   - `"project"` — project name
+   - `"date"` — current date with "Weekly" suffix
+   - `"duration"` — "Week of {date} to {date}"
+   - `"done"` — combined accomplishments from all sessions, deduplicated
+   - `"next"` — forward-looking items from the most recent report
+   - `"commits"` — full week's commits
+4. Pipe to the same generator, save as `weekly-{date}.docx`
 
-## Next Week
+## Generator Location
 
-{What's ahead based on ROADMAP.md}
-```
+`~/.claude/qualia-framework/bin/generate-report-docx.py`
 
-Save to `.planning/reports/weekly-{date}.md`.
+Requires: `python-docx` (pre-installed). Uses Qualia logo from `~/.claude/qualia-framework/assets/qualia-logo.png`.
 
 ---
 > Stuck? Type `/qualia-idk` · Lost? Type `/qualia-help`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualia-framework",
-  "version": "2.4.9",
+  "version": "2.5.1",
   "description": "Qualia Solutions — Claude Code Framework",
   "bin": {
     "qualia-framework": "./bin/cli.js"