@awebai/oats 0.30.3 → 0.32.0

package/lib/resolve.mjs

@@ -60,6 +60,7 @@ import * as defaultRemote from "./remote.mjs";
 import { BY_TEAM_REMOVED, reportRows, soulKeyOf, soulTeams, teamModel } from "./teams.mjs";
 import { bindRemote, packageProviding, readPackageManifests, validateLock } from "./packages.mjs";
 import { settingValueProblems } from "./capability-contract.mjs";
+import { memberRowByKey } from "./workspace.mjs";
 
 export const RESOLUTION_API = 1;
 export const SLOTS = Object.freeze(["knowledge", "messaging", "tasks"]);
@@ -367,14 +368,26 @@ export function composeCapabilities(workspace, soulDefinition, { offs = null } =
 
 /* ───────────────────────────── lookups ────────────────────────────────── */
 
-function memberRow(discovery, repoKey) {
-  return (discovery?.members || []).find((m) => m.key === repoKey) || null;
-}
+/** A discovery's member row by key (the first with that key; lib/workspace.mjs memberRowByKey). */
+const memberRow = (discovery, repoKey) => memberRowByKey(discovery?.members, repoKey);
 
-/** The ref the workspace lists a member under (keeps the operator's spelling: ssh vs https); else from the key. */
+/** The ref the workspace lists a member under (keeps the operator's spelling: ssh vs https); else from the key.
+ *  The key → first listed ref index is built once per members array and parseRepoRef. */
+const memberRefIndex = new WeakMap();
 export function memberRef(discovery, remote, repoKey) {
-  for (const ref of discovery?.workspace?.members || []) {
-    try { if (remote.parseRepoRef(ref).key === repoKey) return ref; } catch { /* validated upstream */ }
+  const members = discovery?.workspace?.members;
+  if (Array.isArray(members)) {
+    let byParser = memberRefIndex.get(members);
+    if (!byParser) memberRefIndex.set(members, byParser = new Map());
+    let index = byParser.get(remote.parseRepoRef);
+    if (!index) {
+      index = new Map();
+      for (const ref of members) {
+        try { const key = remote.parseRepoRef(ref).key; if (!index.has(key)) index.set(key, ref); } catch { /* validated upstream */ }
+      }
+      byParser.set(remote.parseRepoRef, index);
+    }
+    if (index.has(repoKey)) return index.get(repoKey);
   }
   return refForKey(repoKey);
 }
@@ -496,7 +509,10 @@ async function enumerateSkills({ remote, ref, commit, dir, manifest, listing, mo
       // Discovery already listed the capability directory (relative to it): project onto this entry.
       entries = listing.filter((e) => e.path === declared || e.path.startsWith(`${declared}/`)).map((e) => ({ ...e, path: e.path === declared ? "" : e.path.slice(declared.length + 1) })).filter((e) => e.path);
     } else {
-      entries = await remote.listRemoteTree(ref, commit, posix.join(dir, declared), { depth: 2 });
+      // A listing at a commit never changes: the parsed cache keeps it (lib/remote.mjs memoAtCommit).
+      const at = posix.join(dir, declared);
+      const list = () => remote.listRemoteTree(ref, commit, at, { depth: 2 });
+      entries = typeof remote.memoAtCommit === "function" ? await remote.memoAtCommit(ref, commit, `list\0${at}\0${2}`, list) : await list();
     }
     const found = skillsInListing(declared, entries);
     if (found.length === 0) throw missing(raw, "skill-missing", `declares skills entry ${show(raw)} but no SKILL.md is there (neither ${declared}/SKILL.md nor ${declared}/*/SKILL.md)`);

package/lib/schedule.mjs

@@ -29,6 +29,7 @@ import { fileURLToPath } from "node:url";
 import { Cron } from "croner";
 import { loadLocal } from "./workspace.mjs";
 import { noteRuntimeName } from "./deprecation.mjs";
+import { herdrSettingRemoved } from "./errors.mjs";
 import { tickTriggers } from "./triggers.mjs";
 import { resolveMemberClone } from "./instance-resolution.mjs";
 import { AUTOMATION_ID_RE, MODEL_RE, automationContext, automationError, baseRow, localEntry, localId, soulOriginOf, splitId } from "./automations.mjs";
@@ -38,7 +39,6 @@ export const SCHEDULE_FILE = "oats-schedules.json";
 export const SCHEDULE_API = 2;
 const ID_RE = /^[a-z0-9-]{1,40}$/;
 const HARNESSES = new Set(["pi", "claude", "codex"]);
-const BACKENDS = new Set(["tmux", "herdr"]);
 const MESSAGE_MAX = 256 * 1024;
 const OATS_BIN = join(dirname(fileURLToPath(import.meta.url)), "..", "bin", "oats.mjs");
 const COMMAND_TIMEOUT_MS = 5 * 60 * 1000;
@@ -295,8 +295,17 @@ function validateMessage(message, field) {
   if (typeof message !== "string" || !message.trim() || message.includes("\0") || Buffer.byteLength(message) > MESSAGE_MAX) throw scheduleError("E_SCHEDULE_INVALID", `${field}: non-empty text without NUL, at most 256 KiB`, { field });
 }
 
-/** Validate and normalize one definition against its scope. */
-export function validateDefinition(ws, def, { checkAgent = true } = {}) {
+/** The refusal of a spawn job's `backend: herdr` (Herdr was removed in 0.31.0): `where` names the
+ *  file and key that set it. */
+export function herdrBackendRefusal(where) { return Object.assign(herdrSettingRemoved(`${where}: herdr`), { field: "backend" }); }
+/** A stored local spawn job that selects Herdr: its refusal, naming this scope's definitions file. */
+function storedHerdrBackend(ws, id, def) {
+  return def?.kind === "spawn" && !def.workspace && def.backend === "herdr" ? herdrBackendRefusal(`${definitionsPath(ws)} sets jobs.${id}.backend`) : null;
+}
+
+/** Validate and normalize one definition against its scope. `backendSource` names the file and key
+ *  a definition read from elsewhere sets its backend in (default: this scope's definitions file). */
+export function validateDefinition(ws, def, { checkAgent = true, backendSource } = {}) {
   if (!def || typeof def !== "object" || Array.isArray(def)) throw scheduleError("E_SCHEDULE_INVALID", "definition must be an object", { field: "definition" });
   if (def.kind === "trigger") throw scheduleError("E_SCHEDULE_INVALID", "kind: a trigger is added with `oats trigger add`, not `oats schedule add`", { field: "kind" });
   const id = def.id;
@@ -314,7 +323,8 @@ export function validateDefinition(ws, def, { checkAgent = true } = {}) {
       out.agentsRoot = resolve(def.agentsRoot);
     }
     if (def.repo !== undefined) { if (typeof def.repo !== "string" || !def.repo.trim() || def.repo.startsWith("-")) throw scheduleError("E_SCHEDULE_INVALID", "repo: the work repository path, as oats spawn --repo", { field: "repo" }); out.repo = def.repo; }
-    if (def.backend !== undefined) { if (!BACKENDS.has(def.backend)) throw scheduleError("E_SCHEDULE_INVALID", "backend: tmux or herdr", { field: "backend" }); out.backend = def.backend; }
+    if (def.backend === "herdr") throw herdrBackendRefusal(backendSource ?? `${definitionsPath(ws)} sets jobs.${id}.backend`);
+    if (def.backend !== undefined) { if (def.backend !== "tmux") throw scheduleError("E_SCHEDULE_INVALID", "backend: tmux", { field: "backend" }); out.backend = def.backend; }
     if (def.purpose !== undefined) { if (typeof def.purpose !== "string" || !/^[a-z0-9-]{1,40}$/.test(def.purpose)) throw scheduleError("E_SCHEDULE_INVALID", "purpose: lowercase letters, digits and dashes", { field: "purpose" }); out.purpose = def.purpose; }
     // A run spawns <agent>-<purpose|id>-<YYYYMMDDHHMM>; instance names are at most
     // MAX_INSTANCE_NAME characters, so refuse here what would fail at every firing.
@@ -413,7 +423,7 @@ export function validateWorkspaceSchedule(dep, a) {
     const real = (p) => { try { return realpathSync(p); } catch { return resolve(p); } };
     if (!inside(real(dep), real(spec.cwd))) throw scheduleError("E_SCHEDULE_INVALID", `cwd: ${JSON.stringify(d.cwd)} leaves the deployment; a workspace command's cwd is a directory inside it`, { field: "cwd" });
   }
-  const out = validateDefinition(dep, spec, { checkAgent: false });
+  const out = validateDefinition(dep, spec, { checkAgent: false, backendSource: `${a.origin?.path ?? a.name} sets backend` });
   delete out.enabled;
   return out;
 }
@@ -756,11 +766,13 @@ export function tickWorkspace(ws, { now = new Date(), io, reg, wsList, dryRun =
     const def = defs.jobs[id];
     const js = stateOf(id);
     let due, cronError;
-    const shape = shapeError(def);
+    const invalidShape = shapeError(def), herdr = invalidShape ? null : storedHerdrBackend(ws, id, def);
+    const shape = invalidShape ?? herdr?.message;
     if (!shape) validateActiveExecution(js, jobLockInfo(ws, id)); // Also covers host pre-observed candidates.
     if (shape) { cronError = shape; due = false; }
     else { try { due = only ? true : dueAt(def, minute); } catch (e) { cronError = e.message; due = false; } }
-    if (cronError) { if (!dryRun) js.lastRun = { ...(js.lastRun || {}), outcome: "invalid", error: `definition cannot be evaluated: ${cronError}` }; record(id, "invalid", { error: cronError }); continue; }
+    const errorCode = herdr ? { errorCode: herdr.code } : {};
+    if (cronError) { if (!dryRun) js.lastRun = { ...(js.lastRun || {}), outcome: "invalid", error: `definition cannot be evaluated: ${cronError}`, ...errorCode }; record(id, "invalid", { error: cronError, ...errorCode }); continue; }
     if (def.kind === "wake" && js.pendingWake && def.enabled && !dryRun && !only) {
       const dueNow = due && js.lastAttemptedMinute !== key;
       const held = !!jobLockInfo(ws, id);
@@ -1066,7 +1078,8 @@ export function describe(ws, qid, io, { defs, st, now = new Date(), ctx = null }
   const { history, recentRuns } = projectHistory(js);
   const { workspace: _w, ...stored } = def; void _w;
   const base = { ...stored, id, scope: ws, scheduleApi: 2, scheduleHistoryApi: SCHEDULE_HISTORY_API, executionStatus: scheduleExecutionStatus(def, intent, lock), nextRun, lastRun: js.lastRun ? { ...js.lastRun, runId: runIdOf(js.lastRun), session: sessionProvenanceOf(js.lastRun) } : null, history, recentRuns, running: !!lock, ...(js.attempt ? { attempt: js.attempt } : {}), ...(js.pendingWake ? { pendingWake: js.pendingWake } : {}) };
-  return scheduleRow(ws, entry ?? localEntry("schedule", { ...def, id: name }, { dep: ws }), base, ctx);
+  const herdr = entry ? null : storedHerdrBackend(ws, id, def);
+  return scheduleRow(ws, entry ?? localEntry("schedule", { ...def, id: name }, { dep: ws, ...(herdr ? { invalid: { code: herdr.code, message: herdr.message, field: herdr.field } } : {}) }), base, ctx);
 }
 /** A schedule's list row: its stored facts, the fields every trigger and schedule row share
  *  (lib/automations.mjs baseRow) and the schedule's own: `kind` is its run (spawn, command, wake,