const forwarded = result.params as Record<string, unknown>;

expect(forwarded.command).toEqual(["/usr/bin/echo", "SAFE"]);

expect(forwarded.rawCommand).toBe("/usr/bin/echo SAFE");

expect(forwarded.systemRunPlan).toEqual(

expect.objectContaining({

argv: ["/usr/bin/echo", "SAFE"],

cwd: "/real/cwd",

commandText: "/usr/bin/echo SAFE",

agentId: "main",

sessionKey: "agent:main:main",

}),

);

const systemRunPlan = forwarded.systemRunPlan as

| {

argv?: string[];

cwd?: string;

commandText?: string;

agentId?: string;

sessionKey?: string;

}

| undefined;

expect(systemRunPlan?.argv).toEqual(["/usr/bin/echo", "SAFE"]);

expect(systemRunPlan?.cwd).toBe("/real/cwd");

expect(systemRunPlan?.commandText).toBe("/usr/bin/echo SAFE");

expect(systemRunPlan?.agentId).toBe("main");

expect(systemRunPlan?.sessionKey).toBe("agent:main:main");

expect(forwarded.cwd).toBe("/real/cwd");

expect(forwarded.agentId).toBe("main");

expect(forwarded.sessionKey).toBe("agent:main:main");

await configHandlers["config.patch"](options);

expect(restartSentinelMocks.writeRestartSentinel).toHaveBeenCalledWith(

expect.objectContaining({

sessionKey: "agent:main:main",

}),

);

const payload = restartSentinelMocks.writeRestartSentinel.mock.calls.at(-1)?.[0];

expect(payload?.sessionKey).toBe("agent:main:main");

expect(payload?.continuation).toBeUndefined();

});

});

idempotencyKey: "idem-send-options",

});

expect(mocks.deliverOutboundPayloads).toHaveBeenCalledWith(

expect.objectContaining({

forceDocument: true,

silent: true,

formatting: { parseMode: "HTML" },

}),

);

const options = mocks.deliverOutboundPayloads.mock.calls[0]?.[0];

expect(options?.forceDocument).toBe(true);

expect(options?.silent).toBe(true);

expect(options?.formatting).toEqual({ parseMode: "HTML" });

});

it("updates mirror session keys and delivery thread ids when Slack routing derives a thread", async () => {

});

expect(firstRespondCall(respond)?.[0]).toBe(true);

expect(capturedMediaLocalRoots).toEqual(expect.arrayContaining([TEST_AGENT_WORKSPACE]));

expect(capturedMediaLocalRoots).toContain(TEST_AGENT_WORKSPACE);

});

it("forces senderIsOwner=false for narrowly-scoped callers but honors it for full operators", async () => {

isWebchatConnect: () => false,

});

expect(mockCallArg(respond, 0, 1)).toMatchObject({

modelPricing: {

state: "degraded",

detail: "OpenRouter pricing fetch failed: TypeError: fetch failed",

sources: [{ source: "openrouter", state: "degraded", lastFailureAt: 123 }],

},

});

const payload = mockCallArg(respond, 0, 1) as

| {

modelPricing?: {

state?: string;

detail?: string;

sources?: Array<{ source?: string; state?: string; lastFailureAt?: number }>;

};

}

| undefined;

expect(payload?.modelPricing?.state).toBe("degraded");

expect(payload?.modelPricing?.detail).toBe(

"OpenRouter pricing fetch failed: TypeError: fetch failed",

);

expect(payload?.modelPricing?.sources).toHaveLength(1);

expect(payload?.modelPricing?.sources?.[0]?.source).toBe("openrouter");

expect(payload?.modelPricing?.sources?.[0]?.state).toBe("degraded");

expect(payload?.modelPricing?.sources?.[0]?.lastFailureAt).toBe(123);

expect(mockCallArg(respond, 0, 3)).toEqual({ cached: true });

expect(refreshHealthSnapshot).toHaveBeenCalledWith({

probe: false,

| { lane?: string; inputProvenance?: { kind?: string; sourceTool?: string } }

| undefined;

expect(firstCall?.lane).toMatch(/^nested(?::|$)/);

expect(firstCall?.inputProvenance).toMatchObject({

kind: "inter_session",

sourceTool: "sessions_send",

});

expect(firstCall?.inputProvenance?.kind).toBe("inter_session");

expect(firstCall?.inputProvenance?.sourceTool).toBe("sessions_send");

});

});