@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/issue-triage/fix-loop/promotion-task.js

@@ -0,0 +1,108 @@
+import { performance } from 'node:perf_hooks';
+import { parseBaseContext, requiredEnv } from '../../../core/environment.js';
+import { logger } from '../../../core/logging.js';
+import { createGitHubClients } from '../../../core/shared.js';
+import { findRepositoryTarget } from '../hero-group-map.js';
+import { DefaultLoopEffects } from './effects.js';
+import { runPromotionFlow } from './runners.js';
+/**
+ * Parses the env vars dispatched by the webhook handler's
+ * promotion-ci-gate route (apps/webhook-handler/src/tasks/promotion-ci-gate/fargate.ts).
+ * Throws a descriptive error for any missing or malformed variable so the
+ * sandbox task fails fast instead of degrading mid-run.
+ */
+export function parsePromotionTaskInput() {
+    return {
+        base: parseBaseContext(),
+        headSha: requiredEnv('HEAD_SHA'),
+        dryRun: process.env.DRY_RUN?.toLowerCase() === 'true',
+    };
+}
+/**
+ * Builds the PromotionSession. Promotion is API-only (no codex / push /
+ * review), so the session carries only the fields the promotion-flow
+ * effects actually read, and cloning the repo is skipped — none of the
+ * effects reads `localPath`.
+ */
+export function buildPromotionSession({ input, octokit, }) {
+    const { owner, repo } = input.base;
+    // Use the issue-routing catalog when the target repository is supported.
+    // The review effect can then derive its configured route and hero team.
+    const repository = findRepositoryTarget(owner, repo) ?? {
+        owner,
+        repo,
+        fullName: `${owner}/${repo}`,
+        // Keep the existing Product type for an unknown target. The repository
+        // does not occur in that product's routes, so hero routing uses cx-hero.
+        product: 'Todoist',
+    };
+    return {
+        kind: 'fix-loop-promotion',
+        ctx: {
+            owner,
+            repo,
+            installationId: input.base.installationId,
+            deliveryId: input.base.deliveryId ?? 'unknown',
+            dryRun: input.dryRun,
+        },
+        octokit,
+        targetRepo: {
+            repository,
+            localPath: '',
+        },
+    };
+}
+export async function runPromotionTask(input) {
+    const startedAt = performance.now();
+    const { base, headSha, dryRun } = input;
+    const repository = `${base.owner}/${base.repo}`;
+    logger.setBaseContext({
+        delivery_id: base.deliveryId ?? 'unknown',
+        repository,
+    });
+    logger.info('Fix-loop promotion task started', {
+        task: 'fix-loop-promotion',
+        repository,
+        pr_number: base.prNumber,
+        head_sha: headSha,
+        dry_run: dryRun,
+    });
+    try {
+        const { writeOctokit } = await createGitHubClients(base);
+        const session = buildPromotionSession({ input, octokit: writeOctokit });
+        const effects = new DefaultLoopEffects(session, { dryRun });
+        const finalState = await runPromotionFlow(effects, {
+            prNumber: base.prNumber,
+            headSha,
+        });
+        logger.info('Fix-loop promotion task completed', {
+            task: 'fix-loop-promotion',
+            repository,
+            pr_number: base.prNumber,
+            terminal_state: finalState.kind,
+            duration_ms: performance.now() - startedAt,
+        });
+    }
+    catch (error) {
+        logger.error('Fix-loop promotion task failed', {
+            task: 'fix-loop-promotion',
+            repository,
+            pr_number: base.prNumber,
+            head_sha: headSha,
+            error: error instanceof Error ? error.message : String(error),
+            duration_ms: performance.now() - startedAt,
+        });
+        throw error;
+    }
+}
+export async function main() {
+    try {
+        await runPromotionTask(parsePromotionTaskInput());
+    }
+    catch {
+        process.exitCode = 1;
+    }
+}
+if (process.env.VITEST !== 'true' && process.env.TASK_TYPE === 'fix-loop-promotion') {
+    main();
+}

package/sandbox/dist/tasks/issue-triage/fix-loop/recovery.js

@@ -0,0 +1,512 @@
+import { execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { GetObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client, } from '@aws-sdk/client-s3';
+import { Ajv } from 'ajv';
+import { sentryArtifactsPrefix } from 'doistbot-issue-routing';
+import { hashAutofixInputs } from '../../../core/autofix-verification.js';
+import { gitAuthEnv, GITHUB_HTTPS_REWRITE_ARGS } from '../../../core/git-auth.js';
+import { githubHistoryIdentity } from '../../../core/github-history.js';
+import { logger } from '../../../core/logging.js';
+import { autofixCheckpointSchema, AutofixCheckpointStore, checkpointIdentity, } from '../autofix-checkpoint.js';
+import { loadAutofixPolicy } from '../autofix-policy.js';
+import { validateDiff } from '../diff-validator.js';
+import { generateBranchName, verifyCommitSignature } from '../pr-creator.js';
+import { loadRepositoryWorkflow, serializeAutofixPolicy } from '../repo-prompts.js';
+import { ISSUE_FIX_INITIAL_STATE } from './state-machine.js';
+const sha = { type: 'string', pattern: '^([a-f0-9]{40}|[a-f0-9]{64})$' };
+const branch = { type: 'string', pattern: '^doistbot/[A-Za-z0-9/_.-]+$', maxLength: 250 };
+const header = {
+    kind: { type: 'string' },
+    intent: { const: ISSUE_FIX_INITIAL_STATE.intent },
+    promotionPolicy: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['kind'],
+        properties: { kind: { const: ISSUE_FIX_INITIAL_STATE.promotionPolicy.kind } },
+    },
+    maxIterations: { const: ISSUE_FIX_INITIAL_STATE.maxIterations },
+};
+const findings = {
+    type: 'array',
+    maxItems: 1000,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['path', 'line', 'body'],
+        properties: {
+            path: { type: 'string', maxLength: 4096 },
+            line: { type: 'integer', minimum: 1 },
+            body: { type: 'string', maxLength: 100_000 },
+            severity: { enum: ['P0', 'P1', 'P2', 'P3', null] },
+        },
+    },
+};
+function stateSchema(kind, required, properties) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['kind', 'intent', 'promotionPolicy', 'maxIterations', ...required],
+        properties: { ...header, kind: { const: kind }, ...properties },
+    };
+}
+const published = {
+    branch,
+    prNumber: { type: 'integer', minimum: 1 },
+    iteration: { type: 'integer', minimum: 0, maximum: 1 },
+};
+const validateRecord = new Ajv().compile({
+    type: 'object',
+    additionalProperties: false,
+    required: [
+        'version',
+        'reportHash',
+        'policyHash',
+        'originalBase',
+        'branch',
+        'state',
+        'attempt',
+        'generated',
+        'runReport',
+        'savedAt',
+    ],
+    properties: {
+        version: { const: 2 },
+        reportHash: sha,
+        policyHash: sha,
+        originalBase: sha,
+        branch,
+        savedAt: { type: 'string' },
+        generated: {
+            anyOf: [
+                { type: 'null' },
+                {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['ok', 'codexOutput', 'generatedPRTitle', 'generatedPRBody'],
+                    properties: {
+                        ok: { const: true },
+                        diff: { type: 'string', maxLength: 5 * 1024 * 1024 },
+                        codexOutput: { type: 'string', maxLength: 2 * 1024 * 1024 },
+                        generatedPRTitle: { type: ['string', 'null'] },
+                        generatedPRBody: { type: ['string', 'null'] },
+                    },
+                },
+            ],
+        },
+        runReport: { type: ['string', 'null'], maxLength: 5 * 1024 * 1024 },
+        state: {
+            anyOf: [
+                stateSchema('AWAITING_FIRST_FIX', [], {}),
+                stateSchema('ITERATING', ['iteration', 'findings', 'prevHeadSha', 'branch', 'prNumber'], { ...published, iteration: { const: 1 }, findings, prevHeadSha: sha }),
+                stateSchema('REVIEWING', ['iteration', 'headSha', 'branch', 'prNumber'], {
+                    ...published,
+                    headSha: sha,
+                    reviewBaseSha: sha,
+                }),
+                stateSchema('PUSHED_AWAITING_CI', ['headSha', 'prNumber'], {
+                    ...published,
+                    headSha: sha,
+                }),
+                stateSchema('DONE_NEEDS_HUMAN', ['reason', 'findings'], {
+                    branch,
+                    prNumber: published.prNumber,
+                    reason: { type: 'string' },
+                    findings,
+                }),
+            ],
+        },
+        attempt: {
+            anyOf: [
+                { type: 'null' },
+                {
+                    ...autofixCheckpointSchema,
+                    properties: {
+                        ...autofixCheckpointSchema.properties,
+                        identity: sha,
+                        baseCommit: sha,
+                    },
+                },
+            ],
+        },
+    },
+});
+export class IssueFixRecovery {
+    input;
+    directory = path.join(tmpdir(), 'doistbot-fix-loop', randomUUID());
+    s3;
+    key;
+    policy;
+    policyIdentity;
+    record;
+    etag;
+    shared = false;
+    publishedHead;
+    existingPR;
+    constructor(input) {
+        this.input = input;
+        mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+        this.s3 = input.bucket ? new S3Client({ maxAttempts: 2 }) : undefined;
+        this.policy = loadAutofixPolicy(input.targetRepo.localPath);
+        this.policyIdentity = serializeAutofixPolicy(this.policy, loadRepositoryWorkflow(input.targetRepo.localPath, 'autofix'));
+        const identity = hashAutofixInputs(`${githubHistoryIdentity(input.issueUrl)}\n${githubHistoryIdentity(input.targetRepo.repository.fullName)}`);
+        const prefix = input.sentryIssue ? sentryArtifactsPrefix(input.sentryIssue) : 'autofix/';
+        this.key = `${prefix}workflow-${identity}/checkpoint.json`;
+        this.record = {
+            version: 2,
+            reportHash: hashAutofixInputs(input.triageOutput.trim()),
+            policyHash: hashAutofixInputs(this.policyIdentity),
+            originalBase: this.git(['rev-parse', 'HEAD']),
+            branch: generateBranchName(input),
+            state: ISSUE_FIX_INITIAL_STATE,
+            attempt: null,
+            generated: null,
+            runReport: null,
+            savedAt: new Date().toISOString(),
+        };
+    }
+    get state() {
+        return this.record.state;
+    }
+    get publicationBranch() {
+        return this.record.branch;
+    }
+    get checkpoint() {
+        return this.record.attempt ?? undefined;
+    }
+    get originalBase() {
+        return this.record.originalBase;
+    }
+    get generated() {
+        return this.record.generated && this.record.attempt
+            ? { ...this.record.generated, diff: this.record.attempt.patch }
+            : undefined;
+    }
+    git(args, input) {
+        return execFileSync('git', args, {
+            cwd: this.input.targetRepo.localPath,
+            encoding: 'utf8',
+            stdio: 'pipe',
+            input,
+            timeout: 120_000,
+            maxBuffer: 5 * 1024 * 1024,
+            env: gitAuthEnv(this.input.githubToken),
+        }).trim();
+    }
+    checkpointIdentity(baseCommit) {
+        return checkpointIdentity({
+            issueUrl: this.input.issueUrl,
+            repository: this.input.targetRepo.repository.fullName,
+            baseCommit,
+            triageOutput: this.input.triageOutput,
+            policy: this.policyIdentity,
+        });
+    }
+    async findSavedPR(data) {
+        const { owner, repo } = this.input.targetRepo.repository;
+        const prs = await this.input.octokit.rest.pulls.list({
+            owner,
+            repo,
+            head: `${owner}:${data.branch}`,
+            state: 'all',
+            per_page: 100,
+        });
+        return prs.data.find((item) => item.head.ref === data.branch &&
+            // PR descriptions written before the rename still contain the old URL.
+            item.body
+                ?.replaceAll('https://github.com/todoist/', 'https://github.com/Doist/')
+                .includes(githubHistoryIdentity(this.input.issueUrl)));
+    }
+    ensureCommit(commit) {
+        try {
+            this.git(['cat-file', '-e', `${commit}^{commit}`]);
+        }
+        catch {
+            this.git(['fetch', '--depth=1', 'origin', commit]);
+        }
+    }
+    async prepare(retry) {
+        if (!this.s3 || !this.input.bucket)
+            return undefined;
+        let object;
+        try {
+            if (this.input.sentryIssue) {
+                // A missing key returns 403 with our prefix-scoped ListBucket grant.
+                const listed = await this.s3.send(new ListObjectsV2Command({
+                    Bucket: this.input.bucket,
+                    Prefix: this.key,
+                    MaxKeys: 1,
+                }), { abortSignal: AbortSignal.timeout(15_000) });
+                if (!listed.Contents?.some((object) => object.Key === this.key)) {
+                    if (retry)
+                        throw new Error('Saved Sentry fix checkpoint is missing');
+                    return undefined;
+                }
+            }
+            object = await this.s3.send(new GetObjectCommand({ Bucket: this.input.bucket, Key: this.key }), { abortSignal: AbortSignal.timeout(15_000) });
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !['NoSuchKey', 'NotFound'].includes(error.name))
+                throw error;
+            // Expiry can race a retry after its report was loaded. Never reset PR identity.
+            if (this.input.sentryIssue && retry)
+                throw error;
+            if (retry && !this.input.sentryIssue) {
+                this.record.attempt = await new AutofixCheckpointStore(this.checkpointIdentity(this.record.originalBase), this.input.bucket, path.join(this.directory, 'legacy')).load();
+            }
+            return undefined;
+        }
+        if (!object.Body || (object.ContentLength ?? 0) > 10 * 1024 * 1024)
+            throw new Error('Invalid saved fix size');
+        const data = JSON.parse(await object.Body.transformToString());
+        if (!validateRecord(data))
+            throw new Error('Invalid saved fix state');
+        this.etag = object.ETag;
+        this.existingPR = 'prNumber' in data.state ? data.state.prNumber : undefined;
+        if ('branch' in data.state &&
+            data.state.branch !== undefined &&
+            data.state.branch !== data.branch)
+            throw new Error('Saved branch does not match the loop step');
+        if (data.reportHash !== this.record.reportHash ||
+            data.policyHash !== this.record.policyHash) {
+            if (data.reportHash !== this.record.reportHash ||
+                data.state.kind === 'DONE_NEEDS_HUMAN') {
+                const pr = await this.findSavedPR(data);
+                if (pr?.state === 'open' && !pr.merged_at) {
+                    this.existingPR = pr.number;
+                    throw new Error(`The saved fix has a different report, check policy, or workflow prompt. Close PR #${pr.number} before starting a new fix. The previous work is kept.`);
+                }
+                if (this.existingPR !== undefined && !pr)
+                    throw new Error('The saved fix PR could not be found. The previous work is kept.');
+                this.existingPR = undefined;
+                return undefined;
+            }
+            throw new Error('The saved fix has a different report, check policy, or workflow prompt. It cannot be resumed.');
+        }
+        if (data.state.kind === 'DONE_NEEDS_HUMAN' && data.state.prNumber === undefined)
+            return undefined;
+        if (data.generated) {
+            if (!data.attempt)
+                throw new Error('Saved model output has no patch');
+            if ('diff' in data.generated &&
+                typeof data.generated.diff === 'string' &&
+                data.generated.diff.trim() !== data.attempt.patch.trim())
+                throw new Error('Saved model output does not match the patch');
+            const { ok, codexOutput, generatedPRTitle, generatedPRBody } = data.generated;
+            data.generated = { ok, codexOutput, generatedPRTitle, generatedPRBody };
+        }
+        this.record = data;
+        const state = data.state;
+        if (state.kind === 'DONE_NEEDS_HUMAN')
+            return state;
+        const pr = await this.findSavedPR(data);
+        if (pr) {
+            this.existingPR = pr.number;
+            if (pr.state !== 'open' || pr.merged_at)
+                throw new Error(`Saved PR #${pr.number} is closed. The fix cannot be resumed.`);
+            const expected = state.kind === 'ITERATING'
+                ? state.prevHeadSha
+                : 'headSha' in state
+                    ? state.headSha
+                    : undefined;
+            const generated = this.generated;
+            const pushedBeforeSave = expected !== pr.head.sha &&
+                generated !== undefined &&
+                (state.kind === 'ITERATING' || state.kind === 'AWAITING_FIRST_FIX');
+            if (expected && pr.head.sha !== expected && !pushedBeforeSave)
+                throw new Error(`Saved PR #${pr.number} has changed. The fix cannot be resumed.`);
+            if ('prNumber' in state && state.prNumber !== pr.number)
+                throw new Error('Saved PR identity does not match');
+            this.git(['fetch', '--depth=1', 'origin', data.branch]);
+            if (this.git(['rev-parse', 'FETCH_HEAD']) !== pr.head.sha)
+                throw new Error('The remote fix branch changed during restore');
+            await verifyCommitSignature({
+                octokit: this.input.octokit,
+                repoOwner: this.input.targetRepo.repository.owner,
+                repoName: this.input.targetRepo.repository.repo,
+                headSha: pr.head.sha,
+            });
+            this.ensureCommit(data.originalBase);
+            const reviewBase = state.kind === 'ITERATING'
+                ? state.prevHeadSha
+                : state.kind === 'REVIEWING'
+                    ? (state.reviewBaseSha ?? data.originalBase)
+                    : data.originalBase;
+            this.ensureCommit(reviewBase);
+            if (pushedBeforeSave && generated) {
+                if (this.git([
+                    'diff',
+                    '--no-ext-diff',
+                    '--no-textconv',
+                    '--full-index',
+                    '--binary',
+                    reviewBase,
+                    pr.head.sha,
+                ]) !== generated.diff.trim())
+                    throw new Error('The published patch does not match the saved fix');
+            }
+            if (pushedBeforeSave || state.kind === 'AWAITING_FIRST_FIX') {
+                this.record.state = {
+                    ...ISSUE_FIX_INITIAL_STATE,
+                    kind: 'REVIEWING',
+                    iteration: state.kind === 'ITERATING' ? state.iteration : 0,
+                    branch: data.branch,
+                    prNumber: pr.number,
+                    headSha: pr.head.sha,
+                    reviewBaseSha: reviewBase,
+                };
+                this.record.attempt = null;
+                this.record.generated = null;
+            }
+            this.git(['checkout', '-B', data.branch, pr.head.sha]);
+        }
+        else if (state.kind !== 'AWAITING_FIRST_FIX') {
+            throw new Error('The saved fix PR could not be found. The fix cannot be resumed.');
+        }
+        else {
+            this.ensureCommit(data.originalBase);
+            this.git(['checkout', '--detach', data.originalBase]);
+        }
+        if (!pr && this.generated) {
+            const generated = this.generated;
+            const remote = this.git(['ls-remote', '--heads', 'origin', data.branch]);
+            if (remote) {
+                this.git(['fetch', '--depth=1', 'origin', data.branch]);
+                this.publishedHead = this.git(['rev-parse', 'FETCH_HEAD']);
+                await verifyCommitSignature({
+                    octokit: this.input.octokit,
+                    repoOwner: this.input.targetRepo.repository.owner,
+                    repoName: this.input.targetRepo.repository.repo,
+                    headSha: this.publishedHead,
+                });
+                if (this.git([
+                    'diff',
+                    '--no-ext-diff',
+                    '--no-textconv',
+                    '--full-index',
+                    '--binary',
+                    data.originalBase,
+                    this.publishedHead,
+                ]) !== generated.diff.trim()) {
+                    throw new Error('The published patch does not match the saved fix');
+                }
+                this.git(['checkout', '-B', data.branch, this.publishedHead]);
+            }
+        }
+        if (!pr) {
+            this.git(['submodule', 'sync', '--recursive']);
+            this.git([
+                ...GITHUB_HTTPS_REWRITE_ARGS,
+                'submodule',
+                'update',
+                '--init',
+                '--recursive',
+                '--depth=1',
+            ]);
+        }
+        const policy = loadAutofixPolicy(this.input.targetRepo.localPath);
+        const policyIdentity = serializeAutofixPolicy(policy, loadRepositoryWorkflow(this.input.targetRepo.localPath, 'autofix'));
+        if (hashAutofixInputs(policyIdentity) !== data.policyHash)
+            throw new Error('The check policy or workflow prompt on the saved branch has changed');
+        if (this.record.attempt) {
+            const expectedBase = this.record.state.kind === 'ITERATING'
+                ? this.record.state.prevHeadSha
+                : data.originalBase;
+            const expectedIdentity = this.checkpointIdentity(expectedBase);
+            if (this.record.attempt.identity !== expectedIdentity)
+                throw new Error('Saved patch inputs do not match');
+            if (this.record.attempt.baseCommit !== expectedBase)
+                throw new Error('Saved patch base does not match the loop step');
+            const validation = validateDiff(this.record.attempt.patch, {
+                forbiddenTestPaths: policy.forbidden_test_paths,
+            });
+            if (this.record.attempt.patch && !validation.valid)
+                throw new Error('Saved patch does not meet the current fix rules');
+            if (this.record.generated) {
+                if (!this.publishedHead) {
+                    this.git(['reset', '--hard', expectedBase]);
+                    this.git(['clean', '-fd']);
+                    this.git(['apply', '--index', '--whitespace=nowarn', '-'], this.record.attempt.patch);
+                }
+            }
+        }
+        this.shared = true;
+        return this.record.state;
+    }
+    async beforeStep(state) {
+        if (this.record.state.kind !== state.kind ||
+            state.kind === 'REVIEWING' ||
+            state.kind === 'PUSHED_AWAITING_CI') {
+            this.record.attempt = null;
+            this.record.generated = null;
+            this.record.runReport = null;
+        }
+        this.record.state = state;
+        if (state.kind === 'REVIEWING' && state.reviewBaseSha === undefined)
+            this.record.state = { ...state, reviewBaseSha: this.record.originalBase };
+        await this.save();
+    }
+    async saveGenerated(result) {
+        const { ok, codexOutput, generatedPRTitle, generatedPRBody } = result;
+        this.record.generated = { ok, codexOutput, generatedPRTitle, generatedPRBody };
+        await this.save();
+    }
+    async saveAttempt(checkpoint, report) {
+        this.record.attempt = checkpoint;
+        this.record.runReport = report;
+        try {
+            writeFileSync(path.join(this.directory, 'run.json'), report, { mode: 0o600 });
+        }
+        catch (error) {
+            logger.error('Could not save fix run data', { error: String(error) });
+        }
+        const canResume = checkpoint.status !== 'failed' &&
+            (!checkpoint.patch ||
+                validateDiff(checkpoint.patch, {
+                    forbiddenTestPaths: this.policy.forbidden_test_paths,
+                }).valid);
+        return this.save(canResume);
+    }
+    async save(publish = true) {
+        this.record.savedAt = new Date().toISOString();
+        const body = JSON.stringify(this.record);
+        this.shared = false;
+        try {
+            writeFileSync(path.join(this.directory, 'checkpoint.json'), body, { mode: 0o600 });
+            if (!validateRecord(this.record) || Buffer.byteLength(body) > 10 * 1024 * 1024) {
+                logger.error('Fix loop state cannot be restored', { errors: validateRecord.errors });
+                return false;
+            }
+            if (!this.s3 || !this.input.bucket)
+                return false;
+            await this.s3.send(new PutObjectCommand({
+                Bucket: this.input.bucket,
+                Key: `${path.dirname(this.key)}/runs/${path.basename(this.directory)}/${randomUUID()}.json`,
+                Body: body,
+                ContentType: 'application/json',
+            }), { abortSignal: AbortSignal.timeout(15_000) });
+            if (!publish)
+                return false;
+            const result = await this.s3.send(new PutObjectCommand({
+                Bucket: this.input.bucket,
+                Key: this.key,
+                Body: body,
+                ContentType: 'application/json',
+                ...(this.etag ? { IfMatch: this.etag } : { IfNoneMatch: '*' }),
+            }), { abortSignal: AbortSignal.timeout(15_000) });
+            this.etag = result.ETag;
+            this.shared = true;
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'PreconditionFailed')
+                throw new Error('Another fix task changed the saved work. This task stopped to keep that work.');
+            logger.error('Could not save fix loop in shared storage', {
+                directory: this.directory,
+                error: String(error),
+            });
+        }
+        return this.shared;
+    }
+}