@galda/cli 0.10.52 → 0.10.54

package/app/index.html

@@ -6894,16 +6894,17 @@ function renderFsTodo(){
   // (only a reply task, which Doing excludes) — it used to vanish from the lane (Masa 2026-07-24).
   // Show it in Doing as a goal row, and stop its old stopped task from lingering under "Needs you".
   const runningTaskGoalIds = new Set(running.filter((t) => !t.reply).map((t) => t.goalId));
-  const resumedGoalIds = new Set(pgoals.filter((g) => g.status === 'running' && g.startedAt).map((g) => g.id));
+  const runningReplyGoalIds = new Set(list.filter((t) => t.reply && t.status === 'running').map((t) => t.goalId));
+  const resumedGoalIds = new Set(runningReplyGoalIds);
   const doingGoals = pgoals.filter((g) => g.status === 'running' && g.startedAt
-    && !runningTaskGoalIds.has(g.id) && !pausedGoalIds.has(g.id));
+    && runningReplyGoalIds.has(g.id) && !runningTaskGoalIds.has(g.id) && !pausedGoalIds.has(g.id));
   // A reply that was OVER the parallel cap (engine PR #342): the goal is 'running'
   // but startedAt is cleared, and its only pending work is a QUEUED reply task —
   // which Doing needs startedAt for, and Next-up excludes (!t.reply). With no
   // bucket it vanished. Surface these "parked" goals at the TOP of To Do ("最上部",
   // Masa 2026-07-24) as Queued rows — not "Working on it" (nothing runs yet). They
   // auto-promote to Doing the moment a slot frees and the engine sets startedAt.
-  const parkedReplyGoals = pgoals.filter((g) => g.status === 'running' && !g.startedAt
+  const parkedReplyGoals = pgoals.filter((g) => g.status === 'running'
     && !pausedGoalIds.has(g.id) && !runningTaskGoalIds.has(g.id)
     && list.some((t) => t.goalId === g.id && t.reply && t.status === 'queued')
     && !list.some((t) => t.goalId === g.id && !t.reply && ['running', 'queued'].includes(t.status)));
@@ -7695,6 +7696,7 @@ const AUTH_REASON_TEXT = {
   'logged-out': 'Not signed in to claude. Run `claude` in a terminal and /login, then relaunch the manager from that terminal — tasks are paused until then.',
   'bad-credentials': 'Worker sign-in failed. Check ANTHROPIC_API_KEY, or run `claude` and /login, then relaunch the manager from that terminal.',
   'probe-failed': 'Couldn’t verify claude sign-in. Ensure the `claude` CLI is installed and signed in, then relaunch the manager.',
+  'rate-limited': 'Claude has reached its usage limit. Claude tasks are queued until access resets; Codex tasks can continue now.',
 };
 function renderAuthBanner(auth){
   const bar = $('errbar');

package/engine/server.mjs

@@ -26,6 +26,7 @@ import { createSerialQueue } from './lib.mjs';
 import { collectProjectRules } from './lib.mjs';
 import { FALLBACK_CODEX_MODELS, loadCodexModels } from './codex-models.mjs';
 import { CLAUDE_MODELS } from './claude-models.mjs';
+import { classifyWorkerPreflight, workerCanStart } from './worker-availability.mjs';
 import { openPR } from './pr.mjs';
 import { runVerification, exerciseUi } from './verify.mjs';
 
@@ -1101,6 +1102,7 @@ function rebuildQueuesAfterAdopt() {
   for (const p of projects) queues.set(p.id, { running: new Set(), waiting: [] });
   for (const p of projects) {
     const pending = tasks.filter((t) => t.projectId === p.id && t.status === 'queued').sort((a, b) => a.num - b.num);
+    reconcileQueuedGoalStarts(p.id);
     queues.get(p.id).waiting.push(...pending);
     pump(p.id);
     for (const g of goals.filter((g) => g.projectId === p.id && g.status === 'stacked')) {
@@ -1110,6 +1112,17 @@ function rebuildQueuesAfterAdopt() {
   }
 }
 
+function reconcileQueuedGoalStarts(projectId) {
+  const projectTasks = tasks.filter((task) => task.projectId === projectId);
+  for (const goal of goals.filter((item) => item.projectId === projectId && item.status === 'running' && item.startedAt)) {
+    const goalTasks = projectTasks.filter((task) => task.goalId === goal.id);
+    if (goalTasks.some((task) => task.status === 'queued') && !goalTasks.some((task) => task.status === 'running')) {
+      goal.startedAt = null;
+      saveGoal(goal);
+    }
+  }
+}
+
 const ACTIVITY_LIMIT = 1000;
 function activityLine(line) {
   return String(line ?? '')
@@ -1470,9 +1483,9 @@ function startNextStacked(projectId) {
 // standalone `claude` (runClaude), inheriting the launching shell's login. If
 // that shell has no usable credentials, every task fails late with "Not logged
 // in". We probe once at boot and hold the queue + raise a banner instead of
-// failing task after task. Optimistic default (ok:true) so we never falsely
-// block a correctly-authed setup during the ~1s probe.
-let workerAuth = { ok: true, reason: null, checkedAt: null };
+// failing task after task. Claude waits for the short probe; Codex is gated
+// independently and may start immediately.
+let workerAuth = { ok: null, reason: null, checkedAt: null };
 const publicAuth = () => ({ ok: workerAuth.ok, reason: workerAuth.reason });
 
 // Boot preflight: one cheap Read-only `claude` call; classify the result (pure,
@@ -1481,14 +1494,18 @@ const publicAuth = () => ({ ok: workerAuth.ok, reason: workerAuth.reason });
 async function probeWorkerAuth() {
   try {
     const out = await runClaude({ prompt: 'Reply with the single word: ok', cwd: ROOT, tools: 'Read', model: 'haiku' });
-    workerAuth = { ...classifyAuthProbe({ result: out?.result, code: out?.code }), checkedAt: Date.now() };
+    workerAuth = {
+      ...classifyWorkerPreflight(out, { classifyAuthProbe, isRateLimited }),
+      checkedAt: Date.now(),
+    };
   } catch {
     workerAuth = { ok: false, reason: 'probe-failed', checkedAt: Date.now() };
   }
   console.log(workerAuth.ok
     ? '[manager] worker auth preflight OK'
-    : `[manager] worker auth preflight FAILED (${workerAuth.reason}) — holding the queue. ${authBannerText(workerAuth.reason, 'en')}`);
+    : `[manager] Claude preflight unavailable (${workerAuth.reason}) — holding Claude tasks; Codex may continue.`);
   send({ ev: 'auth', auth: publicAuth() });
+  if (workerAuth.ok) for (const project of projects) pump(project.id);
   return workerAuth;
 }
 
@@ -1654,10 +1671,8 @@ async function authorVerify(task, goal, project) {
 // `lastStartAt` check in pump() below.
 const slowModeLastStart = new Map(); // projectId -> ms epoch of the last task start
 function pump(projectId) {
-  // Worker auth preflight failed → hold the queue (the UI banner tells the user
-  // to sign `claude` in and relaunch). Never spawn a worker that can only fail
-  // with "Not logged in". Cleared automatically once a probe succeeds.
-  if (!workerAuth.ok) return;
+  // A Claude sign-in or usage hold must not stop an installed Codex worker.
+  // Claude work stays queued until a later probe succeeds.
   // Project paused by the user (Doing列の一時停止 / chat) → hold this project's
   // queue exactly like the auth hold above. Resume flips the flag and pumps.
   if (isProjectPaused(projectId)) return;
@@ -1684,7 +1699,8 @@ function pump(projectId) {
     if (wait > 0) { setTimeout(() => pump(projectId), wait); return; }
   }
   const runningGoalIds = [...q.running].map((t) => t.goalId);
-  const toStart = nextRunnableTasks(q.waiting, runningGoalIds, slow.enabled ? 1 : slots);
+  const eligible = q.waiting.filter((task) => workerCanStart({ agent: task.agent, auth: workerAuth }));
+  const toStart = nextRunnableTasks(eligible, runningGoalIds, slow.enabled ? 1 : slots);
   for (const task of toStart) {
     const i = q.waiting.indexOf(task);
     if (i !== -1) q.waiting.splice(i, 1);
@@ -1981,7 +1997,9 @@ function queueReplyTask(goal, text, { from = 'manager', via = 'composer' } = {})
     const projectCap = slow.enabled ? Math.min(PROJECT_MAX_PARALLEL, slow.maxParallel) : PROJECT_MAX_PARALLEL;
     const slots = Math.min(projectCap - q.running.size, GLOBAL_MAX_PARALLEL - globalRunningCount());
     const runningGoalIds = [...q.running].map((t) => t.goalId);
-    const startsNow = nextRunnableTasks(q.waiting, runningGoalIds, slow.enabled ? 1 : slots).some((t) => t.id === task.id);
+    const eligible = q.waiting.filter((candidate) => workerCanStart({ agent: candidate.agent, auth: workerAuth }));
+    const startsNow = workerCanStart({ agent: task.agent, auth: workerAuth })
+      && nextRunnableTasks(eligible, runningGoalIds, slow.enabled ? 1 : slots).some((candidate) => candidate.id === task.id);
     goal.startedAt = startsNow ? new Date().toISOString() : null;
     saveGoal(goal);
   }
@@ -4913,7 +4931,10 @@ server.listen(PORT, '127.0.0.1', () => {
     spawn('open', ['-g', openUrl], { stdio: 'ignore' }).unref();
   }
   console.log(`[manager] projects: ${projects.map((p) => `${p.id}=${p.dir}`).join('  ')}`);
-  probeWorkerAuth().catch(() => {}); // hold the queue + banner if `claude` isn't signed in
+  probeWorkerAuth().catch(() => {}); // hold Claude tasks + banner if Claude is unavailable
+  setInterval(() => {
+    if (!workerAuth.ok) probeWorkerAuth().catch(() => {});
+  }, 5 * 60_000).unref();
   syncAllExternal().catch(() => {});
   syncGoalMerges().catch(() => {});
   setInterval(() => {
@@ -4930,6 +4951,7 @@ server.listen(PORT, '127.0.0.1', () => {
   for (const p of projects) {
     const pending = tasks.filter((t) => t.projectId === p.id && t.status === 'queued').sort((a, b) => a.num - b.num);
     const q = queues.get(p.id);
+    reconcileQueuedGoalStarts(p.id);
     q.waiting.push(...pending);
     if (pending.length) console.log(`[manager] ${p.id}: re-queued ${pending.length} pending task(s) after restart`);
     pump(p.id);

package/engine/worker-availability.mjs

@@ -0,0 +1,8 @@
+export function classifyWorkerPreflight({ result = '', code = 0 } = {}, { classifyAuthProbe, isRateLimited }) {
+  if (isRateLimited(result)) return { ok: false, reason: 'rate-limited' };
+  return classifyAuthProbe({ result, code });
+}
+
+export function workerCanStart({ agent, auth } = {}) {
+  return auth?.ok === true || agent === 'codex';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galda/cli",
-  "version": "0.10.52",
+  "version": "0.10.54",
   "type": "module",
   "description": "Galda - hand off work to Claude Code or Codex, get proof back. Runs on your existing subscription, no extra API cost.",
   "scripts": {