taskchef 7.27.2 → 7.28.0

package/src/dashboard/react/App.test.tsx

@@ -112,6 +112,7 @@ vi.mock("@mantine/core", async () => {
     Alert: primitive("div"),
     AppShell,
     Box: primitive("div"),
+    Button: primitive("button"),
     CloseButton: primitive("button"),
     Container: primitive("div"),
     Group: primitive("div"),

package/src/dashboard/react/App.tsx

@@ -1,8 +1,10 @@
+import { ModelSettings } from "./components/ModelSettings";
 import {
   Alert,
   ActionIcon,
   AppShell,
   Box,
+  Button,
   CloseButton,
   Container,
   Group,
@@ -100,6 +102,12 @@ export function DashboardApp({
   initialFilters?: { date?: string; project?: string; status?: string };
   initialTasks?: Task[];
 }) {
+  const [settings, setSettings] = useState(() => window.location.hash === '#settings');
+  useEffect(() => {
+    const update = () => setSettings(window.location.hash === '#settings');
+    window.addEventListener('hashchange', update);
+    return () => window.removeEventListener('hashchange', update);
+  }, []);
   const [tasks, setTasks] = useState<Task[]>(initialTasks);
   const [connected, setConnected] = useState(false);
   const [message, setMessage] = useState<string | null>(null);
@@ -307,13 +315,14 @@ export function DashboardApp({
                 <IconCircleFilled aria-hidden color={connected ? "var(--mantine-color-teal-6)" : "var(--mantine-color-yellow-6)"} size={9} />
                 <Text c="dimmed" size="xs">{connected ? "Live" : connect ? "Connecting…" : "Fixture preview"}</Text>
               </Group>
-              <ThemeToggle />
+              <Group gap="xs"><Button component="a" href={settings ? '#' : '#settings'} variant="subtle" size="xs">{settings ? 'Tasks' : 'Settings'}</Button><ThemeToggle /></Group>
             </Stack>
           </Group>
         </Container>
 
         <AppShell.Main>
           <Container className="taskchef-main" pb={80} size={1080}>
+            {settings ? <ModelSettings /> : <>
             <Paper className="taskchef-toolbar" p="sm" radius="md" withBorder>
               <Stack gap="sm">
                 <Group align="end" gap="sm">
@@ -356,6 +365,7 @@ export function DashboardApp({
                 </Paper>
               )}
             </Stack>
+            </>}
           </Container>
         </AppShell.Main>
       </AppShell>

package/src/dashboard/react/components/ModelSettings.test.tsx

@@ -0,0 +1,53 @@
+import { MantineProvider } from '@mantine/core';
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, expect, test, vi } from 'vitest';
+import { ModelSettings } from './ModelSettings';
+
+vi.mock('@mantine/core', async () => {
+  const { createElement } = await import('react');
+  const block = ({ children }: { children?: import('react').ReactNode }) => createElement('div', null, children);
+  return {
+    MantineProvider: block, Badge: block, Group: block, Paper: block, Stack: block, Text: block, Title: block,
+    Select: () => null,
+    Alert: ({ children }: { children?: import('react').ReactNode }) => createElement('div', { role: 'alert' }, children),
+    Button: ({ children, loading, onClick }: { children?: import('react').ReactNode; loading: boolean; onClick: () => void }) => createElement('button', { disabled: loading, onClick }, children),
+  };
+});
+
+afterEach(() => { cleanup(); vi.unstubAllGlobals(); });
+
+test('refresh shows configuration failures and does not label them honored', async () => {
+  const role = { role: 'reviewer', source: '/fixture/reviewer.toml', effectiveSource: '/fixture/reviewer.toml', model: 'fixture', effort: 'low', status: 'configured', availability: 'not checked', fallback: 'inherit parent settings', problems: [] as string[] };
+  const profile = { id: 'personal', project: 'Personal', roles: [role], problems: [], catalogSource: null };
+  const fetchMock = vi.fn().mockResolvedValueOnce({ ok: true, json: async () => ({ profiles: [profile] }) })
+    .mockResolvedValueOnce({ ok: true, json: async () => ({ profiles: [{ ...profile, roles: [{ ...role, status: 'invalid', problems: ['Unsupported effort'] }] }] }) });
+  vi.stubGlobal('fetch', fetchMock);
+  render(<MantineProvider><ModelSettings /></MantineProvider>);
+  expect(await screen.findByText('configured')).toBeInTheDocument();
+  const refresh = screen.getByText('Refresh').closest('button')!;
+  await waitFor(() => expect(refresh).toBeEnabled());
+  await act(async () => { fireEvent.click(refresh); });
+  expect(await screen.findByText('Unsupported effort')).toBeInTheDocument();
+  expect(screen.getByText(/Overrides blocked/)).toBeInTheDocument();
+  expect(screen.queryByText(/Requested effective settings/)).not.toBeInTheDocument();
+});
+
+test('request failure remains visible and can be retried', async () => {
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce({ ok: false }).mockResolvedValueOnce({ ok: true, json: async () => ({ profiles: [] }) }));
+  render(<MantineProvider><ModelSettings /></MantineProvider>);
+  expect(await screen.findByRole('alert')).toHaveTextContent('could not be loaded');
+  const refresh = screen.getByText('Refresh').closest('button')!;
+  await waitFor(() => expect(refresh).toBeEnabled());
+  await act(async () => { fireEvent.click(refresh); });
+  await waitFor(() => expect(screen.queryByRole('alert')).not.toBeInTheDocument());
+});
+
+
+test('non-string TOML values show diagnostics without crashing settings', async () => {
+  const role = { role: 'reviewer', source: '/fixture/reviewer.toml', model: { slug: 'bad' }, effort: ['bad'], status: 'invalid', availability: 'not checked', fallback: 'inherit parent settings', problems: ['model must be a nonempty string'] };
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, json: async () => ({ profiles: [{ id: 'personal', project: 'Personal', roles: [role], problems: [], catalogSource: null }] }) }));
+  render(<MantineProvider><ModelSettings /></MantineProvider>);
+  expect(await screen.findByText(/Invalid model value/)).toBeInTheDocument();
+  expect(screen.getByText(/Invalid effort value/)).toBeInTheDocument();
+  expect(screen.getByText('model must be a nonempty string')).toBeInTheDocument();
+});

package/src/dashboard/react/components/ModelSettings.tsx

@@ -0,0 +1,61 @@
+import { Alert, Badge, Button, Group, Paper, Select, Stack, Text, Title } from '@mantine/core';
+import { useEffect, useState } from 'react';
+
+type Role = { role: string; source: string | null; effectiveSource: string | null; model: unknown; effort: unknown; status: string; availability: string; fallback: string; problems: string[] };
+type Profile = { id: string; project: string; roles: Role[]; problems: string[]; precedence?: string; scope?: string; catalogSource: string | null };
+
+function setting(value: unknown, name: string) {
+  return typeof value === 'string' ? value : value == null ? `${name} omitted` : `Invalid ${name.toLowerCase()} value`;
+}
+
+export function ModelSettings() {
+  const [profiles, setProfiles] = useState<Profile[]>([]);
+  const [selection, setSelection] = useState('personal');
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [revision, setRevision] = useState(0);
+  useEffect(() => {
+    const controller = new AbortController();
+    setLoading(true);
+    setError(null);
+    fetch('/api/settings', { signal: controller.signal }).then(async (response) => {
+      if (!response.ok) throw new Error('Settings preview could not be loaded.');
+      const data = await response.json() as { profiles: Profile[] };
+      setProfiles(data.profiles);
+    }).catch((failure: Error) => {
+      if (!controller.signal.aborted) setError(failure.message);
+    }).finally(() => { if (!controller.signal.aborted) setLoading(false); });
+    return () => controller.abort();
+  }, [revision]);
+  const profile = profiles.find((item) => item.id === selection) ?? profiles[0];
+  return <Stack gap="md" aria-label="Model settings">
+    <Group justify="space-between">
+      <Title order={2} size="h3">Model roles</Title>
+      <Button variant="light" loading={loading} onClick={() => setRevision((value) => value + 1)}>Refresh</Button>
+    </Group>
+    <Text c="dimmed" size="sm">Preview user-owned Codex agent preferences for planning, implementation, and independent review.</Text>
+    {error && <Alert color="red" role="alert">{error}</Alert>}
+    {loading && <Text role="status">Loading model preferences…</Text>}
+    {profile && <>
+      <Select label="Profile scope" data={profiles.map((item) => ({ value: item.id, label: item.project }))} value={profile.id} onChange={(value) => setSelection(value ?? 'personal')} />
+      {profile.problems.map((problem) => <Alert color="yellow" key={problem}>{problem}</Alert>)}
+      {profile.roles.map((role) => <Paper key={role.role} withBorder p="md">
+        <Stack gap="xs">
+          <Group justify="space-between"><Title order={3} size="h4" tt="capitalize">{role.role}</Title><Badge color={['invalid', 'unavailable'].includes(role.status) ? 'red' : role.status === 'missing' ? 'gray' : 'teal'}>{role.status}</Badge></Group>
+          <Text fw={600}>{setting(role.model, 'Model')} · {setting(role.effort, 'Effort')}</Text>
+          <Text size="sm" style={{ overflowWrap: 'anywhere' }}>Source: {role.source ?? 'No role file'}</Text>
+          <Text size="sm">{role.status === 'configured' ? 'Requested effective settings; passed as explicit overrides after native-tool validation.' : role.status === 'missing' ? `Effective fallback: ${role.fallback}.` : 'Overrides blocked until the configuration problem is resolved or a valid explicit user choice is supplied.'}</Text>
+          <Text c="dimmed" size="sm">When missing: {role.fallback}.</Text>
+          {typeof role.model === 'string' && <Text c="dimmed" size="sm">Availability: {role.availability}.</Text>}
+          {role.problems.map((problem) => <Alert key={problem} color="red">{problem}</Alert>)}
+        </Stack>
+      </Paper>)}
+      <Paper withBorder p="md"><Stack gap="xs">
+        <Text fw={600}>Precedence and validation</Text>
+        <Text size="sm">{profile.precedence}</Text>
+        <Text size="sm">{profile.scope}</Text>
+        <Text c="dimmed" size="sm" style={{ overflowWrap: 'anywhere' }}>Catalog: {profile.catalogSource ?? 'Unavailable'}. This preview does not prove that a future run will honor the profile. The current native interface validates model availability.</Text>
+      </Stack></Paper>
+    </>}
+  </Stack>;
+}

package/src/dashboard.js

@@ -1,3 +1,4 @@
+import { resolveModelRoles } from "./model-roles.js";
 import { EventEmitter } from "node:events";
 import { randomBytes } from "node:crypto";
 import { constants, watch } from "node:fs";
@@ -1178,6 +1179,16 @@ export async function createDashboardServer({
       return;
     }
 
+    if (url.pathname === "/api/settings" && method === "GET") {
+      const config = await readConfig(workspace);
+      const profiles = [{ id: "personal", project: "Personal", ...await resolveModelRoles() }];
+      for (const project of config.projects) {
+        profiles.push({ id: project.path, project: project.name, ...await resolveModelRoles(project.path) });
+      }
+      sendJson(response, 200, { profiles });
+      return;
+    }
+
     if (url.pathname === "/api/snapshot" && (method === "GET" || method === "HEAD")) {
       if (method === "HEAD") {
         response.writeHead(200, securityHeaders("application/json; charset=utf-8"));

package/src/mcp.js

@@ -102,6 +102,8 @@ const preparationSchema = z.object({
   taskId: z.string(),
   preparedAt: z.string(),
   marker: z.string(),
+  modelRoles: z.record(z.string(), z.unknown()).optional(),
+  projectModelRoles: z.array(z.record(z.string(), z.unknown())).optional(),
   projectCount: z.number(),
   projects: z.array(projectSchema),
 });

package/src/model-roles.js

@@ -0,0 +1,44 @@
+import { execFile as execFileCallback } from 'node:child_process';
+import { readdir } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+
+const execFile = promisify(execFileCallback);
+const resolver = fileURLToPath(new URL('../scripts/roles/resolve_roles.py', import.meta.url));
+
+async function hasAgentFiles(directory) {
+  try { return (await readdir(directory)).some((name) => name.endsWith('.toml')); }
+  catch (error) { if (error.code === 'ENOENT') return false; throw error; }
+}
+
+function missingRoles() {
+  return {
+    roles: ['planner', 'implementer', 'reviewer'].map((role) => ({
+      role, source: null, effectiveSource: null, model: null, effort: null,
+      status: 'missing', availability: 'No role files', problems: [],
+      taskOverrides: {}, subagentOverrides: {},
+      fallback: role === 'reviewer' ? 'inherit parent settings' : 'native new-task default (not guaranteed dispatcher inheritance)',
+    })),
+    problems: [], catalogSource: null,
+    precedence: 'explicit user model (and its explicit effort) > project role > personal role > native defaults; explicit effort alone overrides role effort',
+    scope: 'Model and effort only; agent instructions, tools, permissions, and other TOML keys are not applied by this adapter.',
+  };
+}
+
+export async function resolveModelRoles(project = null, { run = execFile, env = process.env } = {}) {
+  try {
+    const home = env.HOME || os.homedir();
+    const codexHome = (env.CODEX_HOME || path.join(home, '.codex')).replace(/^~(?=\/|$)/, home);
+    const directories = [path.join(codexHome, 'agents'), ...(project ? [path.join(project, '.codex', 'agents')] : [])];
+    const configured = await Promise.all(directories.map(hasAgentFiles));
+    if (!configured.some(Boolean)) return missingRoles();
+    const { stdout } = await run('python3', [resolver, ...(project ? ['--project', project] : [])], {
+      env, timeout: 5000, maxBuffer: 128 * 1024,
+    });
+    return JSON.parse(stdout);
+  } catch {
+    return { roles: [], problems: ['Model role preview unavailable. Python 3.11+ and readable agent configuration are required when agent files exist; configured roles have not been honored.'], catalogSource: null };
+  }
+}

package/src/workspace.js

@@ -1,3 +1,4 @@
+import { resolveModelRoles } from "./model-roles.js";
 import { execFile as execFileCallback } from "node:child_process";
 import {
   access,
@@ -704,6 +705,10 @@ export async function prepareDispatch(workspaceRoot, {
     marker,
     projectCount: projects.length,
     projects,
+    modelRoles: await resolveModelRoles(),
+    projectModelRoles: await Promise.all(projects.map(async (project) => ({
+      project: project.name, path: project.path, ...await resolveModelRoles(project.path),
+    }))),
   };
 }