@pantion/mcp-server 0.1.0

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,252 @@
+# /pantion-redialog — Re-evaluate a converged canon with a better model
+
+A converged canon was conducted by a specific model at a specific time. A newer or more capable model may identify gaps: questions that should have been asked, assumptions that were never made explicit, edge cases that were not explored.
+
+This command reads an existing converged canon, produces a gap analysis, and conducts a targeted supplementary dialog to fill those gaps. The original dialog stays intact (append-only).
+
+**Alias:** `/pantion-reconverge`
+
+---
+
+## WHEN YOU ARRIVE HERE
+
+- You have access to a more capable model than the one that conducted the original dialog
+- You suspect the original convergence was too shallow (missing edge cases, vague answers accepted)
+- New domain knowledge has emerged since the original convergence
+- A `/pantion-check` recommended a redialog
+- Periodic re-evaluation of an important canon
+
+---
+
+## STEP 1: IDENTIFY THE CANON
+
+Ask the user (or detect from context):
+
+"Which canon do you want to redialog?"
+
+Options:
+- `canon/dialogspec-dialog.md` (standalone)
+- `canon/architect-dialog.md` (system level)
+- `canon/components/component-[name]-dialog.md` (component)
+
+Read the chosen dialog file (the canon). Verify that the status is CONVERGED, CONVERGED (QUICK), CONVERGED (REVERSE), AMENDED, or RECONVERGED.
+
+If the status is DRAFT: "This canon is not yet converged. Use `/pantion-resume` to continue converging first."
+
+---
+
+## STEP 2: GAP ANALYSIS
+
+Read the entire dialog carefully. Evaluate it against the current convergence standard.
+
+Analyze across six dimensions:
+
+### 1. Unexplored convergence elements
+Check the standard convergence checklist:
+- [ ] Intent: is it truly unambiguous, or just vaguely stated?
+- [ ] Success criteria: are they externally verifiable, or just "it works"?
+- [ ] Inputs: are ALL inputs named (explicit + implicit + defaults)?
+- [ ] Outputs: are they observable and concrete?
+- [ ] Failure behavior: is it specified for each failure mode, not just happy path?
+- [ ] Constraints: are they absolute, or "unless convenient"?
+- [ ] Non-goals: are they specific enough to be enforceable?
+- [ ] Authority Budget Rights: are all six fields addressed?
+- [ ] Authority Budget Consumption: are rate/cost limits specified?
+- [ ] Persistence/restart behavior: is it addressed?
+
+For each item: is it covered in the dialog? Is the coverage deep enough?
+
+### 2. Implicit assumptions
+Identify statements where the original model or user assumed something without making it explicit:
+- Technology assumptions embedded in language
+- User base assumptions (who will use this?)
+- Scale assumptions (how much data? how many users?)
+- Environment assumptions (where will this run?)
+
+### 3. Ambiguous resolutions
+Find places where the original model accepted a vague answer:
+- "It should be fast" → how fast? Under what conditions?
+- "Standard security" → which standard? What threat model?
+- "Handle errors gracefully" → which errors? What is graceful?
+
+### 4. Missing edge cases
+Identify failure modes and boundary conditions not discussed:
+- What happens when input is malformed?
+- What happens at scale limits?
+- What happens when dependencies fail?
+- What about concurrent access, race conditions?
+- What about data migration, versioning?
+
+### 5. Authority budget gaps
+- Are forbidden actions truly complete, or only obvious ones?
+- Is data retention addressed with specific timeframes?
+- Are audit requirements concrete?
+- For consumption: are limits realistic and enforceable?
+
+### 6. Interface gaps (for decomposed systems)
+- Are all five contract fields present per interface?
+- Is the data shape concrete enough to implement?
+- Are error semantics specific (not just "it fails")?
+- Are rate/cost expectations realistic?
+
+---
+
+## STEP 3: PRESENT GAP ANALYSIS
+
+Present the findings to the user:
+
+"I've analyzed the existing dialog and found [N] areas that could benefit from deeper exploration:
+
+**Critical gaps** (likely to cause implementation problems):
+1. [gap]: [why it matters]
+2. [gap]: [why it matters]
+
+**Moderate gaps** (may lead to assumptions during implementation):
+3. [gap]: [why it matters]
+4. [gap]: [why it matters]
+
+**Minor gaps** (nice to have, would improve precision):
+5. [gap]: [why it matters]
+
+Would you like to:
+A) Explore all gaps
+B) Select specific gaps to explore (give me the numbers)
+C) Skip — the canon is fine as-is"
+
+**If the user chooses C**: stop. The canon remains unchanged. Say: "Understood. The canon stays at its current status."
+
+**If no gaps are found**: "I've analyzed the dialog and the convergence looks solid. No significant gaps found. The canon stays at its current status."
+
+---
+
+## STEP 4: REDIALOG
+
+For each selected gap, conduct a targeted dialog:
+
+1. Explain WHY this area needs attention (what the original dialog missed)
+2. Ask specific questions to resolve the gap
+3. Classify answers as HARD or FLEX
+4. Move to the next gap when the current one is resolved
+
+### Rules during redialog:
+- Ask ONE question at a time — wait for the answer before asking the next
+- The original dialog is NOT modified (append-only)
+- New answers may override FLEX decisions from the original dialog
+- New answers may NOT override HARD constraints (those require `/pantion-amend`)
+- If the user contradicts a HARD constraint: "This conflicts with a HARD constraint from the original dialog: [quote]. To change this, use `/pantion-amend`."
+- Redialog OQ-IDs start at OQ-101 to distinguish from original questions (e.g. `OPEN QUESTION [OQ-101]: ...`)
+
+### Saving the redialog
+
+**Append** the redialog section to the existing dialog file:
+
+    --- REDIALOG [date] ---
+    GAP ANALYSIS:
+      1. [gap description]
+      2. [gap description]
+      ...
+    SELECTED BY USER: [numbers or "all"]
+
+    ASSISTANT: [redialog question]
+
+    HUMAN: [user answer]
+
+    ASSISTANT: [follow-up or next gap question]
+
+    HUMAN: [user answer]
+
+    ...
+
+    --- /REDIALOG ---
+
+---
+
+## STEP 5: UPDATE STAMP
+
+Replace the convergence stamp with an updated stamp:
+
+    === DIALOGSPEC STAMP ===
+    STATUS: RECONVERGED
+    DATE: [today]
+    MODEL: [model-id (Display Name), e.g. claude-opus-4-6 (Claude Opus 4.6)]
+    CANON TYPE: [unchanged from original]
+    PARENT: [unchanged from original]
+    PREVIOUS STATUS: [original status] (original date: [date])
+    REDIALOG: [N] gaps identified, [M] explored, [K] resolved
+    OPEN QUESTIONS: none
+    INFERENCE POLICY: [unchanged or updated]
+    AUTHORITY BUDGET RIGHTS: complete
+    AUTHORITY BUDGET CONSUMPTION: complete | n/a
+    STABILITY ZONES: [updated list]
+    FLEX ZONES: [updated list]
+    INHERITED CONSTRAINTS: [unchanged]
+    INTERFACE CANONS: [unchanged]
+    === /DIALOGSPEC STAMP ===
+
+---
+
+## STEP 6: REGENERATE DERIVED FILES
+
+1. **Regenerate the summary** from the complete dialog (including the redialog section)
+2. Determine which spec files are affected (via `canon/traceability.md`)
+3. Regenerate affected spec files
+4. Update `canon/traceability.md`
+
+---
+
+## STEP 7: UPDATE CANON INDEX
+
+Update `canon/index.md`:
+- Update STATUS to RECONVERGED
+- Log the redialog (date + number of gaps explored)
+- Update "Last modified"
+- Remove any Open Questions that were resolved
+- Add any new Open Questions discovered during the redialog
+
+---
+
+## STEP 8: REPORT
+
+Say:
+
+"Redialog complete for [canon name].
+
+**Gap analysis:** [N] gaps identified, [M] explored, [K] resolved
+
+**Gaps explored:**
+- [gap 1]: [resolved / new HARD / new FLEX / opened as question]
+- [gap 2]: [resolved / ...]
+
+**Regenerated files:**
+- [list of files]
+
+**New insights:**
+- [any significant new information from the redialog]
+
+The canon is now RECONVERGED. The original dialog is preserved — the redialog has been appended.
+
+Would you like to review the updated summary, or proceed to regenerating the implementation?"
+
+---
+
+## FOR HIERARCHICAL SYSTEMS
+
+When redialoging an Architect Canon:
+- The gap analysis also evaluates system-wide coverage and decomposition clarity
+- After redialoging the architect level, consider whether component or interface canons also need a redialog
+- Present this to the user: "The architect canon has been redialoged. Based on the changes, the following component/interface canons may also benefit from a redialog: [list]. Would you like to proceed?"
+
+When redialoging a Component Canon:
+- Check that redialog findings do not violate inherited constraints
+- If they do: "This finding conflicts with an inherited constraint from the Architect Canon. Use `/pantion-amend` on the Architect Canon first."
+
+---
+
+## ITERATIVE REDIALOG
+
+A canon may be redialoged multiple times. Each redialog is appended as a separate section. The stamp always reflects the latest state:
+
+    STATUS: RECONVERGED
+    PREVIOUS STATUS: RECONVERGED (previous redialog: [date])
+
+This enables iterative deepening as models improve over time.

package/protocol/commands/reskill.md

@@ -0,0 +1,73 @@
+# /pantion-reskill — Re-evaluate an existing dynamic skill
+
+Re-evaluate an existing dynamic skill'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 skill's domain knowledge
+- The skill has proven insufficient in practice (agents still get things wrong)
+- New domain knowledge has emerged since the skill 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 reskill. Verify:
+- The skill exists in skills/{name}/
+- The skill has a canon in skills/{name}/canon/skill-dialog.md
+- The canon is CONVERGED (not DRAFT)
+
+If no canon exists: "This is a hand-crafted skill without a canon. Use `/pantion-create-skill` to create a dynamic version."
+
+---
+
+## STEP 2: GAP ANALYSIS
+
+Read the skill canon dialog. Analyze across these skill-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 skill 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 skill canon (append-only)
+2. Regenerate all skill files from the updated canon
+3. Each regenerated file gets an updated derivation comment
+
+---
+
+## STEP 5: REPORT
+
+"Reskill complete for '{name}'.
+
+**Gaps explored:** [list]
+**Skill files regenerated:** [list]
+**New domain knowledge added:** [summary]
+
+The skill canon has been updated (append-only). Use this skill in your next convergence dialog to benefit from the improved domain knowledge."

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