@open-cr-agent/core 0.1.0

package/dist/rules/builtin/performance.d.ts

@@ -0,0 +1,2 @@
+export declare const PERFORMANCE_RULES = "### Performance\n- Algorithmic complexity that grows with input the code cannot bound: nested loops over the same collections, repeated linear searches or `includes` inside loops where a set or map fits, sorting inside loops.\n- Round trips in loops: database queries, HTTP calls or file reads per item (N+1) where one batched call works; queries on new filters that fetch unbounded result sets without a limit or pagination.\n- Blocking work on latency-sensitive paths: synchronous file, network or CPU-heavy work in request handlers, event loops, UI threads or `async` functions.\n- Memory: whole files, streams or result sets buffered when their size is external; caches, maps or listener lists that grow without eviction or removal.\n- Repeated work on hot paths: recomputation or re-parsing inside loops, regular expressions or serializers rebuilt per call, React renders triggered by unstable dependencies or props.\n- Concurrency: independent I/O awaited one after another on a latency-critical path; unbounded parallelism that overwhelms a pool, a rate limit or memory.\n- Regressions of existing optimizations: removed indexes, caches, batching, streaming or early exits.";
+//# sourceMappingURL=performance.d.ts.map

package/dist/rules/builtin/performance.js

@@ -0,0 +1,9 @@
+export const PERFORMANCE_RULES = `### Performance
+- Algorithmic complexity that grows with input the code cannot bound: nested loops over the same collections, repeated linear searches or \`includes\` inside loops where a set or map fits, sorting inside loops.
+- Round trips in loops: database queries, HTTP calls or file reads per item (N+1) where one batched call works; queries on new filters that fetch unbounded result sets without a limit or pagination.
+- Blocking work on latency-sensitive paths: synchronous file, network or CPU-heavy work in request handlers, event loops, UI threads or \`async\` functions.
+- Memory: whole files, streams or result sets buffered when their size is external; caches, maps or listener lists that grow without eviction or removal.
+- Repeated work on hot paths: recomputation or re-parsing inside loops, regular expressions or serializers rebuilt per call, React renders triggered by unstable dependencies or props.
+- Concurrency: independent I/O awaited one after another on a latency-critical path; unbounded parallelism that overwhelms a pool, a rate limit or memory.
+- Regressions of existing optimizations: removed indexes, caches, batching, streaming or early exits.`;
+//# sourceMappingURL=performance.js.map

package/dist/rules/builtin/python.d.ts

@@ -0,0 +1,2 @@
+export declare const PYTHON_RULES = "### Python\n- Mutable default arguments or class attributes shared across calls or instances when per-call state was intended.\n- Broad `except` (bare or `Exception`) that swallows errors, including `KeyboardInterrupt`/`SystemExit` via bare `except`, or re-raises without the original cause.\n- Resources opened without `with` or `try/finally` on paths that can raise.\n- Blocking calls inside `async def` code, coroutines that are never awaited, or tasks created without keeping a reference.\n- Truthiness checks that misclassify valid values (`0`, `\"\"`, empty collections) where `is None` was meant.\n- Late-binding closures in loops, iteration while mutating the same collection, integer vs float division mistakes.\n- SQL, shell or template strings built from input instead of parameters; `pickle`/`yaml.load` on untrusted data.";
+//# sourceMappingURL=python.d.ts.map

package/dist/rules/builtin/python.js

@@ -0,0 +1,9 @@
+export const PYTHON_RULES = `### Python
+- Mutable default arguments or class attributes shared across calls or instances when per-call state was intended.
+- Broad \`except\` (bare or \`Exception\`) that swallows errors, including \`KeyboardInterrupt\`/\`SystemExit\` via bare \`except\`, or re-raises without the original cause.
+- Resources opened without \`with\` or \`try/finally\` on paths that can raise.
+- Blocking calls inside \`async def\` code, coroutines that are never awaited, or tasks created without keeping a reference.
+- Truthiness checks that misclassify valid values (\`0\`, \`""\`, empty collections) where \`is None\` was meant.
+- Late-binding closures in loops, iteration while mutating the same collection, integer vs float division mistakes.
+- SQL, shell or template strings built from input instead of parameters; \`pickle\`/\`yaml.load\` on untrusted data.`;
+//# sourceMappingURL=python.js.map

package/dist/rules/builtin/security.d.ts

@@ -0,0 +1,2 @@
+export declare const SECURITY_RULES = "### Security\n- Injection from input that reaches an interpreter: SQL or NoSQL built from strings, shell commands, template rendering, LDAP or XPath, HTML without escaping (XSS), headers or log lines with raw newlines.\n- Server-side request forgery and path traversal: URLs, hosts or file paths built from input without an allow-list or containment check, including archive extraction.\n- Authentication and authorization: new routes, handlers, jobs or queries without the checks their neighbours apply; object access by id without an ownership or tenant check (IDOR); privilege or role checks that can be bypassed or were weakened.\n- Secrets and sensitive data: credentials or tokens in code or config, secrets or personal data written to logs, errors, analytics or responses; session tokens or API keys exposed to the client.\n- Cryptography: home-made crypto, weak or misused algorithms (MD5/SHA-1 for passwords, ECB, static IVs), non-cryptographic randomness for tokens, disabled certificate or signature verification, timing-unsafe secret comparison.\n- Unsafe parsing: deserialization of untrusted data (pickle, Java serialization, YAML full loaders), XML external entities, prototype pollution through deep merges, regular expressions with catastrophic backtracking on input.\n- Resource exhaustion from untrusted input: unbounded sizes, counts, recursion or allocation that an external caller controls.\n- Configuration: permissive CORS with credentials, cookies without Secure/HttpOnly/SameSite where they carry sessions, debug modes or verbose errors enabled in production paths, world-writable files.\n- CI and supply chain: untrusted pull request text or branch names interpolated into workflow `run:` steps, `pull_request_target` checking out untrusted code with secrets, broadened workflow permissions, new dependencies from unexpected sources or install scripts.";
+//# sourceMappingURL=security.d.ts.map

package/dist/rules/builtin/security.js

@@ -0,0 +1,11 @@
+export const SECURITY_RULES = `### Security
+- Injection from input that reaches an interpreter: SQL or NoSQL built from strings, shell commands, template rendering, LDAP or XPath, HTML without escaping (XSS), headers or log lines with raw newlines.
+- Server-side request forgery and path traversal: URLs, hosts or file paths built from input without an allow-list or containment check, including archive extraction.
+- Authentication and authorization: new routes, handlers, jobs or queries without the checks their neighbours apply; object access by id without an ownership or tenant check (IDOR); privilege or role checks that can be bypassed or were weakened.
+- Secrets and sensitive data: credentials or tokens in code or config, secrets or personal data written to logs, errors, analytics or responses; session tokens or API keys exposed to the client.
+- Cryptography: home-made crypto, weak or misused algorithms (MD5/SHA-1 for passwords, ECB, static IVs), non-cryptographic randomness for tokens, disabled certificate or signature verification, timing-unsafe secret comparison.
+- Unsafe parsing: deserialization of untrusted data (pickle, Java serialization, YAML full loaders), XML external entities, prototype pollution through deep merges, regular expressions with catastrophic backtracking on input.
+- Resource exhaustion from untrusted input: unbounded sizes, counts, recursion or allocation that an external caller controls.
+- Configuration: permissive CORS with credentials, cookies without Secure/HttpOnly/SameSite where they carry sessions, debug modes or verbose errors enabled in production paths, world-writable files.
+- CI and supply chain: untrusted pull request text or branch names interpolated into workflow \`run:\` steps, \`pull_request_target\` checking out untrusted code with secrets, broadened workflow permissions, new dependencies from unexpected sources or install scripts.`;
+//# sourceMappingURL=security.js.map

package/dist/rules/builtin/typescript.d.ts

@@ -0,0 +1,2 @@
+export declare const TYPESCRIPT_RULES = "### TypeScript and JavaScript\n- Promises that are neither awaited, returned nor explicitly handled, so failures become unhandled rejections or ordering is lost; `forEach` with async callbacks that callers assume completed.\n- `await` inside loops where independent work was meant to run concurrently, or `Promise.all` over work that must be sequential or bounded.\n- Truthiness checks that misclassify valid values (`0`, `\"\"`, `NaN`, `false`) where `??` or an explicit comparison was needed; `==` comparisons with surprising coercion.\n- Type assertions (`as`, non-null `!`, `any`) that bypass a check the runtime data can actually fail; parsed external data used without validation.\n- Mutation of arguments, shared module state or React state/props in place; missing or wrong hook dependencies that cause stale values or infinite loops.\n- Floating timers, listeners or subscriptions without cleanup on unmount, abort or error.\n- `JSON.parse`, `new URL`, `BigInt` and similar calls on external input without handling their exceptions.";
+//# sourceMappingURL=typescript.d.ts.map

package/dist/rules/builtin/typescript.js

@@ -0,0 +1,9 @@
+export const TYPESCRIPT_RULES = `### TypeScript and JavaScript
+- Promises that are neither awaited, returned nor explicitly handled, so failures become unhandled rejections or ordering is lost; \`forEach\` with async callbacks that callers assume completed.
+- \`await\` inside loops where independent work was meant to run concurrently, or \`Promise.all\` over work that must be sequential or bounded.
+- Truthiness checks that misclassify valid values (\`0\`, \`""\`, \`NaN\`, \`false\`) where \`??\` or an explicit comparison was needed; \`==\` comparisons with surprising coercion.
+- Type assertions (\`as\`, non-null \`!\`, \`any\`) that bypass a check the runtime data can actually fail; parsed external data used without validation.
+- Mutation of arguments, shared module state or React state/props in place; missing or wrong hook dependencies that cause stale values or infinite loops.
+- Floating timers, listeners or subscriptions without cleanup on unmount, abort or error.
+- \`JSON.parse\`, \`new URL\`, \`BigInt\` and similar calls on external input without handling their exceptions.`;
+//# sourceMappingURL=typescript.js.map

package/dist/rules/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./languages.js";
+export * from "./repo-rules.js";
+export * from "./resolve.js";
+export * from "./rule-set.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/rules/index.js

@@ -0,0 +1,5 @@
+export * from "./languages.js";
+export * from "./repo-rules.js";
+export * from "./resolve.js";
+export * from "./rule-set.js";
+//# sourceMappingURL=index.js.map

package/dist/rules/languages.d.ts

@@ -0,0 +1,3 @@
+export type Language = "typescript" | "python" | "go" | "java";
+export declare function detectLanguage(path: string): Language | undefined;
+//# sourceMappingURL=languages.d.ts.map

package/dist/rules/languages.js

@@ -0,0 +1,20 @@
+const EXTENSIONS = {
+    ts: "typescript",
+    tsx: "typescript",
+    mts: "typescript",
+    cts: "typescript",
+    js: "typescript",
+    jsx: "typescript",
+    mjs: "typescript",
+    cjs: "typescript",
+    py: "python",
+    pyi: "python",
+    go: "go",
+    java: "java",
+};
+export function detectLanguage(path) {
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    const dot = name.lastIndexOf(".");
+    return dot > 0 ? EXTENSIONS[name.slice(dot + 1).toLowerCase()] : undefined;
+}
+//# sourceMappingURL=languages.js.map

package/dist/rules/repo-rules.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const repoRuleSchema: z.ZodObject<{
+    path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    rule: z.ZodString;
+}, z.core.$strip>;
+export type RepoRule = z.infer<typeof repoRuleSchema>;
+export declare const repoRulesFileSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodObject<{
+        path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        rule: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const REPO_RULES_PATH = ".ocra/rules.json";
+export declare function parseRepoRules(json: string): RepoRule[];
+//# sourceMappingURL=repo-rules.d.ts.map

package/dist/rules/repo-rules.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export const repoRuleSchema = z.object({
+    path: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]),
+    rule: z.string().min(1),
+});
+export const repoRulesFileSchema = z.object({ rules: z.array(repoRuleSchema) });
+export const REPO_RULES_PATH = ".ocra/rules.json";
+export function parseRepoRules(json) {
+    let data;
+    try {
+        data = JSON.parse(json);
+    }
+    catch (error) {
+        throw new Error(`${REPO_RULES_PATH} is not valid JSON: ${error.message}`);
+    }
+    const parsed = repoRulesFileSchema.safeParse(data);
+    if (!parsed.success) {
+        throw new Error(`${REPO_RULES_PATH} is invalid: ${z.prettifyError(parsed.error)}`);
+    }
+    return parsed.data.rules;
+}
+//# sourceMappingURL=repo-rules.js.map

package/dist/rules/resolve.d.ts

@@ -0,0 +1,4 @@
+import type { RepoRule } from "./repo-rules.js";
+import type { RuleSet } from "./rule-set.js";
+export declare function resolveRules(paths: readonly string[], repoRules: readonly RepoRule[], builtin?: RuleSet): string;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/rules/resolve.js

@@ -0,0 +1,27 @@
+import picomatch from "picomatch";
+import { detectLanguage } from "./languages.js";
+export function resolveRules(paths, repoRules, builtin = {}) {
+    const languages = new Set();
+    for (const path of paths) {
+        const language = detectLanguage(path);
+        if (language)
+            languages.add(language);
+    }
+    const sections = [];
+    if (builtin.general)
+        sections.push(builtin.general);
+    for (const language of [...languages].sort()) {
+        const rules = builtin.languages?.[language];
+        if (rules)
+            sections.push(rules);
+    }
+    const matching = repoRules.filter((r) => {
+        const matches = picomatch(r.path, { dot: true });
+        return paths.some((p) => matches(p));
+    });
+    if (matching.length > 0) {
+        sections.push(`### Repository rules\n${matching.map((r) => r.rule.trim()).join("\n\n")}`);
+    }
+    return sections.join("\n\n");
+}
+//# sourceMappingURL=resolve.js.map

package/dist/rules/rule-set.d.ts

@@ -0,0 +1,6 @@
+import type { Language } from "./languages.js";
+export interface RuleSet {
+    general?: string;
+    languages?: Partial<Record<Language, string>>;
+}
+//# sourceMappingURL=rule-set.d.ts.map

package/dist/rules/rule-set.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rule-set.js.map

package/dist/select/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./select.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/select/index.js

@@ -0,0 +1,2 @@
+export * from "./select.js";
+//# sourceMappingURL=index.js.map

package/dist/select/patterns.d.ts

@@ -0,0 +1,6 @@
+export declare const SECRET_PATTERNS: string[];
+export declare const ENV_TEMPLATE_PATTERNS: string[];
+export declare const NON_REVIEWABLE_EXTENSIONS: string[];
+export declare const GENERATED_PATTERNS: string[];
+export declare const MIGRATION_PATTERNS: string[];
+//# sourceMappingURL=patterns.d.ts.map

package/dist/select/patterns.js

@@ -0,0 +1,132 @@
+export const SECRET_PATTERNS = [
+    "**/.env",
+    "**/.env.*",
+    "**/*.env",
+    "**/.envrc",
+    "**/*.pem",
+    "**/*.key",
+    "**/*.p12",
+    "**/*.pfx",
+    "**/*.keystore",
+    "**/*.jks",
+    "**/id_rsa*",
+    "**/id_ed25519*",
+    "**/id_ecdsa*",
+    "**/id_dsa*",
+    "**/*.p8",
+    "**/.npmrc",
+    "**/.pypirc",
+    "**/.netrc",
+    "**/.pgpass",
+    "**/.htpasswd",
+    "**/.vault-token",
+    "**/.secrets",
+    "**/.streamlit/secrets.toml",
+    "**/*.keytab",
+    "**/credentials.json",
+    "**/application_default_credentials.json",
+    "**/serviceAccountKey*.json",
+    "**/*firebase-adminsdk*.json",
+    "**/gha-creds-*.json",
+    "**/service-account*.json",
+    "**/secrets.{yml,yaml,json}",
+    "**/.git-credentials",
+    "**/.aws/credentials",
+    "**/.kube/config",
+    "**/kubeconfig",
+    "**/.docker/config.json",
+    "**/.dockercfg",
+    "**/*.tfvars",
+    "**/*.tfvars.json",
+    "**/*.tfstate",
+    "**/*.tfstate.backup",
+    "**/.cargo/credentials",
+    "**/.cargo/credentials.toml",
+    "**/.config/gh/hosts.yml",
+    "**/*.ovpn",
+];
+export const ENV_TEMPLATE_PATTERNS = ["**/.env.example", "**/.env.sample", "**/.env.template"];
+export const NON_REVIEWABLE_EXTENSIONS = [
+    "png",
+    "jpg",
+    "jpeg",
+    "gif",
+    "webp",
+    "ico",
+    "bmp",
+    "tiff",
+    "psd",
+    "mp3",
+    "mp4",
+    "wav",
+    "ogg",
+    "mov",
+    "avi",
+    "webm",
+    "woff",
+    "woff2",
+    "ttf",
+    "otf",
+    "eot",
+    "zip",
+    "gz",
+    "tgz",
+    "bz2",
+    "xz",
+    "7z",
+    "rar",
+    "jar",
+    "war",
+    "pdf",
+    "doc",
+    "docx",
+    "xls",
+    "xlsx",
+    "ppt",
+    "pptx",
+    "exe",
+    "dll",
+    "so",
+    "dylib",
+    "a",
+    "o",
+    "class",
+    "pyc",
+    "wasm",
+    "csv",
+    "tsv",
+    "parquet",
+    "db",
+    "sqlite",
+];
+export const GENERATED_PATTERNS = [
+    "**/package-lock.json",
+    "**/npm-shrinkwrap.json",
+    "**/yarn.lock",
+    "**/pnpm-lock.yaml",
+    "**/bun.lock",
+    "**/bun.lockb",
+    "**/Cargo.lock",
+    "**/Gemfile.lock",
+    "**/poetry.lock",
+    "**/uv.lock",
+    "**/Pipfile.lock",
+    "**/composer.lock",
+    "**/go.sum",
+    "**/flake.lock",
+    "**/node_modules/**",
+    "**/vendor/**",
+    "**/third_party/**",
+    "**/*.min.js",
+    "**/*.min.css",
+    "**/*.map",
+    "**/*.pb.go",
+    "**/*_pb2.py",
+    "**/*_pb2_grpc.py",
+    "**/*.pb.ts",
+    "**/*.generated.*",
+    "**/*.g.dart",
+    "**/__snapshots__/**",
+];
+export const MIGRATION_PATTERNS = ["**/migrations/**", "**/migrate/**", "**/*.migration.*"];
+//# sourceMappingURL=patterns.js.map

package/dist/select/select.d.ts

@@ -0,0 +1,19 @@
+import type { FileDiff } from "../domain.js";
+export type ExclusionReason = "binary" | "secret" | "deleted" | "user_exclude" | "extension" | "generated" | "too_large";
+export type FileDecision = {
+    diff: FileDiff;
+    selected: true;
+} | {
+    diff: FileDiff;
+    selected: false;
+    reason: ExclusionReason;
+};
+export interface SelectionPolicy {
+    include: readonly string[];
+    exclude: readonly string[];
+    maxPatchChars: number;
+}
+export declare const defaultSelectionPolicy: SelectionPolicy;
+export declare function isSecretPath(path: string): boolean;
+export declare function selectFiles(diffs: readonly FileDiff[], policy?: SelectionPolicy): FileDecision[];
+//# sourceMappingURL=select.d.ts.map

package/dist/select/select.js

@@ -0,0 +1,52 @@
+import picomatch from "picomatch";
+import { ENV_TEMPLATE_PATTERNS, GENERATED_PATTERNS, MIGRATION_PATTERNS, NON_REVIEWABLE_EXTENSIONS, SECRET_PATTERNS, } from "./patterns.js";
+export const defaultSelectionPolicy = {
+    include: [],
+    exclude: [],
+    maxPatchChars: 200_000,
+};
+const globOptions = { dot: true, nocase: true };
+const isSecret = picomatch(SECRET_PATTERNS, { ...globOptions, ignore: ENV_TEMPLATE_PATTERNS });
+const isGenerated = picomatch(GENERATED_PATTERNS, globOptions);
+const isMigration = picomatch(MIGRATION_PATTERNS, globOptions);
+const nonReviewableExtensions = new Set(NON_REVIEWABLE_EXTENSIONS);
+export function isSecretPath(path) {
+    return isSecret(path);
+}
+export function selectFiles(diffs, policy = defaultSelectionPolicy) {
+    const isUserExcluded = matcher(policy.exclude);
+    const isUserIncluded = matcher(policy.include);
+    return diffs.map((diff) => {
+        const reason = exclusionReason(diff, policy, isUserExcluded, isUserIncluded);
+        return reason ? { diff, selected: false, reason } : { diff, selected: true };
+    });
+}
+function exclusionReason(diff, policy, isUserExcluded, isUserIncluded) {
+    const path = diff.newPath;
+    if (diff.isBinary)
+        return "binary";
+    if (isSecret(diff.oldPath) || isSecret(path))
+        return "secret";
+    if (diff.kind === "deleted")
+        return "deleted";
+    if (isUserExcluded(path))
+        return "user_exclude";
+    if (!isUserIncluded(path)) {
+        if (nonReviewableExtensions.has(extension(path)))
+            return "extension";
+        if (isGenerated(path) && !isMigration(path))
+            return "generated";
+    }
+    if (diff.patch.length > policy.maxPatchChars)
+        return "too_large";
+    return undefined;
+}
+function matcher(patterns) {
+    return patterns.length === 0 ? () => false : picomatch([...patterns], globOptions);
+}
+function extension(path) {
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    const dot = name.lastIndexOf(".");
+    return dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
+}
+//# sourceMappingURL=select.js.map

package/dist/session/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./jsonl.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/session/index.js

@@ -0,0 +1,2 @@
+export * from "./jsonl.js";
+//# sourceMappingURL=index.js.map

package/dist/session/jsonl.d.ts

@@ -0,0 +1,11 @@
+import type { ReviewEvent } from "../pipeline/report.js";
+export declare const EVENTS_FILE = "events.jsonl";
+export declare const REPORT_FILE = "report.json";
+export declare function newSessionId(now?: Date): string;
+export declare class JsonlSessionWriter {
+    readonly id: string;
+    readonly dir: string;
+    constructor(sessionsDir: string, id?: string);
+    write(event: ReviewEvent): void;
+}
+//# sourceMappingURL=jsonl.d.ts.map

package/dist/session/jsonl.js

@@ -0,0 +1,57 @@
+import { randomBytes } from "node:crypto";
+import { appendFileSync, closeSync, constants, lstatSync, mkdirSync, openSync, writeFileSync, writeSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { serializeOutput, toReportOutput } from "../pipeline/output.js";
+export const EVENTS_FILE = "events.jsonl";
+export const REPORT_FILE = "report.json";
+export function newSessionId(now = new Date()) {
+    const stamp = now
+        .toISOString()
+        .replace(/[-:]/g, "")
+        .replace(/\.\d+Z$/, "Z");
+    return `${stamp}-${randomBytes(3).toString("hex")}`;
+}
+// Events are appended synchronously, one JSON object per line, so the log
+// stays valid and ordered even if the process dies mid-run.
+export class JsonlSessionWriter {
+    id;
+    dir;
+    constructor(sessionsDir, id = newSessionId()) {
+        this.id = id;
+        // The sessions directory lives in the reviewed tree, which may carry
+        // links planted to send the logs, or the .gitignore write, elsewhere.
+        for (const dir of [dirname(sessionsDir), sessionsDir])
+            refuseSymlink(dir);
+        this.dir = join(sessionsDir, id);
+        mkdirSync(this.dir, { recursive: true });
+        // The directory is created before a workspace review reads its diff, and
+        // the logs hold code and findings: keep them out of git and out of reviews.
+        const fd = openSync(join(sessionsDir, ".gitignore"), constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_NOFOLLOW);
+        try {
+            writeSync(fd, "*\n");
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    write(event) {
+        const line = serializeOutput({ time: new Date().toISOString(), ...event }, 0);
+        appendFileSync(join(this.dir, EVENTS_FILE), `${line}\n`);
+        if (event.type === "run_finished") {
+            const report = toReportOutput(event.report);
+            writeFileSync(join(this.dir, REPORT_FILE), `${serializeOutput(report)}\n`);
+        }
+    }
+}
+function refuseSymlink(path) {
+    try {
+        if (lstatSync(path).isSymbolicLink()) {
+            throw new Error(`Refusing to write the session log through the symbolic link ${path}`);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+//# sourceMappingURL=jsonl.js.map

package/dist/triage.d.ts

@@ -0,0 +1,11 @@
+import type { FileDiff, RiskTier } from "./domain.js";
+export interface TriagePolicy {
+    trivialMaxLines: number;
+    liteMaxLines: number;
+    maxFilesBeforeFull: number;
+    sensitivePathPatterns: RegExp[];
+    sensitivePathWords: ReadonlySet<string>;
+}
+export declare const defaultTriagePolicy: TriagePolicy;
+export declare function triage(diffs: readonly FileDiff[], policy?: TriagePolicy): RiskTier;
+//# sourceMappingURL=triage.d.ts.map

package/dist/triage.js

@@ -0,0 +1,55 @@
+export const defaultTriagePolicy = {
+    trivialMaxLines: 10,
+    liteMaxLines: 100,
+    maxFilesBeforeFull: 20,
+    sensitivePathPatterns: [/(^|\/)\.github\/workflows\//],
+    // "token" and "session" are left out: lexers, parsers, tool and log
+    // sessions use them far more often than authentication does, and a false
+    // match costs a full-tier review.
+    sensitivePathWords: new Set([
+        "auth",
+        "authn",
+        "authz",
+        "authentication",
+        "authorization",
+        "oauth",
+        "saml",
+        "sso",
+        "jwt",
+        "crypto",
+        "security",
+        "identity",
+        "password",
+        "passwords",
+        "passwd",
+        "credential",
+        "credentials",
+        "secret",
+        "secrets",
+        "login",
+        "permission",
+        "permissions",
+        "acl",
+        "acls",
+    ]),
+};
+export function triage(diffs, policy = defaultTriagePolicy) {
+    const touchesSensitivePath = diffs.some((d) => isSensitivePath(d.newPath, policy) || isSensitivePath(d.oldPath, policy));
+    if (touchesSensitivePath || diffs.length > policy.maxFilesBeforeFull)
+        return "full";
+    const churn = diffs.reduce((sum, d) => sum + d.additions + d.deletions, 0);
+    if (churn <= policy.trivialMaxLines)
+        return "trivial";
+    if (churn <= policy.liteMaxLines)
+        return "lite";
+    return "full";
+}
+function isSensitivePath(path, policy) {
+    return (policy.sensitivePathPatterns.some((p) => p.test(path)) ||
+        pathWords(path).some((w) => policy.sensitivePathWords.has(w)));
+}
+// "src/OAuth2/PasswordHasher.cs" -> o, auth, 2, password, hasher, cs
+function pathWords(path) {
+    return (path.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z]+|\d+/g) ?? []).map((w) => w.toLowerCase());
+}
+//# sourceMappingURL=triage.js.map

package/dist/verify/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./prompt.js";
+export * from "./verify.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/verify/index.js

@@ -0,0 +1,3 @@
+export * from "./prompt.js";
+export * from "./verify.js";
+//# sourceMappingURL=index.js.map

package/dist/verify/prompt.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import type { Finding } from "../domain.js";
+export declare const verificationVerdictSchema: z.ZodEnum<{
+    confirmed: "confirmed";
+    refuted: "refuted";
+    uncertain: "uncertain";
+}>;
+export type VerificationVerdict = z.infer<typeof verificationVerdictSchema>;
+export declare const verificationResponseSchema: z.ZodArray<z.ZodObject<{
+    index: z.ZodNumber;
+    verdict: z.ZodEnum<{
+        confirmed: "confirmed";
+        refuted: "refuted";
+        uncertain: "uncertain";
+    }>;
+    reason: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>>;
+export interface VerificationPrompt {
+    system: string;
+    user: string;
+}
+export declare function buildVerificationPrompt(file: string, findings: readonly Finding[], patch: string, excerpt: string | undefined): VerificationPrompt;
+export declare function fileExcerpt(content: string, findings: readonly Finding[]): string | undefined;
+//# sourceMappingURL=prompt.d.ts.map