bonecode 1.0.0

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

@@ -0,0 +1,315 @@
+// 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_KnowledgeBase",
+    condition: "Attempted state transition not in declared machine",
+    detection: "Log with error_code=INVALID_TRANSITION",
+    remediation: async () => {
+      counter("constraint.violated", { entity: "KnowledgeBase", kind: "invalid_transition" });
+      logger.warn("invalid_transition_blocked", { entity_id: "KnowledgeBase", error_code: "INVALID_TRANSITION" });
+    },
+    rollback: false,
+  },
+  {
+    id: "invalid_transition_CodeFile",
+    condition: "Attempted state transition not in declared machine",
+    detection: "Log with error_code=INVALID_TRANSITION",
+    remediation: async () => {
+      counter("constraint.violated", { entity: "CodeFile", kind: "invalid_transition" });
+      logger.warn("invalid_transition_blocked", { entity_id: "CodeFile", error_code: "INVALID_TRANSITION" });
+    },
+    rollback: false,
+  },
+  {
+    id: "invalid_transition_MemoryEntry",
+    condition: "Attempted state transition not in declared machine",
+    detection: "Log with error_code=INVALID_TRANSITION",
+    remediation: async () => {
+      counter("constraint.violated", { entity: "MemoryEntry", kind: "invalid_transition" });
+      logger.warn("invalid_transition_blocked", { entity_id: "MemoryEntry", error_code: "INVALID_TRANSITION" });
+    },
+    rollback: false,
+  },
+  {
+    id: "invalid_transition_IndexingJob",
+    condition: "Attempted state transition not in declared machine",
+    detection: "Log with error_code=INVALID_TRANSITION",
+    remediation: async () => {
+      counter("constraint.violated", { entity: "IndexingJob", kind: "invalid_transition" });
+      logger.warn("invalid_transition_blocked", { entity_id: "IndexingJob", error_code: "INVALID_TRANSITION" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_KnowledgeBaseService_to_KnowledgeBaseStore",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "KnowledgeBaseService", target: "KnowledgeBaseStore" });
+      gauge("circuit_breaker.open", 1, { service: "KnowledgeBaseService", target: "KnowledgeBaseStore" });
+      logger.error("circuit_breaker_open", { service: "KnowledgeBaseService" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_CodeFileService_to_CodeFileStore",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "CodeFileService", target: "CodeFileStore" });
+      gauge("circuit_breaker.open", 1, { service: "CodeFileService", target: "CodeFileStore" });
+      logger.error("circuit_breaker_open", { service: "CodeFileService" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_CodeChunkService_to_CodeChunkStore",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "CodeChunkService", target: "CodeChunkStore" });
+      gauge("circuit_breaker.open", 1, { service: "CodeChunkService", target: "CodeChunkStore" });
+      logger.error("circuit_breaker_open", { service: "CodeChunkService" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_MemoryEntryService_to_MemoryEntryStore",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "MemoryEntryService", target: "MemoryEntryStore" });
+      gauge("circuit_breaker.open", 1, { service: "MemoryEntryService", target: "MemoryEntryStore" });
+      logger.error("circuit_breaker_open", { service: "MemoryEntryService" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_IndexingJobService_to_IndexingJobStore",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "IndexingJobService", target: "IndexingJobStore" });
+      gauge("circuit_breaker.open", 1, { service: "IndexingJobService", target: "IndexingJobStore" });
+      logger.error("circuit_breaker_open", { service: "IndexingJobService" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_KnowledgeBaseService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "KnowledgeBaseService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "KnowledgeBaseService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_CodeFileService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "CodeFileService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "CodeFileService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_CodeChunkService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "CodeChunkService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "CodeChunkService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_MemoryEntryService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "MemoryEntryService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "MemoryEntryService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "dependency_failure_APIGateway_to_IndexingJobService",
+    condition: "Dependency unreachable or returning errors",
+    detection: "Error rate > 50% in 30s window",
+    remediation: async () => {
+      counter("circuit_breaker.opened", { service: "APIGateway", target: "IndexingJobService" });
+      gauge("circuit_breaker.open", 1, { service: "APIGateway", target: "IndexingJobService" });
+      logger.error("circuit_breaker_open", { service: "APIGateway" });
+    },
+    rollback: false,
+  },
+  {
+    id: "event_delivery_failure_CodebaseIngestionStarted",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 604800000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "CodebaseIngestionStarted" });
+      logger.error("event_delivery_failed", { event: "CodebaseIngestionStarted", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: false,
+  },
+  {
+    id: "event_delivery_failure_CodebaseIngestionCompleted",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 2592000000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "CodebaseIngestionCompleted" });
+      logger.error("event_delivery_failed", { event: "CodebaseIngestionCompleted", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: true,
+  },
+  {
+    id: "event_delivery_failure_FileIndexed",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 604800000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "FileIndexed" });
+      logger.error("event_delivery_failed", { event: "FileIndexed", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: false,
+  },
+  {
+    id: "event_delivery_failure_MemoryStored",
+    condition: "Event not acknowledged within TTL",
+    detection: "Event age > 2592000000 ms",
+    remediation: async () => {
+      counter("event.delivery_failed", { event: "MemoryStored" });
+      logger.error("event_delivery_failed", { event: "MemoryStored", error_code: "DELIVERY_TIMEOUT" });
+    },
+    rollback: false,
+  },
+  {
+    id: "flow_step_failure_ingest_codebase_pipeline_scan",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "ingest_codebase_pipeline", step: "scan" });
+      // Trigger compensation: mark_kb_error(knowledge_base)
+      logger.error("flow_step_failed", { event: "ingest_codebase_pipeline.scan", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_ingest_codebase_pipeline_chunk",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "ingest_codebase_pipeline", step: "chunk" });
+      // Trigger compensation: delete_partial_chunks(knowledge_base)
+      logger.error("flow_step_failed", { event: "ingest_codebase_pipeline.chunk", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_ingest_codebase_pipeline_embed",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "ingest_codebase_pipeline", step: "embed" });
+      // Trigger compensation: delete_embeddings(knowledge_base)
+      logger.error("flow_step_failed", { event: "ingest_codebase_pipeline.embed", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_ingest_codebase_pipeline_finalize",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "ingest_codebase_pipeline", step: "finalize" });
+      // Trigger compensation: mark_kb_error(knowledge_base)
+      logger.error("flow_step_failed", { event: "ingest_codebase_pipeline.finalize", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_reindex_file_pipeline_delete_old",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "reindex_file_pipeline", step: "delete_old" });
+      // Trigger compensation: restore_old_chunks(knowledge_base, file_path)
+      logger.error("flow_step_failed", { event: "reindex_file_pipeline.delete_old", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_reindex_file_pipeline_chunk",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "reindex_file_pipeline", step: "chunk" });
+      // Trigger compensation: delete_new_chunks(knowledge_base, file_path)
+      logger.error("flow_step_failed", { event: "reindex_file_pipeline.chunk", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_reindex_file_pipeline_embed",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "reindex_file_pipeline", step: "embed" });
+      // Trigger compensation: delete_new_embeddings(knowledge_base, file_path)
+      logger.error("flow_step_failed", { event: "reindex_file_pipeline.embed", error_code: "STEP_FAILED" });
+    },
+    rollback: true,
+  },
+  {
+    id: "flow_step_failure_reindex_file_pipeline_update",
+    condition: "Flow step failed after max retries",
+    detection: "Step returns error after retry policy exhausted",
+    remediation: async () => {
+      counter("flow.step_failed", { flow: "reindex_file_pipeline", step: "update" });
+      // Trigger compensation: restore_old_file_record(knowledge_base, file_path)
+      logger.error("flow_step_failed", { event: "reindex_file_pipeline.update", 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 } });
+  }
+}

package/bone/output/rag/src/flows.ts

@@ -0,0 +1,239 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Saga runtime — implements flow declarations with backward compensation.
+//
+// On step failure, executes compensations for ALL completed steps in reverse order.
+
+import { logger } from "./logger";
+import { counter } from "./metrics";
+
+export interface FlowStep {
+  name: string;
+  action: (ctx: any) => Promise<void>;
+  compensation: ((ctx: any) => Promise<void>) | null;
+}
+
+export interface FlowResult {
+  ok: boolean;
+  failed_step?: string;
+  compensated: string[];
+  error?: string;
+}
+
+export async function executeFlow(name: string, steps: FlowStep[], ctx: any): Promise<FlowResult> {
+  const completed: { step: string; compensation: ((c: any) => Promise<void>) | null }[] = [];
+
+  for (const step of steps) {
+    try {
+      logger.info("flow_step_started", { event: name + "." + step.name });
+      await step.action(ctx);
+      completed.push({ step: step.name, compensation: step.compensation });
+      counter("flow.step_completed", { flow: name, step: step.name });
+    } catch (e: any) {
+      logger.error("flow_step_failed", { event: name + "." + step.name, metadata: { error: e.message } });
+      counter("flow.step_failed", { flow: name, step: step.name });
+
+      // Backward compensation in reverse order
+      const compensated: string[] = [];
+      for (const c of [...completed].reverse()) {
+        if (!c.compensation) continue;
+        try {
+          await c.compensation(ctx);
+          compensated.push(c.step);
+          logger.info("flow_compensated", { event: name + "." + c.step });
+        } catch (compErr: any) {
+          logger.error("flow_compensation_failed", { event: name + "." + c.step, metadata: { error: compErr.message } });
+          // Continue with other compensations even if one fails
+        }
+      }
+
+      return { ok: false, failed_step: step.name, compensated, error: e.message };
+    }
+  }
+
+  counter("flow.completed", { flow: name });
+  return { ok: true, compensated: [] };
+}
+
+// Flow: ingest_codebase_pipeline
+// ctx must contain: { req, res, auth, client? } for transactional flows
+export async function execute_ingest_codebase_pipeline(ctx: { req: any; res: any; auth: any; client?: any }): Promise<FlowResult> {
+  const steps: FlowStep[] = [
+    {
+      name: "scan",
+      action: async (ctx) => {
+        // Calls capability: scan_directory(knowledge_base, root_path)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/scan-directory`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step scan failed: ${await response.text()}`);
+        ctx.scan_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: mark_kb_error(knowledge_base)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/mark-kb-error`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "chunk",
+      action: async (ctx) => {
+        // Calls capability: chunk_all_files(knowledge_base, file_list)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/chunk-all-files`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step chunk failed: ${await response.text()}`);
+        ctx.chunk_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: delete_partial_chunks(knowledge_base)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/delete-partial-chunks`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "embed",
+      action: async (ctx) => {
+        // Calls capability: embed_all_chunks(knowledge_base)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/embed-all-chunks`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step embed failed: ${await response.text()}`);
+        ctx.embed_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: delete_embeddings(knowledge_base)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/delete-embeddings`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "finalize",
+      action: async (ctx) => {
+        // Calls capability: mark_kb_ready(knowledge_base)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/mark-kb-ready`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step finalize failed: ${await response.text()}`);
+        ctx.finalize_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: mark_kb_error(knowledge_base)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/mark-kb-error`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+  ];
+  return executeFlow("ingest_codebase_pipeline", steps, ctx);
+}
+
+// Flow: reindex_file_pipeline
+// ctx must contain: { req, res, auth, client? } for transactional flows
+export async function execute_reindex_file_pipeline(ctx: { req: any; res: any; auth: any; client?: any }): Promise<FlowResult> {
+  const steps: FlowStep[] = [
+    {
+      name: "delete_old",
+      action: async (ctx) => {
+        // Calls capability: delete_file_chunks(knowledge_base, file_path)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/delete-file-chunks`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step delete_old failed: ${await response.text()}`);
+        ctx.delete_old_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: restore_old_chunks(knowledge_base, file_path)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/restore-old-chunks`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "chunk",
+      action: async (ctx) => {
+        // Calls capability: chunk_file_for_index(knowledge_base, file_path)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/chunk-file-for-index`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step chunk failed: ${await response.text()}`);
+        ctx.chunk_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: delete_new_chunks(knowledge_base, file_path)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/delete-new-chunks`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "embed",
+      action: async (ctx) => {
+        // Calls capability: embed_file_chunks(knowledge_base, file_path)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/embed-file-chunks`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step embed failed: ${await response.text()}`);
+        ctx.embed_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: delete_new_embeddings(knowledge_base, file_path)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/delete-new-embeddings`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+    {
+      name: "update",
+      action: async (ctx) => {
+        // Calls capability: update_file_record(knowledge_base, file_path)
+        const response = await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/update-file-record`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify(ctx.req.body),
+        });
+        if (!response.ok) throw new Error(`Step update failed: ${await response.text()}`);
+        ctx.update_result = await response.json();
+      },
+      compensation: async (ctx) => {
+        // Compensates: restore_old_file_record(knowledge_base, file_path)
+        await fetch(`${process.env.SERVICE_BASE_URL || "http://localhost:3000"}/restore-old-file-record`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": ctx.req.headers.authorization || "" },
+          body: JSON.stringify({ ...ctx.req.body, _compensating: true }),
+        });
+      },
+    },
+  ];
+  return executeFlow("reindex_file_pipeline", steps, ctx);
+}

package/bone/output/rag/src/health.ts

@@ -0,0 +1,43 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Implements spec/10 §5 (Health Checks)
+
+import { Router, Request, Response } from "express";
+import { pool } from "./db";
+import { dump as dumpMetrics } from "./metrics";
+
+export const healthRouter = Router();
+
+// Liveness — is the process running?
+healthRouter.get("/live", (_req: Request, res: Response) => {
+  res.json({ status: "ok", timestamp: new Date().toISOString() });
+});
+
+// Readiness — can the service accept requests?
+healthRouter.get("/ready", async (_req: Request, res: Response) => {
+  const checks: Record<string, { ok: boolean; message?: string }> = {};
+
+  // Postgres
+  try {
+    await pool.query("SELECT 1");
+    checks.postgres = { ok: true };
+  } catch (e: any) {
+    checks.postgres = { ok: false, message: e.message };
+  }
+
+  const allOk = Object.values(checks).every(c => c.ok);
+  res.status(allOk ? 200 : 503).json({
+    status: allOk ? "ok" : "degraded",
+    checks,
+    timestamp: new Date().toISOString(),
+  });
+});
+
+// Startup — has initialization completed?
+healthRouter.get("/startup", (_req: Request, res: Response) => {
+  res.json({ status: "ok", uptime: process.uptime() });
+});
+
+// Prometheus-style metrics
+healthRouter.get("/metrics", (_req: Request, res: Response) => {
+  res.type("text/plain").send(dumpMetrics());
+});