agent-lyceum 0.5.0 → 0.7.0

package/dist/run-session.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { realInvoker } from "./adapters/index.js";
 import { briefOf, doneContract, parseSteps } from "./format.js";
 import { ProtectedGuard } from "./guard.js";
+import { addBatch, askersWithAnswers, askReplyPath, checkAnswers, describeCheck, isComplete, markDelivered, parseAskBody, readAskReply, renderAnswers, writeAskReply } from "./ask-reply.js";
 import { deliver, deliverOnce, ensureProjectDirs, finishDone, listUnread, rejectDone, routeOutboxes, unreadFiles } from "./mailbox.js";
 import { abandonClaim, attemptLogDir, sourceIdOf, beginAttempt, claimMessages, commitClaim, finishAttempt, markOutputReady, parkOutbox, recoverRunMail, RouteJournal } from "./message-store.js";
 import { isInside } from "./paths.js";
@@ -13,12 +14,15 @@ import { buildSystemPrompt, buildUserPrompt, pickMessages } from "./prompt.js";
 import { atomicWrite } from "./fs-util.js";
 import { assertWorktreeRunnable, collectAgentChanges, existingAgentWorkspace, integrateAgentChanges, prepareAgentWorkspace, resolveWorkspaceMode, snapshotBase } from "./worktree.js";
 import { bindRunProject, newRunId, newRunState, saveRunState } from "./run-store.js";
+import { soloProject } from "./solo.js";
 import { taskMessageBody } from "./task.js";
 import { must } from "./assert.js";
 export { newRunId };
 export const RESULT_FILE = "result.md";
 /** How many times a non-conforming `done` goes back to the lead before it is accepted as `partial`. */
 export const MAX_DONE_REJECTIONS = 2;
+/** How many times a malformed `ask` goes back to its sender before the lead is told instead. */
+export const MAX_ASK_REJECTIONS = 2;
 /** Prompt for a repeat attempt: the earlier one failed and may have changed things already. */
 function retryPrompt(prompt, error) {
     return `${prompt}\n\n# Retry notice\nYour previous attempt at this wake-up failed${error ? ` (${error})` : ""} after possibly changing files already. Its mail was discarded. Check the current state of the repository before redoing the work, and send the mail again.`;
@@ -53,15 +57,19 @@ export class RunSession {
     attempts = new Map();
     constructor(opts) {
         const { task, resume, runDir } = opts;
+        if (resume?.end_reason === "waiting")
+            RunSession.assertAnswered(runDir, resume.run_id);
         if (!task && !resume)
             throw new Error("runTeam needs a task or a run to resume");
         const invoke = opts.invoker ?? realInvoker;
         const say = opts.log ?? ((s) => console.log(s));
-        const cfg = opts.project.dispatcher;
+        const soloName = resume ? resume.solo_agent : opts.soloAgent;
+        const base = soloName ? soloProject(opts.project, soloName) : opts.project;
+        const cfg = base.dispatcher;
         const runId = path.basename(runDir);
         const layout = resume ? resume.mail_layout : "run";
         // Each run gets its own memory directory per agent and (new runs) its own mailboxes.
-        const project = bindRunProject(opts.project, runDir, layout);
+        const project = bindRunProject(base, runDir, layout);
         // Parallel agents work in their own git worktrees; refuse early (before anything is written) when that cannot be done.
         const wsMode = resolveWorkspaceMode(cfg);
         if (wsMode === "worktree")
@@ -99,6 +107,7 @@ export class RunSession {
                 task_summary: t.subject,
                 mail_layout: layout,
                 workspace_mode: wsMode,
+                solo_agent: soloName,
             });
             const seed = parseSteps(task.content, false);
             if (seed.length)
@@ -129,6 +138,16 @@ export class RunSession {
         this.guard = guard;
         this.state = state;
     }
+    /** A waiting run only continues once every unanswered question has a valid answer. */
+    static assertAnswered(runDir, runId) {
+        const reply = readAskReply(runDir);
+        if (!reply)
+            return;
+        const check = checkAnswers(reply);
+        if (!isComplete(check)) {
+            throw new Error(`Run ${runId} is still waiting for answers in ${askReplyPath(runDir)}:\n${describeCheck(check).map((l) => `  ${l}`).join("\n")}`);
+        }
+    }
     saveState() {
         saveRunState(this.runDir, this.state);
     }
@@ -354,6 +373,7 @@ export class RunSession {
                 contract = undefined;
             }
         }
+        const askAccepted = this.handleAsks(route);
         for (const d of route.delivered)
             log("route", d);
         const handedOff = (from, t) => {
@@ -402,6 +422,10 @@ export class RunSession {
             this.endReason = "done";
             return;
         }
+        if (askAccepted) {
+            this.endReason = "waiting";
+            return;
+        }
         const leadIdx = batch.findIndex((a) => a.name === project.lead);
         const leadResult = leadIdx >= 0 ? results[leadIdx] : undefined;
         if (leadResult && !leadResult.ok && !leadResult.cancelled) {
@@ -409,9 +433,86 @@ export class RunSession {
             return;
         }
     }
+    /** The user answered: send each asker its answers as a `reply`, then mark them delivered. Safe to repeat after a crash. */
+    deliverAnswers() {
+        const { runDir, project, log } = this;
+        const reply = readAskReply(runDir);
+        if (!reply)
+            return;
+        const ids = reply.questions.filter((q) => !q.delivered).map((q) => q.id).join(",");
+        for (const asker of askersWithAnswers(reply)) {
+            deliverOnce(project, this.journal(), `ask-answer:${ids}:${asker}`, {
+                from: "user",
+                to: asker,
+                type: "reply",
+                subject: "Answers to your questions",
+                body: renderAnswers(reply, asker),
+            });
+        }
+        writeAskReply(runDir, markDelivered(reply));
+        log("ask-answered", { questions: ids });
+    }
+    /** Store the questions of this pass's valid `ask` mails; malformed ones go back to their sender. Returns true when the run should now wait. */
+    handleAsks(route) {
+        const { say, runDir, project, log, state } = this;
+        if (route.asks.length === 0)
+            return false;
+        let reply = readAskReply(runDir);
+        const accepted = [];
+        for (const a of route.asks) {
+            const parsed = parseAskBody(a.body);
+            const added = parsed.ok ? addBatch(reply, a.from, state.rounds, parsed.questions) : parsed;
+            if (!added.ok) {
+                const n = (state.ask_rejections?.[a.from] ?? 0) + 1;
+                state.ask_rejections = { ...state.ask_rejections, [a.from]: n };
+                rejectDone(a.file);
+                const reason = added.error;
+                say(`  ask from ${a.from} rejected: ${reason}`);
+                log("ask-rejected", { from: a.from, reason, count: n });
+                if (n <= MAX_ASK_REJECTIONS) {
+                    deliverOnce(project, this.journal(), `ask-reject:${a.source}`, {
+                        from: "dispatcher",
+                        to: a.from,
+                        type: "failure",
+                        subject: "Your ask was not accepted",
+                        body: `Your \`ask\` was not accepted: ${reason}.\n\nSend it again with this shape (at most 10 questions; \`options\` and \`suggested\` are optional):\n\n<ask>\n  <question id="q1">\n    <text>Question?</text>\n    <options><option>a</option><option>b</option></options>\n    <suggested reason="why">a</suggested>\n  </question>\n</ask>\n\n(Reminder ${n} of ${MAX_ASK_REJECTIONS}.)`,
+                    });
+                }
+                else {
+                    deliverOnce(project, this.journal(), `ask-reject:${a.source}`, {
+                        from: "dispatcher",
+                        to: project.lead,
+                        type: "failure",
+                        subject: `${a.from}'s ask was rejected ${n} times`,
+                        body: `${a.from} sent a malformed \`ask\` rejected ${n} times (last problem: ${reason}). It was dropped. Decide without asking the user, or send the question yourself in the correct format.`,
+                    });
+                }
+                continue;
+            }
+            reply = added.reply;
+            accepted.push(a.file);
+        }
+        if (!accepted.length || !reply)
+            return false;
+        if (route.done) {
+            for (const f of accepted)
+                finishDone(f);
+            this.note("An ask was ignored because the lead also sent done in the same round.");
+            return false;
+        }
+        // Questions are stored first, the outbox file moves second: a crash in between re-routes the same ask, and addBatch skips it.
+        writeAskReply(runDir, reply);
+        for (const f of accepted)
+            finishDone(f);
+        log("ask", { questions: reply.questions.filter((q) => !q.delivered).map((q) => q.id) });
+        say(`  waiting for your answers: ${askReplyPath(runDir)}`);
+        return true;
+    }
     /** On resume: sort out what the interrupted process left behind before anything is woken. */
     recover() {
         const { say, runId, runDir, project, wsMode, log } = this;
+        if (this.resume?.end_reason === "waiting")
+            this.deliverAnswers();
         const rec = recoverRunMail(runDir, { outboxOf: (agent) => outboxDir(project, agent) });
         for (const i of rec.interrupted) {
             this.note(`${i.attempt.agent} attempt ${i.attempt.n} was interrupted${i.parked.length ? `; ${i.parked.length} output file(s) set aside in ${path.join("mail", "attempts", i.attempt.id, "outbox")}` : ""}. ` +
@@ -500,6 +601,6 @@ export class RunSession {
         this.saveState();
         if (this.pendingDoneFile)
             finishDone(this.pendingDoneFile);
-        return { runId, runDir, rounds: state.rounds, endReason, outcome, outcomeNote, verification: this.doneVerification, doneMessage: this.doneMessage };
+        return { runId, runDir, rounds: state.rounds, endReason, outcome, outcomeNote, verification: this.doneVerification, doneMessage: this.doneMessage, askReplyPath: endReason === "waiting" ? askReplyPath(runDir) : undefined };
     }
 }

package/dist/run-store.d.ts

@@ -3,7 +3,7 @@ import type { Step } from "./format.js";
 import type { RunOutcome } from "./schema.js";
 export declare const STATE_FILE = "state.json";
 export declare const STATE_SCHEMA_VERSION = 2;
-export type EndReason = "done" | "idle" | "max_rounds" | "lead_failed" | "cancelled";
+export type EndReason = "done" | "idle" | "max_rounds" | "lead_failed" | "cancelled" | "waiting";
 export type MailLayout = "run" | "legacy";
 export interface WakeTopic {
     from: string;
@@ -56,10 +56,14 @@ export interface RunState {
     verification?: string;
     /** How many `done` mails were sent back because they broke the completion contract. */
     done_rejections?: number;
+    /** How many malformed `ask` mails each agent had sent back (the limit is MAX_ASK_REJECTIONS). */
+    ask_rejections?: Record<string, number>;
     /** Recovery remarks (interrupted attempts whose side effects may have happened). */
     notes?: string[];
     /** "worktree": non-lead agents work in their own git worktrees. */
     workspace_mode?: "shared" | "worktree";
+    /** Set when the run was started with `run --agent <name>`: that member works alone (a resumed run keeps it). */
+    solo_agent?: string;
     /** Agents whose finished work could not be brought into the repo yet; their work is kept on their branch. */
     blocked_integrations?: {
         agent: string;

package/dist/run-store.js

@@ -23,12 +23,13 @@ const WireState = z
     ended_at: z.string().optional(),
     rounds: nonNeg.optional(),
     max_rounds: nonNeg.optional(),
-    end_reason: z.enum(["done", "idle", "max_rounds", "lead_failed", "cancelled"]).optional(),
-    outcome: z.enum(["completed", "partial", "blocked", "failed", "cancelled"]).optional(),
+    end_reason: z.enum(["done", "idle", "max_rounds", "lead_failed", "cancelled", "waiting"]).optional(),
+    outcome: z.enum(["completed", "partial", "blocked", "failed", "waiting", "cancelled"]).optional(),
     outcome_note: z.string().optional(),
     verification: z.string().optional(),
     done_rejections: nonNeg.optional(),
     notes: z.array(z.string()).optional(),
+    ask_rejections: z.record(z.string(), nonNeg).optional(),
     sessions: z.record(z.string(), z.string()).optional(),
     output_tokens: nonNeg.optional(),
     last_wake: z.record(z.string(), z.any()).optional(),
@@ -36,6 +37,7 @@ const WireState = z
     task_summary: z.string().optional(),
     active: z.record(z.string(), z.any()).optional(),
     wakes: z.array(z.any()).optional(),
+    solo_agent: z.string().optional(),
     steps: z.array(z.object({ text: z.string(), done: z.boolean() })).optional(),
 })
     .passthrough();
@@ -115,5 +117,5 @@ export function outcomeOf(s) {
         return { outcome: s.outcome, verified: true };
     if (!s.end_reason)
         return undefined;
-    return { outcome: s.end_reason === "lead_failed" ? "failed" : s.end_reason === "cancelled" ? "cancelled" : "partial", verified: false };
+    return { outcome: s.end_reason === "lead_failed" ? "failed" : s.end_reason === "cancelled" ? "cancelled" : s.end_reason === "waiting" ? "waiting" : "partial", verified: false };
 }

package/dist/schema.d.ts

@@ -30,6 +30,7 @@ export declare const AgentPartial: z.ZodObject<{
     resume: z.ZodOptional<z.ZodBoolean>;
     can_message: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>>;
     can_edit_agent_md: z.ZodOptional<z.ZodBoolean>;
+    can_ask_user: z.ZodOptional<z.ZodBoolean>;
     owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type AgentPartialT = z.infer<typeof AgentPartial>;
@@ -69,6 +70,7 @@ export declare const GlobalConfig: z.ZodObject<{
         resume: z.ZodOptional<z.ZodBoolean>;
         can_message: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>>;
         can_edit_agent_md: z.ZodOptional<z.ZodBoolean>;
+        can_ask_user: z.ZodOptional<z.ZodBoolean>;
         owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
@@ -112,6 +114,7 @@ export declare const ProjectConfig: z.ZodObject<{
         resume: z.ZodOptional<z.ZodBoolean>;
         can_message: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>>;
         can_edit_agent_md: z.ZodOptional<z.ZodBoolean>;
+        can_ask_user: z.ZodOptional<z.ZodBoolean>;
         owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
@@ -128,6 +131,6 @@ export interface DispatcherSettings {
 }
 export declare const DISPATCHER_DEFAULTS: DispatcherSettings;
 /** How a run turned out, independent of why it stopped (`EndReason`). Only "completed" means success. */
-export declare const RUN_OUTCOMES: readonly ["completed", "partial", "blocked", "failed", "cancelled"];
+export declare const RUN_OUTCOMES: readonly ["completed", "partial", "blocked", "failed", "waiting", "cancelled"];
 export type RunOutcome = (typeof RUN_OUTCOMES)[number];
-export declare function exitCodeForOutcome(outcome: RunOutcome): 0 | 1 | 2 | 130;
+export declare function exitCodeForOutcome(outcome: RunOutcome): 0 | 1 | 2 | 3 | 130;

package/dist/schema.js

@@ -34,6 +34,7 @@ export const AgentPartial = z
     resume: z.boolean().optional(),
     can_message: z.union([z.literal("all"), z.array(z.string())]).optional(),
     can_edit_agent_md: z.boolean().optional(),
+    can_ask_user: z.boolean().optional(),
     owns: z.array(z.string()).optional(),
 })
     .strict();
@@ -71,13 +72,15 @@ export const DISPATCHER_DEFAULTS = {
     log_max_bytes: 8 * 1024 * 1024,
 };
 /** How a run turned out, independent of why it stopped (`EndReason`). Only "completed" means success. */
-export const RUN_OUTCOMES = ["completed", "partial", "blocked", "failed", "cancelled"];
+export const RUN_OUTCOMES = ["completed", "partial", "blocked", "failed", "waiting", "cancelled"];
 export function exitCodeForOutcome(outcome) {
     switch (outcome) {
         case "completed":
             return 0;
         case "failed":
             return 1;
+        case "waiting":
+            return 3;
         case "cancelled":
             return 130;
         default:

package/dist/solo.d.ts

@@ -0,0 +1,12 @@
+import { type ResolvedProject } from "./config.js";
+/**
+ * The project as `run --agent <name>` sees it: `name` is the lead of a team of one, so the task goes to it and its `done` ends the run.
+ * It cannot mail anyone, ask the user, edit any AGENT.md or share the repo with a parallel agent. The other members stay listed, only
+ * so that their files stay protected; nobody mails them, so they are never woken.
+ * `globalAgents` (names in team.yaml) only improves the error message.
+ */
+export declare function soloProject(project: ResolvedProject, name: string, hints?: {
+    globalAgents?: string[];
+}): ResolvedProject;
+/** `project` with only `name` listed: what a preflight of a solo run needs to look at. */
+export declare function onlyAgent(project: ResolvedProject, name: string): ResolvedProject;

package/dist/solo.js

@@ -0,0 +1,28 @@
+import { ConfigError } from "./config.js";
+/**
+ * The project as `run --agent <name>` sees it: `name` is the lead of a team of one, so the task goes to it and its `done` ends the run.
+ * It cannot mail anyone, ask the user, edit any AGENT.md or share the repo with a parallel agent. The other members stay listed, only
+ * so that their files stay protected; nobody mails them, so they are never woken.
+ * `globalAgents` (names in team.yaml) only improves the error message.
+ */
+export function soloProject(project, name, hints = {}) {
+    const a = project.agents[name];
+    if (!a) {
+        const call = hints.globalAgents?.includes(name) ? ` "${name}" is in the global library: use \`agent-lyceum call ${name}\` to run it outside the project.` : "";
+        throw new ConfigError(`Agent "${name}" is not a member of project "${project.name}" (members: ${Object.keys(project.agents).join(", ")}).${call}`);
+    }
+    return {
+        ...project,
+        solo: "run",
+        lead: name,
+        dispatcher: { ...project.dispatcher, max_parallel: 1, workspace_mode: "shared" },
+        agents: { ...project.agents, [name]: { ...a, canMessage: [], canAskUser: false, canEditAgentMd: false, owns: [] } },
+    };
+}
+/** `project` with only `name` listed: what a preflight of a solo run needs to look at. */
+export function onlyAgent(project, name) {
+    const a = project.agents[name];
+    if (!a)
+        throw new ConfigError(`Agent "${name}" is not a member of project "${project.name}" (members: ${Object.keys(project.agents).join(", ")}).`);
+    return { ...project, agents: { [name]: a } };
+}

package/dist/status.d.ts

@@ -44,7 +44,7 @@ export interface RunReport {
     run_id: string;
     dir: string;
     /** running: its dispatcher is alive; interrupted: it died mid-run; ended: it stopped (see end_reason). */
-    state: "running" | "interrupted" | "ended";
+    state: "running" | "interrupted" | "ended" | "waiting";
     live: boolean;
     end_reason?: EndReason;
     outcome?: RunOutcome;
@@ -83,6 +83,12 @@ export interface RunReport {
         ok: boolean;
         error?: string;
     }>;
+    /** Present while the run waits for the user: the file to fill in and how many questions are still open. */
+    ask?: {
+        path: string;
+        total: number;
+        unanswered: number;
+    };
 }
 export interface AgentReport {
     name: string;
@@ -104,6 +110,8 @@ export interface StatusReport {
     };
     agents: AgentReport[];
     run?: RunReport;
+    /** Hints that a `memory tidy` might help. Only a suggestion; nothing runs it. */
+    memory_advice?: string[];
 }
 export interface TaskListReport {
     schema_version: 1;

package/dist/status.js

@@ -1,8 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
+import { askReplyPath, readAskReply } from "./ask-reply.js";
 import { RESULT_FILE } from "./dispatcher.js";
 import { bindRunProject, loadRunState, outcomeOf } from "./run-store.js";
 import { listUnread } from "./mailbox.js";
+import { tidyAdvice } from "./memory-tidy.js";
 import { inspectProjectLock, lockHolderAlive } from "./project-lock.js";
 export function latestRun(project) {
     const root = project.paths.runs;
@@ -76,8 +78,10 @@ function alive(pid) {
         return e.code === "EPERM";
     }
 }
-const OUTCOME_ZH = { completed: "完成", partial: "部分完成", blocked: "受阻", failed: "失敗", cancelled: "已取消" };
+const OUTCOME_ZH = { completed: "完成", partial: "部分完成", blocked: "受阻", failed: "失敗", waiting: "等待回答", cancelled: "已取消" };
 export function runStateLabel(s, live = alive(s.pid)) {
+    if (s.end_reason === "waiting")
+        return "等待回答";
     if (s.end_reason) {
         const o = outcomeOf(s);
         // Runs from before outcomes existed: keep what they recorded, but never present it as a checked success.
@@ -155,10 +159,23 @@ export function buildRunReport(run, project, opts = {}) {
     const result = path.join(run.dir, RESULT_FILE);
     const hasResult = detail && s.end_reason === "done" && fs.existsSync(result);
     const cur = s.steps?.find((x) => !x.done);
+    let ask;
+    if (s.end_reason === "waiting") {
+        try {
+            const r = readAskReply(run.dir);
+            if (r) {
+                const open = r.questions.filter((q) => !q.delivered);
+                ask = { path: askReplyPath(run.dir), total: open.length, unanswered: open.filter((q) => !q.answer?.value.trim()).length };
+            }
+        }
+        catch {
+            ask = { path: askReplyPath(run.dir), total: 0, unanswered: 0 };
+        }
+    }
     return {
         run_id: s.run_id,
         dir: run.dir,
-        state: s.end_reason ? "ended" : live ? "running" : "interrupted",
+        state: s.end_reason === "waiting" ? "waiting" : s.end_reason ? "ended" : live ? "running" : "interrupted",
         live,
         end_reason: s.end_reason,
         outcome: o?.outcome,
@@ -186,6 +203,7 @@ export function buildRunReport(run, project, opts = {}) {
         mail_layout: s.mail_layout,
         workspace_mode: s.workspace_mode,
         last_wake: s.last_wake,
+        ...(ask ? { ask } : {}),
     };
 }
 const projectInfo = (p) => ({ name: p.name, dir: p.dir, lead: p.lead });
@@ -203,6 +221,13 @@ export function buildStatusReport(base, runId) {
     // Mail is per run: count the unread mail of the run being shown.
     const project = run ? bindRunProject(base, run.dir, run.state.mail_layout) : base;
     const report = run ? buildRunReport(run, base) : undefined;
+    let advice = [];
+    try {
+        advice = tidyAdvice(base).map((a) => `${a.agent}: ${a.reason}`);
+    }
+    catch {
+        /* a hint only: never let it break status */
+    }
     return {
         schema_version: 1,
         project: projectInfo(base),
@@ -214,6 +239,7 @@ export function buildStatusReport(base, runId) {
             last_wake: run?.state.last_wake[a.name],
         })),
         run: report,
+        ...(advice.length ? { memory_advice: advice } : {}),
     };
 }
 /** Every run of the project, newest first. */
@@ -274,6 +300,8 @@ function summaryBlock(run, now, c) {
     const lastWake = (s.wakes ?? []).at(-1);
     if (lastWake)
         lines.push(`${L("上一次：")}#${lastWake.round} ${c.cyan(lastWake.agent)} ${okText(c, lastWake.ok)} → ${sentText(lastWake.sent)}`);
+    if (s.ask)
+        lines.push(`${L("等你回答：")}${s.ask.unanswered}/${s.ask.total} 題未答 → ${s.ask.path}`, c.dim(`          填完後執行 agent-lyceum answer ${s.run_id}（或 resume）`));
     lines.push(`${L("流程：")}${flowLine(s, c)}`);
     return lines;
 }
@@ -401,5 +429,7 @@ export function formatStatusReport(report, now = Date.now(), color = false) {
     const lines = [`${c.bold("專案：")}${report.project.name}  ${c.dim(`（repo：${report.project.dir}）`)}`, "", ...summaryBlock(run, now, c), "", ...table];
     if (run)
         lines.push("", `輸出 tokens：${tokens(run.output_tokens)}`);
+    if (report.memory_advice?.length)
+        lines.push("", `記憶：${report.memory_advice.join("；")}（建議執行 agent-lyceum memory tidy -p ${report.project.name}；status 只提示，不會自動整理）`);
     return lines.join("\n");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-lyceum",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Config + dispatcher for teams of Claude Code / Codex agents with scoped context and file-based mailboxes",
   "keywords": [
     "ai",
@@ -58,7 +58,7 @@
     "@types/node": "^20.19.43",
     "tsx": "^4.19.0",
     "typescript": "^7.0.2",
-    "vite": "^7.3.7",
+    "vite": "^8.3.3",
     "vitest": "^4.1.11"
   }
 }