multi-agents-cli 1.0.52 → 1.0.54

package/core/workflow/reset.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * Multi-Agent Monorepo Template - Reset
+ * Full project wipe with 2-step confirmation.
+ *
+ * Deletes:
+ *  - All worktrees
+ *  - All agent branches (local + remote)
+ *  - Remote GitHub repository
+ *  - All project files
+ *
+ * Run with: npm run reset
+ */
+
+'use strict';
+
+const fs           = require('fs');
+const path         = require('path');
+const readline     = require('readline');
+const { execSync } = require('child_process');
+
+let prompts = null;
+try { prompts = require('prompts'); } catch { prompts = null; }
+
+// ── Self-relocate to repo root ────────────────────────────────────────────────
+
+const ROOT = path.join(__dirname, '..');
+
+// ── Colors ────────────────────────────────────────────────────────────────────
+
+const c = {
+  reset:  '\x1b[0m',
+  bold:   '\x1b[1m',
+  dim:    '\x1b[2m',
+  green:  '\x1b[32m',
+  yellow: '\x1b[33m',
+  red:    '\x1b[31m',
+  cyan:   '\x1b[36m',
+};
+
+const bold   = (s) => `${c.bold}${s}${c.reset}`;
+const dim    = (s) => `${c.dim}${s}${c.reset}`;
+const green  = (s) => `${c.green}${s}${c.reset}`;
+const yellow = (s) => `${c.yellow}${s}${c.reset}`;
+const red    = (s) => `${c.red}${s}${c.reset}`;
+const cyan   = (s) => `${c.cyan}${s}${c.reset}`;
+
+const separator = () => console.log(`\n${dim('─'.repeat(60))}\n`);
+
+// ── Paths ─────────────────────────────────────────────────────────────────────
+
+const RUNTIME_DIR   = path.join(ROOT, '.scaffold');
+const CONFIG_PATH   = path.join(RUNTIME_DIR, '.config.json');
+const TRACKING_PATH = path.join(RUNTIME_DIR, '.tracking.json');
+const LOCK_FILE     = path.join(RUNTIME_DIR, '.initialized');
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+const main = async () => {
+
+  // ── Guard: must be initialized ───────────────────────────────────────────────
+
+  if (!fs.existsSync(LOCK_FILE)) {
+    console.log(`\n${red('  ✗ No initialized project found.')}`);
+    console.log(dim('  Run multi-agents init to create a project.\n'));
+    process.exit(1);
+  }
+
+  // ── Load config and tracking ─────────────────────────────────────────────────
+
+  const config   = fs.existsSync(CONFIG_PATH)   ? JSON.parse(fs.readFileSync(CONFIG_PATH,   'utf8')) : {};
+  const tracking = fs.existsSync(TRACKING_PATH) ? JSON.parse(fs.readFileSync(TRACKING_PATH, 'utf8')) : {};
+  const projectName = config.projectName || path.basename(ROOT);
+
+  // ── Collect active resources ──────────────────────────────────────────────────
+
+  const activeAgents = [];
+  for (const scope of ['client', 'backend', 'shared']) {
+    const agents = tracking[scope] || {};
+    for (const [agent, data] of Object.entries(agents)) {
+      if (data && data.branch) {
+        activeAgents.push({ scope, agent, data });
+      }
+    }
+  }
+
+  // ── Get remote ────────────────────────────────────────────────────────────────
+
+  let remoteUrl = null;
+  try {
+    remoteUrl = execSync('git remote get-url origin', { cwd: ROOT, encoding: 'utf8' }).trim();
+  } catch {}
+
+  // ── Display warning ───────────────────────────────────────────────────────────
+
+  separator();
+  console.log(`${red(bold('  ⚠ FULL PROJECT RESET'))}\n`);
+  console.log(`  ${bold('This will permanently delete:')}\n`);
+
+  // Project files
+  console.log(`  ${red('Project files')}`);
+  console.log(`    - All source code and configuration files`);
+  console.log(`    - All scaffold and workflow files\n`);
+
+  // Active agents
+  if (activeAgents.length > 0) {
+    console.log(`  ${red('Active agent workspaces')}`);
+    for (const { agent, scope, data } of activeAgents) {
+      console.log(`\n    ${bold(`${agent} (${scope})`)}`);
+      console.log(`      - Branch        (${data.branch})`);
+      console.log(`      - Remote branch (origin/${data.branch})`);
+      if (data.worktreePath) {
+        console.log(`      - Worktree      (${path.relative(ROOT, data.worktreePath)})`);
+      }
+    }
+    console.log('');
+  }
+
+  // Remote repo
+  if (remoteUrl) {
+    console.log(`  ${red('Remote repository')}`);
+    console.log(`    - ${remoteUrl}\n`);
+  }
+
+  console.log(`  ${red(bold('This cannot be undone.'))}\n`);
+  separator();
+
+  // ── Step 1: First confirmation ────────────────────────────────────────────────
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((resolve) => rl.question(q, (a) => resolve(a.trim())));
+
+  if (prompts && process.stdin.isTTY) {
+    const step1 = await prompts({
+      type:    'select',
+      name:    'value',
+      message: 'Are you sure you want to permanently delete this project?',
+      choices: [
+        { title: red('Yes - I understand this cannot be undone'), value: 'yes' },
+        { title: 'No - Cancel',                                   value: 'no'  },
+      ],
+    }, { onCancel: () => process.exit(0) });
+
+    if (step1.value !== 'yes') {
+      console.log(dim('\n  Reset cancelled.\n'));
+      process.exit(0);
+    }
+  } else {
+    const ans = await ask(`  ${bold('Are you sure?')} ${dim('(y/N)')}: `);
+    if (ans.toLowerCase() !== 'y') {
+      console.log(dim('\n  Reset cancelled.\n'));
+      rl.close();
+      process.exit(0);
+    }
+  }
+
+  // ── Step 2: Type project name ─────────────────────────────────────────────────
+
+  separator();
+  console.log(`  ${yellow('To confirm, type the project name exactly:')}`);
+  console.log(`  ${cyan(bold(projectName))}\n`);
+
+  const typed = await ask(`  ${bold('Project name')}: `);
+  rl.close();
+
+  if (typed !== projectName) {
+    console.log(`\n${red('  ✗ Project name does not match. Reset cancelled.')}\n`);
+    process.exit(1);
+  }
+
+  // ── Execute wipe ──────────────────────────────────────────────────────────────
+
+  separator();
+  console.log(`${yellow('  Wiping project...')}\n`);
+
+  // Remove worktrees
+  for (const { agent, data } of activeAgents) {
+    if (data.worktreePath && fs.existsSync(data.worktreePath)) {
+      try {
+        execSync(`git worktree remove "${data.worktreePath}" --force`, { cwd: ROOT, stdio: 'pipe' });
+        console.log(`  ${green('✓')} Worktree removed (${agent})`);
+      } catch {}
+    }
+  }
+
+  // Delete local branches
+  for (const { agent, data } of activeAgents) {
+    try {
+      execSync(`git branch -D ${data.branch}`, { cwd: ROOT, stdio: 'pipe' });
+      console.log(`  ${green('✓')} Local branch deleted (${agent})`);
+    } catch {}
+  }
+
+  // Delete remote branches
+  for (const { agent, data } of activeAgents) {
+    try {
+      execSync(`git push origin --delete ${data.branch}`, { cwd: ROOT, stdio: 'pipe' });
+      console.log(`  ${green('✓')} Remote branch deleted (${agent})`);
+    } catch {}
+  }
+
+  // Delete remote repo via gh CLI if available
+  if (remoteUrl) {
+    try {
+      const repoPath = remoteUrl.replace('https://github.com/', '').replace('git@github.com:', '').replace('.git', '');
+      execSync(`gh repo delete ${repoPath} --yes`, { stdio: 'pipe' });
+      console.log(`  ${green('✓')} Remote repository deleted`);
+    } catch {
+      console.log(`  ${yellow('!')} Could not delete remote repository automatically.`);
+      console.log(dim(`     Delete manually at: ${remoteUrl}`));
+    }
+  }
+
+  // Wipe project files (keep .git temporarily for branch ops above)
+  const keepList = ['.git'];
+  const entries  = fs.readdirSync(ROOT);
+  for (const entry of entries) {
+    if (keepList.includes(entry)) continue;
+    try {
+      fs.rmSync(path.join(ROOT, entry), { recursive: true, force: true });
+    } catch {}
+  }
+  console.log(`  ${green('✓')} Project files removed`);
+
+  // Remove .git
+  try {
+    fs.rmSync(path.join(ROOT, '.git'), { recursive: true, force: true });
+    console.log(`  ${green('✓')} Git history removed`);
+  } catch {}
+
+  // ── Post-wipe instructions ────────────────────────────────────────────────────
+
+  separator();
+  console.log(`${green(bold('  Project wiped successfully.'))}\n`);
+  console.log(`  To start fresh:\n`);
+  console.log(`  ${cyan(`cd .. && multi-agents init ${projectName}`)}\n`);
+  separator();
+
+  process.exit(0);
+};
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/core/workflow/restart.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+/**
+ * Multi-Agent Monorepo Template - Agent Restarter
+ * Run with: npm run restart
+ */
+
+const fs                  = require('fs');
+const path                = require('path');
+const { execSync, spawn } = require('child_process');
+const readline            = require('readline');
+
+let prompts;
+try { prompts = require('prompts'); } catch { prompts = null; }
+
+// ── Colour helpers ────────────────────────────────────────────────────────────
+const rst    = '\x1b[0m';
+const dim    = s => `\x1b[2m${s}${rst}`;
+const bold   = s => `\x1b[1m${s}${rst}`;
+const green  = s => `\x1b[32m${s}${rst}`;
+const yellow = s => `\x1b[33m${s}${rst}`;
+const red    = s => `\x1b[31m${s}${rst}`;
+const cyan   = s => `\x1b[36m${s}${rst}`;
+const sep    = () => console.log(dim('─'.repeat(60)));
+
+// ── ROOT resolution (works from any worktree) ─────────────────────────────────
+const ROOT = (() => {
+  try {
+    const common = execSync('git rev-parse --git-common-dir', { stdio: 'pipe' }).toString().trim();
+    return common.endsWith('/.git') ? common.slice(0, -5) : path.resolve(common, '..');
+  } catch {
+    console.error(red('  Not inside a git repository.\n'));
+    process.exit(1);
+  }
+})();
+
+const SCAFFOLD_DIR  = path.join(ROOT, '.scaffold');
+const TRACKING_PATH = path.join(SCAFFOLD_DIR, '.tracking.json');
+const CONFIG_PATH   = path.join(SCAFFOLD_DIR, '.config.json');
+
+if (!fs.existsSync(CONFIG_PATH)) {
+  console.log(red('\n  Missing .scaffold/.config.json.'));
+  console.log(dim('  Run npm run init first.\n'));
+  process.exit(1);
+}
+
+const config   = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+const tracking = fs.existsSync(TRACKING_PATH)
+  ? JSON.parse(fs.readFileSync(TRACKING_PATH, 'utf8'))
+  : {};
+
+const ENTRY_CWD = process.cwd();
+
+// ── Constants ─────────────────────────────────────────────────────────────────
+const INIT_AGENTS = { client: ['UI'], backend: ['INIT'] };
+
+const DEPENDENCIES = {
+  client:  { UI: ['LOGIC', 'FORMS', 'ROUTING', 'TESTING', 'ACCESSIBILITY'] },
+  backend: { INIT: ['API', 'LOGIC', 'AUTH', 'DB', 'EVENTS', 'JOBS', 'TESTING'] },
+  shared:  {},
+};
+
+// ── Git worktrees ─────────────────────────────────────────────────────────────
+const getWorktrees = () => {
+  try {
+    const out = execSync('git worktree list --porcelain', { cwd: ROOT, stdio: 'pipe' }).toString();
+    return out.trim().split('\n\n').reduce((acc, block) => {
+      const lines  = block.split('\n');
+      const wtPath = lines.find(l => l.startsWith('worktree '))?.replace('worktree ', '').trim();
+      const branch = lines.find(l => l.startsWith('branch '))?.replace('branch refs/heads/', '').trim();
+      if (wtPath && branch && wtPath !== ROOT) acc.push({ path: wtPath, branch });
+      return acc;
+    }, []);
+  } catch { return []; }
+};
+
+// ── Candidate list: tracked + untracked ──────────────────────────────────────
+const buildCandidates = () => {
+  const worktrees  = getWorktrees();
+  const candidates = [];
+
+  for (const scope of ['client', 'backend', 'shared']) {
+    for (const [agent, data] of Object.entries(tracking[scope] || {})) {
+      if (!data?.branch) continue;
+      const wt = worktrees.find(w => w.branch === data.branch);
+      candidates.push({
+        scope, agent,
+        branch:       data.branch,
+        worktreePath: data.worktreePath || wt?.path || null,
+        status:       data.status || 'ACTIVE',
+      });
+    }
+  }
+
+  for (const wt of worktrees) {
+    const m = wt.branch.match(/^agent\/(client|backend|shared)\/([A-Z]+)\//);
+    if (!m || candidates.find(c => c.branch === wt.branch)) continue;
+    candidates.push({ scope: m[1], agent: m[2], branch: wt.branch, worktreePath: wt.path, status: 'UNTRACKED' });
+  }
+
+  return candidates;
+};
+
+const detectCurrentAgent = (candidates) =>
+  candidates.find(c => c.worktreePath && ENTRY_CWD.startsWith(c.worktreePath));
+
+// ── Prompts ───────────────────────────────────────────────────────────────────
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+const ask = q => new Promise(r => rl.question(q, a => r(a.trim())));
+
+const arrowSelect = async (message, choices) => {
+  if (prompts && process.stdin.isTTY) {
+    const res = await prompts({
+      type: 'select', name: 'value', message,
+      choices: choices.map((c, i) => ({ title: c.label, value: i })),
+    }, { onCancel: () => process.exit(0) });
+    return res.value;
+  }
+  choices.forEach((c, i) => console.log(`  ${dim(`${i + 1}.`)} ${c.label}`));
+  return new Promise(resolve => {
+    rl.question(`\n  Select (1-${choices.length}): `, ans => {
+      const n = parseInt(ans) - 1;
+      resolve(!isNaN(n) && n >= 0 && n < choices.length ? n : 0);
+    });
+  });
+};
+
+// ── Wipe a single agent slot ──────────────────────────────────────────────────
+const wipeAgent = ({ scope, agent, branch, worktreePath }) => {
+  try { execSync(`git worktree remove "${worktreePath}" --force`, { cwd: ROOT, stdio: 'pipe' }); } catch {}
+  try { execSync(`git branch -D ${branch}`, { cwd: ROOT, stdio: 'pipe' }); } catch {}
+  try { execSync(`git push origin --delete ${branch}`, { cwd: ROOT, stdio: 'pipe' }); } catch {}
+
+  if (tracking[scope]?.[agent]) {
+    tracking[scope][agent] = { branch: null, timestamp: null, launchedAt: null, status: null, missingCount: 0, worktreePath: null };
+    fs.writeFileSync(TRACKING_PATH, JSON.stringify(tracking, null, 2), 'utf8');
+  }
+  console.log(`  ${green('✓')} ${agent} wiped`);
+};
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+const main = async () => {
+  console.log('\n');
+  console.log(bold(cyan('  Multi-Agent Monorepo Template')));
+  console.log(dim(`  Agent Restarter - ${config.projectName}\n`));
+  sep();
+
+  const candidates = buildCandidates();
+
+  if (candidates.length === 0) {
+    console.log(yellow('\n  No active agents found. Nothing to restart.\n'));
+    console.log(dim(`  Run ${cyan('npm run agent')} to start a new task.\n`));
+    rl.close(); process.exit(0);
+  }
+
+  // ── Detect location ───────────────────────────────────────────────────────
+  let candidate = detectCurrentAgent(candidates);
+
+  if (!candidate) {
+    sep();
+    console.log(`\n${bold('* Select agent to restart:')}\n`);
+    const idx = await arrowSelect('Select agent', [
+      ...candidates.map(c => ({
+        label: `${bold(c.agent)} ${dim(`(${c.scope})`)}  ${dim(c.branch)}  ${c.status === 'UNTRACKED' ? yellow('untracked') : dim(c.status)}`,
+      })),
+      { label: dim('← cancel') },
+    ]);
+    if (idx === candidates.length) {
+      console.log(dim('\n  Cancelled.\n')); rl.close(); process.exit(0);
+    }
+    candidate = candidates[idx];
+  }
+
+  const { scope, agent, branch, worktreePath } = candidate;
+  const isInitAgent = (INIT_AGENTS[scope] || []).includes(agent);
+  const deps        = (DEPENDENCIES[scope] || {})[agent] || [];
+  const activeDeps  = deps.filter(dep => tracking[scope]?.[dep]?.branch);
+
+  // ── Show agent info ───────────────────────────────────────────────────────
+  sep();
+  console.log(`\n  ${bold('Agent:')}  ${cyan(agent)} ${dim(`(${scope})`)}`);
+  console.log(`  ${bold('Branch:')} ${dim(branch)}`);
+  if (worktreePath) console.log(`  ${bold('Path:')}   ${dim(worktreePath)}\n`);
+
+  // ── Cascade warning ───────────────────────────────────────────────────────
+  if (isInitAgent) {
+    console.log(yellow(`  ⚠ ${agent} is a scaffold agent. Restarting will also wipe:\n`));
+    deps.forEach(dep => console.log(`    ${dim('→')} ${dep}`));
+    console.log(`\n  ${red('All dependent work will be permanently lost.')}\n`);
+  } else if (activeDeps.length > 0) {
+    console.log(yellow('  ⚠ Active dependent agents that will also be wiped:\n'));
+    activeDeps.forEach(dep => console.log(`    ${dim('→')} ${dep}`));
+    console.log('');
+  }
+
+  // ── Decision block ────────────────────────────────────────────────────────
+  const actionIdx = await arrowSelect('What would you like to do?', [
+    { label: `${bold('Init this agent')}  - wipe and restart fresh` },
+    { label: `${bold('Abort')}            - go back or exit` },
+  ]);
+
+  if (actionIdx === 1) {
+    sep();
+    const abortIdx = await arrowSelect('What would you like to do?', [
+      { label: `${bold('Take me back')}  - return to where you were` },
+      { label: `${bold('Exit')}          - stay here and exit` },
+    ]);
+    if (abortIdx === 0) {
+      console.log(`\n  ${green('✓')} Run this to return:\n`);
+      console.log(`  ${cyan(`cd "${ENTRY_CWD}"`)}\n`);
+    } else {
+      console.log(dim('\n  Exited.\n'));
+    }
+    rl.close(); process.exit(0);
+  }
+
+  // ── Wipe ──────────────────────────────────────────────────────────────────
+  sep();
+  console.log(`\n  ${bold('Wiping')} ${cyan(agent)}...\n`);
+
+  const depsToWipe = isInitAgent ? deps : activeDeps;
+  for (const dep of depsToWipe) {
+    const d  = tracking[scope]?.[dep];
+    const wt = d?.branch ? getWorktrees().find(w => w.branch === d.branch) : null;
+    if (d?.branch) wipeAgent({ scope, agent: dep, branch: d.branch, worktreePath: d.worktreePath || wt?.path });
+  }
+  wipeAgent(candidate);
+
+  // ── Chain into agent.js ───────────────────────────────────────────────────
+  sep();
+  console.log(`\n  ${green('✓')} Restart complete. Launching agent selector...\n`);
+  rl.close();
+
+  spawn('node', [path.join(ROOT, '.workflow', 'agent.js'), `--scope=${scope}`, `--agent=${agent}`], {
+    cwd: ROOT, stdio: 'inherit',
+  }).on('exit', code => process.exit(code ?? 0));
+};
+
+main().catch(err => {
+  console.error(red(`\n  Error: ${err.message}\n`));
+  rl.close();
+  process.exit(1);
+});

package/core/workflow/tasks_history.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+/**
+ * Multi-Agent Monorepo Template - Tasks History
+ * Utility for reading and writing to TASKS_HISTORY.md
+ *
+ * Used by: agent.js (on launch), complete.js (on completion)
+ */
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const HISTORY_FILE = 'TASKS_HISTORY.md';
+
+// ── Write session entry on agent launch ───────────────────────────────────────
+
+const writeSessionEntry = (ROOT, { scope, agent, branch, task, launchedAt }) => {
+  const historyPath = path.join(ROOT, HISTORY_FILE);
+
+  const entry = `
+---
+
+## ${new Date(launchedAt).toISOString().slice(0, 10)} | ${agent} | ${scope} | ${branch}
+Launched : ${launchedAt}
+Status   : IN PROGRESS
+Task     : ${task}
+
+### User Overrides
+<!-- agent.js appends [USER OVERRIDE] entries here during session -->
+
+`;
+
+  try {
+    fs.appendFileSync(historyPath, entry, 'utf8');
+  } catch { /* best-effort */ }
+};
+
+// ── Update session status on completion ───────────────────────────────────────
+
+const updateSessionStatus = (ROOT, { branch, status, completedAt, notes }) => {
+  const historyPath = path.join(ROOT, HISTORY_FILE);
+  if (!fs.existsSync(historyPath)) return;
+
+  let content = fs.readFileSync(historyPath, 'utf8');
+
+  // Find the session block by branch name and update status
+  const sessionRegex = new RegExp(
+    `(## [^\\n]+ \\| ${branch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\n[\\s\\S]*?Status   : )IN PROGRESS`
+  );
+
+  if (sessionRegex.test(content)) {
+    content = content.replace(
+      sessionRegex,
+      `$1${status}`
+    );
+
+    // Append completion info after status line
+    content = content.replace(
+      `Status   : ${status}\nTask`,
+      `Status   : ${status}\nCompleted: ${completedAt}${notes ? `\nNotes    : ${notes}` : ''}\nTask`
+    );
+
+    try {
+      fs.writeFileSync(historyPath, content, 'utf8');
+    } catch { /* best-effort */ }
+  }
+};
+
+// ── Append user override entry ────────────────────────────────────────────────
+
+const appendUserOverride = (ROOT, { branch, timestamp, input, deviation, action }) => {
+  const historyPath = path.join(ROOT, HISTORY_FILE);
+  if (!fs.existsSync(historyPath)) return;
+
+  let content = fs.readFileSync(historyPath, 'utf8');
+
+  const overrideEntry = `- [USER OVERRIDE] ${timestamp}
+  Input    : ${input}
+  Deviation: ${deviation}
+  Action   : ${action}
+`;
+
+  // Insert override under the correct session's User Overrides section
+  const placeholder = `### User Overrides\n<!-- agent.js appends [USER OVERRIDE] entries here during session -->`;
+  const sessionBlock = `## [^\\n]+ \\| ${branch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`;
+  const sessionRegex = new RegExp(`(${sessionBlock}[\\s\\S]*?${placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`);
+
+  if (sessionRegex.test(content)) {
+    content = content.replace(
+      sessionRegex,
+      `$1\n${overrideEntry}`
+    );
+    try {
+      fs.writeFileSync(historyPath, content, 'utf8');
+    } catch { /* best-effort */ }
+  }
+};
+
+// ── Initialize TASKS_HISTORY.md if missing ────────────────────────────────────
+
+const ensureHistoryFile = (ROOT) => {
+  const historyPath = path.join(ROOT, HISTORY_FILE);
+  if (!fs.existsSync(historyPath)) {
+    fs.writeFileSync(historyPath, `# TASKS_HISTORY.md
+# Audit trail of all agent sessions and user overrides.
+# Written by agent.js (on launch) and complete.js (on completion).
+# Read by all agents at session start for full project history.
+# Never edit manually.
+`, 'utf8');
+  }
+};
+
+module.exports = {
+  writeSessionEntry,
+  updateSessionStatus,
+  appendUserOverride,
+  ensureHistoryFile,
+};

package/init.js

@@ -1060,20 +1060,11 @@ const main = async () => {
   separator();
   console.log(`\n${bold('Setting up your project...')}\n`);
 
-  // ── Clone multi-agents-core ──────────────────────────────────────────────────
+  // ── Load bundled core ───────────────────────────────────────────────────────
 
-  const CORE_REPO = 'https://github.com/JDev-il/multi-agents-core.git';
-  const CORE_DIR  = path.join(ROOT, '.agents-core');
+  const CORE_DIR = path.join(__dirname, 'core');
 
-  console.log(`  Fetching templates...`);
-  try {
-    execSync(`git clone "${CORE_REPO}" "${CORE_DIR}"`, { stdio: 'pipe' });
-    console.log(`  ${green('✓')} Templates fetched`);
-  } catch (err) {
-    console.log(`  ${red('✗')} Failed to fetch templates. Check your internet connection.`);
-    rl.close();
-    process.exit(1);
-  }
+  console.log(`  ${green('✓')} Templates ready`);
 
   const TEMPLATES = path.join(CORE_DIR, 'templates');
 
@@ -1123,8 +1114,6 @@ const main = async () => {
   fs.mkdirSync(WORKFLOW_DEST, { recursive: true });
   copyDir(WORKFLOW_SRC, WORKFLOW_DEST);
   console.log(`  ${green('✓')} Workflow scripts copied (.workflow/)`);
-
-  execSync(`rm -rf "${CORE_DIR}"`);
   console.log(`  ${green('✓')} Temporary files cleaned up`);
 
   // ── Write @config values ─────────────────────────────────────────────────────
@@ -1159,7 +1148,6 @@ const main = async () => {
   }
 
   ensureGitignore('worktrees/');
-  ensureGitignore('.agents-core/');
   ensureGitignore('.scaffold/');
   ensureGitignore('.workflow/');
   ensureGitignore('node_modules/');
@@ -1213,6 +1201,35 @@ const main = async () => {
   );
   console.log(`  ${green('✓')} .scaffold/.config.json written`);
 
+  // ── Write scope-policy.json ──────────────────────────────────────────────────
+
+  const scopePolicy = {
+    client: {
+      allowed: ['client/**'],
+      blocked: ['backend/**', 'shared/**', 'CONTRACTS.md', 'BUILD_STATE.md', 'TASKS_HISTORY.md'],
+    },
+    backend: {
+      allowed: ['backend/**'],
+      blocked: ['client/**', 'shared/**', 'CONTRACTS.md', 'BUILD_STATE.md', 'TASKS_HISTORY.md'],
+      agentOverrides: {
+        INIT: {
+          allowed: ['backend/**', 'shared/wiring.config.json', 'CONTRACTS.md'],
+        },
+      },
+    },
+    shared: {
+      allowed: ['CLOUD_STATE.md', 'CLOUD.md', 'CLOUD_TEARDOWN.md', '.github/**', 'docker-compose*.yml', 'Dockerfile', '**/.env.example'],
+      blocked: ['client/**', 'backend/**', 'CONTRACTS.md', 'BUILD_STATE.md', 'TASKS_HISTORY.md'],
+    },
+  };
+
+  fs.writeFileSync(
+    path.join(RUNTIME_DIR, 'scope-policy.json'),
+    JSON.stringify(scopePolicy, null, 2),
+    'utf8'
+  );
+  console.log(`  ${green('✓')} .scaffold/scope-policy.json written`);
+
   // ── Generate BUILD_STATE.md ──────────────────────────────────────────────────
 
   const backendDisplay = backendType === 'integrated'