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

package/dist/extension/pipeline/verify.js

@@ -54,8 +54,10 @@ import { readFileSync } from "node:fs";
 // backslashed strings that no longer compare equal to the git-derived repoRoot
 // and would break the walk-up termination check.
 import { basename, dirname, join } from "node:path/posix";
+import { readToolchainFile } from "../toolchain/spawnHook.js";
 import { killTreeSync, trackChild } from "./childRegistry.js";
 import { claimCovers } from "./fanout.js";
+import { ciJobInScope } from "./missionChecks.js";
 import { composeAbortSignal } from "./resilience.js";
 import { scrubSecrets } from "./scrubSecrets.js";
 import { snapshotWorkspace } from "./workspace.js";
@@ -67,6 +69,21 @@ import { snapshotWorkspace } from "./workspace.js";
 export const VERIFY_TIMEOUT_MS = 20 * 60_000;
 /** Per-PACKAGE wall-clock budget for the test half (spec §3d); overrun fails open. Ten minutes until 2026-10-09. */
 export const VERIFY_TEST_TIMEOUT_MS = 20 * 60_000;
+/**
+ * The repository-checks half (the plan's approved checks and the pull
+ * request's CI steps) across a whole build: the gate runs after implement,
+ * after each fix turn and every review round, so a cap per call alone could
+ * add an hour to a build.
+ */
+export const REPO_CHECKS_BUILD_BUDGET_MS = 30 * 60_000;
+/** The same half's cap in one gate call, inside the run budget's verify allowance. */
+export const REPO_CHECKS_CALL_BUDGET_MS = 15 * 60_000;
+/** One approved check's or CI step's cap. */
+export const REPO_CHECK_TIMEOUT_MS = 10 * 60_000;
+/** Below this much budget left, the next repository check is not started. */
+const REPO_CHECK_MIN_START_MS = 5_000;
+/** Cannot-run entries named in the note before "and N more". */
+const MAX_NAMED_CANNOT_RUN = 10;
 /** Cap on located findings parsed from one failing run, and on the opaque-tail message. */
 const MAX_LOCATED_FINDINGS = 25;
 const MAX_TAIL_CHARS = 1000;
@@ -129,14 +146,17 @@ export function isFannedOutScript(body) {
  * Parse `git status --porcelain` into repo-relative changed paths. Each line is
  * `XY <path>`; we drop the 2-char XY status + its separating space, and for a
  * rename/copy (`R  old -> new`) take the destination. Pure; the impure git
- * shell-out is {@link snapshotWorkspace}.
+ * shell-out is {@link snapshotWorkspace}, whose status is trimmed as a whole:
+ * a first line ` M path` arrives as `M path`. A whole line always has a space
+ * third, so a line without one lost its leading space and its path starts one
+ * column earlier.
  */
 export function parseChangedPaths(status) {
     const paths = [];
     for (const raw of status.split("\n")) {
-        if (raw.length < 4)
-            continue; // need at least "XY p"
-        const entry = raw.slice(3); // drop the 2-char XY status + its separating space
+        if (raw.length < 3)
+            continue; // need at least "X p"
+        const entry = raw[2] === " " ? raw.slice(3) : raw.slice(2);
         const arrow = entry.indexOf(" -> ");
         const path = (arrow >= 0 ? entry.slice(arrow + 4) : entry).trim();
         if (path)
@@ -640,6 +660,70 @@ export function buildTestEnv(source = process.env) {
     env.CI = "true";
     return env;
 }
+/**
+ * The secrets a repository check never sees: a copy of the host's
+ * `VERIFICATION_SECRET_ENV_VARS` in
+ * `packages/backend/src/integrations/e2b/supervisedCandidateSession.ts`
+ * (`YAGNI_*` goes with the test env). This package cannot import the backend:
+ * a change to either list is a change to both.
+ */
+const REPO_CHECK_SECRET_KEYS = [
+    "OPENAI_API_KEY",
+    "ANTHROPIC_API_KEY",
+    "FIREWORKS_API_KEY",
+    "BASETEN_API_KEY",
+    "GITHUB_TOKEN",
+    "GH_TOKEN",
+];
+/**
+ * The environment an approved check or CI step runs under: the test half's
+ * (no `YAGNI_*`, no NODE_OPTIONS, CI on) minus the secrets the host strips
+ * from its own check runs, on the repository's toolchain when the build named
+ * one (the same PATH and variables the model's shell gets), then the step's
+ * own literal variables.
+ */
+export function buildRepoCheckEnv(source = process.env, toolchain = null, stepEnv = {}) {
+    const env = buildTestEnv(source);
+    for (const key of REPO_CHECK_SECRET_KEYS)
+        delete env[key];
+    const withToolchain = toolchain ? { ...toolchain.env, ...env, PATH: toolchain.path } : env;
+    return { ...withToolchain, ...stepEnv, CI: "true" };
+}
+/** One repository command as the gate runs it: through bash, as Actions runs a `run:` step. */
+function repoCheckArgv(run) {
+    return ["bash", "--noprofile", "--norc", "-eo", "pipefail", "-c", run];
+}
+/**
+ * The porcelain entries in `after` that `before` did not have: what the
+ * repository checks wrote into the tree. A path that was already dirty is the
+ * build's, and is not listed. Pure.
+ */
+export function newTreeEntries(before, after) {
+    const known = new Set(parseChangedPaths(before));
+    return after
+        .split("\n")
+        .filter((line) => line.trim().length >= 3)
+        .flatMap((line) => {
+        const [path] = parseChangedPaths(line);
+        if (!path || known.has(path))
+            return [];
+        return [{ path, untracked: line.trimStart().startsWith("??") }];
+    });
+}
+function runGitQuiet(args, cwd) {
+    return new Promise((resolve, reject) => {
+        execFile("git", args, { cwd, maxBuffer: 1024 * 1024 }, (err) => (err ? reject(err) : resolve()));
+    });
+}
+/** Undo what the repository checks wrote: an untracked path is removed, a tracked one restored. */
+async function defaultUndoTreeWrites(cwd, entries) {
+    const untracked = entries.filter((entry) => entry.untracked).map((entry) => entry.path);
+    const tracked = entries.filter((entry) => !entry.untracked).map((entry) => entry.path);
+    if (untracked.length > 0)
+        await runGitQuiet(["clean", "-fdq", "--", ...untracked], cwd);
+    if (tracked.length > 0)
+        await runGitQuiet(["checkout", "-q", "--", ...tracked], cwd);
+}
 // `signal` is deliberately NOT passed into execFile: Node's built-in abort
 // handling kills via the child's pid, and when the spawn itself failed (missing
 // command, missing cwd) an abort landing in the same tick resolves that to pid 0
@@ -845,7 +929,213 @@ export function makeRunVerify(opts = {}) {
     const exec = opts.exec ?? defaultExec;
     const timeoutMs = opts.timeoutMs ?? VERIFY_TIMEOUT_MS;
     const testTimeoutMs = opts.testTimeoutMs ?? VERIFY_TEST_TIMEOUT_MS;
+    const now = opts.now ?? Date.now;
+    const changedPaths = opts.changedPaths ??
+        (async (cwd, signal, baselinePaths) => {
+            const snapshot = await snapshotWorkspace(cwd, signal);
+            if (!snapshot.tracked)
+                return [];
+            const baseline = new Set(baselinePaths ?? []);
+            return parseChangedPaths(snapshot.status).filter((p) => !baseline.has(p));
+        });
+    const toolchain = opts.toolchain ??
+        (() => {
+            const path = process.env.YAGNI_TOOLCHAIN_FILE?.trim();
+            return path ? readToolchainFile(path) : null;
+        });
+    const treeStatus = opts.treeStatus ?? (async (cwd, signal) => (await snapshotWorkspace(cwd, signal)).status);
+    const undoTreeWrites = opts.undoTreeWrites ?? defaultUndoTreeWrites;
+    // Across the whole build: the half's time spent, and each CI step's failure
+    // keys from the last call it failed in.
+    let repoChecksSpentMs = 0;
+    const lastCiFailure = new Map();
+    /**
+     * The repository-checks half: the plan's approved checks, then the pull
+     * request's CI steps its changed paths trigger. A failure becomes `critical`
+     * findings the fix turn works on, except where it can never clear: a check
+     * the sandbox cannot start, an infra failure, an approved check that already
+     * failed on the unchanged code (the host compares it after the build), and a
+     * CI step that fails exactly as it did before a fix turn (it may fail on the
+     * base too, and the pull request's CI shows it). Those are notes.
+     */
+    async function runRepoChecks(input) {
+        const { file, cwd, signal } = input;
+        const findings = [];
+        const reasons = [];
+        const labels = [];
+        const cannotRun = [];
+        for (const check of file.checks) {
+            if (check.status === "cannot_run")
+                cannotRun.push(`\`${check.command}\`${check.cause ? ` (${check.cause})` : ""}`);
+        }
+        const paths = await changedPaths(cwd, signal, input.baselinePaths);
+        const jobs = file.ciJobs.filter((job) => ciJobInScope(job, paths));
+        for (const job of jobs) {
+            for (const entry of job.cannotRun)
+                cannotRun.push(`CI ${job.name}, "${entry.step}" (${entry.reason})`);
+        }
+        if (cannotRun.length > 0) {
+            const named = cannotRun.slice(0, MAX_NAMED_CANNOT_RUN).join("; ");
+            const more = cannotRun.length > MAX_NAMED_CANNOT_RUN ? `; and ${cannotRun.length - MAX_NAMED_CANNOT_RUN} more` : "";
+            reasons.push(`could not run in the sandbox: ${named}${more}`);
+        }
+        const approved = file.checks.filter((check) => check.status !== "cannot_run");
+        const steps = jobs.flatMap((job) => job.steps.map((step) => ({ job, step })));
+        if (approved.length === 0 && steps.length === 0)
+            return { findings, reasons, labels };
+        const buildLeft = (opts.repoChecksBuildBudgetMs ?? REPO_CHECKS_BUILD_BUDGET_MS) - repoChecksSpentMs;
+        if (buildLeft < REPO_CHECK_MIN_START_MS) {
+            reasons.push("approved checks and CI steps not run again: the build's check budget is spent; the host still runs the approved checks after the build");
+            return { findings, reasons, labels };
+        }
+        const callBudget = Math.min(opts.repoChecksCallBudgetMs ?? REPO_CHECKS_CALL_BUDGET_MS, timeoutMs - (now() - input.callStartedAt), buildLeft);
+        const halfStartedAt = now();
+        const run = {
+            cwd,
+            signal,
+            left: () => callBudget - (now() - halfStartedAt),
+            toolchainFile: toolchain(),
+            findings,
+            reasons,
+            labels,
+            notReached: 0,
+        };
+        const before = await treeStatus(cwd, signal).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            reasons.push(`could not read the tree before the checks, so what they write is not undone: ${scrubSecrets(msg)}`);
+            return null;
+        });
+        try {
+            await runApprovedChecks(run, approved);
+            await runCiSteps(run, steps, new Set(file.checks.map((check) => check.command.trim())));
+        }
+        finally {
+            repoChecksSpentMs += now() - halfStartedAt;
+            // What the checks wrote into the tree (a coverage folder, an updated
+            // snapshot, a build output) is not the build's change: undone, so the
+            // candidate never carries it.
+            if (before !== null) {
+                try {
+                    const written = newTreeEntries(before, await treeStatus(cwd));
+                    if (written.length > 0)
+                        await undoTreeWrites(cwd, written);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    reasons.push(`could not undo what the checks wrote into the tree: ${scrubSecrets(msg)}`);
+                }
+            }
+        }
+        if (run.notReached > 0) {
+            reasons.push(`${run.notReached} approved check(s) or CI step(s) not reached in the gate's time budget; the host still runs the approved checks after the build`);
+        }
+        return { findings, reasons, labels };
+    }
+    /** One repository command's verdict: passed, a note (it could not run), or a failure with its output. */
+    async function runRepoCommand(run, command, dir, stepEnv) {
+        const capMs = Math.min(opts.repoCheckTimeoutMs ?? REPO_CHECK_TIMEOUT_MS, run.left());
+        const composed = composeAbortSignal(run.signal, AbortSignal.timeout(Math.max(1, capMs)));
+        const env = opts.repoChecksEnv
+            ? { ...opts.repoChecksEnv, ...(stepEnv ?? {}) }
+            : buildRepoCheckEnv(process.env, run.toolchainFile, stepEnv);
+        try {
+            const { code, output: rawOutput } = await exec(repoCheckArgv(command), dir, composed, env);
+            if (code === 0)
+                return { kind: "passed" };
+            const output = scrubSecrets(rawOutput);
+            const cls = classifyTestFailure(output, code);
+            if (cls.kind === "infra")
+                return { kind: "note", reason: `could not run: ${cls.reason}` };
+            return { kind: "failed", output, code };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { kind: "note", reason: `could not run: ${scrubSecrets(msg)}` };
+        }
+    }
+    /** A failure's findings, located from the folder the command ran in and prefixed with what ran. */
+    function repoFailureFindings(run, failure, label, prefix, dir) {
+        const cls = classifyTestFailure(failure.output, failure.code);
+        const parsed = cls.kind === "failures" ? cls.findings : parseVerifyFailures(failure.output, failure.code, label);
+        return parsed.map((f) => ({ ...liftFinding(f, run.cwd, dir), message: `${prefix}: ${f.message}` }));
+    }
+    const findingRoom = (run) => Math.max(0, MAX_LOCATED_FINDINGS - run.findings.length);
+    /**
+     * The plan's approved checks, at the repository root as the host runs them.
+     * One that already failed on the unchanged code is a note: the host compares
+     * the two after the build.
+     */
+    async function runApprovedChecks(run, approved) {
+        for (const check of approved) {
+            if (run.signal?.aborted)
+                return;
+            if (run.left() < REPO_CHECK_MIN_START_MS) {
+                run.notReached += 1;
+                continue;
+            }
+            const label = check.command.length > 80 ? `${check.command.slice(0, 77)}...` : check.command;
+            const verdict = await runRepoCommand(run, check.command, run.cwd, undefined);
+            if (verdict.kind === "note") {
+                run.reasons.push(`approved check \`${label}\` ${verdict.reason}`);
+            }
+            else if (verdict.kind === "failed" && check.status === "fails_on_base") {
+                run.reasons.push(`approved check \`${label}\` failed, and it already failed on the unchanged code; the host compares the two after the build`);
+            }
+            else {
+                run.labels.push(label);
+                if (verdict.kind === "failed") {
+                    const found = repoFailureFindings(run, verdict, label, `approved check \`${label}\``, run.cwd);
+                    run.findings.push(...found.slice(0, findingRoom(run)));
+                }
+            }
+        }
+    }
+    /**
+     * The pull request's CI steps, job by job. A job stops at its first failing
+     * step, as it does on the runner; a step that is one of the approved checks
+     * already ran. A step that fails with the same findings it failed with on
+     * the previous call (so after a fix turn) is a note: it may fail on the base
+     * too, and the pull request's CI shows it.
+     */
+    async function runCiSteps(run, steps, approvedCommands) {
+        const stoppedJobs = new Set();
+        for (const { job, step } of steps) {
+            if (run.signal?.aborted)
+                return;
+            if (stoppedJobs.has(job) || approvedCommands.has(step.run.trim()))
+                continue;
+            if (run.left() < REPO_CHECK_MIN_START_MS) {
+                run.notReached += 1;
+                continue;
+            }
+            const where = `CI ${job.name}, step "${step.name}"`;
+            const key = `${job.workflow}\u0000${job.job}\u0000${step.name}\u0000${step.run}`;
+            const dir = step.workingDirectory ? join(run.cwd, step.workingDirectory.replace(/^\.\/+/, "")) : run.cwd;
+            const verdict = await runRepoCommand(run, step.run, dir, step.env);
+            if (verdict.kind === "passed") {
+                lastCiFailure.delete(key);
+                run.labels.push(`CI ${job.name}: ${step.name}`);
+                continue;
+            }
+            stoppedJobs.add(job);
+            if (verdict.kind === "note") {
+                run.reasons.push(`${where} ${verdict.reason}`);
+                continue;
+            }
+            const stepFindings = repoFailureFindings(run, verdict, step.name, where, dir);
+            const keys = new Set(stepFindings.map((f) => f.message));
+            const previous = lastCiFailure.get(key);
+            lastCiFailure.set(key, keys);
+            if (previous && keys.size > 0 && [...keys].every((k) => previous.has(k))) {
+                run.reasons.push(`${where} still fails the same way after a fix turn; it may fail on the base too, and the pull request's CI shows it`);
+                continue;
+            }
+            run.labels.push(`CI ${job.name}: ${step.name}`);
+            run.findings.push(...stepFindings.slice(0, findingRoom(run)));
+        }
+    }
     return async function runVerify(cwd, signal, baselinePaths) {
+        const callStartedAt = now();
         const dirs = await changedDirs(cwd, signal, baselinePaths);
         const commands = detect(cwd, dirs);
         // An explicitly-allowed .yagni-code/verify override IS the whole gate (spec
@@ -853,7 +1143,10 @@ export function makeRunVerify(opts = {}) {
         // alongside it — the repo already told us exactly how to verify.
         const overridden = commands.some((c) => c.source === "override");
         const testCommands = overridden ? [] : detectTests(cwd, dirs);
-        if (commands.length === 0 && testCommands.length === 0) {
+        // The approved checks carry the plan's approval, not the repository's own
+        // choice of how to verify, so an override never takes them out of the loop.
+        const repoFile = opts.repoChecks?.() ?? null;
+        if (commands.length === 0 && testCommands.length === 0 && !repoFile) {
             return { ran: false, ok: true, reason: "verify skipped: no verify command detected", findings: [] };
         }
         const findings = [];
@@ -898,6 +1191,7 @@ export function makeRunVerify(opts = {}) {
         // root cause, and the loop must fix the compile errors first anyway; the
         // round where typecheck goes green runs the tests, so `clean` is never
         // reached without the tests having run (or their absence honestly noted).
+        const typecheckFailed = findings.length > 0;
         const testLabels = [];
         if (testCommands.length > 0) {
             if (findings.length > 0) {
@@ -939,10 +1233,27 @@ export function makeRunVerify(opts = {}) {
                 }
             }
         }
-        // The command labels list only what produced a verdict — on BOTH the
-        // typecheck and test halves — so the FINISH trailer's `passed (<cmds>)`
-        // never claims a check that was infra-skipped or threw (invariant §0.1).
-        const command = [...new Set(typecheckLabels), ...new Set(testLabels)].join(", ");
+        // REPOSITORY-CHECKS HALF: the plan's approved checks and the pull
+        // request's CI steps (`checks.json`), after the test half, under the same
+        // rule: a tree that does not compile fails them for the same root cause.
+        const repoLabels = [];
+        if (repoFile) {
+            if (typecheckFailed) {
+                reasons.push("approved checks and CI steps skipped: the typecheck half failed; a later round runs them");
+            }
+            else {
+                const repo = await runRepoChecks({ file: repoFile, cwd, signal, baselinePaths, callStartedAt });
+                reasons.push(...repo.reasons);
+                repoLabels.push(...repo.labels);
+                if (repo.labels.length > 0)
+                    anyRan = true;
+                findings.push(...repo.findings);
+            }
+        }
+        // The command labels list only what produced a verdict — on every half —
+        // so the FINISH trailer's `passed (<cmds>)` never claims a check that was
+        // infra-skipped or threw (invariant §0.1).
+        const command = [...new Set(typecheckLabels), ...new Set(testLabels), ...new Set(repoLabels)].join(", ");
         if (!anyRan) {
             return { ran: false, ok: true, command, reason: reasons.join("; ") || "verify skipped", findings: [] };
         }

package/dist/goHeadless.d.ts

@@ -14,7 +14,18 @@
  * `--plan-file`, optional `--memo-file`, `--run-id`, `--json`), so what Jack
  * runs locally and what the fleet executes are the same binary and the same
  * pipeline.
+ *
+ * Skills (YAG-784): the launcher also wires the same Claude Code compat seams
+ * an interactive launch gets, minus plugin MCP. In a cloud run the backend's
+ * `sources.json` mission file decides: the repo's committed skills load only
+ * when an admin marked it trusted for agent runs, and the org marketplace and
+ * personal skills snapshots load from AGENT_SOURCES_ROOT. With no such file
+ * (every local run) the folder's own pi trust decides, as it does
+ * interactively. The skill flags reach only the build and fix stages; rules
+ * and agent dirs ride the env to every stage.
  */
+import { type AgentRunSources } from "./agentSources.js";
+import { type ClaudeCompatDeps, type ClaudeCompatLaunch, type CompatSourceSummary } from "./claudeCompat.js";
 import { type OtelLaunchConfig } from "./otel.js";
 /** Mirrors HEADLESS_GO_EXIT in the extension; duplicated to keep the packages independent. */
 export declare const GO_EXIT: {
@@ -28,6 +39,7 @@ interface HeadlessGoModule {
         cwd?: string;
         env?: NodeJS.ProcessEnv;
         childEnv?: NodeJS.ProcessEnv;
+        extraArgs?: string[];
     }) => Promise<{
         exitCode: number;
     }>;
@@ -48,6 +60,12 @@ export interface GoCommandDeps {
     writeErr?: (line: string) => void;
     env?: NodeJS.ProcessEnv;
     cwd?: string;
+    /** Compat seam (tests inject one so nothing reads the real home). */
+    claudeCompat?: (deps: ClaudeCompatDeps) => Promise<ClaudeCompatLaunch>;
+    /** The `sources.json` reader; defaults to `$YAGNI_MISSION_DIR/sources.json`. */
+    readSources?: (env: NodeJS.ProcessEnv) => AgentRunSources | null;
+    /** Root every cloud snapshot dir must sit under; tests point it at a temp dir. */
+    sourcesRoot?: string;
 }
 /**
  * Build the environment every pipeline stage child inherits: the proxy
@@ -68,6 +86,12 @@ export declare function buildHeadlessChildEnv(opts: {
     /** Resolved OTel export config; stage children export when present. */
     otel?: OtelLaunchConfig;
 }): NodeJS.ProcessEnv;
+/** The one stderr line naming what each source contributed; null when there is nothing to say. */
+export declare function skillsSummaryLine(opts: {
+    cloud: AgentRunSources | null;
+    sources: CompatSourceSummary[];
+    refused: string[];
+}): string | null;
 /**
  * Run `yagni go`. Returns the process exit code: 0 only on a verified
  * candidate, 1 on any other pipeline outcome, 2 on a usage or credential

package/dist/goHeadless.js

@@ -14,11 +14,23 @@
  * `--plan-file`, optional `--memo-file`, `--run-id`, `--json`), so what Jack
  * runs locally and what the fleet executes are the same binary and the same
  * pipeline.
+ *
+ * Skills (YAG-784): the launcher also wires the same Claude Code compat seams
+ * an interactive launch gets, minus plugin MCP. In a cloud run the backend's
+ * `sources.json` mission file decides: the repo's committed skills load only
+ * when an admin marked it trusted for agent runs, and the org marketplace and
+ * personal skills snapshots load from AGENT_SOURCES_ROOT. With no such file
+ * (every local run) the folder's own pi trust decides, as it does
+ * interactively. The skill flags reach only the build and fix stages; rules
+ * and agent dirs ride the env to every stage.
  */
 import { randomUUID } from "node:crypto";
 import { mkdirSync } from "node:fs";
+import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { AGENT_SOURCES_ROOT, cloudCompatOptions, missionDirFromEnv, readAgentRunSources, } from "./agentSources.js";
 import { agentDirEnvVar } from "./branding.js";
+import { CLAUDE_AGENT_DIRS_ENV, CLAUDE_PLUGIN_KEYS_ENV, CLAUDE_PLUGIN_MCP_ENV, CLAUDE_RULES_DIRS_ENV, claudeCompatArgs, } from "./claudeCompat.js";
 import { agentDir, credentialsDir } from "./credentials.js";
 import { otelChildEnv, resolveOtelLaunchWithWorkspace } from "./otel.js";
 import { credentialsFromProfile, profilePath, readActiveProfile } from "./profiles.js";
@@ -60,6 +72,83 @@ export function buildHeadlessChildEnv(opts) {
         ...(opts.otel ? otelChildEnv(opts.otel, opts.baseEnv) : {}),
     };
 }
+/** The compat keys a headless launch computes itself rather than inherits. */
+const COMPAT_ENV_KEYS = [CLAUDE_AGENT_DIRS_ENV, CLAUDE_RULES_DIRS_ENV, CLAUDE_PLUGIN_MCP_ENV, CLAUDE_PLUGIN_KEYS_ENV];
+/** The run's working dir as the pipeline will resolve it (`--cwd` wins). */
+function pipelineCwd(args, fallback) {
+    for (let i = 0; i < args.length; i++) {
+        const token = args[i];
+        if (token === "--cwd" && args[i + 1])
+            return resolve(fallback, args[i + 1]);
+        if (token.startsWith("--cwd=") && token.length > 6)
+            return resolve(fallback, token.slice(6));
+    }
+    return fallback;
+}
+function countsOf(s) {
+    const parts = [];
+    const n = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+    if (s.plugins.length > 0)
+        parts.push(n(s.plugins.length, "plugin"));
+    if (s.skills.length > 0)
+        parts.push(n(s.skills.length, "skills dir"));
+    if (s.commands.length > 0)
+        parts.push(n(s.commands.length, "commands dir"));
+    if (s.rulesDirs.length > 0)
+        parts.push(n(s.rulesDirs.length, "rules dir"));
+    if (s.unsupported.length > 0)
+        parts.push(`${s.unsupported.length} not loaded (${s.unsupported.join("; ")})`);
+    return parts.length > 0 ? parts.join(", ") : "nothing to load";
+}
+/** The one stderr line naming what each source contributed; null when there is nothing to say. */
+export function skillsSummaryLine(opts) {
+    const parts = opts.sources.map((s) => {
+        const label = s.kind === "project" ? `${opts.cloud?.repo.fullName ?? "repository"} (trusted)` : s.label;
+        return `${label}: ${countsOf(s)}`;
+    });
+    if (opts.cloud && !opts.cloud.repo.trusted)
+        parts.push(`${opts.cloud.repo.fullName}: repository skills off (not trusted for agent runs)`);
+    for (const refused of opts.refused)
+        parts.push(`${refused} (skipped)`);
+    return parts.length > 0 ? `Skills: ${parts.join(" | ")}` : null;
+}
+/**
+ * The compat argv + env for a headless run. Cloud mode (a valid sources.json)
+ * trusts what the backend decided and never reads HOME; local mode keeps the
+ * folder's pi trust decision and the user's own `~/.claude`. Plugin MCP never
+ * loads headlessly. Never throws: a failure here only means no skills, and
+ * it says so on stderr so it is not mistaken for "nothing configured".
+ */
+async function headlessCompat(opts) {
+    const { cwd, agentDir, childEnv, deps, writeErr } = opts;
+    try {
+        const cloud = (deps.readSources ?? ((env) => readAgentRunSources(missionDirFromEnv(env), writeErr)))(childEnv);
+        const compat = deps.claudeCompat ?? claudeCompatArgs;
+        const base = { cwd, agentDir, env: childEnv, interactive: false, pluginMcp: false };
+        let refused = [];
+        let launch;
+        if (cloud) {
+            const plan = cloudCompatOptions(cloud, deps.sourcesRoot ?? AGENT_SOURCES_ROOT);
+            refused = plan.refused;
+            launch = await compat({
+                ...base,
+                trustOverride: plan.trustOverride,
+                userScope: false,
+                projectNativeSkills: true,
+                extraRoots: plan.extraRoots,
+                marketplaces: plan.marketplaces,
+            });
+        }
+        else {
+            launch = await compat(base);
+        }
+        return { launch, summary: skillsSummaryLine({ cloud, sources: launch.sources ?? [], refused }) };
+    }
+    catch (err) {
+        const why = err instanceof Error && err.message ? err.message : String(err);
+        return { launch: { argv: [], env: {} }, summary: `Skills: not loaded (the skills setup failed: ${why})` };
+    }
+}
 /**
  * Run `yagni go`. Returns the process exit code: 0 only on a verified
  * candidate, 1 on any other pipeline outcome, 2 on a usage or credential
@@ -135,10 +224,27 @@ export async function goCommand(args, deps = {}, cliVersion) {
         writeErr(err instanceof Error ? err.message : String(err));
         return GO_EXIT.usage;
     }
+    const cwd = deps.cwd ?? process.cwd();
+    const compat = await headlessCompat({
+        cwd: pipelineCwd(args, cwd),
+        agentDir: childEnv[agentDirEnvVar()],
+        childEnv,
+        deps,
+        writeErr,
+    });
+    // Recompute the compat keys rather than inherit a parent session's: plugin
+    // MCP especially must never reach a headless stage child.
+    for (const key of COMPAT_ENV_KEYS)
+        delete childEnv[key];
+    Object.assign(childEnv, compat.launch.env);
+    delete childEnv[CLAUDE_PLUGIN_MCP_ENV];
+    if (compat.summary)
+        writeErr(compat.summary);
     const outcome = await headless.runHeadlessGo(args, {
-        cwd: deps.cwd ?? process.cwd(),
+        cwd,
         env: baseEnv,
         childEnv,
+        ...(compat.launch.argv.length > 0 ? { extraArgs: compat.launch.argv } : {}),
     });
     return outcome.exitCode;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.2.4-staging.1803.1",
+  "version": "1.2.4-staging.1821.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "147ecc1626516d816bd7fe11019658ad31c20d74"
+  "yagniSourceSha": "60f51163d9b1184bea0c2dca85cf2b7d07d6d275"
 }