@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/workflows/update-idea.md

@@ -0,0 +1,157 @@
+<purpose>
+Update an existing idea's fields (title, body, tags) interactively, or append a timestamped note via the --note flag. Enables idea refinement over time without losing the original capture.
+</purpose>
+
+<context_tier>lite</context_tier>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="load_context" priority="first">
+Load project context via tier system:
+
+```bash
+TIER_FILES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" context load-tier lite --raw 2>/dev/null)
+```
+
+Use `TIER_FILES` JSON `files` array for project context (PROJECT.md, STATE.md, config.json).
+</step>
+
+<step name="parse_arguments">
+Parse the arguments string:
+
+- Extract idea ID: first positional argument, or `--id N`
+- Check for `--note "text"` flag
+
+Examples:
+- `/dgs:update-idea 42` -> id=42, no note
+- `/dgs:update-idea 42 --note "This could also solve X"` -> id=42, note="This could also solve X"
+- `/dgs:update-idea --id 42 --note "Revisited this"` -> id=42, note="Revisited this"
+
+If no ID provided, list pending ideas and prompt user to select one:
+
+```bash
+PENDING=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs ideas list --state pending --raw)
+```
+
+Parse the JSON `ideas` array. If empty, display:
+```
+No pending ideas to update. Run /dgs:add-idea to capture one.
+```
+Exit.
+
+If ideas exist, display them as a numbered list and use AskUserQuestion:
+- header: "Select Idea"
+- question: "Which idea would you like to update?"
+- Provide the numbered idea options
+
+Extract the selected idea's ID.
+</step>
+
+<step name="find_idea">
+Look up the idea by ID across all states:
+
+```bash
+LIST=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs ideas list --raw)
+```
+
+Parse JSON, find the idea by ID. If not found:
+```
+Idea #${id} not found.
+```
+Exit.
+
+Note the idea's current state, title, tags, and body for display.
+</step>
+
+<step name="branch_note_or_interactive">
+**If `--note` flag is present:** Go to step "append_note".
+**Otherwise:** Go to step "interactive_update".
+</step>
+
+<step name="append_note">
+Append a timestamped note to the idea (per IDEAS-05):
+
+```bash
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs ideas append-note --id "${id}" --note "${noteText}" --raw
+```
+
+Parse JSON result to confirm success. Go to step "git_commit".
+</step>
+
+<step name="interactive_update">
+Show the user what currently exists for the idea:
+
+```
+## Idea #${id}: ${title}
+
+**Tags:** ${tags.join(", ") || "none"}
+**State:** ${state}
+
+${body}
+```
+
+Use AskUserQuestion to ask which field to change:
+- header: "Update Idea #${id}"
+- question: "Which field would you like to update?"
+- options: "Title", "Body", "Tags"
+
+Based on selection, use AskUserQuestion to prompt for the new value:
+
+**Title:** "Enter new title:" (show current as reference)
+**Body:** "Enter new body text:" (show current as reference)
+**Tags:** "Enter new tags (comma-separated):" (show current as reference)
+
+Then call:
+```bash
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs ideas update --id "${id}" --field "${field}" --value "${newValue}" --raw
+```
+
+Parse JSON result to confirm success. Go to step "git_commit".
+</step>
+
+<step name="git_commit">
+Determine the file path from the update/append-note result.
+
+Find the idea file to get the current path:
+```bash
+LIST=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs ideas list --raw)
+```
+
+Parse to find the idea's state and filename, then commit:
+
+```bash
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "ideas: update #${id} - ${field}" --files ${path}
+```
+
+For note appends, use:
+```bash
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "ideas: add note to #${id}" --files ${path}
+```
+</step>
+
+<step name="confirm">
+Display minimal confirmation:
+
+For note append:
+```
+Note added to Idea #${id}.
+```
+
+For field update:
+```
+Idea #${id} updated.
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Idea file updated with new field value or appended note
+- [ ] Updated timestamp in frontmatter
+- [ ] Git commit created
+- [ ] Minimal confirmation
+</success_criteria>

package/deliver-great-systems/workflows/update.md

@@ -0,0 +1,242 @@
+<purpose>
+Check for DGS updates via npm, display changelog for versions between installed and latest, obtain user confirmation, and execute clean installation with cache clearing.
+</purpose>
+
+<context_tier>none</context_tier>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="get_installed_version">
+Detect whether DGS is installed locally or globally by checking both locations and validating install integrity:
+
+```bash
+# Check local first (takes priority only if valid)
+# Detect runtime config directory (supports Claude, OpenCode, Gemini)
+LOCAL_VERSION_FILE="" LOCAL_MARKER_FILE="" LOCAL_DIR=""
+for dir in .claude .config/opencode .opencode .gemini; do
+  if [ -f "./$dir/deliver-great-systems/VERSION" ]; then
+    LOCAL_VERSION_FILE="./$dir/deliver-great-systems/VERSION"
+    LOCAL_MARKER_FILE="./$dir/deliver-great-systems/workflows/update.md"
+    LOCAL_DIR="$(cd "./$dir" 2>/dev/null && pwd)"
+    break
+  fi
+done
+GLOBAL_VERSION_FILE="" GLOBAL_MARKER_FILE="" GLOBAL_DIR=""
+for dir in .claude .config/opencode .opencode .gemini; do
+  if [ -f "$HOME/$dir/deliver-great-systems/VERSION" ]; then
+    GLOBAL_VERSION_FILE="$HOME/$dir/deliver-great-systems/VERSION"
+    GLOBAL_MARKER_FILE="$HOME/$dir/deliver-great-systems/workflows/update.md"
+    GLOBAL_DIR="$(cd "$HOME/$dir" 2>/dev/null && pwd)"
+    break
+  fi
+done
+
+# Only treat as LOCAL if the resolved paths differ (prevents misdetection when CWD=$HOME)
+IS_LOCAL=false
+if [ -n "$LOCAL_VERSION_FILE" ] && [ -f "$LOCAL_VERSION_FILE" ] && [ -f "$LOCAL_MARKER_FILE" ] && grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+' "$LOCAL_VERSION_FILE"; then
+  if [ -z "$GLOBAL_DIR" ] || [ "$LOCAL_DIR" != "$GLOBAL_DIR" ]; then
+    IS_LOCAL=true
+  fi
+fi
+
+if [ "$IS_LOCAL" = true ]; then
+  cat "$LOCAL_VERSION_FILE"
+  echo "LOCAL"
+elif [ -n "$GLOBAL_VERSION_FILE" ] && [ -f "$GLOBAL_VERSION_FILE" ] && [ -f "$GLOBAL_MARKER_FILE" ] && grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+' "$GLOBAL_VERSION_FILE"; then
+  cat "$GLOBAL_VERSION_FILE"
+  echo "GLOBAL"
+else
+  echo "UNKNOWN"
+fi
+```
+
+Parse output:
+- If last line is "LOCAL": local install is valid; installed version is first line; use `--local`
+- If last line is "GLOBAL": local missing/invalid, global install is valid; installed version is first line; use `--global`
+- If "UNKNOWN": proceed to install step (treat as version 0.0.0)
+
+**If VERSION file missing:**
+```
+## DGS Update
+
+**Installed version:** Unknown
+
+Your installation doesn't include version tracking.
+
+Running fresh install...
+```
+
+Proceed to install step (treat as version 0.0.0 for comparison).
+</step>
+
+<step name="check_latest_version">
+Check npm for latest version:
+
+```bash
+npm view @ktpartners/dgs-platform version 2>/dev/null
+```
+
+**If npm check fails:**
+```
+Couldn't check for updates (offline or npm unavailable).
+
+To update manually: `npx -y @ktpartners/dgs-platform@latest --global`
+```
+
+Exit.
+</step>
+
+<step name="compare_versions">
+Compare installed vs latest:
+
+**If installed == latest:**
+```
+## DGS Update
+
+**Installed:** X.Y.Z
+**Latest:** X.Y.Z
+
+You're already on the latest version.
+```
+
+Exit.
+
+**If installed > latest:**
+```
+## DGS Update
+
+**Installed:** X.Y.Z
+**Latest:** A.B.C
+
+You're ahead of the latest release (development version?).
+```
+
+Exit.
+</step>
+
+<step name="show_changes_and_confirm">
+**If update available**, fetch and show what's new BEFORE updating:
+
+1. Fetch changelog from GitHub raw URL
+2. Extract entries between installed and latest versions
+3. Display preview and ask for confirmation:
+
+```
+## DGS Update Available
+
+**Installed:** 1.5.10
+**Latest:** 1.5.15
+
+### What's New
+────────────────────────────────────────────────────────────
+
+## [1.5.15] - 2026-01-20
+
+### Added
+- Feature X
+
+## [1.5.14] - 2026-01-18
+
+### Fixed
+- Bug fix Y
+
+────────────────────────────────────────────────────────────
+
+⚠️  **Note:** The installer performs a clean install of DGS folders:
+- `commands/dgs/` will be wiped and replaced
+- `deliver-great-systems/` will be wiped and replaced
+- `agents/dgs-*` files will be replaced
+
+(Paths are relative to your install location: `~/.claude/` for global, `./.claude/` for local)
+
+Your custom files in other locations are preserved:
+- Custom commands not in `commands/dgs/` ✓
+- Custom agents not prefixed with `dgs-` ✓
+- Custom hooks ✓
+- Your CLAUDE.md files ✓
+
+If you've modified any DGS files directly, they'll be automatically backed up to `dgs-local-patches/` and can be reapplied with `/dgs:reapply-patches` after the update.
+```
+
+Use AskUserQuestion:
+- Question: "Proceed with update?"
+- Options:
+  - "Yes, update now"
+  - "No, cancel"
+
+**If user cancels:** Exit.
+</step>
+
+<step name="run_update">
+Run the update using the install type detected in step 1:
+
+**If LOCAL install:**
+```bash
+npx -y @ktpartners/dgs-platform@latest --local
+```
+
+**If GLOBAL install (or unknown):**
+```bash
+npx -y @ktpartners/dgs-platform@latest --global
+```
+
+Capture output. If install fails, show error and exit.
+
+Clear the update cache so statusline indicator disappears:
+
+```bash
+# Clear update cache across all runtime directories
+for dir in .claude .config/opencode .opencode .gemini; do
+  rm -f "./$dir/cache/dgs-update-check.json"
+  rm -f "$HOME/$dir/cache/dgs-update-check.json"
+done
+```
+
+The SessionStart hook (`dgs-check-update.js`) writes to the detected runtime's cache directory, so all paths must be cleared to prevent stale update indicators.
+</step>
+
+<step name="display_result">
+Format completion message (changelog was already shown in confirmation step):
+
+```
+╔═══════════════════════════════════════════════════════════╗
+║  DGS Updated: v1.5.10 → v1.5.15                           ║
+╚═══════════════════════════════════════════════════════════╝
+
+⚠️  Restart Claude Code to pick up the new commands.
+
+[View full changelog](https://github.com/glittercowboy/deliver-great-systems/blob/main/CHANGELOG.md)
+```
+</step>
+
+
+<step name="check_local_patches">
+After update completes, check if the installer detected and backed up any locally modified files:
+
+Check for dgs-local-patches/backup-meta.json in the config directory.
+
+**If patches found:**
+
+```
+Local patches were backed up before the update.
+Run /dgs:reapply-patches to merge your modifications into the new version.
+```
+
+**If no patches:** Continue normally.
+</step>
+</process>
+
+<success_criteria>
+- [ ] Installed version read correctly
+- [ ] Latest version checked via npm
+- [ ] Update skipped if already current
+- [ ] Changelog fetched and displayed BEFORE update
+- [ ] Clean install warning shown
+- [ ] User confirmation obtained
+- [ ] Update executed successfully
+- [ ] Restart reminder shown
+</success_criteria>

package/deliver-great-systems/workflows/validate-phase.md

@@ -0,0 +1,177 @@
+<purpose>
+Audit Nyquist validation gaps for a completed phase. Generate missing tests. Update VALIDATION.md.
+</purpose>
+
+<context_tier>verification</context_tier>
+
+<required_reading>
+@~/.claude/deliver-great-systems/references/ui-brand.md
+</required_reading>
+
+<process>
+
+## 0. Initialize
+
+```bash
+INIT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" init phase-op "${PHASE_ARG}")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Parse: `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`.
+
+**Load verification tier context:**
+
+```bash
+TIER_FILES=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" context load-tier verification --phase "${PHASE_ARG}" --raw 2>/dev/null)
+```
+
+This provides all execution-tier files plus VERIFICATION.md and UAT*.md. Keep operational reads of PLAN files for test auditing.
+
+```bash
+AUDITOR_MODEL=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" resolve-model dgs-nyquist-auditor --raw)
+NYQUIST_CFG=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" config get workflow.nyquist_validation --raw)
+```
+
+If `NYQUIST_CFG` is `false`: exit with "Nyquist validation is disabled. Enable via /dgs:settings."
+
+Display banner: `DGS > VALIDATE PHASE {N}: {name}`
+
+## 1. Detect Input State
+
+```bash
+VALIDATION_FILE=$(ls "${PHASE_DIR}"/*-VALIDATION.md 2>/dev/null | head -1)
+SUMMARY_FILES=$(ls "${PHASE_DIR}"/*-SUMMARY.md 2>/dev/null)
+```
+
+- **State A** (`VALIDATION_FILE` non-empty): Audit existing
+- **State B** (`VALIDATION_FILE` empty, `SUMMARY_FILES` non-empty): Reconstruct from artifacts
+- **State C** (`SUMMARY_FILES` empty): Exit — "Phase {N} not executed. Run /dgs:execute-phase {N} first."
+
+## 2. Discovery
+
+### 2a. Read Phase Artifacts
+
+Read all PLAN and SUMMARY files. Extract: task lists, requirement IDs, key-files changed, verify blocks.
+
+### 2b. Build Requirement-to-Task Map
+
+Per task: `{ task_id, plan_id, wave, requirement_ids, has_automated_command }`
+
+### 2c. Detect Test Infrastructure
+
+State A: Parse from existing VALIDATION.md Test Infrastructure table.
+State B: Filesystem scan:
+
+```bash
+find . -name "pytest.ini" -o -name "jest.config.*" -o -name "vitest.config.*" -o -name "pyproject.toml" 2>/dev/null | head -10
+find . \( -name "*.test.*" -o -name "*.spec.*" -o -name "test_*" \) -not -path "*/node_modules/*" 2>/dev/null | head -40
+```
+
+### 2d. Cross-Reference
+
+Match each requirement to existing tests by filename, imports, test descriptions. Record: requirement → test_file → status.
+
+## 3. Gap Analysis
+
+Classify each requirement:
+
+| Status | Criteria |
+|--------|----------|
+| COVERED | Test exists, targets behavior, runs green |
+| PARTIAL | Test exists, failing or incomplete |
+| MISSING | No test found |
+
+Build: `{ task_id, requirement, gap_type, suggested_test_path, suggested_command }`
+
+No gaps → skip to Step 6, set `nyquist_compliant: true`.
+
+## 4. Present Gap Plan
+
+Call AskUserQuestion with gap table and options:
+1. "Fix all gaps" → Step 5
+2. "Skip — mark manual-only" → add to Manual-Only, Step 6
+3. "Cancel" → exit
+
+## 5. Spawn dgs-nyquist-auditor
+
+```
+Task(
+  prompt="Read ~/.claude/agents/dgs-nyquist-auditor.md for instructions.\n\n" +
+    "<files_to_read>{PLAN, SUMMARY, impl files, VALIDATION.md}</files_to_read>" +
+    "<gaps>{gap list}</gaps>" +
+    "<test_infrastructure>{framework, config, commands}</test_infrastructure>" +
+    "<constraints>Never modify impl files. Max 3 debug iterations. Escalate impl bugs.</constraints>",
+  subagent_type="dgs-nyquist-auditor",
+  model="{AUDITOR_MODEL}",
+  description="Fill validation gaps for Phase {N}"
+)
+```
+
+Handle return:
+- `## GAPS FILLED` → record tests + map updates, Step 6
+- `## PARTIAL` → record resolved, move escalated to manual-only, Step 6
+- `## ESCALATE` → move all to manual-only, Step 6
+
+## 6. Generate/Update VALIDATION.md
+
+**State B (create):**
+1. Read template from `~/.claude/deliver-great-systems/templates/VALIDATION.md`
+2. Fill: frontmatter, Test Infrastructure, Per-Task Map, Manual-Only, Sign-Off
+3. Write to `${PHASE_DIR}/${PADDED_PHASE}-VALIDATION.md`
+
+**State A (update):**
+1. Update Per-Task Map statuses, add escalated to Manual-Only, update frontmatter
+2. Append audit trail:
+
+```markdown
+## Validation Audit {date}
+| Metric | Count |
+|--------|-------|
+| Gaps found | {N} |
+| Resolved | {M} |
+| Escalated | {K} |
+```
+
+## 7. Commit
+
+```bash
+git add {test_files}
+git commit -m "test(phase-${PHASE}): add Nyquist validation tests"
+
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit-docs "docs(phase-${PHASE}): add/update validation strategy"
+```
+
+## 8. Results + Routing
+
+**Compliant:**
+```
+DGS > PHASE {N} IS NYQUIST-COMPLIANT
+All requirements have automated verification.
+▶ Next: /dgs:audit-milestone
+```
+
+**Partial:**
+```
+DGS > PHASE {N} VALIDATED (PARTIAL)
+{M} automated, {K} manual-only.
+▶ Retry: /dgs:validate-phase {N}
+```
+
+Display `/clear` reminder.
+
+</process>
+
+<success_criteria>
+- [ ] Nyquist config checked (exit if disabled)
+- [ ] Input state detected (A/B/C)
+- [ ] State C exits cleanly
+- [ ] PLAN/SUMMARY files read, requirement map built
+- [ ] Test infrastructure detected
+- [ ] Gaps classified (COVERED/PARTIAL/MISSING)
+- [ ] User gate with gap table
+- [ ] Auditor spawned with complete context
+- [ ] All three return formats handled
+- [ ] VALIDATION.md created or updated
+- [ ] Test files committed separately
+- [ ] Results with routing presented
+</success_criteria>