@demig0d2/skills 1.0.0

package/skills/continuity-tracker/references/log_schema.md

@@ -0,0 +1,149 @@
+# Continuity Log — Schema Reference
+
+The continuity log is a JSON file (`continuity_log.json`) maintained
+alongside the manuscript. This document describes every field.
+
+---
+
+## Full Schema
+
+```json
+{
+  "book_title": "string — the book's working title",
+  "created": "ISO datetime — when the log was initialized",
+  "last_updated": "ISO datetime — last update timestamp",
+  "last_chapter": "integer — last chapter number completed",
+
+  "commitments": [
+    "string — book-level promises established in front matter/intro"
+  ],
+
+  "established_facts": [
+    "string — factual details about the author's story, must stay consistent"
+  ],
+
+  "metaphors": {
+    "by_chapter": {
+      "1": ["metaphor used in chapter 1", "another metaphor"],
+      "2": ["metaphor used in chapter 2"]
+    },
+    "available": ["strong images not yet used"],
+    "retired": ["all metaphors used — do not repeat"]
+  },
+
+  "insights": {
+    "1": "Core insight fully delivered in chapter 1",
+    "2": "Core insight delivered in chapter 2"
+  },
+
+  "tone_decisions": {
+    "register": "string — e.g., intimate/confessional in My Story",
+    "reader_address": "string — e.g., direct 'you' in Reflection",
+    "author_position": "string — e.g., always in-process, never above",
+    "emotional_ceiling": "string — e.g., darkest content in Ch.1"
+  },
+
+  "structural_patterns": {
+    "section_format": "string — e.g., My Story + My Reflection",
+    "avg_chapter_words": "integer — running average",
+    "opening_style": "string — e.g., immersive scene",
+    "closing_style": "string — e.g., single reframe sentence",
+    "chapter_word_counts": [2400, 2200, 2600]
+  },
+
+  "open_threads": [
+    {
+      "thread": "string — the thread description",
+      "introduced_in": "string — chapter number",
+      "closed": false,
+      "added": "ISO datetime"
+    }
+  ],
+
+  "closed_threads": [
+    {
+      "thread": "string",
+      "introduced_in": "string",
+      "closed": true,
+      "closed_in": "string — chapter where resolved",
+      "added": "ISO datetime"
+    }
+  ],
+
+  "chapter_summaries": {
+    "1": {
+      "title": "Chapter 1 title",
+      "summary": "One-paragraph summary of what was covered"
+    }
+  }
+}
+```
+
+---
+
+## Field Guidelines
+
+### `commitments`
+Book-level promises that must never be contradicted. Examples:
+- "Author frames himself as someone who lived this, not an expert"
+- "Book promises no quick fixes — lasting transformation only"
+- "Author is always in-process, never looking back from arrival"
+
+### `established_facts`
+All narrative details stated in the manuscript that must remain consistent:
+- "Father passed away during author's degree years"
+- "Lived in a tiny penthouse apartment alone"
+- "Walked miles to save money on transport"
+- "Cooked rice and lentils, stretched groceries"
+
+### `metaphors.retired`
+Once a metaphor is used anywhere in the manuscript, it goes here.
+The conflict checker (`conflict_check.py`) scans new chapters against this list.
+
+### `insights`
+One core insight per chapter. Track to avoid restating:
+- Ch.1: "Loneliness as mirror of self-relationship"
+- Ch.2: "Chasing connection from fear, not love, creates neediness"
+- Ch.3: "Aloneness and loneliness are different — one is chosen"
+
+### `open_threads`
+Thematic or narrative threads introduced that haven't been resolved:
+- "Ch.2 mentioned 'the small proof that my life has value' — needs deeper exploration"
+- "Ch.3 established reader's 'wrong attempts' pattern — needs to pay off in Ch.7"
+
+---
+
+## CLI Quick Reference
+
+```bash
+# Initialize
+python log_manager.py init "My Book Title"
+
+# Add chapter
+python log_manager.py add-chapter 1 "Why It Hurts So Much"
+
+# Add established fact
+python log_manager.py add-fact "Author's father passed during degree years"
+
+# Add insight delivered
+python log_manager.py add-insight 1 "Loneliness as mirror of self-relationship"
+
+# Add metaphor (auto-retires it)
+python log_manager.py add-metaphor 1 "deafening scream inside my head"
+
+# Add open thread
+python log_manager.py add-thread "Ch.2 mentioned small proof of self-value — needs depth"
+
+# Close a thread (by index)
+python log_manager.py threads          # list open threads
+python log_manager.py close-thread 0  # close thread at index 0
+
+# View full log
+python log_manager.py show
+
+# Summary only
+python log_manager.py summary
+
+# Conflict check before finalizing a chapter
+python conflict_check.py chapter_5.md --log continuity_log.json
+```

package/skills/continuity-tracker/scripts/conflict_check.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+conflict_check.py — Check a chapter for continuity conflicts against the log
+
+Scans a chapter text file against the established facts, retired metaphors,
+and delivered insights in the continuity log. Surfaces potential conflicts.
+
+Usage:
+    python conflict_check.py <chapter_file> [--log log.json]
+    python conflict_check.py <chapter_file> [--log log.json] --json
+"""
+
+import sys
+import re
+import json
+import argparse
+from pathlib import Path
+
+DEFAULT_LOG = "continuity_log.json"
+
+# ─── Conflict Detection Rules ─────────────────────────────────────────────────
+
+# Known fact patterns that might be stated inconsistently
+NUMERICAL_PATTERN = re.compile(r'\b(\d+)\s+(years?|months?|days?|chapters?|books?|pages?)\b', re.IGNORECASE)
+NAME_PATTERN = re.compile(r'\b[A-Z][a-z]+ [A-Z][a-z]+\b')
+
+
+def load_log(log_path: str) -> dict:
+    path = Path(log_path)
+    if not path.exists():
+        return None
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def check_retired_metaphors(chapter_text: str, retired: list) -> list:
+    """Find retired metaphors used again in this chapter."""
+    conflicts = []
+    chapter_lower = chapter_text.lower()
+    for metaphor in retired:
+        # Check key phrases from the metaphor
+        key_words = [w for w in metaphor.lower().split() if len(w) > 4]
+        matches = sum(1 for w in key_words if w in chapter_lower)
+        if matches >= 2:
+            conflicts.append({
+                "type": "repeated_metaphor",
+                "severity": "medium",
+                "detail": f'Retired metaphor may be reused: "{metaphor}"',
+                "suggestion": "Use a fresh image — this metaphor was already delivered in a prior chapter",
+            })
+    return conflicts
+
+
+def check_repeated_insights(chapter_text: str, insights: dict) -> list:
+    """Check if an insight already fully delivered is being re-delivered."""
+    conflicts = []
+    chapter_lower = chapter_text.lower()
+
+    for ch_num, insight in insights.items():
+        # Look for key phrase overlap
+        insight_words = [w for w in insight.lower().split() if len(w) > 5]
+        if not insight_words:
+            continue
+        matches = sum(1 for w in insight_words if w in chapter_lower)
+        overlap_ratio = matches / len(insight_words) if insight_words else 0
+
+        if overlap_ratio > 0.5:
+            conflicts.append({
+                "type": "repeated_insight",
+                "severity": "medium",
+                "detail": f'Insight from Ch.{ch_num} may be re-delivered: "{insight[:60]}..."',
+                "suggestion": "Build on this insight rather than restating it — add a new dimension",
+            })
+
+    return conflicts
+
+
+def check_fact_consistency(chapter_text: str, established_facts: list) -> list:
+    """Flag when numerical or named facts appear inconsistently."""
+    conflicts = []
+
+    # Extract numbers from chapter
+    chapter_numbers = NUMERICAL_PATTERN.findall(chapter_text)
+
+    for fact in established_facts:
+        # Check if fact contains numbers that contradict chapter
+        fact_numbers = NUMERICAL_PATTERN.findall(fact)
+        for fn_val, fn_unit in fact_numbers:
+            for cn_val, cn_unit in chapter_numbers:
+                if cn_unit.rstrip("s") == fn_unit.rstrip("s") and cn_val != fn_val:
+                    conflicts.append({
+                        "type": "numerical_inconsistency",
+                        "severity": "high",
+                        "detail": f'Number mismatch: fact says "{fn_val} {fn_unit}", chapter says "{cn_val} {cn_unit}"',
+                        "suggestion": f'Verify against established fact: "{fact[:80]}"',
+                    })
+
+    return conflicts
+
+
+def run_conflict_check(chapter_path: str, log_path: str) -> dict:
+    chapter_text = Path(chapter_path).read_text(encoding="utf-8")
+    log = load_log(log_path)
+
+    result = {
+        "chapter_file": chapter_path,
+        "log_file": log_path,
+        "conflicts": [],
+        "warnings": [],
+        "clean": True,
+    }
+
+    if not log:
+        result["warnings"].append("No continuity log found — run log_manager.py init first")
+        return result
+
+    # Run checks
+    retired = log.get("metaphors", {}).get("retired", [])
+    insights = log.get("insights", {})
+    facts = log.get("established_facts", [])
+
+    metaphor_conflicts = check_retired_metaphors(chapter_text, retired)
+    insight_conflicts = check_repeated_insights(chapter_text, insights)
+    fact_conflicts = check_fact_consistency(chapter_text, facts)
+
+    all_conflicts = metaphor_conflicts + insight_conflicts + fact_conflicts
+
+    result["conflicts"] = all_conflicts
+    result["clean"] = len(all_conflicts) == 0
+
+    return result
+
+
+def print_report(result: dict):
+    print(f"\n{'═' * 60}")
+    print(f"  CONTINUITY CONFLICT CHECK")
+    print(f"  Chapter: {result['chapter_file']}")
+    print(f"  Log: {result['log_file']}")
+    print(f"{'═' * 60}")
+
+    if result.get("warnings"):
+        for w in result["warnings"]:
+            print(f"\n  ⚠ {w}")
+
+    if result["clean"]:
+        print(f"\n  ✓ No conflicts detected. Chapter is consistent with log.\n")
+        return
+
+    high = [c for c in result["conflicts"] if c["severity"] == "high"]
+    medium = [c for c in result["conflicts"] if c["severity"] == "medium"]
+
+    print(f"\n  Conflicts: {len(result['conflicts'])} ({len(high)} high, {len(medium)} medium)\n")
+
+    for i, conflict in enumerate(result["conflicts"], 1):
+        icon = "✗" if conflict["severity"] == "high" else "⚠"
+        print(f"  {icon} [{conflict['severity'].upper()}] {conflict['type'].replace('_', ' ').title()}")
+        print(f"     {conflict['detail']}")
+        print(f"     → {conflict['suggestion']}\n")
+
+    print(f"{'═' * 60}")
+    print(f"  Resolve conflicts before updating the continuity log.\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("chapter_file")
+    parser.add_argument("--log", default=DEFAULT_LOG)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    if not Path(args.chapter_file).exists():
+        print(f"Error: File not found: {args.chapter_file}", file=sys.stderr)
+        sys.exit(1)
+
+    result = run_conflict_check(args.chapter_file, args.log)
+
+    if args.json:
+        print(json.dumps(result, indent=2))
+    else:
+        print_report(result)

package/skills/continuity-tracker/scripts/log_manager.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+log_manager.py — Read, write, and update the continuity log
+
+The continuity log is stored as a JSON file alongside the manuscript.
+This script manages all log operations: init, update, read, and summary.
+
+Usage:
+    python log_manager.py init <book_title> [--log log.json]
+    python log_manager.py show [--log log.json]
+    python log_manager.py summary [--log log.json]
+    python log_manager.py add-chapter <N> <title> [--log log.json]
+    python log_manager.py add-fact <fact> [--log log.json]
+    python log_manager.py add-insight <chapter_n> <insight> [--log log.json]
+    python log_manager.py add-metaphor <chapter_n> <metaphor> [--log log.json]
+    python log_manager.py add-thread <thread> [--log log.json]
+    python log_manager.py close-thread <thread_index> [--log log.json]
+    python log_manager.py threads [--log log.json]
+"""
+
+import sys
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+DEFAULT_LOG = "continuity_log.json"
+
+
+def load_log(log_path: str) -> dict:
+    path = Path(log_path)
+    if path.exists():
+        return json.loads(path.read_text(encoding="utf-8"))
+    return None
+
+
+def save_log(log: dict, log_path: str):
+    Path(log_path).write_text(json.dumps(log, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def init_log(book_title: str, log_path: str) -> dict:
+    log = {
+        "book_title": book_title,
+        "created": datetime.now().isoformat(),
+        "last_updated": datetime.now().isoformat(),
+        "last_chapter": 0,
+        "commitments": [],
+        "established_facts": [],
+        "metaphors": {
+            "by_chapter": {},
+            "available": [],
+            "retired": [],
+        },
+        "insights": {},
+        "tone_decisions": {
+            "register": "",
+            "reader_address": "",
+            "author_position": "",
+            "emotional_ceiling": "",
+        },
+        "structural_patterns": {
+            "section_format": "",
+            "avg_chapter_words": 0,
+            "opening_style": "",
+            "closing_style": "",
+            "chapter_word_counts": [],
+        },
+        "open_threads": [],
+        "closed_threads": [],
+        "chapter_summaries": {},
+    }
+    save_log(log, log_path)
+    print(f"  ✓ Log initialized: {log_path}")
+    print(f"    Book: {book_title}")
+    return log
+
+
+def show_log(log: dict):
+    print(f"\n{'═' * 60}")
+    print(f"  CONTINUITY LOG — {log['book_title']}")
+    print(f"  Last updated after Chapter {log['last_chapter']}")
+    print(f"{'═' * 60}")
+
+    if log["commitments"]:
+        print(f"\n  BOOK-LEVEL COMMITMENTS ({len(log['commitments'])}):")
+        for c in log["commitments"]:
+            print(f"    • {c}")
+
+    if log["established_facts"]:
+        print(f"\n  ESTABLISHED FACTS ({len(log['established_facts'])}):")
+        for f in log["established_facts"]:
+            print(f"    • {f}")
+
+    if log["metaphors"]["by_chapter"]:
+        print(f"\n  METAPHORS USED:")
+        for ch, mets in sorted(log["metaphors"]["by_chapter"].items(), key=lambda x: int(x[0])):
+            print(f"    Ch.{ch}: {', '.join(mets)}")
+        if log["metaphors"]["retired"]:
+            print(f"    Retired: {', '.join(log['metaphors']['retired'])}")
+
+    if log["insights"]:
+        print(f"\n  INSIGHTS DELIVERED:")
+        for ch, insight in sorted(log["insights"].items(), key=lambda x: int(x[0])):
+            print(f"    Ch.{ch}: {insight}")
+
+    open_threads = [t for t in log["open_threads"] if not t.get("closed")]
+    if open_threads:
+        print(f"\n  OPEN THREADS ({len(open_threads)}):")
+        for i, t in enumerate(open_threads):
+            print(f"    [{i}] {t['thread']}")
+            if t.get("introduced_in"):
+                print(f"         Introduced: Ch.{t['introduced_in']}")
+
+    if log["chapter_summaries"]:
+        print(f"\n  CHAPTER SUMMARIES ({len(log['chapter_summaries'])}):")
+        for ch, summary in sorted(log["chapter_summaries"].items(), key=lambda x: int(x[0])):
+            title = summary.get("title", f"Chapter {ch}")
+            text = summary.get("summary", "")[:80]
+            print(f"    Ch.{ch} — {title}: {text}...")
+
+    print(f"\n{'═' * 60}\n")
+
+
+def summary_log(log: dict):
+    open_threads = [t for t in log["open_threads"] if not t.get("closed")]
+    print(f"\n  {log['book_title']} — Continuity Summary")
+    print(f"  Chapters completed: {log['last_chapter']}")
+    print(f"  Facts established:  {len(log['established_facts'])}")
+    print(f"  Insights delivered: {len(log['insights'])}")
+    print(f"  Open threads:       {len(open_threads)}")
+    if open_threads:
+        print(f"  ⚠ Unresolved threads:")
+        for t in open_threads:
+            print(f"    · {t['thread'][:60]}")
+    print()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("command", choices=[
+        "init", "show", "summary", "add-chapter", "add-fact",
+        "add-insight", "add-metaphor", "add-thread", "close-thread", "threads"
+    ])
+    parser.add_argument("args", nargs="*")
+    parser.add_argument("--log", default=DEFAULT_LOG)
+    parsed = parser.parse_args()
+
+    log_path = parsed.log
+    cmd = parsed.command
+    args = parsed.args
+
+    if cmd == "init":
+        title = " ".join(args) if args else "Untitled"
+        init_log(title, log_path)
+
+    elif cmd in ("show",):
+        log = load_log(log_path)
+        if not log:
+            print(f"  No log found at {log_path}. Run: python log_manager.py init <title>")
+            sys.exit(1)
+        show_log(log)
+
+    elif cmd == "summary":
+        log = load_log(log_path)
+        if not log:
+            print(f"  No log found at {log_path}")
+            sys.exit(1)
+        summary_log(log)
+
+    elif cmd == "add-chapter":
+        log = load_log(log_path)
+        if not log:
+            print("  No log found. Run init first.")
+            sys.exit(1)
+        n = int(args[0]) if args else log["last_chapter"] + 1
+        title = " ".join(args[1:]) if len(args) > 1 else f"Chapter {n}"
+        log["last_chapter"] = n
+        log["last_updated"] = datetime.now().isoformat()
+        if str(n) not in log["chapter_summaries"]:
+            log["chapter_summaries"][str(n)] = {"title": title, "summary": ""}
+        save_log(log, log_path)
+        print(f"  ✓ Chapter {n}: {title} added to log")
+
+    elif cmd == "add-fact":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        fact = " ".join(args)
+        log["established_facts"].append(fact)
+        log["last_updated"] = datetime.now().isoformat()
+        save_log(log, log_path)
+        print(f"  ✓ Fact added: {fact}")
+
+    elif cmd == "add-insight":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        ch = args[0] if args else str(log["last_chapter"])
+        insight = " ".join(args[1:]) if len(args) > 1 else ""
+        log["insights"][ch] = insight
+        log["last_updated"] = datetime.now().isoformat()
+        save_log(log, log_path)
+        print(f"  ✓ Insight for Ch.{ch} added")
+
+    elif cmd == "add-metaphor":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        ch = args[0] if args else str(log["last_chapter"])
+        metaphor = " ".join(args[1:]) if len(args) > 1 else ""
+        if ch not in log["metaphors"]["by_chapter"]:
+            log["metaphors"]["by_chapter"][ch] = []
+        log["metaphors"]["by_chapter"][ch].append(metaphor)
+        log["metaphors"]["retired"].append(metaphor)
+        log["last_updated"] = datetime.now().isoformat()
+        save_log(log, log_path)
+        print(f"  ✓ Metaphor added to Ch.{ch} and retired")
+
+    elif cmd == "add-thread":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        thread = " ".join(args)
+        log["open_threads"].append({
+            "thread": thread,
+            "introduced_in": str(log["last_chapter"]),
+            "closed": False,
+            "added": datetime.now().isoformat(),
+        })
+        log["last_updated"] = datetime.now().isoformat()
+        save_log(log, log_path)
+        print(f"  ✓ Thread added: {thread}")
+
+    elif cmd == "close-thread":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        idx = int(args[0]) if args else -1
+        open_threads = [t for t in log["open_threads"] if not t.get("closed")]
+        if 0 <= idx < len(open_threads):
+            open_threads[idx]["closed"] = True
+            open_threads[idx]["closed_in"] = str(log["last_chapter"])
+            log["closed_threads"].append(open_threads[idx])
+            log["last_updated"] = datetime.now().isoformat()
+            save_log(log, log_path)
+            print(f"  ✓ Thread [{idx}] closed: {open_threads[idx]['thread'][:60]}")
+        else:
+            print(f"  ✗ Invalid thread index: {idx}")
+
+    elif cmd == "threads":
+        log = load_log(log_path)
+        if not log:
+            sys.exit(1)
+        open_threads = [t for t in log["open_threads"] if not t.get("closed")]
+        print(f"\n  Open threads ({len(open_threads)}):\n")
+        for i, t in enumerate(open_threads):
+            print(f"  [{i}] Introduced Ch.{t.get('introduced_in', '?')}: {t['thread']}")
+        print()