@praneeth_54/agentdoctor 3.0.0 → 3.0.2

package/dist/cli/commands/chat.js

@@ -3,7 +3,7 @@ import { stdin as input, stdout as output } from "node:process";
 import { ChatService, formatChatResponseForCli } from "../../agent/chat/index.js";
 import { MockModelProvider, createModelProvider, loadAiConfig } from "../../ai/index.js";
 import { EXIT_CODES } from "../../types/index.js";
-import { resolveRepoRoot } from "../../utils/path.js";
+import { resolveCliProjectRoot } from "../safe-root.js";
 import { colors } from "../../utils/colors.js";
 function printBanner(options) {
     const lines = [
@@ -51,7 +51,12 @@ function printHelp() {
     ].join("\n"));
 }
 export async function runAskCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
     const chat = new ChatService({
         root,
@@ -78,7 +83,12 @@ export async function runAskCommand(options) {
     }
 }
 export async function runChatCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
     const chat = new ChatService({
         root,

package/dist/cli/commands/complete.js

@@ -1,5 +1,5 @@
 import { EXIT_CODES } from "../../types/index.js";
-import { resolveRepoRoot } from "../../utils/path.js";
+import { resolveCliProjectRoot } from "../safe-root.js";
 import { runProjectInit } from "../../core/brain-product/init.js";
 import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
 import { analyzeGitIntelligence, deadCodeCategory } from "../../intelligence/git/analyze.js";
@@ -14,7 +14,12 @@ function printJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
 export async function runInitCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const result = await runProjectInit(root, {
         ...(options.name ? { projectName: options.name } : {}),
         ...(options.domain ? { businessDomain: options.domain } : {}),
@@ -27,7 +32,12 @@ export async function runInitCommand(options) {
     return EXIT_CODES.SUCCESS;
 }
 export async function runV2SurfaceCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     try {
         switch (options.action) {
             case "graph-ast": {

package/dist/cli/commands/fix.js

@@ -6,6 +6,7 @@ import { buildFixPlan } from "../../core/fix/plan.js";
 import { renderFixPlanTerminal } from "../../core/fix/render.js";
 import { runFix } from "../../core/fix/run.js";
 import { scan } from "../../core/scanner/scan.js";
+import { classifyBroadUserScanRoot } from "../../product/discovery/roots.js";
 import { colors } from "../../utils/colors.js";
 /**
  * Safe Repository Mutation — apply allowlisted agent-config exclusions.
@@ -16,6 +17,11 @@ export async function runFixCommand(options) {
         console.error(`Error: not a directory: ${target}`);
         return EXIT_CODES.USAGE_ERROR;
     }
+    const broad = classifyBroadUserScanRoot(target);
+    if (broad.blocked) {
+        console.error(`Error: ${broad.reason}`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
     const dryRun = options.dryRun === true;
     const yes = options.yes === true;
     try {

package/dist/cli/commands/learn.js

@@ -2,9 +2,14 @@ import { MockModelProvider, createModelProvider, loadAiConfig } from "../../ai/i
 import { StudentService } from "../../agent/student.js";
 import { parseAgentMode, defaultStudentMode } from "../../agent/modes.js";
 import { EXIT_CODES } from "../../types/index.js";
-import { resolveRepoRoot } from "../../utils/path.js";
+import { resolveCliProjectRoot } from "../safe-root.js";
 export async function runLearnCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const mode = parseAgentMode(options.mode) ?? defaultStudentMode();
     const provider = options.useMock ? new MockModelProvider() : createModelProvider(loadAiConfig());
     const resolvedMode = options.build

package/dist/cli/commands/mcp.js

@@ -1,13 +1,17 @@
 import { EXIT_CODES } from "../../types/index.js";
-import { resolveRepoRoot } from "../../utils/path.js";
+import { resolveCliProjectRoot } from "../safe-root.js";
 import { runAgentDoctorMcpStdio } from "../../mcp/agentdoctor/server.js";
 /**
  * Start combined AgentDoctor MCP (Brain tools + intelligence tools) over STDIO.
  */
 export async function runMcpCommand(options) {
-    const root = resolveRepoRoot(options.root);
+    const gated = await resolveCliProjectRoot(options.root);
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
     await runAgentDoctorMcpStdio({
-        root,
+        root: gated.root,
         buildIfMissing: options.buildIfMissing !== false,
     });
     return EXIT_CODES.SUCCESS;

package/dist/cli/commands/platform.js

@@ -1,13 +1,18 @@
 import { randomUUID } from "node:crypto";
 import { EXIT_CODES } from "../../types/index.js";
-import { resolveRepoRoot } from "../../utils/path.js";
+import { resolveCliProjectRoot } from "../safe-root.js";
 import { analyzeRenameImpact, analyzeTestImpact, appendSessionEvent, buildProvenance, compareCommits, createSession, endSession, evaluateAgentAction, exportSessionMarkdown, formatTestImpactHuman, listSessions, loadSession, persistTestImpactReport, planContext, runPlatformScan, saveProvenance, EVALUATE_ONLY, } from "../../platform/index.js";
 import { buildRepositoryGraph } from "../../platform/graph/build.js";
 function printJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
 export async function runPlatformCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     try {
         switch (options.action) {
             case "scan": {

package/dist/cli/commands/policy-graph-run.js

@@ -3,6 +3,7 @@ import { runControlledCommand } from "../../enforcement/runner.js";
 import { graphBuild, graphRebuild, graphStatus, graphUpdate, } from "../../intelligence/graph/incremental.js";
 import { buildIntelligenceGraph } from "../../intelligence/graph/build.js";
 import { EXIT_CODES } from "../../types/index.js";
+import { resolveCliProjectRoot } from "../safe-root.js";
 function emit(json, value, human) {
     if (json) {
         process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
@@ -13,6 +14,12 @@ function emit(json, value, human) {
 }
 export async function runGraphSurfaceCommand(options) {
     try {
+        const gated = await resolveCliProjectRoot(options.root);
+        if (!gated.ok) {
+            console.error(`Error: ${gated.message}`);
+            return gated.code;
+        }
+        options = { ...options, root: gated.root };
         const mode = options.mode ?? "auto";
         if (options.action === "status") {
             const status = await graphStatus({ root: options.root });

package/dist/cli/commands/product.js

@@ -1,5 +1,5 @@
 import { EXIT_CODES } from "../../types/index.js";
-import { resolveRepoRoot } from "../../utils/path.js";
+import { resolveCliProjectRoot } from "../safe-root.js";
 import { resolveTargetArgument } from "./scan.js";
 import { traceRequirements, analyzeApiSurface, analyzeDatabaseSchema, analyzeEvents, analyzeDependencies, analyzeCodeHealth, buildSoftwareMap, analyzeWhatIf, loadDecisionLedger, runForensicAnalysis, buildSoftwareDigitalTwin, runEvalLab, diagnoseAgentDoctorSelf, analyzeInfra, buildIncidentHypotheses, readChangeLedger, analyzeSecuritySurface, analyzePrivacySurface, searchSymbolsAndConcepts, buildTechnicalDebtRoadmap, analyzeFeatureIntelligence, buildSoftwareEvolutionTimeline, queryMemory, loadOrganizationModel, analyzeTestBrain, } from "../../product/index.js";
 import { runRoleAgent } from "../../agent/roles.js";
@@ -7,7 +7,12 @@ function printJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
 export async function runProductCommand(options) {
-    const root = resolveRepoRoot(options.root ?? resolveTargetArgument(undefined));
+    const gated = await resolveCliProjectRoot(options.root ?? resolveTargetArgument(undefined));
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     try {
         let payload;
         switch (options.action) {
@@ -137,7 +142,12 @@ export async function runProductCommand(options) {
     }
 }
 export async function runChangeLedgerListCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root);
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const payload = await readChangeLedger(root);
     if (options.json)
         printJson(payload);

package/dist/cli/commands/scan.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { evaluateScanPolicy } from "../../core/policy/evaluate.js";
 import { scan } from "../../core/scanner/scan.js";
+import { classifyBroadUserScanRoot } from "../../product/discovery/roots.js";
 import { emitGithubReports } from "../../reporters/github/emit.js";
 import { renderJsonReport } from "../../reporters/json/report.js";
 import { renderTerminalReport } from "../../reporters/terminal/report.js";
@@ -13,6 +14,11 @@ export async function runScanCommand(options) {
         console.error(`Error: not a directory: ${target}`);
         return EXIT_CODES.USAGE_ERROR;
     }
+    const broad = classifyBroadUserScanRoot(target);
+    if (broad.blocked) {
+        console.error(`Error: ${broad.reason}`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
     try {
         const result = await scan({
             cwd: target,

package/dist/cli/commands/start.js

@@ -2,15 +2,21 @@ import { EXIT_CODES } from "../../types/index.js";
 import { initBrainStore, rebuildBrain, getBrainStatus } from "../../core/brain-cli/service.js";
 import { discoverProjectRoots } from "../../product/discovery/roots.js";
 import { buildProjectDna, persistProjectDna } from "../../product/dna/build.js";
-import { resolveRepoRoot } from "../../utils/path.js";
+import { resolveCliProjectRoot } from "../safe-root.js";
 function printJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
 export async function runStartCommand(options) {
     const prefer = options.select ?? options.root;
+    // Fail closed before discovery walks anything (home/Desktop refusal must be instant).
+    const gated = await resolveCliProjectRoot(prefer);
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
     const discovery = await discoverProjectRoots({
-        cwd: prefer ? resolveRepoRoot(prefer) : process.cwd(),
-        ...(prefer ? { prefer: resolveRepoRoot(prefer) } : {}),
+        cwd: gated.root,
+        prefer: gated.root,
         ...(options.maxEntries !== undefined ? { maxEntries: options.maxEntries } : {}),
         autoSelect: !options.listOnly,
     });
@@ -25,13 +31,16 @@ export async function runStartCommand(options) {
         }
         process.stdout.write("Project candidates:\n");
         if (discovery.candidates.length === 0) {
-            process.stdout.write("  (none found — navigate into a project or pass a path)\n");
+            process.stdout.write(`  (none found under ${gated.root})\n`);
+            process.stdout.write("  Tip: open a project directory that contains source code or a manifest (package.json, composer.json, pyproject.toml, .git, …),\n");
+            process.stdout.write(`  or run: agentdoctor start ${gated.root}\n`);
+            process.stdout.write("  Related: agentdoctor dna .   # inspect what DNA sees in this folder\n");
             return EXIT_CODES.USAGE_ERROR;
         }
         for (const [i, c] of discovery.candidates.entries()) {
             process.stdout.write(`  [${i + 1}] ${c.root}\n      score=${c.score} markers=${c.markers.join(", ")} (${c.reason})\n`);
         }
-        process.stdout.write("\nRe-run with --select <path> to initialize that project.\n");
+        process.stdout.write("\nMultiple projects detected — re-run with --select <path> (or pass an explicit path).\n");
         return EXIT_CODES.SUCCESS;
     }
     const root = discovery.selected.root;
@@ -49,8 +58,9 @@ export async function runStartCommand(options) {
         printJson(payload);
     }
     else {
+        process.stdout.write(`✓ Project detected: ${dna.name}\n`);
+        process.stdout.write(`  Root: ${root}\n`);
         process.stdout.write(`AgentDoctor start\n`);
-        process.stdout.write(`  root: ${root}\n`);
         process.stdout.write(`  fingerprint: ${dna.fingerprint}\n`);
         process.stdout.write(`  type: ${dna.projectType}\n`);
         process.stdout.write(`  languages: ${dna.languages.join(", ") || "(none)"}\n`);
@@ -64,7 +74,12 @@ export async function runStartCommand(options) {
     return EXIT_CODES.SUCCESS;
 }
 export async function runDnaCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root);
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const dna = options.persist ? await persistProjectDna(root) : await buildProjectDna(root);
     if (options.json) {
         printJson(dna);

package/dist/cli/commands/v2.js

@@ -1,5 +1,5 @@
 import { EXIT_CODES } from "../../types/index.js";
-import { resolveRepoRoot } from "../../utils/path.js";
+import { resolveCliProjectRoot } from "../safe-root.js";
 import { analyzeChanges } from "../../core/changes/analyze.js";
 import { analyzeContextHealth } from "../../core/context-health/analyze.js";
 import { scanSecrets } from "../../core/secrets/scan.js";
@@ -16,7 +16,12 @@ function printJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
 export async function runChangesCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const report = await analyzeChanges({
         root,
         ...(options.since ? { since: options.since } : {}),
@@ -38,7 +43,12 @@ export async function runChangesCommand(options) {
     return EXIT_CODES.SUCCESS;
 }
 export async function runContextHealthCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const report = await analyzeContextHealth(root);
     if (options.json)
         printJson(report);
@@ -51,7 +61,12 @@ export async function runContextHealthCommand(options) {
     return EXIT_CODES.SUCCESS;
 }
 export async function runSecretsCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const report = await scanSecrets({ root, enabled: true });
     if (options.json)
         printJson(report);
@@ -67,8 +82,13 @@ export async function runSecretsCommand(options) {
 }
 export async function runFixUndoCommand(options) {
     try {
+        const gated = await resolveCliProjectRoot(options.root);
+        if (!gated.ok) {
+            console.error(`Error: ${gated.message}`);
+            return gated.code;
+        }
         const record = await undoFix({
-            root: resolveRepoRoot(options.root ?? process.cwd()),
+            root: gated.root,
             auditId: options.auditId,
         });
         process.stdout.write(`Undid Safe Fix audit ${options.auditId} → undo audit ${record.id}\n`);
@@ -80,7 +100,12 @@ export async function runFixUndoCommand(options) {
     }
 }
 export async function runFixHistoryCommand(options) {
-    const audits = await listFixAudits(resolveRepoRoot(options.root ?? process.cwd()));
+    const gated = await resolveCliProjectRoot(options.root);
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const audits = await listFixAudits(gated.root);
     if (options.json)
         printJson({ audits });
     else if (audits.length === 0)
@@ -93,7 +118,12 @@ export async function runFixHistoryCommand(options) {
     return EXIT_CODES.SUCCESS;
 }
 export async function runBaselineCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     try {
         if (options.action === "list") {
             const names = await listNamedBaselines(root);
@@ -167,7 +197,12 @@ export async function runBaselineCommand(options) {
     }
 }
 export async function runPackagesCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root ?? process.cwd());
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const mono = await detectMonorepo(root);
     if (!options.scan) {
         if (options.json)
@@ -200,8 +235,13 @@ export async function runPackagesCommand(options) {
     return EXIT_CODES.SUCCESS;
 }
 export async function runPrReviewCommand(options) {
+    const gated = await resolveCliProjectRoot(options.root);
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
     const report = await analyzePullRequest({
-        root: resolveRepoRoot(options.root ?? process.cwd()),
+        root: gated.root,
         dryRun: true,
         ...(options.base ? { baseRef: options.base } : {}),
     });
@@ -215,8 +255,13 @@ export async function runPrReviewCommand(options) {
 }
 export async function runDashboardCommand(options) {
     try {
+        const gated = await resolveCliProjectRoot(options.root);
+        if (!gated.ok) {
+            console.error(`Error: ${gated.message}`);
+            return gated.code;
+        }
         const server = await startDashboardServer({
-            root: resolveRepoRoot(options.root ?? process.cwd()),
+            root: gated.root,
             host: options.host ?? "127.0.0.1",
             port: options.port ?? 8787,
             readOnly: true,
@@ -237,7 +282,12 @@ export async function runDashboardCommand(options) {
     }
 }
 export async function runPluginsCommand(options) {
-    const root = resolveRepoRoot(options.root ?? process.cwd());
+    const gated = await resolveCliProjectRoot(options.root);
+    if (!gated.ok) {
+        console.error(`Error: ${gated.message}`);
+        return gated.code;
+    }
+    const root = gated.root;
     const plugins = await discoverPlugins(root);
     const analyzerResults = options.run ? await runPluginAnalyzers(root) : undefined;
     if (options.json) {

package/dist/cli/commands/verify.js

@@ -1,5 +1,6 @@
 import { evaluateVerifyPolicy } from "../../core/policy/evaluate.js";
 import { verify } from "../../core/verify/verify.js";
+import { classifyBroadUserScanRoot } from "../../product/discovery/roots.js";
 import { emitGithubReports } from "../../reporters/github/emit.js";
 import { renderVerifyJsonReport } from "../../reporters/verify/json.js";
 import { renderVerifyTerminalReport } from "../../reporters/verify/terminal.js";
@@ -15,6 +16,11 @@ export async function runVerifyCommand(options) {
         console.error(`Error: not a directory: ${target}`);
         return EXIT_CODES.USAGE_ERROR;
     }
+    const broad = classifyBroadUserScanRoot(target);
+    if (broad.blocked) {
+        console.error(`Error: ${broad.reason}`);
+        return EXIT_CODES.USAGE_ERROR;
+    }
     try {
         const result = await verify({
             cwd: target,

package/dist/cli/safe-root.d.ts

@@ -0,0 +1,17 @@
+import { type ExitCode } from "../types/index.js";
+export type CliRootOk = {
+    ok: true;
+    root: string;
+};
+export type CliRootErr = {
+    ok: false;
+    message: string;
+    code: ExitCode;
+};
+/**
+ * Resolve a CLI project root and refuse home / Desktop / Downloads / Documents
+ * (and similarly broad user folders) before any recursive intelligence work.
+ */
+export declare function resolveCliProjectRoot(pathArg?: string): Promise<CliRootOk | CliRootErr>;
+/** Sync variant when the path is already known to exist (tests / internal). */
+export declare function assertCliProjectRootSync(pathArg?: string): CliRootOk | CliRootErr;

package/dist/cli/safe-root.js

@@ -0,0 +1,32 @@
+import { classifyBroadUserScanRoot } from "../product/discovery/roots.js";
+import { EXIT_CODES } from "../types/index.js";
+import { isDirectory } from "../utils/fs.js";
+import { resolveRepoRoot } from "../utils/path.js";
+/**
+ * Resolve a CLI project root and refuse home / Desktop / Downloads / Documents
+ * (and similarly broad user folders) before any recursive intelligence work.
+ */
+export async function resolveCliProjectRoot(pathArg) {
+    const root = resolveRepoRoot(pathArg ?? process.cwd());
+    if (!(await isDirectory(root))) {
+        return {
+            ok: false,
+            message: `not a directory: ${root}`,
+            code: EXIT_CODES.USAGE_ERROR,
+        };
+    }
+    const broad = classifyBroadUserScanRoot(root);
+    if (broad.blocked) {
+        return { ok: false, message: broad.reason, code: EXIT_CODES.USAGE_ERROR };
+    }
+    return { ok: true, root };
+}
+/** Sync variant when the path is already known to exist (tests / internal). */
+export function assertCliProjectRootSync(pathArg) {
+    const root = resolveRepoRoot(pathArg ?? process.cwd());
+    const broad = classifyBroadUserScanRoot(root);
+    if (broad.blocked) {
+        return { ok: false, message: broad.reason, code: EXIT_CODES.USAGE_ERROR };
+    }
+    return { ok: true, root };
+}

package/dist/constants.d.ts

@@ -1,5 +1,5 @@
 import type { AgentId } from "./types/index.js";
-export declare const PACKAGE_VERSION = "3.0.0";
+export declare const PACKAGE_VERSION = "3.0.2";
 export declare const DEFAULT_MAX_FILE_SIZE_BYTES: number;
 /** Directories skipped during normal discovery (unless a rule needs them later). */
 export declare const DEFAULT_IGNORE_DIRECTORIES: Set<string>;

package/dist/constants.js

@@ -1,4 +1,4 @@
-export const PACKAGE_VERSION = "3.0.0";
+export const PACKAGE_VERSION = "3.0.2";
 export const DEFAULT_MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024; // 2 MiB
 /** Directories skipped during normal discovery (unless a rule needs them later). */
 export const DEFAULT_IGNORE_DIRECTORIES = new Set([

package/dist/core/brain-cli/service.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { LocalBrainStore, createBrainQueryEngine, redactBrainForStorage, } from "../understanding/brain/index.js";
 import { compileProjectBrain } from "../../mcp/brain/compile.js";
+import { OWNERSHIP_BOUNDARY_VERSION } from "../../project/ownership.js";
 import { resolveRepoRoot } from "../../utils/path.js";
 import { isDirectory } from "../../utils/fs.js";
 function storeFor(root) {
@@ -16,11 +17,13 @@ export async function getBrainStatus(root) {
     const storeRoot = path.join(resolved, ".agentdoctor", "project-brain");
     try {
         const meta = await store.readMeta();
+        const boundaryOk = meta.ownershipBoundaryVersion === OWNERSHIP_BOUNDARY_VERSION;
+        const hasUsableLatest = boundaryOk && meta.latestSnapshotId !== null;
         return {
             root: resolved,
             storeRoot,
-            hasSnapshot: meta.latestSnapshotId !== null,
-            latestSnapshotId: meta.latestSnapshotId,
+            hasSnapshot: hasUsableLatest,
+            latestSnapshotId: hasUsableLatest ? meta.latestSnapshotId : null,
             snapshotCount: meta.snapshots.length,
             projectName: meta.projectName || null,
             schemaVersion: meta.schemaVersion || null,

package/dist/core/monorepo/detect.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { classifyRelativePathOwnership, isUnderNestedRepository } from "../../project/ownership.js";
 import { resolveRepoRoot, toPosixRelative } from "../../utils/path.js";
 async function readJson(file) {
     try {
@@ -99,6 +100,15 @@ export async function detectMonorepo(rootInput) {
                 continue;
             if (seen.has(pkg.absolutePath))
                 continue;
+            const ownership = classifyRelativePathOwnership(pkg.relativePath);
+            if (ownership !== "project_owned") {
+                limitations.push(`Skipped non-owned workspace package: ${pkg.relativePath} (${ownership})`);
+                continue;
+            }
+            if (await isUnderNestedRepository(root, pkg.absolutePath)) {
+                limitations.push(`Skipped nested-repository workspace package: ${pkg.relativePath}`);
+                continue;
+            }
             seen.add(pkg.absolutePath);
             packages.push(pkg);
         }

package/dist/core/secrets/scan.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { decideDirectoryTraversal } from "../../project/ownership.js";
 import { readTextFile } from "../../utils/fs.js";
 import { resolveRepoRoot, toPosixRelative } from "../../utils/path.js";
 const SECRET_PATTERNS = [
@@ -94,6 +95,14 @@ async function walkFiles(root, dir, out, limit) {
         if (entry.isSymbolicLink())
             continue;
         if (entry.isDirectory()) {
+            const relativeDir = toPosixRelative(root, absolute);
+            const traversal = await decideDirectoryTraversal({
+                projectRoot: root,
+                absoluteDir: absolute,
+                relativeDir,
+            });
+            if (!traversal.traverse)
+                continue;
             await walkFiles(root, absolute, out, limit);
             continue;
         }

package/dist/core/understanding/brain/storage/store.d.ts

@@ -9,6 +9,8 @@ export interface SnapshotMeta {
     projectName: string;
     brainId: string;
     checksum: string;
+    /** Snapshots without this stamp (or with a mismatch) must not be served as current truth. */
+    ownershipBoundaryVersion?: number;
 }
 export interface BrainStoreMeta {
     storageFormatVersion: BrainStorageFormatVersion;
@@ -16,6 +18,8 @@ export interface BrainStoreMeta {
     projectName: string;
     latestSnapshotId: string | null;
     snapshots: SnapshotMeta[];
+    /** When missing or mismatched, latest brain is treated as stale vs current ownership rules. */
+    ownershipBoundaryVersion?: number;
 }
 export interface SnapshotComparison {
     leftId: string;