contextos-agents 1.5.0 → 1.6.0

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

@@ -22,42 +22,36 @@ function getSkillGlobsAndFlags(skillName) {
     return { globs: '', alwaysApply: true };
   }
 
-  const FRONTEND_SKILLS = [
-    'react', 'nextjs', 'typescript', 'ui-ux-pro', 'impeccable-design',
-    'ui-design', 'ux-design', 'web-accessibility', 'brutalist-design',
-    'minimalist-design', 'soft-design', 'redesign-audit', 'react-best-practices',
-  ];
-  if (FRONTEND_SKILLS.includes(skillName)) {
-    return { globs: '**/*.{ts,tsx,js,jsx,css,scss,html}', alwaysApply: false };
-  }
-
-  const BACKEND_SKILLS = ['system-design', 'node', 'nestjs', 'microservices', 'ddd'];
-  if (BACKEND_SKILLS.includes(skillName)) {
-    return { globs: '**/*.{ts,js,json,prisma,sql}', alwaysApply: false };
-  }
-
-  if (skillName === 'database') {
-    return { globs: '**/*.{prisma,sql,sqlite,db,drizzle.config.*}', alwaysApply: false };
-  }
-
-  if (skillName === 'docker') {
-    return { globs: '**/Dockerfile*,**/docker-compose*.{yml,yaml}', alwaysApply: false };
-  }
-
-  if (skillName === 'testing') {
-    return { globs: '**/*.{test,spec}.{ts,js,tsx,jsx},vitest.config.*,jest.config.*', alwaysApply: false };
-  }
-
-  if (skillName === 'state-management') {
-    return { globs: '**/*{store,state,slice,reducer,atom}*.{ts,js,tsx,jsx}', alwaysApply: false };
-  }
-
-  if (skillName === 'performance' || skillName === 'vercel-optimize') {
-    return { globs: '**/*.{ts,tsx,js,jsx,json}', alwaysApply: false };
-  }
-
-  if (skillName === 'fastapi') {
-    return { globs: '**/*.{py,requirements.txt,Pipfile,pyproject.toml}', alwaysApply: false };
+  // Precise surgical globs mapping to prevent context flooding
+  const GLOB_MAP = {
+    'react': '**/*.{tsx,jsx}',
+    'react-best-practices': '**/*.{tsx,jsx}',
+    'nextjs': 'app/**/*,pages/**/*,next.config.*',
+    'typescript': '**/*.{ts,tsx}',
+    'ui-design': '**/*.{tsx,jsx,css,scss}',
+    'ui-ux-pro': '**/*.{tsx,jsx,css,scss}',
+    'ux-design': '**/*.{tsx,jsx}',
+    'impeccable-design': '**/*.{tsx,jsx,css,scss}',
+    'brutalist-design': '**/*.{tsx,jsx,css,scss}',
+    'minimalist-design': '**/*.{tsx,jsx,css,scss}',
+    'soft-design': '**/*.{tsx,jsx,css,scss}',
+    'redesign-audit': '**/*.{tsx,jsx,css,scss}',
+    'web-accessibility': '**/*.{tsx,jsx,html}',
+    'ddd': '**/domain/**/*,**/entities/**/*,**/aggregates/**/*',
+    'microservices': '**/services/**/*,docker-compose.*,**/gateway/**/*',
+    'nestjs': '**/*.module.ts,**/*.controller.ts,**/*.service.ts,nest-cli.json',
+    'node': '**/*.{ts,js}',
+    'database': '**/*.{prisma,sql,sqlite,db,drizzle.config.*}',
+    'docker': '**/Dockerfile*,**/docker-compose*.{yml,yaml}',
+    'testing': '**/*.{test,spec}.{ts,js,tsx,jsx},vitest.config.*,jest.config.*',
+    'state-management': '**/*{store,state,slice,reducer,atom}*.{ts,js,tsx,jsx}',
+    'performance': '**/*.{ts,tsx,js,jsx,json}',
+    'vercel-optimize': '**/*.{ts,tsx,js,jsx,json}',
+    'fastapi': '**/*.{py,requirements.txt,Pipfile,pyproject.toml}',
+  };
+
+  if (GLOB_MAP[skillName]) {
+    return { globs: GLOB_MAP[skillName], alwaysApply: false };
   }
 
   return { globs: '', alwaysApply: false };
@@ -118,7 +112,10 @@ function generateCursorMdc(skillDir) {
   const body = stripFrontmatter(raw);
   const { globs, alwaysApply } = getSkillGlobsAndFlags(skillName);
 
-  const cleanDescription = description.replace(/\r?\n+/g, ' ').replace(/"/g, "'").trim();
+  let cleanDescription = description.replace(/\r?\n+/g, ' ').replace(/"/g, "'").trim();
+  if (!globs && !alwaysApply) {
+    cleanDescription = `Agent-requested: invoke when working on ${title}. ${cleanDescription}`.trim();
+  }
   const mdcContent = `---
 description: "${cleanDescription}"
 globs: ${globs ? `"${globs}"` : '""'}

package/.agents/ctx.js

@@ -301,7 +301,8 @@ if (command === 'export') {
   }
 
   if (subcommand === 'add') {
-    plugins.add(ref, { dryRun, checksum }).catch(err => {
+    const forceUnsafe = args.includes('--force-unsafe-prompts') || args.includes('--force-unsafe');
+    plugins.add(ref, { dryRun, checksum, forceUnsafe }).catch(err => {
       console.error(`[ERROR] ${err.message}`);
       process.exit(1);
     });
@@ -323,7 +324,7 @@ if (command === 'export') {
 
 // ── clean-worktrees ──────────────────────────────────────────────────────────
 } else if (command === 'clean-worktrees' || command === 'clean') {
-  const { execSync } = require('child_process');
+  const { execSync, execFileSync } = require('child_process');
   const fs = require('fs');
   const path = require('path');
   const rootDir = path.resolve(__dirname, '..');
@@ -331,16 +332,16 @@ if (command === 'export') {
   
   console.log('Cleaning up ContextOS swarm worktrees and branches...');
   try {
-    execSync('git worktree prune', { cwd: rootDir, stdio: 'pipe' });
+    execFileSync('git', ['worktree', 'prune'], { cwd: rootDir, stdio: 'pipe' });
   } catch {}
 
   let branchCount = 0;
   try {
-    const branches = execSync('git branch --list "swarm/*"', { cwd: rootDir, encoding: 'utf-8' });
+    const branches = execFileSync('git', ['branch', '--list', 'swarm/*'], { cwd: rootDir, encoding: 'utf-8' });
     const list = branches.split('\n').map(b => b.replace(/^[*+\s]+/, '').trim()).filter(Boolean);
     for (const b of list) {
       try {
-        execSync(`git branch -D "${b}"`, { cwd: rootDir, stdio: 'pipe' });
+        execFileSync('git', ['branch', '-D', b], { cwd: rootDir, stdio: 'pipe' });
         branchCount++;
       } catch {}
     }

package/.agents/doctor.js

@@ -0,0 +1,269 @@
+/**
+ * .agents/doctor.js
+ * ContextOS — Project Diagnostics & Health Check Engine
+ *
+ * Inspects:
+ *   1. .agents/ directory and core runtime files
+ *   2. Node.js environment compatibility
+ *   3. Active profile and skill exclusion/preference state
+ *   4. Compiled AI agent adapters (Gemini, Claude, Cursor, Copilot, etc.)
+ *   5. MCP server status and worktree support
+ *   6. Security controls (pre-commit hooks, secret scanning)
+ *   7. Project tech stack detection and recommended profile alignment
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const profiles = require('./profiles.js');
+
+const DOMAIN_MAP = {
+  frontend: new Set([
+    'react', 'react-best-practices', 'nextjs', 'typescript',
+    'ui-ux-pro', 'ui-design', 'ux-design', 'web-accessibility',
+    'brutalist-design', 'minimalist-design', 'soft-design', 'redesign-audit',
+    'impeccable-design', 'state-management',
+  ]),
+  backend: new Set([
+    'node', 'fastapi', 'nestjs', 'database', 'system-design',
+    'ddd', 'microservices',
+  ]),
+  cross: new Set([
+    'engineering-workflow', 'gstack-roles', 'ponytail-mindset',
+    'gemini-precision', 'interview-me', 'security', 'testing',
+    'performance', 'vercel-optimize', 'docker', 'decisions',
+    'architecture-diagrams', 'subagent-orchestrator', 'graphify',
+    'context-manager', 'context-os', 'adapters', 'generators',
+  ]),
+};
+
+function checkNodeVersion() {
+  const version = process.version; // e.g. v22.12.0
+  const match = version.match(/^v?(\d+)\.(\d+)/);
+  if (!match) return { ok: false, version, message: `${version} (unknown)` };
+
+  const major = parseInt(match[1], 10);
+  const minor = parseInt(match[2], 10);
+  // Requires at least Node 18.0.0 or 16.7.0 for recursive cpSync
+  const ok = major > 16 || (major === 16 && minor >= 7);
+  return {
+    ok,
+    version,
+    message: ok ? `Node.js ${version} (>= 16.7.0 required)` : `Node.js ${version} (< 16.7.0, please upgrade)`,
+  };
+}
+
+function checkPreCommitHook(projectDir) {
+  const hookPath = path.join(projectDir, '.git', 'hooks', 'pre-commit');
+  if (!fs.existsSync(hookPath)) {
+    return { ok: false, message: 'not installed (run: npm run setup:hooks)' };
+  }
+  try {
+    const content = fs.readFileSync(hookPath, 'utf8');
+    if (content.includes('check-secrets')) {
+      return { ok: true, message: 'installed (with secret check)' };
+    }
+    return { ok: false, message: 'installed but missing check-secrets' };
+  } catch {
+    return { ok: false, message: 'unreadable' };
+  }
+}
+
+function checkSecretScanner(projectDir) {
+  const scriptPath = path.join(projectDir, 'scripts', 'check-secrets.js');
+  if (!fs.existsSync(scriptPath)) {
+    return { ok: true, message: 'scanner script not present (skipped)' };
+  }
+  try {
+    execFileSync(process.execPath, [scriptPath, '--all'], {
+      cwd: projectDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { ok: true, message: '0 findings' };
+  } catch (err) {
+    return { ok: false, message: 'potential secrets detected (run: npm run check:secrets)' };
+  }
+}
+
+function checkCompiledAdapters(projectDir) {
+  const compiled = [];
+  const genGemini = path.join(projectDir, '.agents', 'generated', 'gemini', 'skills');
+  if (fs.existsSync(genGemini) && fs.readdirSync(genGemini).length > 0) {
+    compiled.push('gemini');
+  }
+  const genClaude = path.join(projectDir, '.agents', 'generated', 'claude', 'skills');
+  if (fs.existsSync(genClaude) && fs.readdirSync(genClaude).length > 0) {
+    compiled.push('claude');
+  }
+  if (fs.existsSync(path.join(projectDir, '.cursorrules')) || fs.existsSync(path.join(projectDir, '.cursor', 'rules'))) {
+    compiled.push('cursor');
+  }
+  if (fs.existsSync(path.join(projectDir, '.github', 'copilot-instructions.md'))) {
+    compiled.push('copilot');
+  }
+  if (fs.existsSync(path.join(projectDir, '.aider.conf.yml'))) {
+    compiled.push('aider');
+  }
+  if (fs.existsSync(path.join(projectDir, '.zed', 'rules.md'))) {
+    compiled.push('zed');
+  }
+  return compiled;
+}
+
+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: [] } };
+
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  const allSkills = entries
+    .filter(e => e.isDirectory() && fs.existsSync(path.join(skillsDir, e.name, 'SKILL.md')))
+    .map(e => e.name);
+
+  const excludedSet = new Set(activeProfile ? activeProfile.exclude_skills || [] : []);
+  const activeSkills = allSkills.filter(s => !excludedSet.has(s));
+
+  const byDomain = { frontend: [], backend: [], cross: [] };
+  for (const s of activeSkills) {
+    if (DOMAIN_MAP.frontend.has(s)) byDomain.frontend.push(s);
+    else if (DOMAIN_MAP.backend.has(s)) byDomain.backend.push(s);
+    else byDomain.cross.push(s);
+  }
+
+  return {
+    total: allSkills.length,
+    active: activeSkills.length,
+    excluded: excludedSet.size,
+    byDomain,
+  };
+}
+
+function runDoctor(projectDir = process.cwd()) {
+  const version = (() => {
+    try {
+      return require('../package.json').version;
+    } catch {
+      return '1.5.0';
+    }
+  })();
+
+  const agentsDir = path.join(projectDir, '.agents');
+  const hasAgents = fs.existsSync(agentsDir);
+  const nodeCheck = checkNodeVersion();
+  const activeProfile = hasAgents ? profiles.getActiveProfile(projectDir) : null;
+  const skillsInfo = inspectSkills(projectDir, activeProfile);
+  const compiledAdapters = checkCompiledAdapters(projectDir);
+
+  const mcpServerPath = path.join(projectDir, '.agents', 'mcp', 'server.mjs');
+  const hasMcp = fs.existsSync(mcpServerPath);
+
+  const hookCheck = checkPreCommitHook(projectDir);
+  const secretCheck = checkSecretScanner(projectDir);
+  const stack = profiles.detectStack(projectDir);
+
+  console.log('\n┌─────────────────────────────────────────────────────────────┐');
+  console.log(`│  ContextOS Doctor — Project Health Check  v${version.padEnd(16)}│`);
+  console.log('├─────────────────────────────────────────────────────────────┤');
+  console.log('│                                                             │');
+
+  // .agents directory
+  if (hasAgents) {
+    console.log('│  ✓ .agents/ directory found                                 │');
+  } else {
+    console.log('│  ✗ .agents/ directory missing (run: npx contextos-agents)    │');
+  }
+
+  // Node version
+  const nodeIcon = nodeCheck.ok ? '✓' : '✗';
+  console.log(`│  ${nodeIcon} ${nodeCheck.message.padEnd(58)}│`);
+
+  // Active profile
+  if (activeProfile) {
+    const profStr = `Active profile: ${activeProfile.name || activeProfile.profile}`;
+    console.log(`│  ✓ ${profStr.padEnd(58)}│`);
+  } else {
+    console.log('│  • Active profile: default (no profile locked)              │');
+  }
+
+  // Skills
+  const skillsStr = `Skills loaded: ${skillsInfo.active} / ${skillsInfo.total}` +
+    (skillsInfo.excluded > 0 ? ` (${skillsInfo.excluded} excluded by profile)` : '');
+  console.log(`│  ✓ ${skillsStr.padEnd(58)}│`);
+
+  // Adapters
+  if (compiledAdapters.length > 0) {
+    const adaptStr = `Adapters compiled: ${compiledAdapters.join(', ')}`;
+    console.log(`│  ✓ ${adaptStr.padEnd(58)}│`);
+  } else {
+    console.log('│  • Adapters compiled: none (run: contextos export gemini)   │');
+  }
+
+  // MCP
+  if (hasMcp) {
+    console.log('│  ✓ MCP server: installed (.agents/mcp/server.mjs)           │');
+  } else {
+    console.log('│  • MCP server: not installed (run: contextos setup-mcp)     │');
+  }
+
+  // Security
+  const hookIcon = hookCheck.ok ? '✓' : '•';
+  const hookStr = `Pre-commit hook: ${hookCheck.message}`;
+  console.log(`│  ${hookIcon} ${hookStr.padEnd(58)}│`);
+
+  const secretIcon = secretCheck.ok ? '✓' : '✗';
+  const secretStr = `Secret scanner: ${secretCheck.message}`;
+  console.log(`│  ${secretIcon} ${secretStr.padEnd(58)}│`);
+
+  console.log('│                                                             │');
+  console.log('├─────────────────────────────────────────────────────────────┤');
+  console.log('│  Project Stack & Profile Recommendations                    │');
+  console.log('├─────────────────────────────────────────────────────────────┤');
+  console.log('│                                                             │');
+
+  const detectedStr = `Detected Stack: ${stack.detected.length ? stack.detected.join(', ') : 'Generic JS'}`;
+  console.log(`│  • ${detectedStr.slice(0, 56).padEnd(56)} │`);
+
+  const recProfStr = `Recommended Profile: ${stack.recommendedProfile}`;
+  console.log(`│  • ${recProfStr.padEnd(56)} │`);
+
+  console.log('│                                                             │');
+  console.log('│  Skills by Domain:                                          │');
+
+  const feStr = `Frontend (${skillsInfo.byDomain.frontend.length}): ${skillsInfo.byDomain.frontend.slice(0, 4).join(', ')}${skillsInfo.byDomain.frontend.length > 4 ? '...' : ''}`;
+  console.log(`│    ${feStr.padEnd(57)}│`);
+
+  const beStr = `Backend  (${skillsInfo.byDomain.backend.length}): ${skillsInfo.byDomain.backend.slice(0, 4).join(', ')}${skillsInfo.byDomain.backend.length > 4 ? '...' : ''}`;
+  console.log(`│    ${beStr.padEnd(57)}│`);
+
+  const crStr = `Cross    (${skillsInfo.byDomain.cross.length}): ${skillsInfo.byDomain.cross.slice(0, 4).join(', ')}${skillsInfo.byDomain.cross.length > 4 ? '...' : ''}`;
+  console.log(`│    ${crStr.padEnd(57)}│`);
+
+  console.log('│                                                             │');
+  console.log('└─────────────────────────────────────────────────────────────┘\n');
+
+  return {
+    hasAgents,
+    nodeOk: nodeCheck.ok,
+    activeProfile,
+    skillsInfo,
+    compiledAdapters,
+    hasMcp,
+    hookCheck,
+    secretCheck,
+    stack,
+  };
+}
+
+if (require.main === module) {
+  runDoctor();
+}
+
+module.exports = {
+  runDoctor,
+  checkNodeVersion,
+  checkPreCommitHook,
+  checkSecretScanner,
+  checkCompiledAdapters,
+  inspectSkills,
+};

package/.agents/mcp/runtime.py

@@ -38,6 +38,8 @@ _FORBIDDEN_ATTRIBUTES = {
     '__globals__', '__code__', '__builtins__', '__import__',
     '__getattr__', '__setattr__', '__delattr__',
     '__reduce__', '__reduce_ex__',  # pickle-based escapes
+    'create_subprocess_shell', 'create_subprocess_exec',
+    'open_connection', 'start_server', 'connect_read_pipe', 'connect_write_pipe',
 }
 
 def _safe_import(name, globals=None, locals=None, fromlist=(), level=0):
@@ -340,6 +342,20 @@ def merge_threads() -> str:
         return raw
 
 
+class _SafeAsyncio:
+    gather = staticmethod(asyncio.gather)
+    sleep = staticmethod(asyncio.sleep)
+    wait = staticmethod(asyncio.wait)
+    Event = asyncio.Event
+    Queue = asyncio.Queue
+    Lock = asyncio.Lock
+    Semaphore = asyncio.Semaphore
+    TimeoutError = asyncio.TimeoutError
+    as_completed = staticmethod(asyncio.as_completed)
+
+_safe_asyncio = _SafeAsyncio()
+
+
 def _runtime_symbols() -> dict:
     """Return the dict of runtime symbols injected into the user namespace."""
     return {
@@ -352,7 +368,7 @@ def _runtime_symbols() -> dict:
         'merge_threads': merge_threads,
         'FINAL': FINAL,
         'FINAL_VAR': FINAL_VAR,
-        'asyncio': asyncio,
+        'asyncio': _safe_asyncio,
         'json': json,
     }
 

package/.agents/mcp/server.mjs

@@ -2240,8 +2240,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize2) {
-      if (normalize2 !== false)
+    function getFullPath(resolver, id = "", normalize3) {
+      if (normalize3 !== false)
         id = normalizeId(id);
       const p5 = resolver.parse(id);
       return _getFullPath(resolver, p5);
@@ -3581,7 +3581,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize2(uri, options) {
+    function normalize3(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         serialize(parse3(uri, options), options);
@@ -3817,7 +3817,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize: normalize2,
+      normalize: normalize3,
       resolve: resolve10,
       resolveComponent,
       equal,
@@ -6833,9 +6833,10 @@ var init_provider = __esm({
 // src/security/secret-filter.ts
 import * as path3 from "node:path";
 function isBlockedPath(filePath) {
-  const basename5 = path3.basename(filePath).toLowerCase();
-  const ext = path3.extname(filePath).toLowerCase();
-  const parts = filePath.split(path3.sep).map((p5) => p5.toLowerCase());
+  const normalized = path3.normalize(filePath);
+  const basename5 = path3.basename(normalized).toLowerCase();
+  const ext = path3.extname(normalized).toLowerCase();
+  const parts = normalized.split(/[/\\]/).map((p5) => p5.toLowerCase());
   if (BLOCKED_FILENAMES.some((f7) => basename5 === f7.toLowerCase())) {
     return true;
   }
@@ -6851,7 +6852,8 @@ function isBlockedPath(filePath) {
   return false;
 }
 function containsSecrets(content) {
-  const sample = content.slice(0, 5e3);
+  if (!content) return false;
+  const sample = content.length > 1e6 ? content.slice(0, 1e6) : content;
   return SECRET_CONTENT_PATTERNS.some((pattern) => pattern.test(sample));
 }
 function redactSecrets(text) {
@@ -6875,7 +6877,10 @@ var init_secret_filter = __esm({
       "credentials",
       "credentials.json",
       "service-account.json",
-      "serviceAccountKey.json"
+      "serviceAccountKey.json",
+      ".netrc",
+      ".git-credentials",
+      ".npmrc"
     ];
     BLOCKED_EXTENSIONS = [".pem", ".key", ".p12", ".pfx", ".jks", ".keystore"];
     BLOCKED_DIRS = [".ssh", ".gnupg", ".aws", ".azure", ".gcp", ".kube"];
@@ -6887,12 +6892,18 @@ var init_secret_filter = __esm({
       // GitHub personal access token
       /gho_[A-Za-z0-9]{36}/,
       // GitHub OAuth token
+      /github_pat_[A-Za-z0-9_]{82}/,
+      // GitHub fine-grained PAT
       /sk-[A-Za-z0-9]{32,}/,
       // OpenAI API key
       /sk-ant-[A-Za-z0-9-]{90,}/,
       // Anthropic API key
-      /AIza[A-Za-z0-9_-]{35}/
+      /AIza[A-Za-z0-9_-]{35}/,
       // Google API key
+      /npm_[A-Za-z0-9]{32,36}/,
+      // npm access token
+      /xox[baprs]-[A-Za-z0-9_-]{10,48}/
+      // Slack token
     ];
   }
 });
@@ -118880,7 +118891,7 @@ var require_util5 = __commonJS({
       return url2;
     }
     exports.urlGenerate = urlGenerate;
-    function normalize2(aPath) {
+    function normalize3(aPath) {
       var path16 = aPath;
       var url2 = urlParse(aPath);
       if (url2) {
@@ -118917,7 +118928,7 @@ var require_util5 = __commonJS({
       }
       return path16;
     }
-    exports.normalize = normalize2;
+    exports.normalize = normalize3;
     function join10(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
@@ -118943,7 +118954,7 @@ var require_util5 = __commonJS({
         aRootUrl.host = aPath;
         return urlGenerate(aRootUrl);
       }
-      var joined = aPath.charAt(0) === "/" ? aPath : normalize2(aRoot.replace(/\/+$/, "") + "/" + aPath);
+      var joined = aPath.charAt(0) === "/" ? aPath : normalize3(aRoot.replace(/\/+$/, "") + "/" + aPath);
       if (aRootUrl) {
         aRootUrl.path = joined;
         return urlGenerate(aRootUrl);
@@ -119125,7 +119136,7 @@ var require_util5 = __commonJS({
         }
         sourceURL = join10(urlGenerate(parsed), sourceURL);
       }
-      return normalize2(sourceURL);
+      return normalize3(sourceURL);
     }
     exports.computeSourceURL = computeSourceURL;
   }
@@ -162826,7 +162837,12 @@ function writeCodeBlocks(workDir, blocks) {
   for (const block of blocks) {
     const normalized = path13.normalize(block.filePath);
     if (normalized.startsWith("..") || path13.isAbsolute(normalized)) {
-      process.stderr.write(`[contextos-agent] Skipping unsafe path: ${block.filePath}
+      process.stderr.write(`[contextos-agent] Skipping unsafe path (traversal): ${block.filePath}
+`);
+      continue;
+    }
+    if (isBlockedPath(normalized) || !isPathAllowed(normalized, workDir)) {
+      process.stderr.write(`[contextos-agent] Skipping forbidden/policy-blocked path: ${block.filePath}
 `);
       continue;
     }
@@ -188780,20 +188796,8 @@ function buildContextPrompt(projectRoot, task, options = {}) {
 // src/mcp/tools/contextos.ts
 init_secret_filter();
 init_command_exists();
-var ALLOWED_VERIFY_TOOLS = /* @__PURE__ */ new Set([
-  "npm",
-  "npx",
-  "pnpm",
-  "yarn",
-  "pytest",
-  "python",
-  "python3",
-  "cargo",
-  "go",
-  "vitest",
-  "jest",
-  "node"
-]);
+var ALLOWED_VERIFY_TOOLS = /* @__PURE__ */ new Set(["npm", "npx", "pnpm", "yarn", "pytest", "cargo", "go", "vitest", "jest"]);
+var FORBIDDEN_VERIFY_ARGS = /* @__PURE__ */ new Set(["-e", "-c", "--eval", "--print", "-p", "--input-type"]);
 var STRICT_ENV_ALLOWLIST = /* @__PURE__ */ new Set([
   "PATH",
   "HOME",
@@ -188846,6 +188850,15 @@ async function runWorktreeVerification(worktreePath, command) {
       output: `Security error: Command "${rawTool}" is not in the allowed verification tools whitelist (${Array.from(ALLOWED_VERIFY_TOOLS).join(", ")})`
     };
   }
+  const args = parts.slice(1);
+  for (const arg of args) {
+    if (FORBIDDEN_VERIFY_ARGS.has(arg.toLowerCase())) {
+      return {
+        verified: false,
+        output: `Security error: Argument "${arg}" is not permitted in verify_command`
+      };
+    }
+  }
   const exePath = await resolveExecutablePath(rawTool);
   const targetExecutable = exePath || rawTool;
   return new Promise((resolveResult) => {