sigmap 6.9.0 → 6.10.1

package/AGENTS.md

@@ -56,6 +56,19 @@ Use this marker block for all appendable context files:
 | To query by topic | `sigmap --query "<topic>"` |
 
 Always run `sigmap ask` or `sigmap --query` before searching for files relevant to a task.
+## deps
+```
+src/extractors/python_ast.py ← ast
+```
+
+## changes (last 5 commits — 0 seconds ago)
+```
+src/discovery/language-detector.js            ~detectLanguages
+src/extractors/python.js                      +tryNativeExtract  +extract  ~extract  ~extractDocHint
+src/extractors/python_ast.py                  +annotation_to_str  +format_args  +arguments  +get_decorator_names
+src/extractors/r.js                           +extract  +definitions  +readBalancedParens  +normalizeParams
+```
+
 ## packages
 
 ### packages/cli/index.js
@@ -101,18 +114,6 @@ code-fence js
 code-fence ---
 ```
 
-### packages/core/index.js
-```
-module.exports = { extract, rank, buildSigIndex, scan, score, adapt }
-function _resolveExtractor(language)
-function extract(src, language) → string[]
-function rank(query, sigIndex, opts) → { file: string, score: nu
-function buildSigIndex(cwd) → Map<string, string[]>
-function scan(sigs, filePath) → { safe: string[], redacte
-function score(cwd) → { * score: number, * grad
-function adapt(context, adapterName, opts = {}) → string
-```
-
 ### packages/adapters/copilot.js
 ```
 module.exports = { name, format, outputPath, write }
@@ -172,109 +173,19 @@ function outputPath(cwd) → string
 function write(context, cwd, opts = {})
 ```
 
-## src
-
-### src/extractors/php.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
-```
-
-### src/extractors/prdiff.js
-```
-module.exports = { diffSignatures, extractName }
-function diffSignatures(baseSigs, currentSigs) → {added:string[], removed:
-function extractName(sig)
-```
-
-### src/extractors/python.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractClassMethods(stripped, startIndex)
-function tryExtractDataclassFields(stripped, classIndex)
-function tryExtractBaseModelFields(stripped, bodyStart)
-function extractClassConstants(stripped, startIndex)
-function extractReturnType(sigLine)
-function normalizeParams(params)
-function extractDocHint(src, fnName, fnSigLine)
-```
-
-### src/extractors/ruby.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function normalizeParams(params)
-function extractReturnHint(stripped, index)
-```
-
-### src/extractors/rust.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMethods(block)
-function normalizeParams(params)
-function extractReturnType(afterParen)
-```
-
-### src/extractors/scala.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
-```
-
-### src/extractors/svelte.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function normalizeParams(params)
-function normalizeType(type)
-```
-
-### src/extractors/swift.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function extractArrowType(str)
-```
-
-### src/extractors/todos.js
-```
-module.exports = { extractTodos }
-function extractTodos(src) → {line:number, tag:string,
-```
-
-### src/extractors/vue.js
+### packages/core/index.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
-function normalizeParams(params)
-function normalizeType(type)
+module.exports = { extract, rank, buildSigIndex, scan, score, adapt }
+function _resolveExtractor(language)
+function extract(src, language) → string[]
+function rank(query, sigIndex, opts) → { file: string, score: nu
+function buildSigIndex(cwd) → Map<string, string[]>
+function scan(sigs, filePath) → { safe: string[], redacte
+function score(cwd) → { * score: number, * grad
+function adapt(context, adapterName, opts = {}) → string
 ```
 
-### src/eval/scorer.js
-```
-module.exports = { hitAtK, reciprocalRank, precisionAtK, aggregate, firstRank }
-function firstRank(ranked, expected) → number
-function normalizePath(p) → string
-function hitAtK(ranked, expected, k = 5) → 0|1
-function reciprocalRank(ranked, expected) → number
-function precisionAtK(ranked, expected, k = 5) → number
-function aggregate(results, k = 5) → { * hitAt5: number, // fr
-function round(x)
-```
+## src
 
 ### src/eval/runner.js
 ```
@@ -438,19 +349,6 @@ function detectVersion(cwd)
 function format(context, cwd, writtenFiles, sigmapVersion)
 ```
 
-### src/eval/analyzer.js
-```
-module.exports = { analyzeFiles, formatAnalysisTable, formatAnalysisJSON }
-function isDockerfile(name)
-function getExtractorName(filePath)
-function tokenCount(sigs)
-function hasCoverage(filePath, cwd)
-function loadExtractor(name, cwd)
-function analyzeFiles(files, cwd, opts) → object[]
-function formatAnalysisTable(stats, showSlow) → string
-function formatAnalysisJSON(stats) → object
-```
-
 ### src/format/dashboard.js
 ```
 module.exports = { generateDashboardHtml, renderHistoryCharts, computeExtractorCoverage, percentile, overBudgetStreak }
@@ -593,13 +491,6 @@ function _existsAnywhere(cwd, filename, maxDepth)
 function _walkFind(dir, name, depth)
 ```
 
-### src/discovery/language-detector.js
-```
-module.exports = { detectLanguages }
-function detectLanguages(cwd)
-function _walkDepth(dir, depth, extCount)
-```
-
 ### src/discovery/sigmapignore.js
 ```
 module.exports = { loadIgnorePatterns, matchesIgnorePattern }
@@ -607,11 +498,6 @@ function loadIgnorePatterns(cwd)
 function matchesIgnorePattern(dirName, patterns)
 ```
 
-### src/discovery/source-root-registry.js
-```
-module.exports = { REGISTRY }
-```
-
 ### src/retrieval/ranker.js
 ```
 module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, detectIntent }
@@ -656,6 +542,22 @@ function scoreCandidate(dirName, fullPath, context)
 function _countSourceFiles(dir, depth)
 ```
 
+### src/eval/usefulness-scorer.js
+```
+module.exports = { scoreUsefulness, computeUsefulnessStats }
+function scoreUsefulness(taskResult, rankingScore)
+function computeUsefulnessStats(taskResults)
+```
+
+### src/workspace/detector.js
+```
+module.exports = { detectWorkspaces, inferPackage, scopeToPackage }
+function detectWorkspaces(cwd)
+function inferPackage(query, workspaceDirs, cwd)
+function _getMatchLength(name, token)
+function scopeToPackage(filePath, packageDir)
+```
+
 ### src/discovery/source-root-resolver.js
 ```
 module.exports = { resolveSourceRoots }
@@ -667,6 +569,72 @@ function _dedupeNested(scored)
 function _computeConfidence(frameworks, languages, scoredCount)
 ```
 
+### src/discovery/source-root-registry.js
+```
+module.exports = { REGISTRY }
+```
+
+### src/discovery/language-detector.js
+```
+module.exports = { detectLanguages }
+function detectLanguages(cwd)
+function _walkDepth(dir, depth, extCount)
+```
+
+### src/eval/analyzer.js
+```
+module.exports = { analyzeFiles, formatAnalysisTable, formatAnalysisJSON }
+function isDockerfile(name)
+function getExtractorName(filePath)
+function tokenCount(sigs)
+function hasCoverage(filePath, cwd)
+function loadExtractor(name, cwd)
+function analyzeFiles(files, cwd, opts) → object[]
+function formatAnalysisTable(stats, showSlow) → string
+function formatAnalysisJSON(stats) → object
+```
+
+### src/extractors/python.js
+```
+module.exports = { extract, tryNativeExtract }
+function tryNativeExtract(filePath) → string[]|null
+function extract(src, filePath) → string[]
+function extractClassMethods(stripped, startIndex)
+function tryExtractDataclassFields(stripped, classIndex)
+function tryExtractBaseModelFields(stripped, bodyStart)
+function extractClassConstants(stripped, startIndex)
+function extractReturnType(sigLine)
+function normalizeParams(params)
+function extractDocHint(src, fnName, fnSigLine)
+```
+
+### src/extractors/python_ast.py
+```
+def annotation_to_str(node)  # Convert an AST annotation node to a string representation
+def format_args(args_node)  # Format a function arguments node into a compact signature st
+def get_decorator_names(node)  # Return a list of decorator name strings for a function/class
+def is_dataclass(node)
+def is_basemodel(bases)  # Check if class bases include BaseModel or BaseSettings
+def is_optional_annotation(annotation)  # Check if an annotation represents an Optional type
+def get_docstring_hint(node)  # Extract first sentence of docstring, if present
+def extract_dataclass_fields(class_node)  # Return a collapsed fields string for a @dataclass class
+def extract_basemodel_fields(class_node)  # Return a compact {required*, optional
+def extract_class_constants(class_node)  # Yield ALL_CAPS constant assignments from class body
+def extract_method_sig(func_node)  # Format a method signature string (already indented by caller
+def extract_function_sig(func_node, src_lines)  # Format a top-level function signature string
+def extract_fastapi_routes(tree, src_lines)  # Extract FastAPI route signatures from top-level decorated fu
+def extract(filepath)
+def main()
+```
+
+### src/extractors/r.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function readBalancedParens(src, openIdx, cap = 4096)
+function normalizeParams(raw)
+```
+
 ### src/mcp/server.js
 ```
 module.exports = { start }

package/CHANGELOG.md

@@ -10,6 +10,30 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [6.10.1] — 2026-05-10
+
+### Added
+
+- **R language support (Phase 1)** — Extract function signatures from `.r` and `.R` files with support for function definitions (`<-`, `=`, `<<-` forms), multi-line arguments with string-literal protection, S4 patterns (setGeneric, setMethod, setClass), and private function filtering. Shiny framework detection via `app.R`/`ui.R`/`server.R` triplet.
+- **Native Python AST extractor** — Fallback to `python_ast.py` using `ast.parse()` for accurate extraction of complex signatures (multiline args, stacked decorators, complex generics). Preserves regex fallback for Python 2 / no-Python3 environments. Zero breaking changes to output format.
+
+### Fixed
+
+- **ReferenceError in `--query`** — Fixed variable scope issue where `adpIdx` was undefined when no context file present. Moved variable declaration to proper scope before conditional block.
+- **Windows path handling** — Normalized path separators in nested path deduplication. Windows backslashes no longer cause false negatives when matching nested source roots.
+- **.contextignore patterns** — Fixed bracket character classes (`[Bb]in/`) being treated as literals. Fixed trailing slashes on directory patterns not matching nested paths. Added error handling for malformed bracket syntax.
+- **Claude adapter in per-module and hot-cold strategies** — Fixed adapter not being written to output in per-module and hot-cold context strategies.
+
+---
+
+## [6.10.0] — 2026-05-05
+
+### Added
+
+- **Workspace-scoped retrieval for monorepos** — New `src/workspace/detector.js` module detects workspace packages from `package.json` workspaces field (npm array and Yarn v2 `packages` format). Automatically infers target package from query tokens (e.g., "rate limiting payments" → `packages/payments/`). Flags `--package <name>` (explicit) and `--global` (disable scoping) control retrieval scope. Files inside inferred package receive +0.30 score boost for tighter context.
+
+---
+
 ## [6.9.0] — 2026-05-03
 
 ### Added

package/README.md

@@ -12,7 +12,8 @@
 [![Zero deps](https://img.shields.io/badge/dependencies-zero-22c55e)](package.json)
 [![License: MIT](https://img.shields.io/badge/License-MIT-7c6af7.svg)](LICENSE)
 [![GitHub Stars](https://img.shields.io/github/stars/manojmallick/sigmap?style=flat&color=f59e0b&logo=github)](https://github.com/manojmallick/sigmap/stargazers)
-[![Hacker News](https://img.shields.io/badge/Hacker%20News-Discussion-orange?logo=ycombinator)](https://news.ycombinator.com/item?id=47956790)
+[![Star History Chart](https://api.star-history.com/svg?repos=manojmallick/sigmap&type=Date)](https://star-history.com/#manojmallick/sigmap&Date)
+[![Discover on ShyPD](https://img.shields.io/badge/ShyPD-Discover-7c6af7?logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgdmlld0JveD0iMCAwIDE2IDE2Ij48Y2lyY2xlIGN4PSI4IiBjeT0iOCIgcj0iOCIgZmlsbD0id2hpdGUiLz48L3N2Zz4=&logoColor=7c6af7)](https://shypd.ai/tools/sigmap)
 
 </div>
 
@@ -20,9 +21,11 @@
 
 ## Try it now
 
+**No install required.** Run instantly on any machine:
+
 ```bash
 npx sigmap
-sigmap ask "Where is auth handled?"
+npx sigmap ask "Where is auth handled?"
 ```
 
 Zero config. Zero dependencies. Under 10 seconds.
@@ -76,8 +79,8 @@ Ask → Rank → Context → Validate → Judge → Learn
 ## Benchmark
 
 ```
-Benchmark : sigmap-v6.8-main
-Date      : 2026-04-30
+Benchmark : sigmap-v6.10-main
+Date      : 2026-05-05
 
 Hit@5          : 80.0%   (baseline 13.6%  — 5.9× lift)
 Prompt reduction : 41.0%
@@ -228,6 +231,20 @@ If SigMap saves you context or API spend, a ⭐ on [GitHub](https://github.com/m
 
 ---
 
+## Contributing
+
+SigMap welcomes contributions! 
+
+**Before submitting a PR:**
+1. Read [CONTRIBUTING.md](CONTRIBUTING.md)
+2. Check [Discussions → Announcements](../../discussions) for workflow setup
+3. Target the `develop` branch (not main)
+4. Follow the [contributor checklist](.github/CONTRIBUTOR_CHECKLIST.txt)
+
+See [.github/PULL_REQUEST_TEMPLATE.md](.github/PULL_REQUEST_TEMPLATE.md) for the PR checklist. All contributors are credited in the CHANGELOG and release notes.
+
+---
+
 ## Why not embeddings?
 
 | | Embeddings | SigMap |

package/gen-context.js

@@ -5387,7 +5387,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '6.9.0',
+  version: '6.10.1',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -6855,6 +6855,76 @@ __factories["./src/eval/runner"] = function(module, exports) {
   module.exports = { run, rank, loadTasks, buildSigIndex, formatTable, formatMetrics, tokenize };
 };
 
+// ── ./src/eval/usefulness-scorer ──
+__factories["./src/eval/usefulness-scorer"] = function(module, exports) {
+  'use strict';
+
+  /**
+   * Score answer usefulness based on:
+   * 1. Whether right file was retrieved (retrieval hit)
+   * 2. Whether retrieved context covered the answer (coverage)
+   * 3. Confidence in answer quality (from ranking score)
+   */
+  function scoreUsefulness(taskResult, rankingScore) {
+    const { hitRank } = taskResult;
+
+    // Tier 1: File not retrieved — context cannot be useful
+    if (hitRank === -1 || hitRank > 5) {
+      return {
+        tier: 'not-useful',
+        score: 0.0,
+        reason: 'expected file not in top 5'
+      };
+    }
+
+    // Tier 2: File retrieved but not top ranking — partially useful
+    if (hitRank > 1) {
+      return {
+        tier: 'partially-useful',
+        score: rankingScore * 0.5,  // Partial usefulness
+        reason: `file ranked #${hitRank}`
+      };
+    }
+
+    // Tier 3: File at top of ranking — fully useful
+    return {
+      tier: 'fully-useful',
+      score: rankingScore,  // Full usefulness
+      reason: 'file ranked first'
+    };
+  }
+
+  function computeUsefulnessStats(taskResults) {
+    const tiers = {
+      'fully-useful': 0,
+      'partially-useful': 0,
+      'not-useful': 0
+    };
+
+    let totalScore = 0;
+    let count = 0;
+
+    taskResults.forEach(result => {
+      const usefulness = scoreUsefulness(result, result.rankingScore || 1.0);
+      tiers[usefulness.tier]++;
+      totalScore += usefulness.score;
+      count++;
+    });
+
+    return {
+      fully_useful: tiers['fully-useful'],
+      partially_useful: tiers['partially-useful'],
+      not_useful: tiers['not-useful'],
+      fully_useful_pct: count > 0 ? (tiers['fully-useful'] / count * 100).toFixed(1) : 0,
+      partially_useful_pct: count > 0 ? (tiers['partially-useful'] / count * 100).toFixed(1) : 0,
+      not_useful_pct: count > 0 ? (tiers['not-useful'] / count * 100).toFixed(1) : 0,
+      average_usefulness_score: count > 0 ? (totalScore / count).toFixed(3) : 0
+    };
+  }
+
+  module.exports = { scoreUsefulness, computeUsefulnessStats };
+};
+
 
 // ── ./packages/adapters/copilot (bundled) ──
 __factories["./packages/adapters/copilot"] = function(module, exports) {
@@ -7843,6 +7913,95 @@ __factories["./src/discovery/source-root-resolver"] = function(module, exports)
   module.exports = { resolveSourceRoots };
 };
 
+// ── ./src/workspace/detector ──
+__factories["./src/workspace/detector"] = function(module, exports) {
+  'use strict';
+  const fs   = require('fs');
+  const path = require('path');
+  module.exports = { detectWorkspaces, inferPackage, scopeToPackage };
+
+  function detectWorkspaces(cwd) {
+    const pkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgPath)) return [];
+
+    let pkg;
+    try {
+      pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    } catch {
+      return [];
+    }
+
+    const patterns = pkg.workspaces || [];
+    const dirs = [];
+
+    // Handle both flat array and object with packages field (Yarn v2 format)
+    const patternArray = Array.isArray(patterns) ? patterns : (patterns.packages || []);
+
+    for (const p of patternArray) {
+      const base = p.replace(/\/\*\*?$/, '');
+      const resolved = path.join(cwd, base);
+      if (fs.existsSync(resolved)) {
+        try {
+          for (const entry of fs.readdirSync(resolved, { withFileTypes: true })) {
+            if (entry.isDirectory()) dirs.push(path.join(resolved, entry.name));
+          }
+        } catch (_) {}
+      }
+    }
+
+    return dirs;
+  }
+
+  // Infer package from query tokens: "add rate limiting to payments" → "packages/payments"
+  function inferPackage(query, workspaceDirs, cwd) {
+    const tokens = query.toLowerCase().split(/\W+/).filter(t => t.length > 2);
+
+    // Find longest matching package name
+    let bestMatch = null;
+    let bestLen = 0;
+    let bestMatchLen = 0;
+
+    for (const dir of workspaceDirs) {
+      const name = path.basename(dir).toLowerCase();
+      for (const token of tokens) {
+        const matchLen = _getMatchLength(name, token);
+        // Only consider matches; use longest match, and break ties by longest package name
+        if (matchLen > 0 && (matchLen > bestLen || (matchLen === bestLen && name.length > bestMatchLen))) {
+          bestMatch = dir;
+          bestLen = matchLen;
+          bestMatchLen = name.length;
+        }
+      }
+    }
+
+    return bestMatch;
+  }
+
+  function _getMatchLength(name, token) {
+    if (name === token) return 1000 + name.length;  // Exact match is best
+    if (name.startsWith(token) && token.length >= 3) return 100 + token.length;
+    if (token.startsWith(name) && name.length >= 3) return name.length;
+    return 0;
+  }
+
+  // Return boost multiplier for files inside the inferred package
+  function scopeToPackage(filePath, packageDir) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const normalizedPkg = packageDir.replace(/\\/g, '/');
+
+    // Ensure we match the directory boundary, not just a prefix
+    // e.g., packages/payment should not match packages/payment-old
+    if (normalized.startsWith(normalizedPkg)) {
+      const afterPrefix = normalized.slice(normalizedPkg.length);
+      // Check if next char is / or if it's the exact match
+      if (afterPrefix === '' || afterPrefix[0] === '/') {
+        return 0.30;
+      }
+    }
+    return 0;
+  }
+};
+
 /**
  * SigMap — gen-context.js v1.2.0
  * Zero-dependency AI context engine.
@@ -7855,7 +8014,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.9.0';
+const VERSION = '6.10.1';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -7935,14 +8094,22 @@ function loadIgnorePatterns(cwd) {
 function matchesIgnore(relPath, patterns) {
   for (const pat of patterns) {
     const normalized = pat.replace(/\\/g, '/');
-    // Simple glob: support * and ** and trailing /
-    const regexStr = normalized
-      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    // Strip trailing slash (gitignore style — directory patterns)
+    const patternToUse = normalized.endsWith('/')
+      ? normalized.slice(0, -1)
+      : normalized;
+    // Escape regex special chars but NOT brackets (keep them for character classes)
+    const regexStr = patternToUse
+      .replace(/[.+^${}()|\\]/g, '\\$&')
       .replace(/\*\*/g, '___DOUBLE___')
       .replace(/\*/g, '[^/]*')
       .replace(/___DOUBLE___/g, '.*');
-    const regex = new RegExp(`(^|/)${regexStr}($|/)`);
-    if (regex.test(relPath)) return true;
+    try {
+      const regex = new RegExp(`(^|/)${regexStr}($|/)`);
+      if (regex.test(relPath)) return true;
+    } catch (_) {
+      // Malformed bracket syntax or invalid regex — skip this pattern
+    }
   }
   return false;
 }
@@ -8870,7 +9037,7 @@ function runPerModuleStrategy(cwd, config, fileEntries, inputTokenTotal) {
   overviewLines.push('> Inject the relevant module file into your IDE context window.');
   overviewLines.push('> For cross-module questions load both files.');
   const overviewContent = overviewLines.join('\n') + '\n';
-  const primaryTargets = (config.outputs || ['copilot']).filter((t) => t !== 'claude');
+  const primaryTargets = config.outputs || ['copilot'];
   writeOutputs(overviewContent, primaryTargets, cwd, config);
 
   const overviewTokens = estimateTokens(overviewContent);
@@ -8889,7 +9056,7 @@ function runHotColdStrategy(cwd, config, fileEntries, recentFiles, inputTokenTot
   const hotContent = hotEntries.length > 0
     ? formatOutput(hotEntries, cwd, false, config, null)
     : '<!-- Generated by SigMap — no recently changed files -->\n';
-  const primaryTargets = (config.outputs || ['copilot']).filter((t) => t !== 'claude');
+  const primaryTargets = config.outputs || ['copilot'];
   writeOutputs(hotContent, primaryTargets, cwd, config);
   const hotTokens = estimateTokens(hotContent);
 
@@ -9919,6 +10086,7 @@ function main() {
     const { detectIntent, buildSigIndex, rank } = requireSourceOrBundled('./src/retrieval/ranker');
     const { coverageScore } = requireSourceOrBundled('./src/analysis/coverage-score');
     const { loadSession, saveSession, mergeSessionContext } = requireSourceOrBundled('./src/session/memory');
+    const { detectWorkspaces, inferPackage, scopeToPackage } = requireSourceOrBundled('./src/workspace/detector');
 
     const intent = detectIntent(query);
     const intentWeights = getIntentWeights(intent);
@@ -9931,6 +10099,34 @@ function main() {
 
     let ranked = rank(query, sigIndex, { topK: 5, weights: intentWeights, cwd });
 
+    // v6.10: Workspace scoping — infer package from query and apply boost
+    const workspaces = detectWorkspaces(cwd);
+    const packageFlag = args[args.indexOf('--package') + 1];
+    const globalFlag = args.includes('--global');
+
+    let inferredPackage = null;
+    if (!globalFlag && workspaces.length > 0) {
+      if (packageFlag) {
+        inferredPackage = workspaces.find(d => path.basename(d) === packageFlag) || null;
+        if (!packageFlag || !inferredPackage) {
+          process.stderr.write(`[sigmap] ⚠  package "${packageFlag}" not found — searching entire repo\n`);
+        }
+      } else {
+        inferredPackage = inferPackage(query, workspaces, cwd);
+      }
+    }
+
+    if (inferredPackage) {
+      ranked = ranked.map(r => ({
+        ...r,
+        score: r.score + scopeToPackage(r.file, inferredPackage),
+      })).sort((a, b) => b.score - a.score);
+
+      if (!args.includes('--json') && !globalFlag) {
+        process.stderr.write(`[sigmap] 📦 package scope: ${path.relative(cwd, inferredPackage)}\n`);
+      }
+    }
+
     // v6.8: --followup support — carry session context forward
     const isFollowup = args.includes('--followup');
     const session = isFollowup ? loadSession(cwd) : null;
@@ -10994,6 +11190,7 @@ function main() {
       // Priority: --output flag > --adapter flag > buildSigIndex probe order
       //   (customOutput from config is handled inside buildSigIndex itself)
       let queryOpts;
+      const adpIdx = args.indexOf('--adapter');
 
       // 1. --output <file> pins to an explicit path
       if (config.customOutput) {
@@ -11001,17 +11198,14 @@ function main() {
       }
 
       // 2. --adapter <name> pins to that adapter's output path (if --output not given)
-      if (!queryOpts) {
-        const adpIdx = args.indexOf('--adapter');
-        if (adpIdx >= 0) {
-          const adapterName = (args[adpIdx + 1] || '').trim().toLowerCase();
-          const VALID_ADAPTERS = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini', 'codex'];
-          if (VALID_ADAPTERS.includes(adapterName)) {
-            try {
-              const adapterMod = __require('./packages/adapters/' + adapterName);
-              queryOpts = { contextPath: adapterMod.outputPath(cwd) };
-            } catch (_) {}
-          }
+      if (!queryOpts && adpIdx >= 0) {
+        const adapterName = (args[adpIdx + 1] || '').trim().toLowerCase();
+        const VALID_ADAPTERS = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini', 'codex'];
+        if (VALID_ADAPTERS.includes(adapterName)) {
+          try {
+            const adapterMod = __require('./packages/adapters/' + adapterName);
+            queryOpts = { contextPath: adapterMod.outputPath(cwd) };
+          } catch (_) {}
         }
       }