@rigour-labs/core 6.6.2 → 6.6.4

package/dist/types/index.d.ts

@@ -518,6 +518,52 @@ export declare const GatesSchema: z.ZodObject<{
         enabled?: boolean | undefined;
         registry?: string | undefined;
     }>>>;
+    /** Exports the change adds that no other file names (review/unused-exports.ts). */
+    unused_exports: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        allow: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        allow: string[];
+    }, {
+        enabled?: boolean | undefined;
+        allow?: string[] | undefined;
+    }>>>;
+    /** Query shapes that cost production: offset paging in a loop, a time window with no upper bound (review/query-patterns.ts). */
+    query_patterns: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    /** A parameter the change adds as optional that only tests omit (review/optional-params.ts). */
+    optional_params: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    /** A changed function whose body duplicates another in the files the change touched (review/duplicate-functions.ts). */
+    duplicate_functions: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    /** Code files the change adds that nothing imports or runs (review/orphan-files.ts). */
+    orphan_files: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        allow: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        allow: string[];
+    }, {
+        enabled?: boolean | undefined;
+        allow?: string[] | undefined;
+    }>>>;
     migration_order: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         dirs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
@@ -955,6 +1001,23 @@ export declare const GatesSchema: z.ZodObject<{
         enabled: boolean;
         registry?: string | undefined;
     };
+    unused_exports: {
+        enabled: boolean;
+        allow: string[];
+    };
+    query_patterns: {
+        enabled: boolean;
+    };
+    optional_params: {
+        enabled: boolean;
+    };
+    duplicate_functions: {
+        enabled: boolean;
+    };
+    orphan_files: {
+        enabled: boolean;
+        allow: string[];
+    };
     migration_order: {
         enabled: boolean;
         dirs: string[];
@@ -1210,6 +1273,23 @@ export declare const GatesSchema: z.ZodObject<{
         enabled?: boolean | undefined;
         registry?: string | undefined;
     } | undefined;
+    unused_exports?: {
+        enabled?: boolean | undefined;
+        allow?: string[] | undefined;
+    } | undefined;
+    query_patterns?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    optional_params?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    duplicate_functions?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    orphan_files?: {
+        enabled?: boolean | undefined;
+        allow?: string[] | undefined;
+    } | undefined;
     migration_order?: {
         enabled?: boolean | undefined;
         dirs?: string[] | undefined;
@@ -1826,6 +1906,52 @@ export declare const ConfigSchema: z.ZodObject<{
             enabled?: boolean | undefined;
             registry?: string | undefined;
         }>>>;
+        /** Exports the change adds that no other file names (review/unused-exports.ts). */
+        unused_exports: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            allow: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            allow: string[];
+        }, {
+            enabled?: boolean | undefined;
+            allow?: string[] | undefined;
+        }>>>;
+        /** Query shapes that cost production: offset paging in a loop, a time window with no upper bound (review/query-patterns.ts). */
+        query_patterns: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>>;
+        /** A parameter the change adds as optional that only tests omit (review/optional-params.ts). */
+        optional_params: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>>;
+        /** A changed function whose body duplicates another in the files the change touched (review/duplicate-functions.ts). */
+        duplicate_functions: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>>;
+        /** Code files the change adds that nothing imports or runs (review/orphan-files.ts). */
+        orphan_files: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            allow: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            allow: string[];
+        }, {
+            enabled?: boolean | undefined;
+            allow?: string[] | undefined;
+        }>>>;
         migration_order: z.ZodDefault<z.ZodOptional<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             dirs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
@@ -2263,6 +2389,23 @@ export declare const ConfigSchema: z.ZodObject<{
             enabled: boolean;
             registry?: string | undefined;
         };
+        unused_exports: {
+            enabled: boolean;
+            allow: string[];
+        };
+        query_patterns: {
+            enabled: boolean;
+        };
+        optional_params: {
+            enabled: boolean;
+        };
+        duplicate_functions: {
+            enabled: boolean;
+        };
+        orphan_files: {
+            enabled: boolean;
+            allow: string[];
+        };
         migration_order: {
             enabled: boolean;
             dirs: string[];
@@ -2518,6 +2661,23 @@ export declare const ConfigSchema: z.ZodObject<{
             enabled?: boolean | undefined;
             registry?: string | undefined;
         } | undefined;
+        unused_exports?: {
+            enabled?: boolean | undefined;
+            allow?: string[] | undefined;
+        } | undefined;
+        query_patterns?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        optional_params?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        duplicate_functions?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        orphan_files?: {
+            enabled?: boolean | undefined;
+            allow?: string[] | undefined;
+        } | undefined;
         migration_order?: {
             enabled?: boolean | undefined;
             dirs?: string[] | undefined;
@@ -2590,10 +2750,47 @@ export declare const ConfigSchema: z.ZodObject<{
     review: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         /** Let heuristic gates decide the verdict too; by default only findings that prove a defect do (quiet.ts). */
         include_heuristics: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /** Also report findings the base already had; by default only what the change introduced is (baseline.ts). */
+        show_preexisting: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        /** The GitHub account whose token fetches the pull request's previous review (`gh auth token --user`). */
+        github_account: z.ZodOptional<z.ZodString>;
+        /** The fresh reviewer (review/reviewer.ts): the person's own coding agent CLI, headless. `enabled` runs it at every push; `rigour review --reviewer` runs it on request. */
+        reviewer: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            command: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            model: z.ZodOptional<z.ZodString>;
+            timeout_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            timeout_ms: number;
+            command: string;
+            model?: string | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            timeout_ms?: number | undefined;
+            command?: string | undefined;
+            model?: string | undefined;
+        }>>>;
     }, "strip", z.ZodTypeAny, {
         include_heuristics: boolean;
+        show_preexisting: boolean;
+        reviewer: {
+            enabled: boolean;
+            timeout_ms: number;
+            command: string;
+            model?: string | undefined;
+        };
+        github_account?: string | undefined;
     }, {
         include_heuristics?: boolean | undefined;
+        show_preexisting?: boolean | undefined;
+        github_account?: string | undefined;
+        reviewer?: {
+            enabled?: boolean | undefined;
+            timeout_ms?: number | undefined;
+            command?: string | undefined;
+            model?: string | undefined;
+        } | undefined;
     }>>>;
     planned: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
     ignore: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
@@ -2828,6 +3025,23 @@ export declare const ConfigSchema: z.ZodObject<{
             enabled: boolean;
             registry?: string | undefined;
         };
+        unused_exports: {
+            enabled: boolean;
+            allow: string[];
+        };
+        query_patterns: {
+            enabled: boolean;
+        };
+        optional_params: {
+            enabled: boolean;
+        };
+        duplicate_functions: {
+            enabled: boolean;
+        };
+        orphan_files: {
+            enabled: boolean;
+            allow: string[];
+        };
         migration_order: {
             enabled: boolean;
             dirs: string[];
@@ -2876,6 +3090,14 @@ export declare const ConfigSchema: z.ZodObject<{
     };
     review: {
         include_heuristics: boolean;
+        show_preexisting: boolean;
+        reviewer: {
+            enabled: boolean;
+            timeout_ms: number;
+            command: string;
+            model?: string | undefined;
+        };
+        github_account?: string | undefined;
     };
     planned: string[];
     preset?: string | undefined;
@@ -3113,6 +3335,23 @@ export declare const ConfigSchema: z.ZodObject<{
             enabled?: boolean | undefined;
             registry?: string | undefined;
         } | undefined;
+        unused_exports?: {
+            enabled?: boolean | undefined;
+            allow?: string[] | undefined;
+        } | undefined;
+        query_patterns?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        optional_params?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        duplicate_functions?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        orphan_files?: {
+            enabled?: boolean | undefined;
+            allow?: string[] | undefined;
+        } | undefined;
         migration_order?: {
             enabled?: boolean | undefined;
             dirs?: string[] | undefined;
@@ -3161,6 +3400,14 @@ export declare const ConfigSchema: z.ZodObject<{
     } | undefined;
     review?: {
         include_heuristics?: boolean | undefined;
+        show_preexisting?: boolean | undefined;
+        github_account?: string | undefined;
+        reviewer?: {
+            enabled?: boolean | undefined;
+            timeout_ms?: number | undefined;
+            command?: string | undefined;
+            model?: string | undefined;
+        } | undefined;
     } | undefined;
     planned?: string[] | undefined;
 }>;
@@ -3359,9 +3606,9 @@ export declare const ReportSchema: z.ZodObject<{
                 routed: number;
                 already_reviewed: number;
             } | undefined;
+            model?: string | undefined;
             error?: string | undefined;
             tier?: "deep" | "max" | "lite" | "legacy" | "cloud" | undefined;
-            model?: string | undefined;
             model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -3387,9 +3634,9 @@ export declare const ReportSchema: z.ZodObject<{
                 routed: number;
                 already_reviewed: number;
             } | undefined;
+            model?: string | undefined;
             error?: string | undefined;
             tier?: "deep" | "max" | "lite" | "legacy" | "cloud" | undefined;
-            model?: string | undefined;
             model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -3418,9 +3665,9 @@ export declare const ReportSchema: z.ZodObject<{
                 routed: number;
                 already_reviewed: number;
             } | undefined;
+            model?: string | undefined;
             error?: string | undefined;
             tier?: "deep" | "max" | "lite" | "legacy" | "cloud" | undefined;
-            model?: string | undefined;
             model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -3461,9 +3708,9 @@ export declare const ReportSchema: z.ZodObject<{
                 routed: number;
                 already_reviewed: number;
             } | undefined;
+            model?: string | undefined;
             error?: string | undefined;
             tier?: "deep" | "max" | "lite" | "legacy" | "cloud" | undefined;
-            model?: string | undefined;
             model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -3506,9 +3753,9 @@ export declare const ReportSchema: z.ZodObject<{
                 routed: number;
                 already_reviewed: number;
             } | undefined;
+            model?: string | undefined;
             error?: string | undefined;
             tier?: "deep" | "max" | "lite" | "legacy" | "cloud" | undefined;
-            model?: string | undefined;
             model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;
@@ -3569,9 +3816,9 @@ export declare const ReportSchema: z.ZodObject<{
                 routed: number;
                 already_reviewed: number;
             } | undefined;
+            model?: string | undefined;
             error?: string | undefined;
             tier?: "deep" | "max" | "lite" | "legacy" | "cloud" | undefined;
-            model?: string | undefined;
             model_fallback?: boolean | undefined;
             total_ms?: number | undefined;
             files_analyzed?: number | undefined;

package/dist/types/index.js

@@ -281,6 +281,22 @@ export const GatesSchema = z.object({
         registry: z.string().optional(),
     }).optional().default({}),
     // A migration added on a branch that sorts before the newest one on the base (advisory, off by default).
+    /** Exports the change adds that no other file names (review/unused-exports.ts). */
+    unused_exports: z.object({
+        enabled: z.boolean().optional().default(true),
+        allow: z.array(z.string()).optional().default([]), // export names a tool loads by name
+    }).optional().default({}),
+    /** Query shapes that cost production: offset paging in a loop, a time window with no upper bound (review/query-patterns.ts). */
+    query_patterns: z.object({ enabled: z.boolean().optional().default(true) }).optional().default({}),
+    /** A parameter the change adds as optional that only tests omit (review/optional-params.ts). */
+    optional_params: z.object({ enabled: z.boolean().optional().default(true) }).optional().default({}),
+    /** A changed function whose body duplicates another in the files the change touched (review/duplicate-functions.ts). */
+    duplicate_functions: z.object({ enabled: z.boolean().optional().default(true) }).optional().default({}),
+    /** Code files the change adds that nothing imports or runs (review/orphan-files.ts). */
+    orphan_files: z.object({
+        enabled: z.boolean().optional().default(true),
+        allow: z.array(z.string()).optional().default([]), // globs for files a tool loads by path
+    }).optional().default({}),
     migration_order: z.object({
         enabled: z.boolean().optional().default(false),
         dirs: z.array(z.string()).optional().default(['**/supabase/migrations']),
@@ -393,6 +409,17 @@ export const ConfigSchema = z.object({
     review: z.object({
         /** Let heuristic gates decide the verdict too; by default only findings that prove a defect do (quiet.ts). */
         include_heuristics: z.boolean().optional().default(false),
+        /** Also report findings the base already had; by default only what the change introduced is (baseline.ts). */
+        show_preexisting: z.boolean().optional().default(false),
+        /** The GitHub account whose token fetches the pull request's previous review (`gh auth token --user`). */
+        github_account: z.string().optional(),
+        /** The fresh reviewer (review/reviewer.ts): the person's own coding agent CLI, headless. `enabled` runs it at every push; `rigour review --reviewer` runs it on request. */
+        reviewer: z.object({
+            enabled: z.boolean().optional().default(false),
+            command: z.string().optional().default('claude'),
+            model: z.string().optional(),
+            timeout_ms: z.number().optional().default(15 * 60_000),
+        }).optional().default({}),
     }).optional().default({}),
     planned: z.array(z.string()).optional().default([]),
     ignore: z.array(z.string()).optional().default([]),

package/dist/utils/installed-bin.d.ts

@@ -0,0 +1,2 @@
+/** A tool the project installed itself, never a download: node_modules/.bin from `dir` up to `root`. */
+export declare function installedBin(dir: string, root: string, name: string): string | undefined;

package/dist/utils/installed-bin.js

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import path from 'path';
+/** A tool the project installed itself, never a download: node_modules/.bin from `dir` up to `root`. */
+export function installedBin(dir, root, name) {
+    for (let current = dir; current.startsWith(root); current = path.dirname(current)) {
+        for (const candidate of process.platform === 'win32' ? [`${name}.cmd`, name] : [name]) {
+            const bin = path.join(current, 'node_modules', '.bin', candidate);
+            if (fs.existsSync(bin))
+                return bin;
+        }
+        if (current === root)
+            break;
+    }
+    return undefined;
+}

package/dist/utils/profile.d.ts

@@ -0,0 +1,30 @@
+export interface RigourProfile {
+    name: string;
+    /** Path prefixes (`~/work/acme`) or origin remotes (`github.com/acme/*`). */
+    match: string[];
+    /** The home whose `.rigour/` holds this profile's state. */
+    home?: string;
+    team?: {
+        organization: string;
+        team: string;
+        actor: string;
+        /** The team's repositories; lessons from any other repository stay local. */
+        repositories?: string[];
+        /** A command that prints the team database URL (from a keychain, a vault); never stored in the file. */
+        databaseUrlCommand?: string;
+    };
+    /** The GitHub account whose token fetches pull request reviews. */
+    githubAccount?: string;
+}
+/** Where profiles are listed: always the person's real home, never a profile's. */
+export declare function profilesPath(): string;
+export declare function readProfiles(): RigourProfile[];
+export declare function writeProfiles(profiles: RigourProfile[]): void;
+/** The first profile whose match fits `cwd`, by path or by origin remote. */
+export declare function profileFor(cwd: string, profiles?: RigourProfile[]): RigourProfile | undefined;
+/** Apply the profile for `cwd` to this process's environment; returns it, or undefined when none matches. */
+export declare function applyProfile(cwd: string, profiles?: RigourProfile[]): RigourProfile | undefined;
+/** Why this process must not act for `cwd` (it belongs to another profile than the one applied at start), or null. */
+export declare function profileMismatch(cwd: string, profiles?: RigourProfile[]): string | null;
+/** `git@github.com:acme/api.git` and `https://github.com/acme/api` both become `github.com/acme/api`. */
+export declare function hostPath(remote: string): string;

package/dist/utils/profile.js

@@ -0,0 +1,116 @@
+/**
+ * Profiles: one machine, many organizations.
+ *
+ * A person who works for more than one organization needs Rigour's memory, lessons and team
+ * database kept apart per organization, chosen by the repository, not by whichever server or shell
+ * happened to start. `~/.rigour/profiles.json` (or RIGOUR_PROFILES) lists profiles; the first whose
+ * `match` fits the repository (a path prefix, or an origin remote like `github.com/acme/*`) is
+ * applied before the rest of Rigour loads: its home becomes RIGOUR_HOME, and team settings come
+ * from the profile alone (any inherited from the shell are cleared, so another organization's team
+ * can never apply). A long-running server records the profile it started with, and refuses a call
+ * for a repository of another profile instead of answering it with the wrong home.
+ *
+ * Dependency-free on purpose: it runs before the rest of the package is imported.
+ */
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+const TEAM_ENV = ['RIGOUR_ORGANIZATION_ID', 'RIGOUR_TEAM_ID', 'RIGOUR_ACTOR_ID', 'RIGOUR_TEAM_REPOSITORIES', 'RIGOUR_TEAM_DATABASE_URL', 'RIGOUR_TEAM_DATABASE_URL_COMMAND', 'RIGOUR_TEAM_SEMANTIC'];
+/** Where profiles are listed: always the person's real home, never a profile's. */
+export function profilesPath() {
+    return process.env.RIGOUR_PROFILES || path.join(os.homedir(), '.rigour', 'profiles.json');
+}
+export function readProfiles() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(profilesPath(), 'utf8'));
+        return Array.isArray(parsed?.profiles) ? parsed.profiles.filter((p) => p && typeof p.name === 'string' && Array.isArray(p.match)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function writeProfiles(profiles) {
+    fs.mkdirSync(path.dirname(profilesPath()), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(profilesPath(), JSON.stringify({ profiles }, null, 2) + '\n', { mode: 0o600 });
+}
+/** The first profile whose match fits `cwd`, by path or by origin remote. */
+export function profileFor(cwd, profiles = readProfiles()) {
+    if (profiles.length === 0)
+        return undefined;
+    const where = real(cwd);
+    const remote = originRemote(cwd);
+    return profiles.find(profile => profile.match.some(entry => isRemotePattern(entry)
+        ? !!remote && remoteMatches(remote, entry)
+        : isInside(where, real(expandHome(entry)))));
+}
+/** Apply the profile for `cwd` to this process's environment; returns it, or undefined when none matches. */
+export function applyProfile(cwd, profiles) {
+    const profile = profileFor(cwd, profiles);
+    if (!profile)
+        return undefined;
+    process.env.RIGOUR_PROFILE = profile.name;
+    if (profile.home)
+        process.env.RIGOUR_HOME = expandHome(profile.home);
+    for (const name of TEAM_ENV)
+        delete process.env[name];
+    if (profile.team) {
+        process.env.RIGOUR_ORGANIZATION_ID = profile.team.organization;
+        process.env.RIGOUR_TEAM_ID = profile.team.team;
+        process.env.RIGOUR_ACTOR_ID = profile.team.actor;
+        if (profile.team.repositories?.length)
+            process.env.RIGOUR_TEAM_REPOSITORIES = profile.team.repositories.join(',');
+        if (profile.team.databaseUrlCommand)
+            process.env.RIGOUR_TEAM_DATABASE_URL_COMMAND = profile.team.databaseUrlCommand;
+    }
+    if (profile.githubAccount)
+        process.env.RIGOUR_GITHUB_ACCOUNT = profile.githubAccount;
+    return profile;
+}
+/** Why this process must not act for `cwd` (it belongs to another profile than the one applied at start), or null. */
+export function profileMismatch(cwd, profiles) {
+    const belongs = profileFor(cwd, profiles)?.name;
+    const running = process.env.RIGOUR_PROFILE;
+    if (belongs === running)
+        return null;
+    return `This repository belongs to the Rigour profile "${belongs ?? '(none)'}", but this server started as "${running ?? '(none)'}". `
+        + 'Refusing so one profile\'s memory and team never reach another: start Rigour from this repository (or with RIGOUR_CWD set to it).';
+}
+function isRemotePattern(entry) {
+    return /^[a-z0-9.-]+\.[a-z]{2,}\//i.test(entry.replace(/^[a-z]+:\/\//i, ''));
+}
+function remoteMatches(remote, pattern) {
+    const want = hostPath(pattern);
+    return want.endsWith('/*') ? remote.startsWith(want.slice(0, -1)) : remote === want;
+}
+/** `git@github.com:acme/api.git` and `https://github.com/acme/api` both become `github.com/acme/api`. */
+export function hostPath(remote) {
+    return remote.trim().toLowerCase()
+        .replace(/^[a-z][a-z0-9+.-]*:\/\//, '')
+        .replace(/^[^@/]+@/, '')
+        .replace(/^([^/:]+):(?!\d)/, '$1/')
+        .replace(/\/+$/, '')
+        .replace(/\.git$/, '');
+}
+function originRemote(cwd) {
+    const result = spawnSync('git', ['config', '--get', 'remote.origin.url'], { cwd, encoding: 'utf8' });
+    return result.status === 0 && result.stdout.trim() ? hostPath(result.stdout) : undefined;
+}
+function expandHome(entry) {
+    return entry.replace(/^~(?=$|[\\/])/, os.homedir());
+}
+/** The real path; for a path that does not exist yet, its nearest existing parent's real path plus the rest. */
+function real(dir) {
+    const absolute = path.resolve(dir);
+    try {
+        return fs.realpathSync.native(absolute);
+    }
+    catch {
+        const parent = path.dirname(absolute);
+        return parent === absolute ? absolute : path.join(real(parent), path.basename(absolute));
+    }
+}
+function isInside(child, parent) {
+    const relative = path.relative(parent, child);
+    return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}

package/dist/utils/profile.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/profile.test.js

@@ -0,0 +1,58 @@
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { applyProfile, hostPath, profileFor, profileMismatch } from './profile.js';
+let root;
+const saved = { ...process.env };
+const repo = (rel, remote) => {
+    const dir = path.join(root, rel);
+    fs.mkdirSync(dir, { recursive: true });
+    execFileSync('git', ['init', '-q'], { cwd: dir });
+    if (remote)
+        execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: dir });
+    return dir;
+};
+beforeEach(() => { root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'profiles-'))); });
+afterEach(() => { process.env = { ...saved }; fs.rmSync(root, { recursive: true, force: true }); });
+describe('profiles', () => {
+    it('matches a repository by path prefix or by origin remote, first match winning', () => {
+        const byPath = repo('work/acme/api');
+        const byRemote = repo('elsewhere/web', 'git@github.com:Acme/web.git');
+        const other = repo('personal/tool', 'https://github.com/me/tool');
+        const profiles = [
+            { name: 'acme-path', match: [path.join(root, 'work/acme')] },
+            { name: 'acme-remote', match: ['github.com/acme/*'] },
+        ];
+        expect(profileFor(path.join(byPath, 'src'), profiles)?.name).toBe('acme-path');
+        expect(profileFor(byRemote, profiles)?.name).toBe('acme-remote');
+        expect(profileFor(other, profiles)).toBeUndefined();
+        expect(profileFor(path.join(root, 'work/acme-evil'), profiles)).toBeUndefined();
+        expect(hostPath('https://GitHub.com/Acme/web.git/')).toBe('github.com/acme/web');
+    });
+    it("applies the profile's home and team, clearing team settings inherited from the shell", () => {
+        const dir = repo('work/acme/api');
+        process.env.RIGOUR_TEAM_DATABASE_URL = 'postgres://other-org';
+        process.env.RIGOUR_ORGANIZATION_ID = 'other-org';
+        applyProfile(dir, [{ name: 'acme', match: [path.join(root, 'work/acme')], home: path.join(root, 'acme-home'), githubAccount: 'acme-dev' }]);
+        expect(process.env.RIGOUR_HOME).toBe(path.join(root, 'acme-home'));
+        expect(process.env.RIGOUR_PROFILE).toBe('acme');
+        expect(process.env.RIGOUR_GITHUB_ACCOUNT).toBe('acme-dev');
+        expect(process.env.RIGOUR_TEAM_DATABASE_URL).toBeUndefined();
+        expect(process.env.RIGOUR_ORGANIZATION_ID).toBeUndefined();
+        applyProfile(dir, [{ name: 'acme', match: [dir], team: { organization: 'acme', team: 'web', actor: 'dev', repositories: ['github.com/acme/*'], databaseUrlCommand: 'echo url' } }]);
+        expect([process.env.RIGOUR_ORGANIZATION_ID, process.env.RIGOUR_TEAM_REPOSITORIES, process.env.RIGOUR_TEAM_DATABASE_URL_COMMAND]).toEqual(['acme', 'github.com/acme/*', 'echo url']);
+    });
+    it('refuses to act for a repository of another profile than the one the process started with', () => {
+        const acme = repo('work/acme/api');
+        const mine = repo('personal/tool');
+        const profiles = [{ name: 'acme', match: [path.join(root, 'work/acme')] }];
+        delete process.env.RIGOUR_PROFILE;
+        expect(profileMismatch(mine, profiles)).toBeNull();
+        expect(profileMismatch(acme, profiles)).toContain('belongs to the Rigour profile "acme"');
+        process.env.RIGOUR_PROFILE = 'acme';
+        expect(profileMismatch(acme, profiles)).toBeNull();
+        expect(profileMismatch(mine, profiles)).toContain('started as "acme"');
+    });
+});

package/dist/utils/scanner.js

@@ -34,11 +34,13 @@ export class FileScanner {
         const userIgnore = options.ignore || [];
         const ignore = [...new Set([...this.DEFAULT_IGNORE, ...userIgnore])].map(toGlobSeparators);
         const normalizedCwd = options.cwd.replace(/\\/g, '/');
-        return globby(directoriesAsGlobs(normalizedCwd, patterns), {
+        // Sorted: the walk's order varies run to run, and a check that names "the first file" must name the same one.
+        const files = await globby(directoriesAsGlobs(normalizedCwd, patterns), {
             cwd: normalizedCwd,
             ignore: withDirectoryForms(ignore),
             expandDirectories: false,
         });
+        return files.sort();
     }
     /**
      * Read file contents. When a FileSystemCache is provided, uses it for