Build Connected fleet trip

Model the lifecycle before the UI

Turn the trip blueprint into an explicit aggregate boundary owned by the application.

Build

Prove before continuing

Implement every command and event pair

Make intent, actor authority, allowed source state, committed state, and emitted fact reviewable together.

Build

Prove before continuing

Persist restart-safe records

Separate business identity, provider evidence, command receipts, immutable facts, audit, and downstream delivery.

Build

Prove before continuing

Make concurrency and replay deterministic

Apply optimistic expected versions and aggregate-scoped idempotency before executing effects.

Build

Prove before continuing

Control effects and unknown outcomes

Commit outbox intent atomically, execute effects outside the transaction, and reconcile ambiguous results.

Build

Prove before continuing

Run all hostile fixture scenarios

Exercise the success path plus replay, concurrency, state, and response-loss failures without an account.

Build

Prove before continuing

Trace the Delivery Control Tower capstone

Follow the maintained source through domain rules, adapter seam, repository transaction, HTTP boundary, UI evidence, and restart test.

Build

Prove before continuing

Qualify the real integration boundary

Replace only reviewed adapter seams and collect independent production evidence without weakening application invariants.

Build

Prove before continuing

Application-owned reliability scaffolds

The aggregate and SQL examples implement host truth; the fixture clients call the credential-free Journey Lab. Replace only the separately reviewed provider adapter seam.

type State = "planned" | "ready" | "active" | "exception" | "closing" | "closed";
type CommandName = "create_trip" | "confirm_device_ready" | "start_trip" | "raise_exception" | "resolve_exception" | "request_close" | "close_trip";

type Command = {
  name: CommandName;
  aggregateId: string;
  expectedVersion: number;
  idempotencyKey: string;
};

const transitions = {
  "create_trip": { from: [null], to: "planned", event: "trip.created" },
  "confirm_device_ready": { from: ["planned"], to: "ready", event: "trip.ready" },
  "start_trip": { from: ["ready"], to: "active", event: "trip.started" },
  "raise_exception": { from: ["active", "exception"], to: "exception", event: "trip.exception_raised" },
  "resolve_exception": { from: ["exception"], to: "active", event: "trip.exception_resolved" },
  "request_close": { from: ["active", "exception"], to: "closing", event: "trip.close_requested" },
  "close_trip": { from: ["closing"], to: "closed", event: "trip.closed" },
} as const;

export function decide(current: { state: State | null; version: number }, command: Command) {
  const rule = transitions[command.name];
  if (command.expectedVersion !== current.version) throw new Error("version_conflict");
  if (!rule.from.includes(current.state as never)) throw new Error("invalid_transition");
  return {
    state: rule.to as State,
    version: current.version + 1,
    event: rule.event,
    idempotencyKey: command.idempotencyKey,
  };
}

// Persist the result, immutable event, audit row, and outbox intent atomically.
// Store the first result by idempotencyKey before executing another effect.

Exit with reviewable evidence

Trace every external claim to an indexed source