taskchef 5.9.0 → 5.11.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "5.9.0",
+  "version": "5.11.0",
   "description": "Dispatch work from a data-only workspace to visible Codex project tasks.",
   "author": {
     "name": "Favo Yang",

package/README.md

@@ -181,11 +181,12 @@ terminal to stop the server.
 The dashboard:
 
 - orders tasks by their latest semantic or identity update;
-- filters by project and status;
+- filters by project, status, and latest update window (24 hours, 7 days, or
+  all time);
 - shows dismissible notifications when tasks are added or changed;
 - reveals the original instruction, latest semantic result, and task metadata;
-- opens a task's project in Codex on request, while preserving the recorded
-  thread ID for manual task selection.
+- opens the recorded task directly in Codex when it has a supported UUID thread
+  ID, with a project-opening fallback for unresolved or legacy identities.
 
 The server binds only to the numeric IPv4 loopback interface, requires the
 unguessable launch capability before serving instructions or results, validates
@@ -200,14 +201,26 @@ the server or browser, the dashboard rejects logs above 16 MiB, histories above
 2,000 tasks, and unusually large display fields while retaining the last valid
 snapshot. The data CLI remains unaffected by these display limits.
 
-Direct desktop navigation to a recorded thread is not exposed by the supported
-`codex app` CLI, which accepts only a workspace path. A task-level refresh would
-require native Codex metadata tools that are available to the report skill, not
-to a standalone browser page. TaskChef also does not submit replies from the
-dashboard: `codex resume <session> [prompt]` starts an interactive CLI session
-and may execute the prompt immediately, rather than opening a reviewed draft in
-the desktop app. These integrations remain deferred until Codex provides a
-stable task deep link or explicit draft handoff.
+Date windows advance while the page is open, even when the task file is idle.
+They use persisted semantic/identity timestamps and identity changes observed by
+the current server. Legacy schema-v1 identity resolutions did not record an
+update timestamp, so after a dashboard restart those rare historical records
+fall back to their creation time.
+
+The dashboard uses Codex's registered `codex://threads/<thread-id>` desktop
+route for direct navigation. A task-level refresh would require native Codex
+metadata tools that are available to the report skill, not to a standalone
+browser page. TaskChef also does not submit replies from the dashboard: `codex
+resume <session> [prompt]` starts an interactive CLI session and may execute the
+prompt immediately, rather than opening a reviewed draft in the desktop app.
+Refresh and reply integrations remain deferred until Codex exposes supported
+browser-facing contracts for those actions.
+
+TaskChef task records do not contain model token usage, and the supported Codex
+task metadata surface does not expose it to this local server. The dashboard
+therefore does not estimate tokens or inspect private Codex session logs. Token
+usage can be added later if Codex exposes a supported per-task usage field or
+TaskChef executors begin reporting a structured usage value.
 
 ### Manage configured projects
 

package/index.js

@@ -56,6 +56,8 @@ export {
 
 export {
   discoverCodexCli,
+  isCodexThreadDeepLinkId,
+  openThreadInCodex,
   openWorkspaceInCodex,
 } from "./src/codex-app.js";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "5.9.0",
+  "version": "5.11.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",

package/src/codex-app.js

@@ -5,6 +5,7 @@ import { promisify } from "node:util";
 
 const execFile = promisify(execFileCallback);
 const CODEX_COMMAND_TIMEOUT_MS = 10_000;
+const CODEX_THREAD_ID_PATTERN = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
 
 function runCodex(run, filePath, args) {
   return run(filePath, args, { timeout: CODEX_COMMAND_TIMEOUT_MS, killSignal: "SIGKILL" });
@@ -26,6 +27,10 @@ function pathCandidates(env) {
     .map((directory) => path.join(directory, process.platform === "win32" ? "codex.exe" : "codex"));
 }
 
+function isDesktopBundleCandidate(filePath) {
+  return filePath.includes(`${path.sep}Contents${path.sep}Resources${path.sep}`);
+}
+
 async function supportsAppCommand(filePath, run) {
   try {
     const { stdout, stderr } = await runCodex(run, filePath, ["app", "--help"]);
@@ -50,8 +55,16 @@ export async function discoverCodexCli({
     return { path: candidate, source: explicit !== null ? "explicit" : "environment" };
   }
 
+  const candidates = pathCandidates(env);
+  for (const pathCandidate of candidates.filter(isDesktopBundleCandidate)) {
+    const candidate = await executable(pathCandidate);
+    if (candidate && await supportsAppCommand(candidate, run)) {
+      return { path: candidate, source: "desktop-path" };
+    }
+  }
+
   let candidate = null;
-  for (const pathCandidate of pathCandidates(env)) {
+  for (const pathCandidate of candidates) {
     candidate = await executable(pathCandidate);
     if (candidate) break;
   }
@@ -59,8 +72,7 @@ export async function discoverCodexCli({
   if (!(await supportsAppCommand(candidate, run))) {
     throw new Error(`Codex CLI does not support the app command: ${candidate}`);
   }
-  const bundled = candidate.includes(`${path.sep}Contents${path.sep}Resources${path.sep}`);
-  return { path: candidate, source: bundled ? "desktop-path" : "path" };
+  return { path: candidate, source: "path" };
 }
 
 export async function openWorkspaceInCodex(workspace, options = {}) {
@@ -75,3 +87,24 @@ export async function openWorkspaceInCodex(workspace, options = {}) {
     workspace,
   };
 }
+
+export function isCodexThreadDeepLinkId(threadId) {
+  return typeof threadId === "string" && CODEX_THREAD_ID_PATTERN.test(threadId);
+}
+
+export async function openThreadInCodex(threadId, options = {}) {
+  if (!isCodexThreadDeepLinkId(threadId)) {
+    throw new Error("Codex thread ID is not supported by the desktop deep link");
+  }
+  const run = options.run ?? execFile;
+  const platform = options.platform ?? process.platform;
+  const url = `codex://threads/${encodeURIComponent(threadId)}`;
+  if (platform === "darwin") {
+    await runCodex(run, "/usr/bin/open", [url]);
+  } else if (platform === "win32") {
+    await runCodex(run, "rundll32.exe", ["url.dll,FileProtocolHandler", url]);
+  } else {
+    await runCodex(run, "xdg-open", [url]);
+  }
+  return { status: "requested", mechanism: "codex-deep-link", threadId, url };
+}

package/src/dashboard/app.js

@@ -1,6 +1,11 @@
 import {
   findCurrentTask,
+  KNOWN_TASK_STATUSES,
+  nextDateFilterRefreshDelay,
+  notificationTitle,
   reconcileNotifications,
+  taskStatusLabel,
+  taskWithinDateFilter,
 } from "./state.js";
 
 const state = {
@@ -10,6 +15,7 @@ const state = {
   initialized: false,
   selectedTask: null,
 };
+let dateRefreshTimer = null;
 
 const elements = {
   clearNotifications: document.querySelector("#clear-notifications"),
@@ -18,6 +24,7 @@ const elements = {
   connectionLabel: document.querySelector("#connection-label"),
   copyThreadId: document.querySelector("#copy-thread-id"),
   dashboardMessage: document.querySelector("#dashboard-message"),
+  dateFilter: document.querySelector("#date-filter"),
   dialog: document.querySelector("#task-dialog"),
   dialogInstruction: document.querySelector("#dialog-instruction"),
   dialogMetadata: document.querySelector("#dialog-metadata"),
@@ -26,7 +33,7 @@ const elements = {
   dialogTitle: document.querySelector("#dialog-title"),
   emptyState: document.querySelector("#empty-state"),
   notifications: document.querySelector("#notifications"),
-  openProject: document.querySelector("#open-project"),
+  openProject: document.querySelector("#open-codex"),
   projectFilter: document.querySelector("#project-filter"),
   statusFilter: document.querySelector("#status-filter"),
   taskCount: document.querySelector("#task-count"),
@@ -34,10 +41,6 @@ const elements = {
   toastList: document.querySelector("#toast-list"),
 };
 
-function statusLabel(task) {
-  return task.status === null ? "unresolved" : task.status.replaceAll("_", " ");
-}
-
 function formatTime(value) {
   if (!value) return "—";
   return new Intl.DateTimeFormat(undefined, {
@@ -76,9 +79,9 @@ function notificationToast(notification) {
   text.type = "button";
   text.className = "toast-content";
   const title = document.createElement("strong");
-  title.textContent = notification.kind === "new" ? "New task" : "Task updated";
+  title.textContent = notificationTitle(task, notification.kind);
   const description = document.createElement("span");
-  description.textContent = `${task.title} · ${statusLabel(task)}`;
+  description.textContent = `${task.title} · ${taskStatusLabel(task)}`;
   text.append(title, description);
   text.addEventListener("click", () => {
     const current = findCurrentTask(state.tasks, notification.taskId);
@@ -121,13 +124,15 @@ function openDialog(task) {
   elements.dialogInstruction.textContent = task.instruction;
   elements.copyThreadId.disabled = !task.threadId;
   elements.dialogMetadata.replaceChildren(
-    ...detailRow("Status", statusLabel(task)),
+    ...detailRow("Status", taskStatusLabel(task)),
     ...detailRow("Task ID", task.id),
     ...detailRow("Thread ID", task.threadId),
     ...detailRow("Turn ID", task.turnId),
     ...detailRow("Project path", task.project.path),
     ...detailRow("Created", formatTime(task.createdAt)),
-    ...detailRow("Updated", formatTime(task.updatedAt ?? task.createdAt)),
+    ...detailRow("Updated", formatTime(
+      task.meaningfulUpdatedAt ?? task.updatedAt ?? task.createdAt,
+    )),
     ...detailRow("Updated by", task.updatedBy),
   );
   if (!elements.dialog.open) elements.dialog.showModal();
@@ -145,7 +150,7 @@ function taskCard(task) {
   title.addEventListener("click", () => openDialog(task));
   const badge = document.createElement("span");
   badge.className = `status status-${task.status ?? "unresolved"}`;
-  badge.textContent = statusLabel(task);
+  badge.textContent = taskStatusLabel(task);
   heading.append(title, badge);
   const project = document.createElement("p");
   project.className = "task-project";
@@ -154,8 +159,8 @@ function taskCard(task) {
   summary.className = "task-summary";
   summary.textContent = task.summary ?? "No semantic result reported yet.";
   const time = document.createElement("time");
-  time.dateTime = task.updatedAt ?? task.createdAt;
-  time.textContent = `Updated ${formatTime(task.updatedAt ?? task.createdAt)}`;
+  time.dateTime = task.meaningfulUpdatedAt ?? task.updatedAt ?? task.createdAt;
+  time.textContent = `Updated ${formatTime(time.dateTime)}`;
   article.append(heading, project, summary, time);
   return article;
 }
@@ -163,12 +168,17 @@ function taskCard(task) {
 function render() {
   const project = elements.projectFilter.value;
   const status = elements.statusFilter.value;
+  const date = elements.dateFilter.value;
   const visible = state.tasks.filter((task) =>
     (!project || task.project.name === project)
-    && (!status || statusLabel(task) === status));
+    && (!status || taskStatusLabel(task) === status)
+    && taskWithinDateFilter(task, date));
   elements.taskList.replaceChildren(...visible.map(taskCard));
   elements.emptyState.hidden = visible.length > 0;
   elements.taskCount.textContent = `${visible.length} of ${state.tasks.length} task${state.tasks.length === 1 ? "" : "s"}`;
+  clearTimeout(dateRefreshTimer);
+  const refreshDelay = nextDateFilterRefreshDelay(visible, date);
+  dateRefreshTimer = refreshDelay === null ? null : setTimeout(render, refreshDelay);
 }
 
 function applySnapshot(snapshot) {
@@ -193,7 +203,7 @@ function applySnapshot(snapshot) {
   );
   replaceOptions(
     elements.statusFilter,
-    [...new Set(state.tasks.map(statusLabel))].sort(),
+    [...new Set([...KNOWN_TASK_STATUSES, ...state.tasks.map(taskStatusLabel)])],
     "All statuses",
   );
   if (state.selectedTask) {
@@ -222,6 +232,7 @@ events.addEventListener("dashboard-error", (event) => {
 
 elements.projectFilter.addEventListener("change", render);
 elements.statusFilter.addEventListener("change", render);
+elements.dateFilter.addEventListener("change", render);
 elements.clearNotifications.addEventListener("click", () => {
   state.notifications = [];
   renderNotifications();
@@ -244,7 +255,7 @@ elements.openProject.addEventListener("click", async () => {
   if (!state.selectedTask) return;
   elements.openProject.disabled = true;
   try {
-    const response = await fetch(`/api/tasks/${encodeURIComponent(state.selectedTask.id)}/open-project`, {
+    const response = await fetch(`/api/tasks/${encodeURIComponent(state.selectedTask.id)}/open-codex`, {
       method: "POST",
     });
     const result = await response.json();

package/src/dashboard/index.html

@@ -35,6 +35,14 @@
             <option value="">All statuses</option>
           </select>
         </label>
+        <label>
+          Updated
+          <select id="date-filter">
+            <option value="24h">Latest 24 hours</option>
+            <option value="7d">Latest 7 days</option>
+            <option value="all" selected>All time</option>
+          </select>
+        </label>
         <p id="task-count" class="task-count" aria-live="polite"></p>
       </section>
 
@@ -66,7 +74,7 @@
         <button id="close-dialog" class="icon-button" type="button" aria-label="Close task details">×</button>
       </div>
       <div class="dialog-actions">
-        <button id="open-project" class="primary-button" type="button">Open project in Codex</button>
+        <button id="open-codex" class="primary-button" type="button">Open task in Codex</button>
         <button id="copy-thread-id" class="secondary-button" type="button">Copy thread ID</button>
       </div>
       <section>

package/src/dashboard/state.js

@@ -1,4 +1,47 @@
 export const MAX_NOTIFICATIONS = 50;
+export const KNOWN_TASK_STATUSES = [
+  "working",
+  "needs input",
+  "completed",
+  "failed",
+  "unresolved",
+];
+
+const DATE_WINDOWS_MS = new Map([
+  ["24h", 24 * 60 * 60 * 1_000],
+  ["7d", 7 * 24 * 60 * 60 * 1_000],
+  ["all", null],
+]);
+
+function taskMeaningfulTime(task) {
+  return Date.parse(task.meaningfulUpdatedAt ?? task.updatedAt ?? task.createdAt);
+}
+
+export function taskStatusLabel(task) {
+  return task.status === null ? "unresolved" : task.status.replaceAll("_", " ");
+}
+
+export function notificationTitle(task, kind) {
+  return kind === "new" ? "New task" : `Task ${taskStatusLabel(task)}`;
+}
+
+export function taskWithinDateFilter(task, filter, now = Date.now()) {
+  const windowMs = DATE_WINDOWS_MS.get(filter);
+  if (windowMs === null) return true;
+  if (windowMs === undefined) return false;
+  const meaningfulTime = taskMeaningfulTime(task);
+  return Number.isFinite(meaningfulTime) && meaningfulTime >= now - windowMs;
+}
+
+export function nextDateFilterRefreshDelay(tasks, filter, now = Date.now()) {
+  const windowMs = DATE_WINDOWS_MS.get(filter);
+  if (windowMs === null || windowMs === undefined) return null;
+  const nextCutoff = tasks
+    .map((task) => taskMeaningfulTime(task) + windowMs - now)
+    .filter((delay) => Number.isFinite(delay) && delay >= 0)
+    .reduce((minimum, delay) => Math.min(minimum, delay), Number.POSITIVE_INFINITY);
+  return Number.isFinite(nextCutoff) ? nextCutoff + 1 : null;
+}
 
 export function taskSignature(task) {
   return JSON.stringify([

package/src/dashboard.js

@@ -6,7 +6,11 @@ import http from "node:http";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { openWorkspaceInCodex } from "./codex-app.js";
+import {
+  isCodexThreadDeepLinkId,
+  openThreadInCodex,
+  openWorkspaceInCodex,
+} from "./codex-app.js";
 import {
   canonicalDirectory,
   canonicalGitRoot,
@@ -184,7 +188,12 @@ export class DashboardMonitor extends EventEmitter {
       revision: this.revision,
       generatedAt: new Date().toISOString(),
       healthy: !this.unhealthy,
-      tasks: this.tasks,
+      tasks: this.tasks.map((task) => ({
+        ...task,
+        meaningfulUpdatedAt: new Date(
+          meaningfulUpdateTime(task, this.observedUpdateTimes),
+        ).toISOString(),
+      })),
     };
   }
 
@@ -395,6 +404,7 @@ export async function createDashboardServer({
   port = 3210,
   monitorOptions = {},
   openProject = null,
+  openThread = null,
 } = {}) {
   if (!LOOPBACK_HOSTS.has(host)) {
     throw new Error("dashboard host must be a loopback address");
@@ -501,7 +511,7 @@ export async function createDashboardServer({
       return;
     }
 
-    const taskMatch = url.pathname.match(/^\/api\/tasks\/([a-zA-Z0-9._-]+)\/open-project$/);
+    const taskMatch = url.pathname.match(/^\/api\/tasks\/([a-zA-Z0-9._-]+)\/open-codex$/);
     if (taskMatch && method === "POST") {
       if (request.headers.origin !== allowedOrigin) {
         sendJson(response, 403, { message: "Dashboard session validation failed." });
@@ -513,6 +523,12 @@ export async function createDashboardServer({
         return;
       }
       try {
+        if (isCodexThreadDeepLinkId(task.threadId)) {
+          if (openThread) await openThread(task.threadId);
+          else await openThreadInCodex(task.threadId);
+          sendJson(response, 202, { message: "Opened this task in Codex." });
+          return;
+        }
         const trustedProject = (await readConfig(monitor.workspace, { checkPaths: false })).projects
           .find((project) => project.path === task.project.path);
         if (!trustedProject) {
@@ -533,11 +549,13 @@ export async function createDashboardServer({
         if (openProject) await openProject(canonicalProjectPath);
         else await openWorkspaceInCodex(canonicalProjectPath);
         sendJson(response, 202, {
-          message: "Opened the project in Codex. Select the recorded task there.",
+          message: task.threadId
+            ? "Opened the project in Codex; this legacy thread ID cannot use direct navigation."
+            : "Opened the project in Codex; this task does not yet have a thread ID.",
         });
       } catch {
         sendJson(response, 503, {
-          message: "Codex could not be opened. Run codex app with the project path instead.",
+          message: "Codex could not be opened. Open the project and select the recorded thread instead.",
         });
       }
       return;