}

function expectRecordFields(record: unknown, expected: Record<string, unknown>) {

expect(record).toBeDefined();

if (!record || typeof record !== "object") {

throw new Error("Expected record");

}

const actual = record as Record<string, unknown>;

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

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

}

function expectMockCallFields(mock: ReturnType<typeof vi.fn>, expected: Record<string, unknown>) {

expect(findMockCallFields(mock, expected)).toBeDefined();

if (!findMockCallFields(mock, expected)) {

throw new Error(`Expected mock call ${JSON.stringify(expected)}`);

}

}

function expectNoMockCallFields(mock: ReturnType<typeof vi.fn>, expected: Record<string, unknown>) {

const result = await agent.resumeSession(createResumeSessionRequest("agent:main:work"));

expect(result.modes?.currentModeId).toBe("adaptive");

expect(result.configOptions).toBeDefined();

if (!result.configOptions) {

throw new Error("expected resume session config options");

}

function expectConfigOption(options: unknown, id: string, fields: Record<string, unknown>) {

const option = configOptions(options).find((candidate) => candidate.id === id);

expect(option, `config option ${id}`).toBeDefined();

if (!option) {

throw new Error(`Expected config option ${id}`);

}

for (const [field, value] of Object.entries(fields)) {

expect(option?.[field]).toEqual(value);

expect(option[field]).toEqual(value);

}

}

};

const args = parseCommandArgs(command, "set foo bar baz");

expect(args).toBeDefined();

if (!args) {

throw new Error("Expected parsed command args");

}

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");

}

function requireFirstMockCall(mock: unknown, label: string): unknown[] {

const call = (mock as { mock?: { calls?: unknown[][] } }).mock?.calls?.[0];

expect(call).toBeDefined();

if (!call) {

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

}

function callArg<T>(mock: { mock: { calls: unknown[][] } }, index = 0, _type?: (value: T) => T): T {

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

expect(call).toBeDefined();

return call?.[0] as T;

if (!call) {

throw new Error(`Expected mock call ${index}`);

}

return call[0] as T;

}

function expectExternalCatalogInstallCall(index = 0) {

function mockCallArg(mock: { mock: { calls: unknown[][] } }, index = 0): unknown {

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

expect(call).toBeDefined();

if (!call) {

throw new Error(`Expected mock call ${index}`);

}

return call[0];

}

const record = item as Record<string, unknown>;

return Object.entries(fields).every(([key, value]) => Object.is(record[key], value));

});

expect(found).toBeDefined();

if (!found) {

throw new Error(`missing ${label}`);

}

function requireFirstMockCallArg(mock: unknown, label: string) {

const calls = (mock as { mock?: { calls?: unknown[][] } }).mock?.calls;

const call = calls?.[0];

expect(call).toBeDefined();

if (!call) {

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

}

});

const shellWrapperCall = requireMacExecHostCall(shellWrapperInvoke.runViaMacAppExecHost);

expect(shellWrapperCall.approvals).toBeDefined();

if (shellWrapperCall.approvals === undefined) {

throw new Error("Expected shell-wrapper approvals");

}

expect(shellWrapperCall.request?.command).toEqual([

"/bin/sh",

"-lc",

const canonicalCwd = fs.realpathSync(tmp);

expect(invoke.runCommand).not.toHaveBeenCalled();

const macHostCall = requireMacExecHostCall(invoke.runViaMacAppExecHost);

expect(macHostCall.approvals).toBeDefined();

if (macHostCall.approvals === undefined) {

throw new Error("Expected Mac host approvals");

}

expect(macHostCall.request?.command).toEqual(["env", "sh", "-c", "echo SAFE"]);

expect(macHostCall.request?.rawCommand).toBe('env sh -c "echo SAFE"');

expect(macHostCall.request?.cwd).toBe(canonicalCwd);