bonecode 1.0.0

package/bone/output/agent/src/debug.ts

@@ -0,0 +1,66 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Runtime error handler with .bone source annotation.
+
+import * as fs from "fs";
+import * as path from "path";
+
+interface BoneMapping {
+  generated_file: string;
+  generated_line: number;
+  bone_line: number;
+  bone_column: number;
+  description: string;
+}
+
+interface BoneSourceMap {
+  version: number;
+  source_hash: string;
+  source_file: string;
+  mappings: BoneMapping[];
+}
+
+let sourceMap: BoneSourceMap | null = null;
+
+function loadSourceMap(): BoneSourceMap | null {
+  if (sourceMap) return sourceMap;
+  const mapPath = path.join(__dirname, "..", "AgentDomain.bone.map");
+  if (!fs.existsSync(mapPath)) return null;
+  try {
+    sourceMap = JSON.parse(fs.readFileSync(mapPath, "utf-8"));
+    return sourceMap;
+  } catch {
+    return null;
+  }
+}
+
+export function annotateBoneError(err: Error, generatedFile: string): string {
+  const map = loadSourceMap();
+  if (!map) return err.stack || err.message;
+
+  // Extract line number from stack trace
+  const lineMatch = err.stack?.match(new RegExp(generatedFile.replace(/[/\\]/g, "[/\\\\]") + ":(\\d+)"));
+  if (!lineMatch) return err.stack || err.message;
+
+  const generatedLine = parseInt(lineMatch[1], 10);
+  const mapping = map.mappings
+    .filter(m => m.generated_file.includes(generatedFile) && m.generated_line <= generatedLine)
+    .sort((a, b) => b.generated_line - a.generated_line)[0];
+
+  if (!mapping) return err.stack || err.message;
+
+  return [
+    `BoneScript source: ${map.source_file}:${mapping.bone_line}:${mapping.bone_column}`,
+    `  Context: ${mapping.description}`,
+    `Generated TS: ${generatedFile}:${generatedLine}`,
+    ``,
+    err.stack || err.message,
+  ].join("\n");
+}
+
+// Global error handler — annotates unhandled errors with .bone context
+process.on("uncaughtException", (err: Error) => {
+  const annotated = annotateBoneError(err, err.stack?.split("\n")[1]?.match(/\((.+):\d+:\d+\)/)?.[1] || "");
+  console.error("[BoneScript] Unhandled error:");
+  console.error(annotated);
+  // process.exit(1); // disabled - errors should not crash the server
+});

package/bone/output/agent/src/events.ts

@@ -0,0 +1,243 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Durable event bus with transactional outbox pattern.
+// Set EVENT_MODE=durable in .env to enable.
+
+import { Pool, PoolClient } from "pg";
+import { v4 as uuid } from "uuid";
+import { pool } from "./db";
+import { logger } from "./logger";
+import { counter } from "./metrics";
+
+export type EventDeliveryMode = "in_process" | "durable";
+
+const MODE: EventDeliveryMode =
+  (process.env.EVENT_MODE as EventDeliveryMode) || "in_process";
+
+// Events requiring exactly_once delivery (deduplicated)
+const EXACTLY_ONCE_EVENTS = new Set<string>(["AgentCompleted"]);
+
+// Events requiring at_least_once delivery (retried until ack)
+const AT_LEAST_ONCE_EVENTS = new Set<string>(["AgentStarted", "AgentFailed", "ToolCallRequested", "ToolCallCompleted", "PermissionRequired"]);
+
+export interface EventMetadata {
+  source: string;
+  timestamp: Date;
+  correlation_id: string;
+  causation_id: string;
+}
+
+export interface SystemEvent {
+  type: string;
+  payload: Record<string, unknown>;
+  metadata: EventMetadata;
+}
+
+type Handler = (event: SystemEvent) => Promise<void>;
+
+// ─── In-Process Bus ──────────────────────────────────────────────────────────
+
+class InProcessBus {
+  private handlers: Map<string, Handler[]> = new Map();
+
+  subscribe(type: string, handler: Handler): void {
+    const existing = this.handlers.get(type) || [];
+    existing.push(handler);
+    this.handlers.set(type, existing);
+  }
+
+  async publish(type: string, payload: Record<string, unknown>, source: string, correlationId?: string): Promise<void> {
+    const event: SystemEvent = {
+      type,
+      payload,
+      metadata: {
+        source,
+        timestamp: new Date(),
+        correlation_id: correlationId || uuid(),
+        causation_id: uuid(),
+      },
+    };
+    counter("event.published", { type, mode: "in_process" });
+    const handlers = this.handlers.get(type) || [];
+    for (const handler of handlers) {
+      try {
+        await handler(event);
+        counter("event.delivered", { type, mode: "in_process" });
+      } catch (e: any) {
+        counter("event.delivery_failed", { type, mode: "in_process" });
+        logger.error("event_handler_failed", { event: type, metadata: { error: e.message } });
+      }
+    }
+  }
+}
+
+// ─── Durable Bus (Transactional Outbox) ──────────────────────────────────────
+
+class DurableBus {
+  private handlers: Map<string, Handler[]> = new Map();
+
+  subscribe(type: string, handler: Handler): void {
+    const existing = this.handlers.get(type) || [];
+    existing.push(handler);
+    this.handlers.set(type, existing);
+  }
+
+  // Write event to outbox within the current transaction (or a new one)
+  async publish(
+    type: string,
+    payload: Record<string, unknown>,
+    source: string,
+    correlationId?: string,
+    client?: PoolClient
+  ): Promise<void> {
+    const eventId = uuid();
+    const corrId = correlationId || uuid();
+    const sql = `
+      INSERT INTO event_outbox (id, event_type, payload, source, correlation_id)
+      VALUES ($1, $2, $3, $4, $5)
+    `;
+    const params = [eventId, type, JSON.stringify({ ...payload, _event_id: eventId }), source, corrId];
+
+    if (client) {
+      // Write within caller's transaction — atomicity guaranteed
+      await client.query(sql, params);
+    } else {
+      await pool.query(sql, params);
+    }
+    counter("event.outboxed", { type });
+  }
+
+  // Called by the background worker
+  async flush(): Promise<void> {
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+
+      // Fetch pending events (lock rows to prevent concurrent processing)
+      const { rows } = await client.query(`
+        SELECT id, event_type, payload, source, correlation_id, attempts
+        FROM event_outbox
+        WHERE status = 'pending' AND scheduled_at <= NOW()
+        ORDER BY scheduled_at ASC
+        LIMIT 50
+        FOR UPDATE SKIP LOCKED
+      `);
+
+      for (const row of rows) {
+        try {
+          // exactly_once: check deduplication table
+          if (EXACTLY_ONCE_EVENTS.has(row.event_type)) {
+            const { rows: dup } = await client.query(
+              "SELECT 1 FROM event_processed WHERE event_id = $1",
+              [row.payload._event_id || row.id]
+            );
+            if (dup.length > 0) {
+              await client.query(
+                "UPDATE event_outbox SET status = 'delivered', delivered_at = NOW() WHERE id = $1",
+                [row.id]
+              );
+              continue;
+            }
+          }
+
+          const event: SystemEvent = {
+            type: row.event_type,
+            payload: row.payload,
+            metadata: {
+              source: row.source,
+              timestamp: new Date(),
+              correlation_id: row.correlation_id,
+              causation_id: uuid(),
+            },
+          };
+
+          const handlers = this.handlers.get(row.event_type) || [];
+          for (const handler of handlers) {
+            await handler(event);
+          }
+
+          // Mark delivered
+          await client.query(
+            "UPDATE event_outbox SET status = 'delivered', delivered_at = NOW(), attempts = attempts + 1 WHERE id = $1",
+            [row.id]
+          );
+
+          // Record for exactly_once deduplication
+          if (EXACTLY_ONCE_EVENTS.has(row.event_type)) {
+            await client.query(
+              "INSERT INTO event_processed (event_id, event_type) VALUES ($1, $2) ON CONFLICT DO NOTHING",
+              [row.payload._event_id || row.id, row.event_type]
+            );
+          }
+
+          counter("event.delivered", { type: row.event_type, mode: "durable" });
+        } catch (e: any) {
+          const maxAttempts = AT_LEAST_ONCE_EVENTS.has(row.event_type) ? 10 : 3;
+          const newAttempts = row.attempts + 1;
+          const status = newAttempts >= maxAttempts ? "dead_letter" : "pending";
+          const backoffMs = Math.min(1000 * Math.pow(2, newAttempts), 300000);
+          await client.query(
+            `UPDATE event_outbox
+             SET attempts = $1, last_error = $2, status = $3,
+                 scheduled_at = NOW() + ($4 || ' milliseconds')::interval
+             WHERE id = $5`,
+            [newAttempts, e.message, status, backoffMs, row.id]
+          );
+          counter("event.delivery_failed", { type: row.event_type, mode: "durable" });
+          logger.error("event_delivery_failed", { event: row.event_type, metadata: { error: e.message, attempts: newAttempts } });
+        }
+      }
+
+      await client.query("COMMIT");
+    } catch (e) {
+      await client.query("ROLLBACK");
+      throw e;
+    } finally {
+      client.release();
+    }
+  }
+
+  // Start background worker
+  startWorker(intervalMs: number = 1000): NodeJS.Timeout {
+    logger.info("event_worker_started", { event: "startup", metadata: { interval_ms: intervalMs } });
+    return setInterval(async () => {
+      try {
+        await this.flush();
+      } catch (e: any) {
+        logger.error("event_worker_error", { event: "flush_failed", metadata: { error: e.message } });
+      }
+    }, intervalMs);
+  }
+}
+
+// ─── Unified Interface ────────────────────────────────────────────────────────
+
+const inProcess = new InProcessBus();
+const durable = new DurableBus();
+
+export const eventBus = {
+  subscribe(type: string, handler: Handler): void {
+    inProcess.subscribe(type, handler);
+    durable.subscribe(type, handler);
+  },
+
+  async publish(
+    type: string,
+    payload: Record<string, unknown>,
+    source: string,
+    correlationId?: string,
+    client?: PoolClient
+  ): Promise<void> {
+    if (MODE === "durable") {
+      await durable.publish(type, payload, source, correlationId, client);
+    } else {
+      await inProcess.publish(type, payload, source, correlationId);
+    }
+  },
+
+  startWorker(intervalMs?: number): NodeJS.Timeout | null {
+    if (MODE === "durable") {
+      return durable.startWorker(intervalMs);
+    }
+    return null;
+  },
+};

package/bone/output/agent/src/extensions.ts

@@ -0,0 +1,54 @@
+// Generated by BoneScript compiler.
+// Extension points: implement the functions below.
+// Code between sentinel comments is preserved on recompile.
+// DO NOT remove the sentinel comments.
+
+/**
+ * Extension point: create_plan
+ * STABLE: implementation required.
+ */
+export function create_plan(agent_id: uuid, task_id: uuid): json {
+  // <bonescript:ext:create_plan:begin>
+  throw new Error("Not implemented: create_plan");
+  // <bonescript:ext:create_plan:end>
+}
+
+/**
+ * Extension point: execute_build_steps
+ * STABLE: implementation required.
+ */
+export function execute_build_steps(agent_id: uuid, plan_id: uuid): json {
+  // <bonescript:ext:execute_build_steps:begin>
+  throw new Error("Not implemented: execute_build_steps");
+  // <bonescript:ext:execute_build_steps:end>
+}
+
+/**
+ * Extension point: run_tests
+ * Optional.
+ */
+export function run_tests(agent_id: uuid, session_id: uuid): json {
+  // <bonescript:ext:run_tests:begin>
+  throw new Error("Not implemented: run_tests");
+  // <bonescript:ext:run_tests:end>
+}
+
+/**
+ * Extension point: fix_test_failures
+ * Optional.
+ */
+export function fix_test_failures(agent_id: uuid, session_id: uuid): json {
+  // <bonescript:ext:fix_test_failures:begin>
+  throw new Error("Not implemented: fix_test_failures");
+  // <bonescript:ext:fix_test_failures:end>
+}
+
+/**
+ * Extension point: commit_changes
+ * Optional.
+ */
+export function commit_changes(agent_id: uuid, session_id: uuid): string {
+  // <bonescript:ext:commit_changes:begin>
+  throw new Error("Not implemented: commit_changes");
+  // <bonescript:ext:commit_changes:end>
+}

package/bone/output/agent/src/failure_rules.ts

@@ -0,0 +1,323 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Implements spec/10 §6 (Failure Rules)
+//
+// Each rule has: condition, detection, remediation, escalation.
+// Rules are derived from the program's constraints, state machines,
+// dependencies, events, and flows. All rule-based — no ML.
+
+import { logger } from "./logger";
+import { counter, gauge } from "./metrics";
+
+export interface FailureRule {
+  id: string;
+  condition: string;
+  detection: string;
+  remediation: () => Promise<void>;
+  rollback: boolean;
+}
+
+export const RULES: FailureRule[] = [
+  {
+    id: "invalid_transition_AgentInstance",
+    condition: "Attempted state transition not in declared machine",
+    detection: "Log with error_code=INVALID_TRANSITION",
+    remediation: async () => {
+      counter("constraint.violated", { entity: "AgentInstance", kind: "invalid_transition" });
+      logger.warn("invalid_transition_blocked", { entity_id: "AgentInstance", error_code: "INVALID_TRANSITION" });
+    },
+    rollback: false,
+  },
+  {
+    id: "invalid_transition_Task",
+    condition: "Attempted state transition not in declared machine",
+    detection: "Log with error_code=INVALID_TRANSITION",
+    remediation: async () => {
+      counter("constraint.violated", { entity: "Task", kind: "invalid_transition" });
+      logger.warn("invalid_transition_blocked", { entity_id: "Task", error_code: "INVALID_TRANSITION" });
+    },
+    rollback: false,
+  },
+  {
+    id: "invalid_transition_Plan",
+    condition: "Attempted state transition not in declared machine",
+    detection: "Log with error_code=INVALID_TRANSITION",
+    remediation: async () => {
+      counter("constraint.violated", { entity: "Plan", kind: "invalid_transition" });
+      logger.warn("invalid_transition_blocked", { entity_id: "Plan", error_code: "INVALID_TRANSITION" });
+    },
+    rollback: false,
+  },
+  {
+    id: "invalid_transition_BuildStep",
+    condition: "Attempted state transition not in declared machine",
+    detection: "Log with error_code=INVALID_TRANSITION",
+    remediation: async () => {
+      counter("constraint.violated", { entity: "BuildStep", kind: "invalid_transition" });
+      logger.warn("invalid_transition_blocked", { entity_id: "BuildStep", error_code: "INVALID_TRANSITION" });
+    },
+    rollback: false,
+  },
+  {
+    id: "invalid_transition_ToolCall",
+    condition: "Attempted state transition not in declared machine",
+    detection: "Log with error_code=INVALID_TRANSITION",
+    remediation: async () => {
+      counter("constraint.violated", { entity: "ToolCall", kind: "invalid_transition" });
+      logger.warn("invalid_transition_blocked", { entity_id: "ToolCall", error_code: "INVALID_TRANSITION" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_TaskService_to_TaskStore",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "TaskService", target: "TaskStore" });
+      gauge("circuit_breaker.open", 1, { service: "TaskService", target: "TaskStore" });
+      logger.error("circuit_breaker_open", { service: "TaskService" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_PlanService_to_PlanStore",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "PlanService", target: "PlanStore" });
+      gauge("circuit_breaker.open", 1, { service: "PlanService", target: "PlanStore" });
+      logger.error("circuit_breaker_open", { service: "PlanService" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_BuildStepService_to_BuildStepStore",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "BuildStepService", target: "BuildStepStore" });
+      gauge("circuit_breaker.open", 1, { service: "BuildStepService", target: "BuildStepStore" });
+      logger.error("circuit_breaker_open", { service: "BuildStepService" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_ToolCallService_to_ToolCallStore",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "ToolCallService", target: "ToolCallStore" });
+      gauge("circuit_breaker.open", 1, { service: "ToolCallService", target: "ToolCallStore" });
+      logger.error("circuit_breaker_open", { service: "ToolCallService" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_AgentInstanceService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "AgentInstanceService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "AgentInstanceService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_TaskService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "TaskService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "TaskService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_PlanService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "PlanService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "PlanService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_BuildStepService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "BuildStepService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "BuildStepService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_ToolCallService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "ToolCallService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "ToolCallService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_agent_events",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "agent_events" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "agent_events" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_tool_permission_requests",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "tool_permission_requests" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "tool_permission_requests" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "event_delivery_failure_AgentStarted",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 604800000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "AgentStarted" });
+      logger.error("event_delivery_failed", { event: "AgentStarted", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: false,
+  },
+  {
+    id: "event_delivery_failure_AgentCompleted",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 2592000000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "AgentCompleted" });
+      logger.error("event_delivery_failed", { event: "AgentCompleted", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: true,
+  },
+  {
+    id: "event_delivery_failure_AgentFailed",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 2592000000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "AgentFailed" });
+      logger.error("event_delivery_failed", { event: "AgentFailed", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: false,
+  },
+  {
+    id: "event_delivery_failure_ToolCallRequested",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 86400000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "ToolCallRequested" });
+      logger.error("event_delivery_failed", { event: "ToolCallRequested", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: false,
+  },
+  {
+    id: "event_delivery_failure_ToolCallCompleted",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 86400000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "ToolCallCompleted" });
+      logger.error("event_delivery_failed", { event: "ToolCallCompleted", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: false,
+  },
+  {
+    id: "event_delivery_failure_PermissionRequired",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 3600000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "PermissionRequired" });
+      logger.error("event_delivery_failed", { event: "PermissionRequired", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: false,
+  },
+  {
+    id: "flow_step_failure_agent_coding_loop_plan",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "agent_coding_loop", step: "plan" });
+      // Trigger compensation: abandon_plan(plan)
+      logger.error("flow_step_failed", { event: "agent_coding_loop.plan", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_agent_coding_loop_edit",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "agent_coding_loop", step: "edit" });
+      // Trigger compensation: revert_build_steps(agent, plan)
+      logger.error("flow_step_failed", { event: "agent_coding_loop.edit", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_agent_coding_loop_test",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "agent_coding_loop", step: "test" });
+      // Trigger compensation: skip_tests(agent)
+      logger.error("flow_step_failed", { event: "agent_coding_loop.test", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_agent_coding_loop_fix",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "agent_coding_loop", step: "fix" });
+      // Trigger compensation: revert_fixes(agent)
+      logger.error("flow_step_failed", { event: "agent_coding_loop.fix", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_agent_coding_loop_commit",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "agent_coding_loop", step: "commit" });
+      // Trigger compensation: revert_commit(agent)
+      logger.error("flow_step_failed", { event: "agent_coding_loop.commit", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+];
+
+export function findRule(id: string): FailureRule | undefined {
+  return RULES.find(r => r.id === id);
+}
+
+export async function triggerRule(id: string): Promise<void> {
+  const rule = findRule(id);
+  if (!rule) {
+    logger.warn("unknown_rule_triggered", { event: "rule_lookup", error_code: "UNKNOWN_RULE", metadata: { id } });
+    return;
+  }
+  try {
+    await rule.remediation();
+  } catch (e: any) {
+    logger.error("remediation_failed", { event: id, error_code: "REMEDIATION_FAILED", metadata: { error: e.message } });
+  }
+}