@a-company/paradigm 5.8.0 → 5.8.2

package/dist/{agent-loader-DBF4OARL.js → agent-loader-X7TDYLFL.js}

@@ -6,16 +6,20 @@ import {
   computeIntegrityHash,
   createAgentProfile,
   init_agent_loader,
+  isAgentActive,
+  listAllGlobalAgentIds,
   loadAgentProfile,
   loadAllAgentProfiles,
+  loadProjectRoster,
   mergeAgentProfileWithManifest,
   queryExpertise,
   saveAgentProfile,
+  saveProjectRoster,
   syncExpertiseFromLore,
   updateExpertiseFromAssessment,
   updateExpertiseFromLore,
   verifyIntegrity
-} from "./chunk-ITPJJIHG.js";
+} from "./chunk-MA7G4CTI.js";
 import "./chunk-7N7GSU6K.js";
 init_agent_loader();
 export {
@@ -24,11 +28,15 @@ export {
   checkToolPermission,
   computeIntegrityHash,
   createAgentProfile,
+  isAgentActive,
+  listAllGlobalAgentIds,
   loadAgentProfile,
   loadAllAgentProfiles,
+  loadProjectRoster,
   mergeAgentProfileWithManifest,
   queryExpertise,
   saveAgentProfile,
+  saveProjectRoster,
   syncExpertiseFromLore,
   updateExpertiseFromAssessment,
   updateExpertiseFromLore,

package/dist/{chunk-SU3WDCRR.js → chunk-3UCH56D5.js}

@@ -2277,6 +2277,18 @@ var SessionTracker = class {
     if (checkpoint && Date.now() - checkpoint.timestamp > CHECKPOINT_MAX_AGE_MS) {
       return null;
     }
+    if (checkpoint) {
+      for (const key of ["modifiedFiles", "symbolsTouched", "decisions"]) {
+        const val = checkpoint[key];
+        if (typeof val === "string") {
+          try {
+            checkpoint[key] = JSON.parse(val);
+          } catch {
+            checkpoint[key] = [];
+          }
+        }
+      }
+    }
     return checkpoint;
   }
   /**
@@ -3232,7 +3244,7 @@ async function buildRecoveryPreamble(rootDir) {
   } catch {
   }
   try {
-    const { loadNominations } = await import("./nomination-engine-LPLCCDW2.js");
+    const { loadNominations } = await import("./nomination-engine-LLREC5BZ.js");
     const urgent = loadNominations(rootDir, { pending_only: true }).filter((n) => n.urgency === "critical" || n.urgency === "high");
     if (urgent.length > 0) {
       lines.push("");

package/dist/{chunk-ITPJJIHG.js → chunk-MA7G4CTI.js}

@@ -41,6 +41,36 @@ import * as path from "path";
 import * as os from "os";
 import * as crypto from "crypto";
 import * as yaml from "js-yaml";
+function loadProjectRoster(rootDir) {
+  const rosterPath = path.join(rootDir, ROSTER_FILE);
+  if (!fs.existsSync(rosterPath)) return null;
+  try {
+    const data = yaml.load(fs.readFileSync(rosterPath, "utf8"));
+    return data?.active ?? null;
+  } catch {
+    return null;
+  }
+}
+function isAgentActive(agentId, rootDir) {
+  const roster = loadProjectRoster(rootDir);
+  if (!roster) return true;
+  return roster.includes(agentId);
+}
+function saveProjectRoster(rootDir, active) {
+  const rosterPath = path.join(rootDir, ROSTER_FILE);
+  const dir = path.dirname(rosterPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const data = { version: "1.0", active: active.sort() };
+  fs.writeFileSync(rosterPath, yaml.dump(data, { lineWidth: -1, noRefs: true }), "utf8");
+}
+function listAllGlobalAgentIds() {
+  if (!fs.existsSync(GLOBAL_AGENTS_DIR)) return [];
+  try {
+    return fs.readdirSync(GLOBAL_AGENTS_DIR).filter((f) => f.endsWith(AGENT_EXT)).map((f) => f.replace(AGENT_EXT, ""));
+  } catch {
+    return [];
+  }
+}
 function loadAgentProfile(rootDir, agentId) {
   const projectPath = path.join(rootDir, PROJECT_AGENTS_DIR, `${agentId}${AGENT_EXT}`);
   if (fs.existsSync(projectPath)) {
@@ -499,18 +529,23 @@ function detectProjectName(rootDir) {
   }
   return path.basename(rootDir);
 }
-var GLOBAL_AGENTS_DIR, PROJECT_AGENTS_DIR, AGENT_EXT, EMA_ALPHA;
+var GLOBAL_AGENTS_DIR, PROJECT_AGENTS_DIR, AGENT_EXT, ROSTER_FILE, EMA_ALPHA;
 var init_agent_loader = __esm({
   "../paradigm-mcp/src/utils/agent-loader.ts"() {
     init_agents();
     GLOBAL_AGENTS_DIR = path.join(os.homedir(), ".paradigm", "agents");
     PROJECT_AGENTS_DIR = ".paradigm/agents";
     AGENT_EXT = ".agent";
+    ROSTER_FILE = ".paradigm/roster.yaml";
     EMA_ALPHA = 0.3;
   }
 });
 
 export {
+  loadProjectRoster,
+  isAgentActive,
+  saveProjectRoster,
+  listAllGlobalAgentIds,
   loadAgentProfile,
   loadAllAgentProfiles,
   saveAgentProfile,

package/dist/{chunk-B2RC3HEB.js → chunk-V7BZBBI6.js}

@@ -4,7 +4,7 @@ import {
   loadAgentProfile,
   loadAllAgentProfiles,
   saveAgentProfile
-} from "./chunk-ITPJJIHG.js";
+} from "./chunk-MA7G4CTI.js";
 import {
   init_journal_loader,
   journal_loader_exports

package/dist/index.js

@@ -111,7 +111,7 @@ ${chalk2.magenta("\u2569  ")}${chalk2.cyan("\u2534 \u2534\u2534\u2514\u2500\u253
 program.name("paradigm").description("Unified developer tools ecosystem").version(VERSION).addHelpText("before", banner);
 program.command("init").description("Initialize Paradigm in the current project").option("-f, --force", "Overwrite existing files").option("--name <name>", "Project name").option("--ide <ide>", "Target IDE: cursor, copilot, windsurf, claude").option("--stack <stack>", "Stack preset (e.g., nextjs, fastapi, swift-ios). Auto-detected if omitted.").option("--migrate", "Output migration prompt for existing IDE files").option("--quick", "Non-interactive mode with smart defaults").option("--dry-run", "Show what would be created without creating").action(initCommand);
 program.command("shift").description("Full project setup in one command (init + team init + scan + sync all IDEs + doctor)").option("-f, --force", "Reinitialize even if already setup").option("-q, --quick", "Skip slow operations (scan)").option("--verify", "Run health checks after setup").option("--ide <ide>", "Target specific IDE instead of all").option("--configure-models", "Force model configuration prompts for team agents").option("--stack <stack>", "Stack preset (e.g., nextjs, fastapi, swift-ios). Auto-detected if omitted.").option("--workspace <name>", "Create or join a multi-project workspace with this name (creates ../.paradigm-workspace)").option("--workspace-path <path>", "Custom workspace file location (default: ../.paradigm-workspace)").action(async (options) => {
-  const { shiftCommand } = await import("./shift-2NYRFVEZ.js");
+  const { shiftCommand } = await import("./shift-VJUGMADR.js");
   await shiftCommand(options);
 });
 program.command("presets").description("List available stack presets for paradigm init/shift").option("-d, --discipline <discipline>", "Filter by discipline (e.g., fullstack, api, mobile)").action(async (options) => {

package/dist/mcp.js

@@ -79,7 +79,7 @@ import {
   validateProtocol,
   validatePurposeFile,
   validateUniversityContent
-} from "./chunk-SU3WDCRR.js";
+} from "./chunk-3UCH56D5.js";
 import "./chunk-L27I3CPZ.js";
 import {
   getWorkLogSummary,
@@ -133,16 +133,18 @@ import {
   queryEvents,
   resolveDebate,
   searchNotebooks
-} from "./chunk-B2RC3HEB.js";
+} from "./chunk-V7BZBBI6.js";
 import {
   buildProfileEnrichment,
   init_agent_loader,
+  listAllGlobalAgentIds,
   loadAgentProfile,
   loadAllAgentProfiles,
+  loadProjectRoster,
   queryExpertise,
-  saveAgentProfile,
+  saveProjectRoster,
   verifyIntegrity
-} from "./chunk-ITPJJIHG.js";
+} from "./chunk-MA7G4CTI.js";
 import {
   getJournalStats,
   init_journal_loader,
@@ -5686,6 +5688,7 @@ payloads:
 import * as fs12 from "fs";
 import * as path13 from "path";
 import * as yaml8 from "js-yaml";
+init_agent_loader();
 var SYMBOL_PATTERN = /[@#$%^!?&~][a-zA-Z0-9_-]+/g;
 var DEFAULT_MODELS = {
   architect: "opus",
@@ -5990,6 +5993,14 @@ async function handleOrchestrateInline(args, ctx) {
     trackToolCall(text2.length, "paradigm_orchestrate_inline");
     return { handled: true, text: text2 };
   }
+  const roster = loadProjectRoster(ctx.rootDir);
+  if (roster && manifest.agents) {
+    const filtered = {};
+    for (const [id, def] of Object.entries(manifest.agents)) {
+      if (roster.includes(id)) filtered[id] = def;
+    }
+    manifest.agents = filtered;
+  }
   const symbols = extractSymbols(task);
   const classification = classifyTaskLocal(task);
   const plan = planAgentSequence(task, manifest.agents, agentOverride, classification);
@@ -6021,10 +6032,10 @@ async function handleOrchestrateInline(args, ctx) {
   }
   let agentProfiles = /* @__PURE__ */ new Map();
   try {
-    const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-DBF4OARL.js");
+    const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-X7TDYLFL.js");
     const { loadDecisions: loadDecisions3 } = await import("./decision-loader-WWCLIQPJ.js");
     const { loadJournalEntries: loadJournalEntries2 } = await import("./journal-loader-5EYSBFFY.js");
-    const { loadNominations: loadNominations2 } = await import("./nomination-engine-LPLCCDW2.js");
+    const { loadNominations: loadNominations2 } = await import("./nomination-engine-LLREC5BZ.js");
     const recentDecisions = loadDecisions3(ctx.rootDir, { status: "active", limit: 5 }).map((d) => ({ title: d.title, decision: d.decision.slice(0, 150) }));
     const pendingNominations = loadNominations2(ctx.rootDir, { pending_only: true, limit: 10 }).map((n) => ({ urgency: n.urgency, brief: n.brief }));
     for (const stage of plan.stages) {
@@ -6190,6 +6201,16 @@ async function handleAgentPrompt(args, ctx) {
   const handoffContext = args.handoffContext;
   const previousAgent = args.previousAgent;
   const manifest = loadAgentsManifest(ctx.rootDir);
+  const rosterForPrompt = loadProjectRoster(ctx.rootDir);
+  if (rosterForPrompt && !rosterForPrompt.includes(agentName)) {
+    const text2 = JSON.stringify({
+      warning: `Agent "${agentName}" is not on this project's roster`,
+      suggestion: `Run paradigm_agent_activate id="${agentName}" to add it, or check .paradigm/roster.yaml`,
+      activeRoster: rosterForPrompt
+    }, null, 2);
+    trackToolCall(text2.length, "paradigm_agent_prompt");
+    return { handled: true, text: text2 };
+  }
   const manifestAgent = manifest?.agents[agentName];
   const agentDef = {
     name: manifestAgent?.name || agentName,
@@ -6205,10 +6226,10 @@ async function handleAgentPrompt(args, ctx) {
   let profileEnrichment;
   let nickname;
   try {
-    const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-DBF4OARL.js");
+    const { loadAgentProfile: loadAgentProfile2, buildProfileEnrichment: buildProfileEnrichment2 } = await import("./agent-loader-X7TDYLFL.js");
     const { loadDecisions: loadDecisions3 } = await import("./decision-loader-WWCLIQPJ.js");
     const { loadJournalEntries: loadJournalEntries2 } = await import("./journal-loader-5EYSBFFY.js");
-    const { loadNominations: loadNominations2 } = await import("./nomination-engine-LPLCCDW2.js");
+    const { loadNominations: loadNominations2 } = await import("./nomination-engine-LLREC5BZ.js");
     const profile = loadAgentProfile2(ctx.rootDir, agentName);
     if (profile) {
       nickname = profile.nickname;
@@ -10132,7 +10153,7 @@ async function handleLoreTool(name, args, ctx) {
       try {
         const agentId = process.env.PARADIGM_AGENT_ID;
         if (agentId && symbols_touched && symbols_touched.length > 0) {
-          const { updateExpertiseFromLore } = await import("./agent-loader-DBF4OARL.js");
+          const { updateExpertiseFromLore } = await import("./agent-loader-X7TDYLFL.js");
           updateExpertiseFromLore(ctx.rootDir, agentId, {
             symbols_touched,
             confidence: confidence != null && confidence >= 0 && confidence <= 1 ? confidence : void 0
@@ -10303,7 +10324,7 @@ async function handleLoreTool(name, args, ctx) {
       try {
         const agentId = process.env.PARADIGM_AGENT_ID;
         if (agentId && success && entryToAssess.symbols_touched?.length) {
-          const { updateExpertiseFromAssessment } = await import("./agent-loader-DBF4OARL.js");
+          const { updateExpertiseFromAssessment } = await import("./agent-loader-X7TDYLFL.js");
           updateExpertiseFromAssessment(ctx.rootDir, agentId, {
             symbols_touched: entryToAssess.symbols_touched,
             verdict
@@ -18123,6 +18144,7 @@ async function handleAgentTool(name, args, ctx) {
   switch (name) {
     case "paradigm_agent_list": {
       const profiles = loadAllAgentProfiles(ctx.rootDir);
+      const roster = loadProjectRoster(ctx.rootDir);
       if (profiles.length === 0) {
         return {
           handled: true,
@@ -18133,15 +18155,18 @@ async function handleAgentTool(name, args, ctx) {
           }, null, 2)
         };
       }
+      const activeProfiles = roster ? profiles.filter((p) => roster.includes(p.id)) : profiles;
+      const inactiveCount = roster ? profiles.length - activeProfiles.length : 0;
       return {
         handled: true,
         text: JSON.stringify({
-          count: profiles.length,
-          agents: profiles.map((p) => ({
+          count: activeProfiles.length,
+          totalAvailable: profiles.length,
+          ...roster ? { rosterActive: true, inactiveCount } : { rosterActive: false },
+          agents: activeProfiles.map((p) => ({
             id: p.id,
             role: p.role,
             nickname: p.nickname,
-            benched: p.benched || false,
             personality: p.personality,
             topExpertise: (p.expertise || []).sort((a, b) => b.confidence - a.confidence).slice(0, 5).map((e) => ({
               symbol: e.symbol,
@@ -18239,15 +18264,20 @@ async function handleAgentTool(name, args, ctx) {
           text: JSON.stringify({ error: `Agent "${benchId}" not found` }, null, 2)
         };
       }
-      benchProfile.benched = true;
-      benchProfile.updated = (/* @__PURE__ */ new Date()).toISOString();
-      saveAgentProfile(benchId, benchProfile, "global");
+      let currentRoster = loadProjectRoster(ctx.rootDir);
+      if (currentRoster) {
+        currentRoster = currentRoster.filter((id) => id !== benchId);
+      } else {
+        currentRoster = listAllGlobalAgentIds().filter((id) => id !== benchId);
+      }
+      saveProjectRoster(ctx.rootDir, currentRoster);
       return {
         handled: true,
         text: JSON.stringify({
           id: benchId,
-          benched: true,
-          note: `${benchId} is now benched. Maestro will skip this agent during orchestration.`
+          removedFromRoster: true,
+          rosterCount: currentRoster.length,
+          note: `${benchId} removed from this project's roster. Still available globally.`
         }, null, 2)
       };
     }
@@ -18260,15 +18290,21 @@ async function handleAgentTool(name, args, ctx) {
           text: JSON.stringify({ error: `Agent "${activateId}" not found` }, null, 2)
         };
       }
-      activateProfile.benched = false;
-      activateProfile.updated = (/* @__PURE__ */ new Date()).toISOString();
-      saveAgentProfile(activateId, activateProfile, "global");
+      let activateRoster = loadProjectRoster(ctx.rootDir);
+      if (activateRoster) {
+        if (!activateRoster.includes(activateId)) {
+          activateRoster.push(activateId);
+          saveProjectRoster(ctx.rootDir, activateRoster);
+        }
+      } else {
+      }
       return {
         handled: true,
         text: JSON.stringify({
           id: activateId,
-          benched: false,
-          note: `${activateId} is now active. Maestro will include this agent in orchestration.`
+          addedToRoster: true,
+          rosterCount: activateRoster?.length ?? "all (no roster)",
+          note: `${activateId} is active on this project's roster.`
         }, null, 2)
       };
     }
@@ -18445,7 +18481,7 @@ async function handleNotebookTool(name, args, ctx) {
       const concepts = args.concepts || [];
       const tags = args.tags || [];
       const confidence = args.confidence ?? 0.7;
-      const scope = args.scope || "global";
+      const scope = args.scope || (ctx.rootDir ? "project" : "global");
       const result = addNotebookEntry(
         agentId,
         {
@@ -18474,7 +18510,7 @@ async function handleNotebookTool(name, args, ctx) {
     case "paradigm_notebook_promote": {
       const agentId = args.agentId;
       const loreEntryId = args.loreEntryId;
-      const scope = args.scope || "global";
+      const scope = args.scope || (ctx.rootDir ? "project" : "global");
       const result = await promoteFromLore(agentId, loreEntryId, ctx.rootDir, scope);
       if (!result) {
         return {
@@ -21155,7 +21191,7 @@ Update command:
               trackToolCall(noWsText.length, name);
               return { content: [{ type: "text", text: noWsText }] };
             }
-            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-J5SEDVTT.js");
+            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-U2HEB6GW.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
               const memberAbsPath = path34.resolve(path34.dirname(ctx.workspace.workspacePath), member.path);

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-J5SEDVTT.js → reindex-U2HEB6GW.js}

@@ -3,7 +3,7 @@ import {
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles
-} from "./chunk-SU3WDCRR.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/package.json

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