@shipwithai/loopnote 0.0.0-stage → 2.0.0

package/dist/contracts/request.js

@@ -0,0 +1,124 @@
+import { Buffer } from 'node:buffer';
+import { z } from 'zod';
+import { RENAME_MAP } from '../domain/product-identity.js';
+export const MAX_AGENT_REQUEST_BYTES = 1_048_576;
+export const MAX_GIT_ARGUMENT_BYTES = 4_096;
+export const MAX_PATHSPEC_COUNT = 256;
+const emptyPathspecs = [];
+function isValidUnicode(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff)) {
+                return false;
+            }
+            index += 1;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+function isBoundedGitArgument(value) {
+    return value.length > 0 && !value.includes('\0') && isValidUnicode(value) && Buffer.byteLength(value, 'utf8') <= MAX_GIT_ARGUMENT_BYTES;
+}
+export const GitArgumentSchema = z.string().refine(isBoundedGitArgument, {
+    message: 'Git arguments must be non-empty, valid Unicode without NUL, and at most 4096 UTF-8 bytes.',
+});
+const RevisionRangeSchema = z
+    .strictObject({
+    base: GitArgumentSchema,
+    head: GitArgumentSchema,
+    pathspecs: z
+        .array(GitArgumentSchema)
+        .max(MAX_PATHSPEC_COUNT)
+        .default(emptyPathspecs)
+        .transform((pathspecs) => Object.freeze(pathspecs)),
+})
+    .readonly();
+const ExactPatchContentSchema = z
+    .string()
+    .refine((value) => value.length > 0 && !value.includes('\0') && isValidUnicode(value) && Buffer.byteLength(value, 'utf8') <= MAX_AGENT_REQUEST_BYTES, { message: 'Patch content must be valid Unicode without NUL and fit within the request byte limit.' });
+const ExactPatchTargetSchema = z
+    .discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('repository') }),
+    z.strictObject({ kind: z.literal('worktree') }),
+])
+    .readonly();
+export const ExactPatchRequestSchema = z
+    .strictObject({
+    kind: z.literal(`${RENAME_MAP.kindPrefix}.review-request`),
+    schemaVersion: z.literal(1),
+    mode: z.literal('patch'),
+    patch: z
+        .strictObject({
+        content: ExactPatchContentSchema,
+        target: ExactPatchTargetSchema,
+    })
+        .readonly(),
+})
+    .readonly();
+const RevisionRequestSchema = z
+    .strictObject({
+    kind: z.literal(`${RENAME_MAP.kindPrefix}.review-request`),
+    schemaVersion: z.literal(1),
+    mode: z.literal('revisions'),
+    revisions: RevisionRangeSchema,
+})
+    .readonly();
+const UncommittedSourceSchema = z.enum(['staged', 'unstaged', 'worktree']);
+const UncommittedRequestScopeSchema = z
+    .strictObject({
+    source: UncommittedSourceSchema,
+    base: GitArgumentSchema.optional(),
+    pathspecs: z
+        .array(GitArgumentSchema)
+        .max(MAX_PATHSPEC_COUNT)
+        .default(emptyPathspecs)
+        .transform((pathspecs) => Object.freeze(pathspecs)),
+})
+    .superRefine((scope, ctx) => {
+    if (scope.source === 'unstaged' && scope.base !== undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['base'],
+            message: '"base" cannot be combined with source "unstaged".',
+        });
+    }
+})
+    .readonly();
+const UncommittedRequestSchema = z
+    .strictObject({
+    kind: z.literal(`${RENAME_MAP.kindPrefix}.review-request`),
+    schemaVersion: z.literal(1),
+    mode: z.literal('uncommitted'),
+    uncommitted: UncommittedRequestScopeSchema,
+})
+    .readonly();
+const FilesRequestScopeSchema = z
+    .strictObject({
+    paths: z
+        .array(GitArgumentSchema)
+        .min(1)
+        .max(MAX_PATHSPEC_COUNT)
+        .transform((paths) => Object.freeze(paths)),
+})
+    .readonly();
+const FilesRequestSchema = z
+    .strictObject({
+    kind: z.literal(`${RENAME_MAP.kindPrefix}.review-request`),
+    schemaVersion: z.literal(1),
+    mode: z.literal('files'),
+    files: FilesRequestScopeSchema,
+})
+    .readonly();
+export const AgentReviewRequestSchema = z
+    .discriminatedUnion('mode', [
+    RevisionRequestSchema,
+    ExactPatchRequestSchema,
+    UncommittedRequestSchema,
+    FilesRequestSchema,
+])
+    .readonly();

package/dist/domain/anchor.js

@@ -0,0 +1,122 @@
+import { createHash } from 'node:crypto';
+import { decodeBase64url } from './path-bytes.js';
+import { RENAME_MAP } from './product-identity.js';
+const CONTEXT_DOMAIN = Buffer.from(`${RENAME_MAP.slug}-anchor-context-v1`, 'utf8');
+const UNIQUE_DOMAIN = Buffer.from(`${RENAME_MAP.slug}-anchor-unique-v1`, 'utf8');
+const UTF8 = new TextEncoder();
+function framedSha256(domain, fields) {
+    const hash = createHash('sha256');
+    hash.update(domain);
+    for (const field of fields) {
+        const length = Buffer.allocUnsafe(8);
+        length.writeBigUInt64BE(BigInt(field.byteLength));
+        hash.update(length);
+        hash.update(field);
+    }
+    return hash.digest('hex');
+}
+function encodeLine(line) {
+    return [UTF8.encode(String(line.line)), UTF8.encode(line.text)];
+}
+function sameLine(left, right) {
+    return left.line === right.line && left.text === right.text;
+}
+function sameLines(left, right) {
+    return left.length === right.length && left.every((line, index) => sameLine(line, right[index]));
+}
+function samePath(left, right) {
+    return left.bytesBase64url === right.bytesBase64url;
+}
+function contextHash(pathBytes, side, blobOid, line, endLine, context, selectedText) {
+    const fields = [
+        pathBytes,
+        UTF8.encode(side),
+        UTF8.encode(blobOid),
+        UTF8.encode(String(line)),
+    ];
+    if (endLine !== undefined) {
+        fields.push(UTF8.encode('endLine'), UTF8.encode(String(endLine)), UTF8.encode('selectedText'), UTF8.encode(selectedText));
+    }
+    fields.push(UTF8.encode('before'));
+    for (const entry of context.before) {
+        fields.push(...encodeLine(entry));
+    }
+    fields.push(UTF8.encode('target'), ...encodeLine(context.target), UTF8.encode('after'));
+    for (const entry of context.after) {
+        fields.push(...encodeLine(entry));
+    }
+    return framedSha256(CONTEXT_DOMAIN, fields);
+}
+function duplicateKey(pathBytes, side, blobOid, line) {
+    return framedSha256(UNIQUE_DOMAIN, [
+        pathBytes,
+        UTF8.encode(side),
+        UTF8.encode(blobOid),
+        UTF8.encode(String(line)),
+    ]);
+}
+export function buildDurableAnchor(input) {
+    if (!Number.isSafeInteger(input.line) || input.line < 1) {
+        throw new RangeError('Anchor line must be a positive safe integer.');
+    }
+    if (input.endLine !== undefined &&
+        (!Number.isSafeInteger(input.endLine) || input.endLine < input.line)) {
+        throw new RangeError('Anchor endLine must be a safe integer not less than line.');
+    }
+    const lines = input.text.split(/\r\n|\n/u);
+    const lastLine = input.endLine ?? input.line;
+    if (lastLine > lines.length) {
+        throw new RangeError('Anchor line is outside frozen text.');
+    }
+    const targetIndex = input.line - 1;
+    const endIndex = lastLine - 1;
+    const before = lines
+        .slice(Math.max(0, targetIndex - 3), targetIndex)
+        .map((text, index) => Object.freeze({ line: Math.max(1, input.line - 3) + index, text }));
+    const target = Object.freeze({ line: input.line, text: lines[targetIndex] });
+    const after = lines
+        .slice(endIndex + 1, endIndex + 4)
+        .map((text, index) => Object.freeze({ line: lastLine + index + 1, text }));
+    const context = Object.freeze({
+        before: Object.freeze(before),
+        target,
+        after: Object.freeze(after),
+    });
+    const selectedText = input.endLine === undefined ? target.text : lines.slice(targetIndex, endIndex + 1).join('\n');
+    const pathBytes = decodeBase64url(input.path.bytesBase64url);
+    const contextHashValue = contextHash(pathBytes, input.side, input.blobOid, input.line, input.endLine, context, selectedText);
+    return Object.freeze({
+        version: 'durable-anchor-v1',
+        path: input.path,
+        safeDisplayPath: input.safeDisplayPath,
+        side: input.side,
+        line: input.line,
+        ...(input.endLine === undefined ? {} : { endLine: input.endLine }),
+        blobOid: input.blobOid,
+        selectedText,
+        context,
+        contextHash: Object.freeze({ algorithm: 'sha256-v1', value: contextHashValue }),
+        uniqueKey: duplicateKey(pathBytes, input.side, input.blobOid, input.line),
+    });
+}
+export function verifyDurableAnchor(recorded, current) {
+    if (current === undefined) {
+        return Object.freeze({ state: 'orphaned', reason: 'anchor-unavailable' });
+    }
+    const matches = recorded.version === current.version &&
+        samePath(recorded.path, current.path) &&
+        recorded.side === current.side &&
+        recorded.line === current.line &&
+        recorded.endLine === current.endLine &&
+        recorded.blobOid === current.blobOid &&
+        recorded.selectedText === current.selectedText &&
+        sameLines(recorded.context.before, current.context.before) &&
+        sameLine(recorded.context.target, current.context.target) &&
+        sameLines(recorded.context.after, current.context.after) &&
+        recorded.contextHash.algorithm === current.contextHash.algorithm &&
+        recorded.contextHash.value === current.contextHash.value &&
+        recorded.uniqueKey === current.uniqueKey;
+    return Object.freeze(matches
+        ? { state: 'verified', reason: 'exact-match' }
+        : { state: 'stale', reason: 'anchor-mismatch' });
+}

package/dist/domain/comparison-key.js

@@ -0,0 +1,51 @@
+import { createHash } from 'node:crypto';
+import { RENAME_MAP } from './product-identity.js';
+const DOMAIN = Buffer.from(`${RENAME_MAP.slug}-comparison-key-v1`, 'utf8');
+const RANGE_DOMAIN = Buffer.from(`${RENAME_MAP.slug}-range-review-key-v1`, 'utf8');
+const UNCOMMITTED_DOMAIN = Buffer.from(`${RENAME_MAP.slug}-uncommitted-review-key-v1`, 'utf8');
+const STANDALONE_DOMAIN = Buffer.from(`${RENAME_MAP.slug}-standalone-review-key-v1`, 'utf8');
+const encoder = new TextEncoder();
+function frame(value) {
+    const bytes = encoder.encode(value);
+    const length = Buffer.allocUnsafe(8);
+    length.writeBigUInt64BE(BigInt(bytes.byteLength));
+    return Buffer.concat([length, bytes]);
+}
+/**
+ * Computes the repository-local draft identity for an ordered pinned comparison.
+ * Labels, refs, merge bases, and paths deliberately never enter this namespace.
+ */
+export function comparisonKey(baseCommitOid, headCommitOid) {
+    const hash = createHash('sha256');
+    hash.update(DOMAIN);
+    hash.update(frame(baseCommitOid));
+    hash.update(frame(headCommitOid));
+    return hash.digest('hex');
+}
+export function rangeReviewKey(baseCommitOid, headCommitOid, pathspecs) {
+    const hash = createHash('sha256');
+    hash.update(RANGE_DOMAIN);
+    hash.update(frame(baseCommitOid));
+    hash.update(frame(headCommitOid));
+    for (const pathspec of pathspecs) {
+        hash.update(frame(pathspec));
+    }
+    return hash.digest('hex');
+}
+export function uncommittedReviewKey(sourceKind, baseCommitOid, firstSnapshotDigest) {
+    const hash = createHash('sha256');
+    hash.update(UNCOMMITTED_DOMAIN);
+    hash.update(frame(sourceKind));
+    hash.update(frame(baseCommitOid ?? ''));
+    hash.update(frame(firstSnapshotDigest));
+    return hash.digest('hex');
+}
+export function standaloneReviewKey(sortedOriginalArguments, firstSnapshotDigest) {
+    const hash = createHash('sha256');
+    hash.update(STANDALONE_DOMAIN);
+    for (const argument of sortedOriginalArguments) {
+        hash.update(frame(argument));
+    }
+    hash.update(frame(firstSnapshotDigest));
+    return hash.digest('hex');
+}

package/dist/domain/errors.js

@@ -0,0 +1,43 @@
+import { RENAME_MAP } from './product-identity.js';
+export class LaunchError extends Error {
+    kind;
+    recovery;
+    constructor(kind, message, options) {
+        super(message, options);
+        this.name = 'LaunchError';
+        this.kind = kind;
+        this.recovery = options.recovery;
+    }
+}
+export function isLaunchError(error) {
+    if (error instanceof LaunchError) {
+        return true;
+    }
+    if (!(error instanceof Error) ||
+        error.name !== 'LaunchError' ||
+        typeof error.kind !== 'string') {
+        return false;
+    }
+    const recovery = error.recovery;
+    return (recovery !== undefined &&
+        (recovery.kind === 'exit' || recovery.kind === 'return'));
+}
+export const FATAL_LAUNCH_MESSAGES = Object.freeze({
+    gitMissing: `Git is required but was not found. Install Git, then run ${RENAME_MAP.displayName} again.`,
+    gitUnsupported: `Git 2.43.0 or newer with the required machine protocols is required. Upgrade Git, then run ${RENAME_MAP.displayName} again.`,
+    notWorktree: `This directory is not inside a Git worktree. Run ${RENAME_MAP.displayName} from a Git worktree.`,
+    bareRepository: `Bare repositories are not supported. Run ${RENAME_MAP.displayName} from a non-bare Git worktree.`,
+    emptyRepository: `This repository has no commits yet. Create the first commit, then run ${RENAME_MAP.displayName} again.`,
+});
+export const HEAD_RECOVERY = Object.freeze({
+    kind: 'return',
+    role: 'head',
+    preserve: 'base',
+    focus: 'previous-row',
+});
+export const BASE_RECOVERY = Object.freeze({
+    kind: 'return',
+    role: 'base',
+    preserve: 'head',
+    focus: 'previous-row',
+});

package/dist/domain/path-bytes.js

@@ -0,0 +1,82 @@
+const strictUtf8Decoder = new TextDecoder('utf-8', { fatal: true });
+const displayDecoder = new TextDecoder('utf-8');
+const bytesByPath = new WeakMap();
+export function encodeBase64url(bytes) {
+    let binary = '';
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary)
+        .replaceAll('+', '-')
+        .replaceAll('/', '_')
+        .replace(/=+$/, '');
+}
+export function controlSafeDisplay(value) {
+    let display = '';
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (character === '\\') {
+            display += '\\\\';
+        }
+        else if (character === '\t') {
+            display += '\\t';
+        }
+        else if (character === '\n') {
+            display += '\\n';
+        }
+        else if (character === '\r') {
+            display += '\\r';
+        }
+        else if (codePoint < 0x20 ||
+            (codePoint >= 0x7f && codePoint <= 0x9f)) {
+            display += `\\u{${codePoint.toString(16).padStart(2, '0')}}`;
+        }
+        else {
+            display += character;
+        }
+    }
+    return display;
+}
+export function createExactPath(bytes) {
+    const ownedBytes = new Uint8Array(bytes);
+    let utf8;
+    try {
+        utf8 = strictUtf8Decoder.decode(ownedBytes);
+    }
+    catch {
+        utf8 = undefined;
+    }
+    const path = Object.freeze({
+        bytesBase64url: encodeBase64url(ownedBytes),
+        display: controlSafeDisplay(displayDecoder.decode(ownedBytes)),
+        ...(utf8 === undefined ? {} : { utf8 }),
+    });
+    bytesByPath.set(path, ownedBytes);
+    return path;
+}
+export function orderByteSequences(left, right) {
+    const sharedLength = Math.min(left.length, right.length);
+    for (let index = 0; index < sharedLength; index += 1) {
+        const difference = left[index] - right[index];
+        if (difference !== 0)
+            return difference;
+    }
+    return left.length - right.length;
+}
+export function orderExactPaths(left, right) {
+    const leftBytes = bytesByPath.get(left) ?? decodeBase64url(left.bytesBase64url);
+    const rightBytes = bytesByPath.get(right) ?? decodeBase64url(right.bytesBase64url);
+    return orderByteSequences(leftBytes, rightBytes);
+}
+export function decodeBase64url(value) {
+    const base64 = value
+        .replaceAll('-', '+')
+        .replaceAll('_', '/')
+        .padEnd(Math.ceil(value.length / 4) * 4, '=');
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}

package/dist/domain/product-identity.js

@@ -0,0 +1,66 @@
+// Path traversal segments, slashes, NUL, and other ASCII control characters would
+// land directly inside file-path segments (repoStateDir) if left unvalidated.
+const UNSAFE_NAME_PATTERN = /[/\\\0-\x1f]|\.\./;
+// npm-unscoped-name-safe, which is also CSS-class-safe and directory-segment-safe.
+const SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+const ENV_PREFIX_PATTERN = /^[A-Z][A-Z0-9_]*_$/;
+const NPM_SCOPE = '@shipwithai/';
+const NPM_UNSCOPED_NAME_MAX_LENGTH = 214;
+/**
+ * Capitalizes each hyphen-separated slug segment and concatenates them. Shared by
+ * `xdgStateDirTitleCase` and `tsIdentifierPrefix` so both forms are derived by the
+ * exact same rule and can never drift into two different capitalization schemes.
+ */
+function capitalizeSlugSegments(slug) {
+    return slug
+        .split('-')
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+}
+export function deriveProductIdentity(name) {
+    if (UNSAFE_NAME_PATTERN.test(name)) {
+        throw new Error(`deriveProductIdentity: name ${JSON.stringify(name)} contains unsafe path-shaped characters ` +
+            '(slash, NUL/control character, or "..") and cannot be used to derive a slug/path');
+    }
+    const slug = name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (slug === '') {
+        throw new Error(`deriveProductIdentity: name ${JSON.stringify(name)} produces an empty slug after slugification`);
+    }
+    if (!SLUG_PATTERN.test(slug)) {
+        throw new Error(`deriveProductIdentity: derived slug ${JSON.stringify(slug)} is not npm/CSS/path-safe ` +
+            `(must match ${SLUG_PATTERN})`);
+    }
+    const npmPackage = `${NPM_SCOPE}${slug}`;
+    if (npmPackage.length > NPM_UNSCOPED_NAME_MAX_LENGTH) {
+        throw new Error(`deriveProductIdentity: npm package name ${JSON.stringify(npmPackage)} exceeds npm's ` +
+            `${NPM_UNSCOPED_NAME_MAX_LENGTH}-character unscoped-name budget`);
+    }
+    const envPrefix = `${slug.toUpperCase().replace(/-/g, '_')}_`;
+    if (!ENV_PREFIX_PATTERN.test(envPrefix)) {
+        throw new Error(`deriveProductIdentity: derived envPrefix ${JSON.stringify(envPrefix)} is not a valid env var ` +
+            `identifier (must match ${ENV_PREFIX_PATTERN})`);
+    }
+    const titleCase = capitalizeSlugSegments(slug);
+    return Object.freeze({
+        displayName: name.trim(),
+        slug,
+        npmPackage,
+        binCommand: slug,
+        repoStateDir: `.${slug}/`,
+        xdgStateDirLower: slug,
+        xdgStateDirTitleCase: titleCase,
+        kindPrefix: slug,
+        envPrefix,
+        cssPrefix: `${slug}-`,
+        tsIdentifierPrefix: titleCase,
+    });
+}
+// The display name supplied by the human at Task 1's blocking checkpoint (resolved
+// 2026-11-02): "Loopnote". Every later plan in this phase imports this constant —
+// not process.env, not a config file — so no form of the new name is re-derived or
+// hardcoded independently.
+export const RENAME_MAP = deriveProductIdentity('Loopnote');

package/dist/domain/source.js

@@ -0,0 +1,4 @@
+export const DIRTY_ROW_LABEL = 'Dirty — committed HEAD only';
+export const DIRTY_EXPLANATION = 'This worktree has uncommitted changes. This comparison reviews its committed HEAD only — use --worktree, --staged, or --unstaged to review the uncommitted changes directly.';
+export const PENDING_ROW_LABEL = 'Checking worktree state…';
+export const UNAVAILABLE_WORKTREE_REASON = 'Unavailable — this registered worktree cannot be resolved. Choose another entry or repair it with Git.';

package/dist/draft/mutate-draft.js

@@ -0,0 +1,87 @@
+import { DraftMutationSchema, ReviewDraftV1Schema, } from '../contracts/draft.js';
+export function applyDraftMutation(current, input, timestamp) {
+    const mutation = DraftMutationSchema.parse(input);
+    switch (mutation.type) {
+        case 'addComment': {
+            if (current.comments.some((comment) => comment.anchor.uniqueKey === mutation.anchor.uniqueKey)) {
+                return Object.freeze({ kind: 'invalidTarget' });
+            }
+            return Object.freeze({
+                kind: 'applied',
+                draft: ReviewDraftV1Schema.parse({
+                    ...current,
+                    comments: [
+                        ...current.comments,
+                        {
+                            id: mutation.commentId,
+                            state: 'open',
+                            body: mutation.body,
+                            anchor: mutation.anchor,
+                            createdAt: timestamp,
+                            updatedAt: timestamp,
+                        },
+                    ],
+                }),
+            });
+        }
+        case 'setSummary':
+            return Object.freeze({
+                kind: 'applied',
+                draft: ReviewDraftV1Schema.parse({ ...current, summary: mutation.markdown }),
+            });
+        default:
+            break;
+    }
+    const comment = current.comments.find((candidate) => candidate.id === mutation.commentId);
+    if (comment === undefined) {
+        return Object.freeze({ kind: 'invalidTarget' });
+    }
+    switch (mutation.type) {
+        case 'editComment':
+            return Object.freeze({
+                kind: 'applied',
+                draft: ReviewDraftV1Schema.parse({
+                    ...current,
+                    comments: current.comments.map((candidate) => candidate.id === comment.id ? { ...candidate, body: mutation.body, updatedAt: timestamp } : candidate),
+                }),
+            });
+        case 'deleteComment':
+            return Object.freeze({
+                kind: 'applied',
+                draft: ReviewDraftV1Schema.parse({
+                    ...current,
+                    comments: current.comments.filter((candidate) => candidate.id !== comment.id),
+                }),
+            });
+        case 'resolveComment':
+            if (comment.state !== 'open') {
+                return Object.freeze({ kind: 'illegalTransition' });
+            }
+            return Object.freeze({
+                kind: 'applied',
+                draft: ReviewDraftV1Schema.parse({
+                    ...current,
+                    comments: current.comments.map((candidate) => candidate.id === comment.id
+                        ? { ...candidate, state: 'resolved', updatedAt: timestamp, resolvedAt: timestamp }
+                        : candidate),
+                }),
+            });
+        case 'reopenComment':
+            if (comment.state !== 'resolved') {
+                return Object.freeze({ kind: 'illegalTransition' });
+            }
+            return Object.freeze({
+                kind: 'applied',
+                draft: ReviewDraftV1Schema.parse({
+                    ...current,
+                    comments: current.comments.map((candidate) => {
+                        if (candidate.id !== comment.id || candidate.state !== 'resolved') {
+                            return candidate;
+                        }
+                        const { resolvedAt: _resolvedAt, ...reopened } = candidate;
+                        return { ...reopened, state: 'open', updatedAt: timestamp };
+                    }),
+                }),
+            });
+    }
+}