@ktpartners/dgs-platform 2.7.0 → 2.7.2

package/agents/dgs-executor.md

@@ -517,6 +517,56 @@ node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs({phase
 Separate from per-task commits — captures execution results only.
 </final_commit>
 
+<codereview_gate>
+Check if code review is enabled:
+
+```bash
+CODEREVIEW=$(node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" config-get workflow.codereview 2>/dev/null || echo "false")
+```
+
+If `CODEREVIEW` is `true`:
+
+Display:
+```
+------------------------------------------------------------
+ DGS > SPAWNING CODE REVIEW
+------------------------------------------------------------
+
+ Reviewing {phase}-{plan} changes across 3 passes...
+```
+
+Compute diff reference for the plan's task commits:
+
+```bash
+FIRST_TASK_COMMIT=$(git log --oneline --grep="feat(${PHASE}-${PLAN}):" --grep="fix(${PHASE}-${PLAN}):" --grep="test(${PHASE}-${PLAN}):" --grep="refactor(${PHASE}-${PLAN}):" --reverse | head -1 | cut -d' ' -f1)
+```
+
+If FIRST_TASK_COMMIT is empty (no task commits found), skip codereview with message: "No task commits found for {phase}-{plan}, skipping code review."
+
+Otherwise, invoke the codereview workflow:
+
+```
+@~/.claude/deliver-great-systems/workflows/codereview.md
+```
+
+With inputs:
+- PHASE: ${PHASE}
+- PLAN: ${PLAN}
+- PLAN_PATH: ${phase_dir}/{phase}-{plan}-PLAN.md
+- PHASE_DIR: ${phase_dir}
+- DIFF_REF: ${FIRST_TASK_COMMIT}^..HEAD
+
+After codereview completes:
+- If auto-fixes were committed, the fix commit hash is noted in the codereview output
+- The SUMMARY.md already has codereview findings appended and CODEREVIEW.md has been created with the full report (both done by codereview workflow)
+- If the codereview workflow committed auto-fixes, amend the metadata commit to include the updated SUMMARY.md and CODEREVIEW.md:
+  ```bash
+  node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "" --files ${phase_dir}/{phase}-{plan}-SUMMARY.md ${phase_dir}/{phase}-{plan}-CODEREVIEW.md --amend
+  ```
+
+If `CODEREVIEW` is `false` or absent: skip silently (no output).
+</codereview_gate>
+
 <completion_format>
 ```markdown
 ## PLAN COMPLETE
@@ -546,5 +596,6 @@ Plan execution complete when:
 - [ ] STATE.md updated (position, decisions, issues, session)
 - [ ] ROADMAP.md updated with plan progress (via `roadmap update-plan-progress`)
 - [ ] Final metadata commit made (includes SUMMARY.md, STATE.md, ROADMAP.md)
+- [ ] Codereview gate checked (if enabled: codereview invoked, if auto-fixes committed: metadata commit amended)
 - [ ] Completion format returned to orchestrator
 </success_criteria>

package/deliver-great-systems/bin/dgs-tools.cjs

@@ -699,6 +699,7 @@ async function main() {
 
       // Existing single-repo commit logic
       const amend = args.includes('--amend');
+      const push = args.includes('--push');
       const message = args[1];
       // Parse --files flag (collect args after --files, stopping at other flags)
       const filesIndex = args.indexOf('--files');
@@ -706,7 +707,7 @@ async function main() {
       // Parse --phase-dir flag (available for context, passed through if supported)
       const phaseDirIdx = args.indexOf('--phase-dir');
       const phaseDir = phaseDirIdx !== -1 ? args[phaseDirIdx + 1] : null;
-      commands.cmdCommit(cwd, message, files, raw, amend);
+      commands.cmdCommit(cwd, message, files, raw, amend, push);
       break;
     }
 

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

@@ -214,7 +214,7 @@ function cmdResolveModel(cwd, agentType, raw) {
   output(result, raw, model);
 }
 
-function cmdCommit(cwd, message, files, raw, amend) {
+function cmdCommit(cwd, message, files, raw, amend, push) {
   if (!message && !amend) {
     error('commit message required');
   }
@@ -259,6 +259,27 @@ function cmdCommit(cwd, message, files, raw, amend) {
   const hashResult = execGit(cwd, ['rev-parse', '--short', 'HEAD']);
   const hash = hashResult.exitCode === 0 ? hashResult.stdout : null;
   const result = { committed: true, hash, reason: 'committed' };
+
+  // Handle push if requested
+  if (push) {
+    const syncPush = config.sync_push || 'off';
+
+    if (syncPush === 'auto') {
+      try {
+        const { pushAll } = require('./sync.cjs');
+        const pushResult = pushAll(cwd, { force: true });
+        result.pushed = pushResult.ok;
+        result.push_result = pushResult;
+      } catch (err) {
+        result.pushed = false;
+        result.push_result = { ok: false, error: err.message };
+      }
+    } else if (syncPush === 'prompt') {
+      result.needs_push = true;
+    }
+    // 'off' or any other value: no push fields added
+  }
+
   output(result, raw, hash || 'committed');
 }
 

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

@@ -0,0 +1,325 @@
+/**
+ * Tests for commands.cjs — cmdCommit --push behavior
+ *
+ * Uses Node.js built-in test runner (node:test) and assert (node:assert).
+ * Tests use real temp git repos with mocked pushAll to verify push integration.
+ */
+
+const { describe, it, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const { createTempProject } = require('./test-helpers.cjs');
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Capture JSON output from cmdCommit by intercepting console.log.
+ * cmdCommit calls output() which calls console.log(JSON.stringify(...)).
+ */
+function captureCommitOutput(fn) {
+  const logs = [];
+  const origLog = console.log;
+  console.log = (...args) => logs.push(args.join(' '));
+  try {
+    fn();
+  } finally {
+    console.log = origLog;
+  }
+  // Parse the last JSON output line
+  for (let i = logs.length - 1; i >= 0; i--) {
+    try {
+      return JSON.parse(logs[i]);
+    } catch { /* not JSON, skip */ }
+  }
+  return null;
+}
+
+/**
+ * Set up a temp project with git, write a file, and return the fixture.
+ */
+function setupGitFixture(syncPush) {
+  const configOverrides = {};
+  if (syncPush) {
+    configOverrides.git = { sync_push: syncPush };
+  }
+  const fixture = createTempProject({
+    withGit: true,
+    withConfig: configOverrides,
+  });
+  return fixture;
+}
+
+/**
+ * Write a new file and stage it so there's something to commit.
+ */
+function writeAndStageFile(cwd, name, content) {
+  const filePath = path.join(cwd, name);
+  fs.writeFileSync(filePath, content || `content-${Date.now()}`);
+  execSync(`git add "${name}"`, { cwd, stdio: 'pipe' });
+}
+
+/**
+ * Mock pushAll on the sync.cjs module exports.
+ * Since cmdCommit does a lazy require('./sync.cjs') and destructures pushAll,
+ * we need to replace it on the cached module BEFORE cmdCommit runs.
+ */
+function mockPushAll(mockFn) {
+  const syncPath = require.resolve('./sync.cjs');
+  const syncModule = require(syncPath);
+  const original = syncModule.pushAll;
+  syncModule.pushAll = mockFn;
+  return () => { syncModule.pushAll = original; };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('cmdCommit with push=false (default behavior)', () => {
+  let fixture;
+  let commands;
+
+  beforeEach(() => {
+    fixture = setupGitFixture('auto');
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('commits without push fields when push is false', () => {
+    writeAndStageFile(fixture.cwd, 'test-no-push.txt');
+    const result = captureCommitOutput(() => {
+      commands.cmdCommit(fixture.cwd, 'test commit no push', [], true, false, false);
+    });
+    assert.equal(result.committed, true);
+    assert.ok(result.hash);
+    assert.equal(result.reason, 'committed');
+    assert.equal(result.pushed, undefined, 'pushed should not be set');
+    assert.equal(result.push_result, undefined, 'push_result should not be set');
+    assert.equal(result.needs_push, undefined, 'needs_push should not be set');
+  });
+
+  it('commits without push fields when push is undefined', () => {
+    writeAndStageFile(fixture.cwd, 'test-no-push-undef.txt');
+    const result = captureCommitOutput(() => {
+      commands.cmdCommit(fixture.cwd, 'test commit no push undef', [], true, false);
+    });
+    assert.equal(result.committed, true);
+    assert.equal(result.pushed, undefined);
+    assert.equal(result.needs_push, undefined);
+  });
+});
+
+describe('cmdCommit with push=true, sync_push=auto, pushAll succeeds', () => {
+  let fixture;
+  let commands;
+  let restorePushAll;
+
+  beforeEach(() => {
+    fixture = setupGitFixture('auto');
+    restorePushAll = mockPushAll(() => ({
+      ok: true,
+      results: [{ repo: 'test', status: 'pushed', commits: 1, message: 'Pushed 1 commit' }],
+      summary: '1 pushed',
+    }));
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    restorePushAll();
+    fixture.cleanup();
+  });
+
+  it('returns pushed=true and push_result with ok=true', () => {
+    writeAndStageFile(fixture.cwd, 'test-auto-push-ok.txt');
+    const result = captureCommitOutput(() => {
+      commands.cmdCommit(fixture.cwd, 'test commit auto push ok', [], true, false, true);
+    });
+    assert.equal(result.committed, true);
+    assert.ok(result.hash);
+    assert.equal(result.pushed, true);
+    assert.ok(result.push_result);
+    assert.equal(result.push_result.ok, true);
+    assert.equal(result.needs_push, undefined, 'needs_push should not be set in auto mode');
+  });
+});
+
+describe('cmdCommit with push=true, sync_push=auto, pushAll fails', () => {
+  let fixture;
+  let commands;
+  let restorePushAll;
+
+  beforeEach(() => {
+    fixture = setupGitFixture('auto');
+    restorePushAll = mockPushAll(() => ({
+      ok: false,
+      results: [{ repo: 'test', status: 'failed', commits: null, message: 'Push rejected' }],
+      summary: '1 failed',
+    }));
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    restorePushAll();
+    fixture.cleanup();
+  });
+
+  it('returns committed=true, pushed=false, push_result with ok=false', () => {
+    writeAndStageFile(fixture.cwd, 'test-auto-push-fail.txt');
+    const result = captureCommitOutput(() => {
+      commands.cmdCommit(fixture.cwd, 'test commit auto push fail', [], true, false, true);
+    });
+    assert.equal(result.committed, true, 'commit must succeed even if push fails');
+    assert.ok(result.hash);
+    assert.equal(result.pushed, false);
+    assert.ok(result.push_result);
+    assert.equal(result.push_result.ok, false);
+  });
+});
+
+describe('cmdCommit with push=true, sync_push=auto, pushAll throws', () => {
+  let fixture;
+  let commands;
+  let restorePushAll;
+
+  beforeEach(() => {
+    fixture = setupGitFixture('auto');
+    restorePushAll = mockPushAll(() => {
+      throw new Error('Network unreachable');
+    });
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    restorePushAll();
+    fixture.cleanup();
+  });
+
+  it('returns committed=true, pushed=false, push_result with error message', () => {
+    writeAndStageFile(fixture.cwd, 'test-auto-push-throw.txt');
+    const result = captureCommitOutput(() => {
+      commands.cmdCommit(fixture.cwd, 'test commit auto push throw', [], true, false, true);
+    });
+    assert.equal(result.committed, true, 'commit must succeed even if pushAll throws');
+    assert.ok(result.hash);
+    assert.equal(result.pushed, false);
+    assert.ok(result.push_result);
+    assert.equal(result.push_result.ok, false);
+    assert.ok(result.push_result.error.includes('Network unreachable'));
+  });
+});
+
+describe('cmdCommit with push=true, sync_push=prompt', () => {
+  let fixture;
+  let commands;
+
+  beforeEach(() => {
+    fixture = setupGitFixture('prompt');
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('returns needs_push=true, no pushed or push_result fields', () => {
+    writeAndStageFile(fixture.cwd, 'test-prompt-push.txt');
+    const result = captureCommitOutput(() => {
+      commands.cmdCommit(fixture.cwd, 'test commit prompt push', [], true, false, true);
+    });
+    assert.equal(result.committed, true);
+    assert.ok(result.hash);
+    assert.equal(result.needs_push, true);
+    assert.equal(result.pushed, undefined, 'pushed should not be set in prompt mode');
+    assert.equal(result.push_result, undefined, 'push_result should not be set in prompt mode');
+  });
+});
+
+describe('cmdCommit with push=true, sync_push=off', () => {
+  let fixture;
+  let commands;
+
+  beforeEach(() => {
+    fixture = setupGitFixture('off');
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('returns no push-related fields (same as push=false)', () => {
+    writeAndStageFile(fixture.cwd, 'test-off-push.txt');
+    const result = captureCommitOutput(() => {
+      commands.cmdCommit(fixture.cwd, 'test commit off push', [], true, false, true);
+    });
+    assert.equal(result.committed, true);
+    assert.ok(result.hash);
+    assert.equal(result.pushed, undefined, 'pushed should not be set when sync_push=off');
+    assert.equal(result.push_result, undefined, 'push_result should not be set when sync_push=off');
+    assert.equal(result.needs_push, undefined, 'needs_push should not be set when sync_push=off');
+  });
+});
+
+describe('cmdCommit with push=true but nothing to commit', () => {
+  let fixture;
+  let commands;
+  let pushAllCalled;
+  let restorePushAll;
+
+  beforeEach(() => {
+    fixture = setupGitFixture('auto');
+    pushAllCalled = false;
+    restorePushAll = mockPushAll(() => {
+      pushAllCalled = true;
+      return { ok: true, results: [], summary: '' };
+    });
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    restorePushAll();
+    fixture.cleanup();
+  });
+
+  it('does not attempt push when commit has nothing to commit', () => {
+    // Don't write any new file -- nothing to commit
+    const result = captureCommitOutput(() => {
+      commands.cmdCommit(fixture.cwd, 'test nothing to commit', [], true, false, true);
+    });
+    assert.equal(result.committed, false);
+    assert.equal(result.reason, 'nothing_to_commit');
+    assert.equal(pushAllCalled, false, 'pushAll should not be called when nothing to commit');
+    assert.equal(result.pushed, undefined);
+    assert.equal(result.needs_push, undefined);
+  });
+});
+
+describe('cmdCommit with push=true, sync_push unset (defaults to off)', () => {
+  let fixture;
+  let commands;
+
+  beforeEach(() => {
+    // No sync_push in config -- should default to 'off'
+    fixture = setupGitFixture(undefined);
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('returns no push-related fields when sync_push is not configured', () => {
+    writeAndStageFile(fixture.cwd, 'test-unset-push.txt');
+    const result = captureCommitOutput(() => {
+      commands.cmdCommit(fixture.cwd, 'test commit unset push', [], true, false, true);
+    });
+    assert.equal(result.committed, true);
+    assert.equal(result.pushed, undefined);
+    assert.equal(result.push_result, undefined);
+    assert.equal(result.needs_push, undefined);
+  });
+});

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

@@ -9,7 +9,7 @@ const { loadConfig, resolveModelInternal, findPhaseInternal, getRoadmapPhaseInte
 const { requireGitIdentity, formatAuthorString } = require('./identity.cjs');
 const { getPlanningRoot, PROJECTS_DIR } = require('./paths.cjs');
 const { parseReposMd, validateReposMdEager } = require('./repos.cjs');
-const { getCadence } = require('./sync.cjs');
+const { getCadence, pullAll } = require('./sync.cjs');
 
 /**
  * Safely resolve the current git author string.
@@ -25,6 +25,67 @@ function resolveAuthorSafe(cwd) {
   }
 }
 
+// ─── Sync Pull Helper ────────────────────────────────────────────────────────
+
+/**
+ * Apply sync pull logic to an init result object.
+ *
+ * Enriches the result with `needs_pull` and optionally `pull_result` based on
+ * the sync_pull config and cadence_pull for this workflow. This moves pull
+ * orchestration into init itself so workflows get pull state in their JSON
+ * without needing to manually orchestrate sync commands.
+ *
+ * Modes:
+ *   - cadence_pull=false OR sync_pull="off": sets needs_pull=false, no pull
+ *   - sync_pull="prompt": sets needs_pull=true, no pull (workflow prompts user)
+ *   - sync_pull="auto": executes pullAll, sets needs_pull=false, adds pull_result
+ *
+ * CRITICAL: Never throws — init must always return its JSON.
+ *
+ * @param {string} cwd - Working directory
+ * @param {string} workflowName - Workflow name for logging
+ * @param {Object} result - The init result object to enrich (mutated in place)
+ */
+function applySyncPull(cwd, workflowName, result) {
+  const syncPull = result.sync_pull;
+  const cadencePull = result.cadence_pull;
+
+  // No pull: cadence says no, or mode is off
+  if (!cadencePull || syncPull === 'off') {
+    result.needs_pull = false;
+    return;
+  }
+
+  // Prompt mode: signal that pull is needed but don't execute
+  if (syncPull === 'prompt') {
+    result.needs_pull = true;
+    return;
+  }
+
+  // Auto mode: execute pull immediately
+  if (syncPull === 'auto') {
+    result.needs_pull = false;
+    try {
+      const pullResult = pullAll(cwd, { force: true });
+      result.pull_result = {
+        action: pullResult.ok ? 'pulled' : 'failed',
+        ok: pullResult.ok,
+        summary: pullResult.summary,
+      };
+    } catch (err) {
+      result.pull_result = {
+        action: 'failed',
+        ok: false,
+        summary: err.message,
+      };
+    }
+    return;
+  }
+
+  // Unknown mode: treat as off
+  result.needs_pull = false;
+}
+
 // ─── v2 Project Context Resolution ──────────────────────────────────────────
 
 /**
@@ -232,6 +293,7 @@ function cmdInitExecutePhase(cwd, phase, raw) {
     v2_hint: ctx.v2_hint || null,
   };
 
+  applySyncPull(cwd, 'execute-phase', result);
   output(result, raw);
 }
 
@@ -327,6 +389,7 @@ function cmdInitPlanPhase(cwd, phase, raw) {
     } catch {}
   }
 
+  applySyncPull(cwd, 'plan-phase', result);
   output(result, raw);
 }
 
@@ -406,6 +469,7 @@ function cmdInitNewProject(cwd, raw) {
     v2_hint: ctx.v2_hint || null,
   };
 
+  applySyncPull(cwd, 'new-project', result);
   output(result, raw);
 }
 
@@ -454,6 +518,7 @@ function cmdInitNewMilestone(cwd, raw) {
     v2_hint: ctx.v2_hint || null,
   };
 
+  applySyncPull(cwd, 'new-milestone', result);
   output(result, raw);
 }
 
@@ -521,6 +586,7 @@ function cmdInitQuick(cwd, description, raw) {
     v2_hint: ctx.v2_hint || null,
   };
 
+  applySyncPull(cwd, 'quick', result);
   output(result, raw);
 }
 
@@ -569,6 +635,7 @@ function cmdInitResume(cwd, raw) {
     v2_hint: ctx.v2_hint || null,
   };
 
+  applySyncPull(cwd, 'resume-work', result);
   output(result, raw);
 }
 
@@ -612,6 +679,7 @@ function cmdInitVerifyWork(cwd, phase, raw) {
     guard: ctx.guard,
   };
 
+  applySyncPull(cwd, 'verify-work', result);
   output(result, raw);
 }
 
@@ -655,6 +723,7 @@ function cmdInitAuditPhase(cwd, phase, raw) {
     guard: ctx.guard,
   };
 
+  applySyncPull(cwd, 'audit-phase', result);
   output(result, raw);
 }
 
@@ -755,6 +824,7 @@ function cmdInitPhaseOp(cwd, phase, raw, workflow) {
     } catch {}
   }
 
+  applySyncPull(cwd, workflow || 'plan-phase', result);
   output(result, raw);
 }
 
@@ -834,6 +904,7 @@ function cmdInitTodos(cwd, area, raw, workflow) {
     v2_hint: ctx.v2_hint || null,
   };
 
+  applySyncPull(cwd, workflow || 'check-todos', result);
   output(result, raw);
 }
 
@@ -927,6 +998,7 @@ function cmdInitMilestoneOp(cwd, raw, workflow) {
     v2_hint: ctx.v2_hint || null,
   };
 
+  applySyncPull(cwd, workflow || 'complete-milestone', result);
   output(result, raw);
 }
 
@@ -1033,6 +1105,7 @@ function cmdInitMapCodebase(cwd, onlyRepo, raw) {
     v2_hint: ctx.v2_hint || null,
   };
 
+  applySyncPull(cwd, 'map-codebase', result);
   output(result, raw);
 }
 
@@ -1149,6 +1222,7 @@ function cmdInitProgress(cwd, raw) {
     v2_hint: ctx.v2_hint || null,
   };
 
+  applySyncPull(cwd, 'progress', result);
   output(result, raw);
 }
 
@@ -1166,4 +1240,5 @@ module.exports = {
   cmdInitMilestoneOp,
   cmdInitMapCodebase,
   cmdInitProgress,
+  applySyncPull,
 };

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

@@ -505,12 +505,12 @@ describe('v2 mode with project: init todos', () => {
     fixture.cleanup();
   });
 
-  it('returns project-qualified pending_dir', () => {
-    assert.equal(result.pending_dir, path.join('.planning', 'projects', 'test-project', 'todos', 'pending'));
+  it('returns product-level pending_dir', () => {
+    assert.equal(result.pending_dir, path.join('.planning', 'todos', 'pending'));
   });
 
-  it('returns project-qualified completed_dir', () => {
-    assert.equal(result.completed_dir, path.join('.planning', 'projects', 'test-project', 'todos', 'completed'));
+  it('returns product-level completed_dir', () => {
+    assert.equal(result.completed_dir, path.join('.planning', 'todos', 'completed'));
   });
 
   it('returns dgs_mode v2', () => {
@@ -1210,6 +1210,179 @@ describe('branch_name with {project} resolution', () => {
 
 // ─── Backward Compatibility ──────────────────────────────────────────────────
 
+// ─── Sync Pull: needs_pull field tests ────────────────────────────────────────
+
+// Helper: v1 fixture with custom git.sync_pull setting
+function v1FixtureWithSyncPull(syncPull) {
+  return createFixture({
+    '.planning/config.json': JSON.stringify({ git: { sync_pull: syncPull } }),
+    '.planning/STATE.md': '# State',
+    '.planning/ROADMAP.md': '# Roadmap\n\n## Phases\n\n- [ ] **Phase 1: Test Phase** - A test\n',
+    '.planning/REQUIREMENTS.md': '# Requirements',
+    '.planning/PROJECT.md': '# Project',
+    '.planning/phases/01-test-phase/01-CONTEXT.md': '# Context',
+    '.planning/phases/01-test-phase/01-01-PLAN.md': '---\nphase: 01-test-phase\nplan: 01\n---\n# Plan',
+  });
+}
+
+describe('init commands include needs_pull field (sync_pull off)', () => {
+  let fixture;
+
+  beforeEach(() => {
+    fixture = v1Fixture();
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('init execute-phase returns needs_pull false when sync_pull is off', () => {
+    const result = runInit(fixture.cwd, 'execute-phase 1');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('init plan-phase returns needs_pull false when sync_pull is off', () => {
+    const result = runInit(fixture.cwd, 'plan-phase 1');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('init quick returns needs_pull false when sync_pull is off', () => {
+    const result = runInit(fixture.cwd, 'quick "test task"');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('init progress returns needs_pull false when sync_pull is off', () => {
+    const result = runInit(fixture.cwd, 'progress');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('init new-project returns needs_pull false when sync_pull is off', () => {
+    const result = runInit(fixture.cwd, 'new-project');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('init resume returns needs_pull false when sync_pull is off', () => {
+    const result = runInit(fixture.cwd, 'resume');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('init milestone-op returns needs_pull false when sync_pull is off', () => {
+    const result = runInit(fixture.cwd, 'milestone-op');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('init map-codebase returns needs_pull false when sync_pull is off', () => {
+    const result = runInit(fixture.cwd, 'map-codebase');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('no pull_result when sync_pull is off', () => {
+    const result = runInit(fixture.cwd, 'execute-phase 1');
+    assert.equal(result.pull_result, undefined);
+  });
+});
+
+describe('init with sync_pull prompt returns needs_pull true', () => {
+  let fixture;
+
+  beforeEach(() => {
+    fixture = v1FixtureWithSyncPull('prompt');
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('init execute-phase returns needs_pull true when sync_pull is prompt and cadence says pull', () => {
+    const result = runInit(fixture.cwd, 'execute-phase 1');
+    assert.equal(result.needs_pull, true);
+    assert.equal(result.pull_result, undefined);
+  });
+
+  it('init plan-phase returns needs_pull true when sync_pull is prompt', () => {
+    const result = runInit(fixture.cwd, 'plan-phase 1');
+    assert.equal(result.needs_pull, true);
+    assert.equal(result.pull_result, undefined);
+  });
+
+  it('init quick returns needs_pull true when sync_pull is prompt', () => {
+    const result = runInit(fixture.cwd, 'quick "test task"');
+    assert.equal(result.needs_pull, true);
+    assert.equal(result.pull_result, undefined);
+  });
+
+  it('init resume returns needs_pull true when sync_pull is prompt (cadence_pull is true for resume-work)', () => {
+    const result = runInit(fixture.cwd, 'resume');
+    assert.equal(result.needs_pull, true);
+    assert.equal(result.pull_result, undefined);
+  });
+});
+
+describe('init with sync_pull auto but no remote returns pull_result', () => {
+  let fixture;
+
+  beforeEach(() => {
+    fixture = v1FixtureWithSyncPull('auto');
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('init execute-phase returns needs_pull false and pull_result when sync_pull is auto', () => {
+    const result = runInit(fixture.cwd, 'execute-phase 1');
+    assert.equal(result.needs_pull, false);
+    assert.ok(result.pull_result, 'pull_result should be an object');
+    assert.ok('action' in result.pull_result, 'pull_result should have action field');
+    assert.ok('ok' in result.pull_result, 'pull_result should have ok field');
+    assert.ok('summary' in result.pull_result, 'pull_result should have summary field');
+  });
+
+  it('pull_result never causes init to throw', () => {
+    // This should not throw even though the fixture has no git remote
+    const result = runInit(fixture.cwd, 'execute-phase 1');
+    assert.ok(result, 'init should return result even when pull has no remote');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('init plan-phase returns pull_result when sync_pull is auto', () => {
+    const result = runInit(fixture.cwd, 'plan-phase 1');
+    assert.equal(result.needs_pull, false);
+    assert.ok(result.pull_result, 'pull_result should be an object');
+  });
+});
+
+describe('init with cadence_pull false skips pull regardless of sync mode', () => {
+  let fixture;
+
+  beforeEach(() => {
+    // map-codebase has cadence { pull: false, push: true }
+    fixture = v1FixtureWithSyncPull('prompt');
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('init map-codebase returns needs_pull false because cadence_pull is false', () => {
+    const result = runInit(fixture.cwd, 'map-codebase');
+    assert.equal(result.cadence_pull, false, 'map-codebase cadence should have pull: false');
+    assert.equal(result.needs_pull, false);
+  });
+
+  it('init map-codebase returns no pull_result even with sync_pull auto', () => {
+    // Change to auto mode
+    const autoFixture = v1FixtureWithSyncPull('auto');
+    try {
+      const result = runInit(autoFixture.cwd, 'map-codebase');
+      assert.equal(result.needs_pull, false);
+      assert.equal(result.pull_result, undefined, 'No pull_result when cadence_pull is false');
+    } finally {
+      autoFixture.cleanup();
+    }
+  });
+});
+
 describe('backward compatibility: v1 output is superset of old shape', () => {
   let fixture;
 

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

@@ -138,7 +138,7 @@ function createBackupTag(cwd) {
 // ─── Migration Planning ─────────────────────────────────────────────────────
 
 // Directories to move (project-level, order: directories first)
-const DIRS_TO_MOVE = ['phases', 'research', 'todos', 'quick', 'debug'];
+const DIRS_TO_MOVE = ['phases', 'research', 'quick', 'debug'];
 
 // Files to move (project-level)
 const FILES_TO_MOVE = ['PROJECT.md', 'REQUIREMENTS.md', 'ROADMAP.md', 'STATE.md'];

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

@@ -327,13 +327,13 @@ describe('migrateV1ToV2', () => {
     assert.ok(log.includes('rename'));
   });
 
-  it('moves todos/ directory if it exists', () => {
+  it('preserves todos/ at product level (not moved to project)', () => {
     writeFile(tmpDir, '.planning/todos/pending/task1.md', '# Todo 1\n');
     createV1Install(tmpDir, 'Test App');
     migrateV1ToV2(tmpDir, 'test-app');
 
-    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'todos', 'pending', 'task1.md')));
-    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'todos')));
+    assert.ok(fs.existsSync(path.join(tmpDir, '.planning', 'todos', 'pending', 'task1.md')));
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'test-app', 'todos')));
   });
 
   it('moves quick/ directory if it exists', () => {
@@ -407,18 +407,15 @@ describe('collectMigrationMoves', () => {
     writeFile(tmpDir, '.planning/PROJECT.md', '# Project: Test\n');
     writeFile(tmpDir, '.planning/phases/01-setup/01-01-PLAN.md', '---\n---\n');
     writeFile(tmpDir, '.planning/research/notes.md', '# Notes\n');
-    writeFile(tmpDir, '.planning/todos/pending/task.md', '# Todo\n');
 
     const { moves } = collectMigrationMoves(tmpDir, 'test');
 
     const phasesMove = moves.find(m => m.relSource.endsWith('phases'));
     const researchMove = moves.find(m => m.relSource.endsWith('research'));
-    const todosMove = moves.find(m => m.relSource.endsWith('todos'));
     const projectMove = moves.find(m => m.relSource.endsWith('PROJECT.md'));
 
     assert.strictEqual(phasesMove.isDir, true);
     assert.strictEqual(researchMove.isDir, true);
-    assert.strictEqual(todosMove.isDir, true);
     assert.strictEqual(projectMove.isDir, false);
   });
 });

package/deliver-great-systems/bin/lib/path-audit.test.cjs

@@ -41,7 +41,7 @@ const COMPREHENSIVE_PATTERN = /\.planning\//;
  * multi-project install because they resolve to the root instead of
  * .planning/<project>/<path>.
  */
-const PROJECT_SCOPED_PATTERN = /\.planning\/(?:STATE|ROADMAP|PROJECT(?!S\.md)|REQUIREMENTS|phases|archive|quick|todos|debug|research)/;
+const PROJECT_SCOPED_PATTERN = /\.planning\/(?:STATE|ROADMAP|PROJECT(?!S\.md)|REQUIREMENTS|phases|archive|quick|debug|research)/;
 
 /**
  * Workflow files allowlisted from comprehensive .planning/ scanning.

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

@@ -14,7 +14,7 @@ const { getPlanningRoot } = require('./paths.cjs');
 
 // ─── Constants ──────────────────────────────────────────────────────────────
 
-const STANDARD_DIRS = ['phases', 'research', 'todos', 'quick', 'debug'];
+const STANDARD_DIRS = ['phases', 'research', 'quick', 'debug'];
 
 // ─── Project Subfolder Creation ─────────────────────────────────────────────
 

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

@@ -64,7 +64,7 @@ describe('createProjectSubfolder', () => {
 
   it('creates all required subdirectories', () => {
     createProjectSubfolder(tmpDir, 'auth-overhaul', 'Auth Overhaul');
-    const expectedDirs = ['phases', 'research', 'todos', 'quick', 'debug'];
+    const expectedDirs = ['phases', 'research', 'quick', 'debug'];
     for (const dir of expectedDirs) {
       assert.ok(
         fs.existsSync(path.join(tmpDir, '.planning', 'projects', 'auth-overhaul', dir)),

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

@@ -571,7 +571,7 @@ function cmdStateSnapshot(cwd, raw) {
 function getMilestonePhaseFilter(cwd) {
   const milestonePhaseNums = new Set();
   try {
-    const roadmap = fs.readFileSync(path.join(cwd, '.planning', 'ROADMAP.md'), 'utf-8');
+    const 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) {
@@ -632,7 +632,7 @@ function buildStateFrontmatter(bodyContent, cwd) {
 
   if (cwd) {
     try {
-      const phasesDir = path.join(cwd, '.planning', 'phases');
+      const phasesDir = path.join(getPlanningRoot(cwd), 'phases');
       if (fs.existsSync(phasesDir)) {
         const isDirInMilestone = getMilestonePhaseFilter(cwd);
         const phaseDirs = fs.readdirSync(phasesDir, { withFileTypes: true })

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

@@ -228,8 +228,8 @@ function createTempProject(options) {
     }
 
     if (withTodos) {
-      fs.mkdirSync(path.join(cwd, '.planning', PROJECTS_DIR, project, 'todos', 'pending'), { recursive: true });
-      fs.mkdirSync(path.join(cwd, '.planning', PROJECTS_DIR, project, 'todos', 'completed'), { recursive: true });
+      fs.mkdirSync(path.join(cwd, '.planning', 'todos', 'pending'), { recursive: true });
+      fs.mkdirSync(path.join(cwd, '.planning', 'todos', 'completed'), { recursive: true });
     }
 
     if (withResearch) {

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

@@ -527,8 +527,10 @@ The CLI handles:
 Extract from result: `next_phase`, `next_phase_name`, `is_last_phase`.
 
 ```bash
-node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs(phase-{X}): complete phase execution" --files ${roadmap_path} ${state_path} ${requirements_path} ${phase_dir}/*-VERIFICATION.md
+node "$HOME/.claude/deliver-great-systems/bin/dgs-tools.cjs" commit "docs(phase-{X}): complete phase execution" --push --files ${roadmap_path} ${state_path} ${requirements_path} ${phase_dir}/*-VERIFICATION.md
 ```
+
+Parse the commit result JSON. If `needs_push` is true (sync_push is "prompt" mode), handle push prompting via the existing sync_after step. If `pushed` is true, the push already happened atomically with the commit -- skip the sync_after push for this commit (avoid double-push). If `pushed` is false and `push_result` exists, log the push warning but do not halt.
 </step>
 
 <step name="sync_after">

package/package.json

@@ -4,7 +4,7 @@
   "bugs": {
     "url": "https://github.com/KT-Partners-Ltd/dgs-platform-docs/issues"
   },
-  "version": "2.7.0",
+  "version": "2.7.2",
   "description": "Deliver Great Systems Platform — A meta-prompting, context engineering and spec-driven development system for Claude Code and Gemini by KT Partners.",
   "bin": {
     "dgs": "bin/install.js"