@ronaldjdevfs/forge 1.3.0-beta → 1.3.2

package/skills/forge/scripts/rename.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { existsSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from "fs";
 import { join, relative, dirname, basename, extname, parse } from "path";
 
 const ROOT = process.cwd();
@@ -66,7 +66,10 @@ const PLATFORM_RULES = {
 };
 
 const FEATURE_SUBDIR_RULES = [
+  { subdir: "domain/entities", pattern: "entity", case: "pascal", description: "<Name>.entity.ts" },
+  { subdir: "domain/repositories", pattern: "repository", prefix: "I", case: "pascal", description: "I<Name>.repository.ts" },
   { subdir: "domain", pattern: "entity", case: "pascal", description: "<Name>.entity.ts" },
+  { subdir: "domain", pattern: "port", case: "pascal", description: "<Name>.port.ts" },
   { subdir: "domain", pattern: "repository", prefix: "I", case: "pascal", description: "I<Name>.repository.ts" },
   { subdir: "application/use-cases", pattern: "uc", case: "pascal", description: "<Action>.uc.ts" },
   { subdir: "application/mappers", pattern: "mapper", case: "pascal", description: "<Name>.mapper.ts" },
@@ -178,37 +181,73 @@ export function computeExpectedName(filePath) {
       if (featureSubpath === rule.subdir || featureSubpath.startsWith(rule.subdir + "/")) {
         const stemLower = stem.toLowerCase();
 
-        // For domain/entity: <Entity>.entity.ts
-        // Entity name derived from feature dir or current filename
-        if (rule.subdir === "domain" && rule.pattern === "entity") {
+        // For domain/entities/: <Name>.entity.ts
+        if (rule.subdir === "domain/entities") {
           let inferredEntity;
           if (hasSuffix(stem, "entity")) {
             inferredEntity = stem.replace(/\.entity$/i, "");
           } else {
-            const noEntity = stem.replace(/[Ee]ntity$/, "");
-            inferredEntity = noEntity || featureName;
+            inferredEntity = stem;
           }
           const entityStem = toPascalCase(inferredEntity);
           const expectedName = `${entityStem}.entity${ext}`;
           if (expectedName !== filename) {
-            return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: ${rule.description}` };
+            return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain/entities: ${rule.description}` };
           }
         }
 
-        // For domain/repository interface: I<Entity>.repository.ts
-        if (rule.subdir === "domain" && rule.pattern === "repository") {
+        // For domain/repositories/: I<Name>.repository.ts
+        if (rule.subdir === "domain/repositories") {
           const expectedStem = `I${entityName}.repository`;
           const expectedName = `${expectedStem}${ext}`;
           const currentMatches = stem === expectedStem;
           if (!currentMatches) {
+            return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain/repositories: ${rule.description}` };
+          }
+        }
+
+        // For flat domain/entity: migrates to domain/entities/<Name>.entity.ts
+        if (rule.subdir === "domain" && rule.pattern === "entity" && featureSubpath === "domain") {
+          let inferredEntity;
+          if (hasSuffix(stem, "entity")) {
+            inferredEntity = stem.replace(/\.entity$/i, "");
+          } else {
+            const noEntity = stem.replace(/[Ee]ntity$/, "");
+            inferredEntity = noEntity || featureName;
+          }
+          const entityStem = toPascalCase(inferredEntity);
+          const expectedName = `${entityStem}.entity${ext}`;
+          const expectedPath = join(dirname(filePath), "entities", expectedName);
+          return { current: filePath, expected: expectedPath, relPath: join(dirname(relPath), "entities", expectedName), rule: `feature/${featureName}/domain → domain/entities: ${rule.description}` };
+        }
+
+        // For domain/port: <Name>.port.ts
+        if (rule.subdir === "domain" && rule.pattern === "port") {
+          let inferredPort;
+          if (hasSuffix(stem, "port")) {
+            inferredPort = stem.replace(/\.port$/i, "");
+          } else {
+            inferredPort = stem;
+          }
+          const portStem = toPascalCase(inferredPort);
+          const expectedName = `${portStem}.port${ext}`;
+          if (expectedName !== filename) {
             return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: ${rule.description}` };
           }
-          return null;
+        }
+
+        // For flat domain/repository: migrates to domain/repositories/I<Entity>.repository.ts
+        if (rule.subdir === "domain" && rule.pattern === "repository" && featureSubpath === "domain") {
+          const expectedStem = `I${entityName}.repository`;
+          const expectedName = `${expectedStem}${ext}`;
+          const expectedPath = join(dirname(filePath), "repositories", expectedName);
+          return { current: filePath, expected: expectedPath, relPath: join(dirname(relPath), "repositories", expectedName), rule: `feature/${featureName}/domain → domain/repositories: ${rule.description}` };
         }
 
         // For use-cases: <Action>.uc.ts
         if (rule.subdir === "application/use-cases") {
-          const expectedName = `${toPascalCase(stem)}.uc${ext}`;
+          const cleanStem = hasSuffix(stem, "uc") ? stem.replace(/\.uc$/i, "") : stem;
+          const expectedName = `${toPascalCase(cleanStem)}.uc${ext}`;
           if (expectedName !== filename) {
             return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/application/use-cases: ${rule.description}` };
           }
@@ -237,15 +276,21 @@ export function computeExpectedName(filePath) {
       }
     }
 
-    // Check domain/ for files that look like entity/repository but don't match (loose files)
+    // Check domain/ for loose files without suffix → migrate to subdirectory
     if (featureSubpath === "domain" && !stem.includes(".")) {
       const lower = stem.toLowerCase();
       if (lower.includes("repository") || stem.startsWith("I")) {
         const expectedName = `I${entityName}.repository${ext}`;
-        return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: I<Name>.repository.ts` };
+        const expectedPath = join(dirname(filePath), "repositories", expectedName);
+        return { current: filePath, expected: expectedPath, relPath: join(dirname(relPath), "repositories", expectedName), rule: `feature/${featureName}/domain → domain/repositories: I<Name>.repository.ts` };
+      }
+      if (lower.includes("port")) {
+        const expectedName = `${entityName}.port${ext}`;
+        return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: <Name>.port.ts` };
       }
       const expectedName = `${entityName}.entity${ext}`;
-      return { current: filePath, expected: join(dirname(filePath), expectedName), relPath: join(dirname(relPath), expectedName), rule: `feature/${featureName}/domain: <Name>.entity.ts` };
+      const expectedPath = join(dirname(filePath), "entities", expectedName);
+      return { current: filePath, expected: expectedPath, relPath: join(dirname(relPath), "entities", expectedName), rule: `feature/${featureName}/domain → domain/entities: <Name>.entity.ts` };
     }
 
     return null;
@@ -536,6 +581,9 @@ export function renameFile(oldPath, newPath, projectRoot = ROOT) {
     return { success: true, updatedImports: [], note: "El archivo ya tiene el nombre correcto" };
   }
 
+  // Ensure target directory exists
+  mkdirSync(dirname(newPath), { recursive: true });
+
   // Physical rename
   try {
     renameSync(oldPath, newPath);

package/skills/forge/scripts/rollback.mjs

@@ -18,6 +18,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, cpSync, rmSync, statSync } from "fs";
 import { join, relative, resolve, basename } from "path";
+import { fileURLToPath } from "url";
 import { execFileSync } from "child_process";
 
 const ROOT = process.cwd();
@@ -157,7 +158,8 @@ export function listBackups(target) {
 
 export function verifyAfterChange() {
   try {
-    const out = shell("node", [join(import.meta.url, "..", "inspect.mjs"), "--diff", "--json"]);
+    const __dirname = fileURLToPath(new URL(".", import.meta.url));
+    const out = shell("node", [join(__dirname, "inspect.mjs"), "--diff", "--json"]);
     if (!out) return { score: 0, improved: false, error: "inspect falló" };
 
     const result = JSON.parse(out);
@@ -167,7 +169,7 @@ export function verifyAfterChange() {
     let suggestedCommit = null;
     if (improved && score > 0) {
       const branch = shell("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
-      suggestedCommit = `git add -A && git commit -m "forge: relocate/reforge (score: ${score}/110)"`;
+      suggestedCommit = `git add -A && git commit -m "forge: relocate/reforge (score: ${score})"`;
     }
 
     return { score, improved, suggestedCommit };
@@ -205,7 +207,7 @@ if (action === "backup" && arg) {
     console.error(`rollback: ${result.error}`);
     process.exit(1);
   }
-  console.log(`Score: ${result.score}/110 | ${result.improved ? "✓ Mejoró/igual" : "✘ Empeoró"}${result.suggestedCommit ? `\nSugerencia: ${result.suggestedCommit}` : ""}`);
+  console.log(`Score: ${result.score} | ${result.improved ? "✓ Mejoró/igual" : "✘ Empeoró"}${result.suggestedCommit ? `\nSugerencia: ${result.suggestedCommit}` : ""}`);
   process.exit(result.improved ? 0 : 1);
 } else {
   console.log("Uso: node rollback.mjs <backup|restore|list|verify> [target|id]");

package/skills/forge/templates/feature/acl-gateway.ts.md

@@ -0,0 +1,52 @@
+```typescript
+// src/features/<domain>/adapters/out/legacy-<system>/<Domain>Gateway.ts
+import { injectable } from "tsyringe";
+import type { External<Domain>DTO } from "./External<Domain>DTO.js";
+
+@injectable()
+export class <Domain>Gateway {
+  private readonly baseUrl: string;
+
+  constructor() {
+    this.baseUrl = process.env.LEGACY_<SYSTEM>_URL ?? "";
+  }
+
+  async fetch(id: string): Promise<External<Domain>DTO | null> {
+    const response = await fetch(`${this.baseUrl}/api/${id}`, {
+      headers: { Authorization: `Bearer ${this.getApiKey()}` },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (response.status === 404) return null;
+    if (!response.ok) throw new Error(`Legacy error: ${response.statusText}`);
+    return response.json();
+  }
+
+  async upsert(dto: External<Domain>DTO): Promise<External<Domain>DTO> {
+    const response = await fetch(`${this.baseUrl}/api`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.getApiKey()}`,
+      },
+      body: JSON.stringify(dto),
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!response.ok) throw new Error(`Legacy error: ${response.statusText}`);
+    return response.json();
+  }
+
+  async remove(id: string): Promise<void> {
+    const response = await fetch(`${this.baseUrl}/api/${id}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${this.getApiKey()}` },
+    });
+    if (!response.ok && response.status !== 404) {
+      throw new Error(`Legacy error: ${response.statusText}`);
+    }
+  }
+
+  private getApiKey(): string {
+    return process.env.LEGACY_<SYSTEM>_API_KEY ?? "";
+  }
+}
+```

package/skills/forge/templates/feature/acl-repository.ts.md

@@ -0,0 +1,36 @@
+```typescript
+// src/features/<domain>/adapters/out/legacy-<system>/<Domain>ACL.ts
+import { injectable, inject } from "tsyringe";
+import type { I<Domain>Repository } from "../../domain/repositories/I<Domain>.repository.js";
+import type { <Domain>Entity } from "../../domain/entities/<Domain>.entity.js";
+import { <Domain>Gateway } from "./<Domain>Gateway.js";
+import { <Domain>Translator } from "./<Domain>Translator.js";
+
+@injectable()
+export class <Domain>ACLRepository implements I<Domain>Repository {
+  constructor(
+    @inject(<Domain>Gateway) private readonly gateway: <Domain>Gateway,
+    @inject(<Domain>Translator) private readonly translator: <Domain>Translator,
+  ) {}
+
+  async findById(id: string): Promise<<Domain>Entity | null> {
+    try {
+      const dto = await this.gateway.fetch(id);
+      return dto ? this.translator.toDomain(dto) : null;
+    } catch (error) {
+      if (error.message.includes("404")) return null;
+      throw new Error("<Domain>Repository.fetchFailed");
+    }
+  }
+
+  async save(entity: <Domain>Entity): Promise<<Domain>Entity> {
+    const dto = this.translator.toExternal(entity);
+    const result = await this.gateway.upsert(dto);
+    return this.translator.toDomain(result);
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.gateway.remove(id);
+  }
+}
+```

package/skills/forge/templates/feature/acl-translator.ts.md

@@ -0,0 +1,24 @@
+```typescript
+// src/features/<domain>/adapters/out/legacy-<system>/<Domain>Translator.ts
+import type { <Domain>Entity } from "../../../domain/entities/<Domain>.entity.js";
+import type { External<Domain>DTO } from "./External<Domain>DTO.js";
+
+export class <Domain>Translator {
+  toDomain(dto: External<Domain>DTO): <Domain>Entity {
+    return {
+      id: dto.externalId,
+      // mapear campos del DTO externo al modelo de dominio
+      // name: dto.fullName,
+      // email: dto.emailAddress,
+      // status: dto.isActive ? "active" : "inactive",
+    } as <Domain>Entity;
+  }
+
+  toExternal(entity: <Domain>Entity): External<Domain>DTO {
+    return {
+      externalId: entity.id,
+      // mapear campos del dominio al DTO externo
+    } as External<Domain>DTO;
+  }
+}
+```

package/skills/forge/templates/feature/cqrs-query.ts.md

@@ -0,0 +1,40 @@
+```typescript
+// src/features/<domain>/application/queries/Get<Domain>Query.ts
+import { injectable, inject } from "tsyringe";
+import type { I<Domain>ReadRepository } from "../../adapters/out/read/I<Domain>ReadRepository.js";
+
+export type <Domain>QueryResult = {
+  // DTO plano desnormalizado para lectura
+  id: string;
+  // campos optimizados para consulta
+};
+
+@injectable()
+export class Get<Domain>Query {
+  constructor(
+    @inject(I<Domain>ReadRepository)
+    private readonly readRepo: I<Domain>ReadRepository,
+  ) {}
+
+  async execute(id: string): Promise<<Domain>QueryResult | null> {
+    return this.readRepo.findById(id);
+  }
+}
+
+// Query con filtros
+export class List<Domain>Query {
+  constructor(
+    @inject(I<Domain>ReadRepository)
+    private readonly readRepo: I<Domain>ReadRepository,
+  ) {}
+
+  async execute(filters: {
+    page?: number;
+    limit?: number;
+    sort?: string;
+    filter?: Record<string, string>;
+  }): Promise<{ data: <Domain>QueryResult[]; total: number }> {
+    return this.readRepo.findMany(filters);
+  }
+}
+```

package/skills/forge/templates/feature/entity.ts.md

@@ -1,5 +1,5 @@
 ```typescript
-// src/features/<domain>/domain/<Domain>.entity.ts
+// src/features/<domain>/domain/entities/<Domain>.entity.ts
 import type { SomeGlobalType } from "@/shared/types/types.js";
 
 export interface <Domain> {

package/skills/forge/templates/feature/mapper.ts.md

@@ -1,6 +1,6 @@
 ```typescript
 // src/features/<domain>/application/mappers/<Domain>.mapper.ts
-import type { <Domain> } from "../domain/<Domain>.entity.js";
+import type { <Domain> } from "../domain/entities/<Domain>.entity.js";
 
 export class <Domain>Mapper {
   static toDomain(doc: Record<string, any>): <Domain> {

package/skills/forge/templates/feature/outbox-repository.ts.md

@@ -0,0 +1,36 @@
+```typescript
+// src/features/<domain>/adapters/out/persistence/<Domain>OutboxRepository.ts
+import { injectable } from "tsyringe";
+import type { DomainEvent } from "../../../domain/events/DomainEvent.js";
+
+export type OutboxEntry = {
+  id: string;
+  eventType: string;
+  aggregateId: string;
+  aggregateType: string;
+  payload: Record<string, unknown>;
+  occurredAt: Date;
+  processedAt: Date | null;
+  retryCount: number;
+  lastError: string | null;
+};
+
+@injectable()
+export class <Domain>OutboxRepository {
+  async add(event: DomainEvent): Promise<void> {
+    // Implementar: INSERT en tabla outbox dentro de la transacción actual
+    // const entry: OutboxEntry = {
+    //   id: crypto.randomUUID(),
+    //   eventType: event.constructor.name,
+    //   aggregateId: event.aggregateId,
+    //   aggregateType: "<Domain>",
+    //   payload: JSON.parse(JSON.stringify(event)),
+    //   occurredAt: new Date(),
+    //   processedAt: null,
+    //   retryCount: 0,
+    //   lastError: null,
+    // };
+    // await this.db.outbox.create({ data: entry });
+  }
+}
+```

package/skills/forge/templates/feature/repository-impl.ts.md

@@ -1,8 +1,8 @@
 ```typescript
 // src/features/<domain>/adapters/out/persistence/<Domain>.repository.ts
 import { injectable } from "tsyringe";
-import type { <Domain> } from "../../../domain/<Domain>.entity.js";
-import type { I<Domain>Repository } from "../../../domain/I<Domain>.repository.js";
+import type { <Domain> } from "../../../domain/entities/<Domain>.entity.js";
+import type { I<Domain>Repository } from "../../../domain/repositories/I<Domain>.repository.js";
 import { <Domain>Mapper } from "../../../application/mappers/<Domain>.mapper.js";
 import <Domain>Model from "./<Domain>.schema.js";
 import { RepositoryError } from "@/shared/errors/RepositoryError.js";

package/skills/forge/templates/feature/repository-interface.ts.md

@@ -1,6 +1,6 @@
 ```typescript
-// src/features/<domain>/domain/I<Domain>.repository.ts
-import type { <Domain> } from "./<Domain>.entity.js";
+// src/features/<domain>/domain/repositories/I<Domain>.repository.ts
+import type { <Domain> } from "../entities/<Domain>.entity.js";
 
 export interface I<Domain>Repository {
   create(data: Partial<<Domain>>, session?: unknown): Promise<<Domain>>;

package/skills/forge/templates/feature/saga-orchestrator.ts.md

@@ -0,0 +1,72 @@
+```typescript
+// src/features/<domain>/adapters/out/saga/SagaOrchestrator.ts
+import { injectable, inject } from "tsyringe";
+import type { SagaInstance, SagaStatus } from "../../domain/entities/SagaInstance.entity.js";
+import type { ISagaRepository } from "../../domain/repositories/ISagaRepository.repository.js";
+import type { IEventBus } from "@/platform/events/IEventBus.js";
+import type { ILogger } from "@/platform/logger/ILogger.js";
+
+export interface SagaStep {
+  name: string;
+  execute(ctx: Record<string, unknown>): Promise<void>;
+  compensate(ctx: Record<string, unknown>): Promise<void>;
+}
+
+@injectable()
+export class SagaOrchestrator {
+  constructor(
+    @inject(ISagaRepository) private readonly sagaRepo: ISagaRepository,
+    @inject(IEventBus) private readonly eventBus: IEventBus,
+    @inject(ILogger) private readonly logger: ILogger,
+  ) {}
+
+  async execute(
+    sagaType: string,
+    steps: SagaStep[],
+    initialContext: Record<string, unknown>,
+  ): Promise<string> {
+    const saga = SagaInstance.start(sagaType, initialContext);
+    await this.sagaRepo.save(saga);
+
+    for (const step of steps) {
+      try {
+        this.logger.info(`Saga ${saga.id}: executing step ${step.name}`);
+        await step.execute(saga.context);
+        saga.advance(step.name);
+        await this.sagaRepo.save(saga);
+      } catch (error) {
+        this.logger.error(
+          `Saga ${saga.id}: step ${step.name} failed — ${error.message}`,
+        );
+        await this.compensate(saga, steps);
+        return saga.id;
+      }
+    }
+
+    saga.complete();
+    await this.sagaRepo.save(saga);
+    this.eventBus.publish({ type: "saga.completed", sagaId: saga.id });
+    return saga.id;
+  }
+
+  private async compensate(
+    saga: SagaInstance,
+    steps: SagaStep[],
+  ): Promise<void> {
+    const executed = steps.slice(0, saga.currentStepIndex);
+    for (const step of executed.reverse()) {
+      try {
+        this.logger.info(`Saga ${saga.id}: compensating step ${step.name}`);
+        await step.compensate(saga.context);
+      } catch (err) {
+        this.logger.error(
+          `Saga ${saga.id}: compensation failed for ${step.name} — requiere intervención manual`,
+        );
+        saga.requireManualIntervention(step.name, err.message);
+      }
+    }
+    saga.fail();
+    await this.sagaRepo.save(saga);
+  }
+}
+```

package/skills/forge/templates/feature/schema.ts.md

@@ -1,7 +1,7 @@
 ```typescript
 // src/features/<domain>/adapters/out/persistence/<Domain>.schema.ts
 import { model, Schema } from "mongoose";
-import type { <Domain> } from "../../../domain/<Domain>.entity.js";
+import type { <Domain> } from "../../../domain/entities/<Domain>.entity.js";
 
 const <Domain>Schema = new Schema<<Domain>>(
   {

package/skills/forge/templates/feature/use-case.ts.md

@@ -1,8 +1,8 @@
 ```typescript
 // src/features/<domain>/application/use-cases/Create<Domain>.uc.ts
 import { injectable, inject } from "tsyringe";
-import type { <Domain> } from "../../domain/<Domain>.entity.js";
-import type { I<Domain>Repository } from "../../domain/I<Domain>.repository.js";
+import type { <Domain> } from "../../domain/entities/<Domain>.entity.js";
+import type { I<Domain>Repository } from "../../domain/repositories/I<Domain>.repository.js";
 import { UseCaseError } from "@/shared/errors/UseCaseError.js";
 // Opcional: errores de dominio y eventos
 // import { <Domain>NotFoundError } from "../../domain/errors/<Domain>NotFound.error.js";

package/skills/forge/templates/platform/outbox-relayer.ts.md

@@ -0,0 +1,80 @@
+```typescript
+// src/platform/scheduler/OutboxRelayer.ts
+import { injectable, inject } from "tsyringe";
+import type { IEventBus } from "@/platform/events/IEventBus.js";
+import type { ILogger } from "@/platform/logger/ILogger.js";
+
+type OutboxEntry = {
+  id: string;
+  eventType: string;
+  payload: Record<string, unknown>;
+  retryCount: number;
+};
+
+@injectable()
+export class OutboxRelayer {
+  private readonly POLL_INTERVAL_MS = 1000;
+  private readonly MAX_RETRIES = 10;
+  private readonly BATCH_SIZE = 50;
+  private running = false;
+
+  constructor(
+    @inject(IEventBus) private readonly eventBus: IEventBus,
+    @inject(ILogger) private readonly logger: ILogger,
+  ) {}
+
+  async start(): Promise<void> {
+    this.running = true;
+    this.logger.info("OutboxRelayer started");
+    while (this.running) {
+      await this.processBatch();
+      await this.sleep(this.POLL_INTERVAL_MS);
+    }
+  }
+
+  stop(): void {
+    this.running = false;
+    this.logger.info("OutboxRelayer stopped");
+  }
+
+  private async processBatch(): Promise<void> {
+    const batch = await this.fetchUnprocessed();
+    for (const entry of batch) {
+      try {
+        await this.eventBus.publish(entry.payload);
+        await this.markProcessed(entry.id);
+      } catch (error) {
+        this.logger.error(`Outbox ${entry.id}: publish failed — ${error.message}`);
+        await this.incrementRetry(entry.id, error.message);
+        if (entry.retryCount >= this.MAX_RETRIES) {
+          await this.sendToDLQ(entry);
+        }
+      }
+    }
+  }
+
+  private async fetchUnprocessed(): Promise<OutboxEntry[]> {
+    // SELECT * FROM outbox WHERE processed_at IS NULL
+    //   AND retry_count < $1 ORDER BY occurred_at ASC LIMIT $2
+    return [];
+  }
+
+  private async markProcessed(id: string): Promise<void> {
+    // UPDATE outbox SET processed_at = NOW() WHERE id = $1
+  }
+
+  private async incrementRetry(id: string, error: string): Promise<void> {
+    // UPDATE outbox SET retry_count = retry_count + 1, last_error = $1 WHERE id = $2
+  }
+
+  private async sendToDLQ(entry: OutboxEntry): Promise<void> {
+    this.logger.error(`Outbox ${entry.id}: moved to DLQ after ${this.MAX_RETRIES} retries`);
+    // INSERT INTO outbox_dlq SELECT * FROM outbox WHERE id = $1
+    // DELETE FROM outbox WHERE id = $1
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+```