contextos-agents 2.0.0-beta.2 → 2.0.0-beta.3

package/.agents/AGENTS.md

@@ -37,71 +37,37 @@ Skills are loaded on-demand. To keep the agent context window efficient:
 
 ## Skill Registry
 
-All skills live in `.agents/core/skills/`. Here is what each does and when to use it:
+### Built-in Core Skills (Bundled in `.agents/core/skills/`)
 
-### Core Skills (Always Considered)
+These 7 skills are always present in ContextOS Core:
 
 | Skill | File | Activate When |
 |-------|------|--------------|
 | **engineering-workflow** | `engineering-workflow/SKILL.md` | **Every task** — defines the DEFINE→PLAN→BUILD→VERIFY→REVIEW→SHIP pipeline |
 | **gstack-roles** | `gstack-roles/SKILL.md` | **Every task** — declare your specialist role before each phase |
 | **ponytail-mindset** | `ponytail-mindset/SKILL.md` | **Every BUILD phase** — run the 7-rung ladder before writing any code |
-| **interview-me** | `interview-me/SKILL.md` | **Before /spec** — when requirements are ambiguous or need interactive clarification |
-| **subagent-orchestrator** | `subagent-orchestrator/SKILL.md` | **Parallel tasks** — decompose and delegate work across isolated subagents |
 | **gemini-precision** | `gemini-precision/SKILL.md` | **All Gemini tasks** — zero assumptions, zero placeholders, surgical blast radius, test proof |
+| **security** | `security/SKILL.md` | Any feature with auth, data access, user input, external integration |
+| **context-os** | `context-os/SKILL.md` | Managing context rules, compiler pipelines, project policies |
+| **context-manager** | `context-manager/SKILL.md` | Context selection, dynamic skill resolution, project graph traversal |
 
-### Frontend Skills
+### Extended Catalog Skills (Installed on Demand via `contextos skill add <name>`)
 
-| Skill | File | Activate When |
-|-------|------|--------------|
-| **ui-ux-pro** | `ui-ux-pro/SKILL.md` | Any UI task — planning guide, design decisions, color systems |
-| **brutalist-design** | `brutalist-design/SKILL.md` | When explicitly asked for brutalist, high contrast, industrial, or sharp UI |
-| **minimalist-design** | `minimalist-design/SKILL.md` | When explicitly asked for clean, minimal, editorial, or Notion-like UI |
-| **soft-design** | `soft-design/SKILL.md` | When explicitly asked for calm, soft, premium, or low-contrast UI |
-| **redesign-audit** | `redesign-audit/SKILL.md` | When tasked to audit or redesign an existing complex UI codebase without breaking it |
-| **impeccable-design** | `impeccable-design/SKILL.md` | REVIEW phase for UI — run as hard QA checklist before shipping |
-| **react** | `react/SKILL.md` | React component work |
-| **react-best-practices** | `react-best-practices/SKILL.md` | Deep React component refactoring, hooks, and strict pattern enforcement |
-| **nextjs** | `nextjs/SKILL.md` | Next.js App Router, Server Actions, routing |
-| **typescript** | `typescript/SKILL.md` | Type-safe code, generics, config |
-| **state-management** | `state-management/SKILL.md` | Zustand, TanStack Query, client/server state |
-| **ui-design** | `ui-design/SKILL.md` | Component library design, tokens |
-| **ux-design** | `ux-design/SKILL.md` | User flow design, interaction patterns |
-| **web-accessibility** | `web-accessibility/SKILL.md` | ARIA, WCAG compliance |
-
-### Backend Skills
-
-| Skill | File | Activate When |
-|-------|------|--------------|
-| **system-design** | `system-design/SKILL.md` | Any backend architecture — mandatory pre-design checklist |
-| **node** | `node/SKILL.md` | Node.js server code |
-| **fastapi** | `fastapi/SKILL.md` | FastAPI / Python backend |
-| **nestjs** | `nestjs/SKILL.md` | NestJS framework |
-| **microservices** | `microservices/SKILL.md` | Service decomposition |
-| **ddd** | `ddd/SKILL.md` | Domain modeling, bounded contexts |
-| **database** | `database/SKILL.md` | PostgreSQL, Prisma, Drizzle, migrations, indexing |
+The following domain skills are available in the extended catalog and can be added to your project on demand:
 
-### Cross-Cutting Skills
-
-| Skill | File | Activate When |
-|-------|------|--------------|
-| **security** | `security/SKILL.md` | Any feature with auth, data access, user input |
-| **performance** | `performance/SKILL.md` | Optimization tasks, Core Web Vitals |
-| **vercel-optimize** | `vercel-optimize/SKILL.md` | Edge caching, Vercel deployments, Next.js optimization |
-| **testing** | `testing/SKILL.md` | Vitest, RTL, Playwright, TDD/BDD testing |
-| **docker** | `docker/SKILL.md` | Dockerfiles, multi-stage, container security, compose |
-| **decisions** | `decisions/SKILL.md` | Making architectural choices |
-| **architecture-diagrams** | `architecture-diagrams/SKILL.md` | Interactive animated SVG/HTML architecture and sequence diagrams |
-| **adapters** | `adapters/SKILL.md` | Building system integrations |
-| **generators** | `generators/SKILL.md` | Code generation patterns |
-| **graphify** | `graphify/SKILL.md` | Codebase mapping, AST dependency knowledge graph, blast-radius analysis |
+| Domain | Skills | Install Command |
+|--------|--------|-----------------|
+| **Frontend** | `react`, `react-best-practices`, `nextjs`, `typescript`, `ui-ux-pro`, `impeccable-design`, `state-management`, `ui-design`, `ux-design`, `web-accessibility`, `brutalist-design`, `minimalist-design`, `soft-design`, `redesign-audit` | `contextos skill add <name>` |
+| **Backend** | `system-design`, `node`, `fastapi`, `nestjs`, `microservices`, `ddd`, `database` | `contextos skill add <name>` |
+| **Cross-Cutting** | `testing`, `docker`, `decisions`, `architecture-diagrams`, `adapters`, `generators`, `graphify`, `performance`, `vercel-optimize` | `contextos skill add <name>` |
 
 ---
 
 ## Automatic Skill Activation Rules (Proactive Routing)
 
-The following rules are **deterministic** — no judgment needed. If the condition is true, the skill is loaded. 
-**PROACTIVE ROUTING RULE**: If a user request matches a skill trigger, DO NOT simply answer them ad-hoc. You must proactively load the skill and follow its workflow. Skills contain multi-step workflows, checklists, and quality gates that always produce better results than an unstructured response.
+The following rules are **deterministic** — no judgment needed. If the condition is true, the skill is loaded.
+
+> **Availability Guard**: Load only skills that are physically installed in `.agents/core/skills/`. For uninstalled catalog skills, rely on core skills (`engineering-workflow`, `ponytail-mindset`, `gemini-precision`, `security`) and recommend `contextos skill add <name>` when deep domain checklists are needed.
 
 ### By Task Type
 

package/.agents/adapters/cursor/export.js

@@ -19,12 +19,29 @@ function describe() {
   };
 }
 
-function getSkillGlobsAndFlags(skillName) {
-  const ALWAYS_APPLY_SKILLS = ['engineering-workflow', 'gstack-roles', 'ponytail-mindset'];
+function getSkillGlobsAndFlags(skillName, skillDir = null) {
+  const ALWAYS_APPLY_SKILLS = ['engineering-workflow', 'gstack-roles', 'ponytail-mindset', 'gemini-precision'];
   if (ALWAYS_APPLY_SKILLS.includes(skillName)) {
     return { globs: '', alwaysApply: true };
   }
 
+  // 1. Dynamic extraction from skill.yaml if available
+  if (skillDir) {
+    const yamlPath = path.join(skillDir, 'skill.yaml');
+    if (fs.existsSync(yamlPath)) {
+      try {
+        const yamlContent = fs.readFileSync(yamlPath, 'utf8');
+        const match = yamlContent.match(/(?:fileGlobs|triggers\s*:\s*(?:files|globs)|globs)\s*:\s*\[?([^\r\n\]]+)\]?/i);
+        if (match && match[1]) {
+          const globsVal = match[1].replace(/['"]/g, '').trim();
+          if (globsVal) {
+            return { globs: globsVal, alwaysApply: false };
+          }
+        }
+      } catch {}
+    }
+  }
+
   const GLOB_MAP = {
     'react': '**/*.{tsx,jsx}',
     'react-best-practices': '**/*.{tsx,jsx}',
@@ -110,7 +127,7 @@ function generateCursorMdc(skillDir) {
   if (troubleshooting) raw += '\n\n' + troubleshooting;
 
   const body = stripFrontmatter(raw);
-  const { globs, alwaysApply } = getSkillGlobsAndFlags(skillName);
+  const { globs, alwaysApply } = getSkillGlobsAndFlags(skillName, skillDir);
 
   let cleanDescription = description.replace(/\r?\n+/g, ' ').replace(/"/g, "'").trim();
   if (!globs && !alwaysApply) {

package/.agents/ctx.js

@@ -643,9 +643,31 @@ if (command === 'export') {
       console.error(`[ERROR] ${err.message}`);
       process.exit(1);
     });
+  } else if (subcommand === 'override' || subcommand === 'eject' || subcommand === 'diff') {
+    const { SkillCustomizationManager } = require('./customization-dx.js');
+    const manager = new SkillCustomizationManager(process.cwd());
+    try {
+      if (subcommand === 'override') {
+        const res = manager.override(ref);
+        console.log(`✓ Created skill override for '${ref}' at: ${res.overridePath}`);
+      } else if (subcommand === 'eject') {
+        const res = manager.eject(ref);
+        console.log(`✓ Ejected skill '${ref}' to project layer at: ${res.ejectedPath}`);
+      } else if (subcommand === 'diff') {
+        const res = manager.diff(ref);
+        if (!res.hasDiff) {
+          console.log(`No diff for skill '${ref}' against upstream.`);
+        } else {
+          console.log(`Diff for skill '${ref}':\n${res.diff}`);
+        }
+      }
+    } catch (err) {
+      console.error(`[ERROR] ${err.message}`);
+      process.exit(1);
+    }
   } else {
     console.error(`Unknown skill subcommand: ${subcommand}`);
-    console.error('Valid subcommands: add, remove, list, search');
+    console.error('Valid subcommands: add, remove, list, search, override, eject, diff');
     process.exit(1);
   }
 
@@ -800,75 +822,15 @@ if (command === 'export') {
 
 // ── thread ──────────────────────────────────────────────────────────────────
 } else if (command === 'thread') {
-  const { ThreadStore } = require('./runtime/thread-store.js');
-  const { evaluateMergeReadiness } = require('./runtime/state-machine.js');
-  const store = new ThreadStore({ baseDir: process.cwd() });
-  const subcmd = args[1] || 'list';
-  const isJson = args.includes('--json');
-
-  if (subcmd === 'list') {
-    const list = store.list();
-    if (isJson) {
-      console.log(JSON.stringify(list, null, 2));
-    } else {
-      console.log('\n══════════════════════════════════════════');
-      console.log('  ContextOS — Runtime Execution Threads');
-      console.log('══════════════════════════════════════════\n');
-      if (list.length === 0) {
-        console.log('  No runtime threads recorded yet.');
-      } else {
-        for (const th of list) {
-          const ready = th.merge?.status === 'READY' ? ' [READY TO MERGE]' : '';
-          console.log(`  • ID: ${th.id} (rev: ${th.revision})`);
-          console.log(`    Status      : Exec: ${th.execution.status} | Verify: ${th.verification.status} | Review: ${th.review.status} | Merge: ${th.merge.status}${ready}`);
-          console.log(`    Task        : ${(th.config?.task || '').slice(0, 70)}`);
-          console.log(`    Created     : ${new Date(th.createdAt).toISOString()}`);
-          console.log('');
-        }
-      }
-      console.log('──────────────────────────────────────────\n');
-    }
-  } else if (subcmd === 'get') {
-    const threadId = args[2];
-    if (!threadId) {
-      console.error('Usage: node ctx.js thread get <threadId> [--json]');
-      process.exit(1);
-    }
-    const th = store.get(threadId);
-    if (!th) {
-      console.error(`Thread "${threadId}" not found.`);
-      process.exit(1);
-    }
-    console.log(JSON.stringify(th, null, 2));
-  } else if (subcmd === 'readiness') {
-    const threadId = args[2];
-    if (!threadId) {
-      console.error('Usage: node ctx.js thread readiness <threadId> [--json]');
-      process.exit(1);
-    }
-    const th = store.get(threadId);
-    if (!th) {
-      console.error(`Thread "${threadId}" not found.`);
-      process.exit(1);
-    }
-    const readiness = evaluateMergeReadiness(th);
-    if (isJson) {
-      console.log(JSON.stringify(readiness, null, 2));
-    } else {
-      console.log('\n══════════════════════════════════════════');
-      console.log(`  ContextOS — Merge Readiness (${th.id})`);
-      console.log('══════════════════════════════════════════\n');
-      console.log(`  Overall Verdict: ${readiness.isReady ? 'READY TO MERGE ✓' : 'NOT READY ✗'}\n`);
-      for (const c of readiness.checks) {
-        const mark = c.passed ? '✓' : '✗';
-        console.log(`  ${mark} [${c.name.padEnd(24)}] ${c.message}`);
-      }
-      console.log('\n──────────────────────────────────────────\n');
-    }
-  } else {
-    console.error(`Unknown thread subcommand: ${subcmd}. Available: list, get, readiness`);
-    process.exit(1);
-  }
+  console.log('\n══════════════════════════════════════════');
+  console.log('  ContextOS — Runtime Execution Threads');
+  console.log('══════════════════════════════════════════\n');
+  console.log('[INFO] Execution runtime and thread management have moved to @contextos/mcp in v2.0.');
+  console.log('       To view, manage, and verify execution threads, install and run:');
+  console.log('         npm install --save-dev @contextos/mcp');
+  console.log('         npx contextos-mcp thread ' + (args.slice(1).join(' ') || 'list'));
+  console.log('\n──────────────────────────────────────────\n');
+  process.exit(0);
 
 // ── unknown ───────────────────────────────────────────────────────────────────
 } else {

package/.agents/doctor.js

@@ -167,6 +167,15 @@ function checkFilesystemPermissions(projectDir) {
 function checkPreCommitHook(projectDir) {
   const hookPath = path.join(projectDir, '.git', 'hooks', 'pre-commit');
   if (!fs.existsSync(hookPath)) {
+    if (!isContextOSDevRepo(projectDir)) {
+      return {
+        id: 'pre_commit_hook',
+        status: STATUS.SKIP,
+        ok: true,
+        message: 'optional (not installed in workspace)',
+        remediation: null,
+      };
+    }
     return {
       id: 'pre_commit_hook',
       status: STATUS.WARN,
@@ -207,6 +216,15 @@ function checkPreCommitHook(projectDir) {
 function checkSecretScanner(projectDir) {
   const scriptPath = path.join(projectDir, 'scripts', 'check-secrets.js');
   if (!fs.existsSync(scriptPath)) {
+    if (!isContextOSDevRepo(projectDir)) {
+      return {
+        id: 'secret_scanner',
+        status: STATUS.SKIP,
+        ok: true,
+        message: 'optional (not configured in workspace)',
+        remediation: null,
+      };
+    }
     // Per Milestone 8 spec: "doctor не считает отсутствующий scanner PASS"
     return {
       id: 'secret_scanner',
@@ -680,6 +698,85 @@ function checkDriftStatus(projectDir) {
   }
 }
 
+function isContextOSDevRepo(projectDir) {
+  try {
+    const pkgPath = path.join(projectDir, 'package.json');
+    if (!fs.existsSync(pkgPath)) return false;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg.name === 'contextos-agents' || pkg.name === 'contextos';
+  } catch {
+    return false;
+  }
+}
+
+function checkModuleExecution(projectDir) {
+  const errors = [];
+
+  // Check CanonicalResolver
+  try {
+    const resolverPath = path.join(projectDir, '.agents', 'resolver', 'canonical-resolver.js');
+    if (fs.existsSync(resolverPath)) {
+      const resolver = require(resolverPath);
+      if (!resolver || typeof resolver.CanonicalResolver !== 'function') {
+        errors.push('CanonicalResolver is not exported correctly');
+      }
+    } else {
+      errors.push('.agents/resolver/canonical-resolver.js missing');
+    }
+  } catch (err) {
+    errors.push(`CanonicalResolver import failed: ${err.message}`);
+  }
+
+  // Check RuleCatalog
+  try {
+    const rulesPath = path.join(projectDir, '.agents', 'rules', 'rule-catalog.js');
+    if (fs.existsSync(rulesPath)) {
+      const rules = require(rulesPath);
+      if (!rules || typeof rules.RuleCatalog !== 'function') {
+        errors.push('RuleCatalog is not exported correctly');
+      }
+    } else {
+      errors.push('.agents/rules/rule-catalog.js missing');
+    }
+  } catch (err) {
+    errors.push(`RuleCatalog import failed: ${err.message}`);
+  }
+
+  // Check ManifestCompiler
+  try {
+    const compilerPath = path.join(projectDir, '.agents', 'compiler', 'manifest-compiler.js');
+    if (fs.existsSync(compilerPath)) {
+      const compiler = require(compilerPath);
+      if (!compiler || typeof compiler.ManifestCompiler !== 'function') {
+        errors.push('ManifestCompiler is not exported correctly');
+      }
+    } else {
+      errors.push('.agents/compiler/manifest-compiler.js missing');
+    }
+  } catch (err) {
+    errors.push(`ManifestCompiler import failed: ${err.message}`);
+  }
+
+  if (errors.length > 0) {
+    return {
+      id: 'module_execution',
+      status: STATUS.FAIL,
+      ok: false,
+      message: errors.join('; '),
+      errors,
+      remediation: 'Reinstall package via `npx contextos-agents init --force` to restore core modules',
+    };
+  }
+
+  return {
+    id: 'module_execution',
+    status: STATUS.PASS,
+    ok: true,
+    message: 'all core modules verified (resolver, rules, compiler)',
+    remediation: null,
+  };
+}
+
 function inspectSkills(projectDir, activeProfile) {
   const skillsDir = path.join(projectDir, '.agents', 'core', 'skills');
   if (!fs.existsSync(skillsDir)) return { total: 0, active: 0, excluded: 0, byDomain: { frontend: [], backend: [], cross: [] } };
@@ -782,9 +879,27 @@ function applyDoctorFix(projectDir = process.cwd(), options = {}) {
 function runDoctor(projectDir = process.cwd(), options = {}) {
   const version = (() => {
     try {
-      return require('../package.json').version;
+      const parentPkgPath = path.join(__dirname, '..', 'package.json');
+      if (fs.existsSync(parentPkgPath)) {
+        const parentPkg = JSON.parse(fs.readFileSync(parentPkgPath, 'utf8'));
+        if (parentPkg.name === 'contextos-agents' || parentPkg.name === 'contextos') {
+          return parentPkg.version;
+        }
+      }
+      const lockfileV2Path = path.join(projectDir, '.agents', 'lockfile.v2.json');
+      if (fs.existsSync(lockfileV2Path)) {
+        const lf = JSON.parse(fs.readFileSync(lockfileV2Path, 'utf8'));
+        if (lf.package && lf.package.compilerVersion) return lf.package.compilerVersion;
+      }
+      const lockfilePath = path.join(projectDir, '.agents', 'lockfile.json');
+      if (fs.existsSync(lockfilePath)) {
+        const lf = JSON.parse(fs.readFileSync(lockfilePath, 'utf8'));
+        if (lf.generator && lf.generator.version) return lf.generator.version;
+        if (lf.version) return lf.version;
+      }
+      return '2.0.0';
     } catch {
-      return '1.7.1';
+      return '2.0.0';
     }
   })();
 
@@ -811,6 +926,18 @@ function runDoctor(projectDir = process.cwd(), options = {}) {
     errors.push('.agents/ directory missing (run: npx contextos-agents init)');
   }
 
+  const moduleExecCheck = hasAgents ? checkModuleExecution(projectDir) : {
+    id: 'module_execution',
+    status: STATUS.FAIL,
+    ok: false,
+    message: '.agents directory missing',
+    remediation: 'Run: npx contextos-agents init',
+  };
+  checks.push(moduleExecCheck);
+  if (!moduleExecCheck.ok) {
+    errors.push(moduleExecCheck.message);
+  }
+
   const nodeCheck = checkNodeVersion();
   checks.push(nodeCheck);
   if (!nodeCheck.ok) errors.push(nodeCheck.message);
@@ -947,6 +1074,11 @@ function runDoctor(projectDir = process.cwd(), options = {}) {
     console.log('│  ✗ .agents/ directory missing (run: npx contextos-agents)    │');
   }
 
+  // Execution check
+  const execIcon = moduleExecCheck.ok ? '✓' : '✗';
+  const execStr = `Core modules: ${moduleExecCheck.message}`;
+  console.log(`│  ${execIcon} ${execStr.slice(0, 58).padEnd(58)}│`);
+
   // Node version
   const nodeIcon = nodeCheck.ok ? '✓' : '✗';
   console.log(`│  ${nodeIcon} ${nodeCheck.message.padEnd(58)}│`);
@@ -990,7 +1122,7 @@ function runDoctor(projectDir = process.cwd(), options = {}) {
   if (mcpCheck.status === STATUS.PASS) {
     console.log('│  ✓ MCP server: installed (.agents/mcp/server.mjs)           │');
   } else {
-    console.log('│  • MCP server: not installed (run: contextos setup-mcp)     │');
+    console.log('│  • MCP server: not installed (run: npm i -D @contextos/mcp) │');
   }
 
   // Pre-commit hook
@@ -1109,5 +1241,7 @@ module.exports = {
   checkSandboxAvailability,
   checkClaimEvidence,
   checkProjectLock,
+  checkModuleExecution,
+  isContextOSDevRepo,
   inspectSkills,
 };

package/.agents/plugins.js

@@ -62,12 +62,10 @@ const c = {
 const PROMPT_INJECTION_PATTERNS = [
   /ignore\s+(all\s+)?previous\s+instructions/i,
   /forget\s+(all\s+)?previous/i,
-  /you\s+are\s+now/i,
-  /system\s*:\s*/i,
+  /you\s+are\s+now\s+(?:an?\s+)?(?:unrestricted|jailbreak|evil|dan|developer\s+mode|bypassed)/i,
   /\[SYSTEM\]/i,
-  /base64\s*,\s*[A-Za-z0-9+/=]{40,}/i,
-  /https?:\/\/[^\s)]+\/(?:exfil|steal|leak|webhook|collect)/i,
-  /\b(?:eval|exec|Function)\s*\(/i,
+  /(?:^|[\r\n])\s*system\s*:\s*/i,
+  /https?:\/\/[^\s)]+\/(?:exfil|steal|leak|webhook|collect)\b/i,
 ];
 
 // ── Shell Escapes & Script Injection Scanner ──────────────────────────────────
@@ -411,6 +409,23 @@ async function installFromGitHub(descriptor, skillName, dryRun, checksum, forceU
     manifest['skill.yaml'] = yamlHash;
   }
 
+  // Also try to fetch standard ancillary files if present
+  const ancillaryFiles = ['EXAMPLES.md', 'TROUBLESHOOTING.md', 'VALIDATION.json'];
+  for (const f of ancillaryFiles) {
+    const fUrl = skillPath ? `${base}/${skillPath}/${f}` : `${base}/${f}`;
+    try {
+      const fContent = await fetchText(fUrl);
+      if (fContent && fContent.length > 0) {
+        scanForPromptInjection(fContent, { throwOnMatch: !forceUnsafe });
+        const fHash = crypto.createHash('sha256').update(fContent).digest('hex');
+        tx.stageWrite(`${relTargetDir}/${f}`, fContent);
+        manifest[f] = fHash;
+      }
+    } catch {
+      // Ancillary files are optional
+    }
+  }
+
   // Write a source marker with manifest
   const sourceContent = JSON.stringify({
     type:    'github',