@ktpartners/dgs-platform 2.8.0 → 3.0.4

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

@@ -378,6 +378,75 @@ function pullAll(cwd, options = {}) {
  * @param {string[]|null} [options.repos=null] - Filter to push only specific repos by name
  * @returns {{ ok: boolean, results: Array<{ repo: string, path: string, status: string, commits: number|null, message: string }>, problems?: Array, summary: string }}
  */
+/**
+ * Push active worktree branches to remote as backup. Best-effort — failures
+ * are appended to results but do not block other sync operations.
+ *
+ * Reads worktree entries from config.local.json for the current project.
+ * Skips stale entries where the worktree directory no longer exists.
+ * Push-only — no pull of worktree branches (deferred to future).
+ *
+ * @param {string} cwd - Planning root
+ * @param {Array} results - Results array to append push outcomes to
+ */
+function _pushWorktreeBranches(cwd, results) {
+  const config = loadConfig(cwd);
+  const project = config.current_project;
+  if (!project) return;
+
+  let localConfig;
+  try {
+    const localPath = getLocalConfigPath(cwd);
+    if (!fs.existsSync(localPath)) return;
+    localConfig = JSON.parse(fs.readFileSync(localPath, 'utf-8'));
+  } catch {
+    return; // No config.local.json or invalid JSON — nothing to push
+  }
+
+  const worktrees = (localConfig.projects && localConfig.projects[project] && localConfig.projects[project].worktrees) || {};
+
+  for (const [slug, entry] of Object.entries(worktrees)) {
+    const type = entry.type; // 'milestone' or 'quick'
+    const repos = entry.repos || {};
+
+    for (const [repoName, worktreePath] of Object.entries(repos)) {
+      // Skip stale worktrees (directory doesn't exist)
+      if (!fs.existsSync(worktreePath)) continue;
+
+      // Determine branch name based on type
+      const branchName = type === 'milestone' ? 'milestone/' + slug : 'quick/' + slug;
+      const label = repoName + ' (worktree: ' + slug + ')';
+
+      try {
+        // Check if worktree has a remote
+        if (!hasRemote(worktreePath)) continue;
+
+        // Push the worktree branch from the worktree directory
+        const pushResult = execGitWithTimeout(worktreePath, ['push', '-u', 'origin', branchName], 30000);
+
+        results.push({
+          repo: label,
+          path: worktreePath,
+          status: pushResult.exitCode === 0 ? 'pushed' : 'failed',
+          commits: 0,
+          message: pushResult.exitCode === 0
+            ? 'Pushed worktree branch ' + branchName
+            : 'Failed to push ' + branchName + ': ' + (pushResult.stderr || '').trim(),
+        });
+      } catch (e) {
+        // Best-effort — failure does not block other operations
+        results.push({
+          repo: label,
+          path: worktreePath,
+          status: 'failed',
+          commits: 0,
+          message: 'Push failed: ' + (e.message || String(e)),
+        });
+      }
+    }
+  }
+}
+
 function pushAll(cwd, options = {}) {
   const { dryRun = false, force = false, repos: repoFilter = null } = options;
   let allRepos = collectSyncRepos(cwd);
@@ -468,6 +537,12 @@ function pushAll(cwd, options = {}) {
     results.push({ repo: label, path: repo.path, status: 'pushed', commits: commitCount, message: `Pushed ${commitLabel}` });
   }
 
+  // --- Worktree Branch Push ---
+  // Push active worktree branches as remote backup (best-effort, non-blocking)
+  if (!dryRun) {
+    _pushWorktreeBranches(cwd, results);
+  }
+
   // Build summary
   const pushed = results.filter(r => r.status === 'pushed').length;
   const current = results.filter(r => r.status === 'current').length;

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

@@ -708,6 +708,86 @@ function cmdValidateHealth(cwd, options, raw) {
     }
   }
 
+  // ─── Check 10: Uncommitted tracking files in completed phases ─────────────
+  // Surface the condition `phase finalize` was designed to prevent: a completed
+  // phase whose ROADMAP.md / STATE.md / REQUIREMENTS.md / VERIFICATION.md are
+  // modified in the working tree but not committed (e.g., Claude dropped the
+  // commit step between updating trackers and invoking `commit`).
+  try {
+    const { execGit } = require('./core.cjs');
+    const isGit = execGit(cwd, ['rev-parse', '--is-inside-work-tree']);
+    if (isGit.exitCode === 0 && isGit.stdout.trim() === 'true') {
+      // git resolves symlinks when reporting paths; normalize both sides against
+      // the real git root so relative paths compare correctly on macOS
+      // (/var/folders → /private/var/folders).
+      const gitRootRes = execGit(cwd, ['rev-parse', '--show-toplevel']);
+      const gitRoot = gitRootRes.exitCode === 0 ? gitRootRes.stdout.trim() : cwd;
+      const statusRes = execGit(cwd, ['status', '--porcelain']);
+      if (statusRes.exitCode === 0) {
+        // `git status --porcelain` emits "XY path" lines (X=index, Y=worktree,
+        // column 3 is a separator space, path starts at column 4). Note:
+        // execGit.stdout is already .trim()'d so lines may have lost a leading
+        // space when X=' ' (worktree-only changes). Extract the path from
+        // whatever follows the first whitespace group.
+        const dirtyPaths = statusRes.stdout
+          .split('\n')
+          .filter(Boolean)
+          .map(l => {
+            // Match "XY<space>path" OR "<space>Y<space>path" (leading space may be trimmed).
+            // A path after 2 status chars + 1 space begins at index 3 of the original,
+            // but lines like " M file" got left-trimmed to "M file" (only one status char).
+            // Normalize: skip the leading non-space + exactly one space.
+            const m = l.match(/^\S{1,2}\s(.+)$/);
+            return m ? m[1].trim() : l.trim();
+          });
+
+        // Identify completed phases from ROADMAP.md checkboxes
+        const completedPhases = new Set();
+        if (fs.existsSync(roadmapPath)) {
+          const rm = fs.readFileSync(roadmapPath, 'utf-8');
+          const re = /-\s*\[x\]\s*.*Phase\s+(\d+[A-Z]?(?:\.\d+)*)/gi;
+          let m;
+          while ((m = re.exec(rm)) !== null) completedPhases.add(m[1]);
+        }
+
+        // Tracking files at the planning root — compute relative to gitRoot
+        const trackingRoot = ['ROADMAP.md', 'STATE.md', 'REQUIREMENTS.md']
+          .map(f => path.relative(gitRoot, path.join(planningDir, f)));
+
+        // VERIFICATION.md files inside completed phase dirs
+        const trackingVerif = [];
+        if (completedPhases.size > 0) {
+          try {
+            const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+            for (const e of entries) {
+              if (!e.isDirectory()) continue;
+              const dm = e.name.match(/^(\d+[A-Z]?(?:\.\d+)*)/i);
+              if (!dm) continue;
+              const phaseNum = dm[1];
+              const unpadded = String(parseInt(phaseNum, 10));
+              if (!completedPhases.has(phaseNum) && !completedPhases.has(unpadded)) continue;
+              const phaseFiles = fs.readdirSync(path.join(phasesDir, e.name));
+              for (const f of phaseFiles) {
+                if (/-VERIFICATION\.md$/i.test(f)) {
+                  trackingVerif.push(path.relative(gitRoot, path.join(phasesDir, e.name, f)));
+                }
+              }
+            }
+          } catch { /* ignore */ }
+        }
+
+        const allTracking = [...trackingRoot, ...trackingVerif];
+        const dirtyTracking = dirtyPaths.filter(p => allTracking.includes(p));
+        if (dirtyTracking.length > 0) {
+          addIssue('warning', 'W009',
+            `Uncommitted tracking files for completed phase(s): ${dirtyTracking.join(', ')}`,
+            'Run `dgs-tools phase finalize <phase>` for the relevant phase, or commit manually'
+          );
+        }
+      }
+    }
+  } catch { /* non-git or git error — skip silently */ }
+
   // ─── Perform repairs if requested ─────────────────────────────────────────
   const repairActions = [];
   if (options.repair && repairs.length > 0) {
@@ -720,7 +800,6 @@ function cmdValidateHealth(cwd, options, raw) {
               model_profile: 'balanced',
               commit_docs: true,
               search_gitignored: false,
-              branching_strategy: 'none',
               research: true,
               plan_checker: true,
               verifier: true,