@alecsibilia/luca 14.0.0-alpha.2 → 14.0.0-alpha.21

package/engine/journal/join-entries.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod'
+
+import { ENTRY_FIELDS } from './entry-fields'
+
+import { BadTestSchema } from '../agents/role-results'
+
+/**
+ * The journal entries of joining tickets onto the run branch: the join, a
+ * rebase after a clash or failed gates, tests sent back, an undone join,
+ * and the push.
+ */
+
+/** An approved ticket's commits, replayed onto the run branch (or not). */
+export const TicketJoinedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('ticket_joined'),
+    content: z.discriminatedUnion('ok', [
+        z.object({
+            ok: z.literal(true),
+            /** The new commits on the run branch, oldest first. */
+            shas: z.array(z.string().min(1)),
+            /**
+             * The ticket's size: lines added plus lines removed by its
+             * commits, binary files counting 0. `null` in older journals.
+             */
+            lines_changed: z.number().int().min(0).nullable().default(null),
+        }),
+        z.object({ ok: z.literal(false), error: z.string() }),
+    ]),
+})
+
+/**
+ * A ticket's join is about to replay its commits onto the run branch, which
+ * stands at `run_branch_sha`. A join a crash cut off (no `ticket_joined`
+ * after this) is redone from there: the run branch is reset to it first.
+ */
+export const JoinStartedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('join_started'),
+    content: z.object({ run_branch_sha: z.string().min(1) }),
+})
+
+/**
+ * Why a joined ticket went back to be fixed on top of the run branch: its
+ * commits clashed with it, or the gates failed after it joined.
+ */
+export const RejoinCauseSchema = z.enum(['clash', 'join_gates'])
+
+export type RejoinCause = z.infer<typeof RejoinCauseSchema>
+
+/**
+ * The engine put a ticket's whole change back on top of the run branch, as
+ * uncommitted changes in its worktree, after a clash or failed gates after
+ * joining. `base_sha` is the run branch commit it now starts from. `tests`
+ * and `code` are the files that clashed (conflict markers left in them),
+ * split by the config's test file patterns. `undone` are the run branch
+ * commits the engine undid first (a join whose gates failed), and
+ * `reinstall` says whether the worktree needs its install again. As with
+ * `join_undone`, replay clears the join of any other ticket whose joined
+ * commits are among `undone` (#519).
+ */
+export const TicketRebasedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('ticket_rebased'),
+    content: z.object({
+        cause: RejoinCauseSchema,
+        base_sha: z.string().min(1),
+        tests: z.array(z.string()),
+        code: z.array(z.string()),
+        undone: z.array(z.string()),
+        /**
+         * The dependency files (manifests, lockfiles) differ between the
+         * worktree's old base and the new one, and the ticket's own change
+         * touches no manifest: the worktree gets its frozen install again.
+         * (A ticket that changes a manifest gets the install in its gates.)
+         */
+        reinstall: z.boolean().default(false),
+    }),
+})
+
+/**
+ * After a rebase, the implementer sent one of the ticket's tests back as bad
+ * (#489): the tickets that joined the run branch since the ticket's old base
+ * made it wrong. The engine sends it to the ticket's test-writer to update,
+ * with the implementer's code kept in the worktree. `round` counts these per
+ * ticket, from 1. `joined` are the tickets whose commits the run branch got
+ * between `from_sha` (the ticket's base before the rebase) and `base_sha`
+ * (its base now), and `files` the files the run branch changed between them.
+ */
+export const TestsSentBackEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('tests_sent_back'),
+    content: z.object({
+        round: z.number().int().positive(),
+        bad_test: BadTestSchema,
+        from_sha: z.string().min(1),
+        base_sha: z.string().min(1),
+        joined: z.array(
+            z.object({
+                ticket: z.number().int().positive(),
+                title: z.string(),
+            })
+        ),
+        files: z.array(z.string()),
+    }),
+})
+
+/**
+ * A stuck ticket's join was undone on the run branch (its commits were
+ * never pushed), so no other ticket builds on them. `shas` are every commit
+ * the undo took off the run branch, oldest first: the ticket's own join and
+ * any later, unpushed joins on top of it (#519). Replay clears the join of
+ * every ticket whose joined commits are among them, not only this one's, so
+ * those tickets join again on the run branch as it is now.
+ */
+export const JoinUndoneEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('join_undone'),
+    content: z.object({ shas: z.array(z.string()) }),
+})
+
+export const RunBranchPushedEntrySchema = z.object({
+    ...ENTRY_FIELDS,
+    kind: z.literal('run_branch_pushed'),
+    content: z.object({ branch: z.string(), sha: z.string() }),
+})

package/engine/journal/journal-entry-schema.ts

@@ -0,0 +1,218 @@
+/**
+ * What a caller hands the journal to append (`JournalEntrySchema`): every
+ * record kind's entry schema in one union. The journal adds `seq` and `time`
+ * (see `journal-record-schema.ts`). A new kind is added here, there, and in
+ * `journal-kinds.ts`.
+ */
+import { z } from 'zod'
+
+import {
+    AgentFailedEntrySchema,
+    AgentFinishedEntrySchema,
+    AgentSessionClosedEntrySchema,
+    AgentSessionEntrySchema,
+    AgentStartedEntrySchema,
+    ChoresDoneEntrySchema,
+    SharedGitChangedEntrySchema,
+} from './agent-entries'
+import {
+    AgentMessageDeliveredEntrySchema,
+    AgentMessageEntrySchema,
+} from './agent-message-entries'
+import {
+    AlreadyDoneCheckedEntrySchema,
+    TicketAlreadyDoneEntrySchema,
+    TicketClosedEntrySchema,
+} from './already-done-entries'
+import {
+    ChangesetDroppedEntrySchema,
+    CommitMadeEntrySchema,
+    LeftoverScanEntrySchema,
+} from './commit-entries'
+import {
+    DecisionModelOffEntrySchema,
+    JevAnsweredEntrySchema,
+    JevAskedEntrySchema,
+    JevFailedEntrySchema,
+} from './decision-model-entries'
+import {
+    FinalReviewFixingEntrySchema,
+    FinalReviewPassedEntrySchema,
+    FinalReviewRetriedEntrySchema,
+    FinalReviewShippedEntrySchema,
+    FinalReviewStartedEntrySchema,
+    FinalReviewStuckEntrySchema,
+    LensFinishedEntrySchema,
+    LensStartedEntrySchema,
+} from './final-review-entries'
+import {
+    DependenciesInstalledEntrySchema,
+    GatesRunEntrySchema,
+    RedCheckEntrySchema,
+} from './gate-entries'
+import {
+    IntakeReadEntrySchema,
+    IntakeRefusedEntrySchema,
+    NothingToDoEntrySchema,
+    SpecSnapshotEntrySchema,
+    TicketSnapshotEntrySchema,
+} from './intake-entries'
+import {
+    JoinStartedEntrySchema,
+    JoinUndoneEntrySchema,
+    RunBranchPushedEntrySchema,
+    TestsSentBackEntrySchema,
+    TicketJoinedEntrySchema,
+    TicketRebasedEntrySchema,
+} from './join-entries'
+import {
+    LimitWaitEndedEntrySchema,
+    LimitWaitStartedEntrySchema,
+    UsageLineWaitEndedEntrySchema,
+    UsageLineWaitStartedEntrySchema,
+    UsageRecordedEntrySchema,
+} from './limit-entries'
+import {
+    LearningSkippedEntrySchema,
+    MemoriesReportedEntrySchema,
+    MemoriesSavedEntrySchema,
+    MemoryRecalledEntrySchema,
+    MemoryWriteDoneEntrySchema,
+    MemoryWriteStartedEntrySchema,
+} from './memory-entries'
+import {
+    ChangesetWrittenEntrySchema,
+    PullRequestOpenedEntrySchema,
+} from './pull-request-entries'
+import {
+    RepoWaitEndedEntrySchema,
+    RepoWaitPsFailedEntrySchema,
+    RepoWaitSkippedEntrySchema,
+    RepoWaitStartedEntrySchema,
+} from './repo-wait-entries'
+import {
+    ConfigReloadedEntrySchema,
+    ConfigReloadRefusedEntrySchema,
+    EngineResumedEntrySchema,
+    RunResumedEntrySchema,
+    RunStartedEntrySchema,
+    RunStoppedEntrySchema,
+    StepEndedEntrySchema,
+    StepStartedEntrySchema,
+    TicketWaitingEntrySchema,
+} from './run-entries'
+import {
+    CommentReadEntrySchema,
+    ReplyIgnoredEntrySchema,
+    ReplyReceivedEntrySchema,
+    RunStuckEntrySchema,
+    StuckReportedEntrySchema,
+    TicketRetriedEntrySchema,
+    TicketSkippedEntrySchema,
+    TicketStuckEntrySchema,
+} from './stuck-entries'
+import {
+    BaselinePreparedEntrySchema,
+    BaselineReusedEntrySchema,
+    BaselineTestsEntrySchema,
+    PrepareMadeEntrySchema,
+    RunBranchCreatedEntrySchema,
+    TicketWorktreeCreatedEntrySchema,
+    WorktreeResetEntrySchema,
+    WorktreesRemovedEntrySchema,
+} from './worktree-entries'
+
+/**
+ * What a caller hands the journal to append: a kind, its content, and who it
+ * is about. The journal adds `seq` and `time`.
+ *
+ * Later tickets add kinds here.
+ */
+export const JournalEntrySchema = z.discriminatedUnion('kind', [
+    RunStartedEntrySchema,
+    IntakeReadEntrySchema,
+    IntakeRefusedEntrySchema,
+    NothingToDoEntrySchema,
+    SpecSnapshotEntrySchema,
+    TicketSnapshotEntrySchema,
+    RunBranchCreatedEntrySchema,
+    TicketWorktreeCreatedEntrySchema,
+    BaselinePreparedEntrySchema,
+    PrepareMadeEntrySchema,
+    BaselineTestsEntrySchema,
+    BaselineReusedEntrySchema,
+    AgentStartedEntrySchema,
+    AgentFinishedEntrySchema,
+    AgentFailedEntrySchema,
+    ChoresDoneEntrySchema,
+    RedCheckEntrySchema,
+    AlreadyDoneCheckedEntrySchema,
+    LeftoverScanEntrySchema,
+    ChangesetDroppedEntrySchema,
+    CommitMadeEntrySchema,
+    WorktreeResetEntrySchema,
+    DependenciesInstalledEntrySchema,
+    GatesRunEntrySchema,
+    TicketJoinedEntrySchema,
+    TicketRebasedEntrySchema,
+    TestsSentBackEntrySchema,
+    RunBranchPushedEntrySchema,
+    TicketStuckEntrySchema,
+    RunStuckEntrySchema,
+    ChangesetWrittenEntrySchema,
+    PullRequestOpenedEntrySchema,
+    JevAskedEntrySchema,
+    JevAnsweredEntrySchema,
+    JevFailedEntrySchema,
+    DecisionModelOffEntrySchema,
+    AgentSessionEntrySchema,
+    AgentSessionClosedEntrySchema,
+    SharedGitChangedEntrySchema,
+    RunStoppedEntrySchema,
+    LimitWaitStartedEntrySchema,
+    LimitWaitEndedEntrySchema,
+    UsageLineWaitStartedEntrySchema,
+    UsageLineWaitEndedEntrySchema,
+    UsageRecordedEntrySchema,
+    WorktreesRemovedEntrySchema,
+    AgentMessageEntrySchema,
+    AgentMessageDeliveredEntrySchema,
+    FinalReviewStartedEntrySchema,
+    LensStartedEntrySchema,
+    LensFinishedEntrySchema,
+    FinalReviewFixingEntrySchema,
+    FinalReviewStuckEntrySchema,
+    FinalReviewPassedEntrySchema,
+    FinalReviewShippedEntrySchema,
+    StuckReportedEntrySchema,
+    CommentReadEntrySchema,
+    ReplyReceivedEntrySchema,
+    ReplyIgnoredEntrySchema,
+    TicketRetriedEntrySchema,
+    TicketSkippedEntrySchema,
+    TicketAlreadyDoneEntrySchema,
+    TicketClosedEntrySchema,
+    JoinUndoneEntrySchema,
+    FinalReviewRetriedEntrySchema,
+    MemoryRecalledEntrySchema,
+    MemoryWriteStartedEntrySchema,
+    MemoryWriteDoneEntrySchema,
+    MemoriesSavedEntrySchema,
+    LearningSkippedEntrySchema,
+    MemoriesReportedEntrySchema,
+    StepStartedEntrySchema,
+    StepEndedEntrySchema,
+    TicketWaitingEntrySchema,
+    RunResumedEntrySchema,
+    JoinStartedEntrySchema,
+    EngineResumedEntrySchema,
+    ConfigReloadedEntrySchema,
+    ConfigReloadRefusedEntrySchema,
+    RepoWaitStartedEntrySchema,
+    RepoWaitEndedEntrySchema,
+    RepoWaitSkippedEntrySchema,
+    RepoWaitPsFailedEntrySchema,
+])
+
+/** A journal entry as callers write it; schema defaults fill the rest. */
+export type JournalEntry = z.input<typeof JournalEntrySchema>

package/engine/journal/journal-kinds.ts

@@ -0,0 +1,97 @@
+/**
+ * Every record kind the journal knows (`JournalKindSchema`, `JOURNAL_KINDS`).
+ * A new kind is added here, in `journal-entry-schema.ts`, and in
+ * `journal-record-schema.ts`.
+ */
+import { z } from 'zod'
+
+/** Every record kind the journal knows so far. */
+export const JournalKindSchema = z.enum([
+    'run_started',
+    'intake_read',
+    'intake_refused',
+    'nothing_to_do',
+    'spec_snapshot',
+    'ticket_snapshot',
+    'run_branch_created',
+    'ticket_worktree_created',
+    'baseline_prepared',
+    'prepare_made',
+    'baseline_tests',
+    'baseline_reused',
+    'agent_started',
+    'agent_finished',
+    'agent_failed',
+    'chores_done',
+    'red_check',
+    'already_done_checked',
+    'leftover_scan',
+    'changeset_dropped',
+    'commit_made',
+    'worktree_reset',
+    'dependencies_installed',
+    'gates_run',
+    'ticket_joined',
+    'ticket_rebased',
+    'tests_sent_back',
+    'run_branch_pushed',
+    'ticket_stuck',
+    'run_stuck',
+    'changeset_written',
+    'pull_request_opened',
+    'jev_asked',
+    'jev_answered',
+    'jev_failed',
+    'decision_model_off',
+    'agent_session',
+    'agent_session_closed',
+    'shared_git_changed',
+    'run_stopped',
+    'limit_wait_started',
+    'limit_wait_ended',
+    'usage_line_wait_started',
+    'usage_line_wait_ended',
+    'usage_recorded',
+    'worktrees_removed',
+    'agent_message',
+    'agent_message_delivered',
+    'final_review_started',
+    'lens_started',
+    'lens_finished',
+    'final_review_fixing',
+    'final_review_stuck',
+    'final_review_passed',
+    'final_review_shipped',
+    'stuck_reported',
+    'comment_read',
+    'reply_received',
+    'reply_ignored',
+    'ticket_retried',
+    'ticket_skipped',
+    'ticket_already_done',
+    'ticket_closed',
+    'join_undone',
+    'final_review_retried',
+    'memory_recalled',
+    'memory_write_started',
+    'memory_write_done',
+    'memories_saved',
+    'learning_skipped',
+    'memories_reported',
+    'step_started',
+    'step_ended',
+    'ticket_waiting',
+    'run_resumed',
+    'join_started',
+    'engine_resumed',
+    'config_reloaded',
+    'config_reload_refused',
+    'repo_wait_started',
+    'repo_wait_ended',
+    'repo_wait_skipped',
+    'repo_wait_ps_failed',
+])
+
+export type JournalKind = z.infer<typeof JournalKindSchema>
+
+export const JOURNAL_KINDS = JournalKindSchema.options

package/engine/journal/journal-record-schema.ts

@@ -0,0 +1,218 @@
+/**
+ * One line of a run's journal (`JournalRecordSchema`): every record kind's
+ * entry schema in one union, each with the `seq` and `time` the journal adds.
+ * A new kind is added here, in `journal-entry-schema.ts`, and in
+ * `journal-kinds.ts`.
+ */
+import { z } from 'zod'
+
+import {
+    AgentFailedEntrySchema,
+    AgentFinishedEntrySchema,
+    AgentSessionClosedEntrySchema,
+    AgentSessionEntrySchema,
+    AgentStartedEntrySchema,
+    ChoresDoneEntrySchema,
+    SharedGitChangedEntrySchema,
+} from './agent-entries'
+import {
+    AgentMessageDeliveredEntrySchema,
+    AgentMessageEntrySchema,
+} from './agent-message-entries'
+import {
+    AlreadyDoneCheckedEntrySchema,
+    TicketAlreadyDoneEntrySchema,
+    TicketClosedEntrySchema,
+} from './already-done-entries'
+import {
+    ChangesetDroppedEntrySchema,
+    CommitMadeEntrySchema,
+    LeftoverScanEntrySchema,
+} from './commit-entries'
+import {
+    DecisionModelOffEntrySchema,
+    JevAnsweredEntrySchema,
+    JevAskedEntrySchema,
+    JevFailedEntrySchema,
+} from './decision-model-entries'
+import {
+    FinalReviewFixingEntrySchema,
+    FinalReviewPassedEntrySchema,
+    FinalReviewRetriedEntrySchema,
+    FinalReviewShippedEntrySchema,
+    FinalReviewStartedEntrySchema,
+    FinalReviewStuckEntrySchema,
+    LensFinishedEntrySchema,
+    LensStartedEntrySchema,
+} from './final-review-entries'
+import {
+    DependenciesInstalledEntrySchema,
+    GatesRunEntrySchema,
+    RedCheckEntrySchema,
+} from './gate-entries'
+import {
+    IntakeReadEntrySchema,
+    IntakeRefusedEntrySchema,
+    NothingToDoEntrySchema,
+    SpecSnapshotEntrySchema,
+    TicketSnapshotEntrySchema,
+} from './intake-entries'
+import {
+    JoinStartedEntrySchema,
+    JoinUndoneEntrySchema,
+    RunBranchPushedEntrySchema,
+    TestsSentBackEntrySchema,
+    TicketJoinedEntrySchema,
+    TicketRebasedEntrySchema,
+} from './join-entries'
+import {
+    LimitWaitEndedEntrySchema,
+    LimitWaitStartedEntrySchema,
+    UsageLineWaitEndedEntrySchema,
+    UsageLineWaitStartedEntrySchema,
+    UsageRecordedEntrySchema,
+} from './limit-entries'
+import {
+    LearningSkippedEntrySchema,
+    MemoriesReportedEntrySchema,
+    MemoriesSavedEntrySchema,
+    MemoryRecalledEntrySchema,
+    MemoryWriteDoneEntrySchema,
+    MemoryWriteStartedEntrySchema,
+} from './memory-entries'
+import {
+    ChangesetWrittenEntrySchema,
+    PullRequestOpenedEntrySchema,
+} from './pull-request-entries'
+import {
+    RepoWaitEndedEntrySchema,
+    RepoWaitPsFailedEntrySchema,
+    RepoWaitSkippedEntrySchema,
+    RepoWaitStartedEntrySchema,
+} from './repo-wait-entries'
+import {
+    ConfigReloadedEntrySchema,
+    ConfigReloadRefusedEntrySchema,
+    EngineResumedEntrySchema,
+    RunResumedEntrySchema,
+    RunStartedEntrySchema,
+    RunStoppedEntrySchema,
+    StepEndedEntrySchema,
+    StepStartedEntrySchema,
+    TicketWaitingEntrySchema,
+} from './run-entries'
+import {
+    CommentReadEntrySchema,
+    ReplyIgnoredEntrySchema,
+    ReplyReceivedEntrySchema,
+    RunStuckEntrySchema,
+    StuckReportedEntrySchema,
+    TicketRetriedEntrySchema,
+    TicketSkippedEntrySchema,
+    TicketStuckEntrySchema,
+} from './stuck-entries'
+import {
+    BaselinePreparedEntrySchema,
+    BaselineReusedEntrySchema,
+    BaselineTestsEntrySchema,
+    PrepareMadeEntrySchema,
+    RunBranchCreatedEntrySchema,
+    TicketWorktreeCreatedEntrySchema,
+    WorktreeResetEntrySchema,
+    WorktreesRemovedEntrySchema,
+} from './worktree-entries'
+
+const STAMP_FIELDS = {
+    /** 1, 2, 3, ... in the order records were appended. */
+    seq: z.number().int().min(1),
+    time: z.iso.datetime(),
+}
+
+/** One line of a run's journal. */
+export const JournalRecordSchema = z.discriminatedUnion('kind', [
+    RunStartedEntrySchema.extend(STAMP_FIELDS),
+    IntakeReadEntrySchema.extend(STAMP_FIELDS),
+    IntakeRefusedEntrySchema.extend(STAMP_FIELDS),
+    NothingToDoEntrySchema.extend(STAMP_FIELDS),
+    SpecSnapshotEntrySchema.extend(STAMP_FIELDS),
+    TicketSnapshotEntrySchema.extend(STAMP_FIELDS),
+    RunBranchCreatedEntrySchema.extend(STAMP_FIELDS),
+    TicketWorktreeCreatedEntrySchema.extend(STAMP_FIELDS),
+    BaselinePreparedEntrySchema.extend(STAMP_FIELDS),
+    PrepareMadeEntrySchema.extend(STAMP_FIELDS),
+    BaselineTestsEntrySchema.extend(STAMP_FIELDS),
+    BaselineReusedEntrySchema.extend(STAMP_FIELDS),
+    AgentStartedEntrySchema.extend(STAMP_FIELDS),
+    AgentFinishedEntrySchema.extend(STAMP_FIELDS),
+    AgentFailedEntrySchema.extend(STAMP_FIELDS),
+    ChoresDoneEntrySchema.extend(STAMP_FIELDS),
+    RedCheckEntrySchema.extend(STAMP_FIELDS),
+    AlreadyDoneCheckedEntrySchema.extend(STAMP_FIELDS),
+    LeftoverScanEntrySchema.extend(STAMP_FIELDS),
+    ChangesetDroppedEntrySchema.extend(STAMP_FIELDS),
+    CommitMadeEntrySchema.extend(STAMP_FIELDS),
+    WorktreeResetEntrySchema.extend(STAMP_FIELDS),
+    DependenciesInstalledEntrySchema.extend(STAMP_FIELDS),
+    GatesRunEntrySchema.extend(STAMP_FIELDS),
+    TicketJoinedEntrySchema.extend(STAMP_FIELDS),
+    TicketRebasedEntrySchema.extend(STAMP_FIELDS),
+    TestsSentBackEntrySchema.extend(STAMP_FIELDS),
+    RunBranchPushedEntrySchema.extend(STAMP_FIELDS),
+    TicketStuckEntrySchema.extend(STAMP_FIELDS),
+    RunStuckEntrySchema.extend(STAMP_FIELDS),
+    ChangesetWrittenEntrySchema.extend(STAMP_FIELDS),
+    PullRequestOpenedEntrySchema.extend(STAMP_FIELDS),
+    JevAskedEntrySchema.extend(STAMP_FIELDS),
+    JevAnsweredEntrySchema.extend(STAMP_FIELDS),
+    JevFailedEntrySchema.extend(STAMP_FIELDS),
+    DecisionModelOffEntrySchema.extend(STAMP_FIELDS),
+    AgentSessionEntrySchema.extend(STAMP_FIELDS),
+    AgentSessionClosedEntrySchema.extend(STAMP_FIELDS),
+    SharedGitChangedEntrySchema.extend(STAMP_FIELDS),
+    RunStoppedEntrySchema.extend(STAMP_FIELDS),
+    LimitWaitStartedEntrySchema.extend(STAMP_FIELDS),
+    LimitWaitEndedEntrySchema.extend(STAMP_FIELDS),
+    UsageLineWaitStartedEntrySchema.extend(STAMP_FIELDS),
+    UsageLineWaitEndedEntrySchema.extend(STAMP_FIELDS),
+    UsageRecordedEntrySchema.extend(STAMP_FIELDS),
+    WorktreesRemovedEntrySchema.extend(STAMP_FIELDS),
+    AgentMessageEntrySchema.extend(STAMP_FIELDS),
+    AgentMessageDeliveredEntrySchema.extend(STAMP_FIELDS),
+    FinalReviewStartedEntrySchema.extend(STAMP_FIELDS),
+    LensStartedEntrySchema.extend(STAMP_FIELDS),
+    LensFinishedEntrySchema.extend(STAMP_FIELDS),
+    FinalReviewFixingEntrySchema.extend(STAMP_FIELDS),
+    FinalReviewStuckEntrySchema.extend(STAMP_FIELDS),
+    FinalReviewPassedEntrySchema.extend(STAMP_FIELDS),
+    FinalReviewShippedEntrySchema.extend(STAMP_FIELDS),
+    StuckReportedEntrySchema.extend(STAMP_FIELDS),
+    CommentReadEntrySchema.extend(STAMP_FIELDS),
+    ReplyReceivedEntrySchema.extend(STAMP_FIELDS),
+    ReplyIgnoredEntrySchema.extend(STAMP_FIELDS),
+    TicketRetriedEntrySchema.extend(STAMP_FIELDS),
+    TicketSkippedEntrySchema.extend(STAMP_FIELDS),
+    TicketAlreadyDoneEntrySchema.extend(STAMP_FIELDS),
+    TicketClosedEntrySchema.extend(STAMP_FIELDS),
+    JoinUndoneEntrySchema.extend(STAMP_FIELDS),
+    FinalReviewRetriedEntrySchema.extend(STAMP_FIELDS),
+    MemoryRecalledEntrySchema.extend(STAMP_FIELDS),
+    MemoryWriteStartedEntrySchema.extend(STAMP_FIELDS),
+    MemoryWriteDoneEntrySchema.extend(STAMP_FIELDS),
+    MemoriesSavedEntrySchema.extend(STAMP_FIELDS),
+    LearningSkippedEntrySchema.extend(STAMP_FIELDS),
+    MemoriesReportedEntrySchema.extend(STAMP_FIELDS),
+    StepStartedEntrySchema.extend(STAMP_FIELDS),
+    StepEndedEntrySchema.extend(STAMP_FIELDS),
+    TicketWaitingEntrySchema.extend(STAMP_FIELDS),
+    RunResumedEntrySchema.extend(STAMP_FIELDS),
+    JoinStartedEntrySchema.extend(STAMP_FIELDS),
+    EngineResumedEntrySchema.extend(STAMP_FIELDS),
+    ConfigReloadedEntrySchema.extend(STAMP_FIELDS),
+    ConfigReloadRefusedEntrySchema.extend(STAMP_FIELDS),
+    RepoWaitStartedEntrySchema.extend(STAMP_FIELDS),
+    RepoWaitEndedEntrySchema.extend(STAMP_FIELDS),
+    RepoWaitSkippedEntrySchema.extend(STAMP_FIELDS),
+    RepoWaitPsFailedEntrySchema.extend(STAMP_FIELDS),
+])
+
+export type JournalRecord = z.infer<typeof JournalRecordSchema>