@a-company/paradigm 5.8.1 → 5.9.0

package/dist/{nomination-engine-LPLCCDW2.js → nomination-engine-LLREC5BZ.js}

@@ -17,8 +17,8 @@ import {
   processEvent,
   processPendingEvents,
   resolveDebate
-} from "./chunk-B2RC3HEB.js";
-import "./chunk-ITPJJIHG.js";
+} from "./chunk-V7BZBBI6.js";
+import "./chunk-MA7G4CTI.js";
 import "./chunk-MCMOGQMU.js";
 import "./chunk-7N7GSU6K.js";
 init_nomination_engine();

package/dist/{reindex-KFUPB3ES.js → reindex-U2HEB6GW.js}

@@ -3,7 +3,7 @@ import {
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles
-} from "./chunk-T3YGSZCI.js";
+} from "./chunk-3UCH56D5.js";
 import "./chunk-L27I3CPZ.js";
 import "./chunk-SDDCVUCV.js";
 import "./chunk-5VKJBNJL.js";

package/dist/{shift-2NYRFVEZ.js → shift-VJUGMADR.js}

@@ -46,16 +46,191 @@ import "./chunk-YMDLDELF.js";
 import "./chunk-PDX44BCA.js";
 
 // src/commands/shift.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 import chalk from "chalk";
 import ora from "ora";
 import * as yaml from "js-yaml";
+
+// src/core/project-type.ts
+import * as fs from "fs";
+import * as path from "path";
+import { Glob } from "glob";
+function detectProjectType(cwd) {
+  const exists = (p) => {
+    if (p.includes("*")) {
+      try {
+        const matches = new Glob(p, { cwd, nodir: true }).walkSync();
+        return matches.length > 0;
+      } catch {
+        return false;
+      }
+    }
+    return fs.existsSync(path.join(cwd, p));
+  };
+  if (exists("project.godot") || exists("Assets/ProjectSettings")) return "game";
+  if (exists("Package.swift") && !exists("package.json")) {
+    return exists("Sources/*/App") || exists("**/AppDelegate.swift") ? "macos-app" : "ios-app";
+  }
+  if (exists("pubspec.yaml")) return "flutter-app";
+  if (exists("supabase") && (exists("next.config.*") || exists("vite.config.*"))) return "saas-web-app";
+  if (exists("next.config.*") || exists("vite.config.*") || exists("nuxt.config.*")) return "web-app";
+  if (exists("Dockerfile") || exists("prisma") || exists("drizzle.config.*")) return "backend-api";
+  if (exists("Cargo.toml")) return "rust-project";
+  if (exists("pyproject.toml") || exists("setup.py") || exists("requirements.txt")) return "python-project";
+  return "generic";
+}
+var ROSTER_SUGGESTIONS = {
+  "saas-web-app": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "security",
+    "documentor",
+    "designer",
+    "copywriter",
+    "performance",
+    "devops",
+    "dba",
+    "e2e",
+    "dx",
+    "seo",
+    "pm",
+    "product",
+    "sales",
+    "legal",
+    "a11y",
+    "qa",
+    "advocate",
+    "debugger",
+    "release",
+    "narrator"
+  ],
+  "web-app": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "security",
+    "documentor",
+    "designer",
+    "copywriter",
+    "performance",
+    "devops",
+    "e2e",
+    "seo",
+    "a11y",
+    "qa",
+    "debugger"
+  ],
+  "backend-api": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "security",
+    "documentor",
+    "devops",
+    "dba",
+    "performance",
+    "dx",
+    "qa",
+    "debugger",
+    "release"
+  ],
+  "ios-app": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "security",
+    "documentor",
+    "designer",
+    "mobile",
+    "performance",
+    "a11y",
+    "qa",
+    "debugger"
+  ],
+  "macos-app": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "security",
+    "documentor",
+    "designer",
+    "performance",
+    "qa",
+    "debugger"
+  ],
+  "flutter-app": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "security",
+    "documentor",
+    "designer",
+    "mobile",
+    "performance",
+    "a11y",
+    "debugger"
+  ],
+  "game": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "documentor",
+    "gamedev",
+    "3d",
+    "audio",
+    "designer",
+    "performance",
+    "debugger"
+  ],
+  "rust-project": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "security",
+    "documentor",
+    "performance",
+    "debugger",
+    "qa"
+  ],
+  "python-project": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "security",
+    "documentor",
+    "performance",
+    "debugger",
+    "qa"
+  ],
+  "generic": [
+    "architect",
+    "builder",
+    "reviewer",
+    "tester",
+    "security",
+    "documentor",
+    "debugger",
+    "qa"
+  ]
+};
+
+// src/commands/shift.ts
 async function shiftCommand(options = {}) {
   const cwd = process.cwd();
-  const projectName = path.basename(cwd);
-  const paradigmDir = path.join(cwd, ".paradigm");
-  const isInitialized = fs.existsSync(paradigmDir) && fs.statSync(paradigmDir).isDirectory();
+  const projectName = path2.basename(cwd);
+  const paradigmDir = path2.join(cwd, ".paradigm");
+  const isInitialized = fs2.existsSync(paradigmDir) && fs2.statSync(paradigmDir).isDirectory();
   console.log(chalk.blue("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
   console.log(chalk.blue("\u2502") + chalk.white.bold("  paradigm shift                                 ") + chalk.blue("\u2502"));
   console.log(chalk.blue("\u2502") + chalk.gray("  Full project setup in one command              ") + chalk.blue("\u2502"));
@@ -83,10 +258,10 @@ async function shiftCommand(options = {}) {
     }
   } else {
     spinner.succeed(chalk.gray("Step 1/6: Already initialized (use --force to reinit)"));
-    const configPath = path.join(paradigmDir, "config.yaml");
-    if (fs.existsSync(configPath)) {
+    const configPath = path2.join(paradigmDir, "config.yaml");
+    if (fs2.existsSync(configPath)) {
       try {
-        const configContent = fs.readFileSync(configPath, "utf8");
+        const configContent = fs2.readFileSync(configPath, "utf8");
         const config = yaml.load(configContent);
         if (!config.discipline || config.discipline === "auto") {
           const detected = detectDiscipline(cwd);
@@ -96,7 +271,7 @@ async function shiftCommand(options = {}) {
               `discipline: ${detected}`
             );
             if (updated !== configContent) {
-              fs.writeFileSync(configPath, updated, "utf8");
+              fs2.writeFileSync(configPath, updated, "utf8");
               console.log(chalk.green(`  \u2713 Detected discipline: ${chalk.cyan(detected)} (updated config.yaml)`));
             }
           } else if (!config.discipline) {
@@ -106,7 +281,7 @@ async function shiftCommand(options = {}) {
 discipline: ${detected}`
             );
             if (withDiscipline !== configContent) {
-              fs.writeFileSync(configPath, withDiscipline, "utf8");
+              fs2.writeFileSync(configPath, withDiscipline, "utf8");
               console.log(chalk.green(`  \u2713 Added discipline: ${chalk.cyan(detected)} to config.yaml`));
             }
           }
@@ -127,17 +302,17 @@ discipline: ${detected}`
     }
   }
   {
-    const configPath = path.join(paradigmDir, "config.yaml");
-    if (options.workspace && fs.existsSync(configPath)) {
-      const wsFilePath = options.workspacePath ? path.resolve(cwd, options.workspacePath) : path.join(path.dirname(cwd), ".paradigm-workspace");
-      if (fs.existsSync(wsFilePath)) {
+    const configPath = path2.join(paradigmDir, "config.yaml");
+    if (options.workspace && fs2.existsSync(configPath)) {
+      const wsFilePath = options.workspacePath ? path2.resolve(cwd, options.workspacePath) : path2.join(path2.dirname(cwd), ".paradigm-workspace");
+      if (fs2.existsSync(wsFilePath)) {
         try {
-          const wsConfig = yaml.load(fs.readFileSync(wsFilePath, "utf8"));
-          const currentName = path.basename(cwd);
-          const wsDir = path.dirname(wsFilePath);
-          const relPath = "./" + path.relative(wsDir, cwd);
+          const wsConfig = yaml.load(fs2.readFileSync(wsFilePath, "utf8"));
+          const currentName = path2.basename(cwd);
+          const wsDir = path2.dirname(wsFilePath);
+          const relPath = "./" + path2.relative(wsDir, cwd);
           const alreadyMember = wsConfig.members.some(
-            (m) => path.resolve(wsDir, m.path) === cwd
+            (m) => path2.resolve(wsDir, m.path) === cwd
           );
           if (!alreadyMember) {
             const role = detectProjectRole(currentName, cwd);
@@ -146,7 +321,7 @@ discipline: ${detected}`
               path: relPath,
               ...role && { role }
             });
-            fs.writeFileSync(
+            fs2.writeFileSync(
               wsFilePath,
               yaml.dump(wsConfig, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false, quotingType: '"' }),
               "utf8"
@@ -160,66 +335,66 @@ discipline: ${detected}`
         }
       } else {
         try {
-          const currentName = path.basename(cwd);
-          const wsDir = path.dirname(wsFilePath);
-          const relPath = "./" + path.relative(wsDir, cwd);
+          const currentName = path2.basename(cwd);
+          const wsDir = path2.dirname(wsFilePath);
+          const relPath = "./" + path2.relative(wsDir, cwd);
           const role = detectProjectRole(currentName, cwd);
           const wsConfig = {
             version: "1.0",
             name: options.workspace,
             members: [{ name: currentName, path: relPath, ...role && { role } }]
           };
-          fs.mkdirSync(path.dirname(wsFilePath), { recursive: true });
-          fs.writeFileSync(
+          fs2.mkdirSync(path2.dirname(wsFilePath), { recursive: true });
+          fs2.writeFileSync(
             wsFilePath,
             yaml.dump(wsConfig, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false, quotingType: '"' }),
             "utf8"
           );
-          console.log(chalk.green(`  \u2713 Created workspace: ${chalk.cyan(options.workspace)} at ${chalk.gray(path.relative(cwd, wsFilePath))}`));
+          console.log(chalk.green(`  \u2713 Created workspace: ${chalk.cyan(options.workspace)} at ${chalk.gray(path2.relative(cwd, wsFilePath))}`));
         } catch (e) {
           console.log(chalk.yellow(`  \u26A0 Failed to create workspace: ${e.message}`));
         }
       }
       try {
-        const configContent = fs.readFileSync(configPath, "utf8");
+        const configContent = fs2.readFileSync(configPath, "utf8");
         const config = yaml.load(configContent);
-        const relWsPath = path.relative(cwd, wsFilePath);
+        const relWsPath = path2.relative(cwd, wsFilePath);
         if (config.workspace !== relWsPath) {
           if (config.workspace) {
             const updated = configContent.replace(
               /^workspace:\s*.*$/m,
               `workspace: "${relWsPath}"`
             );
-            fs.writeFileSync(configPath, updated, "utf8");
+            fs2.writeFileSync(configPath, updated, "utf8");
           } else {
             const updated = configContent.trimEnd() + `
 workspace: "${relWsPath}"
 `;
-            fs.writeFileSync(configPath, updated, "utf8");
+            fs2.writeFileSync(configPath, updated, "utf8");
           }
           console.log(chalk.green(`  \u2713 Linked workspace in config.yaml`));
         }
       } catch (e) {
         log.operation("shift").debug("Workspace config link failed", { error: e.message });
       }
-    } else if (fs.existsSync(configPath)) {
+    } else if (fs2.existsSync(configPath)) {
       try {
-        const configContent = fs.readFileSync(configPath, "utf8");
+        const configContent = fs2.readFileSync(configPath, "utf8");
         const config = yaml.load(configContent);
         if (!config.workspace) {
-          let searchDir = path.dirname(cwd);
+          let searchDir = path2.dirname(cwd);
           for (let i = 0; i < 3; i++) {
-            const wsCandidate = path.join(searchDir, ".paradigm-workspace");
-            if (fs.existsSync(wsCandidate)) {
-              const relPath = path.relative(cwd, wsCandidate);
+            const wsCandidate = path2.join(searchDir, ".paradigm-workspace");
+            if (fs2.existsSync(wsCandidate)) {
+              const relPath = path2.relative(cwd, wsCandidate);
               const updated = configContent.trimEnd() + `
 workspace: "${relPath}"
 `;
-              fs.writeFileSync(configPath, updated, "utf8");
+              fs2.writeFileSync(configPath, updated, "utf8");
               console.log(chalk.green(`  \u2713 Found workspace: ${chalk.cyan(relPath)} (added to config.yaml)`));
               break;
             }
-            const parent = path.dirname(searchDir);
+            const parent = path2.dirname(searchDir);
             if (parent === searchDir) break;
             searchDir = parent;
           }
@@ -247,6 +422,26 @@ workspace: "${relPath}"
   } else {
     spinner.succeed(chalk.gray("Step 2/6: Team already configured (use --force to reinit)"));
   }
+  const rosterPath = path2.join(cwd, ".paradigm", "roster.yaml");
+  if (!fs2.existsSync(rosterPath) || options.force) {
+    try {
+      const projectType = detectProjectType(cwd);
+      const suggested = ROSTER_SUGGESTIONS[projectType] || ROSTER_SUGGESTIONS["generic"];
+      const rosterData = { version: "1.0", project: projectName, type: projectType, active: suggested.sort() };
+      fs2.writeFileSync(rosterPath, yaml.dump(rosterData, { lineWidth: -1, noRefs: true }), "utf8");
+      console.log(chalk.green(`  \u2713 Agent roster set: ${chalk.cyan(suggested.length)} agents for ${chalk.cyan(projectType)}`));
+    } catch (e) {
+      log.operation("shift").debug("Roster setup failed", { error: e.message });
+    }
+  } else {
+    try {
+      const existing = yaml.load(fs2.readFileSync(rosterPath, "utf8"));
+      const count = existing?.active?.length ?? 0;
+      console.log(chalk.gray(`  \u2713 Agent roster exists (${count} agents active)`));
+    } catch {
+      console.log(chalk.gray("  \u2713 Agent roster exists"));
+    }
+  }
   if (!options.quick) {
     spinner.start("Step 3/6: Scanning and indexing symbols...");
     try {
@@ -259,10 +454,10 @@ workspace: "${relPath}"
     spinner.succeed(chalk.gray("Step 3/6: Skipped scan (--quick mode)"));
   }
   {
-    const configPath = path.join(paradigmDir, "config.yaml");
-    if (fs.existsSync(configPath)) {
+    const configPath = path2.join(paradigmDir, "config.yaml");
+    if (fs2.existsSync(configPath)) {
       try {
-        const configForWs = yaml.load(fs.readFileSync(configPath, "utf8"));
+        const configForWs = yaml.load(fs2.readFileSync(configPath, "utf8"));
         if (configForWs.workspace) {
           spinner.start("Step 3b/6: Reindexing workspace members...");
           try {
@@ -278,29 +473,29 @@ workspace: "${relPath}"
       }
     }
   }
-  const portalPath = path.join(cwd, "portal.yaml");
-  if (!fs.existsSync(portalPath)) {
+  const portalPath = path2.join(cwd, "portal.yaml");
+  if (!fs2.existsSync(portalPath)) {
     const defaultPortal = { version: "1.0.0", gates: {}, routes: {} };
-    fs.writeFileSync(portalPath, yaml.dump(defaultPortal, { lineWidth: -1, noRefs: true }), "utf8");
+    fs2.writeFileSync(portalPath, yaml.dump(defaultPortal, { lineWidth: -1, noRefs: true }), "utf8");
   }
-  const lorePath = path.join(cwd, ".paradigm", "lore");
-  if (!fs.existsSync(lorePath)) {
-    fs.mkdirSync(lorePath, { recursive: true });
+  const lorePath = path2.join(cwd, ".paradigm", "lore");
+  if (!fs2.existsSync(lorePath)) {
+    fs2.mkdirSync(lorePath, { recursive: true });
   }
-  const uniBase = path.join(cwd, ".paradigm", "university");
+  const uniBase = path2.join(cwd, ".paradigm", "university");
   for (const subdir of ["content/notes", "content/policies", "content/quizzes", "content/paths", "diplomas"]) {
-    const dirPath = path.join(uniBase, subdir);
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
+    const dirPath = path2.join(uniBase, subdir);
+    if (!fs2.existsSync(dirPath)) {
+      fs2.mkdirSync(dirPath, { recursive: true });
     }
   }
-  const uniConfigPath = path.join(uniBase, "config.yaml");
-  if (!fs.existsSync(uniConfigPath)) {
+  const uniConfigPath = path2.join(uniBase, "config.yaml");
+  if (!fs2.existsSync(uniConfigPath)) {
     let projectName2 = "Project";
     try {
-      const configPath = path.join(cwd, ".paradigm", "config.yaml");
-      if (fs.existsSync(configPath)) {
-        const configData = yaml.load(fs.readFileSync(configPath, "utf8"));
+      const configPath = path2.join(cwd, ".paradigm", "config.yaml");
+      if (fs2.existsSync(configPath)) {
+        const configData = yaml.load(fs2.readFileSync(configPath, "utf8"));
         if (configData.project && typeof configData.project === "string") {
           projectName2 = configData.project;
         }
@@ -334,7 +529,7 @@ workspace: "${relPath}"
         includeGlobalPLSAT: true
       }
     };
-    fs.writeFileSync(uniConfigPath, yaml.dump(uniConfig, { lineWidth: -1, noRefs: true }), "utf8");
+    fs2.writeFileSync(uniConfigPath, yaml.dump(uniConfig, { lineWidth: -1, noRefs: true }), "utf8");
   }
   spinner.start("Step 4/6: Syncing IDE configurations...");
   try {
@@ -391,19 +586,20 @@ workspace: "${relPath}"
     { path: ".purpose", desc: "Root feature definitions" },
     { path: ".paradigm/lore/", desc: "Project lore timeline", isDir: true },
     { path: "portal.yaml", desc: "Authorization gates" },
+    { path: ".paradigm/roster.yaml", desc: "Agent roster for this project" },
     { path: "CLAUDE.md", desc: "Claude Code AI instructions" },
     { path: "AGENTS.md", desc: "Universal AI agent instructions" },
     { path: ".cursor/rules/", desc: "Cursor AI instructions", isDir: true },
     { path: ".claude/hooks/", desc: "Claude Code enforcement hooks", isDir: true, optional: true },
     { path: ".cursor/hooks/", desc: "Cursor enforcement hooks", isDir: true, optional: true }
   ];
-  const configPathForSummary = path.join(paradigmDir, "config.yaml");
-  if (fs.existsSync(configPathForSummary)) {
+  const configPathForSummary = path2.join(paradigmDir, "config.yaml");
+  if (fs2.existsSync(configPathForSummary)) {
     try {
-      const cfg = yaml.load(fs.readFileSync(configPathForSummary, "utf8"));
+      const cfg = yaml.load(fs2.readFileSync(configPathForSummary, "utf8"));
       if (typeof cfg.workspace === "string") {
-        const wsAbsPath = path.resolve(cwd, cfg.workspace);
-        const wsRelPath = path.relative(cwd, wsAbsPath);
+        const wsAbsPath = path2.resolve(cwd, cfg.workspace);
+        const wsRelPath = path2.relative(cwd, wsAbsPath);
         files.push({ path: wsRelPath, desc: "Multi-project workspace", optional: true });
       }
     } catch (e) {
@@ -411,8 +607,8 @@ workspace: "${relPath}"
     }
   }
   for (const file of files) {
-    const fullPath = path.join(cwd, file.path);
-    if (fs.existsSync(fullPath)) {
+    const fullPath = path2.join(cwd, file.path);
+    if (fs2.existsSync(fullPath)) {
       console.log(chalk.green("  \u2713 ") + chalk.white(file.path.padEnd(28)) + chalk.gray(file.desc));
     } else if (!file.optional) {
       console.log(chalk.yellow("  \u25CB ") + chalk.gray(file.path.padEnd(28)) + chalk.gray(`(${file.desc})`));

package/dist/symphony-loader-UZGON56V.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import {
+  SCORE_DIR,
+  acknowledgeMessages,
+  appendJsonlLine,
+  appendToInbox,
+  appendToOutbox,
+  approveFileRequest,
+  buildMessage,
+  cleanStaleAgents,
+  createFileRequest,
+  createThread,
+  denyFileRequest,
+  discoverClaudeCodeSessions,
+  ensureMailDirs,
+  ensureScoreDirs,
+  expireOldRequests,
+  garbageCollect,
+  getAgentDir,
+  getMyIdentity,
+  getThreadMessages,
+  isAgentAsleep,
+  isPathAutoApproved,
+  isPathDenied,
+  listAgents,
+  listFileRequests,
+  listThreads,
+  loadFileRequest,
+  loadThread,
+  loadTrustConfig,
+  markAgentPollTime,
+  peekInbox,
+  readAck,
+  readInbox,
+  readJsonlFile,
+  readOutbox,
+  recordAckSize,
+  registerAgent,
+  resolveAgentIdentity,
+  resolveThread,
+  routeMessage,
+  unregisterAgent,
+  updateAgentStatus,
+  updateThread
+} from "./chunk-NQKQG45G.js";
+import "./chunk-7N7GSU6K.js";
+export {
+  SCORE_DIR,
+  acknowledgeMessages,
+  appendJsonlLine,
+  appendToInbox,
+  appendToOutbox,
+  approveFileRequest,
+  buildMessage,
+  cleanStaleAgents,
+  createFileRequest,
+  createThread,
+  denyFileRequest,
+  discoverClaudeCodeSessions,
+  ensureMailDirs,
+  ensureScoreDirs,
+  expireOldRequests,
+  garbageCollect,
+  getAgentDir,
+  getMyIdentity,
+  getThreadMessages,
+  isAgentAsleep,
+  isPathAutoApproved,
+  isPathDenied,
+  listAgents,
+  listFileRequests,
+  listThreads,
+  loadFileRequest,
+  loadThread,
+  loadTrustConfig,
+  markAgentPollTime,
+  peekInbox,
+  readAck,
+  readInbox,
+  readJsonlFile,
+  readOutbox,
+  recordAckSize,
+  registerAgent,
+  resolveAgentIdentity,
+  resolveThread,
+  routeMessage,
+  unregisterAgent,
+  updateAgentStatus,
+  updateThread
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-company/paradigm",
-  "version": "5.8.1",
+  "version": "5.9.0",
   "description": "Unified CLI for Paradigm developer tools",
   "type": "module",
   "main": "./dist/index.js",