@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/server/loop-service.js

@@ -0,0 +1,837 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { writeJsonFileAtomic } from "./atomic-file.js";
+import { curateAgentActivity } from "./agent/activity-curator.js";
+import { formatProviderModel, } from "./agent/create-agent/create.js";
+import { buildStructuredAgentResponsePrompt, getStructuredAgentResponse, } from "./agent/agent-response-loop.js";
+import { buildStringCommandShellInvocation, createStringCommandShellEnvOverlay, } from "../utils/string-command-shell.js";
+import { execCommand } from "../utils/spawn.js";
+const LOOP_ID_LENGTH = 8;
+const DEFAULT_LOOP_PROVIDER = "claude";
+const MAX_VERIFY_OUTPUT_BYTES = 64 * 1024;
+const LoopVerifyPromptSchema = z.object({
+    passed: z.boolean(),
+    reason: z.string().min(1),
+});
+const LoopLogEntrySchema = z.object({
+    seq: z.number().int().positive(),
+    timestamp: z.string(),
+    iteration: z.number().int().positive().nullable(),
+    source: z.enum(["loop", "worker", "verifier", "verify-check"]),
+    level: z.enum(["info", "error"]),
+    text: z.string(),
+});
+const LoopVerifyCheckResultSchema = z.object({
+    command: z.string(),
+    exitCode: z.number().int(),
+    passed: z.boolean(),
+    stdout: z.string(),
+    stderr: z.string(),
+    startedAt: z.string(),
+    completedAt: z.string(),
+});
+const LoopVerifyPromptResultSchema = z.object({
+    passed: z.boolean(),
+    reason: z.string(),
+    verifierAgentId: z.string().nullable(),
+    startedAt: z.string(),
+    completedAt: z.string(),
+});
+const LoopIterationRecordSchema = z.object({
+    index: z.number().int().positive(),
+    workerAgentId: z.string().nullable(),
+    workerStartedAt: z.string(),
+    workerCompletedAt: z.string().nullable(),
+    verifierAgentId: z.string().nullable(),
+    status: z.enum(["running", "succeeded", "failed", "stopped"]),
+    workerOutcome: z.enum(["completed", "failed", "canceled"]).nullable(),
+    failureReason: z.string().nullable(),
+    verifyChecks: z.array(LoopVerifyCheckResultSchema),
+    verifyPrompt: LoopVerifyPromptResultSchema.nullable(),
+});
+const LoopRecordSchema = z.object({
+    id: z.string(),
+    name: z.string().nullable(),
+    prompt: z.string(),
+    cwd: z.string(),
+    provider: z.string(),
+    model: z.string().nullable(),
+    modeId: z.string().nullable().default(null),
+    workerProvider: z.string().nullable(),
+    workerModel: z.string().nullable(),
+    verifierProvider: z.string().nullable(),
+    verifierModel: z.string().nullable(),
+    verifierModeId: z.string().nullable().default(null),
+    verifyPrompt: z.string().nullable(),
+    verifyChecks: z.array(z.string()),
+    archive: z.boolean(),
+    sleepMs: z.number().int().nonnegative(),
+    maxIterations: z.number().int().positive().nullable(),
+    maxTimeMs: z.number().int().positive().nullable(),
+    status: z.enum(["running", "succeeded", "failed", "stopped"]),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    startedAt: z.string(),
+    completedAt: z.string().nullable(),
+    stopRequestedAt: z.string().nullable(),
+    iterations: z.array(LoopIterationRecordSchema),
+    logs: z.array(LoopLogEntrySchema),
+    nextLogSeq: z.number().int().positive(),
+    activeIteration: z.number().int().positive().nullable(),
+    activeWorkerAgentId: z.string().nullable(),
+    activeVerifierAgentId: z.string().nullable(),
+});
+const StoredLoopsSchema = z.array(LoopRecordSchema);
+function nowIso() {
+    return new Date().toISOString();
+}
+function cloneLoop(record) {
+    return LoopRecordSchema.parse(record);
+}
+function createLoopId() {
+    return randomUUID().replace(/-/g, "").slice(0, LOOP_ID_LENGTH);
+}
+function normalizeName(name) {
+    const trimmed = name?.trim();
+    return trimmed ? trimmed : null;
+}
+function normalizePrompt(value, field) {
+    if (value === undefined) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error(`${field} cannot be empty`);
+    }
+    return trimmed;
+}
+function ensurePositiveInteger(value, field) {
+    if (value === undefined) {
+        return null;
+    }
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`${field} must be a positive integer`);
+    }
+    return value;
+}
+function ensureNonNegativeInteger(value, field) {
+    if (value === undefined) {
+        return 0;
+    }
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${field} must be a non-negative integer`);
+    }
+    return value;
+}
+async function assertLoopCwdDirectory(cwd) {
+    let stats;
+    try {
+        stats = await fs.stat(cwd);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`Working directory ${cwd} no longer exists`, { cause: error });
+        }
+        throw error;
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`Working directory ${cwd} is not a directory`);
+    }
+}
+function buildWorkerTitle(loop, iterationIndex) {
+    const prefix = loop.name ?? loop.id;
+    return `${prefix} [loop ${iterationIndex} worker]`;
+}
+function buildVerifierTitle(loop, iterationIndex) {
+    const prefix = loop.name ?? loop.id;
+    return `${prefix} [loop ${iterationIndex} verifier]`;
+}
+function isUnknownLoopAgentError(error, agentId) {
+    return error instanceof Error && error.message === `Unknown agent '${agentId}'`;
+}
+function formatStreamLog(event) {
+    switch (event.type) {
+        case "timeline": {
+            const rendered = curateAgentActivity([event.item]);
+            return rendered === "No activity to display." ? null : rendered;
+        }
+        case "turn_failed":
+            return `[Turn Failed] ${event.error}`;
+        case "turn_canceled":
+            return `[Turn Canceled] ${event.reason}`;
+        case "permission_requested":
+            return `[Permission Requested] ${event.request.name}`;
+        case "permission_resolved":
+            return `[Permission Resolved] ${event.requestId}`;
+        default:
+            return null;
+    }
+}
+async function sleepWithAbort(ms, signal) {
+    if (ms <= 0) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            cleanup();
+            reject(signal.reason instanceof Error ? signal.reason : new Error("Loop aborted"));
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", onAbort);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function isAbortError(error) {
+    if (error instanceof Error && error.message === "Loop aborted") {
+        return true;
+    }
+    return false;
+}
+async function runVerifyCheck(options) {
+    const startedAt = nowIso();
+    try {
+        const shell = buildStringCommandShellInvocation({
+            command: options.command,
+            windowsShell: "cmd",
+        });
+        const result = await execCommand(shell.shell, shell.args, {
+            cwd: options.cwd,
+            envOverlay: createStringCommandShellEnvOverlay(),
+            maxBuffer: MAX_VERIFY_OUTPUT_BYTES,
+            shell: false,
+        });
+        return {
+            command: options.command,
+            exitCode: 0,
+            passed: true,
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? "",
+            startedAt,
+            completedAt: nowIso(),
+        };
+    }
+    catch (error) {
+        const childError = error;
+        return {
+            command: options.command,
+            exitCode: typeof childError.code === "number" ? childError.code : 1,
+            passed: false,
+            stdout: childError.stdout ?? "",
+            stderr: childError.stderr ?? "",
+            startedAt,
+            completedAt: nowIso(),
+        };
+    }
+}
+export class LoopService {
+    constructor(options) {
+        this.options = options;
+        this.loaded = false;
+        this.loops = new Map();
+        this.persistQueue = Promise.resolve();
+        this.running = new Map();
+        this.storePath = path.join(options.byspaceHome, "loops", "loops.json");
+        this.logger = options.logger.child({ module: "loop-service" });
+    }
+    async initialize() {
+        if (this.loaded) {
+            return;
+        }
+        this.loops.clear();
+        try {
+            const raw = await fs.readFile(this.storePath, "utf8");
+            const parsed = StoredLoopsSchema.parse(JSON.parse(raw));
+            for (const record of parsed) {
+                if (record.status === "running") {
+                    const recovered = cloneLoop(record);
+                    recovered.status = "stopped";
+                    recovered.updatedAt = nowIso();
+                    recovered.completedAt = recovered.updatedAt;
+                    recovered.stopRequestedAt = recovered.updatedAt;
+                    recovered.activeIteration = null;
+                    recovered.activeWorkerAgentId = null;
+                    recovered.activeVerifierAgentId = null;
+                    this.appendLog(recovered, {
+                        iteration: null,
+                        source: "loop",
+                        level: "error",
+                        text: "Loop was interrupted by daemon restart.",
+                    });
+                    const lastIteration = recovered.iterations.at(-1);
+                    if (lastIteration && lastIteration.status === "running") {
+                        lastIteration.status = "stopped";
+                        lastIteration.failureReason = "Daemon restarted";
+                        lastIteration.workerCompletedAt = recovered.updatedAt;
+                    }
+                    this.loops.set(recovered.id, recovered);
+                    continue;
+                }
+                this.loops.set(record.id, record);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT") {
+                this.logger.error({ err: error, storePath: this.storePath }, "Failed to load loops");
+            }
+        }
+        this.loaded = true;
+        await this.persist();
+    }
+    async runLoop(input) {
+        await this.initialize();
+        const prompt = normalizePrompt(input.prompt, "prompt");
+        if (!prompt) {
+            throw new Error("prompt cannot be empty");
+        }
+        const verifyPrompt = normalizePrompt(input.verifyPrompt, "verifyPrompt");
+        const verifyChecks = (input.verifyChecks ?? []).map((command) => {
+            const trimmed = command.trim();
+            if (!trimmed) {
+                throw new Error("verifyChecks cannot contain empty commands");
+            }
+            return trimmed;
+        });
+        if (!verifyPrompt && verifyChecks.length === 0) {
+            throw new Error("Loop requires --verify or at least one --verify-check");
+        }
+        const cwd = path.resolve(input.cwd);
+        await assertLoopCwdDirectory(cwd);
+        const createdAt = nowIso();
+        const record = LoopRecordSchema.parse({
+            id: createLoopId(),
+            name: normalizeName(input.name),
+            prompt,
+            cwd,
+            provider: input.provider ?? DEFAULT_LOOP_PROVIDER,
+            model: normalizePrompt(input.model, "model"),
+            modeId: normalizePrompt(input.modeId, "modeId"),
+            workerProvider: input.workerProvider ?? null,
+            workerModel: normalizePrompt(input.workerModel, "workerModel"),
+            verifierProvider: input.verifierProvider ?? null,
+            verifierModel: normalizePrompt(input.verifierModel, "verifierModel"),
+            verifierModeId: normalizePrompt(input.verifierModeId, "verifierModeId"),
+            verifyPrompt,
+            verifyChecks,
+            archive: input.archive ?? false,
+            sleepMs: ensureNonNegativeInteger(input.sleepMs, "sleepMs"),
+            maxIterations: ensurePositiveInteger(input.maxIterations, "maxIterations"),
+            maxTimeMs: ensurePositiveInteger(input.maxTimeMs, "maxTimeMs"),
+            status: "running",
+            createdAt,
+            updatedAt: createdAt,
+            startedAt: createdAt,
+            completedAt: null,
+            stopRequestedAt: null,
+            iterations: [],
+            logs: [],
+            nextLogSeq: 1,
+            activeIteration: null,
+            activeWorkerAgentId: null,
+            activeVerifierAgentId: null,
+        });
+        this.loops.set(record.id, record);
+        this.appendLog(record, {
+            iteration: null,
+            source: "loop",
+            level: "info",
+            text: `Loop created in ${record.cwd}`,
+        });
+        await this.persist();
+        const abortController = new AbortController();
+        const promise = this.executeLoop(record.id, abortController.signal).finally(() => {
+            this.running.delete(record.id);
+        });
+        this.running.set(record.id, { abortController, promise });
+        return cloneLoop(record);
+    }
+    async listLoops() {
+        await this.initialize();
+        return Array.from(this.loops.values())
+            .sort((left, right) => right.createdAt.localeCompare(left.createdAt))
+            .map((record) => ({
+            id: record.id,
+            name: record.name,
+            status: record.status,
+            cwd: record.cwd,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+            activeIteration: record.activeIteration,
+        }));
+    }
+    async inspectLoop(idOrPrefix) {
+        await this.initialize();
+        const loop = this.requireLoop(idOrPrefix);
+        return cloneLoop(loop);
+    }
+    async getLoopLogs(idOrPrefix, afterSeq = 0) {
+        await this.initialize();
+        const loop = this.requireLoop(idOrPrefix);
+        const entries = loop.logs.filter((entry) => entry.seq > afterSeq);
+        return {
+            loop: cloneLoop(loop),
+            entries: entries.map((entry) => LoopLogEntrySchema.parse(entry)),
+            nextCursor: loop.nextLogSeq - 1,
+        };
+    }
+    async stopLoop(idOrPrefix) {
+        await this.initialize();
+        const loop = this.requireLoop(idOrPrefix);
+        if (loop.status !== "running") {
+            return cloneLoop(loop);
+        }
+        const running = this.running.get(loop.id);
+        loop.stopRequestedAt = loop.stopRequestedAt ?? nowIso();
+        loop.updatedAt = loop.stopRequestedAt;
+        this.appendLog(loop, {
+            iteration: loop.activeIteration,
+            source: "loop",
+            level: "info",
+            text: "Stop requested.",
+        });
+        if (running) {
+            running.abortController.abort(new Error("Loop aborted"));
+        }
+        await this.persist();
+        if (running) {
+            if (loop.activeWorkerAgentId) {
+                await this.stopInternalAgent(loop.activeWorkerAgentId, loop.archive);
+            }
+            if (loop.activeVerifierAgentId) {
+                await this.stopInternalAgent(loop.activeVerifierAgentId, loop.archive);
+            }
+            await running.promise.catch(() => { });
+        }
+        else {
+            loop.status = "stopped";
+            loop.completedAt = nowIso();
+            loop.updatedAt = loop.completedAt;
+            await this.persist();
+        }
+        return cloneLoop(loop);
+    }
+    async stopInternalAgent(agentId, archive) {
+        let cancellation;
+        try {
+            cancellation = await this.options.agentManager.cancelAgentRun(agentId);
+        }
+        catch (error) {
+            if (isUnknownLoopAgentError(error, agentId)) {
+                return;
+            }
+            throw error;
+        }
+        if (cancellation.status !== "refused") {
+            return;
+        }
+        if (!this.options.agentManager.getAgent(agentId)) {
+            return;
+        }
+        try {
+            if (archive) {
+                await this.options.agentManager.archiveAgent(agentId);
+                return;
+            }
+            await this.options.agentManager.closeAgent(agentId);
+        }
+        catch (error) {
+            if (!isUnknownLoopAgentError(error, agentId)) {
+                throw error;
+            }
+        }
+    }
+    async executeLoop(loopId, signal) {
+        const loop = this.requireLoop(loopId);
+        const deadline = loop.maxTimeMs ? Date.now() + loop.maxTimeMs : null;
+        const workspaceId = this.options.ensureWorkspaceForCreate(loop.cwd, { prompt: loop.prompt });
+        workspaceId.catch(() => { });
+        const context = {
+            workspaceId,
+        };
+        try {
+            for (let index = 1;; index += 1) {
+                if (signal.aborted) {
+                    throw new Error("Loop aborted");
+                }
+                if (loop.maxIterations && index > loop.maxIterations) {
+                    this.finishLoop(loop, "failed", `Reached max iterations (${loop.maxIterations}).`);
+                    return;
+                }
+                if (deadline !== null && Date.now() > deadline) {
+                    this.finishLoop(loop, "failed", `Reached max time (${loop.maxTimeMs}ms).`);
+                    return;
+                }
+                const iteration = LoopIterationRecordSchema.parse({
+                    index,
+                    workerAgentId: null,
+                    workerStartedAt: nowIso(),
+                    workerCompletedAt: null,
+                    verifierAgentId: null,
+                    status: "running",
+                    workerOutcome: null,
+                    failureReason: null,
+                    verifyChecks: [],
+                    verifyPrompt: null,
+                });
+                loop.iterations.push(iteration);
+                loop.activeIteration = index;
+                loop.updatedAt = nowIso();
+                this.appendLog(loop, {
+                    iteration: index,
+                    source: "loop",
+                    level: "info",
+                    text: `Starting iteration ${index}.`,
+                });
+                await this.persist();
+                const workerPassed = await this.runWorkerIteration(loop, iteration, signal, context);
+                if (signal.aborted) {
+                    throw new Error("Loop aborted");
+                }
+                if (!workerPassed) {
+                    iteration.status = iteration.status === "stopped" ? "stopped" : "failed";
+                }
+                else {
+                    const verificationPassed = await this.runVerification(loop, iteration, signal, context);
+                    if (verificationPassed) {
+                        iteration.status = "succeeded";
+                        this.finishLoop(loop, "succeeded", `Iteration ${index} passed verification.`);
+                        return;
+                    }
+                    if (iteration.status === "running") {
+                        iteration.status = "failed";
+                    }
+                }
+                loop.activeIteration = null;
+                loop.activeWorkerAgentId = null;
+                loop.activeVerifierAgentId = null;
+                loop.updatedAt = nowIso();
+                await this.persist();
+                if (loop.sleepMs > 0) {
+                    this.appendLog(loop, {
+                        iteration: index,
+                        source: "loop",
+                        level: "info",
+                        text: `Sleeping ${loop.sleepMs}ms before next iteration.`,
+                    });
+                    await this.persist();
+                    await sleepWithAbort(loop.sleepMs, signal);
+                }
+            }
+        }
+        catch (error) {
+            await this.handleExecuteLoopError(loop, loopId, error);
+        }
+    }
+    async handleExecuteLoopError(loop, loopId, error) {
+        const iteration = loop.activeIteration
+            ? loop.iterations.find((candidate) => candidate.index === loop.activeIteration)
+            : null;
+        if (isAbortError(error)) {
+            this.finishLoop(loop, "stopped", "Loop stopped.");
+            if (iteration && iteration.status === "running") {
+                iteration.status = "stopped";
+                iteration.failureReason = "Loop stopped";
+                iteration.workerCompletedAt = nowIso();
+            }
+            await this.persist();
+            return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error({ err: error, loopId }, "Loop execution failed");
+        this.finishLoop(loop, "failed", message);
+        if (iteration && iteration.status === "running") {
+            iteration.status = "failed";
+            iteration.failureReason = message;
+            iteration.workerCompletedAt = nowIso();
+        }
+        await this.persist();
+    }
+    async runWorkerIteration(loop, iteration, signal, context) {
+        const workspaceId = await context.workspaceId;
+        if (signal.aborted) {
+            throw new Error("Loop aborted");
+        }
+        const created = await this.options.createAgent({
+            kind: "mcp",
+            provider: this.formatWorkerProviderModel(loop),
+            cwd: loop.cwd,
+            workspaceId,
+            title: buildWorkerTitle(loop, iteration.index),
+            mode: loop.modeId ?? undefined,
+            unattended: true,
+            promptFailure: "return-error",
+            background: true,
+            notifyOnFinish: false,
+            internal: true,
+        });
+        const agent = created.snapshot;
+        iteration.workerAgentId = agent.id;
+        loop.activeWorkerAgentId = agent.id;
+        loop.updatedAt = nowIso();
+        await this.persist();
+        let workerCanceledReason = null;
+        const unsubscribe = this.options.agentManager.subscribe((event) => {
+            if (event.type !== "agent_stream") {
+                return;
+            }
+            if (event.event.type === "turn_canceled") {
+                workerCanceledReason = event.event.reason;
+            }
+            const text = formatStreamLog(event.event);
+            if (!text) {
+                return;
+            }
+            this.appendLog(loop, {
+                iteration: iteration.index,
+                source: "worker",
+                level: event.event.type === "turn_failed" ? "error" : "info",
+                text,
+            });
+            void this.persist();
+        }, { agentId: agent.id, replayState: false });
+        try {
+            const result = await this.options.agentManager.runAgent(agent.id, this.toPrompt(loop.prompt));
+            iteration.workerCompletedAt = nowIso();
+            iteration.workerOutcome = "completed";
+            if (result.canceled || workerCanceledReason) {
+                throw new Error(`Loop worker ${agent.id} was canceled: ${workerCanceledReason}`);
+            }
+            return true;
+        }
+        catch (error) {
+            iteration.workerCompletedAt = nowIso();
+            iteration.workerOutcome = "failed";
+            iteration.failureReason = error instanceof Error ? error.message : String(error);
+            this.appendLog(loop, {
+                iteration: iteration.index,
+                source: "loop",
+                level: "error",
+                text: `Worker failed: ${iteration.failureReason}`,
+            });
+            return false;
+        }
+        finally {
+            unsubscribe();
+            loop.activeWorkerAgentId = null;
+            loop.updatedAt = nowIso();
+            await this.persist();
+            try {
+                if (loop.archive) {
+                    await this.options.agentManager.archiveAgent(agent.id);
+                }
+                else {
+                    await this.options.agentManager.closeAgent(agent.id);
+                }
+            }
+            catch {
+                // Ignore cleanup errors for internal loop workers.
+            }
+            if (signal.aborted && iteration.status === "running") {
+                iteration.status = "stopped";
+            }
+        }
+    }
+    async runVerification(loop, iteration, signal, context) {
+        for (const command of loop.verifyChecks) {
+            if (signal.aborted) {
+                throw new Error("Loop aborted");
+            }
+            this.appendLog(loop, {
+                iteration: iteration.index,
+                source: "verify-check",
+                level: "info",
+                text: `$ ${command}`,
+            });
+            const result = await runVerifyCheck({ cwd: loop.cwd, command });
+            iteration.verifyChecks.push(result);
+            const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
+            this.appendLog(loop, {
+                iteration: iteration.index,
+                source: "verify-check",
+                level: result.passed ? "info" : "error",
+                text: output ? `exit ${result.exitCode}\n${output}` : `exit ${result.exitCode}`,
+            });
+            loop.updatedAt = nowIso();
+            await this.persist();
+            if (!result.passed) {
+                iteration.failureReason = `Verify check failed: ${command}`;
+                return false;
+            }
+        }
+        if (!loop.verifyPrompt) {
+            return true;
+        }
+        const startedAt = nowIso();
+        const initialVerifierPrompt = buildStructuredAgentResponsePrompt({
+            prompt: loop.verifyPrompt,
+            schema: LoopVerifyPromptSchema,
+            schemaName: "LoopVerifierResult",
+        });
+        const created = await this.options.createAgent({
+            kind: "mcp",
+            provider: this.formatVerifierProviderModel(loop),
+            cwd: loop.cwd,
+            workspaceId: await context.workspaceId,
+            title: buildVerifierTitle(loop, iteration.index),
+            mode: loop.verifierModeId ?? loop.modeId ?? undefined,
+            unattended: true,
+            promptFailure: "return-error",
+            background: true,
+            notifyOnFinish: false,
+            internal: true,
+        });
+        const verifierAgent = created.snapshot;
+        iteration.verifierAgentId = verifierAgent.id;
+        loop.activeVerifierAgentId = verifierAgent.id;
+        loop.updatedAt = nowIso();
+        await this.persist();
+        const unsubscribe = this.options.agentManager.subscribe((event) => {
+            if (event.type !== "agent_stream") {
+                return;
+            }
+            const text = formatStreamLog(event.event);
+            if (!text) {
+                return;
+            }
+            this.appendLog(loop, {
+                iteration: iteration.index,
+                source: "verifier",
+                level: event.event.type === "turn_failed" ? "error" : "info",
+                text,
+            });
+            void this.persist();
+        }, { agentId: verifierAgent.id, replayState: false });
+        try {
+            let waitingForInitialResponse = true;
+            const result = await getStructuredAgentResponse({
+                caller: async (nextPrompt) => {
+                    if (waitingForInitialResponse) {
+                        waitingForInitialResponse = false;
+                        const run = await this.options.agentManager.runAgent(verifierAgent.id, initialVerifierPrompt);
+                        return this.resolveFinalText(run.timeline, run.finalText);
+                    }
+                    const run = await this.options.agentManager.runAgent(verifierAgent.id, this.toPrompt(nextPrompt));
+                    return this.resolveFinalText(run.timeline, run.finalText);
+                },
+                prompt: loop.verifyPrompt,
+                schema: LoopVerifyPromptSchema,
+                maxRetries: 2,
+                schemaName: "LoopVerifierResult",
+            });
+            iteration.verifyPrompt = {
+                passed: result.passed,
+                reason: result.reason,
+                verifierAgentId: verifierAgent.id,
+                startedAt,
+                completedAt: nowIso(),
+            };
+            this.appendLog(loop, {
+                iteration: iteration.index,
+                source: "loop",
+                level: result.passed ? "info" : "error",
+                text: `Verifier result: ${result.reason}`,
+            });
+            if (!result.passed) {
+                iteration.failureReason = result.reason;
+            }
+            return result.passed;
+        }
+        finally {
+            unsubscribe();
+            loop.activeVerifierAgentId = null;
+            loop.updatedAt = nowIso();
+            await this.persist();
+            try {
+                if (loop.archive) {
+                    await this.options.agentManager.archiveAgent(verifierAgent.id);
+                }
+                else {
+                    await this.options.agentManager.closeAgent(verifierAgent.id);
+                }
+            }
+            catch {
+                // Ignore cleanup errors for internal loop verifiers.
+            }
+        }
+    }
+    formatWorkerProviderModel(loop) {
+        return formatProviderModel(loop.workerProvider ?? loop.provider, loop.workerModel ?? loop.model);
+    }
+    formatVerifierProviderModel(loop) {
+        return formatProviderModel(loop.verifierProvider ?? loop.provider, loop.verifierModel ?? loop.model);
+    }
+    resolveFinalText(timeline, finalText) {
+        if (finalText.trim()) {
+            return finalText;
+        }
+        for (let index = timeline.length - 1; index >= 0; index -= 1) {
+            const item = timeline[index];
+            if (item?.type === "assistant_message" && item.text.trim()) {
+                return item.text;
+            }
+        }
+        return "";
+    }
+    toPrompt(text) {
+        return text;
+    }
+    finishLoop(loop, status, message) {
+        loop.status = status;
+        loop.completedAt = nowIso();
+        loop.updatedAt = loop.completedAt;
+        loop.activeIteration = null;
+        loop.activeWorkerAgentId = null;
+        loop.activeVerifierAgentId = null;
+        this.appendLog(loop, {
+            iteration: null,
+            source: "loop",
+            level: status === "succeeded" ? "info" : "error",
+            text: message,
+        });
+    }
+    appendLog(loop, entry) {
+        loop.logs.push({
+            seq: loop.nextLogSeq,
+            timestamp: nowIso(),
+            ...entry,
+        });
+        loop.nextLogSeq += 1;
+        loop.updatedAt = nowIso();
+    }
+    requireLoop(idOrPrefix) {
+        const trimmed = idOrPrefix.trim();
+        if (!trimmed) {
+            throw new Error("Loop id is required");
+        }
+        const exact = this.loops.get(trimmed);
+        if (exact) {
+            return exact;
+        }
+        const matches = Array.from(this.loops.values()).filter((record) => record.id.startsWith(trimmed));
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        if (matches.length > 1) {
+            throw new Error(`Loop id prefix is ambiguous: ${trimmed}`);
+        }
+        throw new Error(`Loop not found: ${trimmed}`);
+    }
+    async persist() {
+        const nextPersist = this.persistQueue.then(async () => {
+            const records = Array.from(this.loops.values()).sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+            await writeJsonFileAtomic(this.storePath, records);
+            return;
+        });
+        this.persistQueue = nextPersist.catch(() => { });
+        await nextPersist;
+    }
+}
+//# sourceMappingURL=loop-service.js.map