const makeSkillJob = makeIsolatedAgentTurnJob;

const makeSkillParams = makeIsolatedAgentTurnParams;

function requireRecord(value: unknown, label: string): Record<string, unknown> {

if (typeof value !== "object" || value === null || Array.isArray(value)) {

throw new Error(`expected ${label} to be an object`);

}

return value as Record<string, unknown>;

}

function getMockCallArg(

mock: { mock: { calls: readonly unknown[][] } },

callIndex: number,

argIndex: number,

label: string,

): unknown {

const call = mock.mock.calls[callIndex];

if (!call) {

throw new Error(`expected ${label} call ${callIndex}`);

}

return call[argIndex];

}

function getFirstMockArg(

mock: { mock: { calls: readonly unknown[][] } },

label: string,

): Record<string, unknown> {

return requireRecord(getMockCallArg(mock, 0, 0, label), `${label} params`);

}

// ---------- tests ----------

describe("runCronIsolatedAgentTurn — skill filter", () => {

function expectDefaultModelCall(params: { primary: string; fallbacks: string[] }) {

expect(runWithModelFallbackMock).toHaveBeenCalledOnce();

const callCfg = runWithModelFallbackMock.mock.calls[0][0].cfg;

const model = callCfg?.agents?.defaults?.model as { primary?: string; fallbacks?: string[] };

const callCfg = getFirstMockArg(runWithModelFallbackMock, "model fallback").cfg as

| { agents?: { defaults?: { model?: { primary?: string; fallbacks?: string[] } } } }

| undefined;

const model = callCfg?.agents?.defaults?.model;

expect(model?.primary).toBe(params.primary);

expect(model?.fallbacks).toEqual(params.fallbacks);

}

agentId: "scout",

});

expect(buildWorkspaceSkillSnapshotMock).toHaveBeenCalledOnce();

expect(buildWorkspaceSkillSnapshotMock.mock.calls[0][1]).toHaveProperty("skillFilter", [

"meme-factory",

"weather",

]);

expect(getMockCallArg(buildWorkspaceSkillSnapshotMock, 0, 1, "skill snapshot")).toHaveProperty(

"skillFilter",

["meme-factory", "weather"],

);

});

it("omits skillFilter when agent has no skills config", async () => {

});

expect(buildWorkspaceSkillSnapshotMock).toHaveBeenCalledOnce();

// When no skills config, skillFilter should be undefined (no filtering applied)

expect(buildWorkspaceSkillSnapshotMock.mock.calls[0][1].skillFilter).toBeUndefined();

expect(

requireRecord(

getMockCallArg(buildWorkspaceSkillSnapshotMock, 0, 1, "skill snapshot"),

"skill snapshot options",

).skillFilter,

).toBeUndefined();

});

it("passes empty skillFilter when agent explicitly disables all skills", async () => {

});

expect(buildWorkspaceSkillSnapshotMock).toHaveBeenCalledOnce();

// Explicit empty skills list should forward [] to filter out all skills

expect(buildWorkspaceSkillSnapshotMock.mock.calls[0][1]).toHaveProperty("skillFilter", []);

expect(getMockCallArg(buildWorkspaceSkillSnapshotMock, 0, 1, "skill snapshot")).toHaveProperty(

"skillFilter",

[],

);

});

it("refreshes cached snapshot when skillFilter changes without version bump", async () => {

agentId: "weather-bot",

});

expect(buildWorkspaceSkillSnapshotMock).toHaveBeenCalledOnce();

expect(buildWorkspaceSkillSnapshotMock.mock.calls[0][1]).toHaveProperty("skillFilter", [

"weather",

]);

expect(getMockCallArg(buildWorkspaceSkillSnapshotMock, 0, 1, "skill snapshot")).toHaveProperty(

"skillFilter",

["weather"],

);

});

it("forces a fresh session for isolated cron runs", async () => {

await runSkillFilterCase();

expect(resolveCronSessionMock).toHaveBeenCalledOnce();

expect(resolveCronSessionMock.mock.calls[0]?.[0]?.forceNew).toBe(true);

expect(getFirstMockArg(resolveCronSessionMock, "cron session").forceNew).toBe(true);

});

it("reuses cached snapshot when version and normalized skillFilter are unchanged", async () => {

expect(result.status).toBe("ok");

expect(logWarnMock).not.toHaveBeenCalled();

expect(runWithModelFallbackMock).toHaveBeenCalledOnce();

const runParams = runWithModelFallbackMock.mock.calls[0][0];

const runParams = getFirstMockArg(runWithModelFallbackMock, "model fallback");

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

expect(runParams.model).toBe("claude-sonnet-4-6");

});

expect(runCliAgentMock).toHaveBeenCalledOnce();

// Fresh session: cliSessionId must be undefined, not the stored value.

expect(runCliAgentMock.mock.calls[0][0]).toHaveProperty("cliSessionId", undefined);

expect(getFirstMockArg(runCliAgentMock, "CLI run")).toHaveProperty("cliSessionId", undefined);

});

it("reuses stored cliSessionId on continuation runs (isNewSession=false)", async () => {

expect(runCliAgentMock).toHaveBeenCalledOnce();

// Continuation: cliSessionId should be passed through for session resume.

expect(runCliAgentMock.mock.calls[0][0]).toHaveProperty(

expect(getFirstMockArg(runCliAgentMock, "CLI run")).toHaveProperty(

"cliSessionId",

"existing-cli-session-def",

);