sinapse-ai 1.8.0 → 1.9.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sinapse-ai",
-  "version": "1.8.0",
-  "description": "SINAPSE AI: Framework de orquestracao de IA — 18 squads, 189 agentes especializados",
+  "version": "1.9.1",
+  "description": "SINAPSE AI: Framework de orquestracao de IA — 17 squads, 172 agentes especializados",
   "bin": {
     "sinapse": "bin/sinapse.js",
     "sinapse-ai": "bin/cli.js",
@@ -23,14 +23,17 @@
     ".codex/command-registry.json",
     ".codex/delegation-matrix.json",
     ".codex/handoff-packet.schema.json",
+    ".codex/handoff-packet.parity.schema.json",
+    ".codex/handoff-packet.template.json",
+    ".codex/delegation-parity.json",
     ".codex/instructions.md",
     ".codex/agents/",
     ".codex/scripts/",
     ".codex/skills/",
     ".codex/tasks/",
+    "AGENTS.md",
     "squads/squad-*/**",
     "squads/claude-code-mastery/**",
-    "squads/sinapse/**",
     "sinapse/**",
     "docs/guides/",
     "docs/installation/",
@@ -48,11 +51,15 @@
     "docs/troubleshooting.md",
     "docs/ide-integration.md",
     "docs/agent-reference-guide.md",
-    "docs/codex-integration-process.md",
-    "docs/codex-parity-program.md",
     "docs/TELEMETRY.md",
     "README.md",
-    "LICENSE"
+    "CHANGELOG.md",
+    "LICENSE",
+    "!**/__tests__/**",
+    "!**/tests/**",
+    "!**/*.test.js",
+    "!**/*.spec.js",
+    ".sinapse-ai/development/templates/**"
   ],
   "scripts": {
     "format": "prettier --write \"**/*.md\"",
@@ -85,11 +92,6 @@
     "sync:ide:claude": "node .sinapse-ai/infrastructure/scripts/ide-sync/index.js sync --ide claude-code",
     "sync:ide:codex": "node .sinapse-ai/infrastructure/scripts/sync-codex-local-first.js",
     "validate:claude-sync": "node .sinapse-ai/infrastructure/scripts/ide-sync/index.js validate --ide claude-code --strict",
-    "validate:gemini-sync": "node .sinapse-ai/infrastructure/scripts/ide-sync/index.js validate --ide gemini --strict",
-    "validate:cursor-sync": "node .sinapse-ai/infrastructure/scripts/ide-sync/index.js validate --ide cursor --strict",
-    "validate:antigravity-sync": "node .sinapse-ai/infrastructure/scripts/ide-sync/index.js validate --ide antigravity --strict",
-    "validate:copilot-sync": "node .sinapse-ai/infrastructure/scripts/ide-sync/index.js validate --ide github-copilot --strict",
-    "validate:kimi-sync": "node .sinapse-ai/infrastructure/scripts/ide-sync/index.js validate --ide kimi --strict",
     "validate:claude-integration": "node .sinapse-ai/infrastructure/scripts/validate-claude-integration.js",
     "validate:squad-schema": "node scripts/validate-squad-yaml.js",
     "validate:squad-schema:strict": "node scripts/validate-squad-yaml.js --strict",
@@ -112,6 +114,8 @@
     "validate:no-personal-leaks": "node scripts/validate-no-personal-leaks.js",
     "validate:orqx-discipline": "node scripts/validate-orqx-discipline.js",
     "validate:cross-refs": "node scripts/validate-cross-refs.js",
+    "validate:agents-md": "node scripts/validate-agents-md.js",
+    "validate:agents-md:fix": "node scripts/validate-agents-md.js --fix",
     "validate:all": "node scripts/validate-all.js",
     "sync:squad-yaml": "node scripts/sync-squad-yaml-components.js",
     "validate:squad-yaml": "node scripts/sync-squad-yaml-components.js --check",
@@ -123,7 +127,7 @@
     "brand": "node scripts/sinapse-patch.js",
     "prepublishOnly": "node bin/utils/validate-publish.js && npm run generate:manifest && npm run validate:manifest",
     "setup": "node bin/postinstall.js",
-    "prepare": "husky"
+    "prepare": "node scripts/prepare-hooks.js"
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",

package/packages/installer/src/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * @sinapse/installer entry point.
+ *
+ * Fixes the broken `main` / `bin.sinapse-installer` reference: package.json
+ * pointed here but the file did not exist. This re-exports the real wizard
+ * (src/wizard/index.js) for programmatic use, and runs it when invoked
+ * directly as a CLI (`sinapse-installer`).
+ */
+
+const wizard = require('./wizard');
+
+module.exports = wizard;
+
+// CLI mode: run the wizard when this file is executed directly.
+if (require.main === module) {
+  Promise.resolve()
+    .then(() => wizard.runWizard())
+    .catch((error) => {
+      // eslint-disable-next-line no-console
+      console.error('Installer failed:', error && error.message ? error.message : error);
+      process.exit(1);
+    });
+}

package/packages/installer/src/installer/git-hooks-installer.js

@@ -51,22 +51,22 @@ const { runSafe } = require('../../../../.sinapse-ai/core/utils/spawn-safe');
 const MANAGED_HOOKS_DIRNAME = path.join('.sinapse-ai', 'git-hooks');
 
 /**
- * Source scanner files copied into `<hooksDir>/lib/` so the generated hook can
+ * Source guard files copied into `<hooksDir>/lib/` so the generated hook can
  * `require` them with a stable relative path regardless of where the project
- * lives. `staged-secret-scan.js` is self-contained (only `child_process`).
+ * lives. All are self-contained (Node built-ins only) and bundle together.
  * @constant {Array<{from: string, to: string}>}
  */
+const BIN_UTILS = path.join(__dirname, '..', '..', '..', '..', 'bin', 'utils');
 const SCANNER_SOURCES = [
-  {
-    from: path.join(__dirname, '..', '..', '..', '..', 'bin', 'utils', 'staged-secret-scan.js'),
-    to: 'staged-secret-scan.js',
-  },
+  // --- secret scan (3 guards share this bundle) ---
+  { from: path.join(BIN_UTILS, 'staged-secret-scan.js'), to: 'staged-secret-scan.js' },
   // staged-secret-scan.js requires secret-scanner-core.js via __dirname, so the
-  // core must travel with it into the lib/ bundle. Both files use only Node built-ins.
-  {
-    from: path.join(__dirname, '..', '..', '..', '..', 'bin', 'utils', 'secret-scanner-core.js'),
-    to: 'secret-scanner-core.js',
-  },
+  // core must travel with it into the lib/ bundle.
+  { from: path.join(BIN_UTILS, 'secret-scanner-core.js'), to: 'secret-scanner-core.js' },
+  // --- destructive SQL DDL/DML guard (FASE C) ---
+  { from: path.join(BIN_UTILS, 'staged-sql-guard.js'), to: 'staged-sql-guard.js' },
+  // --- framework boundary guard (FASE C; respects boundary.frameworkProtection) ---
+  { from: path.join(BIN_UTILS, 'framework-guard.js'), to: 'framework-guard.js' },
 ];
 
 /**
@@ -173,17 +173,23 @@ function copyScannerLib(hooksDir) {
 /**
  * Build the content of the managed `pre-commit` Node hook.
  *
- * The hook:
- *   1. Runs the bundled staged-secret-scan against the staged index.
- *   2. Blocks the commit (exit 1) on any finding, printing redacted reasons.
- *   3. Fail-CLOSED: if the scanner cannot be loaded/run, the commit is blocked
- *      (a broken guard must never silently allow secrets through).
- *   4. Chains to a pre-existing `.husky/pre-commit` (or a backed-up prior hook)
- *      so the project's own hooks still run.
+ * The hook runs THREE bundled guards in sequence (each a standalone module
+ * under ./lib that exits non-zero on a finding), then chains to a pre-existing
+ * husky hook:
+ *   1. staged-secret-scan.js  — secret/.env/private-key/entropy leak (fail-CLOSED)
+ *   2. staged-sql-guard.js     — destructive DDL/DML (DROP/TRUNCATE/DELETE-no-WHERE)
+ *   3. framework-guard.js      — L1/L2 boundary (no-op unless boundary
+ *                                .frameworkProtection is true in core-config.yaml)
+ *
+ * Each guard is spawned as a child Node process (cwd = project root, where git
+ * already runs hooks) so it gets the same staged index and reuses its own
+ * exit/print semantics. A non-zero exit from ANY guard blocks the commit. If a
+ * guard process cannot even be spawned, the commit is blocked (fail-CLOSED) —
+ * a guard that silently disappears must never let a commit through unscanned.
  *
  * @param {Object} [options]
  * @param {string|null} [options.chainHookRel] - Relative path (from project
- *   root) of a prior hook to chain to after the scan passes. When null, the
+ *   root) of a prior hook to chain to after the guards pass. When null, the
  *   hook auto-detects `.husky/pre-commit` at runtime.
  * @returns {string} Hook file content.
  */
@@ -201,38 +207,40 @@ const fs = require('fs');
 const { spawnSync } = require('child_process');
 
 const projectRoot = process.cwd();
+const libDir = path.join(__dirname, 'lib');
+
+// --- 1-3. SINAPSE staged guards (each fail-CLOSED) ---------------------------
+// Order: secret scan, then destructive-SQL guard, then framework-boundary guard.
+// framework-guard self-disables when boundary.frameworkProtection is false.
+const GUARDS = [
+  { file: 'staged-secret-scan.js', label: 'Secret Scan' },
+  { file: 'staged-sql-guard.js',   label: 'SQL Guard' },
+  { file: 'framework-guard.js',    label: 'Framework Boundary' },
+];
 
-// --- 1. SINAPSE staged secret scan (fail-CLOSED) ----------------------------
-let scanStagedFiles;
-let getStagedFiles;
-try {
-  // The scanner is bundled next to this hook under ./lib so the require path is
-  // stable no matter where the project lives.
-  ({ scanStagedFiles, getStagedFiles } = require(path.join(__dirname, 'lib', 'staged-secret-scan.js')));
-} catch (loadErr) {
-  process.stderr.write('SINAPSE Secret Scan: scanner could not be loaded — blocking commit (fail-closed).\\n');
-  process.stderr.write('  ' + (loadErr && loadErr.message ? loadErr.message : String(loadErr)) + '\\n');
-  process.exit(1);
-}
-
-try {
-  const files = getStagedFiles();
-  const findings = scanStagedFiles(files);
-  if (findings.length > 0) {
-    process.stderr.write('\\nSINAPSE Secret Scan: commit blocked.\\n\\n');
-    for (const f of findings) {
-      process.stderr.write('  - ' + f.filePath + ': ' + f.reason + '\\n');
-    }
-    process.stderr.write('\\nRemove the sensitive content before committing.\\n\\n');
+for (const guard of GUARDS) {
+  const guardPath = path.join(libDir, guard.file);
+  if (!fs.existsSync(guardPath)) {
+    // A bundled guard vanished — fail-CLOSED rather than skip silently.
+    process.stderr.write('SINAPSE ' + guard.label + ': guard missing at ' + guardPath + ' — blocking commit (fail-closed).\\n');
+    process.exit(1);
+  }
+  const res = spawnSync(process.execPath, [guardPath], { stdio: 'inherit', cwd: projectRoot });
+  if (res.error) {
+    process.stderr.write('SINAPSE ' + guard.label + ': guard failed to run — blocking commit (fail-closed).\\n');
+    process.stderr.write('  ' + res.error.message + '\\n');
     process.exit(1);
   }
-} catch (scanErr) {
-  process.stderr.write('SINAPSE Secret Scan: scan failed — blocking commit (fail-closed).\\n');
-  process.stderr.write('  ' + (scanErr && scanErr.message ? scanErr.message : String(scanErr)) + '\\n');
-  process.exit(1);
+  if (typeof res.status === 'number' && res.status !== 0) {
+    // Non-zero from a guard = commit blocked. A clean guard prints its own
+    // reason; a crashed guard (e.g. corrupted lib) does not, so emit an
+    // explicit fail-closed line so the block is never silent.
+    process.stderr.write('SINAPSE ' + guard.label + ': blocking commit (fail-closed, exit ' + res.status + ').\\n');
+    process.exit(res.status);
+  }
 }
 
-// --- 2. Chain to a pre-existing hook (husky or backed-up prior hook) --------
+// --- 4. Chain to a pre-existing hook (husky or backed-up prior hook) --------
 const explicitChain = ${chainLiteral};
 const candidates = [];
 if (explicitChain) {
@@ -273,6 +281,150 @@ process.exit(0);
 `;
 }
 
+/**
+ * Build the content of the managed `pre-push` Node hook.
+ *
+ * Runs the project's `validate:all` aggregate guard (the same set the prior
+ * husky pre-push ran) before allowing a push. It is best-effort about the exact
+ * script name: it picks the first of `validate:all` / `validate` that exists in
+ * the target's package.json `scripts`, and is a no-op (allow) when neither is
+ * present (so non-SINAPSE consumer repos are not blocked by a missing script).
+ *
+ * Then chains to a pre-existing `.husky/pre-push` so any project-specific push
+ * checks still run.
+ *
+ * @param {Object} [options]
+ * @param {string|null} [options.chainHookRel]
+ * @returns {string} Hook file content.
+ */
+function buildPrePushHook(options = {}) {
+  const chainHookRel = options.chainHookRel || null;
+  const chainLiteral = chainHookRel ? JSON.stringify(chainHookRel) : 'null';
+
+  return `#!/usr/bin/env node
+'use strict';
+/* ${MANAGED_MARKER} — Auto-generated by SINAPSE git-hooks-installer. Do not edit manually. */
+/* Re-run \`sinapse init\` (or the greenfield bootstrap) to regenerate. */
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const projectRoot = process.cwd();
+
+// --- 1. Run validate:all (or validate) if the project defines it -----------
+function pickValidateScript() {
+  try {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (!fs.existsSync(pkgPath)) return null;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const scripts = (pkg && pkg.scripts) || {};
+    for (const name of ['validate:all', 'validate']) {
+      if (typeof scripts[name] === 'string' && scripts[name].length > 0) return name;
+    }
+  } catch {
+    // Unreadable package.json — treat as "no validate script" (allow).
+  }
+  return null;
+}
+
+const script = pickValidateScript();
+if (script) {
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  // shell:true on Windows — spawning npm.cmd without it throws EINVAL (CVE-2024-27980 /
+  // Node DEP0190). Args are fixed/literal here, so there is no shell-injection surface.
+  const res = spawnSync(npmCmd, ['run', '--silent', script], { stdio: 'inherit', cwd: projectRoot, shell: process.platform === 'win32' });
+  if (res.error) {
+    process.stderr.write('SINAPSE pre-push: could not run "npm run ' + script + '" — blocking push (fail-closed).\\n');
+    process.stderr.write('  ' + res.error.message + '\\n');
+    process.stderr.write('  Bypass (emergency only): git push --no-verify\\n');
+    process.exit(1);
+  }
+  if (typeof res.status === 'number' && res.status !== 0) {
+    process.stderr.write('\\nSINAPSE pre-push: validation failed (see output above). Push blocked.\\n');
+    process.stderr.write('  Bypass (emergency only): git push --no-verify\\n\\n');
+    process.exit(res.status);
+  }
+}
+
+// --- 2. Chain to a pre-existing pre-push hook ------------------------------
+const explicitChain = ${chainLiteral};
+const candidates = [];
+if (explicitChain) {
+  candidates.push(path.resolve(projectRoot, explicitChain));
+}
+candidates.push(path.join(projectRoot, '.husky', 'pre-push'));
+
+const selfPath = __filename;
+for (const candidate of candidates) {
+  if (!candidate || !fs.existsSync(candidate)) continue;
+  if (path.resolve(candidate) === path.resolve(selfPath)) continue;
+
+  const isJs = candidate.endsWith('.js') || candidate.endsWith('.cjs');
+  const cmd = isJs ? process.execPath : candidate;
+  const args = isJs ? [candidate] : [];
+  const res = spawnSync(cmd, args, { stdio: 'inherit', cwd: projectRoot });
+  if (res.error) {
+    if (!isJs) {
+      const shRes = spawnSync('sh', [candidate], { stdio: 'inherit', cwd: projectRoot });
+      if (!shRes.error) {
+        if (typeof shRes.status === 'number' && shRes.status !== 0) process.exit(shRes.status);
+        break;
+      }
+    }
+    process.stderr.write('SINAPSE pre-push: failed to run chained hook ' + candidate + ': ' + res.error.message + '\\n');
+    process.exit(1);
+  }
+  if (typeof res.status === 'number' && res.status !== 0) process.exit(res.status);
+  break;
+}
+
+process.exit(0);
+`;
+}
+
+/**
+ * Build the content of the managed `post-commit` Node hook.
+ *
+ * Preserves the prior husky post-commit behavior (cache-clear + IDS registry
+ * update) by delegating to the project's existing scripts when present. Both
+ * sub-scripts are non-blocking by design (any failure is swallowed) so a
+ * post-commit problem never breaks the commit that already happened.
+ *
+ * @returns {string} Hook file content.
+ */
+function buildPostCommitHook() {
+  return `#!/usr/bin/env node
+'use strict';
+/* ${MANAGED_MARKER} — Auto-generated by SINAPSE git-hooks-installer. Do not edit manually. */
+/* Re-run \`sinapse init\` (or the greenfield bootstrap) to regenerate. */
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const projectRoot = process.cwd();
+
+// Migrated from .husky/post-commit (non-blocking, best-effort).
+const POST_COMMIT_SCRIPTS = [
+  path.join('.sinapse-ai', 'infrastructure', 'scripts', 'git-hooks', 'post-commit.js'),
+  path.join('.sinapse-ai', 'hooks', 'ids-post-commit.js'),
+];
+
+for (const rel of POST_COMMIT_SCRIPTS) {
+  const abs = path.join(projectRoot, rel);
+  if (!fs.existsSync(abs)) continue;
+  try {
+    spawnSync(process.execPath, [abs], { stdio: 'ignore', cwd: projectRoot });
+  } catch {
+    // Never block on post-commit failures.
+  }
+}
+
+process.exit(0);
+`;
+}
+
 /**
  * Install the SINAPSE git guard into a project.
  *
@@ -345,10 +497,20 @@ async function installGitHooks(options = {}) {
       }
     }
 
-    // Bundle the scanner lib and write the managed pre-commit hook.
+    // Bundle the guard lib and write the managed hooks (pre-commit, pre-push,
+    // post-commit). All three live under core.hooksPath so there is a single
+    // active hook system (no husky/hooksPath split).
     copyScannerLib(hooksDir);
     writeManagedHook(hooksDir, 'pre-commit', buildPreCommitHook({ chainHookRel: explicitChain }));
 
+    // pre-push: run validate:all, then chain to any prior .husky/pre-push.
+    const huskyPrePush = path.join(projectDir, '.husky', 'pre-push');
+    const prePushChain = fs.existsSync(huskyPrePush) ? path.join('.husky', 'pre-push') : null;
+    writeManagedHook(hooksDir, 'pre-push', buildPrePushHook({ chainHookRel: prePushChain }));
+
+    // post-commit: migrated cache-clear + IDS registry update (non-blocking).
+    writeManagedHook(hooksDir, 'post-commit', buildPostCommitHook());
+
     // Point core.hooksPath at our managed dir (project-relative for portability).
     const relHooksDir = MANAGED_HOOKS_DIRNAME.split(path.sep).join('/');
     const set = await setCoreHooksPath(projectDir, relHooksDir);
@@ -379,6 +541,8 @@ module.exports = {
   writeManagedHook,
   copyScannerLib,
   buildPreCommitHook,
+  buildPrePushHook,
+  buildPostCommitHook,
   MANAGED_HOOKS_DIRNAME,
   MANAGED_MARKER,
 };

package/packages/installer/src/installer/sinapse-ai-installer.js

@@ -209,6 +209,35 @@ async function copyDirectoryWithRootReplacement(sourceDir, destDir, onProgress =
   return copiedFiles;
 }
 
+/**
+ * Codex CLI context files that live at the package ROOT (not under .codex/ or
+ * .sinapse-ai/), so the directory-copy loops never reach them. AGENTS.md is the
+ * file Codex reads by default — it carries the Imperator greeting and the full
+ * agent roster. Delivered only when the user selects Codex.
+ * @constant {string[]}
+ */
+const CODEX_ROOT_FILES = ['AGENTS.md'];
+
+/**
+ * Deliver the Codex root context files (AGENTS.md) into the target project.
+ * Idempotent: re-running overwrites the destination so it stays aligned with the
+ * shipped roster. Missing source files are skipped silently (never throws).
+ *
+ * @param {string} pkgRoot - Package root (where AGENTS.md ships)
+ * @param {string} targetDir - Destination project root
+ * @returns {Promise<string[]>} Relative paths actually delivered
+ */
+async function deliverCodexRootFiles(pkgRoot, targetDir) {
+  const delivered = [];
+  for (const name of CODEX_ROOT_FILES) {
+    const src = path.join(pkgRoot, name);
+    if (!await fs.pathExists(src)) continue;
+    const ok = await copyFileWithRootReplacement(src, path.join(targetDir, name));
+    if (ok) delivered.push(name);
+  }
+  return delivered;
+}
+
 /**
  * Install .sinapse-ai content to target directory
  *
@@ -225,6 +254,7 @@ async function installSinapseCore(options = {}) {
   const {
     targetDir = process.cwd(),
     onProgress = null,
+    includeCodex = false,
   } = options;
 
   const result = {
@@ -283,6 +313,45 @@ async function installSinapseCore(options = {}) {
       }
     }
 
+    // Top-level payload dirs that live OUTSIDE .sinapse-ai (siblings at the
+    // package root), so the FOLDERS_TO_COPY loop above never reaches them:
+    //  - squads/ : the 17 domain squads (160 specialists + orchestrators).
+    //              Needed by BOTH IDEs — Claude syncs the squad orchestrators
+    //              into .claude/commands, and Codex resolves the full 172-agent
+    //              roster from here. Without it a project has only the 12 core
+    //              agents, contradicting the shipped AGENTS.md.
+    //  - .codex/ : Codex CLI payload (resolvers, tasks, JSON registries). Only
+    //              when the user selected Codex; agents + skills are then
+    //              regenerated from squads/ + core by sync-codex-local-first.js.
+    const pkgRoot = path.dirname(sourceDir);
+    const topLevelDirs = ['squads'];
+    if (includeCodex) topLevelDirs.push('.codex');
+    for (const dirName of topLevelDirs) {
+      const src = path.join(pkgRoot, dirName);
+      const dest = path.join(targetDir, dirName);
+      if (await fs.pathExists(src)) {
+        spinner.text = `Copying ${dirName}...`;
+        const copied = await copyDirectoryWithRootReplacement(src, dest, onProgress);
+        result.installedFiles.push(...copied.map((f) => path.join(dirName, f)));
+        if (dirName === '.codex') result.codexInstalledFiles = copied.length;
+        if (dirName === 'squads') result.squadsInstalledFiles = copied.length;
+      }
+    }
+
+    // AGENTS.md is the Codex CLI's default context file (Imperator greeting +
+    // the full agent roster). It lives at the package ROOT (not under .codex/ or
+    // .sinapse-ai/), so neither loop above reaches it. Without it, a Codex user's
+    // project has the .codex pointers/resolvers but no greeting and no roster —
+    // the parity built in the repo never reaches the user.
+    if (includeCodex) {
+      spinner.text = 'Copying AGENTS.md...';
+      const delivered = await deliverCodexRootFiles(pkgRoot, targetDir);
+      if (delivered.includes('AGENTS.md')) {
+        result.installedFiles.push('AGENTS.md');
+        result.agentsMdInstalled = true;
+      }
+    }
+
     // Create install manifest
     spinner.text = 'Creating installation manifest...';
     const packageVersion = require('../../../../package.json').version;
@@ -428,6 +497,8 @@ module.exports = {
   copyDirectoryWithRootReplacement,
   generateVersionJson,
   generateFileHashes,
+  deliverCodexRootFiles,
   FOLDERS_TO_COPY,
   ROOT_FILES_TO_COPY,
+  CODEX_ROOT_FILES,
 };

package/packages/installer/src/wizard/feedback.js

@@ -139,7 +139,7 @@ function showWelcome() {
   console.log(`  ${t('welcomeMessage')}`);
   console.log(`  ${t('welcomeSubtitle')}`);
   console.log('');
-  console.log('  18 squads · 189 agents · 1,213 tasks');
+  console.log('  17 squads · 172 agents · 1,200 tasks');
   console.log(`  ${t('welcomeDesc1')}`);
   console.log(`  ${t('welcomeDesc2')}`);
   console.log('');

package/packages/installer/src/wizard/ide-config-generator.js

@@ -201,34 +201,13 @@ async function copyAgentFiles(projectRoot, agentFolder, ideConfig = null) {
 
   for (const file of agentFiles) {
     const sourcePath = path.join(sourceDir, file);
-    const agentName = file.replace('.md', '');
-
     // Only copy if source is a file (not directory)
     const stat = await fs.stat(sourcePath);
     if (stat.isFile()) {
-      if (ideConfig && ideConfig.agentFolder && ideConfig.agentFolder.includes('.github')) {
-        // GitHub Copilot: apply transformer for .agent.md format with YAML frontmatter
-        try {
-          const agentParser = require('../../../../.sinapse-ai/infrastructure/scripts/ide-sync/agent-parser');
-          const copilotTransformer = require('../../../../.sinapse-ai/infrastructure/scripts/ide-sync/transformers/github-copilot');
-          const agentData = agentParser.parseAgentFile(sourcePath);
-          const content = copilotTransformer.transform(agentData);
-          const filename = copilotTransformer.getFilename(agentData);
-          const targetPath = path.join(targetDir, filename);
-          await fs.writeFile(targetPath, content, 'utf8');
-          copiedFiles.push(targetPath);
-        } catch (transformError) {
-          // Fallback: copy raw file with .agent.md extension
-          const targetPath = path.join(targetDir, `${agentName}.agent.md`);
-          await fs.copy(sourcePath, targetPath);
-          copiedFiles.push(targetPath);
-        }
-      } else {
-        // Normal copy for other IDEs
-        const targetPath = path.join(targetDir, file);
-        await fs.copy(sourcePath, targetPath);
-        copiedFiles.push(targetPath);
-      }
+      // Copy agent file (Claude Code + Codex only — secondary IDE adapters removed)
+      const targetPath = path.join(targetDir, file);
+      await fs.copy(sourcePath, targetPath);
+      copiedFiles.push(targetPath);
     }
   }
 
@@ -658,6 +637,19 @@ const HOOK_EVENT_MAP = {
     matcher: null,
     timeout: 5,
   },
+  // Statusline agent/squad tracker (Cluster D — feedback visual).
+  // Detector writes the per-cwd session-cache the statusline reads;
+  // clear wipes it when the session ends. FAIL-OPEN: both exit 0 on error.
+  'track-agent.cjs': {
+    event: 'UserPromptSubmit',
+    matcher: null,
+    timeout: 10,
+  },
+  'track-agent-clear.cjs': {
+    event: 'Stop',
+    matcher: null,
+    timeout: 10,
+  },
 };
 
 /** Default event config for unmapped hooks (backwards compatible). */
@@ -937,7 +929,12 @@ async function linkGeminiExtension(projectRoot) {
     return { status: 'skipped', reason: 'manifest-not-found' };
   }
 
-  const versionCheck = spawnSync('gemini', ['--version'], { encoding: 'utf8' });
+  // On Windows, `gemini` is a .cmd/.ps1 shim — spawnSync without a shell throws
+  // EINVAL. Run through the shell on win32 so the shim resolves.
+  const versionCheck = spawnSync('gemini', ['--version'], {
+    encoding: 'utf8',
+    shell: process.platform === 'win32',
+  });
   if (versionCheck.status !== 0) {
     return { status: 'skipped', reason: 'gemini-cli-not-available' };
   }
@@ -946,6 +943,7 @@ async function linkGeminiExtension(projectRoot) {
     cwd: projectRoot,
     encoding: 'utf8',
     timeout: 30000,
+    shell: process.platform === 'win32',
   });
 
   if (linkResult.status === 0) {
@@ -960,6 +958,7 @@ async function linkGeminiExtension(projectRoot) {
       cwd: projectRoot,
       encoding: 'utf8',
       timeout: 30000,
+      shell: process.platform === 'win32',
     });
 
     if (uninstall.status !== 0) {
@@ -970,6 +969,7 @@ async function linkGeminiExtension(projectRoot) {
       cwd: projectRoot,
       encoding: 'utf8',
       timeout: 30000,
+      shell: process.platform === 'win32',
     });
 
     if (linkResult.status === 0) {