@bridge_gpt/mcp-server 0.2.68 → 0.2.70

package/build/shared-resources.generated.js

@@ -0,0 +1,5 @@
+// AUTO-GENERATED — do not edit manually. Regenerate with: npm run build
+// This file is produced by scripts/bundle-pipelines.js
+export const SHARED_RESOURCES = {
+    "epic-contract-resolution-duty.md": "# Epic-contract resolution duty (version 1)\n\nThis ticket is a confirmed child of an epic. Resolve every review finding — Confirmed Improvements, Needs Scrutiny, Open Questions, and every clarifying answer — against the epic's current contracts before you finalize it. This duty adds evidence to your decision. It does not replace the review's other rules, and it does not tell you to accept or reject critique by default.\n\n## 1. What counts as an obligation\n\n- The **current text** of the parent epic and of each sibling ticket is the requirement source. A normative statement there (\"must\", \"never\", \"owns\", \"exposes\", \"no migration\", an acceptance criterion) is a mandatory obligation.\n- **Inspected code** at `fresh_base_root` is feasibility evidence: it shows what exists and what a change would touch. Code does not create an obligation, and a changed file is not a changed scope.\n- A stale attachment, an old review document, or an earlier plan never overrides current ticket text. If you already met such historical material and it disagrees with current text, say so in one line, decide from current text, and name the ticket that owns the disputed requirement. A discrepancy alone is never a blocker.\n\n## 2. Choose relevant sources, not every source\n\n- Start from the parent requirements and the sibling inventory summaries in the context response.\n- Request a sibling's text (`sibling_keys`) only when a finding, the parent, a summary, an explicit reference, or an inspected interface ties it to the change: it produces something this ticket consumes, consumes something this ticket produces, or owns a behavior the finding would change.\n- Leave irrelevant siblings unhydrated. Never claim anything about a sibling whose text you did not receive.\n- A completed sibling's contract still binds. Its work has shipped, so the obligation is now also code.\n\n## 3. Resolve each finding\n\nFor each finding, check the proposed change's effect on every relevant producer or consumer obligation. Then choose one:\n\n- **Accept** it when it is a beneficial, in-scope fix that keeps every cited obligation. A finding is not suspect because a critic raised it.\n- **Adapt** it when its goal is sound but its form breaks an obligation, and a compatible form exists. Record the adapted direction.\n- **Reject** it when it would break an obligation and no compatible form serves its goal.\n- **Select a supported alternative** when the ticket, a sibling, or the code already offers a compatible way to meet the goal.\n\nRecord for each decision: the contract source (ticket key and `content_sha256`), the obligation in a short quote or paraphrase, the effect of the change on it, and the inspected code location (`file:symbol` at `base_sha`).\n\n## 4. Report coverage truthfully\n\n- Cite only sources whose `outcome` is `fetched` or `partial`. For `partial`, cite only the returned range.\n- When the response lists gaps — `missing`, `failed`, `unhydrated`, an incomplete inventory, a reached bound — disclose them in one plain line and keep resolving with the evidence you have. Missing context is a limitation, not a conflict and not a reason to stop.\n- Never write that a contract was checked when its text was not returned.\n\n## 5. Before final capture, revalidate what you relied on\n\nPass each cited source's `ticket_key` and `content_sha256` in `revalidate`. Reassess only the decisions whose sources came back `changed`. If revalidation is `unavailable`, disclose that and keep the earlier evidence; do not claim the source is unchanged.\n\n## 6. The only stop: mandatory incompatibility\n\nStop automatic finalization **only** when all of these hold:\n\n1. Two or more cited, current, mandatory obligations cannot all hold at once.\n2. You tried a supported interpretation of each, rejecting or adapting the suggestion, and every compatible alternative you could find.\n3. No decision within this ticket's scope can satisfy them all without abandoning an explicit obligation.\n\nAmbiguity, disagreement between reviewers, several valid options, optional improvements, unavailable context, and imperfect documentation never meet this threshold. Resolve those automatically and record your choice.\n\nWhen the threshold is met, set the finding's status to `mandatory_incompatibility` and record: the exact conflicting obligations with their sources, every alternative you attempted and why it failed, and the one decision you recommend (which obligation should change, and who owns it). Do not record that finding as accepted or dismissed, do not write a binding instruction that claims every obligation holds, and do not report the review as finalized. Waiving another ticket's obligation is that ticket owner's decision; route it to them.\n"
+};

package/build/start-tickets.js

@@ -63,6 +63,8 @@ import path from "path";
 import { fileURLToPath } from "node:url";
 import { validateHttpBaseUrl } from "./base-url.js";
 import { VERSION } from "./version.generated.js";
+import { getNoticeDecision } from "./session-upgrade-notice.js";
+import { formatUpdateAdvice } from "./upgrade-advice.js";
 import { resolveBapiCredentials, getPrimaryCredentialStorePath, } from "./credential-store.js";
 import { LEGACY_SERVER_NAMES, MCP_PACKAGE_NAME, MCP_SERVER_NAME } from "./mcp-identity.js";
 // BAPI-941: the shared drift diagnostic formatter. The leaf drift module imports
@@ -199,6 +201,7 @@ export function parseStartTicketsArgs(argv) {
     let hostPlatform;
     let baseBranch = "main";
     let conductorEnabled = false;
+    let verificationScope;
     // BAPI-948: `--guard-stale-branch` (and `--conductor`, which implies it) opt the
     // packaged CLI into the F7 stale-branch guard. Tracked separately from
     // `conductorEnabled` so the pilot can take the safety check WITHOUT taking the
@@ -221,6 +224,13 @@ export function parseStartTicketsArgs(argv) {
     const keys = [];
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
+        if (arg === "--verification-scope" || arg.startsWith("--verification-scope=")) {
+            const value = arg.startsWith("--verification-scope=") ? arg.slice("--verification-scope=".length) : argv[++i];
+            if (value !== "full" && value !== "targeted")
+                return { status: "error", message: "--verification-scope requires full or targeted" };
+            verificationScope = value;
+            continue;
+        }
         const takeValue = () => {
             // The `--flag=value` form is handled inline by callers; this reads the
             // separate next token for the `--flag value` form.
@@ -552,6 +562,7 @@ export function parseStartTicketsArgs(argv) {
             agentName: resolvedAgentName,
             baseBranch,
             conductorEnabled,
+            ...(verificationScope ? { verificationScope } : {}),
             workflow,
             reviewRounds,
             // BAPI-948: include `guardStaleWorktree` ONLY when the run asked for the F7
@@ -622,7 +633,7 @@ resumeMode = false, workflow = "implement", reviewRounds,
 // command.
 baseBranch, bridgeApiBaseUrlOverride, 
 // BAPI-1365: a recognized operator `--tier`, forwarded to the review prompt.
-manualTier) {
+manualTier, verificationScope) {
     if (!isSupportedStartTicketsPlatform(deps.platform)) {
         return { ok: false, error: unsupportedPlatformMessage(deps.platform) };
     }
@@ -643,7 +654,7 @@ manualTier) {
             // falls back to the basename-derived repo name (the 403 root cause), and
             // (BAPI-586/BAPI-801) the run base so the spawned worker opens its PR
             // against it. The base assignment stays outermost.
-            buildAgentShellCommand: (key, worktreePath, modelAlias, launchArgs) => prependBaseBranchEnvAssignment(prependRepoNameEnvAssignment(buildAgentShellCommand(agent, key, worktreePath, platform, autoApprove, modelAlias, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, launchArgs, bridgeApiBaseUrl, manualTier), repoName, platform), prBaseBranch, platform),
+            buildAgentShellCommand: (key, worktreePath, modelAlias, launchArgs) => prependBaseBranchEnvAssignment(prependRepoNameEnvAssignment(buildAgentShellCommand(agent, key, worktreePath, platform, autoApprove, modelAlias, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, launchArgs, bridgeApiBaseUrl, manualTier, verificationScope), repoName, platform), prBaseBranch, platform),
             spawnTerminalTab: deps.spawnTerminalTab,
         },
     };
@@ -1384,7 +1395,9 @@ export async function resumeWorktrees(deps, options) {
  * Single line (no newlines, no `;`, no quotes/apostrophes) so it stays safe when
  * single-quoted into a shell command and embedded in terminal-launcher args.
  */
-export function buildResumeModeRemediationFinalizeInstruction() {
+export function buildResumeModeRemediationFinalizeInstruction(scope = "full") {
+    if (scope === "targeted")
+        return "Explicit epic targeted verification scope: run focused repair checks and mandatory local obligations once at the final artifact. Defer only server-approved CI coverage joins to named required checks. Missing coverage stays local and actual failures remain blockers. Do one renewal pass and one confirming readiness read. Never treat a focused subset as suite proof.";
     return ("Resume-mode remediation finalize: you were re-dispatched to fix a blocked ticket " +
         "(a merge conflict, a CI failure, or requested review changes). First rebase against " +
         "the current base branch and resolve the merge conflicts. A clean textual merge can " +
@@ -1446,7 +1459,9 @@ export function buildAgentPrompt(key, opts = {}) {
         // read $BAPI_BASE_BRANCH for them.
         parts.push(buildPrBaseContractLaunchInstruction());
     }
-    if (opts.resumeMode)
+    if (opts.verificationScope === "targeted")
+        parts.push(buildResumeModeRemediationFinalizeInstruction("targeted"));
+    else if (opts.resumeMode)
         parts.push(buildResumeModeRemediationFinalizeInstruction());
     return parts.join(" ");
 }
@@ -1498,13 +1513,13 @@ export function buildAgentInvocation(agent, prompt, quote, modelAlias, launchArg
     }
 }
 /** POSIX agent shell command: `cd '<path>' && <agent> [--model '<alias>'] '<prompt>'`. */
-export function buildPosixAgentShellCommand(agent, key, worktreePath, autoApprove = false, modelAlias, conductorEnabled = false, resumeMode = false, workflow = "implement", reviewRounds, baseBranch, launchArgs = [], bridgeApiBaseUrl, manualTier) {
-    const invocation = buildAgentInvocation(agent, buildAgentPrompt(key, { autoApprove, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, agentName: agent.name, manualTier }), (p) => `'${shSquoteInner(p)}'`, modelAlias, agent.name === "cursor-agent" && autoApprove ? worktreePath : launchArgs);
+export function buildPosixAgentShellCommand(agent, key, worktreePath, autoApprove = false, modelAlias, conductorEnabled = false, resumeMode = false, workflow = "implement", reviewRounds, baseBranch, launchArgs = [], bridgeApiBaseUrl, manualTier, verificationScope) {
+    const invocation = buildAgentInvocation(agent, buildAgentPrompt(key, { autoApprove, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, agentName: agent.name, manualTier, verificationScope }), (p) => `'${shSquoteInner(p)}'`, modelAlias, agent.name === "cursor-agent" && autoApprove ? worktreePath : launchArgs);
     return `cd '${shSquoteInner(worktreePath)}' && ${prependBridgeApiBaseUrlEnvAssignment(invocation, bridgeApiBaseUrl, "darwin")}`;
 }
 /** PowerShell agent shell command: `Set-Location -LiteralPath '<path>'; <agent> [--model '<alias>'] '<prompt>'`. */
-export function buildPowerShellAgentShellCommand(agent, key, worktreePath, autoApprove = false, modelAlias, conductorEnabled = false, resumeMode = false, workflow = "implement", reviewRounds, baseBranch, launchArgs = [], bridgeApiBaseUrl, manualTier) {
-    const invocation = buildAgentInvocation(agent, buildAgentPrompt(key, { autoApprove, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, agentName: agent.name, manualTier }), powershellSquote, modelAlias, agent.name === "cursor-agent" && autoApprove ? worktreePath : launchArgs);
+export function buildPowerShellAgentShellCommand(agent, key, worktreePath, autoApprove = false, modelAlias, conductorEnabled = false, resumeMode = false, workflow = "implement", reviewRounds, baseBranch, launchArgs = [], bridgeApiBaseUrl, manualTier, verificationScope) {
+    const invocation = buildAgentInvocation(agent, buildAgentPrompt(key, { autoApprove, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, agentName: agent.name, manualTier, verificationScope }), powershellSquote, modelAlias, agent.name === "cursor-agent" && autoApprove ? worktreePath : launchArgs);
     return `Set-Location -LiteralPath ${powershellSquote(worktreePath)}; ${prependBridgeApiBaseUrlEnvAssignment(invocation, bridgeApiBaseUrl, "win32")}`;
 }
 /**
@@ -1515,10 +1530,10 @@ export function buildPowerShellAgentShellCommand(agent, key, worktreePath, autoA
  * injected as `--model` at the spawn boundary. `conductorEnabled` appends the
  * BAPI-586 PR-base contract instruction to the prompt (opt-in via `--conductor`).
  */
-export function buildAgentShellCommand(agent, key, worktreePath, platform = "darwin", autoApprove = false, modelAlias, conductorEnabled = false, resumeMode = false, workflow = "implement", reviewRounds, baseBranch, launchArgs = [], bridgeApiBaseUrl, manualTier) {
+export function buildAgentShellCommand(agent, key, worktreePath, platform = "darwin", autoApprove = false, modelAlias, conductorEnabled = false, resumeMode = false, workflow = "implement", reviewRounds, baseBranch, launchArgs = [], bridgeApiBaseUrl, manualTier, verificationScope) {
     if (platform === "win32")
-        return buildPowerShellAgentShellCommand(agent, key, worktreePath, autoApprove, modelAlias, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, launchArgs, bridgeApiBaseUrl, manualTier);
-    return buildPosixAgentShellCommand(agent, key, worktreePath, autoApprove, modelAlias, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, launchArgs, bridgeApiBaseUrl, manualTier);
+        return buildPowerShellAgentShellCommand(agent, key, worktreePath, autoApprove, modelAlias, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, launchArgs, bridgeApiBaseUrl, manualTier, verificationScope);
+    return buildPosixAgentShellCommand(agent, key, worktreePath, autoApprove, modelAlias, conductorEnabled, resumeMode, workflow, reviewRounds, baseBranch, launchArgs, bridgeApiBaseUrl, manualTier, verificationScope);
 }
 /**
  * Build the shell command run inside a spawned tab/session for an ARBITRARY
@@ -2146,7 +2161,7 @@ export function buildDryRunResults(keys, overrides) {
  * PowerShell on Windows, `wt` + POSIX on macOS/Linux, and a non-throwing `wt` +
  * POSIX fallback for unsupported platforms.
  */
-export function getDryRunPlatformDetails(agent, platform = process.platform, env = process.env, autoApprove = false, conductorEnabled = false, repoName = null, workflow = "implement", reviewRounds, baseBranch, manualTier) {
+export function getDryRunPlatformDetails(agent, platform = process.platform, env = process.env, autoApprove = false, conductorEnabled = false, repoName = null, workflow = "implement", reviewRounds, baseBranch, manualTier, verificationScope) {
     return {
         worktrunkBinary: resolveWorktrunkBinary(platform, env),
         // The builder accepts an optional resolved modelAlias; the dry-run caller
@@ -2198,7 +2213,7 @@ export function buildDryRunMcpProvisioningLines(worktreePath, platform = process
  * the secret-free MCP provisioning preview. Pure platform formatting only — no
  * preflight, no routing failures.
  */
-export function buildDryRunDetailLines(agent, key, branch, platform = process.platform, env = process.env, baseBranch = "main", autoApprove = false, modelAlias = null, conductorEnabled = false, repoName = null, mcpServerInvocation, workflow = "implement", reviewRounds, manualTier) {
+export function buildDryRunDetailLines(agent, key, branch, platform = process.platform, env = process.env, baseBranch = "main", autoApprove = false, modelAlias = null, conductorEnabled = false, repoName = null, mcpServerInvocation, workflow = "implement", reviewRounds, manualTier, verificationScope) {
     const { worktrunkBinary, buildAgentShellCommand: build } = getDryRunPlatformDetails(agent, platform, env, autoApprove, conductorEnabled, repoName, workflow, reviewRounds, baseBranch, manualTier);
     const wtArgs = buildWtSwitchArgs(branch, false, baseBranch);
     const agentInvocation = build(key, "<worktree-path>", modelAlias);
@@ -3922,7 +3937,7 @@ export async function orchestrateStartTickets(deps, options, overrides = {}) {
     // epic.base_branch override applied above) so the spawned worker gets
     // BAPI_BASE_BRANCH — every conductor worker, and a plain worker whose base
     // is non-default.
-    options.baseBranch, bridgeApiBaseUrl, isModelTier(options.injectedTier) ? options.injectedTier : undefined);
+    options.baseBranch, bridgeApiBaseUrl, isModelTier(options.injectedTier) ? options.injectedTier : undefined, options.verificationScope);
     if (!platformConfig.ok)
         return { ok: false, error: platformConfig.error };
     // BAPI-527: resolve the base start point new worktrees are cut from BEFORE any
@@ -4150,6 +4165,19 @@ export async function runStartTicketsCli(argv, overrides = {}) {
     const options = parsed.options;
     const rawDeps = overrides.deps ?? createDefaultStartTicketsDeps();
     const orchestrate = overrides.orchestrate ?? orchestrateStartTickets;
+    // BAPI-1446: one cache-only upgrade reminder per run, on the existing stderr
+    // sink. The decision is evaluated over the EFFECTIVE environment, so a worker's
+    // markers (set when this CLI is itself run by an unattended process) keep it
+    // silent. It reads the local cache only, never the network, and any failure is
+    // contained: it never changes command execution or the exit status.
+    try {
+        const decision = (overrides.upgradeNotice ?? ((env) => getNoticeDecision(env, VERSION)))(rawDeps.env);
+        if (decision.show)
+            errorLog(formatUpdateAdvice(decision.current, decision.latest));
+    }
+    catch {
+        // Advisory only.
+    }
     // The parser validates `--agent`, so this resolves to a real spec; the guard
     // is defensive only.
     const agent = resolveAgentSpec(options.agentName);
@@ -4192,7 +4220,7 @@ export async function runStartTicketsCli(argv, overrides = {}) {
             const branch = resolveBranchForTicket(key, options.branchOverrides);
             const routedRow = routedByKey.get(key);
             const modelAlias = routedRow?.modelAlias ?? null;
-            for (const line of buildDryRunDetailLines(agent, key, branch, deps.platform, deps.env, options.baseBranch, options.autoApprove, modelAlias, options.conductorEnabled ?? false, dryRunRepoName, dryRunMcpInvocation, options.workflow, options.reviewRounds, isModelTier(options.injectedTier) ? options.injectedTier : undefined)) {
+            for (const line of buildDryRunDetailLines(agent, key, branch, deps.platform, deps.env, options.baseBranch, options.autoApprove, modelAlias, options.conductorEnabled ?? false, dryRunRepoName, dryRunMcpInvocation, options.workflow, options.reviewRounds, isModelTier(options.injectedTier) ? options.injectedTier : undefined, options.verificationScope)) {
                 log(line);
             }
             log(`DRY-RUN:   model routing: ${formatModelRoutingLine(routedRow ?? { key, branch, status: "dry-run" }, agent, { workflow: options.workflow })}`);

package/build/test-command-detection.js

@@ -0,0 +1,247 @@
+/**
+ * Read-only test-command detection (BAPI-1460).
+ *
+ * Proposes the one runnable command a repository's CI workflow should run. It
+ * READS ONLY: the stored command, the learned `unit_testing_stack` prose, and a
+ * handful of repository files. It never runs the command, never runs a package
+ * manager, never imports Python, never evaluates a Make recipe, never prompts,
+ * and never writes. Its dependency surface has no subprocess runner, no prompt
+ * function, and no configuration writer, so it cannot.
+ *
+ * ## Order
+ *
+ * 1. A stored command (`GET /setup/testing-config`) wins, with no question.
+ * 2. Otherwise repository files are scanned, in a fixed order: JavaScript
+ *    (`package.json` `scripts.test`, runner from the lockfile), Make (a real
+ *    `test:` target), pytest (each listed marker), Go (`go.mod`), Rust
+ *    (`Cargo.toml`).
+ * 3. When more than one stack is detected, the learned `unit_testing_stack`
+ *    prose picks among them through a fixed vocabulary. It is a hint and is
+ *    never interpreted as a command.
+ * 4. No candidate means exactly one required question, with no default.
+ *
+ * ## Caller contract (the setup command)
+ *
+ * - `question: "none"` — use `selected` as is.
+ * - `question: "accept_or_replace"` — ask once, offering `selected` as the
+ *   default and the other candidates as alternatives.
+ * - `question: "required"` — ask once with no default. An empty answer is the
+ *   named cancellation outcome {@link TEST_COMMAND_DETECTION_CANCELLED}; nothing
+ *   is stored.
+ * - Every chosen or typed command is validated with `validateTestCommand` and
+ *   saved through `PUT /setup/testing-config`. An invalid answer is explained
+ *   with the validation message and is never stored.
+ *
+ * A detected command is an UNVERIFIED proposal: passing the syntax rules does
+ * not mean the command was run or that it works.
+ */
+import { readStoredTestCommand, readUnitTestingStack, } from "./testing-config-client.js";
+/** The stacks detection recognizes, in detection order. */
+export const DETECTED_STACKS = ["javascript", "make", "python", "go", "rust"];
+/** Named outcome for an empty answer to the required question. */
+export const TEST_COMMAND_DETECTION_CANCELLED = "test_command_not_provided";
+class DetectionReadError extends Error {
+    reason;
+    file;
+    constructor(reason, file) {
+        super(reason);
+        this.reason = reason;
+        this.file = file;
+    }
+}
+function isMissing(err) {
+    const code = typeof err === "object" && err !== null ? err.code : undefined;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+async function readOptional(deps, relPath) {
+    try {
+        return await deps.readFile(relPath);
+    }
+    catch (err) {
+        if (isMissing(err))
+            return null;
+        throw new DetectionReadError("repository_read_failed", relPath);
+    }
+}
+async function detectJavaScript(deps) {
+    const raw = await readOptional(deps, "package.json");
+    if (raw === null)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new DetectionReadError("malformed_repository_file", "package.json");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new DetectionReadError("malformed_repository_file", "package.json");
+    }
+    const scripts = parsed.scripts;
+    if (!scripts || typeof scripts !== "object" || Array.isArray(scripts))
+        return null;
+    const test = scripts.test;
+    if (typeof test !== "string" || test.trim().length === 0)
+        return null;
+    if ((await readOptional(deps, "pnpm-lock.yaml")) !== null) {
+        return { stack: "javascript", command: "pnpm test", provenance: "package.json + pnpm-lock.yaml", verified: false };
+    }
+    if ((await readOptional(deps, "yarn.lock")) !== null) {
+        return { stack: "javascript", command: "yarn test", provenance: "package.json + yarn.lock", verified: false };
+    }
+    return { stack: "javascript", command: "npm test", provenance: "package.json", verified: false };
+}
+/**
+ * Whether a Makefile declares a real `test` target: a rule line (not a recipe,
+ * comment, or variable assignment such as `test := x`) whose target list
+ * includes `test`. `.PHONY: test` alone does not count. Recipes are never read.
+ */
+export function makefileHasTestTarget(text) {
+    for (const line of text.split(/\r\n|\n|\r/)) {
+        if (/^[\t #]/.test(line))
+            continue;
+        const rule = /^([^:=#]+?)\s*::?(?!=)/.exec(line);
+        if (!rule)
+            continue;
+        if (rule[1].trim().split(/\s+/).includes("test"))
+            return true;
+    }
+    return false;
+}
+async function detectMake(deps) {
+    // GNU make's own lookup order; only the first file present is read.
+    for (const name of ["GNUmakefile", "makefile", "Makefile"]) {
+        const raw = await readOptional(deps, name);
+        if (raw === null)
+            continue;
+        if (!makefileHasTestTarget(raw))
+            return null;
+        return { stack: "make", command: "make test", provenance: name, verified: false };
+    }
+    return null;
+}
+async function detectPython(deps) {
+    if ((await readOptional(deps, "pytest.ini")) !== null) {
+        return { stack: "python", command: "pytest", provenance: "pytest.ini", verified: false };
+    }
+    const pyproject = await readOptional(deps, "pyproject.toml");
+    if (pyproject !== null && /^\s*\[tool\.pytest\.ini_options\]\s*$/m.test(pyproject)) {
+        return { stack: "python", command: "pytest", provenance: "pyproject.toml [tool.pytest.ini_options]", verified: false };
+    }
+    const setupCfg = await readOptional(deps, "setup.cfg");
+    if (setupCfg !== null && /^\s*\[tool:pytest\]\s*$/m.test(setupCfg)) {
+        return { stack: "python", command: "pytest", provenance: "setup.cfg [tool:pytest]", verified: false };
+    }
+    if ((await readOptional(deps, "tests/conftest.py")) !== null) {
+        return { stack: "python", command: "pytest", provenance: "tests/conftest.py", verified: false };
+    }
+    return null;
+}
+async function detectGo(deps) {
+    if ((await readOptional(deps, "go.mod")) === null)
+        return null;
+    return { stack: "go", command: "go test ./...", provenance: "go.mod", verified: false };
+}
+async function detectRust(deps) {
+    if ((await readOptional(deps, "Cargo.toml")) === null)
+        return null;
+    return { stack: "rust", command: "cargo test", provenance: "Cargo.toml", verified: false };
+}
+/**
+ * Words in the learned `unit_testing_stack` prose that name each stack. Matched
+ * as whole words, case-insensitively. Order matters only for ties, which pick
+ * the earlier detected candidate.
+ */
+export const STACK_HINT_VOCABULARY = {
+    javascript: ["javascript", "typescript", "node", "nodejs", "node.js", "jest", "vitest", "mocha", "npm", "pnpm", "yarn"],
+    // Bare "make" and "go" are ordinary English words, so only unambiguous forms count.
+    make: ["makefile", "make test", "gnu make"],
+    python: ["python", "pytest", "unittest"],
+    go: ["golang", "go test", "go.mod", "go modules"],
+    rust: ["rust", "cargo"],
+};
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** The stacks the prose names, using {@link STACK_HINT_VOCABULARY} only. */
+export function stacksNamedByHint(hint) {
+    const named = new Set();
+    if (!hint)
+        return named;
+    for (const stack of DETECTED_STACKS) {
+        for (const word of STACK_HINT_VOCABULARY[stack]) {
+            const pattern = new RegExp(`(^|[^A-Za-z0-9_.])${escapeRegExp(word)}(?=$|[^A-Za-z0-9_])`, "i");
+            if (pattern.test(hint)) {
+                named.add(stack);
+                break;
+            }
+        }
+    }
+    return named;
+}
+/**
+ * Detect candidates from repository files, in the fixed stack order. Throws
+ * {@link DetectionReadError} for an unreadable or malformed file.
+ */
+async function detectCandidates(deps) {
+    const found = [];
+    for (const detect of [detectJavaScript, detectMake, detectPython, detectGo, detectRust]) {
+        const candidate = await detect(deps);
+        if (candidate)
+            found.push(candidate);
+    }
+    return found;
+}
+/** Propose a test command. Read-only; never throws for an expected failure. */
+export async function detectTestCommand(options, deps) {
+    if (!options.skipStoredRead) {
+        const stored = await readStoredTestCommand(deps.config);
+        if (!stored.ok)
+            return { status: "failed", reason: stored.reason };
+        if (stored.testCommand !== null) {
+            return {
+                status: "stored",
+                selected: stored.testCommand,
+                provenance: "stored configuration",
+                question: "none",
+                candidates: [],
+            };
+        }
+    }
+    let candidates;
+    try {
+        candidates = await detectCandidates(deps);
+    }
+    catch (err) {
+        if (err instanceof DetectionReadError)
+            return { status: "failed", reason: err.reason, file: err.file };
+        throw err;
+    }
+    if (candidates.length === 0) {
+        return { status: "none_detected", selected: null, question: "required", candidates };
+    }
+    if (candidates.length === 1) {
+        return {
+            status: "detected",
+            selected: candidates[0].command,
+            provenance: candidates[0].provenance,
+            question: "none",
+            selectedByStackHint: false,
+            candidates,
+        };
+    }
+    // The learned stack is advisory: an unreadable hint falls back to the first
+    // candidate rather than stopping detection.
+    const stackHint = await readUnitTestingStack(deps.config);
+    const named = stacksNamedByHint(stackHint.ok ? stackHint.value : null);
+    const hinted = candidates.find((c) => named.has(c.stack));
+    const chosen = hinted ?? candidates[0];
+    return {
+        status: "detected",
+        selected: chosen.command,
+        provenance: chosen.provenance,
+        question: "accept_or_replace",
+        selectedByStackHint: hinted !== undefined,
+        candidates,
+    };
+}

package/build/test-command-validation.js

@@ -0,0 +1,73 @@
+/**
+ * The stored-test-command rules, mirrored from Python (BAPI-1460).
+ *
+ * The canonical rules live in `api/library/config/test_command_validation.py`;
+ * the server re-checks every write. This mirror exists so detection can explain
+ * a bad answer before a round trip, and so the CI renderer can refuse to put a
+ * bad command into a workflow file at all. Keep the bound, the reason codes, and
+ * the blank-character set identical in both languages.
+ *
+ * Validation establishes permitted SYNTAX only — one line, no NUL, no GitHub
+ * Actions expression opener, a bounded length. It never establishes that the
+ * command runs. Error messages are fixed text and never include the command.
+ */
+/** Upper bound on the command, counted in Unicode code points. */
+export const TEST_COMMAND_MAX_CODE_POINTS = 500;
+/**
+ * Characters that count as blank when deciding whether a command is empty.
+ *
+ * An explicit list rather than `String.prototype.trim()`, because Python's
+ * `str.strip()` and JavaScript's `trim()` recognize different characters.
+ */
+export const TEST_COMMAND_BLANK_CHARACTERS = new Set(Array.from("\t\n\u000b\u000c\r \u0085\u00a0\u1680" +
+    "\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a" +
+    "\u2028\u2029\u202f\u205f\u3000\ufeff"));
+/** Stable, non-revealing reason codes. Identical to the Python reason codes. */
+export const TEST_COMMAND_VALIDATION_REASONS = [
+    "not_a_string",
+    "empty",
+    "multi_line",
+    "nul_byte",
+    "expression_opener",
+    "too_long",
+];
+const MESSAGES = {
+    not_a_string: "test_command must be a string",
+    empty: "test_command must not be empty",
+    multi_line: "test_command must be a single line (no newline or carriage return)",
+    nul_byte: "test_command must not contain a NUL byte",
+    expression_opener: "test_command must not contain the GitHub Actions expression opener ${{",
+    too_long: `test_command must be at most ${TEST_COMMAND_MAX_CODE_POINTS} characters`,
+};
+/** A refused command. `reason` is a fixed code; the message never echoes input. */
+export class TestCommandValidationError extends Error {
+    reason;
+    constructor(reason) {
+        super(MESSAGES[reason]);
+        this.name = "TestCommandValidationError";
+        this.reason = reason;
+    }
+}
+/**
+ * Return `command` unchanged when it is an acceptable test command; throw
+ * {@link TestCommandValidationError} otherwise. Checks run on the raw input.
+ */
+export function validateTestCommand(command) {
+    if (typeof command !== "string")
+        throw new TestCommandValidationError("not_a_string");
+    if (command.includes("\n") || command.includes("\r")) {
+        throw new TestCommandValidationError("multi_line");
+    }
+    if (command.includes("\u0000"))
+        throw new TestCommandValidationError("nul_byte");
+    if (command.includes("${{"))
+        throw new TestCommandValidationError("expression_opener");
+    const codePoints = Array.from(command);
+    if (codePoints.length > TEST_COMMAND_MAX_CODE_POINTS) {
+        throw new TestCommandValidationError("too_long");
+    }
+    if (codePoints.every((ch) => TEST_COMMAND_BLANK_CHARACTERS.has(ch))) {
+        throw new TestCommandValidationError("empty");
+    }
+    return command;
+}

package/build/testing-config-client.js

@@ -0,0 +1,150 @@
+/**
+ * Typed client for the stored test command (BAPI-1460).
+ *
+ * Wraps `GET` / `PUT /setup/testing-config` and the existing
+ * `GET /jira/config-field/unit_testing_stack` reader. It reuses the shared
+ * {@link BridgeApiUrls} builders: `/setup/...` is a root-level mount, so it is
+ * built from `buildApiUrl`, while the config-field reader sits under the
+ * `/jira` mount and uses `buildGetUrl`.
+ *
+ * Every non-success is a typed outcome with a closed `reason`. No upstream
+ * error body, header, URL, API key, or command is ever placed in an outcome:
+ * a transport error's message can carry the request URL, and a server 422 body
+ * is fixed text the caller does not need verbatim.
+ */
+import { TestCommandValidationError, validateTestCommand } from "./test-command-validation.js";
+/** Root-level path of the testing-config handlers. */
+export const TESTING_CONFIG_PATH = "/setup/testing-config";
+/** The `/jira`-mounted config-field path for the learned unit-testing stack. */
+export const UNIT_TESTING_STACK_FIELD_PATH = "/config-field/unit_testing_stack";
+function failure(reason, status) {
+    return { ok: false, reason, status };
+}
+function statusFailure(status) {
+    if (status === 401)
+        return failure("unauthenticated", status);
+    if (status === 403)
+        return failure("forbidden", status);
+    if (status === 404)
+        return failure("not_found", status);
+    if (status === 409)
+        return failure("invalid_stored_command", status);
+    if (status === 422)
+        return failure("invalid_command", status);
+    return failure("backend_failure", status);
+}
+async function readJsonObject(resp) {
+    try {
+        const parsed = JSON.parse(await resp.text());
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+/** Extract and re-validate a stored command; `undefined` means malformed. */
+function storedCommand(body) {
+    const value = body.test_command;
+    if (value === null)
+        return null;
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        return validateTestCommand(value);
+    }
+    catch (err) {
+        if (err instanceof TestCommandValidationError)
+            return undefined;
+        throw err;
+    }
+}
+function testingConfigUrl(deps, params) {
+    const url = new URL(deps.urls.buildApiUrl(TESTING_CONFIG_PATH));
+    for (const [key, value] of Object.entries(params ?? {}))
+        url.searchParams.set(key, value);
+    return url.toString();
+}
+/** `GET /setup/testing-config`. A stored value that fails validation is `invalid_stored_command`. */
+export async function readStoredTestCommand(deps) {
+    let resp;
+    try {
+        resp = await deps.fetch(testingConfigUrl(deps, { repo_name: deps.repoName }), {
+            headers: await deps.getGetHeaders(),
+        });
+    }
+    catch {
+        return failure("transport_failure", 0);
+    }
+    if (!resp.ok)
+        return statusFailure(resp.status);
+    const body = await readJsonObject(resp);
+    if (!body)
+        return failure("malformed_response", resp.status);
+    const command = storedCommand(body);
+    if (command === undefined)
+        return failure("invalid_stored_command", resp.status);
+    return { ok: true, testCommand: command };
+}
+/**
+ * `PUT /setup/testing-config`. The command is validated locally first, so a
+ * refused value never leaves the process; the server re-validates regardless.
+ */
+export async function writeStoredTestCommand(deps, testCommand) {
+    try {
+        validateTestCommand(testCommand);
+    }
+    catch (err) {
+        if (err instanceof TestCommandValidationError)
+            return failure("invalid_command", 0);
+        throw err;
+    }
+    let resp;
+    try {
+        resp = await deps.fetch(testingConfigUrl(deps), {
+            method: "PUT",
+            headers: await deps.getPostHeaders(),
+            body: JSON.stringify({ repo_name: deps.repoName, test_command: testCommand }),
+        });
+    }
+    catch {
+        return failure("transport_failure", 0);
+    }
+    if (!resp.ok)
+        return statusFailure(resp.status);
+    const body = await readJsonObject(resp);
+    if (!body || typeof body.unit_testing_instructions_updated !== "boolean") {
+        return failure("malformed_response", resp.status);
+    }
+    const command = storedCommand(body);
+    if (command === undefined)
+        return failure("invalid_stored_command", resp.status);
+    return {
+        ok: true,
+        testCommand: command,
+        unitTestingInstructionsUpdated: body.unit_testing_instructions_updated,
+    };
+}
+/** `GET /jira/config-field/unit_testing_stack`. Prose; a hint, never a command. */
+export async function readUnitTestingStack(deps) {
+    let resp;
+    try {
+        resp = await deps.fetch(deps.urls.buildGetUrl(UNIT_TESTING_STACK_FIELD_PATH, { repo_name: deps.repoName }), { headers: await deps.getGetHeaders() });
+    }
+    catch {
+        return failure("transport_failure", 0);
+    }
+    if (!resp.ok)
+        return statusFailure(resp.status);
+    const body = await readJsonObject(resp);
+    if (!body)
+        return failure("malformed_response", resp.status);
+    const value = body.value;
+    if (value === null || value === undefined)
+        return { ok: true, value: null };
+    if (typeof value !== "string")
+        return failure("malformed_response", resp.status);
+    return { ok: true, value };
+}