tines 0.0.221 → 0.0.223

package/dist/index.js

@@ -5623,6 +5623,15 @@ function runnerStatusLabel(runner) {
     return "rate limited";
   return runner.online ? "online" : "offline";
 }
+function runnerConcurrencyLabel(runner) {
+  if (runner.type !== "local" || !runner.concurrency_control) return `${runner.max_concurrent}`;
+  const control = runner.concurrency_control;
+  if (control.status === "applied")
+    return `${runner.max_concurrent} applied \xB7 ceiling ${control.ceiling ?? "?"}`;
+  if (control.status === "pending")
+    return `${runner.max_concurrent} pending \xB7 confirmed ${control.applied_cap ?? "none"} \xB7 ceiling ${control.ceiling ?? "?"}`;
+  return `${runner.max_concurrent} web off (${control.reason ?? "unavailable"})`;
+}
 function ruleTargetsLabel(rule) {
   if (rule.targets.length === 0) return "(no targets)";
   if (rule.targets.length === 1 && rule.targets[0]?.runner_id === "*") {
@@ -10092,6 +10101,23 @@ function loadDaemonState(path2) {
 function saveDaemonState(path2, runs) {
   writeJsonFile(path2, { runs });
 }
+function daemonDeclinesPath(dir, runnerId) {
+  return join5(dir, `daemon-declines-${runnerId}.json`);
+}
+function loadDaemonDeclines(path2) {
+  const state = readJsonFile(path2);
+  if (!state || !Array.isArray(state.run_ids)) return [];
+  return [
+    ...new Set(
+      state.run_ids.filter(
+        (id2) => typeof id2 === "string" && id2.length >= 1 && id2.length <= 128 && /^[\x21-\x7e]+$/.test(id2)
+      )
+    )
+  ];
+}
+function saveDaemonDeclines(path2, runIds) {
+  writeJsonFile(path2, { run_ids: [...runIds] });
+}
 function processStartTimeMs(pid) {
   try {
     const stat2 = readFileSync8(`/proc/${pid}/stat`, "utf8");
@@ -10198,7 +10224,7 @@ async function ensureRunnerCredentials(opts) {
     name: opts.name,
     harness: opts.harness,
     ...opts.command !== void 0 ? { command: opts.command } : {},
-    max_concurrent: opts.maxConcurrent,
+    max_concurrent: opts.allowRemoteConcurrency ? 1 : opts.maxConcurrent,
     hostname: hostname(),
     platform: `${platform()} ${arch()}`
   });
@@ -10304,6 +10330,7 @@ async function runDaemon(opts) {
     harness: opts.harness,
     ...opts.command !== void 0 ? { command: opts.command } : {},
     maxConcurrent: opts.maxConcurrent,
+    allowRemoteConcurrency: opts.allowRemoteConcurrency,
     ...opts.apiKey !== void 0 ? { apiKey: opts.apiKey } : {},
     log
   });
@@ -10316,7 +10343,12 @@ async function runDaemon(opts) {
   }
   const client2 = createApiClient({ baseUrl, apiKey: creds.token });
   const statePath = daemonStatePath(opts.configDir, creds.runner_id);
+  const declinesPath = daemonDeclinesPath(opts.configDir, creds.runner_id);
   let shuttingDown = false;
+  let effectiveConcurrency = opts.allowRemoteConcurrency ? 1 : opts.maxConcurrent;
+  let appliedConcurrency;
+  const declinedAssignments = new Set(loadDaemonDeclines(declinesPath));
+  let warnedUnsupportedConcurrency = false;
   const refresher = new CliRefresher(() => installAgentCli({ configDir: opts.configDir, log }), {
     ttlMs: CLI_REFRESH_TTL_MS
   });
@@ -10764,7 +10796,7 @@ async function runDaemon(opts) {
   process.on("SIGINT", () => void shutdown());
   process.on("SIGTERM", () => void shutdown());
   log(
-    `polling ${baseUrl} every ${Math.round(opts.pollIntervalMs / 1e3)}s (harness ${opts.harness}, max ${opts.maxConcurrent} concurrent) \u2014 Ctrl-C to stop`
+    `polling ${baseUrl} every ${Math.round(opts.pollIntervalMs / 1e3)}s (harness ${opts.harness}, ${opts.allowRemoteConcurrency ? `web-adjustable with local ceiling ${opts.maxConcurrent}` : `local cap ${opts.maxConcurrent}`}) \u2014 Ctrl-C to stop`
   );
   let failures = 0;
   while (!shuttingDown) {
@@ -10773,7 +10805,16 @@ async function runDaemon(opts) {
       const res = await client2.pollRunner(creds.runner_id, {
         instance_id: instanceId,
         owned_runs: table2.ids(),
-        max_concurrent: opts.maxConcurrent,
+        // Kept for older servers. Opted-in daemons advertise only the last
+        // accepted scheduling cap, never the higher machine ceiling.
+        max_concurrent: effectiveConcurrency,
+        concurrency_control: {
+          version: 1,
+          allow_remote: opts.allowRemoteConcurrency,
+          ceiling: opts.maxConcurrent,
+          ...appliedConcurrency ? { applied: appliedConcurrency } : {}
+        },
+        ...declinedAssignments.size > 0 ? { declined_assignments: [...declinedAssignments].slice(0, 100) } : {},
         ...effortCapabilities ? { effort_capabilities: effortCapabilities } : {},
         // Stated on every poll while pending; absent otherwise, which
         // the server reads as "not draining" — so a daemon that died
@@ -10782,11 +10823,31 @@ async function runDaemon(opts) {
       });
       failures = 0;
       for (const runId of res.cancels) killWithoutFinish(runId);
+      let declinesChanged = false;
+      for (const runId of res.released_assignments ?? []) {
+        if (declinedAssignments.delete(runId)) declinesChanged = true;
+      }
+      if (declinesChanged) saveDaemonDeclines(declinesPath, declinedAssignments);
+      if (res.concurrency_control) {
+        const control = res.concurrency_control;
+        if (opts.allowRemoteConcurrency && control.available && Number.isSafeInteger(control.revision) && Number.isInteger(control.cap) && control.cap >= 1 && control.cap <= opts.maxConcurrent) {
+          effectiveConcurrency = control.cap;
+          appliedConcurrency = { revision: control.revision, cap: control.cap };
+        }
+      } else if (opts.allowRemoteConcurrency && !warnedUnsupportedConcurrency) {
+        warnedUnsupportedConcurrency = true;
+        log(
+          "web concurrency adjustment unavailable: upgrade the server; retaining conservative cap"
+        );
+      }
       for (const assignment of res.assignments) {
-        if (table2.size >= opts.maxConcurrent) {
+        if (declinedAssignments.size > 0 || table2.size >= opts.maxConcurrent) {
           log(
-            `warning: supervisor delivered ${assignment.run.id} beyond --max-concurrent ${opts.maxConcurrent}; launching anyway (the server cap governs)`
+            `run ${assignment.run.id}: refusing launch beyond local ceiling ${opts.maxConcurrent}; requesting safe release`
           );
+          declinedAssignments.add(assignment.run.id);
+          saveDaemonDeclines(declinesPath, declinedAssignments);
+          continue;
         }
         void launch(assignment);
       }
@@ -10862,7 +10923,15 @@ function withDaemonFlags(cmd) {
   ).option("--harness <harness>", "claude-code | codex | custom", "claude-code").option(
     "--command <template>",
     "custom harness command template ({prompt_file}, {workspace}, {model})"
-  ).option("--max-concurrent <n>", "maximum simultaneous runs", (v) => Number.parseInt(v, 10), 1).option("--poll-interval <seconds>", "seconds between polls", (v) => Number.parseInt(v, 10), 15).option(
+  ).option(
+    "--max-concurrent <n>",
+    "local maximum simultaneous runs (remote-adjustment ceiling when enabled)",
+    (v) => Number(v),
+    1
+  ).option(
+    "--allow-remote-concurrency",
+    "allow signed-in operators to request concurrency up to --max-concurrent"
+  ).option("--poll-interval <seconds>", "seconds between polls", (v) => Number.parseInt(v, 10), 15).option(
     "--keep-workspaces <mode>",
     "keep settled runs' workspaces for debugging: never | failed | always",
     "never"
@@ -10910,6 +10979,7 @@ function parseDaemonFlags(opts) {
     harness,
     ...opts.command !== void 0 ? { command: opts.command } : {},
     maxConcurrent: opts.maxConcurrent,
+    allowRemoteConcurrency: opts.allowRemoteConcurrency === true,
     pollIntervalSeconds: opts.pollInterval,
     keepWorkspaces,
     keepWorkspacesForHours: opts.keepWorkspacesFor,
@@ -10961,6 +11031,7 @@ function daemonArgs(input2) {
   ];
   if (input2.command !== void 0) args.push("--command", input2.command);
   if (input2.maxConcurrent !== 1) args.push("--max-concurrent", String(input2.maxConcurrent));
+  if (input2.allowRemoteConcurrency) args.push("--allow-remote-concurrency");
   if (input2.pollIntervalSeconds !== void 0 && input2.pollIntervalSeconds !== 15)
     args.push("--poll-interval", String(input2.pollIntervalSeconds));
   if (input2.keepWorkspaces !== void 0 && input2.keepWorkspaces !== "never")
@@ -11228,6 +11299,7 @@ stop it first \u2014 \`tines runners pause ${settings.name}\`, wait for 0 active
         harness: settings.harness,
         ...settings.command !== void 0 ? { command: settings.command } : {},
         maxConcurrent: settings.maxConcurrent,
+        allowRemoteConcurrency: settings.allowRemoteConcurrency,
         ...resolveApiKey(opts) !== void 0 ? { apiKey: resolveApiKey(opts) } : {},
         log: log2
       });
@@ -11258,6 +11330,7 @@ stop it first \u2014 \`tines runners pause ${settings.name}\`, wait for 0 active
         harness: harnessFlag(settings.harness),
         ...settings.command !== void 0 ? { command: settings.command } : {},
         maxConcurrent: settings.maxConcurrent,
+        allowRemoteConcurrency: settings.allowRemoteConcurrency,
         pollIntervalSeconds: settings.pollIntervalSeconds,
         keepWorkspaces: settings.keepWorkspaces,
         keepWorkspacesForHours: settings.keepWorkspacesForHours,
@@ -11429,12 +11502,13 @@ function register8(program3) {
       if (opts.json) return printJson(res);
       if (res.items.length === 0) return console.log("no runners");
       table([
-        ["NAME", "TYPE", "STATUS", "RUNS", "TIER", "LAST SEEN"],
+        ["NAME", "TYPE", "STATUS", "RUNS", "CONCURRENCY", "TIER", "LAST SEEN"],
         ...res.items.map((r) => [
           r.name,
           r.type,
           runnerStatusLabel(r),
           `${r.active_runs}/${r.max_concurrent}`,
+          runnerConcurrencyLabel(r),
           r.default_tier,
           r.last_seen_at ? timestamp(r.last_seen_at) : "\u2014"
         ])
@@ -11449,6 +11523,7 @@ function register8(program3) {
       console.log(
         `active runs: ${runner.active_runs}/${runner.max_concurrent}  timeout: ${runner.max_run_minutes}m  default tier: ${runner.default_tier}`
       );
+      console.log(`concurrency: ${runnerConcurrencyLabel(runner)}`);
       if (runner.last_seen_at) console.log(`last seen: ${timestamp(runner.last_seen_at)}`);
       if (runner.backoff_reason === "rate_limit" && runner.backoff_until) {
         console.log(
@@ -11691,6 +11766,7 @@ function register8(program3) {
         harness: settings.harness,
         command: settings.command,
         maxConcurrent: settings.maxConcurrent,
+        allowRemoteConcurrency: settings.allowRemoteConcurrency,
         pollIntervalMs: settings.pollIntervalSeconds * 1e3,
         configDir: defaultConfigDir(),
         cliRefresh: opts.cliRefresh,
@@ -12178,7 +12254,7 @@ function queueFix(block) {
   const runner = block.runnerName ?? "the routed runner";
   switch (block.verdict) {
     case "at_capacity":
-      return `raise the cap on ${runner} \u2014 restart its daemon with tines runner daemon --max-concurrent N, or edit the runner on the Agents page`;
+      return `edit ${runner} on the Agents page; if web adjustment is off, relaunch locally with tines runner daemon --allow-remote-concurrency --max-concurrent N`;
     case "quota_exhausted":
       return block.binding?.kind === "state_roster" ? "raise the roster limit \u2014 tines supervisor quota roster --default <n> --state <workflow>/<state>=<n> (this replaces the whole roster, so restate every override you keep)" : "raise the cap \u2014 tines supervisor quota global <n> \u2014 or switch to a per-state roster with tines supervisor quota roster";
     case "offline":
@@ -12283,7 +12359,8 @@ function register10(program3) {
           `  ${r.name}`,
           r.type,
           runnerStatusLabel(r),
-          `${r.active_runs}/${r.max_concurrent}`
+          `${r.active_runs}/${r.max_concurrent}`,
+          runnerConcurrencyLabel(r)
         ])
       );
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.221",
+  "version": "0.0.223",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",