taskchef 5.1.0 → 5.1.1

package/.codex-plugin/plugin.json

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

package/SPEC.md

@@ -196,10 +196,12 @@ For each assignment, `$taskchef-delegate`:
    marked entry with `threadId: null`, then prefers one native client-ID wait or
    resolution call with a 30-second timeout when Codex exposes one
 7. when no native operation is available, takes at most two recent-thread
-   snapshots near 10 and 30 seconds after the provisional result, filters
-   candidates by available host/project/time/worktree metadata, uses title only
-   as an advisory ordering hint, and accepts only one thread whose structured
-   delegated input starts with the exact marker
+   snapshots on a nominal 10- and 30-second schedule after the provisional
+   result; a late first checkpoint runs immediately, and the second starts at
+   least 20 seconds after the first actually started. It filters candidates by
+   available host/project/time/worktree metadata, uses title only as an advisory
+   ordering hint, and accepts only one thread whose structured delegated input
+   starts with the exact marker
 8. atomically fills the nullable thread ID after an exact match
 9. returns after recording or after reporting that bounded resolution was
    unresolved, without waiting for executor work completion.
@@ -209,11 +211,13 @@ Creation-time filtering allows five seconds of clock skew. Candidate reads run
 concurrently where the host permits and inspect only structured
 `codexDelegation.input`, never untrusted title, summary, preview, or plain-text
 marker echoes. A native resolver result is verified against the same structured
-marker before persistence. Zero exact matches time out unresolved; multiple
-exact matches are ambiguous. Snapshot, candidate-read, native-resolution, or
-task-resolution errors leave the already-recorded nullable entry intact. No
-snapshot, candidate read, marker verification, or task-resolution write starts
-after the 30-second deadline, so tool latency can reduce the number of attempts.
+marker before persistence. Zero exact matches remain unresolved; multiple exact
+matches are ambiguous. Snapshot, candidate-read, native-resolution, or
+task-resolution errors leave the already-recorded nullable entry intact. The
+fallback is bounded by two snapshots rather than an absolute wall-clock cutoff:
+mandatory recording or tool latency can shift both attempts later, but cannot
+erase an attempt or reduce the minimum 20-second interval between their start
+times.
 A `clientThreadId`, `pendingWorktreeId`, or ID in the documented provisional
 `local:` namespace remains diagnostic context and is rejected from every path
 that could persist the canonical `threadId` field.

package/package.json

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

package/skills/taskchef-delegate/SKILL.md

@@ -82,10 +82,14 @@ for all deterministic workspace and task-record operations.
      ID, call it exactly once with a timeout of at most 30 seconds. Do not invent
      an operation or pass the provisional ID to tools that require `threadId`.
    - When no native operation is available, take at most two `list_threads`
-     snapshots with limit 50, near 10 and 30 seconds after the provisional
-     result. Count tool latency against the 30-second deadline. Do not start a
-     snapshot, candidate read, marker verification, or task-resolution write
-     after it.
+     snapshots with limit 50. The nominal schedule is 10 and 30 seconds after
+     the provisional result. Treat the first checkpoint as due, not expired: if
+     nullable recording or other required work finishes after 10 seconds, take
+     the first snapshot immediately. Start the second snapshot no sooner than
+     20 seconds after the first snapshot actually started. Useful candidate
+     work counts toward that interval; when it finishes sooner, wait only the
+     remainder. Never suppress either snapshot merely because an earlier step
+     ran late, and never take a third snapshot.
    - Filter Codex candidates by the expected host, project, creation time
      (allow five seconds of clock skew), and worktree environment whenever
      those fields are present. Use the title only to prioritize reads; Codex

package/src/delegation.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 
-export const THREAD_RESOLUTION_CHECKPOINTS_MS = Object.freeze([10_000, 29_000]);
+export const THREAD_RESOLUTION_CHECKPOINTS_MS = Object.freeze([10_000, 30_000]);
 export const THREAD_RESOLUTION_TIMEOUT_MS = 30_000;
 export const THREAD_RESOLUTION_RECENT_LIMIT = 50;
 export const THREAD_RESOLUTION_CLOCK_SKEW_MS = 5_000;
@@ -179,6 +179,9 @@ function validateResolutionSchedule(checkpointsMs, timeoutMs) {
   if (!Array.isArray(checkpointsMs) || checkpointsMs.length === 0) {
     throw new Error("checkpointsMs must contain at least one checkpoint");
   }
+  if (checkpointsMs.length > 2) {
+    throw new Error("checkpointsMs must contain at most two checkpoints");
+  }
   if (!Number.isInteger(timeoutMs) || timeoutMs < 1) {
     throw new Error("timeoutMs must be positive");
   }
@@ -189,6 +192,9 @@ function validateResolutionSchedule(checkpointsMs, timeoutMs) {
     }
     previous = checkpoint;
   }
+  if (checkpointsMs.length === 2 && checkpointsMs[1] - checkpointsMs[0] < 20_000) {
+    throw new Error("checkpointsMs must keep two checkpoints at least 20000ms apart");
+  }
 }
 
 async function inspectCandidates(candidates, {
@@ -365,7 +371,11 @@ export async function createAndRecordDelegation({
     return false;
   };
 
-  const acceptResolvedThread = async (thread, resolution, attempt, { verified = false } = {}) => {
+  const acceptResolvedThread = async (thread, resolution, attempt, {
+    verified = false,
+    enforceDeadline = true,
+  } = {}) => {
+    const canContinue = enforceDeadline ? hasResolutionTime : () => true;
     const threadId = toolIdentifier(thread.id);
     if (
       threadId === null
@@ -381,18 +391,18 @@ export async function createAndRecordDelegation({
       return null;
     }
     const durableThread = { ...thread, id: threadId };
-    if (!hasResolutionTime()) return null;
+    if (!canContinue()) return null;
     if (!verified) {
       const inspected = await inspectCandidates([durableThread], {
         readThread,
         taskId: prepared.id,
         attempt,
-        canVerify: hasResolutionTime,
+        canVerify: canContinue,
       });
       discoveryErrors.push(...inspected.errors);
       if (inspected.exactMatches.length !== 1 || inspected.errors.length > 0) return null;
     }
-    if (!hasResolutionTime()) return null;
+    if (!canContinue()) return null;
     try {
       await resolveRecordedTask({ id: prepared.id, threadId });
     } catch (error) {
@@ -470,12 +480,14 @@ export async function createAndRecordDelegation({
   let exactMatches = [];
   let ambiguousMatches = [];
   let attemptsMade = 0;
+  let previousAttemptStartedAt = resolutionStartedAt;
   for (let index = 0; index < checkpointsMs.length; index += 1) {
     const attempt = index + 1;
-    const checkpointMs = checkpointsMs[index];
-    const elapsedBeforeAttempt = now() - resolutionStartedAt;
-    if (elapsedBeforeAttempt > timeoutMs) break;
-    const remainingDelayMs = checkpointMs - elapsedBeforeAttempt;
+    const intervalMs = index === 0
+      ? checkpointsMs[0]
+      : checkpointsMs[index] - checkpointsMs[index - 1];
+    const dueAt = previousAttemptStartedAt + intervalMs;
+    const remainingDelayMs = dueAt - now();
     if (remainingDelayMs > 0) {
       try {
         await waitImpl(remainingDelayMs);
@@ -488,43 +500,36 @@ export async function createAndRecordDelegation({
         break;
       }
     }
-    if (!hasResolutionTime()) break;
+    previousAttemptStartedAt = now();
     attemptsMade = attempt;
     let candidates = [];
     let attemptFailed = false;
     try {
       const snapshot = await listThreads({ limit: recentLimit });
-      if (hasResolutionTime()) {
-        candidates = filterThreadCandidates(snapshot, {
-          excludedThreadIds: provisionalIds,
-          hostId: expected.hostId ?? null,
-          projectId: expected.projectId ?? target.projectId ?? null,
-          title,
-          createdAfter,
-          environmentType: expected.environmentType ?? target.environment?.type ?? null,
-        });
-      }
+      candidates = filterThreadCandidates(snapshot, {
+        excludedThreadIds: provisionalIds,
+        hostId: expected.hostId ?? null,
+        projectId: expected.projectId ?? target.projectId ?? null,
+        title,
+        createdAfter,
+        environmentType: expected.environmentType ?? target.environment?.type ?? null,
+      });
     } catch (error) {
-      if (hasResolutionTime()) {
-        attemptFailed = true;
-        discoveryErrors.push({
-          attempt,
-          operation: "listThreads",
-          message: error instanceof Error ? error.message : String(error),
-        });
-      }
+      attemptFailed = true;
+      discoveryErrors.push({
+        attempt,
+        operation: "listThreads",
+        message: error instanceof Error ? error.message : String(error),
+      });
     }
-    if (!hasResolutionTime()) break;
     const inspected = await inspectCandidates(candidates, {
       readThread,
       taskId: prepared.id,
       attempt,
-      canVerify: hasResolutionTime,
     });
     exactMatches = inspected.exactMatches;
     discoveryErrors.push(...inspected.errors);
     if (inspected.errors.length > 0) attemptFailed = true;
-    if (!hasResolutionTime()) break;
     if (exactMatches.length > 1) ambiguousMatches = exactMatches;
     if (
       exactMatches.length === 1
@@ -536,7 +541,7 @@ export async function createAndRecordDelegation({
         exactMatches[0],
         "discovered",
         attempt,
-        { verified: true },
+        { verified: true, enforceDeadline: false },
       );
       if (resolved !== null) return resolved;
     }