agent-lyceum 0.26.0 → 0.28.0

package/dist/status.js

@@ -319,7 +319,14 @@ export function buildStatusReport(base, runId, now = Date.now()) {
     catch {
         /* a hint only: never let it break status */
     }
-    return {
+    const wakes = run?.state.wakes ?? [];
+    const below = new Set();
+    for (const a of Object.values(project.agents)) {
+        const last = wakes.filter((w) => w.agent === a.name).at(-1);
+        if (last?.tier && !last.fallback_from && last.runtime === a.runtime && !candidatesFor(a).some((c) => c.primary && c.key === `${last.runtime}/${(last.model ?? "").trim().toLowerCase()}`))
+            below.add(a.name);
+    }
+    const out = {
         schema_version: 1,
         project: projectInfo(base),
         agents: Object.values(project.agents).map((a) => ({
@@ -335,6 +342,8 @@ export function buildStatusReport(base, runId, now = Date.now()) {
         run: report,
         ...(advice.length ? { memory_advice: advice } : {}),
     };
+    belowCeiling.set(out, below);
+    return out;
 }
 /** Every run of the project, newest first. */
 export function buildTaskListReport(project) {
@@ -513,6 +522,19 @@ function fallbackLines(agents, c) {
     }
     return out;
 }
+/** Agents whose latest wake ran on a tiered model below the ceiling; kept off the report so `status --json` is unchanged. */
+const belowCeiling = new WeakMap();
+/** An agent whose latest wake ran on a model below its ceiling (spec 24.9): one line each, in agent order. */
+function tierLines(report, c) {
+    const out = [];
+    const wakes = report.run?.wakes ?? [];
+    for (const a of report.agents) {
+        const last = wakes.filter((w) => w.agent === a.name).at(-1);
+        if (last?.tier && last.runtime && belowCeiling.get(report)?.has(a.name))
+            out.push(`  ${c.cyan(a.name)} ${c.yellow(`tier ${last.tier}`)}（${modelName(`${last.runtime}/${last.model ?? ""}`)}）`);
+    }
+    return out;
+}
 export function formatStatusReport(report, now = Date.now(), color = false) {
     const c = paint(color);
     const run = report.run;
@@ -543,6 +565,9 @@ export function formatStatusReport(report, now = Date.now(), color = false) {
     const fb = fallbackLines(report.agents, c);
     if (fb.length)
         lines.push("", ...fb);
+    const tl = tierLines(report, c);
+    if (tl.length)
+        lines.push(...(fb.length ? [] : [""]), ...tl);
     if (run)
         lines.push("", `輸出 tokens：${tokens(run.output_tokens)}${cacheText(run.cache_read_tokens, run.cache_write_tokens) ? `　${cacheText(run.cache_read_tokens, run.cache_write_tokens)}` : ""}`);
     if (report.memory_advice?.length)

package/dist/tiers.d.ts

@@ -0,0 +1,27 @@
+import { type Tier } from "./schema.js";
+export declare function isTier(v: unknown): v is Tier;
+/** Index of `model` on `ladder` (trim + lowercase, like the fallback keys), or -1. */
+export declare function ladderIndex(ladder: readonly string[], model: string | undefined): number;
+/**
+ * The tiers an agent can run on: the ladder from its lowest entry up to and including `model` (the ceiling).
+ * `undefined` when there is nothing below the ceiling (no ladder, no model, model not on it, or it is the lowest entry).
+ */
+export declare function availableTiers(ladder: readonly string[] | undefined, model: string | undefined): string[] | undefined;
+/** `low` = lowest, `high` = ceiling, `mid` = `tiers[floor(n/2)]` (the higher middle when n is even). */
+export declare function modelForTier(tiers: readonly string[], tier: Tier): string;
+export type TierFlag = "absent" | "invalid" | Tier | {
+    ignored: "not-lead" | "not-a-task" | "no-tiers";
+};
+/** Judge the `tier` frontmatter of one outgoing mail, in the order of spec 24.5.2. Not wired anywhere yet. */
+export declare function tierFlag(i: {
+    value: unknown;
+    senderIsLead: boolean;
+    type: string;
+    recipientTiers?: string[];
+}): TierFlag;
+/** A mail without a valid tier counts as `high` (the ceiling). */
+export declare function effectiveTier(meta: {
+    tier?: unknown;
+}): Tier;
+/** The tier a wake runs at: the highest of the batch when every mail has a valid one, else `undefined` (the ceiling). */
+export declare function wakeTier(tiers: readonly unknown[]): Tier | undefined;

package/dist/tiers.js

@@ -0,0 +1,49 @@
+import { TIERS } from "./schema.js";
+const norm = (m) => (m ?? "").trim().toLowerCase();
+export function isTier(v) {
+    return typeof v === "string" && TIERS.includes(v);
+}
+/** Index of `model` on `ladder` (trim + lowercase, like the fallback keys), or -1. */
+export function ladderIndex(ladder, model) {
+    const m = norm(model);
+    return m ? ladder.findIndex((e) => norm(e) === m) : -1;
+}
+/**
+ * The tiers an agent can run on: the ladder from its lowest entry up to and including `model` (the ceiling).
+ * `undefined` when there is nothing below the ceiling (no ladder, no model, model not on it, or it is the lowest entry).
+ */
+export function availableTiers(ladder, model) {
+    if (!ladder?.length)
+        return undefined;
+    const i = ladderIndex(ladder, model);
+    return i >= 1 ? ladder.slice(0, i + 1) : undefined;
+}
+/** `low` = lowest, `high` = ceiling, `mid` = `tiers[floor(n/2)]` (the higher middle when n is even). */
+export function modelForTier(tiers, tier) {
+    const n = tiers.length;
+    return tiers[tier === "low" ? 0 : tier === "high" ? n - 1 : Math.floor(n / 2)];
+}
+/** Judge the `tier` frontmatter of one outgoing mail, in the order of spec 24.5.2. Not wired anywhere yet. */
+export function tierFlag(i) {
+    if (i.value === undefined || i.value === null || i.value === "")
+        return "absent";
+    if (!i.senderIsLead)
+        return { ignored: "not-lead" };
+    if (!isTier(i.value))
+        return "invalid";
+    if (i.type !== "task")
+        return { ignored: "not-a-task" };
+    if (!i.recipientTiers || i.recipientTiers.length < 2)
+        return { ignored: "no-tiers" };
+    return i.value;
+}
+/** A mail without a valid tier counts as `high` (the ceiling). */
+export function effectiveTier(meta) {
+    return isTier(meta.tier) ? meta.tier : "high";
+}
+/** The tier a wake runs at: the highest of the batch when every mail has a valid one, else `undefined` (the ceiling). */
+export function wakeTier(tiers) {
+    if (tiers.length === 0 || !tiers.every(isTier))
+        return undefined;
+    return TIERS[Math.max(...tiers.map((t) => TIERS.indexOf(t)))];
+}

package/dist/validate.js

@@ -1,7 +1,9 @@
 import fs from "node:fs";
 import { enforcementFor, memoryDirs } from "./policy.js";
+import { describeConflict, fallbackCapExcess, sandboxConflictsOf } from "./sandbox-invocation.js";
 import { isInside } from "./paths.js";
-import { inferRuntime, RUNTIME_EFFORTS } from "./schema.js";
+import { inferRuntime, RUNTIME_EFFORTS, RUNTIMES } from "./schema.js";
+import { ladderIndex } from "./tiers.js";
 import { must } from "./assert.js";
 export function validateProject(project) {
     const issues = [];
@@ -15,7 +17,30 @@ export function validateProject(project) {
     if (!fs.existsSync(project.dir) || !fs.statSync(project.dir).isDirectory()) {
         err(`Project dir does not exist: ${project.dir}`);
     }
+    for (const rt of RUNTIMES) {
+        const ladder = project.modelTiers[rt];
+        if (!ladder)
+            continue;
+        const seen = new Set();
+        ladder.forEach((m, i) => {
+            const other = inferRuntime(m);
+            if (other !== rt)
+                err(`model_tiers.${rt}[${i}]: "${m}" is not a ${rt} model (recognised as ${other ?? "nothing"}). List only ${rt} models, lowest first.`);
+            const k = m.trim().toLowerCase();
+            if (seen.has(k))
+                err(`model_tiers.${rt}: "${m}" is listed twice.`);
+            seen.add(k);
+        });
+    }
     for (const a of Object.values(project.agents)) {
+        const ladder = a.runtime ? project.modelTiers[a.runtime] : undefined;
+        if (a.runtime && ladder) {
+            if (!a.model)
+                warn(`Agent "${a.name}" has no model, so model_tiers.${a.runtime} does not apply to it: it always runs on its runtime's default model.`);
+            else if (ladderIndex(ladder, a.model) < 0) {
+                err(`Agent "${a.name}": model "${a.model}" is not on model_tiers.${a.runtime} (${ladder.join(", ")}). Add it to the ladder, or set model_tiers.${a.runtime}: [] in project.yaml to turn the ladder off for this project.`);
+            }
+        }
         if (!a.runtime)
             err(`Agent "${a.name}" has no runtime (set runtime, or a recognizable model such as opus/sonnet/haiku/claude-* or gpt-*/codex-*).`);
         const modelRuntime = inferRuntime(a.model);
@@ -26,6 +51,10 @@ export function validateProject(project) {
             err(`Agent "${a.name}": effort "${a.effort}" is not supported by ${a.runtime} (use ${RUNTIME_EFFORTS[a.runtime].join(", ")}).`);
         }
         validateFallback(project, a, err);
+        for (const c of sandboxConflictsOf(project, a, false))
+            err(describeConflict(a.name, c, "load"));
+        for (const f of fallbackCapExcess(a))
+            err(`agent ${a.name}: fallback ${f.label} would apply more sandbox allowance than the primary (${f.excess.join("; ")}).`);
         if (!fs.existsSync(a.agentMd))
             err(`Agent "${a.name}": AGENT.md not found at ${a.agentMd}`);
         if (!a.memory.global && !a.memory.project)
@@ -39,6 +68,9 @@ export function validateProject(project) {
             }
         }
     }
+    if (Object.keys(project.modelTiers).length > 0 && !Object.values(project.agents).some((a) => a.name !== project.lead && a.tiers)) {
+        warn("model_tiers is set, but no member can run below its model (each member's model is the lowest entry of its ladder): tiers have no effect.");
+    }
     // Memory directories must not overlap between agents (or equal each other).
     const mem = [];
     for (const a of Object.values(project.agents))

package/dist/worktree.js

@@ -4,6 +4,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { atomicWrite } from "./fs-util.js";
+import { escapesParent } from "./paths.js";
 const IDENTITY = {
     GIT_AUTHOR_NAME: "agent-lyceum",
     GIT_AUTHOR_EMAIL: "agent-lyceum@localhost",
@@ -474,7 +475,7 @@ export function collectAgentChanges(workspace) {
             const resolved = path.posix.normalize(path.posix.join(path.posix.dirname(p), target));
             if (path.posix.isAbsolute(target))
                 violations.push(`${f.path}: symlink to an absolute path (${target})`);
-            else if (resolved.startsWith(".."))
+            else if (escapesParent(resolved, "/"))
                 violations.push(`${f.path}: symlink leaves the project directory (${target})`);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-lyceum",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "Config + dispatcher for teams of Claude Code / Codex agents with scoped context and file-based mailboxes",
   "keywords": [
     "ai",