feat(quality-gates): add baseline verification and acknowledged failures

- Add QualityGatesBaseline interface to track verified state
- Add QUALITY_GATES_VERIFY tool to run gates and establish baseline
- Add QUALITY_GATES_ACKNOWLEDGE tool to acknowledge pre-existing failures
- Add QUALITY_GATES_BASELINE_GET tool to check current baseline status
- Update agent prompt to differentiate between:
  - All gates passing: agent maintains this state
  - Acknowledged failures: agent ignores pre-existing issues

When failures are acknowledged, agents focus on their assigned task
without trying to solve the world by fixing unrelated issues.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: vibegui

task-runner/server/tools/agent.ts

@@ -61,6 +61,14 @@ interface QualityGate {
   required: boolean;
 }
 
+interface QualityGatesBaseline {
+  verified: boolean;
+  verifiedAt: string;
+  allPassed: boolean;
+  acknowledged: boolean;
+  failingGates: string[];
+}
+
 interface SiteContext {
   /** Whether this is a Deco site */
   isDeco?: boolean;
@@ -87,20 +95,31 @@ interface TaskContext {
 }
 
 /**
- * Load quality gates from project config
+ * Load quality gates and baseline from project config
  */
-async function loadQualityGates(workspace: string): Promise<QualityGate[]> {
+async function loadQualityGatesWithBaseline(workspace: string): Promise<{
+  gates: QualityGate[];
+  baseline?: QualityGatesBaseline;
+}> {
   try {
     const configPath = `${workspace}/.beads/project-config.json`;
     const content = await Bun.file(configPath).text();
-    const config = JSON.parse(content) as { qualityGates?: QualityGate[] };
-    return config.qualityGates ?? [];
+    const config = JSON.parse(content) as {
+      qualityGates?: QualityGate[];
+      qualityGatesBaseline?: QualityGatesBaseline;
+    };
+    return {
+      gates: config.qualityGates ?? [],
+      baseline: config.qualityGatesBaseline,
+    };
   } catch {
     // Return defaults if no config
-    return [
-      { name: "Type Check", command: "bun run check", required: true },
-      { name: "Lint", command: "bun run lint", required: true },
-    ];
+    return {
+      gates: [
+        { name: "Type Check", command: "bun run check", required: true },
+        { name: "Lint", command: "bun run lint", required: true },
+      ],
+    };
   }
 }
 
@@ -199,7 +218,8 @@ async function buildAgentPrompt(ctx: TaskContext): Promise<string> {
   } = ctx;
 
   // Load project-specific data
-  const qualityGates = ctx.qualityGates ?? (await loadQualityGates(workspace));
+  const { gates: qualityGates, baseline } =
+    await loadQualityGatesWithBaseline(workspace);
   const memorySummary = await loadMemorySummary(workspace);
 
   // Build acceptance criteria section
@@ -213,26 +233,62 @@ You must verify EACH criterion before completing. Check them off mentally as you
 `;
   }
 
-  // Build quality gates section
+  // Build quality gates section based on baseline status
   const requiredGates = qualityGates.filter((g) => g.required);
   let qualityGatesSection = "";
+
   if (requiredGates.length > 0) {
-    qualityGatesSection = `
+    const hasAcknowledgedFailures =
+      baseline?.verified &&
+      !baseline.allPassed &&
+      baseline.acknowledged &&
+      baseline.failingGates.length > 0;
+
+    if (hasAcknowledgedFailures) {
+      // Pre-existing failures acknowledged - agent should NOT try to fix them
+      const failingGateNames = baseline.failingGates;
+      const passingGates = requiredGates.filter(
+        (g) => !failingGateNames.includes(g.name),
+      );
+
+      qualityGatesSection = `
+## Quality Gates - PRE-EXISTING FAILURES ACKNOWLEDGED
+
+**IMPORTANT: The following gates were ALREADY FAILING before your task started:**
+${failingGateNames.map((name) => `- ⚠️ ${name} (PRE-EXISTING FAILURE - DO NOT FIX)`).join("\n")}
+
+**Do NOT attempt to fix these pre-existing failures.** The user has acknowledged them.
+Focus ONLY on your assigned task. Do not try to "solve the world."
+
+${passingGates.length > 0 ? `**Gates you MUST maintain passing:**\n${passingGates.map((g) => `- \`${g.command}\` (${g.name})`).join("\n")}\n\nIf your changes cause these gates to fail, YOU must fix that.` : ""}
+
+**Your responsibility:**
+- Complete your task without breaking gates that were passing
+- Do NOT spend time on pre-existing failures
+- If you accidentally break a passing gate, fix that regression
+- Focus on task completion, not codebase-wide cleanup
+
+**SESSION_LAND behavior:**
+- Will check gates that were passing before
+- Pre-existing failures are excluded from verification
+- Your task succeeds if you complete the work without new regressions
+`;
+    } else {
+      // Normal mode - all gates must pass
+      qualityGatesSection = `
 ## Quality Gates (ALL must pass - MANDATORY)
 ${requiredGates.map((g) => `- \`${g.command}\` (${g.name})`).join("\n")}
 
 **CRITICAL: ALL quality gates must pass before you can complete the task.**
 
 - Run each gate command and verify it exits with code 0
 - If ANY gate fails, YOU MUST FIX IT before completing
-- This includes ALL errors in the codebase, not just ones you introduced
-- Pre-existing errors are YOUR responsibility - fix them or the task is incomplete
 - Do NOT output <promise>COMPLETE</promise> until all gates pass
-- Do NOT rationalize "these errors existed before" - that is not acceptable
 - If you cannot fix a gate failure, explain why and do NOT mark the task complete
 
 **SESSION_LAND will verify gates pass. If they fail, success=false and task remains incomplete.**
 `;
+    }
   }
 
   // Get tool descriptions for the prompt

task-runner/server/tools/quality-gates.ts

@@ -23,8 +23,26 @@ export interface QualityGate {
   source: "auto" | "manual"; // auto = detected from package.json, manual = user-defined
 }
 
+export interface QualityGateResult {
+  gate: string;
+  command: string;
+  passed: boolean;
+  output: string;
+  duration: number;
+}
+
+export interface QualityGatesBaseline {
+  verified: boolean;
+  verifiedAt: string;
+  allPassed: boolean;
+  acknowledged: boolean; // User acknowledged pre-existing failures
+  failingGates: string[]; // Names of gates that were failing
+  results: QualityGateResult[];
+}
+
 export interface ProjectConfig {
   qualityGates: QualityGate[];
+  qualityGatesBaseline?: QualityGatesBaseline;
   completionToken: string;
   memoryDir: string;
   lastUpdated: string;
@@ -407,6 +425,214 @@ export const createProjectConfigGetTool = (_env: Env) =>
     },
   });
 
+// ============================================================================
+// QUALITY_GATES_VERIFY
+// ============================================================================
+
+export const createQualityGatesVerifyTool = (_env: Env) =>
+  createPrivateTool({
+    id: "QUALITY_GATES_VERIFY",
+    description:
+      "Run quality gates to establish a baseline. Must be done before creating tasks. Returns current state and allows acknowledging pre-existing failures.",
+    inputSchema: z.object({}),
+    outputSchema: z.object({
+      allPassed: z.boolean(),
+      results: z.array(
+        z.object({
+          gate: z.string(),
+          command: z.string(),
+          passed: z.boolean(),
+          output: z.string(),
+          duration: z.number(),
+        }),
+      ),
+      baseline: z.object({
+        verified: z.boolean(),
+        verifiedAt: z.string(),
+        allPassed: z.boolean(),
+        acknowledged: z.boolean(),
+        failingGates: z.array(z.string()),
+      }),
+    }),
+    execute: async () => {
+      const workspace = getWorkspace();
+      const config = await loadProjectConfig(workspace);
+      const requiredGates = config.qualityGates.filter((g) => g.required);
+
+      const results: QualityGateResult[] = [];
+
+      for (const gate of requiredGates) {
+        const start = Date.now();
+        try {
+          const [cmd, ...args] = gate.command.split(" ");
+          const proc = Bun.spawn([cmd, ...args], {
+            cwd: workspace,
+            stdout: "pipe",
+            stderr: "pipe",
+          });
+
+          const stdout = await new Response(proc.stdout).text();
+          const stderr = await new Response(proc.stderr).text();
+          const exitCode = await proc.exited;
+
+          results.push({
+            gate: gate.name,
+            command: gate.command,
+            passed: exitCode === 0,
+            output: (stdout + stderr).slice(-500),
+            duration: Date.now() - start,
+          });
+        } catch (error) {
+          results.push({
+            gate: gate.name,
+            command: gate.command,
+            passed: false,
+            output: error instanceof Error ? error.message : String(error),
+            duration: Date.now() - start,
+          });
+        }
+      }
+
+      const allPassed = results.every((r) => r.passed);
+      const failingGates = results.filter((r) => !r.passed).map((r) => r.gate);
+
+      // Update baseline - not acknowledged yet if there are failures
+      const baseline: QualityGatesBaseline = {
+        verified: true,
+        verifiedAt: new Date().toISOString(),
+        allPassed,
+        acknowledged: allPassed, // Auto-acknowledge if all pass
+        failingGates,
+        results,
+      };
+
+      config.qualityGatesBaseline = baseline;
+      await saveProjectConfig(workspace, config);
+
+      return {
+        allPassed,
+        results,
+        baseline: {
+          verified: baseline.verified,
+          verifiedAt: baseline.verifiedAt,
+          allPassed: baseline.allPassed,
+          acknowledged: baseline.acknowledged,
+          failingGates: baseline.failingGates,
+        },
+      };
+    },
+  });
+
+// ============================================================================
+// QUALITY_GATES_ACKNOWLEDGE
+// ============================================================================
+
+export const createQualityGatesAcknowledgeTool = (_env: Env) =>
+  createPrivateTool({
+    id: "QUALITY_GATES_ACKNOWLEDGE",
+    description:
+      "Acknowledge pre-existing quality gate failures. After acknowledging, agents will NOT attempt to fix these failures - they will focus only on their assigned task.",
+    inputSchema: z.object({
+      acknowledge: z.boolean().describe("Set to true to acknowledge failures"),
+    }),
+    outputSchema: z.object({
+      success: z.boolean(),
+      baseline: z
+        .object({
+          verified: z.boolean(),
+          allPassed: z.boolean(),
+          acknowledged: z.boolean(),
+          failingGates: z.array(z.string()),
+        })
+        .optional(),
+      error: z.string().optional(),
+    }),
+    execute: async ({ context }) => {
+      const workspace = getWorkspace();
+      const config = await loadProjectConfig(workspace);
+
+      if (!config.qualityGatesBaseline?.verified) {
+        return {
+          success: false,
+          error:
+            "No baseline verified. Run QUALITY_GATES_VERIFY first to establish baseline.",
+        };
+      }
+
+      if (config.qualityGatesBaseline.allPassed) {
+        return {
+          success: true,
+          baseline: {
+            verified: true,
+            allPassed: true,
+            acknowledged: true,
+            failingGates: [],
+          },
+        };
+      }
+
+      config.qualityGatesBaseline.acknowledged = context.acknowledge;
+      await saveProjectConfig(workspace, config);
+
+      return {
+        success: true,
+        baseline: {
+          verified: config.qualityGatesBaseline.verified,
+          allPassed: config.qualityGatesBaseline.allPassed,
+          acknowledged: config.qualityGatesBaseline.acknowledged,
+          failingGates: config.qualityGatesBaseline.failingGates,
+        },
+      };
+    },
+  });
+
+// ============================================================================
+// QUALITY_GATES_BASELINE_GET
+// ============================================================================
+
+export const createQualityGatesBaselineGetTool = (_env: Env) =>
+  createPrivateTool({
+    id: "QUALITY_GATES_BASELINE_GET",
+    description: "Get the current quality gates baseline verification status",
+    inputSchema: z.object({}),
+    outputSchema: z.object({
+      hasBaseline: z.boolean(),
+      baseline: z
+        .object({
+          verified: z.boolean(),
+          verifiedAt: z.string(),
+          allPassed: z.boolean(),
+          acknowledged: z.boolean(),
+          failingGates: z.array(z.string()),
+        })
+        .optional(),
+      canCreateTasks: z.boolean(),
+    }),
+    execute: async () => {
+      const workspace = getWorkspace();
+      const config = await loadProjectConfig(workspace);
+
+      const baseline = config.qualityGatesBaseline;
+      const hasBaseline = !!baseline?.verified;
+      const canCreateTasks =
+        hasBaseline && (baseline.allPassed || baseline.acknowledged);
+
+      return {
+        hasBaseline,
+        baseline: baseline
+          ? {
+              verified: baseline.verified,
+              verifiedAt: baseline.verifiedAt,
+              allPassed: baseline.allPassed,
+              acknowledged: baseline.acknowledged,
+              failingGates: baseline.failingGates,
+            }
+          : undefined,
+        canCreateTasks,
+      };
+    },
+  });
+
 // ============================================================================
 // Export all quality gate tools
 // ============================================================================
@@ -417,4 +643,7 @@ export const qualityGateTools = [
   createQualityGatesAddTool,
   createQualityGatesRunTool,
   createProjectConfigGetTool,
+  createQualityGatesVerifyTool,
+  createQualityGatesAcknowledgeTool,
+  createQualityGatesBaselineGetTool,
 ];