@yagni-app/code-staging 1.2.4-staging.1803.1 → 1.2.4-staging.1821.1

package/dist/claudeCompat.js

@@ -28,10 +28,10 @@
  *
  * Set YAGNI_DISABLE_CLAUDE_COMPAT=1 to turn the whole bridge off.
  */
-import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmdirSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmdirSync, statSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
-import { delimiter, dirname, join, resolve } from "node:path";
-import { discoverClaudePlugins } from "./claudePlugins.js";
+import { delimiter, dirname, join, resolve, sep } from "node:path";
+import { containedExistingPath, discoverClaudePlugins, pluginAssets, readMarketplace, resolveLocalPluginRoot, } from "./claudePlugins.js";
 import { pluginsHome, readLedger } from "./pluginStore.js";
 export const CLAUDE_COMPAT_DISABLE_ENV = "YAGNI_DISABLE_CLAUDE_COMPAT";
 /** Plugin `agents/` dirs for the extension's subagent discovery (delimiter-joined). */
@@ -241,6 +241,137 @@ export function writeTrustDecision(agentDir, cwd, decision) {
         }
     }
 }
+/** Personal root layouts, in load order. */
+export const EXTRA_ROOT_LAYOUT = {
+    skills: ["skills", ".claude/skills", ".agents/skills"],
+    commands: ["commands", ".claude/commands"],
+    rules: ["rules", ".claude/rules"],
+};
+/** Project dirs pi loads only behind its own trust; wired explicitly instead. */
+const PROJECT_NATIVE_SKILLS = [".agents/skills", ".pi/skills"];
+const PROJECT_NATIVE_PROMPTS = [".pi/prompts"];
+/** Bound on the symlink scan of one asset path, so a huge tree can't stall a launch. */
+export const SYMLINK_SCAN_LIMIT = 20_000;
+function isContainedIn(realRoot, real) {
+    return real === realRoot || real.startsWith(realRoot + sep);
+}
+/**
+ * True when `path` (inside `realRoot`) holds no symlink that resolves outside
+ * `realRoot`. A tree too large to scan within the bound counts as unsafe.
+ */
+function symlinksStayInside(path, realRoot, scanLimit = SYMLINK_SCAN_LIMIT) {
+    let budget = scanLimit;
+    const stack = [path];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries;
+        try {
+            if (!lstatSync(current).isDirectory())
+                continue;
+            entries = readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (--budget < 0)
+                return false;
+            const child = join(current, entry.name);
+            if (entry.isSymbolicLink()) {
+                let real;
+                try {
+                    real = realpathSync(child);
+                }
+                catch {
+                    continue; // Dangling: nothing can be read through it.
+                }
+                if (!isContainedIn(realRoot, real))
+                    return false;
+            }
+            else if (entry.isDirectory()) {
+                stack.push(child);
+            }
+        }
+    }
+    return true;
+}
+/**
+ * `<root>/<rel>` as a realpath when it exists, is a directory, stays inside
+ * `root` after symlink resolution, and holds no symlink pointing outside it.
+ * Every source the interactive launcher never read goes through this, so a
+ * hostile link in a repo or snapshot can't hand pi a directory outside it.
+ * `scanLimit` exists for tests: a tree with more entries than it is refused.
+ */
+export function safeSourceDir(root, rel, scanLimit = SYMLINK_SCAN_LIMIT) {
+    const contained = containedExistingPath(root, rel);
+    if (!contained || !isDirectory(contained))
+        return null;
+    let realRoot;
+    try {
+        realRoot = realpathSync(root);
+    }
+    catch {
+        return null;
+    }
+    return symlinksStayInside(contained, realRoot, scanLimit) ? contained : null;
+}
+function emptySummary(label, kind) {
+    return { label, kind, skills: [], commands: [], rulesDirs: [], plugins: [], unsupported: [] };
+}
+function summaryHasContent(s) {
+    return s.skills.length + s.commands.length + s.rulesDirs.length + s.plugins.length + s.unsupported.length > 0;
+}
+function addPluginsToSummary(summary, plugins) {
+    for (const plugin of plugins) {
+        summary.plugins.push(plugin.key);
+        summary.skills.push(...plugin.skillPaths);
+        summary.commands.push(...plugin.commandPaths);
+        summary.unsupported.push(...plugin.unsupported.map((u) => `${plugin.key}: ${u}`));
+    }
+}
+/** The enabled plugins of one marketplace checkout, plus what could not load. Never throws. */
+export function marketplacePlugins(mp) {
+    const marketplace = readMarketplace(mp.root);
+    let realRoot = null;
+    try {
+        realRoot = realpathSync(mp.root);
+    }
+    catch {
+        realRoot = null;
+    }
+    if (!marketplace || !realRoot) {
+        return { plugins: [], unsupported: [".claude-plugin/marketplace.json missing or unreadable"] };
+    }
+    const plugins = [];
+    const unsupported = [];
+    for (const name of new Set(mp.enabled)) {
+        const entry = marketplace.plugins.find((p) => p.name === name);
+        if (!entry) {
+            unsupported.push(`${name}: not in the marketplace`);
+            continue;
+        }
+        const root = resolveLocalPluginRoot(marketplace, entry);
+        if (!root) {
+            unsupported.push(`${name}: plugin source not supported`);
+            continue;
+        }
+        if (!symlinksStayInside(root, realRoot)) {
+            unsupported.push(`${name}: links outside the marketplace`);
+            continue;
+        }
+        const assets = pluginAssets(root, name, {
+            key: `${name}@${marketplace.name}`,
+            origin: "org-marketplace",
+            version: entry.version ?? null,
+        });
+        if (!assets) {
+            unsupported.push(`${name}: nothing to load`);
+            continue;
+        }
+        plugins.push(assets);
+    }
+    return { plugins, unsupported };
+}
 export function compatDisabled(env) {
     const value = env[CLAUDE_COMPAT_DISABLE_ENV];
     return value !== undefined && value !== "" && value !== "0";
@@ -250,27 +381,34 @@ export function compatDisabled(env) {
  * unconditionally, project-sourced dirs/plugins/rules once trusted, asking
  * (and persisting) the trust decision when needed. Everything is fail-soft —
  * compat can only add flags/env, never break a launch.
+ *
+ * The optional deps (`trustOverride`, `userScope`, `pluginMcp`,
+ * `projectNativeSkills`, `extraRoots`, `marketplaces`) serve headless cloud
+ * runs; left unset, the argv and env are exactly the interactive behavior.
  */
 export async function claudeCompatArgs(deps) {
     const env = deps.env ?? process.env;
     if (compatDisabled(env))
         return { argv: [], env: {} };
     const home = deps.homeDir ?? homedir();
-    const projectTrust = readTrustDecision(deps.agentDir, deps.cwd);
+    const userScope = deps.userScope !== false;
+    const projectTrust = deps.trustOverride ?? readTrustDecision(deps.agentDir, deps.cwd);
     let plugins;
     try {
         plugins = discoverClaudePlugins({
             cwd: deps.cwd,
             homeDir: home,
-            yagniLedger: readLedger(pluginsHome(env, home)),
+            ...(userScope ? { yagniLedger: readLedger(pluginsHome(env, home)) } : { includeUserScope: false }),
         });
     }
     catch {
         plugins = { user: [], project: [] };
     }
+    const projectDirs = probeClaudeDirs(deps.cwd);
+    const userDirs = userScope ? probeClaudeDirs(home) : { skills: null, commands: null, rules: null };
     const decision = decideClaudeCompat({
-        project: probeClaudeDirs(deps.cwd),
-        user: probeClaudeDirs(home),
+        project: projectDirs,
+        user: userDirs,
         projectPlugins: plugins.project,
         userPlugins: plugins.user,
         projectTrust,
@@ -286,27 +424,106 @@ export async function claudeCompatArgs(deps) {
             trusted = null;
         }
     }
-    const argv = [...decision.userArgv];
-    if (trusted === true)
+    // Backend-authorized sources (the org marketplace's enabled plugins and the
+    // personal roots) load whatever the folder's trust says.
+    const summaries = [];
+    const orgPlugins = [];
+    // Only keys that will actually load shadow an org copy: an untrusted repo's
+    // plugins never load, so they must not hide the org marketplace's copy.
+    const seenKeys = new Set([...plugins.user, ...(trusted === true ? plugins.project : [])].map((p) => p.key));
+    for (const mp of deps.marketplaces ?? []) {
+        const summary = emptySummary(mp.label, "org-marketplace");
+        const found = marketplacePlugins(mp);
+        const fresh = found.plugins.filter((p) => !seenKeys.has(p.key));
+        for (const p of fresh)
+            seenKeys.add(p.key);
+        orgPlugins.push(...fresh);
+        addPluginsToSummary(summary, fresh);
+        summary.unsupported.push(...found.unsupported);
+        summaries.push(summary);
+    }
+    const extraArgv = [];
+    const extraRulesDirs = [];
+    for (const extra of deps.extraRoots ?? []) {
+        const summary = emptySummary(extra.label, "personal");
+        const found = (rels) => rels.map((rel) => safeSourceDir(extra.root, rel)).filter((dir) => dir !== null);
+        summary.skills.push(...found(EXTRA_ROOT_LAYOUT.skills));
+        summary.commands.push(...found(EXTRA_ROOT_LAYOUT.commands));
+        summary.rulesDirs.push(...found(EXTRA_ROOT_LAYOUT.rules));
+        for (const dir of summary.skills)
+            extraArgv.push("--skill", dir);
+        for (const dir of summary.commands)
+            extraArgv.push("--prompt-template", dir);
+        extraRulesDirs.push(...summary.rulesDirs);
+        summaries.push(summary);
+    }
+    const nativeSkills = [];
+    const nativePrompts = [];
+    if (trusted === true && deps.projectNativeSkills === true) {
+        for (const rel of PROJECT_NATIVE_SKILLS) {
+            const dir = safeSourceDir(deps.cwd, rel);
+            if (dir)
+                nativeSkills.push(dir);
+        }
+        for (const rel of PROJECT_NATIVE_PROMPTS) {
+            const dir = safeSourceDir(deps.cwd, rel);
+            if (dir)
+                nativePrompts.push(dir);
+        }
+    }
+    const argv = [...decision.userArgv, ...pluginsToArgv(orgPlugins), ...extraArgv];
+    if (trusted === true) {
         argv.push(...decision.projectArgv);
+        for (const dir of nativeSkills)
+            argv.push("--skill", dir);
+        for (const dir of nativePrompts)
+            argv.push("--prompt-template", dir);
+    }
     const agentDirs = [
         ...decision.userAgentDirs,
+        ...orgPlugins.flatMap((p) => p.agentDirs),
         ...(trusted === true ? decision.projectAgentDirs : []),
     ];
     // User rules first, project rules last: the extension appends in order, so
     // project rules end up closest to the task — matching Claude Code priority.
     const rulesDirs = [
         ...decision.userRulesDirs,
+        ...extraRulesDirs,
         ...(trusted === true ? decision.projectRulesDirs : []),
     ];
-    const mcpEntries = [
-        ...decision.userMcp,
-        ...(trusted === true ? decision.projectMcp : []),
-    ];
+    // Org plugin servers come from repo config, so they ride the approval gate.
+    const mcpEntries = deps.pluginMcp === false
+        ? []
+        : [
+            ...decision.userMcp,
+            ...pluginMcpEntries(orgPlugins, true),
+            ...(trusted === true ? decision.projectMcp : []),
+        ];
     const loadedKeys = [
         ...plugins.user.map((p) => p.key),
+        ...orgPlugins.map((p) => p.key),
         ...(trusted === true ? plugins.project.map((p) => p.key) : []),
     ];
+    const user = emptySummary("~/.claude", "user");
+    if (userDirs.skills)
+        user.skills.push(userDirs.skills);
+    if (userDirs.commands)
+        user.commands.push(userDirs.commands);
+    user.rulesDirs.push(...decision.userRulesDirs);
+    addPluginsToSummary(user, plugins.user);
+    summaries.unshift(user);
+    if (trusted === true) {
+        const project = emptySummary("repository", "project");
+        if (projectDirs.skills)
+            project.skills.push(projectDirs.skills);
+        if (projectDirs.commands)
+            project.commands.push(projectDirs.commands);
+        project.rulesDirs.push(...decision.projectRulesDirs);
+        project.skills.push(...nativeSkills);
+        project.commands.push(...nativePrompts);
+        addPluginsToSummary(project, plugins.project);
+        summaries.push(project);
+    }
     const extraEnv = {};
     if (agentDirs.length > 0)
         extraEnv[CLAUDE_AGENT_DIRS_ENV] = agentDirs.join(delimiter);
@@ -316,7 +533,10 @@ export async function claudeCompatArgs(deps) {
         extraEnv[CLAUDE_PLUGIN_MCP_ENV] = JSON.stringify(mcpEntries);
     if (loadedKeys.length > 0)
         extraEnv[CLAUDE_PLUGIN_KEYS_ENV] = loadedKeys.join(delimiter);
-    return { argv, env: extraEnv };
+    // Explicitly requested sources are always reported (an empty one is news);
+    // user and project scope only when they contributed something.
+    const sources = summaries.filter((s) => s.kind === "org-marketplace" || s.kind === "personal" || summaryHasContent(s));
+    return { argv, env: extraEnv, ...(sources.length > 0 ? { sources } : {}) };
 }
 function toInventory(plugin, gated) {
     return {

package/dist/claudePlugins.d.ts

@@ -38,7 +38,12 @@
  * cannot reach outside its repo/plugin.
  */
 import type { PluginLedger } from "./pluginStore.js";
-export type PluginOrigin = "yagni" | "claude-code" | "repo-marketplace";
+/**
+ * `org-marketplace`: a workspace's plugin marketplace snapshot handed to a
+ * cloud run (YAG-784); loaded by `claudeCompatArgs`'s `marketplaces` option,
+ * never by `discoverClaudePlugins`.
+ */
+export type PluginOrigin = "yagni" | "claude-code" | "repo-marketplace" | "org-marketplace";
 export interface PluginMcp {
     /** File the servers came from (plugin `.mcp.json` or `plugin.json`). */
     sourcePath: string;
@@ -98,6 +103,8 @@ export interface EnableState {
  * project `.claude/settings.local.json`.
  */
 export declare function readEnabledPlugins(cwd: string, homeDir: string): Map<string, EnableState>;
+/** Project-scope `enabledPlugins` only (no user `~/.claude/settings.json`). */
+export declare function readProjectEnabledPlugins(cwd: string): Map<string, EnableState>;
 /** `~/.claude/plugins/known_marketplaces.json` → marketplace name → checkout dir. */
 export declare function readKnownMarketplaces(homeDir: string): Map<string, string>;
 /**
@@ -142,6 +149,13 @@ export interface DiscoverPluginsDeps {
     homeDir: string;
     /** YAGNI's own ledger (`readLedger` from pluginStore.ts); wins over the mirrored Claude Code state. */
     yagniLedger?: PluginLedger;
+    /**
+     * False skips everything under `homeDir` (the YAGNI ledger, Claude Code's
+     * install ledger, known marketplaces, user `enabledPlugins`), leaving only
+     * the repo's own marketplace and project `enabledPlugins` opt-outs. Headless
+     * cloud runs use it so nothing a sandbox step wrote under HOME can load.
+     */
+    includeUserScope?: boolean;
 }
 /**
  * All locally-present Claude Code plugin content relevant to `cwd`, split by

package/dist/claudePlugins.js

@@ -145,6 +145,13 @@ export function readEnabledPlugins(cwd, homeDir) {
     collectEnabled(join(cwd, ".claude", "settings.local.json"), "project", out);
     return out;
 }
+/** Project-scope `enabledPlugins` only (no user `~/.claude/settings.json`). */
+export function readProjectEnabledPlugins(cwd) {
+    const out = new Map();
+    collectEnabled(join(cwd, ".claude", "settings.json"), "project", out);
+    collectEnabled(join(cwd, ".claude", "settings.local.json"), "project", out);
+    return out;
+}
 /** `~/.claude/plugins/known_marketplaces.json` → marketplace name → checkout dir. */
 export function readKnownMarketplaces(homeDir) {
     const out = new Map();
@@ -365,9 +372,10 @@ function resolveInstalledRoot(key, installed, marketplaces, realCwd) {
  */
 export function discoverClaudePlugins(deps) {
     try {
-        const installed = readInstalledPlugins(deps.homeDir);
-        const enabled = readEnabledPlugins(deps.cwd, deps.homeDir);
-        const marketplaces = readKnownMarketplaces(deps.homeDir);
+        const userScope = deps.includeUserScope !== false;
+        const installed = userScope ? readInstalledPlugins(deps.homeDir) : new Map();
+        const enabled = userScope ? readEnabledPlugins(deps.cwd, deps.homeDir) : readProjectEnabledPlugins(deps.cwd);
+        const marketplaces = userScope ? readKnownMarketplaces(deps.homeDir) : new Map();
         const realCwd = realOrNull(deps.cwd) ?? resolve(deps.cwd);
         const user = [];
         const project = [];
@@ -375,7 +383,7 @@ export function discoverClaudePlugins(deps) {
         // YAGNI-installed plugins are the user's own explicit action (`yagni
         // plugin install`), so both scopes load without ceremony; a project-scope
         // install applies only inside its repo.
-        for (const [key, entries] of Object.entries(deps.yagniLedger?.plugins ?? {})) {
+        for (const [key, entries] of Object.entries((userScope ? deps.yagniLedger?.plugins : undefined) ?? {})) {
             const applicable = entries.filter((e) => {
                 if (!e.enabled || !isDirectory(e.installPath))
                     return false;

package/dist/extension/pipeline/headlessGo.d.ts

@@ -60,6 +60,7 @@
  */
 import { type TreeSnapshotDeps } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
+import { makeRunVerify } from "./verify.js";
 import { type RunBudget } from "./budget.js";
 import type { Finding, JsonEvent, ModelTier, PipelineStage, StageId, StageTag, StageUsage, StopReason } from "./types.js";
 /** One-line usage copy, shared by every argument error. */
@@ -143,10 +144,20 @@ export interface HeadlessGoDeps {
     env?: NodeJS.ProcessEnv;
     /** Environment for spawned stage children. Defaults to `env`. */
     childEnv?: NodeJS.ProcessEnv;
+    /**
+     * Extra pi flags for the build and fix stage children: the launcher's
+     * `--skill` / `--prompt-template` paths (YAG-784). See RunPipelineDeps.extraArgs.
+     */
+    extraArgs?: string[];
     /** Wall clock (epoch ms) the host's time left is anchored to. Defaults to `Date.now`; injected in tests. */
     now?: () => number;
     runPipeline?: typeof defaultRunPipeline;
     readFile?: (path: string) => string;
+    /**
+     * The verify gate a mission run uses, given its `checks.json` (null when
+     * there is none). Defaults to the real gate; injected in tests.
+     */
+    makeRunVerify?: typeof makeRunVerify;
     /** stdout sink; one call per NDJSON line, newline added by the caller. */
     write?: (line: string) => void;
     /** stderr sink for human-readable problems. */

package/dist/extension/pipeline/headlessGo.js

@@ -59,12 +59,15 @@
  * ceilings (`SANDBOX_RUN_BUDGET`), not interactive /go's.
  */
 import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { continuationResumePlan, parseContinuation } from "./continuation.js";
 import { resolveFanoutMode } from "./fanout.js";
 import { makeFanoutBeats } from "./fanoutBeats.js";
 import { normalizeMission } from "./mission.js";
+import { MISSION_CHECKS_FILE_NAME, readMissionChecksFile } from "./missionChecks.js";
 import { startTreeSnapshots } from "./treeSnapshot.js";
 import { runPipeline as defaultRunPipeline } from "./orchestrator.js";
+import { makeRunVerify } from "./verify.js";
 import { loadGroundingEnabled } from "../grounding.js";
 import { codeStateHome } from "../stateHome.js";
 import { parseTierCap, TIER_CAP_ENV } from "./tierCap.js";
@@ -319,9 +322,26 @@ export async function runHeadlessGo(argv, deps = {}) {
     // NDJSON stream as `pipeline_fanout` records, and the mission collector
     // folds them onto the Run.
     const fanoutBeats = makeFanoutBeats();
+    // A mission's approved checks and its pull request's CI jobs, written by the
+    // host beside the ticket: the verify gate runs them inside the loop. No file
+    // (a host that predates it) leaves the gate as it was.
+    let runVerify;
+    if (mission && args.ticketFile) {
+        const checksPath = join(dirname(args.ticketFile), MISSION_CHECKS_FILE_NAME);
+        const read = readMissionChecksFile(checksPath, readFile);
+        if (read.file) {
+            const checks = read.file;
+            runVerify = (deps.makeRunVerify ?? makeRunVerify)({ repoChecks: () => checks });
+        }
+        else if (read.problem !== "missing") {
+            const why = read.problem === "malformed" ? "not a version 1 checks file" : "it could not be read";
+            writeErr(`Ignoring ${checksPath}: ${why}. The verify gate runs its own checks only.`);
+        }
+    }
     const pipelineDeps = {
         cwd,
         childEnv,
+        ...(deps.extraArgs?.length ? { extraArgs: deps.extraArgs } : {}),
         // `go.fanout` rides the same env surface as the tier cap, so a benchmark lane
         // pins the implement diamond without a second flag (spec decision 8).
         fanout: resolveFanoutMode(env),
@@ -336,6 +356,7 @@ export async function runHeadlessGo(argv, deps = {}) {
         ...(deps.stages ? { stages: deps.stages } : {}),
         grounded: deps.grounded ?? grounding,
         ...(mission ? { mission } : {}),
+        ...(runVerify ? { runVerify } : {}),
         ...(continuation ? { continuation: { stageAtStop: continuation.stageAtStop } } : {}),
         ...(resumeFrom ? { resumeFrom } : {}),
         onEvent: (ev, tag) => {

package/dist/extension/pipeline/invocation.d.ts

@@ -73,5 +73,6 @@ export declare function buildStageInvocation(stage: PipelineStage, ctx: {
 export declare function groundedChildArgv(stageArgv: string[], opts: {
     piCli: string;
     extensionPath: string;
+    extraArgs?: string[];
 }): string[];
 //# sourceMappingURL=invocation.d.ts.map

package/dist/extension/pipeline/invocation.js

@@ -89,12 +89,19 @@ export function buildStageInvocation(stage, ctx) {
  */
 export function groundedChildArgv(stageArgv, opts) {
     const userChoseProvider = stageArgv.includes("--provider");
+    // Extra flags (the launcher's `--skill` / `--prompt-template` paths for a
+    // build or fix stage) go before the positional `Task: …` prompt, which pi
+    // reads as the message only while it stays last.
+    const extra = opts.extraArgs ?? [];
+    const passthrough = extra.length > 0 && stageArgv.length > 0
+        ? [...stageArgv.slice(0, -1), ...extra, stageArgv[stageArgv.length - 1]]
+        : stageArgv;
     return [
         opts.piCli,
         "-e",
         opts.extensionPath,
         ...(userChoseProvider ? [] : ["--provider", "yagni"]),
-        ...stageArgv,
+        ...passthrough,
     ];
 }
 //# sourceMappingURL=invocation.js.map

package/dist/extension/pipeline/missionChecks.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `checks.json`, the mission file that hands the build's verify gate what to
+ * run besides its own detected scripts: the plan's approved checks (each with
+ * what the host already knows: it fails on the unchanged code, or the sandbox
+ * cannot start it) and the pull request's CI jobs, read from the repository's
+ * workflows at build time.
+ *
+ * The format's producer is `renderMissionChecksJson` in
+ * `packages/backend/src/integrations/e2b/missionFiles.ts`; this package does
+ * not depend on the backend, so it reads the same version 1 with its own
+ * parser. A change there is a change here. A file that is missing or does not
+ * read as version 1 means no repository checks, never a stopped build.
+ */
+export declare const MISSION_CHECKS_FILE_NAME = "checks.json";
+export type MissionCheckStatus = "runnable" | "fails_on_base" | "cannot_run";
+export interface MissionCheck {
+    command: string;
+    status: MissionCheckStatus;
+    cause?: string;
+}
+export interface MissionCiStep {
+    name: string;
+    run: string;
+    workingDirectory?: string;
+    env?: Record<string, string>;
+}
+export interface MissionCiJob {
+    workflow: string;
+    job: string;
+    name: string;
+    paths?: string[];
+    pathsIgnore?: string[];
+    steps: MissionCiStep[];
+    cannotRun: Array<{
+        step: string;
+        reason: string;
+    }>;
+}
+export interface MissionChecksFile {
+    version: 1;
+    checks: MissionCheck[];
+    ciJobs: MissionCiJob[];
+}
+/** The file, or null when the text is not a well-formed version 1 file. */
+export declare function parseMissionChecksFile(text: string): MissionChecksFile | null;
+/**
+ * Read the file. `missing` (no such file: a host that predates it, or a run
+ * with no mission) is silent; `unreadable` and `malformed` are the caller's to
+ * report once.
+ */
+export declare function readMissionChecksFile(path: string, readFile?: (path: string) => string): {
+    file: MissionChecksFile;
+} | {
+    file: null;
+    problem: "missing" | "unreadable" | "malformed";
+};
+/** GitHub's filter glob: `*` within one path segment, `**` across segments, `?` one character. */
+export declare function globToRegExp(pattern: string): RegExp;
+/**
+ * Whether a change to `changedPaths` runs this job on its pull request, by
+ * GitHub's rules: with `paths`, when any changed path matches; with
+ * `paths-ignore`, unless every changed path is ignored (a new folder is never
+ * taken as ignored). No filter: always. No changed paths: never.
+ */
+export declare function ciJobInScope(job: Pick<MissionCiJob, "paths" | "pathsIgnore">, changedPaths: readonly string[]): boolean;
+//# sourceMappingURL=missionChecks.d.ts.map