vibe-coding-master 0.5.2 → 0.5.4

package/dist/backend/gateway/gateway-service.js

@@ -1,9 +1,9 @@
-import { readFile } from "node:fs/promises";
 import { VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
-import { parseAssistantContent, resolveExistingClaudeTranscriptPath } from "../services/claude-transcript-service.js";
+import { resolveExistingClaudeTranscriptPath } from "../services/claude-transcript-service.js";
+import { isFinalTurnTextEvent, readTranscriptTextEvents, selectLatestTurnReply } from "../services/claude-transcript-reply.js";
 import { parseGatewayCommand } from "./gateway-command-parser.js";
 import { createLarkRegistrationClient } from "./channels/lark-registration.js";
 const QR_LOGIN_TTL_MS = 8 * 60 * 1000;
@@ -13,7 +13,6 @@ const POLL_LONG_BACKOFF_MS = 30_000;
 const MAX_FAILURES_BEFORE_LONG_BACKOFF = 3;
 const DEFAULT_POLL_TIMEOUT_MS = 35_000;
 const LARK_REGISTRATION_CONFIRM_TIMEOUT_MS = 15_000;
-const MAX_LATEST_PM_REPLY_CHARS = 8_000;
 const GATEWAY_TRANSLATION_FAILURE_TEXT = "PM 回复已收到，但翻译失败。\n发送 /retry 重新翻译。";
 const COMMANDS_ALLOWED_WHEN_DISABLED = new Set([
     "help",
@@ -1186,29 +1185,6 @@ export function createGatewayService(deps) {
         });
     }
 }
-async function readTranscriptTextEvents(transcriptPath) {
-    const raw = await readFile(transcriptPath, "utf8");
-    const events = [];
-    for (const line of raw.split("\n")) {
-        if (!line.trim()) {
-            continue;
-        }
-        for (const event of parseAssistantContent(line)) {
-            if (event.kind === "text") {
-                events.push({
-                    id: event.id,
-                    timestamp: event.timestamp,
-                    text: event.text,
-                    stopReason: event.stopReason
-                });
-            }
-        }
-    }
-    return events;
-}
-function isFinalTurnTextEvent(event) {
-    return event.stopReason === "end_turn";
-}
 function selectEventsAfterCursor(events, cursorId) {
     if (events.length === 0) {
         return [];
@@ -1222,56 +1198,9 @@ function selectEventsAfterCursor(events, cursorId) {
     }
     return events.slice(index + 1);
 }
-function selectLatestTurnReply(events, session) {
-    if (events.length === 0) {
-        return undefined;
-    }
-    const startMs = timestampMs(session.lastTurnStartedAt);
-    const endMs = timestampMs(session.lastTurnEndedAt);
-    const finalEvents = events.filter(isFinalTurnTextEvent);
-    const selected = startMs === undefined
-        ? finalEvents.slice(-1)
-        : finalEvents.filter((event) => {
-            const eventMs = timestampMs(event.timestamp);
-            return eventMs !== undefined
-                && eventMs >= startMs - 1_000
-                && (endMs === undefined || eventMs <= endMs + 1_000);
-        });
-    if (selected.length === 0) {
-        return undefined;
-    }
-    const text = selected.map((event) => event.text).join("\n\n").trim();
-    if (!text) {
-        return undefined;
-    }
-    const limited = limitLatestPmReply(text);
-    const lastEvent = selected.at(-1);
-    return {
-        transcriptEventId: lastEvent?.id ?? null,
-        transcriptTimestamp: lastEvent?.timestamp ?? null,
-        text: limited.text,
-        truncated: limited.truncated
-    };
-}
 function latestPmReplyKey(repoRoot, taskSlug) {
     return JSON.stringify([repoRoot, taskSlug]);
 }
-function limitLatestPmReply(text) {
-    if (text.length <= MAX_LATEST_PM_REPLY_CHARS) {
-        return { text, truncated: false };
-    }
-    return {
-        text: text.slice(0, MAX_LATEST_PM_REPLY_CHARS).trimEnd(),
-        truncated: true
-    };
-}
-function timestampMs(value) {
-    if (!value) {
-        return undefined;
-    }
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
 function projectsText(projects) {
     if (projects.length === 0) {
         return "No recent projects. Connect a repository from desktop VCM first.";

package/dist/backend/services/claude-hook-service.js

@@ -1,5 +1,6 @@
-import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorToolRoleName, isVcmRoleName } from "../../shared/constants.js";
+import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorToolRoleName, isUserFacingRole, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
+import { readLatestRoleTurnReply } from "./claude-transcript-reply.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const MAX_ROLE_RETRY_ATTEMPTS = 20;
@@ -115,17 +116,29 @@ export function createClaudeHookService(deps) {
         void repoRoot;
         return input.taskSlug;
     }
+    // Defensive task-binding guard: only mutate a task's round/status when the
+    // posting role's authoritative session record is bound to that task. A session
+    // whose record reports a different slug (e.g. a project-scoped sentinel session)
+    // must not resume or clobber an unrelated task's flow. Absence of a record is
+    // not proof of misattribution, so the normal flow proceeds.
+    async function isHookSessionBoundToTask(context, role) {
+        const session = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, role);
+        return !session || session.taskSlug === context.taskSlug;
+    }
     async function handleUserPromptSubmitHook(input) {
         const eventName = parseHookEvent(input.event.hook_event_name);
         if (eventName !== "UserPromptSubmit") {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
-        deps.jobGuard?.notePromptSubmitted({
-            repoRoot: context.project.repoRoot,
-            taskSlug: context.taskSlug,
-            role: input.role
-        });
+        const boundToTask = await isHookSessionBoundToTask(context, input.role);
+        if (boundToTask) {
+            deps.jobGuard?.notePromptSubmitted({
+                repoRoot: context.project.repoRoot,
+                taskSlug: context.taskSlug,
+                role: input.role
+            });
+        }
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
@@ -134,14 +147,16 @@ export function createClaudeHookService(deps) {
             transcriptPath: stringOrUndefined(input.event.transcript_path),
             cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
-        await deps.roundService.recordClaudeHookEvent({
-            repoRoot: context.project.repoRoot,
-            stateRepoRoot: context.taskRepoRoot,
-            stateRoot: context.config.stateRoot,
-            taskSlug: context.taskSlug,
-            role: input.role,
-            eventName
-        });
+        if (boundToTask) {
+            await deps.roundService.recordClaudeHookEvent({
+                repoRoot: context.project.repoRoot,
+                stateRepoRoot: context.taskRepoRoot,
+                stateRoot: context.config.stateRoot,
+                taskSlug: context.taskSlug,
+                role: input.role,
+                eventName
+            });
+        }
         if (session) {
             await deps.translationService.recordConversationBoundary({
                 repoRoot: context.project.repoRoot,
@@ -276,6 +291,7 @@ export function createClaudeHookService(deps) {
     async function recordTurnEnd(input, context, eventName, options) {
         const scopedRouteDispatchInput = createRouteDispatchInput(input, context, input.role);
         const settleRouteDispatchInput = createRouteDispatchInput(input, context);
+        const boundToTask = await isHookSessionBoundToTask(context, input.role);
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
@@ -284,28 +300,32 @@ export function createClaudeHookService(deps) {
             transcriptPath: stringOrUndefined(input.event.transcript_path),
             cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
-        await deps.roundService.recordClaudeHookEvent({
-            repoRoot: context.project.repoRoot,
-            stateRepoRoot: context.taskRepoRoot,
-            stateRoot: context.config.stateRoot,
-            taskSlug: context.taskSlug,
-            role: input.role,
-            eventName,
-            ...(options.settleGuard
-                ? {
-                    settleGuard: async () => {
-                        const pending = await deps.messageService.listPendingRouteFiles(settleRouteDispatchInput);
-                        if (pending.length === 0) {
-                            return { action: "stop" };
+        if (boundToTask) {
+            const userFacingReply = await captureUserFacingReply(eventName, input.role, session);
+            await deps.roundService.recordClaudeHookEvent({
+                repoRoot: context.project.repoRoot,
+                stateRepoRoot: context.taskRepoRoot,
+                stateRoot: context.config.stateRoot,
+                taskSlug: context.taskSlug,
+                role: input.role,
+                eventName,
+                ...(userFacingReply ? { userFacingReply } : {}),
+                ...(options.settleGuard
+                    ? {
+                        settleGuard: async () => {
+                            const pending = await deps.messageService.listPendingRouteFiles(settleRouteDispatchInput);
+                            if (pending.length === 0) {
+                                return { action: "stop" };
+                            }
+                            const retried = await deps.messageService.scanAndDispatchPendingRouteFiles(settleRouteDispatchInput);
+                            return retried.some((result) => result.delivered)
+                                ? { action: "continue", reason: "pending route message dispatched" }
+                                : { action: "stop" };
                         }
-                        const retried = await deps.messageService.scanAndDispatchPendingRouteFiles(settleRouteDispatchInput);
-                        return retried.some((result) => result.delivered)
-                            ? { action: "continue", reason: "pending route message dispatched" }
-                            : { action: "stop" };
                     }
-                }
-                : {})
-        });
+                    : {})
+            });
+        }
         if (session) {
             await deps.translationService.recordConversationBoundary({
                 repoRoot: context.project.repoRoot,
@@ -582,6 +602,21 @@ function parseHookEvent(value) {
         hint: "VCM accepts UserPromptSubmit, Stop, StopFailure, and PostCompact hooks only."
     });
 }
+// On a user-facing role's Stop, best-effort capture its last user-facing turn
+// text to seed the await-user pause message. Capture failure is non-fatal and
+// must never block turn-end, so a missing/failed read just omits the field.
+async function captureUserFacingReply(eventName, role, session) {
+    if (eventName !== "Stop" || !isUserFacingRole(role) || !session) {
+        return undefined;
+    }
+    try {
+        const reply = await readLatestRoleTurnReply(session);
+        return reply ? { text: reply.text, truncated: reply.truncated } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function throwUnsupportedEvent(eventName) {
     throw new VcmError({
         code: "HOOK_EVENT_UNSUPPORTED",

package/dist/backend/services/claude-transcript-reply.js

@@ -0,0 +1,107 @@
+import { readFile } from "node:fs/promises";
+import { parseAssistantContent, resolveExistingClaudeTranscriptPath } from "./claude-transcript-service.js";
+/** Default maximum captured-reply length (characters). */
+export const MAX_TURN_REPLY_CHARS = 8_000;
+/** Tolerance applied when matching transcript events to the role's last-turn window. */
+const TURN_WINDOW_TOLERANCE_MS = 1_000;
+/**
+ * Best-effort read of a role's latest user-facing turn reply.
+ *
+ * Resolves the session's transcript, selects the `end_turn` text emitted within
+ * the session's last-turn window (`lastTurnStartedAt`..`lastTurnEndedAt`), and
+ * truncates to `options.maxLength` (default `MAX_TURN_REPLY_CHARS`). Returns
+ * `undefined` when no transcript or no usable text is available — callers must
+ * treat a missing reply as non-fatal.
+ */
+export async function readLatestRoleTurnReply(session, options) {
+    const transcriptPath = resolveExistingClaudeTranscriptPath(session);
+    if (!transcriptPath) {
+        return undefined;
+    }
+    let events;
+    try {
+        events = await readTranscriptTextEvents(transcriptPath);
+    }
+    catch {
+        return undefined;
+    }
+    return selectLatestTurnReply(events, session, options?.maxLength ?? MAX_TURN_REPLY_CHARS);
+}
+/** Read all assistant text events from a transcript file (throws on read failure). */
+export async function readTranscriptTextEvents(transcriptPath) {
+    const raw = await readFile(transcriptPath, "utf8");
+    const events = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim()) {
+            continue;
+        }
+        for (const event of parseAssistantContent(line)) {
+            if (event.kind === "text") {
+                events.push({
+                    id: event.id,
+                    timestamp: event.timestamp,
+                    text: event.text,
+                    stopReason: event.stopReason
+                });
+            }
+        }
+    }
+    return events;
+}
+/** True for a text event that completed a turn (assistant stopped of its own accord). */
+export function isFinalTurnTextEvent(event) {
+    return event.stopReason === "end_turn";
+}
+/**
+ * Select the role's last completed user-facing reply from its transcript events,
+ * scoped to the session's last-turn window, joined and truncated. Returns
+ * `undefined` when no end_turn text falls in the window or the text is empty.
+ */
+export function selectLatestTurnReply(events, session, maxLength = MAX_TURN_REPLY_CHARS) {
+    if (events.length === 0) {
+        return undefined;
+    }
+    const startMs = timestampMs(session.lastTurnStartedAt);
+    const endMs = timestampMs(session.lastTurnEndedAt);
+    const finalEvents = events.filter(isFinalTurnTextEvent);
+    const selected = startMs === undefined
+        ? finalEvents.slice(-1)
+        : finalEvents.filter((event) => {
+            const eventMs = timestampMs(event.timestamp);
+            return eventMs !== undefined
+                && eventMs >= startMs - TURN_WINDOW_TOLERANCE_MS
+                && (endMs === undefined || eventMs <= endMs + TURN_WINDOW_TOLERANCE_MS);
+        });
+    if (selected.length === 0) {
+        return undefined;
+    }
+    const text = selected.map((event) => event.text).join("\n\n").trim();
+    if (!text) {
+        return undefined;
+    }
+    const limited = limitTranscriptReply(text, maxLength);
+    const lastEvent = selected.at(-1);
+    return {
+        transcriptEventId: lastEvent?.id ?? null,
+        transcriptTimestamp: lastEvent?.timestamp ?? null,
+        text: limited.text,
+        truncated: limited.truncated
+    };
+}
+/** Truncate reply text to `maxLength`, reporting whether truncation occurred. */
+export function limitTranscriptReply(text, maxLength = MAX_TURN_REPLY_CHARS) {
+    if (text.length <= maxLength) {
+        return { text, truncated: false };
+    }
+    return {
+        text: text.slice(0, maxLength).trimEnd(),
+        truncated: true
+    };
+}
+function timestampMs(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}

package/dist/backend/services/round-service.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { randomUUID } from "node:crypto";
+import { isUserFacingRole } from "../../shared/constants.js";
 const DEFAULT_SETTLE_MS = 10_000;
 const setGlobalTimeout = globalThis.setTimeout.bind(globalThis);
 const clearGlobalTimeout = globalThis.clearTimeout.bind(globalThis);
@@ -108,6 +109,8 @@ export function createRoundService(deps) {
             ...state,
             currentRound: stopped,
             lastStoppedRound: stopped,
+            awaitingUser: resolveAwaitingUserOnStop(state.awaitingUser, current.activeRole, stopped.stoppedAt ?? timestamp, state.pendingUserReply),
+            pendingUserReply: undefined,
             updatedAt: timestamp
         };
         await save(input, next);
@@ -193,7 +196,7 @@ export function createRoundService(deps) {
             const settled = await settleIfNeeded(input, await load(input), timestamp);
             const current = settled.currentRound;
             const shouldStartNewRound = input.eventName === "UserPromptSubmit" && (!current || current.status === "stopped");
-            const next = applyRoundHookEvent({
+            const recorded = applyRoundHookEvent({
                 state: settled,
                 taskSlug: input.taskSlug,
                 role: input.role,
@@ -202,6 +205,8 @@ export function createRoundService(deps) {
                 roundId: shouldStartNewRound ? id() : current?.id ?? "",
                 settleMs
             });
+            const answered = clearAwaitingUserIfAnswered(recorded, input.eventName, input.role);
+            const next = applyPendingUserReplyStash(answered, input, timestamp);
             await save(input, next);
             if (input.eventName === "UserPromptSubmit") {
                 clearSettleTimer(input);
@@ -383,7 +388,7 @@ function toSessionRoundState(state, updatedAt) {
             totalCcActiveMs: state.totalCcActiveMs,
             currentRoundCcActiveMs: 0,
             roleRecovery: state.roleRecovery,
-            flowPause: computeFlowPause(undefined, state.roleRecovery),
+            flowPause: computeFlowPause(undefined, state.roleRecovery, state.awaitingUser),
             roles: [],
             updatedAt
         };
@@ -412,41 +417,147 @@ function toSessionRoundState(state, updatedAt) {
         totalCcActiveMs: state.totalCcActiveMs + activeDurationMs,
         currentRoundCcActiveMs,
         roleRecovery: state.roleRecovery,
-        flowPause: computeFlowPause(current, state.roleRecovery),
+        flowPause: computeFlowPause(current, state.roleRecovery, state.awaitingUser),
         roles: current.roles,
         updatedAt
     };
 }
 /**
- * Authoritative flow-pause predicate (single source of truth). Returns a paused
- * VcmFlowPauseState exactly when a real round has ended and the auto flow has not
- * advanced and we are not mid active-recovery — mirroring the decision the GUI
- * previously derived. Reason is `role-recovery-failed` when recovery has failed,
- * otherwise `stopped-no-next-turn`. Returns a non-paused state (or undefined) when
- * the flow is not paused. The frontend consumes this instead of re-deriving it.
+ * Authoritative flow-pause predicate (single source of truth). The frontend
+ * consumes this instead of re-deriving the pause decision.
  *
- * Intended logic (to implement):
- *   const recovering = roleRecovery?.status === "waiting" || roleRecovery?.status === "retrying";
- *   const paused = !!current && current.status === "stopped" && !!current.id && !recovering;
- *   if (!paused) return undefined; // or { paused: false }
- *   return {
- *     paused: true,
- *     reason: roleRecovery?.status === "failed" ? "role-recovery-failed" : "stopped-no-next-turn",
- *     role: current.activeRole,
- *     since: current.stoppedAt ?? current.lastTurnEndedAt
- *   };
+ * Reason precedence: `role-recovery-failed` > `awaiting-user` > `stopped-no-next-turn`.
+ * - `awaiting-user` is emitted whenever `awaitingUser` is set and recovery has not
+ *   failed. It is STICKY: it stays paused regardless of round status (the round may
+ *   auto-continue under another role while the user's decision is still pending).
+ * - `stopped-no-next-turn` is emitted only when a real round has ended and the auto
+ *   flow has not advanced and we are not mid active-recovery.
  */
-function computeFlowPause(current, roleRecovery) {
+function computeFlowPause(current, roleRecovery, awaitingUser) {
     const recovering = roleRecovery?.status === "waiting" || roleRecovery?.status === "retrying";
-    const paused = Boolean(current) && current.status === "stopped" && Boolean(current.id) && !recovering;
-    if (!paused) {
+    if (recovering) {
+        return undefined;
+    }
+    const roundStopped = Boolean(current) && current.status === "stopped" && Boolean(current.id);
+    if (roleRecovery?.status === "failed") {
+        return roundStopped
+            ? {
+                paused: true,
+                reason: "role-recovery-failed",
+                role: current.activeRole,
+                since: current.stoppedAt ?? current.lastTurnEndedAt
+            }
+            : undefined;
+    }
+    if (awaitingUser) {
+        return {
+            paused: true,
+            reason: "awaiting-user",
+            role: awaitingUser.role,
+            since: awaitingUser.since,
+            message: awaitingUser.message,
+            messageTruncated: awaitingUser.messageTruncated
+        };
+    }
+    if (roundStopped) {
+        return {
+            paused: true,
+            reason: "stopped-no-next-turn",
+            role: current.activeRole,
+            since: current.stoppedAt ?? current.lastTurnEndedAt
+        };
+    }
+    return undefined;
+}
+/**
+ * Sticky await-user resolution on settle->stopped: keep any existing anchor
+ * untouched, and only set a new one when the settling role addresses the human
+ * operator. Non-user-facing roles never raise an await-user anchor.
+ */
+function resolveAwaitingUserOnStop(existing, role, since, pendingReply) {
+    if (existing) {
+        return existing;
+    }
+    if (!isUserFacingRole(role)) {
+        return undefined;
+    }
+    if (pendingReply && pendingReply.role === role) {
+        return {
+            role,
+            since,
+            capturedAt: pendingReply.capturedAt,
+            message: pendingReply.text,
+            messageTruncated: pendingReply.truncated
+        };
+    }
+    return { role, since };
+}
+/**
+ * Maintain the transient `pendingUserReply` stash. A user-facing role's Stop with
+ * a captured reply records it until settle promotes it to `awaitingUser.message`.
+ * The same role's next UserPromptSubmit obsoletes the stash (turn answered/resumed),
+ * so stale text can never attach to a later anchor.
+ */
+function applyPendingUserReplyStash(state, input, timestamp) {
+    if (input.eventName === "Stop" && isUserFacingRole(input.role) && input.userFacingReply) {
+        return {
+            ...state,
+            pendingUserReply: {
+                role: input.role,
+                text: input.userFacingReply.text,
+                truncated: input.userFacingReply.truncated,
+                capturedAt: timestamp
+            }
+        };
+    }
+    if (input.eventName === "UserPromptSubmit"
+        && state.pendingUserReply?.role === input.role) {
+        return { ...state, pendingUserReply: undefined };
+    }
+    return state;
+}
+/**
+ * Clear the await-user anchor only when the awaiting role itself receives its
+ * next UserPromptSubmit (the user answered / that role resumed). Other roles,
+ * other events, and round auto-continuation never clear it.
+ */
+function clearAwaitingUserIfAnswered(state, eventName, role) {
+    if (eventName !== "UserPromptSubmit" || state.awaitingUser?.role !== role) {
+        return state;
+    }
+    return { ...state, awaitingUser: undefined };
+}
+function normalizeAwaitingUser(input) {
+    if (!input || typeof input !== "object") {
+        return undefined;
+    }
+    const record = input;
+    if (typeof record.role !== "string" || typeof record.since !== "string") {
+        return undefined;
+    }
+    return {
+        role: record.role,
+        since: record.since,
+        capturedAt: typeof record.capturedAt === "string" ? record.capturedAt : undefined,
+        message: typeof record.message === "string" ? record.message : undefined,
+        messageTruncated: record.messageTruncated === true ? true : undefined
+    };
+}
+function normalizePendingUserReply(input) {
+    if (!input || typeof input !== "object") {
+        return undefined;
+    }
+    const record = input;
+    if (typeof record.role !== "string"
+        || typeof record.text !== "string"
+        || typeof record.capturedAt !== "string") {
         return undefined;
     }
     return {
-        paused: true,
-        reason: roleRecovery?.status === "failed" ? "role-recovery-failed" : "stopped-no-next-turn",
-        role: current.activeRole,
-        since: current.stoppedAt ?? current.lastTurnEndedAt
+        role: record.role,
+        text: record.text,
+        truncated: record.truncated === true,
+        capturedAt: record.capturedAt
     };
 }
 function normalizeRoundFile(input, taskSlug, updatedAt) {
@@ -461,6 +572,8 @@ function normalizeRoundFile(input, taskSlug, updatedAt) {
         totalCompletedTurnCount: normalizeNumber(input.totalCompletedTurnCount ?? legacy.totalStopCount),
         totalCcActiveMs: normalizeNumber(input.totalCcActiveMs),
         roleRecovery: normalizeRoleRecovery(input.roleRecovery),
+        awaitingUser: normalizeAwaitingUser(input.awaitingUser),
+        pendingUserReply: normalizePendingUserReply(input.pendingUserReply),
         updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : updatedAt
     };
 }