@ktpartners/dgs-platform 2.9.0 → 3.3.0

package/deliver-great-systems/bin/lib/context.cjs

@@ -911,6 +911,125 @@ function cmdContextLoadTier(cwd, tierName, args, raw) {
   output(result, raw, result.files.map(f => f.path).join('\n'));
 }
 
+// ─── Code Context Resolution ──────────────────────────────────────────────
+
+// Lazy requires to avoid circular dependencies (repos.cjs requires core.cjs)
+function _getRepos() { return require('./repos.cjs'); }
+const { getLocalConfigPath } = require('./config.cjs');
+
+/**
+ * Resolve the active code context for a repo.
+ *
+ * Returns the directory where code operations should target:
+ * - Main checkout when no active context
+ * - Milestone worktree when milestone context active
+ * - Quick worktree when quick context active
+ *
+ * Handles stale contexts (missing directories) by clearing
+ * active_context and falling back to main with a warning.
+ *
+ * @param {string} cwd - Working directory (for config resolution)
+ * @param {string} repoName - Name of the repo (as in REPOS.md)
+ * @returns {{ type: string, directory: string, slug?: string, mode?: string }}
+ */
+function resolveCodeContext(cwd, repoName) {
+  const localPath = getLocalConfigPath(cwd);
+  let local;
+  try {
+    local = JSON.parse(fs.readFileSync(localPath, 'utf-8'));
+  } catch {
+    local = {};
+  }
+
+  const activeContext = local && local.execution && local.execution.active_context;
+  if (!activeContext) {
+    // No active context -- resolve to main checkout
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  // Look up the current project
+  const project = local.current_project;
+  if (!project) {
+    // No project set -- fall back to main
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  // Look up worktree entry
+  const worktreeEntry = local.projects
+    && local.projects[project]
+    && local.projects[project].worktrees
+    && local.projects[project].worktrees[activeContext];
+
+  if (!worktreeEntry) {
+    // Stale context -- entry missing from config
+    process.stderr.write(
+      'Warning: Active context \'' + activeContext + '\' not found in worktree state. Falling back to main.\n'
+    );
+    _clearActiveContext(localPath, local);
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  // Look up repo directory in worktree entry
+  const worktreeDir = worktreeEntry.repos && worktreeEntry.repos[repoName];
+  if (!worktreeDir) {
+    // Repo not in this worktree -- fall back to main
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  // Validate directory exists on disk
+  if (!fs.existsSync(worktreeDir)) {
+    // Stale context -- directory missing
+    process.stderr.write(
+      'Warning: Active context \'' + activeContext + '\' is stale -- worktree directory no longer exists at ' + worktreeDir + '. Falling back to main.\n'
+    );
+    _clearActiveContext(localPath, local);
+    return _resolveMainCheckout(cwd, repoName);
+  }
+
+  return {
+    type: worktreeEntry.type || 'milestone',
+    directory: worktreeDir,
+    slug: activeContext,
+    mode: worktreeEntry.mode || null,
+  };
+}
+
+/**
+ * Resolve main checkout path for a repo.
+ * @private
+ */
+function _resolveMainCheckout(cwd, repoName) {
+  try {
+    const parsed = _getRepos().parseReposMd(cwd);
+    if (parsed && parsed.repos) {
+      const repo = parsed.repos.find(function(r) { return r.name === repoName; });
+      if (repo && repo.path) {
+        const root = getPlanningRoot(cwd);
+        const absPath = path.resolve(root, repo.path);
+        return { type: 'main', directory: absPath };
+      }
+    }
+  } catch {
+    // REPOS.md not found or parse error
+  }
+  // Fallback: return cwd
+  return { type: 'main', directory: cwd };
+}
+
+/**
+ * Clear active_context in config.local.json.
+ * @private
+ */
+function _clearActiveContext(localPath, localData) {
+  try {
+    if (!localData.execution) localData.execution = {};
+    localData.execution.active_context = null;
+    fs.writeFileSync(localPath, JSON.stringify(localData, null, 2) + '\n', 'utf-8');
+  } catch {
+    // Best effort -- don't crash on write failure
+  }
+}
+
 // ─── Exports ────────────────────────────────────────────────────────────────
 
 module.exports = {
@@ -918,6 +1037,7 @@ module.exports = {
   cmdContextLoadTier,
   truncateApprovedSpec,
   resetTierCache,
+  resolveCodeContext,
   // Internal exports for testing
   parseTierDefinitions,
   parseSimpleYaml,

package/deliver-great-systems/bin/lib/core.cjs

@@ -22,12 +22,14 @@ const MODEL_PROFILES = {
   'dgs-executor':             { quality: 'opus', balanced: 'sonnet', budget: 'sonnet' },
   'dgs-phase-researcher':     { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
   'dgs-project-researcher':   { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
+  'dgs-idea-researcher':      { quality: 'opus', balanced: 'sonnet', budget: 'haiku' },
   'dgs-research-synthesizer': { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
   'dgs-debugger':             { quality: 'opus', balanced: 'sonnet', budget: 'sonnet' },
   'dgs-codebase-mapper':      { quality: 'sonnet', balanced: 'haiku', budget: 'haiku' },
   'dgs-verifier':             { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
   'dgs-plan-checker':         { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
   'dgs-integration-checker':  { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
+  'dgs-review-analyst':       { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
 };
 
 // ─── Output helpers ───────────────────────────────────────────────────────────
@@ -71,9 +73,6 @@ function loadConfig(cwd) {
     model_profile: 'balanced',
     commit_docs: true,
     search_gitignored: false,
-    branching_strategy: 'none',
-    phase_branch_template: 'dgs/{project}/phase-{phase}-{slug}',
-    milestone_branch_template: 'dgs/{project}/{milestone}-{slug}',
     base_branch: 'main',
     sync_push: 'off',
     sync_pull: 'off',
@@ -144,9 +143,6 @@ function loadConfig(cwd) {
       model_profile: get('model_profile') ?? defaults.model_profile,
       commit_docs: get('commit_docs', { section: 'planning', field: 'commit_docs' }) ?? defaults.commit_docs,
       search_gitignored: get('search_gitignored', { section: 'planning', field: 'search_gitignored' }) ?? defaults.search_gitignored,
-      branching_strategy: get('branching_strategy', { section: 'git', field: 'branching_strategy' }) ?? defaults.branching_strategy,
-      phase_branch_template: get('phase_branch_template', { section: 'git', field: 'phase_branch_template' }) ?? defaults.phase_branch_template,
-      milestone_branch_template: get('milestone_branch_template', { section: 'git', field: 'milestone_branch_template' }) ?? defaults.milestone_branch_template,
       base_branch: get('base_branch', { section: 'git', field: 'base_branch' }) ?? defaults.base_branch,
       sync_push: get('sync_push', { section: 'git', field: 'sync_push' }) ?? defaults.sync_push,
       sync_pull: get('sync_pull', { section: 'git', field: 'sync_pull' }) ?? defaults.sync_pull,
@@ -472,7 +468,14 @@ function generateSlugInternal(text) {
 
 function getMilestoneInfo(cwd) {
   try {
-    const roadmap = fs.readFileSync(path.join(getPlanningRoot(cwd), 'ROADMAP.md'), 'utf-8');
+    // Try project-scoped ROADMAP first, then planning root
+    let roadmap;
+    try {
+      const projectRoot = getProjectRoot(cwd);
+      roadmap = fs.readFileSync(path.join(cwd, projectRoot, 'ROADMAP.md'), 'utf-8');
+    } catch {
+      roadmap = fs.readFileSync(path.join(getPlanningRoot(cwd), 'ROADMAP.md'), 'utf-8');
+    }
 
     // First: check for list-format roadmaps using 🚧 (in-progress) marker
     // e.g. "- 🚧 **v2.1 Belgium** — Phases 24-28 (in progress)"
@@ -484,10 +487,20 @@ function getMilestoneInfo(cwd) {
       };
     }
 
-    // Second: heading-format roadmaps — strip shipped milestones in <details> blocks
+    // Second: bullet-list format with "(in progress)" marker
+    // e.g. "- v19.0 Git Worktrees -- Phases 124-129 (in progress)"
+    const bulletMatch = roadmap.match(/^- v(\d+\.\d+)\s+(.+?)\s+--\s+Phases\s+\S+\s+\(in progress\)/m);
+    if (bulletMatch) {
+      return {
+        version: 'v' + bulletMatch[1],
+        name: bulletMatch[2].trim(),
+      };
+    }
+
+    // Third: heading-format roadmaps — strip shipped milestones in <details> blocks
     const cleaned = roadmap.replace(/<details>[\s\S]*?<\/details>/gi, '');
-    // Extract version and name from the same ## heading for consistency
-    const headingMatch = cleaned.match(/## .*v(\d+\.\d+)[:\s]+([^\n(]+)/);
+    // e.g. "### v19.0 Git Worktrees (In Progress)"
+    const headingMatch = cleaned.match(/#{2,3}\s+v(\d+\.\d+)[:\s]+([^\n(]+)/);
     if (headingMatch) {
       return {
         version: 'v' + headingMatch[1],
@@ -513,7 +526,13 @@ function getMilestoneInfo(cwd) {
 function getMilestonePhaseFilter(cwd) {
   const milestonePhaseNums = new Set();
   try {
-    const roadmap = fs.readFileSync(path.join(getPlanningRoot(cwd), 'ROADMAP.md'), 'utf-8');
+    let roadmap;
+    try {
+      const projectRoot = getProjectRoot(cwd);
+      roadmap = fs.readFileSync(path.join(cwd, projectRoot, 'ROADMAP.md'), 'utf-8');
+    } catch {
+      roadmap = fs.readFileSync(path.join(getPlanningRoot(cwd), 'ROADMAP.md'), 'utf-8');
+    }
     const phasePattern = /#{2,4}\s*Phase\s+(\d+[A-Z]?(?:\.\d+)*)\s*:/gi;
     let m;
     while ((m = phasePattern.exec(roadmap)) !== null) {
@@ -673,7 +692,9 @@ function isProjectCompleted(cwd, slug) {
  * List project folders in a v2 install.
  * Scans projects/ directly and returns directories that:
  * - Don't start with '.'
- * - Contain a STATE.md file (qualifying marker for project folders)
+ * - Contain a PROJECT.md file (canonical project marker; STATE.md is milestone state
+ *   and may be absent for thin-skeleton projects created by /dgs:new-project before
+ *   /dgs:new-milestone has run)
  *
  * Returns empty array if the projects/ directory does not exist, for v1 installs, or on any error.
  *
@@ -688,8 +709,8 @@ function getProjectFolders(cwd) {
       .filter(e => e.isDirectory())
       .filter(e => !e.name.startsWith('.'))
       .filter(e => {
-        // Must contain STATE.md to qualify as a project
-        return fs.existsSync(path.join(projectsDir, e.name, 'STATE.md'));
+        // Must contain PROJECT.md to qualify as a project
+        return fs.existsSync(path.join(projectsDir, e.name, 'PROJECT.md'));
       })
       .map(e => e.name)
       .sort();

package/deliver-great-systems/bin/lib/core.test.cjs

@@ -24,6 +24,8 @@ const {
   loadConfig,
   isProjectCompleted,
   getProjectDir,
+  resolveModelInternal,
+  MODEL_PROFILES,
 } = require('./core.cjs');
 
 // ─── Root layout (no v2 markers) Tests ───────────────────────────────────────
@@ -388,7 +390,9 @@ describe('getProjectFolders', () => {
     const fixture = createFixture({
       'config.json': JSON.stringify({}),
       'PROJECTS.md': '# Projects\n',
+      'projects/auth-overhaul/PROJECT.md': '# Project\n',
       'projects/auth-overhaul/STATE.md': '# State',
+      'projects/dashboard-v2/PROJECT.md': '# Project\n',
       'projects/dashboard-v2/STATE.md': '# State',
       'phases/': null,
       'codebase/': null,
@@ -404,10 +408,11 @@ describe('getProjectFolders', () => {
     }
   });
 
-  it('only includes directories containing STATE.md', () => {
+  it('only includes directories containing PROJECT.md', () => {
     const fixture = createFixture({
       'config.json': JSON.stringify({}),
       'PROJECTS.md': '# Projects\n',
+      'projects/valid-project/PROJECT.md': '# Project\n',
       'projects/valid-project/STATE.md': '# State',
       'projects/empty-folder/': null,
     });
@@ -420,10 +425,43 @@ describe('getProjectFolders', () => {
     }
   });
 
+  it('returns thin-skeleton project folder containing PROJECT.md but no STATE.md', () => {
+    const fixture = createFixture({
+      'config.json': JSON.stringify({}),
+      'PROJECTS.md': '# Projects\n',
+      'projects/word-gen/PROJECT.md': '# Project: Word Gen\n',
+    });
+
+    try {
+      const result = getProjectFolders(fixture.cwd);
+      assert.deepEqual(result, ['word-gen']);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('excludes directory with neither PROJECT.md nor STATE.md', () => {
+    const fixture = createFixture({
+      'config.json': JSON.stringify({}),
+      'PROJECTS.md': '# Projects\n',
+      'projects/empty-folder/': null,
+      'projects/real-project/PROJECT.md': '# Project\n',
+    });
+
+    try {
+      const result = getProjectFolders(fixture.cwd);
+      assert.deepEqual(result, ['real-project']);
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
   it('excludes dot-directories', () => {
     const fixture = createFixture({
       'config.json': JSON.stringify({}),
+      'projects/.hidden/PROJECT.md': '# Project\n',
       'projects/.hidden/STATE.md': '# State',
+      'projects/real-project/PROJECT.md': '# Project\n',
       'projects/real-project/STATE.md': '# State',
     });
 
@@ -745,6 +783,7 @@ describe('root layout', () => {
       'config.json': JSON.stringify({}),
       'PROJECTS.md': '# Projects\n',
       'REPOS.md': '# Repos\n',
+      'projects/proj-a/PROJECT.md': '# Project\n',
       'projects/proj-a/STATE.md': '# State\n',
       'projects/proj-a/phases/': null,
     });
@@ -837,3 +876,42 @@ describe('config two-file merge', () => {
   });
 
 });
+
+// ─── MODEL_PROFILES dgs-idea-researcher tiering ──────────────────────────────
+
+describe('MODEL_PROFILES dgs-idea-researcher tiering', () => {
+  let fixture;
+
+  afterEach(() => {
+    if (fixture) fixture.cleanup();
+    fixture = null;
+  });
+
+  it('MODEL_PROFILES table contains dgs-idea-researcher with quality/balanced/budget tiers', () => {
+    const profile = MODEL_PROFILES['dgs-idea-researcher'];
+    assert.ok(profile, 'MODEL_PROFILES[\'dgs-idea-researcher\'] should be defined');
+    assert.equal(typeof profile.quality, 'string', 'quality tier present');
+    assert.equal(typeof profile.balanced, 'string', 'balanced tier present');
+    assert.equal(typeof profile.budget, 'string', 'budget tier present');
+  });
+
+  it('resolveModelInternal returns inherit for dgs-idea-researcher on quality profile', () => {
+    fixture = createTempProject({ withConfig: { model_profile: 'quality' } });
+    const resolved = resolveModelInternal(fixture.cwd, 'dgs-idea-researcher');
+    // Per core.cjs: when the resolved tier is 'opus', the function returns 'inherit'.
+    assert.equal(resolved, 'inherit');
+  });
+
+  it('resolveModelInternal returns sonnet for dgs-idea-researcher on balanced profile', () => {
+    fixture = createTempProject({ withConfig: { model_profile: 'balanced' } });
+    const resolved = resolveModelInternal(fixture.cwd, 'dgs-idea-researcher');
+    assert.equal(resolved, 'sonnet');
+  });
+
+  it('resolveModelInternal returns haiku for dgs-idea-researcher on budget profile', () => {
+    fixture = createTempProject({ withConfig: { model_profile: 'budget' } });
+    const resolved = resolveModelInternal(fixture.cwd, 'dgs-idea-researcher');
+    assert.equal(resolved, 'haiku');
+  });
+
+});

package/deliver-great-systems/bin/lib/execution.cjs

@@ -9,11 +9,15 @@
 const fs = require('fs');
 const path = require('path');
 const { execGit, safeReadFile, loadConfig, output, error } = require('./core.cjs');
-const { getPlanningRoot } = require('./paths.cjs');
+const { getPlanningRoot, PROJECTS_DIR } = require('./paths.cjs');
 const { parseReposMd } = require('./repos.cjs');
 const { extractFrontmatter } = require('./frontmatter.cjs');
 const { scanProjectReposTags } = require('./projects.cjs');
 
+// Lazy require to avoid circular dependency (context.cjs does not require execution.cjs,
+// but keeping it lazy is a safety practice for future refactoring).
+function _getResolveCodeContext() { return require('./context.cjs').resolveCodeContext; }
+
 // ─── Repo Path Resolution ───────────────────────────────────────────────────
 
 /**
@@ -24,7 +28,26 @@ const { scanProjectReposTags } = require('./projects.cjs');
  * @param {Array} repos - Parsed repos array (optional, loads from REPOS.md if not provided)
  * @returns {{ absPath: string, repo: Object } | null}
  */
-function resolveRepoPath(cwd, repoName, repos) {
+function resolveRepoPath(cwd, repoName, repos, useActiveContext) {
+  // If active context requested, resolve to worktree directory
+  if (useActiveContext) {
+    try {
+      const ctx = _getResolveCodeContext()(cwd, repoName);
+      if (ctx && ctx.type !== 'main') {
+        // Resolve the repo object for metadata (still need repo.name etc.)
+        if (!repos) {
+          const parsed = parseReposMd(cwd);
+          if (parsed) repos = parsed.repos;
+        }
+        const repo = repos ? repos.find(r => r.name === repoName) : null;
+        return { absPath: ctx.directory, repo: repo || { name: repoName, path: ctx.directory } };
+      }
+    } catch {
+      // Fall through to standard resolution
+    }
+  }
+
+  // Standard resolution via REPOS.md
   if (!repos) {
     const parsed = parseReposMd(cwd);
     if (!parsed) return null;
@@ -48,8 +71,8 @@ function resolveRepoPath(cwd, repoName, repos) {
  * @param {Array} repos - Parsed repos array (optional, loads from REPOS.md if not provided)
  * @returns {{ absFilePath: string, repoAbsPath: string, repo: Object } | null}
  */
-function resolveRepoRelativePath(cwd, repoName, relativePath, repos) {
-  const resolved = resolveRepoPath(cwd, repoName, repos);
+function resolveRepoRelativePath(cwd, repoName, relativePath, repos, useActiveContext) {
+  const resolved = resolveRepoPath(cwd, repoName, repos, useActiveContext);
   if (!resolved) return null;
   const absFilePath = path.join(resolved.absPath, relativePath);
   return { absFilePath, repoAbsPath: resolved.absPath, repo: resolved.repo };
@@ -65,14 +88,14 @@ function resolveRepoRelativePath(cwd, repoName, relativePath, repos) {
  * @param {string} [phaseDir] - Optional phase directory to check for partial SUMMARY.md
  * @returns {{ passed: boolean, dirty_repos: Array, partial_execution: Object|null, missing_repos: string[] }}
  */
-function preflightCheck(cwd, repoNames, phaseDir) {
+function preflightCheck(cwd, repoNames, phaseDir, useActiveContext) {
   const parsed = parseReposMd(cwd);
   const repos = parsed ? parsed.repos : [];
   const dirty_repos = [];
   const missing_repos = [];
 
   for (const name of repoNames) {
-    const resolved = resolveRepoPath(cwd, name, repos);
+    const resolved = resolveRepoPath(cwd, name, repos, useActiveContext);
     if (!resolved) {
       missing_repos.push(name);
       continue;
@@ -316,13 +339,13 @@ function buildPlanningCommitBody(repoResults) {
  * @param {string[]} repoNames - Repo names to check
  * @returns {Array<{repoName: string, repoPath: string, files: string[]}>}
  */
-function detectRepoChanges(cwd, repoNames) {
+function detectRepoChanges(cwd, repoNames, useActiveContext) {
   const parsed = parseReposMd(cwd);
   const repos = parsed ? parsed.repos : [];
   const changes = [];
 
   for (const name of repoNames) {
-    const resolved = resolveRepoPath(cwd, name, repos);
+    const resolved = resolveRepoPath(cwd, name, repos, useActiveContext);
     if (!resolved) continue;
     if (!fs.existsSync(resolved.absPath)) continue;
 
@@ -347,7 +370,7 @@ function detectRepoChanges(cwd, repoNames) {
     if (files.length > 0) {
       changes.push({
         repoName: name,
-        repoPath: resolved.repo.path,
+        repoPath: useActiveContext ? resolved.absPath : resolved.repo.path,
         files,
       });
     }
@@ -360,7 +383,6 @@ function detectRepoChanges(cwd, repoNames) {
 
 /**
  * Create branches in each repo for multi-repo execution.
- * Respects branching_strategy config — if 'none', skips branch creation.
  * Reuses existing branch if it already exists.
  * Detects branch prefix collisions and warns about potential ambiguity.
  *
@@ -375,15 +397,12 @@ function detectRepoChanges(cwd, repoNames) {
  * @param {string} cwd - Product root
  * @param {string[]} repoNames - Repo names
  * @param {string} branchName - Branch name (e.g., dgs/project/phase-slug)
- * @param {{ branching_strategy?: string }} config - Config object
+ * @param {object} [config] - Config object (legacy parameter, kept for backward compatibility)
  * @param {string|null} [baseBranch=null] - Base branch to checkout before creating new branch.
  *   When null/undefined, creates branch from wherever HEAD is (backwards-compatible behavior).
  * @returns {{ created: boolean, reason?: string, error?: string, repo?: string, branches?: Array<{repo: string, branch: string, action: string}>, warnings?: Array }}
  */
 function createRepoBranches(cwd, repoNames, branchName, config, baseBranch) {
-  if (config && config.branching_strategy === 'none') {
-    return { created: false, reason: 'branching_disabled' };
-  }
 
   const parsed = parseReposMd(cwd);
   const repos = parsed ? parsed.repos : [];
@@ -521,7 +540,7 @@ function updateRepoStatus(cwd, projectSlug, repoResults) {
   let statePath;
   const planRoot = getPlanningRoot(cwd);
   if (projectSlug) {
-    statePath = path.join(planRoot, projectSlug, 'STATE.md');
+    statePath = path.join(planRoot, PROJECTS_DIR, projectSlug, 'STATE.md');
   }
   if (!statePath || !fs.existsSync(statePath)) {
     statePath = path.join(planRoot, 'STATE.md');
@@ -622,8 +641,21 @@ function cmdCommitMultiRepo(cwd, options, raw) {
 
   const warnings = [];
 
+  // Determine whether to resolve repos against active worktree
+  let useActiveContext = false;
+  try {
+    const { getLocalConfigPath } = require('./config.cjs');
+    const localPath = getLocalConfigPath(cwd);
+    if (fs.existsSync(localPath)) {
+      const localCfg = JSON.parse(fs.readFileSync(localPath, 'utf-8'));
+      if (localCfg.execution && localCfg.execution.active_context) {
+        useActiveContext = true;
+      }
+    }
+  } catch { /* fall back to standard resolution */ }
+
   // Run preflight
-  const preflight = preflightCheck(cwd, repoNames, options.phaseDir || null);
+  const preflight = preflightCheck(cwd, repoNames, options.phaseDir || null, useActiveContext);
 
   // Missing repos is a hard error — block execution
   if (preflight.missing_repos && preflight.missing_repos.length > 0) {
@@ -649,7 +681,7 @@ function cmdCommitMultiRepo(cwd, options, raw) {
   }
 
   // Detect changes
-  const changes = detectRepoChanges(cwd, repoNames);
+  const changes = detectRepoChanges(cwd, repoNames, useActiveContext);
   if (changes.length === 0) {
     output({ success: true, message: 'No changes detected', commits: [], warnings }, raw);
     return;