taskchef 8.4.2 → 8.5.1

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

@@ -154,6 +154,8 @@ test("Settings uses the same capped content layout as List", () => {
   const { container } = render(<DashboardApp connect={false} />);
   const settingsPage = container.querySelector(".taskchef-settings-page");
   expect(settingsPage).toHaveClass("taskchef-content");
+  expect(container.querySelector(".taskchef-header")).not.toHaveClass("taskchef-list-layout");
+  expect(container.querySelector(".taskchef-main")).not.toHaveClass("taskchef-list-layout");
   expect(within(settingsPage as HTMLElement).getByRole("link", { name: "Back to tasks" })).toBeInTheDocument();
   window.location.hash = "";
 });
@@ -208,6 +210,8 @@ test("places the filtered task count below the toolbar and updates it from live
   const summary = document.querySelector<HTMLElement>(".taskchef-results-summary");
   const taskList = screen.getByRole("region", { name: "Tasks" });
 
+  expect(header.querySelector(".taskchef-header")).toHaveClass("taskchef-list-layout");
+  expect(document.querySelector(".taskchef-main")).toHaveClass("taskchef-list-layout");
   expect(projectFilter).toHaveValue("Another project");
   expect(screen.getByRole("combobox", { name: "Updated" })).toHaveValue("All time");
   expect(toolbar?.firstElementChild?.firstElementChild).toContainElement(viewSwitch);
@@ -248,6 +252,8 @@ test("Board ignores the List status filter and restores it on return", () => {
   render(<DashboardApp connect={false} initialFilters={{ status: "completed" }} initialTasks={tasks} />);
   expect(screen.getByRole("radio", { name: /Completed/ })).toBeChecked();
   fireEvent.click(screen.getByRole("radio", { name: "Board" }));
+  expect(document.querySelector(".taskchef-header")).not.toHaveClass("taskchef-list-layout");
+  expect(document.querySelector(".taskchef-main")).not.toHaveClass("taskchef-list-layout");
   const toolbar = document.querySelector<HTMLElement>(".taskchef-toolbar");
   expect(toolbar?.firstElementChild?.firstElementChild).toContainElement(screen.getByRole("radiogroup", { name: "View" }));
   expect(screen.getByRole("radiogroup", { name: "View" }).compareDocumentPosition(screen.getByRole("combobox", { name: "Project" })) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
@@ -256,6 +262,8 @@ test("Board ignores the List status filter and restores it on return", () => {
   expect(screen.getByRole("region", { name: "Task board" })).toHaveTextContent("Working task");
   expect(screen.getByRole("region", { name: "Task board" })).toHaveTextContent("Completed task");
   fireEvent.click(screen.getByRole("radio", { name: "List" }));
+  expect(document.querySelector(".taskchef-header")).toHaveClass("taskchef-list-layout");
+  expect(document.querySelector(".taskchef-main")).toHaveClass("taskchef-list-layout");
   expect(screen.getByRole("radio", { name: /Completed/ })).toBeChecked();
   expect(screen.getByText("Tasks: 1 of 2")).toBeInTheDocument();
 });

package/src/dashboard/react/App.tsx

@@ -239,6 +239,7 @@ export function DashboardApp({
   const visible = useMemo(() => filterTasks(tasks, { project, status, date, now }), [tasks, project, status, date, now]);
   const boardTasks = useMemo(() => filterTasks(tasks, { project, date, now }), [tasks, project, date, now]);
   const board = preferredView === "board";
+  const listLayout = !board && !settings;
   const counts = useMemo(() => statusFilterCounts(tasks, { project, date, now }), [tasks, project, date, now]);
   const statusData = STATUS_FILTERS.map(({ label, value }: { label: string; value: string }) => ({
     label: counts[value] > 0 ? `${label} ${counts[value]}` : label,
@@ -322,7 +323,7 @@ export function DashboardApp({
       <RelativeTimeProvider now={now}>
       <AppShell className="taskchef-shell" padding={0}>
         <Box className="taskchef-header-shell" component="header">
-          <Container className={`taskchef-header${board ? " taskchef-header-board" : ""}`} size="100%">
+          <Container className={`taskchef-header${board ? " taskchef-header-board" : ""}${listLayout ? " taskchef-list-layout" : ""}`} size="100%">
             <Group className="taskchef-header-layout" justify="space-between" wrap="nowrap">
               <Group className="taskchef-header-copy" gap="xs" wrap="nowrap">
                 <BrandIcon />
@@ -344,7 +345,7 @@ export function DashboardApp({
         </Box>
 
         <AppShell.Main>
-          <Container className={`taskchef-main${board ? " taskchef-main-board" : ""}`} pb={80} size="100%">
+          <Container className={`taskchef-main${board ? " taskchef-main-board" : ""}${listLayout ? " taskchef-list-layout" : ""}`} pb={80} size="100%">
             {projectIndex?.status === "unavailable" && (
               <Alert color="yellow" icon={<IconAlertTriangle size={18} />} mb="md" title="Project index unavailable">
                 Task history is still visible. Verify the index and inspect backups before making project changes.

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

@@ -186,7 +186,7 @@ export function TaskDetail({
       opened={opened}
       overlayProps={{ backgroundOpacity: 0.55, blur: 2 }}
       scrollAreaComponent={ScrollArea.Autosize}
-      size="min(820px, calc(100vw - 32px))"
+      size="min(600px, calc(100vw - 32px))"
       title={<span className="taskchef-visually-hidden">Task details</span>}
       trapFocus
       zIndex={300}

package/src/dashboard/react/styles.css

@@ -30,6 +30,7 @@ body {
 .taskchef-version { margin-inline-start: 0.45rem; color: var(--taskchef-muted); font-size: 0.78em; font-weight: 600; letter-spacing: 0; text-transform: none; }
 .taskchef-brand-icon, .taskchef-brand-icon img { display: block; flex: none; width: 28px; height: 28px; }
 .taskchef-main { max-width: var(--taskchef-page-max-width); padding-top: 8px; padding-inline: var(--taskchef-page-gutter); }
+.taskchef-list-layout { --taskchef-content-max-width: 600px; max-width: calc(var(--taskchef-content-max-width) + 2 * var(--taskchef-page-gutter)); }
 .taskchef-content { width: 100%; max-width: var(--taskchef-content-max-width); }
 .taskchef-toolbar { max-width: none; margin-bottom: 22px; padding: 8px 0 var(--mantine-spacing-md); border: 0; border-bottom: 1px solid var(--taskchef-border); background: transparent; box-shadow: none; }
 .taskchef-toolbar-filters { width: min(100%, 488px); min-width: 0; }

package/src/github.js

@@ -74,8 +74,9 @@ export function normalizeGithubRepositories(
   return repositories;
 }
 
-export function matchProjectForGithubUrl(value, projects) {
+export function matchProjectForGithubUrl(value, projects, routingHints = []) {
   if (!Array.isArray(projects)) throw new Error("projects must be an array");
+  if (!Array.isArray(routingHints)) throw new Error("routingHints must be an array");
   let parsed;
   try {
     parsed = parseGithubUrl(value, "GitHub URL", { allowIssueOrPull: true });
@@ -84,15 +85,17 @@ export function matchProjectForGithubUrl(value, projects) {
   }
   const repository = `https://github.com/${parsed.owner}/${parsed.repository}`;
   const key = repository.toLowerCase();
-  const matches = projects.filter((project) =>
-    Array.isArray(project?.githubRepos)
-    && project.githubRepos.some((candidate) => {
+  const matches = projects.filter((project) => {
+    const learned = routingHints.find((hint) => hint?.path === project?.path)?.githubRepos ?? [];
+    return [...(Array.isArray(project?.githubRepos) ? project.githubRepos : []), ...learned]
+      .some((candidate) => {
       try {
         return canonicalGithubRepository(candidate).toLowerCase() === key;
       } catch {
         return false;
       }
-    }));
+    });
+  });
   if (matches.length === 1) {
     return { status: "matched", repository, project: matches[0], projects: matches };
   }

package/src/mcp.js

@@ -8,7 +8,10 @@ import {
   reportTaskState,
   reportTaskResult,
   dashboardAutostartEnabled,
+  includeProject,
   readConfig,
+  reconcileProjects,
+  updateProjectHint,
 } from "./workspace.js";
 import { parseTaskChefMarker } from "./delegation.js";
 import { createDashboardManager } from "./dashboard-manager.js";
@@ -105,6 +108,60 @@ const preparationSchema = z.object({
   modelRoles: z.record(z.string(), z.unknown()).optional(),
   projectCount: z.number(),
   projects: z.array(projectSchema),
+  routingHints: z.array(z.object({
+    path: z.string(),
+    aliases: z.array(z.string()),
+    githubRepos: z.array(z.string()),
+    responsibilities: z.array(z.string()),
+  })).optional(),
+});
+
+const nativeProjectSnapshotSchema = z.object({
+  schemaVersion: z.literal(2),
+  projects: z.array(z.object({
+    projectId: z.string().min(1),
+    projectKind: z.string().min(1),
+    label: z.string().min(1),
+    path: z.string().nullable().optional(),
+    hostId: z.string().nullable().optional(),
+    hostDisplayName: z.string().nullable().optional(),
+    isGitRepository: z.boolean().nullable().optional(),
+  }).passthrough()),
+}).passthrough();
+
+const routingProvenanceSchema = z.object({
+  kind: z.enum(["explicit_user", "verified_repository", "accepted_terminal_report"]),
+  evidence: z.string().min(1).max(240),
+  taskId: z.string().min(1).nullable(),
+  threadId: z.string().min(1).nullable(),
+  turnRef: z.string().min(1).max(256).nullable(),
+  repositoryPath: z.string().min(1).nullable(),
+});
+
+const reconciliationSchema = z.object({
+  schemaVersion: z.literal(1),
+  changed: z.boolean(),
+  projectCount: z.number().int().nonnegative(),
+  addedCount: z.number().int().nonnegative(),
+  boundCount: z.number().int().nonnegative(),
+  available: z.array(z.object({
+    hostId: z.string(),
+    projectId: z.string(),
+    path: z.string(),
+  })),
+  diagnostics: z.array(z.object({
+    projectId: z.string(),
+    code: z.string(),
+    message: z.string(),
+  })),
+});
+
+const hintUpdateSchema = z.object({
+  changed: z.boolean(),
+  suppressed: z.boolean(),
+  project: z.string(),
+  kind: z.enum(["alias", "githubRepo", "responsibility"]),
+  value: z.string(),
 });
 
 const dashboardSchema = z.object({
@@ -166,6 +223,9 @@ export function createTaskChefMcpServer({
   reportResult = reportTaskResult,
   reportState = reportTaskState,
   link = linkTask,
+  reconcile = reconcileProjects,
+  updateHint = updateProjectHint,
+  include = includeProject,
   dashboardManager = createDashboardManager({ workspace }),
   readConfiguration = readConfig,
   logDashboardDiagnostic,
@@ -223,6 +283,75 @@ export function createTaskChefMcpServer({
     },
   );
 
+  server.registerTool(
+    "reconcile_projects",
+    {
+      title: "Reconcile TaskChef projects",
+      description:
+        "Atomically reconcile an agent-supplied native Codex list_projects schema-2 snapshot into the local TaskChef project index. Only eligible local projects on hostId local are considered; existing curated metadata and missing entries are preserved.",
+      inputSchema: { snapshot: nativeProjectSnapshotSchema },
+      outputSchema: { reconciliation: reconciliationSchema },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+      },
+    },
+    async ({ snapshot }) => {
+      const result = await reconcile(workspace, snapshot);
+      const reconciliation = {
+        schemaVersion: 1,
+        changed: result.changed,
+        projectCount: result.projectCount,
+        addedCount: result.added.length,
+        boundCount: result.bound.length,
+        available: result.available,
+        diagnostics: result.diagnostics,
+      };
+      return toolResult(
+        "reconciliation",
+        reconciliation,
+        `Reconciled ${reconciliation.projectCount} TaskChef project(s).`,
+      );
+    },
+  );
+
+  server.registerTool(
+    "include_project",
+    {
+      title: "Include a previously excluded TaskChef project",
+      description:
+        "Remove an explicit reconciliation exclusion by exact local native projectId or canonical path. Reconciliation must run afterward before the project becomes a routing target again.",
+      inputSchema: {
+        projectId: z.string().min(1).optional(),
+        path: z.string().min(1).optional(),
+      },
+      outputSchema: {
+        result: z.object({ changed: z.boolean(), remainingExclusionCount: z.number().int().nonnegative() }),
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+      },
+    },
+    async ({ projectId, path: projectPath }) => {
+      if (Boolean(projectId) === Boolean(projectPath)) {
+        throw new Error("include_project requires exactly one projectId or path");
+      }
+      const updated = await include(workspace, projectId
+        ? { projectId, hostId: "local" }
+        : { path: projectPath });
+      const result = {
+        changed: updated.changed,
+        remainingExclusionCount: updated.exclusions.length,
+      };
+      return toolResult("result", result, result.changed
+        ? "Removed the TaskChef project exclusion."
+        : "No matching TaskChef project exclusion exists.");
+    },
+  );
+
   server.registerTool(
     "prepare_dispatch",
     {
@@ -243,6 +372,43 @@ export function createTaskChefMcpServer({
     },
   );
 
+  server.registerTool(
+    "update_project_hint",
+    {
+      title: "Remember or forget TaskChef project routing",
+      description:
+        "Remember or forget one bounded routing fact for an exact configured project. Aliases and forgetting require explicit user evidence; repository ownership requires verified origin evidence; report-derived responsibilities require the accepted current terminal task/turn identity.",
+      inputSchema: {
+        action: z.enum(["remember", "correct", "forget"]),
+        project: z.string().min(1),
+        kind: z.enum(["alias", "githubRepo", "responsibility"]),
+        value: z.string().min(1).max(256),
+        provenance: routingProvenanceSchema,
+      },
+      outputSchema: { result: hintUpdateSchema },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (input) => {
+      const updated = await updateHint(workspace, input);
+      const result = {
+        changed: updated.changed,
+        suppressed: updated.suppressed,
+        project: updated.project,
+        kind: updated.kind,
+        value: updated.value,
+      };
+      return toolResult(
+        "result",
+        result,
+        `${result.changed ? "Updated" : "Kept"} TaskChef project routing.`,
+      );
+    },
+  );
+
   server.registerTool(
     "record_task",
     {