});

});

it("accepts malformed completed wait errors as successful terminal runs", async () => {

const gatewayCall = vi

.fn()

.mockResolvedValueOnce({ runId: "run-error-completed" })

.mockResolvedValueOnce({ status: "error", error: "completed" });

const env = {

gateway: { call: gatewayCall },

transport: {

buildAgentDelivery: vi.fn(() => ({

channel: "qa-channel",

replyChannel: "reply-channel",

replyTo: "reply-target",

})),

},

} as never;

await expect(

runAgentPrompt(env, {

sessionKey: "session-error-completed",

message: "hello",

}),

).resolves.toEqual({

started: { runId: "run-error-completed" },

waited: { status: "error", error: "completed" },

});

});

it("waits for the latest assistant history reply", async () => {

const gatewayCall = vi

.fn()

messages?: unknown[];

};

type QaAgentWaitResult = {

status?: string;

error?: string;

};

const ANSI_ESCAPE_PATTERN = new RegExp(String.raw`\x1B\[[0-?]*[ -/]*[@-~]`, "g");

const MANAGED_DREAMING_CRON_MARKER = "[managed-by=memory-core.short-term-promotion]";

const MANAGED_DREAMING_CRON_NAME = "Memory Dreaming Promotion";

{

timeoutMs: resolveQaGatewayTimeoutWithGraceMs(waitTimeoutMs),

},

)) as { status?: string; error?: string };

)) as QaAgentWaitResult;

} catch (error) {

throw new QaSuiteInfraError(

"agent_wait_failed",

}

}

function isSuccessfulAgentWaitResult(waited: QaAgentWaitResult) {

if (waited.status === "ok" || waited.status === "completed" || waited.status === "succeeded") {

return true;

}

return waited.status === "error" && waited.error?.trim().toLowerCase() === "completed";

}

function readLatestAssistantTextFromHistory(history: QaChatHistoryResponse | undefined) {

for (const message of (history?.messages ?? []).toReversed()) {

if (!isRecord(message) || message.role !== "assistant") {

) {

const started = await startAgentRun(env, params);

const waited = await waitForAgentRun(env, started.runId!, params.timeoutMs ?? 30_000);

if (waited.status === "error" || waited.status === "timeout" || waited.status === "pending") {

if (!isSuccessfulAgentWaitResult(waited)) {

throw new Error(

`agent.wait returned ${waited.status ?? "unknown"}: ${waited.error ?? "no error"}`,

);

expectedReplyAll:

- "personal-failure-recovery.txt"

- "PERSONAL-FAILURE-RECOVERY-OK"

- "failed step:"

- "retry boundary:"

forbiddenNeedles:

- "fully complete"

- "all done"

expectedReplyAll:

- "personal-progress-proof.txt"

- "PERSONAL-NO-FAKE-PROGRESS-OK"

- "local proof artifact written"

forbiddenNeedles:

- "sent successfully"

- "published successfully"

- set: expectedReplyAll

value:

expr: config.expectedReplyAll.map(normalizeLowercaseStringOrEmpty)

- call: waitForCondition

- call: waitForAgentHistoryReply

saveAs: outbound

args:

- ref: env

- expr: config.sessionKey

- lambda:

expr: "state.getSnapshot().messages.filter((candidate) => candidate.direction === 'outbound' && candidate.conversation.id === 'qa-operator' && expectedReplyAll.every((needle) => normalizeLowercaseStringOrEmpty(candidate.text).includes(needle))).at(-1)"

params: [text]

expr: "expectedReplyAll.every((needle) => normalizeLowercaseStringOrEmpty(text).includes(needle))"

- expr: liveTurnTimeoutMs(env, 30000)

- expr: "env.providerMode === 'mock-openai' ? 100 : 250"

- assert:

}),

).rejects.toThrow(/not found/);

});

test("normalizes completed agent.wait envelopes for plugin subagents", async () => {

const serverPlugins = await loadServerPlugins();

const runtime = serverPlugins.createGatewaySubagentRuntime();

serverPlugins.setFallbackGatewayContext(createTestContext("plugin-wait", createTestCfg()));

handleGatewayRequest.mockImplementation(async (opts: HandleGatewayRequestOptions) => {

switch (opts.req.method) {

case "agent.wait":

opts.respond(true, { status: "completed" });

return;

default:

opts.respond(true, {});

}

});

await expect(runtime.waitForRun({ runId: "plugin-run-completed" })).resolves.toEqual({

status: "ok",

});

});

test("normalizes malformed completed wait errors for plugin subagents", async () => {

const serverPlugins = await loadServerPlugins();

const runtime = serverPlugins.createGatewaySubagentRuntime();

serverPlugins.setFallbackGatewayContext(

createTestContext("plugin-wait-error", createTestCfg()),

);

handleGatewayRequest.mockImplementation(async (opts: HandleGatewayRequestOptions) => {

switch (opts.req.method) {

case "agent.wait":

opts.respond(true, { status: "error", error: "completed" });

return;

default:

opts.respond(true, {});

}

});

await expect(runtime.waitForRun({ runId: "plugin-run-error-completed" })).resolves.toEqual({

status: "ok",

});

});

});

...(params.timeoutMs != null && { timeoutMs: params.timeoutMs }),

},

);

const status = payload?.status;

let status = payload?.status;

if (status === "completed" || status === "succeeded") {

status = "ok";

} else if (status === "error" && payload?.error?.trim().toLowerCase() === "completed") {

status = "ok";

}

if (status !== "ok" && status !== "error" && status !== "timeout") {

throw new Error(`Gateway agent.wait returned unexpected status: ${status}`);

throw new Error(`Gateway agent.wait returned unexpected status: ${payload?.status}`);

}

return {

status,

...(typeof payload?.error === "string" && payload.error && { error: payload.error }),

...(status !== "ok" &&

typeof payload?.error === "string" &&

payload.error && { error: payload.error }),

};

},

getSessionMessages,