@pantion/dialogs 0.2.1

package/protocol/commands/quick.md

@@ -0,0 +1,170 @@
+> **Legacy**: This file is kept for backward compatibility. New sessions use "dialog" mode. See `dialog.md`.
+
+# /pantion-quick — Quick prototyping (experiment mode)
+
+You are now in Pantion Quick mode. This is the accelerated variant for prototyping and discovery.
+You follow the same protocol as /pantion-start, but with these adjustments:
+
+---
+
+## Difference from /pantion-start
+
+| Aspect | /pantion-start | /pantion-quick |
+|--------|---------------|----------------|
+| Questions | Resolve all ambiguity | Only ask critical questions |
+| Assumptions | None (OPEN QUESTION) | Make conservative assumptions |
+| Authority Budget | Cover completely | Cover basics, rest with conservative defaults |
+| Non-goals | Document explicitly | Document basics |
+| Build speed | After full convergence | After sufficient convergence |
+| Marking | Everything is checked | Assumptions are marked with lightning |
+
+---
+
+## PHASE 1: QUICK CONVERGENCE
+
+### Start
+Say:
+
+"Quick mode: I'll get moving fast. I'll only ask the crucial questions and make conservative assumptions for the rest. I'll mark those so you can adjust them later. Tell me what you want to build."
+
+### Rules
+1. Ask ONE question at a time — wait for the answer before asking the next
+2. Ask at most 5-8 essential questions (don't exhaustively converge)
+3. Focus on: what does it do, for whom, what are the hard boundaries
+4. On ambiguity: make a conservative assumption and mark with ASSUMPTION
+5. Authority budget: use conservative defaults where not explicitly discussed
+6. Non-goals: base on what logically is NOT in scope
+
+### Conservative defaults for undiscussed elements:
+- **Data retention**: store nothing unless explicitly requested
+- **Data access**: only what is minimally necessary
+- **Rate limits**: no explicit limits (but note as ASSUMPTION)
+- **Auditability**: basic logging
+- **Failure behavior**: graceful fail with user notification
+- **Inference policy**: conservative
+
+### Saving the dialog (CRITICAL — the dialog IS the canon)
+
+Same principle as /pantion-start: the verbatim dialog is always saved.
+
+**Two files are always produced:**
+- `canon/{naam}/dialog.md` — THE CANON: the verbatim dialog (quick status is in the stamp, not the filename)
+- `canon/{naam}/summary.md` — DERIVED: structured summary for navigation
+
+### Convergence Verification Table (quick variant)
+
+Before the stamp, include the verification table (with assumptions marked):
+
+    **Convergence Verification:**
+
+    | Criterium | Status |
+    |-----------|--------|
+    | Canon status | ✅ |
+    | Intent clarity | ✅ |
+    | Observable success | ✅ |
+    | Inputs complete | ✅ |
+    | Outputs unambiguous | ✅ |
+    | Failure specified | ⚡ ASSUMPTION: graceful fail |
+    | Constraints absolute | ✅ |
+    | Non-goals documented | ⚡ ASSUMPTION: basic non-goals |
+    | Ambiguity handled | ⚡ ASSUMPTION: conservative |
+    | Authority Budget | ⚡ ASSUMPTION: conservative defaults |
+    | Inference Policy | ✅ conservative |
+    | Dialog stability | ✅ |
+
+    **Conclusion:** Sufficient for quick prototype. [N] assumptions made — see assumptions list.
+
+### Convergence Stamp (quick variant)
+
+The stamp is placed at the top of the dialog file:
+
+    === DIALOGSPEC STAMP ===
+    STATUS: CONVERGED (QUICK)
+    DATE: [today]
+    MODEL: [model-id (Display Name), e.g. claude-opus-4-6 (Claude Opus 4.6)]
+    CANON TYPE: standalone
+    PARENT: none
+    OPEN QUESTIONS: none (assumptions marked)
+    INFERENCE POLICY: conservative
+    AUTHORITY BUDGET: partial (conservative defaults for undiscussed elements)
+    STABILITY ZONES: [HARD invariants]
+    FLEX ZONES: [FLEX defaults + assumptions]
+    ASSUMPTIONS: [list of all assumptions]
+    === /DIALOGSPEC STAMP ===
+
+Save the verbatim dialog as `canon/{naam}/dialog.md`.
+Generate the derived summary as `canon/{naam}/summary.md`.
+
+---
+
+## PHASE 2: QUICK TRANSLATION
+
+Generate the same files as /pantion-start, but:
+- Mark all assumptions with `ASSUMPTION:` in the files
+- Keep files shorter and more pragmatic
+- Skip command files unless there are clear workflows
+
+All derived files point to the dialog: `<!-- Derived from: canon/{naam}/dialog.md, [date] -->`
+
+### Extra file:
+
+**`canon/assumptions.md`**
+
+List all assumptions made in quick mode with their conservative defaults. Reference to the dialog turns where the assumption was made. Each assumption can be replaced with an explicit choice via /pantion-amend.
+
+---
+
+## PHASE 3: QUICK BUILD
+
+Build the system with the same rules as /pantion-start.
+
+### Extra after building:
+
+Say:
+
+"Prototype is built. I made [N] assumptions.
+Here are the most important ones:
+
+1. [assumption 1]
+2. [assumption 2]
+3. [assumption 3]
+
+Want to adjust any of these? Or would you like to run the full protocol with /pantion-start?"
+
+---
+
+## When to escalate
+
+### To /pantion-start (full protocol)
+
+If during quick mode it becomes clear that:
+- There are safety-critical aspects that cannot be covered by assumptions
+- The user corrects assumptions multiple times
+- Authority Budget questions are too complex for conservative defaults
+
+Then say:
+"This system has aspects that cannot be covered by assumptions. I recommend switching to /pantion-start for the full protocol. The quick dialog will be carried over as a starting point."
+
+### To /pantion-decompose (split up)
+
+If during quick mode it becomes clear that:
+- Multiple independent modules/interfaces are emerging
+- The Decompose Score is 3 or higher (see /pantion-start for criteria)
+- Different parts have fundamentally different rights/restrictions
+
+Then say:
+"This system is too large for a single quick canon. I recommend switching to /pantion-decompose. I'll carry the quick dialog over as input for the Architect Canon — what we already know doesn't need to be discussed again."
+
+When switching to decompose:
+1. Save the current quick dialog as DRAFT
+2. Start /pantion-decompose
+3. Use the quick dialog as starting point (don't start from scratch)
+4. Mark in `canon/index.md` that the quick canon has been absorbed into the Architect Canon
+
+## Canon Index
+
+Update `canon/index.md` when completing a quick session:
+- Status: CONVERGED (QUICK)
+- References to both dialog file and summary file
+- List of all assumptions
+- Reference to `canon/assumptions.md`

package/protocol/commands/redialog.md

@@ -0,0 +1,73 @@
+# /pantion-redialog — Re-evaluate an existing dynamic dialog
+
+Re-evaluate an existing dynamic dialog's canon with a better model. Identifies gaps in domain knowledge and conducts supplementary convergence.
+
+---
+
+## WHEN YOU ARRIVE HERE
+
+- A better model is available and you want to deepen the dialog's domain knowledge
+- The dialog has proven insufficient in practice (agents still get things wrong)
+- New domain knowledge has emerged since the dialog was created
+- Periodic review of an important skill
+
+---
+
+## RULES
+
+1. Ask ONE question at a time — wait for the answer before asking the next
+2. The original skill dialog is append-only — never edit or delete
+3. Focus on GAPS — things that should have been asked but weren't
+4. The user is still the domain expert
+
+---
+
+## STEP 1: IDENTIFY THE SKILL
+
+Ask the user which skill to redialog. Verify:
+- The dialog exists in dialogs/{name}/
+- The dialog has a canon in dialogs/{name}/canon/dialog.md
+- The canon is CONVERGED (not DRAFT)
+
+If no canon exists: "This is a hand-crafted skill without a canon. Use `/pantion-create-dialog` to create a dynamic version."
+
+---
+
+## STEP 2: GAP ANALYSIS
+
+Read the dialog canon dialog. Analyze across these dialog-specific dimensions:
+
+1. **Missing domain questions**: Are there convergence questions that should be asked but aren't in the rules?
+2. **Incomplete anti-patterns**: Are there agent mistakes not covered?
+3. **Vague guidance**: Are any rules too vague to be actionable?
+4. **Output gaps**: Is the translation specification complete?
+5. **Vocabulary gaps**: Are there domain terms not explained?
+6. **Real-world gaps**: Based on actual use, what did the dialog fail to guide?
+
+Present the gap analysis and let the user choose which gaps to explore.
+
+---
+
+## STEP 3: SUPPLEMENTARY DIALOG
+
+Conduct a targeted dialog for selected gaps. Append to the existing canon (append-only).
+
+---
+
+## STEP 4: UPDATE AND REGENERATE
+
+1. Save the updated dialog canon (append-only)
+2. Regenerate all dialog files from the updated canon
+3. Each regenerated file gets an updated derivation comment
+
+---
+
+## STEP 5: REPORT
+
+"Redialog complete for '{name}'.
+
+**Gaps explored:** [list]
+**Dialog files regenerated:** [list]
+**New domain knowledge added:** [summary]
+
+The dialog canon has been updated (append-only). Use this dialog in your next convergence dialog to benefit from the improved domain knowledge."

package/protocol/commands/reflect.md

@@ -0,0 +1,136 @@
+# /pantion-reflect — Reality Convergence (Post-Build Learning)
+
+Capture empirical observations from a built implementation back into the canon. Reality Convergence is **observational** — it records, classifies, links, and creates open questions. It does NOT modify intent. Intent changes require a separate `pantion_amend` with HUMAN STAMP approval.
+
+## When to Use
+
+After building from a canon, deploying, and observing the result. The canon was correct at convergence time, but reality reveals information that was impossible to know before the build.
+
+## Prerequisites
+
+- Canon must be CONVERGED, AMENDED, or RECONVERGED (not DRAFT)
+- Something must have been built from this canon
+- The user has observations from the real implementation
+
+## Guardrails
+
+1. Reality Convergence may **NOT** disable HARD constraints or silently modify intent
+2. It may **ONLY**: record observations, link to canon anchors, classify, create open questions, propose amendment candidates
+3. Intent changes remain an explicit, human decision via `pantion_amend` + approval gate
+4. The HUMAN STAMP is **NOT** affected — RC is observational, not authoritative
+5. The canon lifecycle status is **NOT** changed — RC is an overlay, not a status transition
+
+---
+
+## STEP 1: IDENTIFY THE CANON
+
+Ask: "Which canon do you want to reflect on with reality feedback?"
+
+Read the chosen dialog file. Verify it is not DRAFT.
+
+---
+
+## STEP 2: BUILD CONTEXT
+
+Ask: "What was built from this canon? When was it deployed? How long has it been running? What environment (production/staging/local)?"
+
+This context frames the observations. A system running for 6 months produces deeper feedback than one tested for a day.
+
+---
+
+## STEP 3: REALITY CONVERGENCE DIALOG
+
+Conduct a structured dialog. Ask ONE question at a time.
+
+### 3a. Confirmed Intent
+"What worked exactly as described in the canon?"
+
+### 3b. Surprises
+"What surprised you — positively or negatively?"
+
+### 3c. Incorrect Assumptions
+"Which assumptions from the canon turned out to be wrong in practice?"
+
+### 3d. Observed Failure Modes
+"What failure modes did you actually see? Were they covered by the canon?"
+
+### 3e. Classification
+For each observation, classify:
+- **intent-mismatch**: the canon said X but we actually meant Y
+- **unknown-unknown**: something we couldn't have predicted
+- **hard-constraint-conflict**: reality violates a HARD constraint
+- **implementation-gap**: the intent was clear but the build missed it
+
+### 3f. Canon Anchors
+For each observation, link to relevant canon anchors (H[n], A[n]), acceptance tests (AT-nnn), and behavior map entries.
+
+---
+
+## STEP 4: PRODUCE STRUCTURED BLOCK
+
+Format the observations as a structured REALITY CONVERGENCE block:
+
+    --- REALITY CONVERGENCE [date] ---
+    BUILD REF: [path to collapse manifest or description]
+    ENV: production | staging | local
+    SCOPE: [which parts of the system were observed]
+
+    OBSERVATIONS:
+    - RC-001: [observation description]
+      RELATED: [canon anchors, acceptance tests]
+      CLASS: [intent-mismatch | unknown-unknown | hard-constraint-conflict | implementation-gap]
+      EVIDENCE: [optional — logs, metrics, user feedback, or "none"]
+      OPEN QUESTION: OQ-[nnn] (if applicable)
+
+    - RC-002: [next observation]
+      ...
+
+    OUTCOME:
+    - [n] open questions created (OQ-nnn..nnn)
+    - Proposed amendment areas: [list with HARD/FLEX classification]
+    --- /REALITY CONVERGENCE ---
+
+---
+
+## STEP 5: REALITY STAMP (overlay)
+
+Produce a REALITY STAMP that tracks reality-coverage as an overlay on the canon (does NOT replace the DIALOGSPEC STAMP):
+
+    === REALITY STAMP ===
+    STATUS: VALIDATED (PARTIAL) | VALIDATED (FULL)
+    COVERS: [n] acceptance tests, [n] behaviors
+    OPEN QUESTIONS: [list or "none"]
+    LAST BUILD REF: [reference]
+    DATE: [date]
+    === /REALITY STAMP ===
+
+---
+
+## STEP 6: SAVE AND REPORT
+
+Call `pantion_reflect` with:
+- `canon_name`: the canon name
+- `reflection_dialog`: the complete reality convergence dialog
+- `stamp`: the raw REALITY STAMP text
+
+Report:
+- Confirmed intent (what worked)
+- Observations with classifications
+- Open questions created
+- Proposed amendment candidates
+
+Offer next steps:
+- Use `pantion_amend` to apply intent changes where needed (requires HUMAN STAMP approval)
+- Run `pantion_check` to verify consistency
+- Re-translate if amendments are made
+
+---
+
+## IMPORTANT
+
+- **RC observes. Amend changes.** Never conflate the two.
+- A canon can be reflected on multiple times — each build cycle may produce new observations
+- Open questions from RC use IDs starting at OQ-201+ to distinguish from convergence OQs
+- During future reconvergence, the model has access to both the original dialog AND the reality observations
+- The REALITY STAMP is cumulative: each reflection updates coverage
+- EVIDENCE is optional — low-friction capture is the priority. Teams that have logs or metrics can attach them; teams without can still capture valuable observations

package/protocol/commands/resume.md

@@ -0,0 +1,148 @@
+# /pantion-resume — Continue converging on an existing DRAFT canon
+
+You have one or more canons that are not yet fully converged.
+You pick up where you left off.
+
+---
+
+## WHEN YOU ARRIVE HERE
+
+- A previous `/pantion-start` session was not completed (STATUS: DRAFT)
+- There are OPEN QUESTIONS in `canon/index.md` that need to be answered
+- A large decomposition spans multiple sessions
+- After stakeholder feedback on a DRAFT canon
+
+---
+
+## STEP 1: RESTORE CONTEXT
+
+Read `canon/index.md` and identify:
+
+1. Which canons exist?
+2. Which have STATUS: DRAFT?
+3. Which OPEN QUESTIONS are there?
+
+Then read the **dialog file** (the canon) to restore full context. The dialog contains the complete history of all previous sessions.
+
+Report:
+
+"Welcome back. Here is the current state:
+
+**Canons:**
+- [canon name]: [STATUS] — [N] open questions
+
+**Open Questions (most important first):**
+1. [question 1] (from [canon name])
+2. [question 2] (from [canon name])
+3. [question 3] (from [canon name])
+
+Would you like to work through the open questions, or do you want to tackle something else first?"
+
+---
+
+## STEP 2: WORK THROUGH OPEN QUESTIONS
+
+Take on the OPEN QUESTIONS one by one.
+
+### Rules:
+1. Ask ONE question at a time — wait for the answer before asking the next
+2. Read the dialog file (canon) to restore full context
+3. Re-pose the question, with context on why it was open
+4. Classify the answer as HARD or FLEX
+5. **Append the new dialog turns** to the existing dialog file (append-only — never edit previous turns)
+6. Remove the question from the Open Questions Backlog in `canon/index.md`
+
+### When new questions arise:
+If answering a question raises new questions:
+- Add them to the Open Questions Backlog
+- Continue with the current question
+
+### When there are dependencies:
+If a question depends on another canon (during decomposition):
+- Mark the dependency
+- Skip the question and move to the next
+- Come back when the dependent canon has been updated
+
+---
+
+## STEP 3: CONVERGENCE CHECK PER CANON
+
+After working through the questions, check per canon:
+
+- [ ] All OPEN QUESTIONS answered?
+- [ ] Intent is unambiguous?
+- [ ] Authority Budget is complete?
+- [ ] Failure behavior is specified?
+- [ ] Non-goals are documented?
+
+### If the canon is NOW converged:
+
+1. Update the stamp in the dialog file to CONVERGED:
+
+        === DIALOGSPEC STAMP ===
+        STATUS: CONVERGED
+        DATE: [today]
+        MODEL: [model-id (Display Name), e.g. claude-opus-4-6 (Claude Opus 4.6)]
+        CANON TYPE: [type]
+        PREVIOUS STATUS: DRAFT (resumed from [date of earlier session])
+        SESSIONS: [number of sessions to convergence]
+        OPEN QUESTIONS: none
+        ...
+        === /DIALOGSPEC STAMP ===
+
+2. **Regenerate** the derived summary (`canon/dialogspec-summary.md`) from the complete dialog
+3. Update `canon/index.md` with the new status
+
+### If questions are still open:
+
+1. Update the progress stamp in the dialog file:
+
+        === DIALOGSPEC PROGRESS ===
+        DATE: [today]
+        STATUS: DRAFT (session [N])
+        RESOLVED THIS SESSION: [list of answered questions]
+        REMAINING OPEN QUESTIONS: [list]
+        NEXT SESSION FOCUS: [suggestion for next session]
+        === /DIALOGSPEC PROGRESS ===
+
+2. **Regenerate** the derived summary from the dialog so far
+3. Update `canon/index.md`
+
+Say:
+
+"There are still [N] questions open. The most important ones for the next session:
+
+1. [question]
+2. [question]
+
+Progress has been saved. You can continue later with `/pantion-resume`."
+
+---
+
+## STEP 4: FLOW TO NEXT PHASE
+
+If ALL canons are CONVERGED:
+
+### For standalone:
+"All questions have been answered and the canon has converged. Would you like to generate the project files and build? (That's the same as `/pantion-translate` followed by the build phase.)"
+
+### For decomposition:
+"All canons have converged:
+- Architect Canon: completed
+- Interface Canons: completed ([N] interfaces)
+- Component Canons: completed ([N] components)
+
+Would you like to run the consistency check? (`/pantion-check`)"
+
+---
+
+## STEP 5: UPDATE CANON INDEX
+
+ALWAYS update `canon/index.md` at the end of a resume session:
+
+- Update status per canon
+- Remove resolved questions from backlog
+- Add new questions to backlog
+- Update "Last modified"
+- Log any amendments
+- Ensure references to both dialog file and summary file are present