@ktpartners/dgs-platform 3.0.4 → 3.3.0

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

@@ -817,8 +817,9 @@ function phaseCompleteInternal(cwd, phaseNum) {
     const reqPath = path.join(cwd, projRoot, 'REQUIREMENTS.md');
     if (fs.existsSync(reqPath)) {
       // Extract Requirements line from roadmap for this phase
+      // Match both **Requirements:** (colon inside bold) and **Requirements**: (colon outside bold)
       const reqMatch = roadmapContent.match(
-        new RegExp(`Phase\\s+${escapeRegex(phaseNum)}[\\s\\S]*?\\*\\*Requirements:\\*\\*\\s*([^\\n]+)`, 'i')
+        new RegExp(`Phase\\s+${escapeRegex(phaseNum)}[\\s\\S]*?\\*\\*Requirements(?::\\*\\*|\\*\\*:)\\s*([^\\n]+)`, 'i')
       );
 
       if (reqMatch) {
@@ -944,6 +945,20 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
  *
  * Does NOT call cmdCommit (which exits). Uses execGit directly.
  */
+// Collect the list of still-dirty paths in `gitCwd` after a commit. Purely
+// informational — populates `result.dirty_after`. Duplicated from
+// commands.cjs/quick.cjs instead of extracted because the three call sites
+// use slightly different cwd variables and a shared module would obscure that.
+function collectDirtyAfter(gitCwd) {
+  const porcelain = execGit(gitCwd, ['status', '--porcelain']);
+  if (porcelain.exitCode !== 0) return [];
+  return (porcelain.stdout || '')
+    .split('\n')
+    .map(l => l.trim())
+    .filter(Boolean)
+    .map(l => l.replace(/^..\s+/, ''));
+}
+
 function cmdPhaseFinalize(cwd, phaseNum, options, raw) {
   if (!phaseNum) {
     error('phase number required for phase finalize');
@@ -993,6 +1008,7 @@ function cmdPhaseFinalize(cwd, phaseNum, options, raw) {
     result.commit_reason = nothing ? 'nothing_to_commit' : 'commit_failed';
     if (!nothing) result.commit_error = commitResult.stderr;
     result.files_committed = [];
+    result.dirty_after = collectDirtyAfter(cwd);
     output(result, raw);
     return;
   }
@@ -1001,6 +1017,7 @@ function cmdPhaseFinalize(cwd, phaseNum, options, raw) {
   result.hash = hashResult.exitCode === 0 ? hashResult.stdout : null;
   result.commit_reason = 'committed';
   result.files_committed = filesToStage;
+  result.dirty_after = collectDirtyAfter(cwd);
 
   // Optional push (same semantics as cmdCommit)
   if (options && options.push) {

package/deliver-great-systems/bin/lib/plan-number-validity.test.cjs

@@ -0,0 +1,48 @@
+// deliver-great-systems/bin/lib/plan-number-validity.test.cjs
+// REL-04 regression test scaffold — initially RED. Turns GREEN after plan 02
+// adds Dimension 10 (plan-number validity) to agents/dgs-plan-checker.md.
+//
+// Strategy: this is an agent-prompt assertion, not a CLI test. Tests read
+// agents/dgs-plan-checker.md and assert the dimension exists with the required
+// remediation text + soft-fail marker + named-follow-up-phase reference.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const repoRoot = path.resolve(__dirname, '../../..');
+const checkerPath = path.join(repoRoot, 'agents/dgs-plan-checker.md');
+
+test('REL-04: dgs-plan-checker has Dimension 10 (plan-number validity)', () => {
+  const content = fs.readFileSync(checkerPath, 'utf-8');
+  assert.match(content, /## Dimension 10: Plan Number Validity/, 'Dimension 10 must exist');
+});
+
+test('REL-04: Dimension 10 enumerates rejected plan-number forms', () => {
+  const content = fs.readFileSync(checkerPath, 'utf-8');
+  for (const form of ['plan: 00', 'plan: 0', 'positive integer']) {
+    assert.ok(content.includes(form), `Dimension 10 must mention "${form}"`);
+  }
+});
+
+test('REL-04: Dimension 10 includes exact rename remediation command', () => {
+  const content = fs.readFileSync(checkerPath, 'utf-8');
+  assert.match(content, /git mv .*-00-PLAN\.md.*-01-PLAN\.md/, 'remediation must include git mv command');
+});
+
+test('REL-04: Dimension 10 is soft-fail (warning, not block) on initial rollout', () => {
+  const content = fs.readFileSync(checkerPath, 'utf-8');
+  const dim10Match = content.match(/## Dimension 10[\s\S]+?(?=## Dimension|$)/);
+  assert.ok(dim10Match, 'Dimension 10 block must exist');
+  const dim10Text = dim10Match[0];
+  assert.ok(/soft-fail|warning|warn/i.test(dim10Text), 'Dimension 10 must mark itself as soft-fail/warning');
+});
+
+test('REL-04: Dimension 10 references the named follow-up phase for hard-reject promotion', () => {
+  const content = fs.readFileSync(checkerPath, 'utf-8');
+  assert.ok(/follow-up phase|hard-reject promotion/i.test(content),
+    'Dimension 10 must reference hard-reject deferral to a named follow-up phase');
+});
+
+// REL-04 sentinel — flag this file as a Wave-0 RED scaffold for plan 02.

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

@@ -171,8 +171,14 @@ function scanProjectReposTags(cwd, slug) {
  * Enumerate all project subfolders and build a { projects, warnings } result
  * WITHOUT writing PROJECTS.md. Pure read function — no side effects.
  *
- * Ghost project guard: projects whose STATE.md is missing or unreadable
- * are warned about and omitted from the output.
+ * Thin-skeleton projects (PROJECT.md present, STATE.md absent) yield a placeholder
+ * entry with status "No milestone yet" and emit no warning — this is the post-thin-skeleton
+ * contract where /dgs:new-project writes only PROJECT.md and STATE.md is created later
+ * by /dgs:new-milestone.
+ *
+ * Ghost-project guard (defensive): a directory with neither PROJECT.md nor STATE.md is
+ * normally filtered out by getProjectFolders before reaching here. If a future caller
+ * passes such a slug directly, the legacy warning is preserved and the entry is omitted.
  *
  * @param {string} cwd - Working directory (product root)
  * @returns {{ projects: Array, warnings: string[] }}
@@ -185,7 +191,22 @@ function listProjectsReadonly(cwd) {
   for (const slug of slugs) {
     const state = readProjectState(cwd, slug);
     if (!state) {
-      warnings.push(`Ghost project: ${slug} (STATE.md missing or unreadable)`);
+      // No STATE.md (or unreadable): if PROJECT.md is present, treat as thin-skeleton
+      // and emit a placeholder row. Only warn when neither marker is present (defensive
+      // guard for direct callers that bypass getProjectFolders).
+      const projectMdPath = path.join(getProjectDir(cwd, slug), 'PROJECT.md');
+      if (fs.existsSync(projectMdPath)) {
+        projects.push({
+          name: slug,
+          status: 'No milestone yet',
+          repos_touched: '',
+          current_phase: '',
+          completed_date: '',
+          progress: '',
+        });
+      } else {
+        warnings.push(`Ghost project: ${slug} (STATE.md missing or unreadable)`);
+      }
       continue;
     }
 
@@ -671,6 +692,20 @@ function cmdProjectsReactivate(cwd, options, raw) {
   const regenResult = regenerateProjectsMd(cwd);
   const remainingActive = regenResult.projects.filter(p => !p.status.toLowerCase().includes('completed'));
 
+  // Commit STATE.md and PROJECTS.md so reactivation is persisted
+  const planningRoot = getPlanningRoot(cwd);
+  const projectDir = getProjectDir(cwd, slug);
+  const statePath = path.join(projectDir, 'STATE.md');
+  const projectsPath = path.join(planningRoot, 'PROJECTS.md');
+  const filesToCommit = [statePath, projectsPath].filter(f => fs.existsSync(f));
+  try {
+    const { execSync } = require('child_process');
+    for (const f of filesToCommit) {
+      execSync(`git add "${f}"`, { cwd: planningRoot, stdio: 'pipe' });
+    }
+    execSync(`git commit -m "docs: reactivate project ${slug}" --allow-empty`, { cwd: planningRoot, stdio: 'pipe' });
+  } catch { /* commit may fail if nothing changed — safe to ignore */ }
+
   output({ reactivated: true, slug, set_as_current: !!opts.set_current, remaining_active: remainingActive.length }, raw);
 }
 

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

@@ -11,22 +11,57 @@ const os = require('os');
 
 const { createTempDir, cleanupDir, createFixture , initGitRepo } = require('./test-helpers.cjs');
 const { resetPaths } = require('./paths.cjs');
-const { getProjectRoot } = require('./core.cjs');
+const { getProjectRoot, loadConfig } = require('./core.cjs');
 
 // Helper: create projects/ directory structure
 function setupPlanning(cwd) {
   fs.mkdirSync(path.join(cwd, 'projects'), { recursive: true });
 }
 
-// Helper: create a project subfolder with STATE.md manually under projects/<slug>/
+// Helper: create a fully-scaffolded project subfolder under projects/<slug>/
+// (writes PROJECT.md as the canonical project marker plus optional STATE.md for milestone state)
 function createProjectManually(cwd, slug, stateContent) {
   const projDir = path.join(cwd, 'projects', slug);
   fs.mkdirSync(projDir, { recursive: true });
+  fs.writeFileSync(path.join(projDir, 'PROJECT.md'), `# Project: ${slug}\n`);
   if (stateContent) {
     fs.writeFileSync(path.join(projDir, 'STATE.md'), stateContent);
   }
 }
 
+// Helper: create a thin-skeleton project (PROJECT.md only, no STATE.md) — mirrors what
+// /dgs:new-project writes before /dgs:new-milestone creates STATE.md.
+function createThinSkeletonProject(cwd, slug) {
+  const projDir = path.join(cwd, 'projects', slug);
+  fs.mkdirSync(projDir, { recursive: true });
+  fs.writeFileSync(path.join(projDir, 'PROJECT.md'), `# Project: ${slug}\n`);
+}
+
+// Capture stdout helper for cmdProjects* CLI calls (mirrors commands.test.cjs:48-70).
+function captureStdout(fn) {
+  const chunks = [];
+  const origWrite = process.stdout.write.bind(process.stdout);
+  const origExit = process.exit;
+  let exitCode = null;
+  process.stdout.write = (data) => { chunks.push(String(data)); return true; };
+  process.exit = (code) => {
+    exitCode = code == null ? 0 : code;
+    throw new Error('__EXIT__');
+  };
+  try {
+    fn();
+  } catch (e) {
+    if (e && e.message !== '__EXIT__') throw e;
+  } finally {
+    process.stdout.write = origWrite;
+    process.exit = origExit;
+  }
+  const stdout = chunks.join('');
+  let json = null;
+  try { json = JSON.parse(stdout); } catch { /* not JSON */ }
+  return { stdout, exitCode, json };
+}
+
 // Helper: create plan file with <repos> tags under projects/<slug>/phases/
 function createPlanFile(cwd, slug, phaseDir, planName, content) {
   const dir = path.join(cwd, 'projects', slug, 'phases', phaseDir);
@@ -44,6 +79,7 @@ const {
   reactivateProject,
   parseProjectsMd,
   checkSlugPrefixCollision,
+  cmdProjectsSwitch,
 } = require('./projects.cjs');
 
 // ─── createProjectSubfolder ─────────────────────────────────────────────────
@@ -322,6 +358,17 @@ describe('regenerateProjectsMd', () => {
     const content = fs.readFileSync(path.join(tmpDir, 'PROJECTS.md'), 'utf-8');
     assert.ok(content.startsWith('# Projects'));
   });
+
+  it('writes thin-skeleton placeholder row into Active table', () => {
+    createThinSkeletonProject(tmpDir, 'word-gen');
+    regenerateProjectsMd(tmpDir);
+    const content = fs.readFileSync(path.join(tmpDir, 'PROJECTS.md'), 'utf-8');
+    const [activeSection, completedSection] = content.split('## Completed');
+    // Active row should match: | word-gen | No milestone yet |  |  |
+    assert.match(activeSection, /\|\s*word-gen\s*\|\s*No milestone yet\s*\|\s*\|\s*\|/);
+    // word-gen must NOT appear in the Completed section
+    assert.ok(!completedSection.includes('word-gen'), 'thin-skeleton project must not appear in Completed section');
+  });
 });
 
 // ─── listProjectsReadonly ───────────────────────────────────────────────────
@@ -407,6 +454,35 @@ describe('listProjectsReadonly', () => {
     assert.deepStrictEqual(result.projects, []);
     assert.ok(Array.isArray(result.warnings));
   });
+
+  it('returns placeholder entry with status "No milestone yet" for thin-skeleton (PROJECT.md only) and emits no warning for that slug', () => {
+    createThinSkeletonProject(tmpDir, 'word-gen');
+    const result = listProjectsReadonly(tmpDir);
+    assert.strictEqual(result.projects.length, 1);
+    assert.deepStrictEqual(result.projects[0], {
+      name: 'word-gen',
+      status: 'No milestone yet',
+      repos_touched: '',
+      current_phase: '',
+      completed_date: '',
+      progress: '',
+    });
+    assert.ok(Array.isArray(result.warnings));
+    assert.ok(!result.warnings.some(w => w.includes('word-gen')), 'no warning should mention word-gen');
+  });
+
+  it('preserves ghost-warning code path when neither PROJECT.md nor STATE.md exists', () => {
+    // Genuine ghost: no marker files at all — getProjectFolders filters it out, so it
+    // never reaches listProjectsReadonly's loop. Real project alongside to keep suite non-empty.
+    fs.mkdirSync(path.join(tmpDir, 'projects', 'ghost'), { recursive: true });
+    createProjectManually(tmpDir, 'real-project', '# State\n\nStatus: Active\n');
+
+    const result = listProjectsReadonly(tmpDir);
+    assert.ok(Array.isArray(result.warnings));
+    assert.ok(!result.projects.some(p => p.name === 'ghost'), 'ghost dir should be omitted from projects array');
+    // The warnings array remains a defensive code path; legacy callers may still trip it.
+    // No assertion on warnings content here — discovery layer (getProjectFolders) handles ghost exclusion.
+  });
 });
 
 // ─── completeProject ────────────────────────────────────────────────────────
@@ -943,6 +1019,7 @@ describe('cmdProjectsSwitch guards', () => {
       'config.json': JSON.stringify({ current_project: 'finished-proj' }),
       'PROJECTS.md': '# Projects\n\n## Active\n\n| Project | Status | Repos Touched | Current Phase |\n|---------|--------|---------------|---------------|\n\n## Completed\n\n| Project | Completed | Duration |\n|---------|-----------|----------|\n| finished-proj | 2026-02-20 | |\n',
       'REPOS.md': '# Repos\n\n| Name | Path |\n',
+      'projects/finished-proj/PROJECT.md': '# Project: Finished Proj\n',
       'projects/finished-proj/STATE.md': '# Project State\n\nStatus: completed\nCompleted: 2026-02-20\n',
     });
 
@@ -956,3 +1033,36 @@ describe('cmdProjectsSwitch guards', () => {
     }
   });
 });
+
+// ─── cmdProjectsSwitch thin-skeleton ────────────────────────────────────────
+
+describe('cmdProjectsSwitch thin-skeleton', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = createTempDir(); tmpDir = fs.realpathSync(tmpDir); initGitRepo(tmpDir);
+    setupPlanning(tmpDir);
+  });
+
+  afterEach(() => { resetPaths(); cleanupDir(tmpDir); });
+
+  it('cmdProjectsSwitch succeeds on a thin-skeleton slug and writes current_project to config.json', () => {
+    // v2 prerequisites: config.json, PROJECTS.md, REPOS.md at planning root,
+    // plus the thin-skeleton project under projects/<slug>/PROJECT.md
+    fs.writeFileSync(path.join(tmpDir, 'config.json'), '{}');
+    fs.writeFileSync(path.join(tmpDir, 'PROJECTS.md'), '# Projects\n');
+    fs.writeFileSync(path.join(tmpDir, 'REPOS.md'), '# Repos\n');
+    createThinSkeletonProject(tmpDir, 'word-gen');
+
+    const { exitCode } = captureStdout(() => {
+      cmdProjectsSwitch(tmpDir, 'word-gen', true);
+    });
+
+    // exitCode 0 (or unset null = success path that did not throw) signals success
+    assert.ok(exitCode === 0 || exitCode === null, `expected success exit, got ${exitCode}`);
+
+    // config.json must now contain current_project: word-gen
+    const config = loadConfig(tmpDir);
+    assert.strictEqual(config.current_project, 'word-gen');
+  });
+});

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

@@ -19,6 +19,8 @@ const { execGit, output, error, loadConfig } = require('./core.cjs');
 const { getLocalConfigPath } = require('./config.cjs');
 const { getPlanningRoot } = require('./paths.cjs');
 const { cmdWorktreesCreate, cmdWorktreesRemove, rebaseAndMerge } = require('./worktrees.cjs');
+const { checkFourEyes } = require('./governance.cjs');
+const { requireGitIdentity, formatAuthorString } = require('./identity.cjs');
 
 // ─── Internal helpers ─────────────────────────────────────────────────────────
 
@@ -53,6 +55,24 @@ function _writeLocalConfig(cwd, data) {
   fs.renameSync(tmpPath, localPath);
 }
 
+/**
+ * Generate a collision-resistant quick task ID: YYMMDD-xxx
+ * xxx = 2-second precision blocks since midnight, encoded as 3-char Base36.
+ * @param {Date} [date] - Date to use (defaults to now)
+ * @returns {string} e.g. '260414-v4y'
+ */
+function generateQuickId(date) {
+  const now = date || new Date();
+  const yy = String(now.getFullYear()).slice(-2);
+  const mm = String(now.getMonth() + 1).padStart(2, '0');
+  const dd = String(now.getDate()).padStart(2, '0');
+  const dateStr = yy + mm + dd;
+  const secondsSinceMidnight = now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds();
+  const timeBlocks = Math.floor(secondsSinceMidnight / 2);
+  const timeEncoded = timeBlocks.toString(36).padStart(3, '0');
+  return dateStr + '-' + timeEncoded;
+}
+
 /**
  * Sanitize a title into a valid slug for branch/worktree naming.
  * @param {string} title
@@ -91,6 +111,13 @@ function _clearStaleQuick(cwd, project, slug, localConfig) {
 
 // ─── Exported functions ───────────────────────────────────────────────────────
 
+// Stale-defence symmetry: this function probes entry.repos paths with
+// fs.existsSync the same way getActiveQuick (below) does for QUICK
+// entries. Don't "simplify" the on-disk check away — its absence is
+// exactly the bug fixed in 260507-pdp. Asymmetry: we do NOT auto-clear
+// stale milestone entries here; milestone state is heavier and may
+// carry inspectable context. The user clears manually via
+// `dgs-tools worktrees remove <slug>`.
 /**
  * Detect whether a quick should be product-level or milestone-context.
  *
@@ -116,7 +143,16 @@ function detectQuickMode(cwd, forceMain) {
   const entry = worktrees[activeContext];
 
   if (entry && entry.type === 'milestone') {
-    return { mode: 'milestone-context', activeSlug: activeContext, activeMilestone: activeContext };
+    const repos = entry.repos || {};
+    const paths = Object.values(repos);
+    const anyExists = paths.length > 0 && paths.some(function(p) { return fs.existsSync(p); });
+    if (anyExists) {
+      return { mode: 'milestone-context', activeSlug: activeContext, activeMilestone: activeContext };
+    }
+    // Stale milestone entry — no on-disk worktree. Fall through to product
+    // mode so quicks land where the user expects. Don't auto-clear: milestone
+    // state is heavier than quick state and may carry context worth
+    // inspecting; the user can run `dgs-tools worktrees remove <slug>`.
   }
 
   // If active context is a quick or unknown, treat as product-level
@@ -178,9 +214,20 @@ function startProductQuick(cwd, title, mode) {
   const project = config.current_project;
   if (!project) return { success: false, error: 'No current project set' };
 
-  // Sanitize title to slug
-  const slug = _sanitizeSlug(title);
-  if (!slug) return { success: false, error: 'Cannot create slug from title: ' + title };
+  // Generate quickId and sanitize title to slug with quickId prefix
+  const quickId = generateQuickId();
+  const descSlug = _sanitizeSlug(title);
+  if (!descSlug) return { success: false, error: 'Cannot create slug from title: ' + title };
+  const slug = quickId + '-' + descSlug;
+  // Match worktrees.cjs _sanitizeSlug: slice(0, 50) then strip trailing dashes.
+  // cmdWorktreesCreate re-sanitises whatever slug we pass, so we must pre-truncate
+  // here and use the canonical slug for the execSync arg, the read-back lookup,
+  // the active_context write, and the return value. Otherwise long descSlugs
+  // (40 chars) push the total past 50 and the read-back below misses, returning
+  // repos: {} and breaking the workflow's worktree-context injection (which
+  // causes the executor to commit to main of the registered repo instead of
+  // the quick/<slug> branch in the worktree). See quick task 260507-kq9.
+  const canonicalSlug = slug.slice(0, 50).replace(/-+$/, '');
 
   // Create worktree via existing cmdWorktreesCreate
   // Note: cmdWorktreesCreate calls output() which exits the process.
@@ -194,7 +241,7 @@ function startProductQuick(cwd, title, mode) {
   try {
     const modeArgs = mode ? ' --mode ' + mode : '';
     const result = execSync(
-      'node ' + JSON.stringify(dgsTools) + ' worktrees create ' + JSON.stringify(slug) + ' --type quick' + modeArgs,
+      'node ' + JSON.stringify(dgsTools) + ' worktrees create ' + JSON.stringify(canonicalSlug) + ' --type quick' + modeArgs,
       { cwd: root, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf-8', timeout: 60000 }
     );
     // Parse output to verify creation
@@ -211,13 +258,13 @@ function startProductQuick(cwd, title, mode) {
   const localConfig = _readLocalConfig(cwd);
   if (localConfig.projects && localConfig.projects[project]
     && localConfig.projects[project].worktrees
-    && localConfig.projects[project].worktrees[slug]) {
-    localConfig.projects[project].worktrees[slug].mode = mode || null;
+    && localConfig.projects[project].worktrees[canonicalSlug]) {
+    localConfig.projects[project].worktrees[canonicalSlug].mode = mode || null;
   }
 
   // Set active_context
   if (!localConfig.execution) localConfig.execution = {};
-  localConfig.execution.active_context = slug;
+  localConfig.execution.active_context = canonicalSlug;
 
   _writeLocalConfig(cwd, localConfig);
 
@@ -226,9 +273,9 @@ function startProductQuick(cwd, title, mode) {
     (finalConfig.projects &&
       finalConfig.projects[project] &&
       finalConfig.projects[project].worktrees &&
-      finalConfig.projects[project].worktrees[slug] &&
-      finalConfig.projects[project].worktrees[slug].repos) || {};
-  return { success: true, slug: slug, repos: repos };
+      finalConfig.projects[project].worktrees[canonicalSlug] &&
+      finalConfig.projects[project].worktrees[canonicalSlug].repos) || {};
+  return { success: true, slug: canonicalSlug, repos: repos };
 }
 
 /**
@@ -237,7 +284,8 @@ function startProductQuick(cwd, title, mode) {
  * @param {string} cwd - Planning root
  * @returns {{ success: boolean, commitCount?: number, slug?: string, error?: string, manualInstructions?: string }}
  */
-function quickComplete(cwd) {
+function quickComplete(cwd, options) {
+  options = options || {};
   const active = getActiveQuick(cwd);
   if (!active) {
     return { success: false, error: 'No active product-level quick to complete. If working in a milestone context, changes are part of the milestone.' };
@@ -256,6 +304,88 @@ function quickComplete(cwd) {
   const config = loadConfig(cwd);
   const baseBranch = config.base_branch || 'main';
 
+  // ── Four-Eyes Gate (GATE-02) ───────────────────────────────────────────────
+  const planRoot = getPlanningRoot(cwd);
+  const rawConfig = (() => {
+    try {
+      return JSON.parse(fs.readFileSync(path.join(planRoot, 'config.json'), 'utf-8'));
+    } catch { return {}; }
+  })();
+  const fourEyesMode = (rawConfig.workflow && rawConfig.workflow.four_eyes) || 'off';
+
+  if (fourEyesMode !== 'off') {
+    // Resolve current user identity
+    let currentUserStr = '';
+    try {
+      const identity = requireGitIdentity(cwd);
+      currentUserStr = formatAuthorString(identity);
+    } catch {
+      currentUserStr = '';
+    }
+
+    // Get contributors from quick task worktree commits
+    const quickContributors = [];
+    for (const repoName of repoNames) {
+      const worktreePath = repos[repoName];
+      const branchName = 'quick/' + slug;
+      try {
+        // Get unique commit authors from the quick branch
+        const logResult = execGit(worktreePath, ['log', '--format=%aN <%aE>', baseBranch + '..' + branchName]);
+        if (logResult.exitCode === 0 && logResult.stdout.trim()) {
+          const authors = logResult.stdout.trim().split('\n');
+          for (const author of authors) {
+            if (author.trim()) quickContributors.push(author.trim());
+          }
+        }
+      } catch { /* ignore — contributor detection is best-effort */ }
+    }
+
+    // Deduplicate contributors
+    const seen = new Map();
+    for (const c of quickContributors) {
+      const key = c.toLowerCase();
+      if (!seen.has(key)) seen.set(key, c);
+    }
+    const uniqueContribs = [...seen.values()];
+
+    // Run four-eyes check
+    const feResult = checkFourEyes(uniqueContribs, currentUserStr, fourEyesMode);
+
+    // Display contributor list (SHR-02 — contextual: "this task")
+    const contribNames = uniqueContribs.length > 0
+      ? uniqueContribs.join(', ')
+      : '(none detected)';
+
+    if (feResult.passed) {
+      process.stderr.write('Contributors: ' + contribNames + ' \u2014 \u2714 Four-eyes satisfied\n');
+    } else {
+      process.stderr.write('Contributors: ' + contribNames + '\n');
+
+      let displayName = currentUserStr;
+      try {
+        const identity = requireGitIdentity(cwd);
+        displayName = identity.name;
+      } catch { /* use full string */ }
+
+      if (fourEyesMode === 'warn') {
+        // Warn: display warning, proceed
+        process.stderr.write('\u26A0 You (' + displayName + ') contributed to this task. Completing anyway (warn mode).\n');
+      } else if (fourEyesMode === 'enforce') {
+        if (options.force) {
+          // Force: display override, proceed
+          process.stderr.write('\u26A0 Forced: you (' + displayName + ') are the only contributor. Override logged.\n');
+        } else {
+          // Block: return error
+          return {
+            success: false,
+            error: '\u2718 Blocked: you (' + displayName + ') are the only contributor. Use --force to override.',
+          };
+        }
+      }
+    }
+  }
+  // Off mode: no check, no output (GATE-03)
+
   // Rebase and merge each repo
   for (const repoName of repoNames) {
     const worktreePath = repos[repoName];
@@ -366,8 +496,9 @@ function quickAbandon(cwd, confirmed) {
  * CLI handler for `dgs-tools complete-quick` (also `quick-complete` for backward compat).
  * @param {string} cwd
  */
-function cmdQuickComplete(cwd) {
-  const result = quickComplete(cwd);
+function cmdQuickComplete(cwd, args) {
+  const force = args && args.includes('--force');
+  const result = quickComplete(cwd, { force });
   if (!result.success) {
     if (result.manualInstructions) {
       process.stderr.write(result.manualInstructions + '\n');
@@ -425,6 +556,22 @@ function cmdQuickAbandon(cwd, args) {
  * @param {object} options - { description, quickDir, statePath, push, repoCwd, fast }
  * @param {boolean} raw - true to emit raw JSON, false for pretty output
  */
+// Collect the list of still-dirty paths in `gitCwd` after a commit. Purely
+// informational — populates `result.dirty_after` so callers can detect
+// verify-step side effects that leaked outside the staged file set. Never
+// throws. Duplicated from commands.cjs/phase.cjs instead of extracted because
+// the three call sites use slightly different cwd variables (gitCwd vs
+// gitCwdReal vs cwd) and a shared helper would obscure that.
+function collectDirtyAfter(gitCwd) {
+  const porcelain = execGit(gitCwd, ['status', '--porcelain']);
+  if (porcelain.exitCode !== 0) return [];
+  return (porcelain.stdout || '')
+    .split('\n')
+    .map(l => l.trim())
+    .filter(Boolean)
+    .map(l => l.replace(/^..\s+/, ''));
+}
+
 function cmdQuickFinalize(cwd, quickId, options, raw) {
   options = options || {};
 
@@ -490,15 +637,20 @@ function cmdQuickFinalize(cwd, quickId, options, raw) {
     }
 
     const taskDir = path.join(options.quickDir, taskDirName);
-    const candidates = [
-      path.join(taskDir, quickId + '-PLAN.md'),
-      path.join(taskDir, quickId + '-SUMMARY.md'),
-      path.join(taskDir, quickId + '-CONTEXT.md'),
-      path.join(taskDir, quickId + '-VERIFICATION.md'),
-    ];
-    for (const abs of candidates) {
-      if (fs.existsSync(abs)) {
-        filesToStage.push(toRel(abs));
+    // Sweep all quick-task artifacts in taskDir, accepting both the flat
+    // ({quickId}-NAME.md) and numbered ({quickId}-NN-NAME.md) shapes. The
+    // numbered shape is what the dgs-planner template renders for quick
+    // tasks (see agents/dgs-planner.md). False-positive risk is negligible
+    // because quickId is a 6-char base36 timestamp + 3-char suffix.
+    const escapedId = quickId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const artifactRe = new RegExp(
+      '^' + escapedId + '(-\\d+)?-(PLAN|SUMMARY|CONTEXT|VERIFICATION|CODEREVIEW|DEBUG-LOG|RESEARCH)\\.md$'
+    );
+    let taskEntries = [];
+    try { taskEntries = fs.readdirSync(taskDir); } catch { /* taskDir guard above already handled missing dir */ }
+    for (const entry of taskEntries) {
+      if (artifactRe.test(entry)) {
+        filesToStage.push(toRel(path.join(taskDir, entry)));
       }
     }
   }
@@ -542,6 +694,7 @@ function cmdQuickFinalize(cwd, quickId, options, raw) {
     result.commit_reason = nothing ? 'nothing_to_commit' : 'commit_failed';
     if (!nothing) result.commit_error = commitResult.stderr;
     result.files_committed = [];
+    result.dirty_after = collectDirtyAfter(gitCwdReal);
     output(result, raw);
     return;
   }
@@ -550,6 +703,7 @@ function cmdQuickFinalize(cwd, quickId, options, raw) {
   result.hash = hashResult.exitCode === 0 ? hashResult.stdout : null;
   result.commit_reason = 'committed';
   result.files_committed = filesToStage;
+  result.dirty_after = collectDirtyAfter(gitCwdReal);
 
   // Optional push (same semantics as cmdPhaseFinalize)
   if (options.push) {
@@ -573,6 +727,7 @@ function cmdQuickFinalize(cwd, quickId, options, raw) {
 }
 
 module.exports = {
+  generateQuickId,
   detectQuickMode,
   getActiveQuick,
   startProductQuick,