@ktpartners/dgs-platform 2.9.0 → 3.3.0

package/bin/install.js

@@ -1806,6 +1806,50 @@ function install(isGlobal, runtime = 'claude') {
       });
       console.log(`  ${green}✓${reset} Configured context window monitor hook`);
     }
+
+    // Configure PreToolUse hook for workflow discipline enforcement
+    const disciplineCommand = isGlobal
+      ? buildHookCommand(targetDir, 'dgs-enforce-discipline.js')
+      : 'node ' + dirName + '/hooks/dgs-enforce-discipline.js';
+
+    if (!settings.hooks.PreToolUse) {
+      settings.hooks.PreToolUse = [];
+    }
+
+    const hasDisciplineHook = settings.hooks.PreToolUse.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('dgs-enforce-discipline'))
+    );
+
+    if (!hasDisciplineHook) {
+      settings.hooks.PreToolUse.push({
+        matcher: 'Edit|Write|Skill',
+        hooks: [
+          {
+            type: 'command',
+            command: disciplineCommand
+          }
+        ]
+      });
+      console.log(`  ${green}✓${reset} Configured workflow discipline hook`);
+    }
+
+    // Configure PostToolUse hook for discipline marker cleanup (Skill completion)
+    const hasDisciplinePostHook = settings.hooks.PostToolUse.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('dgs-enforce-discipline'))
+    );
+
+    if (!hasDisciplinePostHook) {
+      settings.hooks.PostToolUse.push({
+        matcher: 'Skill',
+        hooks: [
+          {
+            type: 'command',
+            command: disciplineCommand
+          }
+        ]
+      });
+      console.log(`  ${green}✓${reset} Configured discipline marker cleanup hook`);
+    }
   }
 
   // Write file manifest for future modification detection

package/commands/dgs/abandon-quick.md

@@ -0,0 +1,28 @@
+---
+name: dgs:abandon-quick
+description: Abandon active quick task — remove worktree without merging
+argument-hint: ""
+allowed-tools:
+  - Read
+  - Bash
+  - AskUserQuestion
+---
+<objective>
+Abandon the active product-level quick task.
+
+Remove the worktree directory and branch without merging any changes to main. All committed and uncommitted work in the worktree is discarded.
+
+Requires confirmation before proceeding. This action cannot be undone.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/abandon-quick.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+</context>
+
+<process>
+Execute the abandon-quick workflow from @~/.claude/deliver-great-systems/workflows/abandon-quick.md end-to-end.
+</process>

package/commands/dgs/add-tests.md

@@ -31,8 +31,8 @@ Output: Test files committed with message `test(phase-{N}): add unit and E2E tes
 <context>
 Phase: $ARGUMENTS
 
-@.planning/STATE.md
-@.planning/ROADMAP.md
+@${state_path}
+@${roadmap_path}
 </context>
 
 <process>

package/commands/dgs/audit-milestone.md

@@ -1,7 +1,7 @@
 ---
 name: dgs:audit-milestone
 description: Audit milestone completion against original intent before archiving
-argument-hint: "[version]"
+argument-hint: "[version] [--strict-audit]"
 allowed-tools:
   - Read
   - Glob
@@ -22,12 +22,13 @@ Verify milestone achieved its definition of done. Check requirements coverage, c
 
 <context>
 Version: $ARGUMENTS (optional — defaults to current milestone)
+Flags: `--strict-audit` (optional — preserves old strict behaviour where empty SUMMARY `requirements_completed` always yields `partial` regardless of VERIFICATION state; default omits this and applies REL-10 soft-tolerance).
 
 Core planning files are resolved in-workflow (`init milestone-op`) and loaded only as needed.
 
 **Completed Work:**
-Glob: .planning/phases/*/*-SUMMARY.md
-Glob: .planning/phases/*/*-VERIFICATION.md
+Glob: ${project_root}/phases/*/*-SUMMARY.md
+Glob: ${project_root}/phases/*/*-VERIFICATION.md
 </context>
 
 <process>

package/commands/dgs/capture-principle.md

@@ -11,7 +11,7 @@ allowed-tools:
 ---
 
 <objective>
-Extract a design principle from the current conversation context (e.g., a debugging session, root cause analysis, or architectural discussion) and save it to `.planning/docs/product/DESIGN-PRINCIPLES.md`.
+Extract a design principle from the current conversation context (e.g., a debugging session, root cause analysis, or architectural discussion) and save it to `docs/product/DESIGN-PRINCIPLES.md` in the planning repo.
 
 Principles are product-level artifacts — actionable rules distilled from hard-won lessons. They are loaded automatically by any workflow that reads product docs (Planning, Execution, and Verification tiers), preventing the same mistakes from recurring.
 </objective>
@@ -19,27 +19,27 @@ Principles are product-level artifacts — actionable rules distilled from hard-
 <context>
 Arguments: $ARGUMENTS (optional seed text for the principle)
 
-State is resolved in-process via `state load` and git repo root detection.
+State is resolved via `init milestone-op` which provides planning-repo-relative paths.
 </context>
 
 <process>
 
 ## 1. Resolve Target Path
 
-Determine where `DESIGN-PRINCIPLES.md` lives:
+Resolve the planning repo root and product docs path:
 
 ```bash
-REPO_ROOT=$(git rev-parse --show-toplevel)
+INIT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs init milestone-op)
 ```
 
-The target is always at `${REPO_ROOT}/.planning/docs/product/DESIGN-PRINCIPLES.md`.
+Extract `commit_docs` and `project_root` from the init JSON.
 
-Load state for commit_docs setting:
+Resolve the product docs directory:
 ```bash
-INIT=$(node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs state load)
+DOCS_DIR=$(node -e "const d = require('$HOME/.claude/deliver-great-systems/bin/lib/docs.cjs'); process.stdout.write(d.resolveDocsDir(process.cwd(), 'product'))")
 ```
 
-Extract `commit_docs` from the init JSON.
+The target is always at `${DOCS_DIR}/DESIGN-PRINCIPLES.md`.
 
 ## 2. Extract Principle from Context
 
@@ -71,7 +71,7 @@ If the user provides edits, incorporate them and re-present. If the user rejects
 
 ## 4. Read Existing DESIGN-PRINCIPLES.md
 
-Read `.planning/docs/product/DESIGN-PRINCIPLES.md` at the resolved path.
+Read `${DOCS_DIR}/DESIGN-PRINCIPLES.md`.
 
 If the file does **not** exist, create it with this template:
 
@@ -90,7 +90,7 @@ Actionable design rules distilled from project experience. Loaded automatically
 
 Also ensure the directory exists:
 ```bash
-mkdir -p "${REPO_ROOT}/.planning/docs/product"
+mkdir -p "${DOCS_DIR}"
 ```
 
 If the file exists, read and parse existing principles (look for `### ` headings under `## Principles`).
@@ -124,7 +124,7 @@ Use today's date for the `Added` field.
 
 If `commit_docs` is true:
 ```bash
-node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "docs: capture design principle - {title}" --push --files .planning/docs/product/DESIGN-PRINCIPLES.md
+node ~/.claude/deliver-great-systems/bin/dgs-tools.cjs commit "docs: capture design principle - {title}" --push --files docs/product/DESIGN-PRINCIPLES.md
 ```
 
 If `commit_docs` is false, just save the file without committing.

package/commands/dgs/cleanup.md

@@ -3,9 +3,9 @@ name: dgs:cleanup
 description: Archive milestone phase directories and clean up completed quick task directories
 ---
 <objective>
-Archive phase directories from completed milestones into `.planning/milestones/v{X.Y}-phases/`, and remove planning directories for completed quick/fast tasks from `.planning/quick/`.
+Archive phase directories from completed milestones into `${project_root}/milestones/v{X.Y}-phases/`, and remove planning directories for completed quick/fast tasks from `${project_root}/quick/`.
 
-Use when `.planning/phases/` has accumulated directories from past milestones, or `.planning/quick/` has many completed task directories.
+Use when `${project_root}/phases/` has accumulated directories from past milestones, or `${project_root}/quick/` has many completed task directories.
 </objective>
 
 <execution_context>

package/commands/dgs/complete-milestone.md

@@ -25,10 +25,10 @@ Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tag
 
 <context>
 **Project files:**
-- `.planning/ROADMAP.md`
-- `.planning/REQUIREMENTS.md`
-- `.planning/STATE.md`
-- `.planning/PROJECT.md`
+- `${roadmap_path}`
+- `${project_root}/REQUIREMENTS.md`
+- `${state_path}`
+- `${project_path}`
 
 **User input:**
 
@@ -41,7 +41,7 @@ Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tag
 
 0. **Check for audit:**
 
-   - Look for `.planning/v{{version}}-MILESTONE-AUDIT.md`
+   - Look for `${project_root}/v{{version}}-MILESTONE-AUDIT.md`
    - If missing or stale: recommend `/dgs:audit-milestone` first
    - If audit status is `gaps_found`: recommend `/dgs:plan-milestone-gaps` first
    - If audit status is `passed`: proceed to step 1
@@ -82,17 +82,17 @@ Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tag
 
 4. **Archive milestone:**
 
-   - Create `.planning/milestones/v{{version}}-ROADMAP.md`
+   - Create `${project_root}/milestones/v{{version}}-ROADMAP.md`
    - Extract full phase details from ROADMAP.md
    - Fill milestone-archive.md template
    - Update ROADMAP.md to one-line summary with link
 
 5. **Archive requirements:**
 
-   - Create `.planning/milestones/v{{version}}-REQUIREMENTS.md`
+   - Create `${project_root}/milestones/v{{version}}-REQUIREMENTS.md`
    - Mark all v1 requirements as complete (checkboxes checked)
    - Note requirement outcomes (validated, adjusted, dropped)
-   - Delete `.planning/REQUIREMENTS.md` (fresh one created for next milestone)
+   - Delete `${project_root}/REQUIREMENTS.md` (fresh one created for next milestone)
 
 6. **Update PROJECT.md:**
 
@@ -114,9 +114,9 @@ Output: Milestone archived (roadmap + requirements), PROJECT.md evolved, git tag
 
 <success_criteria>
 
-- Milestone archived to `.planning/milestones/v{{version}}-ROADMAP.md`
-- Requirements archived to `.planning/milestones/v{{version}}-REQUIREMENTS.md`
-- `.planning/REQUIREMENTS.md` deleted (fresh for next milestone)
+- Milestone archived to `${project_root}/milestones/v{{version}}-ROADMAP.md`
+- Requirements archived to `${project_root}/milestones/v{{version}}-REQUIREMENTS.md`
+- `${project_root}/REQUIREMENTS.md` deleted (fresh for next milestone)
 - ROADMAP.md collapsed to one-line entry
 - PROJECT.md updated with current state
 - Git tag v{{version}} created

package/commands/dgs/complete-quick.md

@@ -0,0 +1,28 @@
+---
+name: dgs:complete-quick
+description: Complete active quick task — rebase, merge to main, push, clean up worktree
+argument-hint: ""
+allowed-tools:
+  - Read
+  - Bash
+  - AskUserQuestion
+---
+<objective>
+Complete the active product-level quick task.
+
+Rebase the quick branch onto the latest base_branch, fast-forward merge to main, push to remote, and remove the worktree directory and branch.
+
+Only valid for product-level quicks. Milestone-context quicks merge with the milestone via /dgs:complete-milestone.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/complete-quick.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+</context>
+
+<process>
+Execute the complete-quick workflow from @~/.claude/deliver-great-systems/workflows/complete-quick.md end-to-end.
+</process>

package/commands/dgs/create-milestone-job.md

@@ -14,7 +14,7 @@ Generate a milestone build job that plans and executes all remaining phases, wit
 
 Purpose: Reads the roadmap, determines which phases still need work, generates the step sequence, shows it for approval, and writes the job file on confirmation.
 
-Output: Job file at `.planning/jobs/pending/milestone-{version}.md` ready for `/dgs:run-job`.
+Output: Job file at `jobs/pending/milestone-{version}.md` ready for `/dgs:run-job`.
 </objective>
 
 <execution_context>
@@ -26,7 +26,7 @@ Arguments: $ARGUMENTS
 
 Flags:
 - `version` (optional): Milestone version (e.g., `v6`). Auto-detects from ROADMAP.md if omitted.
-- `--no-check`: Skip audit-milestone and complete-milestone steps in the generated job.
+- `--no-check`: Skip the audit-milestone step in the generated job.
 
 State is resolved in-workflow via `dgs-tools.cjs jobs milestone-preview` and `jobs create-milestone`.
 </context>

package/commands/dgs/debug.md

@@ -22,7 +22,7 @@ User's issue: $ARGUMENTS
 
 Check for active sessions:
 ```bash
-ls .planning/debug/*.md 2>/dev/null | grep -v resolved | head -5
+ls ${project_root}/debug/*.md 2>/dev/null | grep -v resolved | head -5
 ```
 </context>
 
@@ -85,7 +85,7 @@ goal: find_and_fix
 </mode>
 
 <debug_file>
-Create: .planning/debug/{slug}.md
+Create: ${project_root}/debug/{slug}.md
 </debug_file>
 ```
 
@@ -130,7 +130,7 @@ Continue debugging {slug}. Evidence is in the debug file.
 
 <prior_state>
 <files_to_read>
-- .planning/debug/{slug}.md (Debug session state)
+- ${project_root}/debug/{slug}.md (Debug session state)
 </files_to_read>
 </prior_state>
 

package/commands/dgs/develop-idea.md

@@ -26,7 +26,7 @@ If discussion concludes that the idea is not viable, research is skipped entirel
 
 When re-running on an idea with prior history, the user is offered a choice: re-do both, just discuss, or just research.
 
-The output is a Discussion Log entry in the idea file, a research document at `.planning/docs/ideas/pending/{slug}-research.md`, and a Research Log entry in the idea file -- all committed at appropriate stages.
+The output is a Discussion Log entry in the idea file, a research document at `${project_root}/docs/ideas/pending/{slug}-research.md`, and a Research Log entry in the idea file -- all committed at appropriate stages.
 </objective>
 
 <execution_context>

package/commands/dgs/diff-report.md

@@ -0,0 +1,124 @@
+---
+name: dgs:diff-report
+description: Generate a diff report (REVIEW.md) on demand for any milestone or quick task
+argument-hint: "[version|--quick slug] [--detailed]"
+allowed-tools:
+  - Read
+  - Bash
+---
+
+# /dgs:diff-report -- On-Demand Diff Report
+
+Generate a REVIEW.md on demand without requiring audit-milestone or complete-quick.
+
+## Usage
+
+```
+/dgs:diff-report              -- Auto-detect: active quick task or current milestone
+/dgs:diff-report v21.0        -- Generate for a specific milestone version
+/dgs:diff-report --quick slug -- Generate for a specific quick task
+/dgs:diff-report --detailed   -- Use LLM-powered detailed analysis mode
+```
+
+## Steps
+
+<step name="parse_arguments">
+Parse $ARGUMENTS for:
+- A version string (e.g., `v21.0`, `v22.0`) — milestone target
+- `--quick <slug>` — quick task target with explicit slug
+- `--detailed` — pass through to underlying CLI command
+- No arguments — auto-detect mode
+
+Store as `TARGET_TYPE` (one of: `milestone`, `quick`, `auto`), `TARGET_VALUE` (version or slug, may be empty), and `DETAILED` (boolean).
+</step>
+
+<step name="detect_context">
+**If TARGET_TYPE is `auto`** (no version or --quick specified):
+
+Check for an active quick task first:
+```bash
+ACTIVE_QUICK=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" quick generate-review --raw 2>&1)
+QUICK_EXIT=$?
+```
+
+If `QUICK_EXIT` is 0 and the output contains `"generated": true` or `"fastForward": true`:
+- Set `TARGET_TYPE = quick` (auto-detected)
+- The command already ran and produced the review
+
+If `QUICK_EXIT` is non-zero (no active quick task):
+- Set `TARGET_TYPE = milestone` (fall back to current milestone)
+
+**If TARGET_TYPE is `milestone`:**
+Use the version argument if provided. Otherwise auto-detection happens inside the CLI command.
+
+**If TARGET_TYPE is `quick`:**
+Use the slug argument if provided. Otherwise auto-detection happens inside the CLI command.
+</step>
+
+<step name="show_context">
+Display what will be generated before proceeding:
+
+**If auto-detected quick task:**
+```
+Generating review for quick task...
+```
+
+**If milestone (with version):**
+```
+Generating review for milestone {version}...
+```
+
+**If milestone (auto-detect):**
+```
+Generating review for current milestone...
+```
+
+**If explicit quick task:**
+```
+Generating review for quick task {slug}...
+```
+</step>
+
+<step name="generate">
+Run the appropriate CLI command:
+
+**For milestone reports:**
+```bash
+RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" jobs generate-review ${TARGET_VALUE} ${DETAILED_FLAG} 2>&1)
+EXIT_CODE=$?
+```
+
+Where `${TARGET_VALUE}` is the version (e.g., `v21.0`) or empty for auto-detect, and `${DETAILED_FLAG}` is `--detailed` if requested or empty.
+
+**For quick task reports:**
+```bash
+RESULT=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" quick generate-review ${TARGET_VALUE} ${DETAILED_FLAG} 2>&1)
+EXIT_CODE=$?
+```
+
+Where `${TARGET_VALUE}` is the slug or empty for auto-detect.
+
+Note: If auto-detect already ran the quick command in step 2 and succeeded, skip re-running — use the result from step 2.
+</step>
+
+<step name="report">
+**If EXIT_CODE is 0:**
+
+Display the result from the CLI command (it includes file path and stats).
+
+**If EXIT_CODE is non-zero:**
+
+Display the error from the CLI command. The underlying commands already produce actionable error messages:
+- `No version specified and no active job found` — no milestone to generate for
+- `No active quick task found` — no quick task to generate for
+- `No job file found for [version]` — missing job file, need to run a milestone job first
+- `No code changes detected` — fast-forwarded quick task (informational, not an error)
+</step>
+
+## Success Criteria
+
+- [ ] Auto-detects quick task vs milestone context
+- [ ] Delegates to existing CLI commands (no code duplication)
+- [ ] --detailed flag passed through to underlying command
+- [ ] Shows context line before generating
+- [ ] Error messages are actionable (from underlying CLI commands)

package/commands/dgs/fast.md

@@ -1,7 +1,7 @@
 ---
 name: dgs:fast
 description: Make a trivial edit with a single atomic commit — no subagents, no ceremony
-argument-hint: "<description> [--dry-run]"
+argument-hint: "<description> [--dry-run] [--main]"
 allowed-tools:
   - Read
   - Write
@@ -20,6 +20,8 @@ Make a trivial edit and commit it atomically. Fast mode is the lightest DGS comm
 - Warns if scope exceeds 3 files or 30 lines (suggests /dgs:quick instead)
 
 **`--dry-run` flag:** Shows proposed changes as a diff, then asks "Apply these changes?" before committing.
+
+**`--main` flag:** Forces product-level mode even when a milestone is active. Commits to `base_branch` in the main checkout instead of the milestone worktree.
 </objective>
 
 <execution_context>

package/commands/dgs/health.md

@@ -9,7 +9,7 @@ allowed-tools:
   - AskUserQuestion
 ---
 <objective>
-Validate `.planning/` directory integrity and jobs directory structure. Reports actionable issues for both planning health and job management health.
+Validate planning directory integrity and jobs directory structure. Reports actionable issues for both planning health and job management health.
 </objective>
 
 <execution_context>

package/commands/dgs/map-codebase.md

@@ -1,6 +1,6 @@
 ---
 name: dgs:map-codebase
-description: Analyze registered repos with parallel mapper agents to produce per-repo .planning/codebase/<repo>/ documents and cross-repo analysis
+description: Analyze registered repos with parallel mapper agents to produce per-repo codebase/<repo>/ documents and cross-repo analysis
 argument-hint: "[<repo-name>]"
 allowed-tools:
   - Read
@@ -18,9 +18,9 @@ Supports two modes:
 - **Refresh mode** (default, no flags): Clears all existing codebase maps and remaps everything from scratch.
 - **Update mode** (`<repo-name>` or `--only <repo-name>`): Re-maps only the specified repo and regenerates unified files from all repos.
 
-Reads REPOS.md to discover registered repos, then spawns 4 mapper agents per repo (or just the targeted repo in update mode). Each agent explores the repo's actual path and writes documents directly to `.planning/codebase/<repo-name>/`. The orchestrator only receives confirmations.
+Reads REPOS.md to discover registered repos, then spawns 4 mapper agents per repo (or just the targeted repo in update mode). Each agent explores the repo's actual path and writes documents directly to `codebase/<repo-name>/`. The orchestrator only receives confirmations.
 
-Output: .planning/codebase/<repo-name>/ folders, each with 7 structured documents about that repo's codebase state, plus 7 unified top-level files synthesized from per-repo content, plus CROSS-REPO.md with cross-repo comparison tables (when 2+ repos).
+Output: codebase/<repo-name>/ folders, each with 7 structured documents about that repo's codebase state, plus 7 unified top-level files synthesized from per-repo content, plus CROSS-REPO.md with cross-repo comparison tables (when 2+ repos).
 </objective>
 
 <execution_context>
@@ -31,7 +31,7 @@ Output: .planning/codebase/<repo-name>/ folders, each with 7 structured document
 **Reads REPOS.md** to discover registered repos and their paths.
 
 **Load project state if exists:**
-Check for .planning/STATE.md - loads context if project already initialized
+Check for ${state_path} - loads context if project already initialized
 
 **This command can run:**
 - Before /dgs:new-project (brownfield codebases) - creates codebase maps first
@@ -60,7 +60,7 @@ Check for .planning/STATE.md - loads context if project already initialized
 3. Mode-aware cleanup:
    - Refresh: Delete all existing codebase docs and per-repo subdirectories
    - Update: Delete only the targeted repo's subdirectory (other repos untouched)
-4. Create .planning/codebase/<repo-name>/ directories (all repos or just targeted repo)
+4. Create codebase/<repo-name>/ directories (all repos or just targeted repo)
 5. Spawn 4 parallel dgs-codebase-mapper agents per repo (all run in parallel):
    - Agent 1: tech focus -> writes STACK.md, INTEGRATIONS.md
    - Agent 2: arch focus -> writes ARCHITECTURE.md, STRUCTURE.md
@@ -78,7 +78,7 @@ Check for .planning/STATE.md - loads context if project already initialized
 </process>
 
 <success_criteria>
-- [ ] .planning/codebase/<repo-name>/ directories created for each registered repo (or targeted repo in update mode)
+- [ ] codebase/<repo-name>/ directories created for each registered repo (or targeted repo in update mode)
 - [ ] All 7 codebase documents written per repo by mapper agents
 - [ ] Documents follow template structure
 - [ ] Parallel agents completed without errors

package/commands/dgs/new-milestone.md

@@ -15,11 +15,11 @@ Start a new milestone: questioning → research (optional) → requirements →
 Brownfield equivalent of new-project. Project exists, PROJECT.md has history. Gathers "what's next", updates PROJECT.md, then runs requirements → roadmap cycle.
 
 **Creates/Updates:**
-- `.planning/PROJECT.md` — updated with new milestone goals
-- `.planning/research/` — domain research (optional, NEW features only)
-- `.planning/REQUIREMENTS.md` — scoped requirements for this milestone
-- `.planning/ROADMAP.md` — phase structure (continues numbering)
-- `.planning/STATE.md` — reset for new milestone
+- `${project_path}` — updated with new milestone goals
+- `${project_root}/research/` — domain research (optional, NEW features only)
+- `${project_root}/REQUIREMENTS.md` — scoped requirements for this milestone
+- `${roadmap_path}` — phase structure (continues numbering)
+- `${state_path}` — reset for new milestone
 
 **After:** `/dgs:plan-phase [N]` to start execution.
 </objective>

package/commands/dgs/new-project.md

@@ -1,42 +1,29 @@
 ---
 name: dgs:new-project
-description: Initialize a new project with deep context gathering and PROJECT.md
-argument-hint: "[--auto]"
+description: Initialize a new project as a thin skeleton (name + one-liner).
+argument-hint: "[<name>]"
 allowed-tools:
   - Read
   - Bash
   - Write
-  - Task
-  - AskUserQuestion
 ---
-<context>
-**Flags:**
-- `--auto` — Automatic mode. After config questions, runs research → requirements → roadmap without further interaction. Expects idea document via @ reference.
-</context>
-
 <objective>
-Initialize a new project through unified flow: questioning → research (optional) → requirements → roadmap.
+Initialize a new project as a thin skeleton. Projects are holders — specs and
+milestones carry the real work.
 
 **Creates:**
-- `.planning/PROJECT.md` — project context
-- `.planning/config.json` — workflow preferences
-- `.planning/research/` — domain research (optional)
-- `.planning/REQUIREMENTS.md` — scoped requirements
-- `.planning/ROADMAP.md` — phase structure
-- `.planning/STATE.md` — project memory
+- `${project_path}` — thin PROJECT.md (title + one-line placeholder)
 
-**After this command:** Run `/dgs:plan-phase 1` to start execution.
+**After this command:** Run `/dgs:write-spec` to capture what you're building,
+then `/dgs:new-milestone --auto <spec-id>` to start the first milestone.
 </objective>
 
 <execution_context>
 @~/.claude/deliver-great-systems/workflows/new-project.md
-@~/.claude/deliver-great-systems/references/questioning.md
 @~/.claude/deliver-great-systems/references/ui-brand.md
 @~/.claude/deliver-great-systems/templates/project.md
-@~/.claude/deliver-great-systems/templates/requirements.md
 </execution_context>
 
 <process>
-Execute the new-project workflow from @~/.claude/deliver-great-systems/workflows/new-project.md end-to-end.
-Preserve all workflow gates (validation, approvals, commits, routing).
+Execute the new-project workflow end-to-end. Preserve gates (--auto error, commit).
 </process>

package/commands/dgs/package-scan.md

@@ -0,0 +1,43 @@
+---
+name: dgs:package-scan
+description: Scan all repos for dependency vulnerabilities and licence compliance
+argument-hint: "[--threshold <sev>] [--repo <name>]"
+allowed-tools:
+  - Read
+  - Bash
+  - Edit
+  - Write
+  - Glob
+  - Grep
+---
+<objective>
+Scan all registered repos and the product root for dependency vulnerabilities via a tool cascade (Snyk → OSV-Scanner → ecosystem-native). Produces a markdown report with YAML frontmatter (programmatic consumption) and a human-readable body, committed atomically to the active phase directory / active milestone / project root depending on lifecycle context.
+
+Purpose: Surface known CVEs and licence compliance issues across every language ecosystem in the project within seconds, with no configuration beyond REPOS.md.
+
+Output: `{phase-dir}/{phase}-PACKAGE-SCAN.md` (when run during a phase), or `milestones/v{X}.{Y}-PACKAGE-SCAN.md` (during a milestone), or `PACKAGE-SCAN-{YYYY-MM-DD-HHmm}.md` at project root (standalone). The report is atomically committed via `dgs-tools commit --files`.
+</objective>
+
+<execution_context>
+@~/.claude/deliver-great-systems/workflows/package-scan.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS
+
+**Flags** (Phase 153 will wire these; the command accepts them silently now):
+- `--threshold <sev>` — filter to findings at `<sev>` severity or higher (critical/high/medium/low)
+- `--repo <name>` — scan a single repo by name (must match REPOS.md entry)
+
+**Config keys** (see `deliver-great-systems/references/package-scan-config.md`):
+- `testing.packages.tool` — `auto` (default), `snyk`, `osv`, or `native`
+- `testing.packages.severity_threshold` — minimum severity to include
+- `testing.packages.include_dev_dependencies` — boolean, default `true`
+- `testing.packages.timeout_seconds` — integer, default 300
+- `testing.packages.snyk_token` — local-only (use `dgs-tools config-local-set`)
+</context>
+
+<process>
+Execute the package-scan workflow from @~/.claude/deliver-great-systems/workflows/package-scan.md end-to-end.
+Preserve all workflow gates (init, scan invocation, report-write-and-commit composition).
+</process>