multi-agents-cli 1.0.91 → 1.0.93

package/core/workflow/agent.js

@@ -863,6 +863,42 @@ const main = async () => {
     }
   }
 
+
+  // Soft gate - shared selected but missing prerequisites
+  if (project === 'shared') {
+    const clientCompleted  = buildEntries.filter(e => e.scope === 'client'  && e.status === 'COMPLETED');
+    const backendCompleted = buildEntries.filter(e => e.scope === 'backend' && e.status === 'COMPLETED');
+    const clientUIДone     = clientCompleted.some(e => e.agent === 'UI');
+    const backendINITDone  = backendCompleted.some(e => e.agent === 'INIT');
+    const missing = [];
+
+    if (!clientUIДone) {
+      missing.push({ item: 'Client scaffold', detail: 'no completed client work found — SECURITY needs to know what auth patterns the client uses' });
+    }
+    if (!backendINITDone) {
+      missing.push({ item: 'Backend INIT', detail: 'backend not scaffolded yet — SECURITY needs to know the backend auth strategy and DB schema' });
+    }
+    if (!contracts.hasContent) {
+      missing.push({ item: 'CONTRACTS.md', detail: 'no shared types defined — auth utilities should align with established contracts' });
+    }
+
+    if (missing.length > 0) {
+      console.log(`\n${yellow('  ⚠ Shared prerequisites not fully met:')}
+`);
+      missing.forEach(m => {
+        console.log(`  ${dim('→')} ${bold(m.item)}`);
+        console.log(`     ${m.detail}\n`);
+      });
+      console.log(`  ${dim('The agent will proceed autonomously and make assumptions about auth patterns.')}`);
+      console.log(`  ${dim('These may need revision once client and backend are fully established.\n')}`);
+      const proceedIdx = await arrowSelect('Shared prerequisites not met:', [
+        { label: `${green('→')} Proceed anyway` },
+        { label: `${yellow('←')} Go back — pick a different scope  ${dim('← recommended')}` },
+      ], rl);
+      if (proceedIdx === 1) continue flowLoop;
+    }
+  }
+
   // ── Select agent (with re-selection loop + back to scope) ────────────────────
 
   const agentOptions = AGENTS[project] || [];
@@ -1143,6 +1179,122 @@ const main = async () => {
     }
   }
 
+
+  // ── Backend simultaneous flow (client/LOGIC only, separate backend, first run) ──
+  let backendLaunchTiming = null;
+  const isSimultaneousCandidate =
+    project === 'client' &&
+    agent   === 'LOGIC'  &&
+    config.backend?.type === 'separate' &&
+    !argAgent &&
+    !buildEntries.some(e => e.scope === 'backend') &&
+    !tracking?.backend?.INIT?.backendPromptShown;
+
+  if (isSimultaneousCandidate) {
+    separator();
+    console.log(`\n  ${yellow('⚡ Backend not started yet')}\n`);
+    console.log(`  Your backend has not been scaffolded yet.`);
+    console.log(`  Since client/LOGIC establishes integration contracts, this is the ideal moment to plan backend scaffolding.\n`);
+
+    const intentIdx = await arrowSelect('Would you like to include backend/INIT?', [
+      { label: `${green('→')} Yes — I want to scaffold the backend` },
+      { label: `${dim('→')} No  — continue with client/LOGIC only` },
+    ], rl);
+
+    if (intentIdx === 0) {
+      console.log('');
+      const timingIdx = await arrowSelect('When would you like to scaffold backend/INIT?', [
+        { label: `${green('→')} Now   — open backend/INIT workspace alongside this LOGIC session\n              ${dim('A second IDE window will open. Both agents run in parallel.')}` },
+        { label: `${dim('→')} After — launch backend/INIT when LOGIC completes\n              ${dim('complete.js will prompt you immediately after merge.')}` },
+        { label: `${dim('→')} Skip  — changed my mind, continue with client/LOGIC only` },
+      ], rl);
+
+      if (timingIdx === 0) backendLaunchTiming = 'now';
+      else if (timingIdx === 1) backendLaunchTiming = 'after';
+      else backendLaunchTiming = 'skip';
+    } else {
+      backendLaunchTiming = 'skip';
+    }
+
+    // Write flag to backend/INIT tracking slot — prevents prompt from showing again
+    guards.updateTrackingSlot(tracking, 'backend', 'INIT', {
+      backendPromptShown:  true,
+      backendLaunchTiming,
+    }, ROOT);
+
+    // Inject backend coordination block into TASK.md contextSection
+    if (backendLaunchTiming === 'now') {
+      contextSection += `\n---\n\n## Backend Coordination\n\nBackend/INIT is running in parallel in a separate workspace.\nEstablish CONTRACTS.md entries early — the backend agent will consume them.\nDo not wait for backend confirmation. Work autonomously on client scope.\n`;
+    } else if (backendLaunchTiming === 'after') {
+      contextSection += `\n---\n\n## Backend Coordination\n\nBackend/INIT will launch after this LOGIC session completes.\nBe deliberate about API contracts — document all integration points in CONTRACTS.md.\nThe backend agent will use these as its starting reference.\n`;
+    }
+
+    // If Now — create backend/INIT worktree immediately
+    if (backendLaunchTiming === 'now') {
+      const beTimestamp    = Date.now();
+      const beBranchName   = `agent/backend/init/${beTimestamp}`;
+      const beWorktreeName = `${config.projectName.toLowerCase().replace(/\s+/g, '-')}-backend-init-${beTimestamp}`;
+      const beWorktreePath = path.join(ROOT, 'worktrees', beWorktreeName);
+
+      console.log(`\n  ${dim('Setting up backend/INIT workspace...')}\n`);
+
+      try {
+        execSync(`git worktree add "${beWorktreePath}" -b ${beBranchName}`, { cwd: ROOT, stdio: 'pipe' });
+
+        // Framework files
+        const beScope = generateClaudeScope({ project: 'backend', agent: 'INIT', branchName: beBranchName, worktreePath: beWorktreePath });
+        fs.writeFileSync(path.join(beWorktreePath, '.claude-scope'), beScope, 'utf8');
+
+        const beTask = AGENT_DESCRIPTIONS.backend?.INIT || 'scaffolds backend architecture, folder structure, DB setup, wiring config and contracts';
+        const beTaskMd = generateTaskMd({ project: 'backend', agent: 'INIT', task: beTask, branchName: beBranchName, contextSection: '', remoteSetupSection: '' });
+        fs.writeFileSync(path.join(beWorktreePath, 'TASK.md'), beTaskMd, 'utf8');
+
+        const bePkg = {
+          name: `${config.projectName.toLowerCase().replace(/\s+/g, '-')}-worktree`,
+          version: '1.0.0', private: true,
+          scripts: {
+            init:     'multi-agents init',
+            agent:    `node "${ROOT}/.workflow/run.js"`,
+            restart:  `node "${ROOT}/.workflow/restart.js"`,
+            reset:    `node "${ROOT}/.workflow/reset.js"`,
+            complete: `node "${ROOT}/.workflow/complete.js"`,
+          },
+        };
+        fs.writeFileSync(path.join(beWorktreePath, 'package.json'), JSON.stringify(bePkg, null, 2), 'utf8');
+
+        const beGitignore = ['# Framework files — never commit these to the agent branch', 'package.json', '.claude-scope', 'scope.json', 'TASK.md', '.vscode/', '.idea/', '.zed/', 'node_modules/'].join('\n') + '\n';
+        fs.writeFileSync(path.join(beWorktreePath, '.gitignore'), beGitignore, 'utf8');
+
+        // Tracking
+        guards.updateTrackingSlot(tracking, 'backend', 'INIT', {
+          branch:      beBranchName,
+          timestamp:   beTimestamp,
+          launchedAt:  new Date().toISOString(),
+          status:      'ACTIVE',
+          worktreePath: beWorktreePath,
+          backendPromptShown:  true,
+          backendLaunchTiming: 'now',
+        }, ROOT);
+
+        // TASKS_HISTORY
+        tasksHistory.ensureHistoryFile(ROOT);
+        tasksHistory.writeSessionEntry(ROOT, { scope: 'backend', agent: 'INIT', branch: beBranchName, task: beTask, launchedAt: new Date().toISOString() });
+
+        console.log(`  ${green('✓')} Backend/INIT worktree created: worktrees/${beWorktreeName}`);
+
+        // Open backend IDE window
+        const beIdeOpened = openIDE(beWorktreePath);
+        if (!beIdeOpened) console.log(`  ${yellow('!')} Could not open IDE for backend — open manually at: ${dim(beWorktreePath)}`);
+        console.log(`  ${green('✓')} Backend/INIT workspace open — start a Claude Code session there when ready\n`);
+
+      } catch (e) {
+        console.log(`  ${yellow('⚠')} Could not create backend/INIT worktree: ${e.message}`);
+      }
+    }
+
+    separator();
+  }
+
   separator();
 
   // ── Confirm ───────────────────────────────────────────────────────────────────

package/core/workflow/complete.js

@@ -448,6 +448,47 @@ const main = async () => {
   separator();
   console.log('');
 
+
+  // ── Backend/INIT launch prompt (if user chose 'after' during LOGIC session) ──
+  try {
+    const _tracking = guards.loadTracking(ROOT, config);
+    const beSlot    = _tracking?.backend?.INIT;
+    if (
+      _scope === 'logic' &&
+      _parts[0] === 'agent' && _parts[1] === 'client' &&
+      beSlot?.backendLaunchTiming === 'after' &&
+      beSlot?.status !== 'ACTIVE' &&
+      beSlot?.status !== 'COMPLETED'
+    ) {
+      separator();
+      console.log(`\n  ${yellow('⚡ Ready to scaffold your backend?')}\n`);
+      console.log(`  client/LOGIC is merged. This is the ideal moment to launch backend/INIT.\n`);
+
+      const { spawn: _spawn } = require('child_process');
+      const launchIdx = await new Promise(resolve => {
+        rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const choices = [
+          '1. Launch backend/INIT now  ← recommended',
+          '2. Skip — I will handle it manually',
+        ];
+        choices.forEach(c => console.log(`  ${c}`));
+        rl2.question('\n  Select (1-2): ', ans => {
+          rl2.close();
+          resolve(parseInt(ans));
+        });
+      });
+
+      if (launchIdx === 1) {
+        console.log(`\n  ${green('✓')} Launching backend/INIT...\n`);
+        rl.close();
+        _spawn('node', [path.join(ROOT, '.workflow', 'agent.js'), '--scope=backend', '--agent=INIT'], {
+          cwd: ROOT, stdio: 'inherit',
+        });
+        return;
+      }
+    }
+  } catch { /* best-effort */ }
+
   rl.close();
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multi-agents-cli",
-  "version": "1.0.91",
+  "version": "1.0.93",
   "description": "Multi-agent workflow orchestration for Claude Code — isolated git worktrees, structured state tracking, autonomous task chaining",
   "keywords": [
     "claude-code",