@bridge_gpt/mcp-server 0.2.42 → 0.2.43

package/build/run-unit-tests-launcher.js

@@ -20,6 +20,20 @@ import { readdirSync } from "fs";
 import { spawnSync } from "child_process";
 import path from "path";
 const DEFAULT_BUILD_DIR = "build";
+// BAPI-877 — the SECOND directory the unit lane discovers. `mcp_server/scripts/`
+// holds hand-authored ESM (`"type": "module"`) that the build itself runs:
+// bundle-version.js, sync-agent-mirrors.js, and friends. They are NOT tsc inputs
+// (tsconfig.json is rootDir "src" / include "src/**/*.ts"), so they compile to
+// nothing and a `*.test.js` beside them has no build/ counterpart to discover.
+// Before this constant existed, such a file ran in NO lane at all: not `npm
+// test` (which walked build/ only), not the integration lane, not the pre-push
+// gate. sync-agent-mirrors.test.js sat unrun for months that way.
+//
+// Discovered from source rather than from build/ for that reason, and unioned
+// into the "normal" group — a `scripts/…` path can never match the
+// build/integration/ prefix, so it needs no filter change to land there.
+const SCRIPT_TEST_DIR = "scripts";
+export const SCRIPTS_DIR_PREFIX = "scripts/";
 // The Windows CreateProcess command-line limit is ~8191 characters. This
 // budget stays well under it (accounting for execPath + node options +
 // separators) so a single batch can never approach the real ceiling even on a
@@ -28,9 +42,9 @@ const DEFAULT_BUILD_DIR = "build";
 export const MAX_COMMAND_LENGTH = 6000;
 // Explicit manifest: only tests that call node:test's `mock.module()` API
 // need --experimental-test-module-mocks. Everything else discovered under
-// build/ is eligible for the "normal" group automatically — new tests do NOT
-// need to be registered anywhere else. Add an entry here only when a new test
-// needs module mocking.
+// build/ OR scripts/ is eligible for the "normal" group automatically — new
+// tests do NOT need to be registered anywhere else. Add an entry here only when
+// a new test needs module mocking.
 export const MODULE_MOCK_MANIFEST = [
     "build/attachment-download.test.js",
     "build/attachment-upload.test.js",
@@ -40,6 +54,8 @@ export const MODULE_MOCK_MANIFEST = [
     "build/conductor/git-inspection.test.js",
     "build/conductor/paths.test.js",
     "build/conductor/pr-ci-producer-emit-seam.test.js",
+    "build/conductor/recovery-cli.test.js",
+    "build/conductor/recovery-operations.test.js",
     "build/conductor/security-regressions.test.js",
     "build/conductor/store-lifecycle.test.js",
     "build/conductor/store-queries.test.js",
@@ -57,6 +73,7 @@ export const MODULE_MOCK_MANIFEST = [
     "build/index-heavy-read-truncation.test.js",
     "build/index-output-path.test.js",
     "build/index.review-rounds.test.js",
+    "build/plane/cli.test.js",
     "build/recovery-formatting.test.js",
     "build/sfcc/client.test.js",
     "build/sfcc/permissions.test.js",
@@ -128,6 +145,10 @@ export const INTEGRATION_DISCOVERY_EXCLUSIONS = [
 // discovered into the unit lane automatically and needs no registration —
 // tests/pytest/mcp/test_mcp_server_test_registration_multicomponent.py fails if
 // a *.integration.test.ts ends up in neither lane.
+//
+// BAPI-877 — a `scripts/…` path must NEVER be listed here. This is not a style
+// rule: `discoverIntegrationTestFiles` walks build/ only, so the entry would fail
+// its own presence check below and throw on EVERY `npm run test:integration` run.
 export const INTEGRATION_LANE_ONLY = [
     "build/conductor/conductor-runtime.integration.test.js",
 ];
@@ -160,6 +181,55 @@ export function discoverTestFiles(options) {
     results.sort();
     return results;
 }
+/**
+ * BAPI-877 — hand-authored `scripts/*.test.js`, sorted and package-relative.
+ *
+ * A thin delegation rather than a second walker: `buildDir` already generalizes
+ * (the walk is directory-agnostic and `path.relative(root, …)` yields
+ * `scripts/x.test.js` for free), and duplicating the ENOENT swallow, the sort,
+ * and the separator normalization would be three chances to diverge.
+ *
+ * Deliberately does NOT apply the empty-discovery guard — `discoverUnitTestFiles`
+ * owns that, so this stays a pure query usable in isolation.
+ */
+export function discoverScriptTestFiles(options) {
+    return discoverTestFiles({ ...options, buildDir: SCRIPT_TEST_DIR });
+}
+/**
+ * BAPI-877 — everything the unit lane runs: compiled `build/**` plus authored
+ * `scripts/**`.
+ *
+ * WHY THE EMPTY-SCRIPTS GUARD IS SEPARATE. `selectTestGroup`'s "selected group
+ * is empty" refusal cannot fire for this: ~390 compiled files are always
+ * present, so a scripts-discovery regression would be masked and the lane would
+ * report green over zero scripts tests — the exact "coverage that exists only if
+ * someone runs it by hand" failure BAPI-877 exists to remove. Refusing here
+ * matches `runIntegrationLane` and `discoverIntegrationTestFiles`, which take the
+ * same posture for the same reason.
+ *
+ * The cost is deliberate: deleting every `scripts/*.test.js` breaks `npm test`
+ * until someone edits this file. Deleting all coverage for the build's version
+ * generator and agent-mirror synchronizer SHOULD require touching the line that
+ * says so, rather than silently shrinking the suite.
+ *
+ * WHY IT LIVES HERE and not in `runSelectedGroup`: the guard belongs on the
+ * production path only. Every test that injects its own `discoverFn` supplies a
+ * build-only fixture tree, and firing there would force `scripts/*` entries into
+ * BASELINE_NORMAL_FILES — falsifying the independent historical oracle this
+ * suite is built on.
+ */
+export function discoverUnitTestFiles(options) {
+    const compiled = discoverTestFiles(options);
+    const authored = discoverScriptTestFiles(options);
+    if (authored.length === 0) {
+        throw new Error(`run-unit-tests: discovered zero ${SCRIPTS_DIR_PREFIX}*.test.js under ` +
+            `"${options.root}" — refusing to run. A scripts-lane discovery regression is ` +
+            `invisible beside the compiled tests that still ran, which is the failure ` +
+            `this lane exists to prevent (BAPI-877). If ${SCRIPTS_DIR_PREFIX} genuinely ` +
+            `has no test file any more, remove this guard deliberately.`);
+    }
+    return [...compiled, ...authored].sort();
+}
 /** Throws if the module-mock, force-exit-quarantine, or integration-lane manifest has drifted from the discovered build output. */
 export function validateManifest(discovered) {
     const discoveredSet = new Set(discovered);
@@ -264,8 +334,8 @@ export function runSelectedGroup(mode, options) {
     if (mode !== "normal" && mode !== "module-mocks") {
         throw new Error(`run-unit-tests: unknown group "${mode}" (expected "normal" or "module-mocks")`);
     }
-    const { root, execPath = process.execPath, spawnFn = spawnSync, discoverFn = (opts) => discoverTestFiles(opts), log = console.log, } = options;
-    const discovered = discoverFn({ root });
+    const { root, execPath = process.execPath, spawnFn = spawnSync, discoverFn = (opts) => discoverUnitTestFiles(opts), fsImpl, log = console.log, } = options;
+    const discovered = discoverFn({ root, fsImpl });
     const selected = selectTestGroup(mode, discovered);
     // Split out the force-exit quarantine: those files run last, each as its own
     // single-file spawn WITH --test-force-exit (exact tally, prompt exit despite

package/build/setup-epic.js

@@ -55,8 +55,14 @@
  * A run with no feature branch is byte-identical to before: no parse read, no
  * `git`, no scope, no polling, no extra JSON keys.
  *
- * Read-only against the local filesystem: it reads the plan sidecar and the
- * optional policy file, and writes nothing.
+ * Reads the plan sidecar and the optional policy file from the local
+ * filesystem. As of BAPI-872 it can also WRITE the local filesystem in one
+ * narrow case: after a successful create/reuse, if a live `plane up` manifest
+ * exists for this exact repository root, setup-epic binds the resolved
+ * `epic_run_id` onto it (`.bridge/plane/plane.json`) so a later `plane down`
+ * can stop that run automatically instead of guessing from repository-wide
+ * active-run state. Every other workflow (remote, no local plane) is
+ * unaffected and performs no such write.
  */
 import { readFile as fsReadFile, stat as fsStat } from "node:fs/promises";
 import os from "node:os";
@@ -75,6 +81,11 @@ import { getConfigFieldBaseBranch, getIndexScopeLifecycle, getParseStatus, } fro
 import { createExecFileRunCommand, ensureCommitResolvableLocally, normalizeCommitSha, performExactIndexScopeCut, pollIndexScopeLifecycle, readRemoteBranchHead, runGit, SCOPE_LIFECYCLE_LABELS, } from "./conduct-epic/cut-protocol.js";
 import { hashPlan } from "./conductor/plan.js";
 import { MCP_PACKAGE_NAME } from "./mcp-identity.js";
+// BAPI-872: local plane-manifest binding, so `plane down` can later stop the
+// run this setup resolved WITHOUT guessing from repository-wide active-run
+// state. See `planeBinding` on `SetupEpicDeps` below.
+import { createPlaneFsDeps, createPlaneProcessDeps } from "./plane/defaults.js";
+import { bindPlaneManifestEpicRun, manifestHasLiveProcess, readPlaneManifest, } from "./plane/manifest.js";
 /** Accepted `policy_json.review_policy.source` values (the `ReviewPolicy` surface). */
 export const SETUP_EPIC_REVIEW_POLICY_SOURCES = [
     "verdict_protocol",
@@ -114,6 +125,11 @@ export function createDefaultSetupEpicDeps() {
         isTTY: Boolean(process.stdin.isTTY),
         promptLine: defaultPromptLine,
         runCommand: createExecFileRunCommand(),
+        planeBinding: {
+            readManifest: (repoRoot) => readPlaneManifest(repoRoot, createPlaneFsDeps()),
+            isPlaneProcessAlive: (pid) => createPlaneProcessDeps().isAlive(pid),
+            bind: (repoRoot, planeId, epicRunId) => bindPlaneManifestEpicRun(repoRoot, planeId, epicRunId, createPlaneFsDeps()),
+        },
     };
 }
 /** User-facing usage text. */
@@ -159,6 +175,12 @@ export function getSetupEpicUsage() {
         "                         post-create PATCH is needed. Contradicts nothing",
         "                         silently: if the file and --feature-branch or",
         "                         --review-policy disagree, setup-epic errors naming both.",
+        "                         policy_json.job_timeouts values must be below the job",
+        "                         type's gate ceiling (implement / spec_review / resume",
+        "                         10799; remediate / ci_fix 3599; rebase / smoke 2699;",
+        "                         merge 1799); the server rejects a higher value with a",
+        "                         422 naming the offending field. Full table:",
+        "                         docs/claude/epic-conductor-v2-operator-runbook.md §4.",
         "  --replace-policy       Authorize replacing a LIVE run's stored policy with the",
         "                         policy file, as a complete replacement. Without it, a",
         "                         divergent policy on a reused run is refused with a",
@@ -1016,12 +1038,19 @@ async function resolveScopeIdForRun(access, fetchImpl, epicRunId) {
     const match = listing.value.scopes.find((scope) => scope.epic_run_id === epicRunId);
     return match?.scope_id ?? null;
 }
-/** Operator-facing guidance for a bounded scope failure category. */
-function scopeFailureGuidance(reason, featureBranch) {
+/**
+ * Operator-facing guidance for a bounded scope failure category.
+ *
+ * BAPI-872: abandonment guidance names the conductor CLI verb — never a raw
+ * `PATCH` recipe an operator would have to hand-roll. `epicRunId` is the
+ * concrete, already-resolved run ID at this call site (the failure is scoped to
+ * ONE run), so it is always named explicitly rather than left as a placeholder.
+ */
+function scopeFailureGuidance(reason, featureBranch, epicRunId) {
     if (reason === "canonical_index_advanced") {
         return (`The canonical index advanced before the scope could be seeded. The cut must be ` +
             `re-driven at the newer commit: delete origin/${featureBranch}, abandon this run ` +
-            `(PATCH /jira/epic-runs/runs/<epic_run_id> {"status": "abandoned"}), and re-run setup-epic.`);
+            `(conductor abandon-run --epic-run-id ${epicRunId}), and re-run setup-epic.`);
     }
     return `Recovery: ${SETUP_EPIC_SCOPE_RECOVERY_COMMAND}.`;
 }
@@ -1246,7 +1275,7 @@ export async function runSetupEpicCli(argv, overrides = {}) {
         else if (err instanceof ConductorBridgeApiError && err.status === 409) {
             deps.errorLog(`Epic ${opts.epicKey} has MULTIPLE active runs — it is wedged, and every ` +
                 `plan call will keep failing. Abandon the duplicate before retrying:\n` +
-                `  PATCH /jira/epic-runs/runs/<epic_run_id> {"status": "abandoned"}\n` +
+                `  conductor abandon-run --epic-run-id <duplicate_epic_run_id>\n` +
                 `Detail: ${errorDetail(err)}`);
             return 1;
         }
@@ -1332,7 +1361,7 @@ export async function runSetupEpicCli(argv, overrides = {}) {
                 `validated because the epic itself is wedged, and every plan call will ` +
                 `keep failing. This is NOT a problem with your plan. Abandon the ` +
                 `duplicate before retrying:\n` +
-                `  PATCH /jira/epic-runs/runs/<epic_run_id> {"status": "abandoned"}\n` +
+                `  conductor abandon-run --epic-run-id <duplicate_epic_run_id>\n` +
                 `No run was created and no automation-start charge occurred.\n` +
                 `Detail: ${errorDetail(err)}`);
             return 1;
@@ -1617,6 +1646,51 @@ export async function runSetupEpicCli(argv, overrides = {}) {
             return 1;
         }
     }
+    // --- Plane-manifest binding (BAPI-872) ------------------------------------
+    // A live `plane up` for THIS exact repository root can now be told which run
+    // it is driving, so a later `plane down` can stop it automatically instead
+    // of guessing from repository-wide active-run state (which risks stopping
+    // the WRONG run). Absence of a local plane — remote runs, CI, any non-plane
+    // workflow — is normal and produces neither an attempt nor a warning.
+    if (deps.planeBinding) {
+        try {
+            const manifestRead = await deps.planeBinding.readManifest(deps.cwd);
+            if (manifestRead.kind === "valid") {
+                const manifest = manifestRead.manifest;
+                const isLive = manifestHasLiveProcess(manifest, {
+                    isAlive: deps.planeBinding.isPlaneProcessAlive,
+                });
+                if (isLive) {
+                    const bound = await deps.planeBinding.bind(deps.cwd, manifest.planeId, result.epic_run_id);
+                    if (bound.ok) {
+                        say(bound.alreadyBound
+                            ? `Plane:      already bound to run ${result.epic_run_id}`
+                            : `Plane:      bound to run ${result.epic_run_id} — \`plane down\` will stop it automatically`);
+                    }
+                    else {
+                        const msg = `Could not bind the local plane to run ${result.epic_run_id} (${bound.message}). ` +
+                            "A later `plane down` cannot be guaranteed to stop it automatically — if you need " +
+                            `to stop this run, run \`conductor stop-run --epic-run-id ${result.epic_run_id}\`.`;
+                        warnings.push(msg);
+                        say(`Plane:      [warn] ${msg}`);
+                    }
+                }
+                // A recorded-but-not-live manifest is normal: `plane up` will revalidate
+                // and replace a stale record on its own, and there is nothing running to
+                // hand this binding to yet.
+            }
+            // A missing or unvalidated manifest is normal — no attempt, no warning.
+        }
+        catch (err) {
+            // The binding capability itself must never fail setup-epic as a whole;
+            // an unexpected error here is reported as a warning, never thrown.
+            const msg = `Could not check for a local plane to bind run ${result.epic_run_id} to (${errorDetail(err)}). ` +
+                "A later `plane down` cannot be guaranteed to stop it automatically — if you need to stop " +
+                `this run, run \`conductor stop-run --epic-run-id ${result.epic_run_id}\`.`;
+            warnings.push(msg);
+            say(`Plane:      [warn] ${msg}`);
+        }
+    }
     // --- The exact cut (BAPI-850) --------------------------------------------
     // AFTER the run exists and BEFORE the plan is stored/approved: the scope's run
     // association is immutable server-side, so the cut is driven with this run's
@@ -1806,7 +1880,7 @@ export async function runSetupEpicCli(argv, overrides = {}) {
                 deps.errorLog(`Index scope ${scopeId} FAILED (reason: ${verdict.reason}) — this is a recorded ` +
                     `failure, not an in-progress state. Ticket dispatch remains blocked: the reconciler ` +
                     `will not dispatch against a failed scope.`);
-                deps.errorLog(scopeFailureGuidance(verdict.reason, effectiveFeatureBranch ?? ""));
+                deps.errorLog(scopeFailureGuidance(verdict.reason, effectiveFeatureBranch ?? "", result.epic_run_id));
                 exitCode = 1;
             }
             else {

package/build/version.generated.js

@@ -1,2 +1,3 @@
 // AUTO-GENERATED — do not edit manually. Regenerate with: npm run build
-export const VERSION = "0.2.42";
+export const VERSION = "0.2.43";
+export const BUILD_COMMIT = "1840a67a5a0d-dirty";

package/build/worktree-core.js

@@ -97,21 +97,32 @@ function pickWorktreePathField(parsed) {
     return undefined;
 }
 /**
- * F7: decide whether a PRE-EXISTING branch is safe to reuse as a conductor
- * worktree base. A branch whose tip is an ancestor of the resolved base carries
- * no commits beyond base (nothing stale to build on) and is safe. A branch with
- * commits not on base is a leftover from a prior run — refuse it. Prefers the
- * authoritative `origin/<base>` ref when present. Conservative: any inability to
- * prove ancestry refuses (when in doubt, refuse).
+ * The remediation sentence for a branch left over by a prior FAILED run.
+ * Unchanged since the guard was introduced.
+ */
+function staleLeftoverRemedy(branch, baseRef) {
+    return (`it carries commits not on the resolved base (likely a leftover from a prior run). ` +
+        `Refusing to reuse a stale worktree — delete it (git worktree remove + git branch -D ${branch}) ` +
+        `or rebase it onto ${baseRef}, then re-dispatch.`);
+}
+/**
+ * BAPI-862: the remediation for a branch that carries a SUCCEEDED implement whose
+ * pull request was never attached.
  *
- * `baseStartPoint` (BAPI-527) is the SAME effective base new worktrees are cut
- * from: a branch name for interactive dispatch, or the fetched immutable commit
- * SHA for non-mutating conductor dispatch. When it is a SHA the `origin/<sha>`
- * probe below naturally fails to resolve, so the ancestry check falls back to
- * comparing the existing branch directly against that fetched SHA — never
- * against the local `main` branch name.
+ * Names the `pr_not_attached` gate observation so the executor refusal and the
+ * reconciler's own state are one searchable vocabulary, points at attachment, and
+ * states plainly that the two remedies above destroy completed work. It must not
+ * contain the words "delete" or "rebase" at all: an operator scanning a wall of
+ * job output for the next command is exactly who lost work last time.
  */
-export async function isExistingBranchSafeToReuse(deps, branch, baseStartPoint) {
+function unattachedSuccessRemedy(branch) {
+    return (`it carries the commits of a SUCCEEDED implement whose pull request was never attached ` +
+        `(implement gate observation: pr_not_attached). Refusing to reuse the worktree — but this ` +
+        `branch is finished work, not a leftover. Open or attach a pull request from '${branch}' and ` +
+        `let the reconciler bind it. Do NOT remove or re-write the branch: either would destroy a ` +
+        `completed implementation.`);
+}
+export async function isExistingBranchSafeToReuse(deps, branch, baseStartPoint, classification = "unknown") {
     let baseRef = baseStartPoint;
     const originRef = `origin/${baseStartPoint}`;
     const originExists = await deps.runCommand("git", ["rev-parse", "--verify", "--quiet", originRef], { cwd: deps.cwd });
@@ -122,11 +133,14 @@ export async function isExistingBranchSafeToReuse(deps, branch, baseStartPoint)
     const ancestor = await deps.runCommand("git", ["merge-base", "--is-ancestor", branch, baseRef], { cwd: deps.cwd });
     if (commandSucceeded(ancestor))
         return { safe: true };
+    // The REFUSAL is identical either way (BAPI-862 non-goal: refusal behavior is
+    // unchanged). Only the diagnosis and the remedy differ.
+    const remedy = classification === "succeeded_pr_not_attached"
+        ? unattachedSuccessRemedy(branch)
+        : staleLeftoverRemedy(branch, baseRef);
     return {
         safe: false,
-        reason: `existing branch '${branch}' is not an ancestor of ${baseRef}; it carries commits not on the ` +
-            `resolved base (likely a leftover from a prior run). Refusing to reuse a stale worktree — delete it ` +
-            `(git worktree remove + git branch -D ${branch}) or rebase it onto ${baseRef}, then re-dispatch.`,
+        reason: `existing branch '${branch}' is not an ancestor of ${baseRef}; ${remedy}`,
     };
 }
 /**
@@ -263,7 +277,7 @@ export async function createWorktreeForTicket(deps, key, branchOverrides, worktr
         // check compares against the SAME effective base start point (branch name or
         // fetched SHA) that a NEW branch would be cut from below.
         if (exists && guardStaleWorktree) {
-            const safety = await isExistingBranchSafeToReuse(deps, branch, baseStartPoint);
+            const safety = await isExistingBranchSafeToReuse(deps, branch, baseStartPoint, behavior.staleBranchClassification ?? "unknown");
             if (!safety.safe) {
                 return {
                     key,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge_gpt/mcp-server",
-  "version": "0.2.42",
+  "version": "0.2.43",
   "description": "Bridge API MCP server — exposes Jira endpoints as MCP tools for Claude Code agents",
   "license": "MIT",
   "type": "module",

package/pipelines/greenfield-setup.json

@@ -0,0 +1,286 @@
+{
+  "name": "greenfield-setup",
+  "description": "Onboard a brand-new project that has no code to learn from yet. Offers a bounded interview (or generic defaults), ratifies the open non-functional requirements on a decision page, settles version control, convenes a general council, synthesizes one coherent set of project standards behind a single approval, writes the unset standards fields, and closes with the one authoritative install-manifest apply plus the read-after-write manifest /install-bridge resumes from.",
+  "variables": [
+    "docs_dir",
+    "repo_name"
+  ],
+  "steps": [
+    {
+      "type": "mcp_call",
+      "tool": "ping",
+      "params": {},
+      "description": "Verify Bridge API connectivity"
+    },
+    {
+      "type": "agent_task",
+      "instruction": "Create the required output directory by running: mkdir -p {docs_dir}/greenfield/{repo_name}/standards",
+      "description": "Create the greenfield working directory"
+    },
+    {
+      "type": "mcp_call",
+      "id": "read_install_manifest",
+      "tool": "get_install_manifest",
+      "params": {},
+      "description": "Read the install manifest once and keep its snapshot token for the final apply"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_architecture_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "architecture_instructions",
+        "operation": "get"
+      },
+      "description": "Check whether architecture_instructions already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_review_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "review_instructions",
+        "operation": "get"
+      },
+      "description": "Check whether review_instructions already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_documentation_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "documentation_instructions",
+        "operation": "get"
+      },
+      "description": "Check whether documentation_instructions already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_unit_testing_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "unit_testing_instructions",
+        "operation": "get"
+      },
+      "description": "Check whether unit_testing_instructions already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_e2e_testing_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "e2e_testing_instructions",
+        "operation": "get"
+      },
+      "description": "Check whether e2e_testing_instructions already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_frontend_correctness_standards",
+      "tool": "config_field",
+      "params": {
+        "field_name": "frontend_correctness_standards",
+        "operation": "get"
+      },
+      "description": "Check whether frontend_correctness_standards already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_backend_correctness_standards",
+      "tool": "config_field",
+      "params": {
+        "field_name": "backend_correctness_standards",
+        "operation": "get"
+      },
+      "description": "Check whether backend_correctness_standards already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_template_correctness_standards",
+      "tool": "config_field",
+      "params": {
+        "field_name": "template_correctness_standards",
+        "operation": "get"
+      },
+      "description": "Check whether template_correctness_standards already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_style_correctness_standards",
+      "tool": "config_field",
+      "params": {
+        "field_name": "style_correctness_standards",
+        "operation": "get"
+      },
+      "description": "Check whether style_correctness_standards already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "fetch_design_principles",
+      "tool": "config_field",
+      "params": {
+        "field_name": "design_principles",
+        "operation": "get"
+      },
+      "description": "Check whether design_principles already has content",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "agent_task",
+      "id": "greenfield_interview",
+      "instruction_file": "greenfield-interview.md",
+      "description": "Offer the interview, settle the project framing and version control, and commit the decisions"
+    },
+    {
+      "type": "agent_task",
+      "id": "synthesize_standards",
+      "instruction_file": "greenfield-synthesize-standards.md",
+      "description": "Draft the project standards from the committed framing and take one approval"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_architecture_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "architecture_instructions",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/architecture_instructions.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the architecture standard",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_review_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "review_instructions",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/review_instructions.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the code-review standard",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_documentation_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "documentation_instructions",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/documentation_instructions.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the documentation standard",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_unit_testing_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "unit_testing_instructions",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/unit_testing_instructions.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the unit-testing standard",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_e2e_testing_instructions",
+      "tool": "config_field",
+      "params": {
+        "field_name": "e2e_testing_instructions",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/e2e_testing_instructions.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the end-to-end testing standard",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_frontend_correctness_standards",
+      "tool": "config_field",
+      "params": {
+        "field_name": "frontend_correctness_standards",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/frontend_correctness_standards.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the frontend correctness standard",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_backend_correctness_standards",
+      "tool": "config_field",
+      "params": {
+        "field_name": "backend_correctness_standards",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/backend_correctness_standards.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the backend correctness standard",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_template_correctness_standards",
+      "tool": "config_field",
+      "params": {
+        "field_name": "template_correctness_standards",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/template_correctness_standards.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the template correctness standard",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_style_correctness_standards",
+      "tool": "config_field",
+      "params": {
+        "field_name": "style_correctness_standards",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/style_correctness_standards.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the style correctness standard",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "mcp_call",
+      "id": "upload_design_principles",
+      "tool": "config_field",
+      "params": {
+        "field_name": "design_principles",
+        "file_path": "{docs_dir}/greenfield/{repo_name}/standards/design_principles.md",
+        "operation": "update",
+        "only_if_null": true
+      },
+      "description": "Save the design principles",
+      "on_error": "warn_and_continue"
+    },
+    {
+      "type": "agent_task",
+      "id": "apply_and_report",
+      "instruction_file": "greenfield-apply-and-report.md",
+      "description": "Save the project setup and report where the project stands"
+    }
+  ]
+}