for (const hash of hashes) {

expect(hash.startsWith("tool:")).toBe(true);

expect(hash.length).toBe("tool:".length + 64);

expect([...hash.slice("tool:".length)].every((char) => /[a-f0-9]/.test(char))).toBe(true);

expect(/^[a-f0-9]+$/.test(hash.slice("tool:".length))).toBe(true);

}

});

await expect(

fs.stat(join(sandboxDir, "media", "inbound", basename(sensitiveFile))),

).rejects.toMatchObject({ code: "ENOENT" });

).rejects.toSatisfy((error) => {

expect((error as NodeJS.ErrnoException).code).toBe("ENOENT");

return true;

});

expect(ctx.MediaPath).toBe(sensitiveFile);

}

await expect(

fs.stat(join(sandboxDir, "media", "inbound", basename(mediaPath))),

).rejects.toMatchObject({ code: "ENOENT" });

).rejects.toSatisfy((error) => {

expect((error as NodeJS.ErrnoException).code).toBe("ENOENT");

return true;

});

expect(ctx.MediaPath).toBe(mediaPath);

expect(sessionCtx.MediaPath).toBe(mediaPath);

});

);

expect(params.runEmbeddedPiAgentMock).toHaveBeenCalledOnce();

expect(params.runEmbeddedPiAgentMock.mock.calls[0]?.[0]).toEqual(

expect.objectContaining(expected),

);

const runParams = params.runEmbeddedPiAgentMock.mock.calls[0]?.[0] as

| Record<string, unknown>

| undefined;

expect(runParams).toBeDefined();

if (!runParams) {

throw new Error("expected embedded PI agent call params");

}

for (const [key, value] of Object.entries(expected)) {

expect(runParams[key]).toEqual(value);

}

}

async function writeStoredModelOverride(cfg: ReturnType<typeof makeCfg>): Promise<void> {

// Should skip killing the ended depth-1 run itself, but still kill depth-2.

expect(result.stoppedSubagents).toBe(1);

expectSessionLaneCleared(depth2Key);

expect(subagentRegistryMocks.markSubagentRunTerminated).toHaveBeenCalledWith(

expect.objectContaining({ runId: "run-2", childSessionKey: depth2Key }),

);

expect(subagentRegistryMocks.markSubagentRunTerminated).toHaveBeenCalledTimes(1);

const [[terminatedRun]] = subagentRegistryMocks.markSubagentRunTerminated.mock

.calls as unknown as Array<[{ runId?: string; childSessionKey?: string }]>;

expect(terminatedRun.runId).toBe("run-2");

expect(terminatedRun.childSessionKey).toBe(depth2Key);

});

it("cascade stop still traverses an ended current parent when a stale older active row exists", async () => {

expect(result.stoppedSubagents).toBe(1);

expectSessionLaneCleared(depth2Key);

expect(subagentRegistryMocks.markSubagentRunTerminated).toHaveBeenCalledWith(

expect.objectContaining({ runId: "run-active-child", childSessionKey: depth2Key }),

);

expect(subagentRegistryMocks.markSubagentRunTerminated).toHaveBeenCalledTimes(1);

const [[terminatedRun]] = subagentRegistryMocks.markSubagentRunTerminated.mock

.calls as unknown as Array<[{ runId?: string; childSessionKey?: string }]>;

expect(terminatedRun.runId).toBe("run-active-child");

expect(terminatedRun.childSessionKey).toBe(depth2Key);

});

it("stopSubagentsForRequester does not traverse a child that moved to a newer parent", () => {

const errorMock = vi.fn();

async function expectPathMissing(targetPath: string): Promise<void> {

await expect(fs.access(targetPath)).rejects.toMatchObject({ code: "ENOENT" });

await expect(fs.access(targetPath)).rejects.toSatisfy((error) => {

expect((error as NodeJS.ErrnoException).code).toBe("ENOENT");

return true;

});

}

describe("resetReplyRunSession", () => {

}),

);

expect(result?.mediaUrl).toBe("/tmp/outbound-media/generated.png");

expect(result?.mediaUrls).toEqual(["/tmp/outbound-media/generated.png"]);

expect(Array.isArray(result)).toBe(false);

if (!result || Array.isArray(result)) {

throw new Error("expected single reply payload");

}

expect(result.mediaUrl).toBe("/tmp/outbound-media/generated.png");

expect(result.mediaUrls).toEqual(["/tmp/outbound-media/generated.png"]);

const outboundAttachmentCall = resolveOutboundAttachmentFromUrlMock.mock.calls[0];

expect(outboundAttachmentCall?.[0]).toBe(path.join("/tmp/workspace", "out", "generated.png"));

expect(outboundAttachmentCall?.[1]).toBe(5 * 1024 * 1024);

const result = await handleBashCommand(params, true);

expect(result?.shouldContinue).toBe(false);

expect(handleBashChatCommandMock).toHaveBeenCalledWith(

expect.objectContaining({

agentId: "target",

sessionKey: "agent:target:whatsapp:direct:test-user",

}),

);

expect(handleBashChatCommandMock).toHaveBeenCalledTimes(1);

const [[bashParams]] = handleBashChatCommandMock.mock.calls as unknown as Array<

[{ agentId?: string; sessionKey?: string }]

>;

expect(bashParams.agentId).toBe("target");

expect(bashParams.sessionKey).toBe("agent:target:whatsapp:direct:test-user");

});

});

shouldContinue: false,

reply: { text: "Docked replies to discord." },

});

expect(params.sessionStore?.[params.sessionKey]).toMatchObject({

lastChannel: "discord",

lastTo: "UserCase123",

lastAccountId: "default",

});

const updatedEntry = params.sessionStore?.[params.sessionKey];

expect(updatedEntry?.lastChannel).toBe("discord");

expect(updatedEntry?.lastTo).toBe("UserCase123");

expect(updatedEntry?.lastAccountId).toBe("default");

});

it("accepts generated underscore aliases such as Telegram native /dock_discord", async () => {

});

expect(reply.text).toContain("✅ Session exported!");

const systemPromptBundleParams =

hoisted.resolveCommandsSystemPromptBundleMock.mock.calls[0]?.[0];

const [[systemPromptBundleParams]] = hoisted.resolveCommandsSystemPromptBundleMock.mock

.calls as unknown as Array<[{ sessionEntry?: { sessionId?: string; updatedAt?: number } }]>;

expect(systemPromptBundleParams?.sessionEntry?.sessionId).toBe("session-from-store");

expect(systemPromptBundleParams?.sessionEntry?.updatedAt).toBe(2);

});

const result = await handleModelsCommand(params, true);

expect(result?.reply?.text).toContain("Models (anthropic · 🔑 target-auth) — showing 1-2 of 2");

const authLabelParams = modelAuthLabelMocks.resolveModelAuthLabel.mock.calls[0]?.[0];

expect(authLabelParams?.provider).toBe("anthropic");

expect(authLabelParams?.workspaceDir).toBe("/tmp");

const [[authLabelParams]] = modelAuthLabelMocks.resolveModelAuthLabel.mock

.calls as unknown as Array<[{ provider?: string; workspaceDir?: string }]>;

expect(authLabelParams.provider).toBe("anthropic");

expect(authLabelParams.workspaceDir).toBe("/tmp");

});

it("uses spawned workspace for direct /models provider visibility", async () => {