@corelayer-ai/cli 0.4.4 → 0.5.0

package/dist/commands/install-skill.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, copyFileSync, unlinkSync, rmdirSync, } from "node:fs";
+import { existsSync, cpSync, rmSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -7,11 +7,11 @@ const SKILL_NAME = "corelayer";
 function getSkillTargetDir() {
     return join(homedir(), ".claude", "skills", SKILL_NAME);
 }
-function getSkillSourcePath() {
+function getSkillSourceDir() {
     const thisFile = fileURLToPath(import.meta.url);
     const distDir = dirname(dirname(thisFile));
     const packageDir = dirname(distDir);
-    return join(packageDir, "skill", "SKILL.md");
+    return join(packageDir, "skill");
 }
 function printInstallHelp() {
     process.stdout
@@ -44,16 +44,15 @@ export async function runInstallSkill(args, ctx) {
         printInstallHelp();
         return;
     }
-    const source = getSkillSourcePath();
-    if (!existsSync(source)) {
-        fail("Skill file not found. The CLI package may be incomplete.");
+    const sourceDir = getSkillSourceDir();
+    if (!existsSync(join(sourceDir, "SKILL.md"))) {
+        fail("Skill files not found. The CLI package may be incomplete.");
     }
     const targetDir = getSkillTargetDir();
-    const targetFile = join(targetDir, "SKILL.md");
-    mkdirSync(targetDir, { recursive: true });
-    copyFileSync(source, targetFile);
+    rmSync(targetDir, { recursive: true, force: true });
+    cpSync(sourceDir, targetDir, { recursive: true });
     if (!ctx.quiet) {
-        process.stdout.write(`Corelayer skill installed to ${targetFile}\n`);
+        process.stdout.write(`Corelayer skill installed to ${targetDir}\n`);
     }
 }
 export async function runUninstallSkill(args, ctx) {
@@ -62,17 +61,10 @@ export async function runUninstallSkill(args, ctx) {
         return;
     }
     const targetDir = getSkillTargetDir();
-    const targetFile = join(targetDir, "SKILL.md");
-    if (!existsSync(targetFile)) {
+    if (!existsSync(targetDir)) {
         fail("Corelayer skill is not installed.");
     }
-    unlinkSync(targetFile);
-    try {
-        rmdirSync(targetDir);
-    }
-    catch {
-        // directory not empty or already removed
-    }
+    rmSync(targetDir, { recursive: true, force: true });
     if (!ctx.quiet) {
         process.stdout.write("Corelayer skill uninstalled.\n");
     }

package/dist/commands/issues.js

@@ -1,7 +1,7 @@
-import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
 import { CorelayerClient } from "../lib/api-client.js";
-import { readConfig, resolveToken, resolveApiUrl } from "../lib/config.js";
+import { readConfig, resolveApiUrl, resolveToken } from "../lib/config.js";
 import { fail, formatDate, printJson, printTable } from "../lib/output.js";
 function readFlag(args, flag) {
     const index = args.indexOf(flag);
@@ -27,7 +27,9 @@ function removeFlags(args) {
             arg === "--page" ||
             arg === "--feedback" ||
             arg === "--last-seen-before" ||
-            arg === "--last-seen-before-or-on") {
+            arg === "--last-seen-before-or-on" ||
+            arg === "--since" ||
+            arg === "--duration") {
             skipNext = true;
             continue;
         }
@@ -55,8 +57,9 @@ USAGE:
 
 SUBCOMMANDS:
   list                  List issues in a group
-  get <id>              Show details for one issue
+  get <id|slug>         Show details for one issue
   summary               Summarize issue health for a group
+  diff                  Show issues new or changed since a timestamp
   close <id>            Close an issue (write operation)
   bulk-close            Close many issues in one request (write operation)
   reopen <id>           Reopen a closed issue (write operation)
@@ -66,25 +69,49 @@ OPTIONS:
   --group <id>          Group ID (or set default-group via 'corelayer config set')
   --status <status>     Filter by status (list)
   --severity <sev>      Filter by severity (list)
-  --limit <n>           Limit results (list)
-  --page <n>            Page number (list)
+  --limit <n>           Limit results (list, diff)
+  --page <n>            Page number (list, diff)
   --feedback <text>     Feedback message (close)
   --last-seen-before <date|preset>
                         Filter bulk-close to issues seen before a cutoff
   --last-seen-before-or-on <date|preset>
                         Filter bulk-close to issues seen on or before a cutoff
+  --since <timestamp|preset>
+                        Diff: ISO 8601 timestamp or preset (1hour, 24hours, 7days, 14days, 30days)
+  --duration <duration>
+                        Diff: human-friendly duration (e.g. 2hours, 4hours, 30m, 1d)
   --yes                 Skip confirmation prompt (delete)
   --json                Output as JSON
   -h, --help            Print help
 
 EXAMPLES:
   corelayer issues list --group g_123 --status Open
-  corelayer issues get i_456 --json
+  corelayer issues get corelayer-prod-engine-20260602-1 --json
+  corelayer issues diff --group g_123 --since 2026-06-01T00:00:00Z
+  corelayer issues diff --group g_123 --since 24hours
+  corelayer issues diff --group g_123 --duration 2hours --limit 50
   corelayer issues close i_456 --feedback "fixed in deploy 2026-04-07"
   corelayer issues bulk-close --group g_123 --last-seen-before-or-on 14days --feedback "Not seen in two weeks"
   corelayer issues delete i_456 --yes
 `);
 }
+function parseDuration(value) {
+    const match = value
+        .trim()
+        .toLowerCase()
+        .match(/^(\d+(?:\.\d+)?)\s*(m|min|minutes?|h|hr|hours?|d|days?)$/);
+    if (!match)
+        return null;
+    const n = parseFloat(match[1]);
+    const unit = match[2];
+    if (unit.startsWith("m"))
+        return Math.round(n * 60 * 1000);
+    if (unit.startsWith("h"))
+        return Math.round(n * 60 * 60 * 1000);
+    if (unit.startsWith("d"))
+        return Math.round(n * 24 * 60 * 60 * 1000);
+    return null;
+}
 export async function runIssues(args, ctx) {
     if (args.includes("--help") || args.includes("-h")) {
         printHelp();
@@ -114,7 +141,7 @@ export async function runIssues(args, ctx) {
             printJson(result);
             return;
         }
-        const rows = result.issues.map(issue => [
+        const rows = result.issues.map((issue) => [
             issue.id,
             issue.slug || "-",
             issue.severity || "-",
@@ -129,11 +156,11 @@ export async function runIssues(args, ctx) {
         return;
     }
     if (sub === "get") {
-        const issueId = commandArgs[0];
-        if (!issueId) {
-            fail("Usage: corelayer issues get <issueId>");
+        const issueIdentifier = commandArgs[0];
+        if (!issueIdentifier) {
+            fail("Usage: corelayer issues get <issueId|slug>");
         }
-        const issue = await client.getIssue(issueId);
+        const issue = await client.getIssue(issueIdentifier);
         if (ctx.json) {
             printJson(issue);
             return;
@@ -239,5 +266,50 @@ export async function runIssues(args, ctx) {
         printJson(summary);
         return;
     }
-    fail("Usage: corelayer issues <list|get|close|bulk-close|reopen|delete|summary> [options]");
+    if (sub === "diff") {
+        const groupId = readFlag(args, "--group") || config.defaults?.group;
+        if (!groupId) {
+            fail("groupId is required. Use --group <groupId> or set default-group via corelayer config set default-group <groupId>");
+        }
+        const sinceFlag = readFlag(args, "--since");
+        const durationFlag = readFlag(args, "--duration");
+        if (!sinceFlag && !durationFlag) {
+            fail("One of --since <timestamp|preset> or --duration <duration> is required.\n" +
+                "Examples: --since 2026-06-01T00:00:00Z  --since 24hours  --duration 2hours");
+        }
+        let sinceValue;
+        if (durationFlag) {
+            const ms = parseDuration(durationFlag);
+            if (ms === null) {
+                fail(`Invalid --duration value: "${durationFlag}". Examples: 30m, 2hours, 4h, 1d, 7days`);
+            }
+            sinceValue = new Date(Date.now() - ms).toISOString();
+        }
+        else {
+            sinceValue = sinceFlag;
+        }
+        const result = await client.diffIssues(groupId, sinceValue, {
+            limit: readFlag(args, "--limit"),
+            page: readFlag(args, "--page"),
+        });
+        if (ctx.json) {
+            printJson(result);
+            return;
+        }
+        process.stdout.write(`DIFF SINCE ${result.since}\n`);
+        const rows = result.issues.map((issue) => [
+            issue.id,
+            issue.slug || "-",
+            issue.severity || "-",
+            issue.status || "-",
+            issue.title || "-",
+            formatDate(issue.last_seen_at || issue.lastSeenAt),
+        ]);
+        printTable(["ID", "SLUG", "SEVERITY", "STATUS", "TITLE", "LAST SEEN"], rows);
+        if (!ctx.quiet) {
+            process.stdout.write(`${result.total} issue${result.total === 1 ? "" : "s"} changed since ${result.since}\n`);
+        }
+        return;
+    }
+    fail("Usage: corelayer issues <list|get|close|bulk-close|reopen|delete|summary|diff> [options]");
 }

package/dist/commands/preflight.js

@@ -0,0 +1,137 @@
+import { execSync } from "node:child_process";
+import { CorelayerClient } from "../lib/api-client.js";
+import { resolveToken, resolveApiUrl } from "../lib/config.js";
+import { fail, printJson } from "../lib/output.js";
+const MAX_DIFF_CHARS = 12_000;
+function printHelp() {
+    process.stdout.write(`corelayer preflight - Check a change against org memory before you push
+
+Surfaces failure modes and things to double-check that your org has hit before for
+changes like this one. Run inside a git repo with no arguments and it derives the PR
+context from your branch; override any piece with the flags below.
+
+USAGE:
+  corelayer preflight [options]
+
+OPTIONS:
+  --title <text>         PR title (default: latest commit subject / branch name)
+  --description <text>   PR description (default: commits since base + changed files)
+  --repo <name>          Repository name (default: parsed from the git remote)
+  --base <ref>           Base branch to diff against (default: origin/HEAD, else main)
+  --diff                 Include the (truncated) code diff in what's sent
+  --json                 Output as JSON
+  -h, --help             Print help
+
+EXAMPLES:
+  corelayer preflight
+  corelayer preflight --diff
+  corelayer preflight --description "Add Redis cache to the payments worker" --repo payments-api
+`);
+}
+function readFlag(args, flag) {
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return args[index + 1];
+}
+function git(args) {
+    try {
+        return execSync(`git ${args}`, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function detectRepo() {
+    const url = git("config --get remote.origin.url");
+    if (!url)
+        return undefined;
+    const match = url.replace(/\.git$/, "").match(/([^/:]+)$/);
+    return match ? match[1] : undefined;
+}
+function detectBase() {
+    const head = git("rev-parse --abbrev-ref origin/HEAD"); // e.g. origin/main
+    if (head && head.startsWith("origin/"))
+        return head.slice("origin/".length);
+    for (const candidate of ["main", "master"]) {
+        if (git(`rev-parse --verify ${candidate}`))
+            return candidate;
+    }
+    return "main";
+}
+function severityColor(sev, noColor) {
+    const label = (sev || "n/a").toUpperCase();
+    if (noColor)
+        return label;
+    const code = sev === "critical" || sev === "high"
+        ? "31" // red
+        : sev === "medium"
+            ? "33" // yellow
+            : "90"; // grey
+    return `\x1b[${code}m${label}\x1b[0m`;
+}
+function printChecks(checks, noColor) {
+    checks.forEach((check, i) => {
+        process.stdout.write(`${i + 1}. ${check.advice}\n`);
+        const seen = check.occurrenceCount > 1 ? ` · seen ${check.occurrenceCount}×` : "";
+        const where = check.scope === "resource" ? check.anchorLabel : check.scope;
+        process.stdout.write(`   ${severityColor(check.severity, noColor)} · "${check.title}" · ${where}${seen}\n`);
+    });
+}
+export async function runPreflight(args, ctx) {
+    if (args.includes("--help") || args.includes("-h")) {
+        printHelp();
+        return;
+    }
+    const base = readFlag(args, "--base") || detectBase();
+    const commits = git(`log ${base}..HEAD --pretty=format:%s%n%b`) || "";
+    const files = git(`diff --name-only ${base}...HEAD`) || "";
+    const branch = git("rev-parse --abbrev-ref HEAD");
+    const repo = readFlag(args, "--repo") || detectRepo();
+    const title = readFlag(args, "--title") || commits.split("\n")[0]?.trim() || branch;
+    let description = readFlag(args, "--description");
+    if (!description) {
+        const parts = [];
+        if (commits.trim())
+            parts.push(commits.trim());
+        if (files.trim())
+            parts.push(`Changed files:\n${files.trim()}`);
+        description = parts.join("\n\n");
+    }
+    if (args.includes("--diff")) {
+        const diff = git(`diff ${base}...HEAD`);
+        if (diff)
+            description += `\n\nDiff:\n${diff.slice(0, MAX_DIFF_CHARS)}`;
+    }
+    if (!description.trim()) {
+        fail(`No PR context found. Run inside a git repo with commits ahead of "${base}", or pass --description.`);
+    }
+    const token = resolveToken();
+    if (!token) {
+        fail("Not authenticated. Set CORELAYER_API_KEY or run: corelayer login");
+    }
+    const apiUrl = resolveApiUrl(ctx.apiUrlOverride);
+    const client = new CorelayerClient(apiUrl, token);
+    const result = await client.preflight({
+        description,
+        title: title || undefined,
+        repo,
+    });
+    if (ctx.json) {
+        printJson(result);
+        return;
+    }
+    if (result.checks.length === 0) {
+        if (!ctx.quiet) {
+            process.stdout.write("✓ Preflight: nothing in org memory to double-check for this change.\n");
+        }
+        return;
+    }
+    if (!ctx.quiet) {
+        process.stdout.write(`Preflight — ${result.checks.length} thing(s) to double-check before you push:\n\n`);
+    }
+    printChecks(result.checks, ctx.noColor);
+}

package/dist/index.js

@@ -8,6 +8,7 @@ import { runIssues } from "./commands/issues.js";
 import { runInstallSkill, runUninstallSkill, } from "./commands/install-skill.js";
 import { runLogin } from "./commands/login.js";
 import { runLogout } from "./commands/logout.js";
+import { runPreflight } from "./commands/preflight.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 function printHelp() {
@@ -23,6 +24,7 @@ COMMANDS:
   api-keys           Create Corelayer API keys
   groups             List and inspect groups
   issues             List, inspect, and manage issues
+  preflight          Check a change against org memory before you push
   integrations       List integrations for a group
   config             Read and write local CLI config
   install-skill      Install the Corelayer agent skill
@@ -119,6 +121,9 @@ async function main() {
         case "integrations":
             await runIntegrations(rest, ctx);
             return;
+        case "preflight":
+            await runPreflight(rest, ctx);
+            return;
         case "config":
             await runConfig(rest, ctx);
             return;

package/dist/lib/api-client.js

@@ -64,6 +64,9 @@ export class CorelayerClient {
     async getIssue(issueId) {
         return this.request("GET", `/api/v1/issues/${issueId}`);
     }
+    async preflight(params) {
+        return this.request("POST", "/api/v1/preflight", params);
+    }
     async closeIssue(issueId, feedback) {
         await this.request("PATCH", `/api/v1/issues/${issueId}`, {
             status: "Closed",
@@ -94,6 +97,15 @@ export class CorelayerClient {
     async deleteIssue(issueId) {
         await this.request("DELETE", `/api/v1/issues/${issueId}`);
     }
+    async diffIssues(groupId, since, options = {}) {
+        const params = new URLSearchParams({ groupId, since });
+        for (const [key, value] of Object.entries(options)) {
+            if (value !== undefined && value !== null && value !== "") {
+                params.set(key, String(value));
+            }
+        }
+        return this.request("GET", `/api/v1/issues/diff?${params.toString()}`);
+    }
     async getIssueSummary(groupId) {
         const params = new URLSearchParams({ groupId });
         return this.request("GET", `/api/v1/issues/summary?${params.toString()}`);
@@ -130,13 +142,13 @@ export class CorelayerClient {
         const suffix = params.toString() ? `?${params.toString()}` : "";
         const raw = await this.request("GET", `/api/v1/integrations/accounts${suffix}`);
         return {
-            accounts: (raw.accounts ?? []).map(account => ({
+            accounts: (raw.accounts ?? []).map((account) => ({
                 id: account.id,
                 group_id: account.group_id,
                 provider_code: account.provider_code,
                 is_active: account.is_active,
                 created_at: account.created_at,
-                resources: (account.resources ?? []).map(resource => ({
+                resources: (account.resources ?? []).map((resource) => ({
                     id: resource.id,
                     resource_type: resource.resource_type,
                     external_id: resource.external_id,
@@ -144,7 +156,7 @@ export class CorelayerClient {
                     is_active: resource.is_active,
                 })),
             })),
-            providers: (raw.providers ?? []).map(provider => ({
+            providers: (raw.providers ?? []).map((provider) => ({
                 provider_code: provider.provider_code,
                 display_name: provider.display_name,
             })),

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@corelayer-ai/cli",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "Corelayer CLI",
   "type": "module",
   "bin": {
-    "corelayer": "./dist/index.js"
+    "corelayer": "dist/index.js"
   },
   "files": [
     "dist",

package/skill/SKILL.md

@@ -5,7 +5,9 @@ description: >
   error analysis, root cause analysis, issue triage, Corelayer, or wants to
   check/manage/close/reopen production issues. Also use when the user says
   "check prod", "what's broken", "any errors", "issue summary", or references
-  the corelayer CLI.
+  the corelayer CLI. Also use before opening or pushing a pull request, or when
+  the user asks what could break, what to watch out for, or for a preflight /
+  pre-merge check on a change.
 user-invocable: true
 ---
 
@@ -37,12 +39,35 @@ corelayer issues list --status open
 ### Inspect a specific issue
 
 ```bash
-corelayer issues get <issueId>
-corelayer issues get <issueId> --json
+corelayer issues get <issueId|slug>
+corelayer issues get <issueId|slug> --json
 ```
 
 Returns: title, status, severity, event count, what happened, root cause, and next steps.
 
+### Diff issues since a timestamp (post-deploy triage)
+
+```bash
+corelayer issues diff --group <groupId> --since 2026-06-01T00:00:00Z
+corelayer issues diff --group <groupId> --since 24hours
+corelayer issues diff --group <groupId> --duration 2hours --limit 50
+corelayer issues diff --group <groupId> --duration 30m --json
+```
+
+Returns issues that are new or changed since the given timestamp. Useful after PR merges/deploys to identify regressions or newly surfaced issues.
+
+### Preflight a change before you push
+
+```bash
+corelayer preflight            # derives PR context from the current git branch
+corelayer preflight --diff     # include the code diff in the check
+corelayer preflight --json
+```
+
+Returns failure modes and things to double-check that the org has hit before for a change
+like this; empty means memory has nothing to flag. See [references/preflight.md](references/preflight.md)
+for flags, how to read the output, and the `corelayer.preflight` MCP tool.
+
 ### Triage issues
 
 ```bash
@@ -84,7 +109,7 @@ Setting a default group avoids repeating `--group` on every command.
 List issues for a group. Requires `--group` or a configured default group.
 Filterable by status (`open`, `closed`) and severity (`critical`, `high`, `medium`, `low`).
 
-### `corelayer issues get <issueId>`
+### `corelayer issues get <issueId|slug>`
 
 Get full details for an issue including AI-generated analysis: what happened, root cause, and next steps.
 
@@ -92,6 +117,18 @@ Get full details for an issue including AI-generated analysis: what happened, ro
 
 Returns a JSON severity breakdown for the group.
 
+### `corelayer issues diff --group <id> (--since <timestamp|preset> | --duration <duration>) [--limit <n>] [--page <n>]`
+
+Returns issues that are new or updated since the given point in time. Useful for post-deploy triage — run after a PR merge to see what regressions or new errors have surfaced.
+
+`--since` accepts an ISO 8601 timestamp (`2026-06-01T00:00:00Z`) or a preset: `1hour`, `24hours`, `7days`, `14days`, `30days`.
+
+`--duration` accepts human-friendly durations: `30m`, `2hours`, `4h`, `1d`, `7days`. The duration is subtracted from the current time to compute the since-timestamp.
+
+`--limit` and `--page` paginate results. The API defaults to 20 results and caps `--limit` at 100.
+
+Use `--json` for machine-readable output suitable for agent automation.
+
 ### `corelayer issues close <issueId> [--feedback "..."]`
 
 Close an issue. Optionally provide feedback (e.g., link to the fix).
@@ -108,6 +145,10 @@ Reopen a previously closed issue.
 
 Soft-delete an issue. Prompts for confirmation unless `--yes` is passed.
 
+### `corelayer preflight [--title <t>] [--description <d>] [--repo <name>] [--base <ref>] [--diff]`
+
+Check a pending change against the org's accumulated memory before opening a PR. With no flags it derives repo/title/description from the current git branch (commits + changed files since the base branch); any flag overrides its piece, and `--diff` includes the patch. Returns grounded, second-person reminders for this change, or nothing when no relevant lesson exists. Full guidance in [references/preflight.md](references/preflight.md).
+
 ### `corelayer groups list`
 
 List all groups in the organization.
@@ -139,9 +180,19 @@ Clear stored credentials.
 ```bash
 corelayer issues summary
 corelayer issues list --severity critical
-corelayer issues get <id> --json
+corelayer issues get <issueId|slug> --json
 ```
 
+### Before you open a pull request
+
+```bash
+corelayer preflight
+```
+
+Run it once the change is ready, before pushing. Surface any returned checks to the user as
+reminders to double-check (they're advisory, not blockers); if it returns nothing, say memory
+had nothing to flag. See [references/preflight.md](references/preflight.md).
+
 ### Scripting and automation
 
 Use `--json` and `--quiet` flags for machine-readable output:

package/skill/references/preflight.md

@@ -0,0 +1,71 @@
+# Preflight — check a change against org memory before you push
+
+Preflight asks Corelayer's organizational brain: *"for a change like this, what has
+bitten this org before?"* It returns specific, second-person reminders grounded in past
+incidents, facts, decisions, and standing preferences for the services the change touches —
+e.g. an env-var flag that's broken prod deploys before, a packaging step a service has missed,
+a config that needs to be set in every environment. It returns nothing when no relevant lesson
+exists, so an empty result is a meaningful "all clear from memory."
+
+Run it after the work is done and before opening the PR, as a final review pass.
+
+## CLI
+
+Run inside the git repo with no arguments — it derives the PR context from the branch:
+
+```bash
+corelayer preflight
+```
+
+- **repo** ← parsed from the git remote (`origin`)
+- **title** ← the latest commit subject (falls back to the branch name)
+- **description** ← commit messages since the base branch + the list of changed files
+- **base** ← `origin/HEAD` (else `main`/`master`)
+
+Override any piece, or include the actual diff for a richer signal:
+
+```bash
+corelayer preflight --diff
+corelayer preflight --base develop
+corelayer preflight --title "Add Redis cache" --description "Caches payment lookups in the worker" --repo payments-api
+corelayer preflight --json          # machine-readable, for automation
+```
+
+If there are no commits ahead of the base branch (nothing to describe), pass `--description`
+explicitly.
+
+## Reading the output
+
+Each check is one reminder plus its grounding:
+
+```
+1. Double-check the prod env-var flags — deploys here have failed before when they were missing.
+   CRITICAL · "Missing/Incorrect Environment Variables in Deployments" · payments-api · seen 30×
+```
+
+- **severity** — `critical | high | medium | low` of the underlying lesson.
+- **"title"** — the lesson the reminder is grounded in (cite-and-verify; the wording is generated, the lesson is real).
+- **service / scope** — the service the lesson is anchored to, or `system` / `cross-cutting` for org-wide lessons.
+- **seen N×** — how many times the org has hit this; higher = more established.
+
+`--json` also returns `consideredCount` (lessons in the org's catalog) and `pulledCount`
+(lessons the judge read in full for this change).
+
+## How to act on it
+
+- Treat the checks as **reminders, not blockers** — preflight is advisory and fails open
+  (it never blocks a push). Surface them to the user and let them decide.
+- An **empty result is normal and useful** — it means nothing in memory maps to this change.
+  Don't manufacture concerns; say memory had nothing to flag.
+- Higher `seen N×` and `critical`/`high` severity deserve the most attention.
+
+## MCP equivalent
+
+If the Corelayer MCP server is connected, the same capability is the `corelayer.preflight`
+tool (read-only), taking `{ description, title?, repo? }`. Use it when you already have the
+PR text in context and don't need the CLI's git gathering.
+
+## Notes
+
+- Scoped to your organization via the API key — it only sees your org's memory.
+- Read-only; requires authentication (`corelayer login` or `CORELAYER_API_KEY`).