agent-lyceum 0.17.2 → 0.18.0

package/dist/policy.d.ts

@@ -8,7 +8,6 @@ export interface AgentEnforcement {
     otherContext: Level;
     shared: Level;
     repoInstructions: Level;
-    owns: Level;
     /** Absolute paths outside the repo this agent may write. */
     writablePaths: string[];
     notes: string[];
@@ -22,9 +21,6 @@ export interface WritePolicy {
     allowFiles: string[];
     /** Files/dirs that must stay unwritable (checked even inside the repo). */
     deny: string[];
-    /** Repo-relative globs the agent owns (only enforced when max_parallel > 1). */
-    owns: string[];
-    restrictRepoToOwns: boolean;
 }
 export declare function commonFile(project: ResolvedProject): string;
 export declare function outboxDir(project: ResolvedProject, agent: string): string;
@@ -42,7 +38,5 @@ export declare function sharedIndex(project: ResolvedProject): string | undefine
 export declare function repoDirFor(project: ResolvedProject, agent: string): string;
 export declare function writePolicy(project: ResolvedProject, agent: ResolvedAgent): WritePolicy;
 export declare function enforcementFor(project: ResolvedProject, agent: ResolvedAgent): AgentEnforcement;
-/** Static directory prefixes (absolute) of an agent's `owns` globs. */
-export declare function ownsDirs(project: ResolvedProject, agent: ResolvedAgent): string[];
 /** Can `agent` legitimately change this protected file? */
 export declare function mayEditProtected(project: ResolvedProject, agent: ResolvedAgent, file: string): boolean;

package/dist/policy.js

@@ -1,7 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
 import { findOnPath } from "./fs-util.js";
-import { globStaticPrefix } from "./paths.js";
 export function commonFile(project) {
     return path.join(project.paths.shared, "common", "COMMON.md");
 }
@@ -123,8 +122,6 @@ export function writePolicy(project, agent) {
         readDirs: shared && !mayWriteShared ? [shared] : [],
         allowFiles,
         deny: [...new Set(deny)],
-        owns: agent.owns,
-        restrictRepoToOwns: project.dispatcher.max_parallel > 1 && agent.owns.length > 0 && !isLead,
     };
 }
 let sandboxProbe;
@@ -143,12 +140,11 @@ export function enforcementFor(project, agent) {
     const pol = writePolicy(project, agent);
     const os = osSandboxAvailable();
     const notes = [];
-    const parallel = project.dispatcher.max_parallel > 1;
     const isLeadAgent = agent.name === project.lead;
     let e;
     if (agent.runtime === "claude-code") {
         const lvl = os ? "os" : "tool-rules";
-        e = { memory: lvl, agentMd: lvl, otherContext: lvl, shared: isLeadAgent ? "n/a" : lvl, repoInstructions: lvl, owns: parallel ? "tool-rules" : "n/a" };
+        e = { memory: lvl, agentMd: lvl, otherContext: lvl, shared: isLeadAgent ? "n/a" : lvl, repoInstructions: lvl };
         if (!os)
             notes.push("OS sandbox unavailable (Windows, or Linux without bubblewrap): Bash can bypass Edit rules.");
         if (!isLeadAgent && !os)
@@ -156,7 +152,7 @@ export function enforcementFor(project, agent) {
     }
     else {
         const lvl = os ? "os" : "prompt-only";
-        e = { memory: lvl, agentMd: lvl, otherContext: lvl, shared: isLeadAgent ? "n/a" : os ? "os" : "post-hoc", repoInstructions: "post-hoc", owns: parallel ? "prompt-only" : "n/a" };
+        e = { memory: lvl, agentMd: lvl, otherContext: lvl, shared: isLeadAgent ? "n/a" : os ? "os" : "post-hoc", repoInstructions: "post-hoc" };
         notes.push("Codex cannot forbid single files inside the repo; CLAUDE.md/AGENTS.md changes are detected and reverted after each wake-up.");
         if (!isLeadAgent && !os)
             notes.push("Without the OS sandbox only the handoff index (_shared/MEMORY.md) is checked after each wake-up; other files in _shared are not protected.");
@@ -171,10 +167,6 @@ export function enforcementFor(project, agent) {
         notes,
     };
 }
-/** Static directory prefixes (absolute) of an agent's `owns` globs. */
-export function ownsDirs(project, agent) {
-    return agent.owns.map((g) => path.join(project.dir, globStaticPrefix(g)));
-}
 /** Can `agent` legitimately change this protected file? */
 export function mayEditProtected(project, agent, file) {
     return writePolicy(project, agent).allowFiles.includes(file);

package/dist/project-lock.d.ts

@@ -4,10 +4,13 @@ export declare const LOCK_FILE = "lock.json";
 export declare const LOCKS_DIR = "locks";
 export interface LockOptions {
     heartbeatMs?: number;
-    /** Most runs that may hold a lock of this project at once, this one included. Default 1. */
-    maxConcurrent?: number;
+    /** The run works directly in the project checkout (not in its own worktree): only one such run may be active. It is written with `exclusive` too, so older binaries keep out. */
+    checkout?: boolean;
     /** The holder needs the whole project (e.g. a memory tidy): refused while any other lock is alive, and it keeps every other lock out while held. */
     exclusive?: boolean;
+    /** For a checkout run's refusal message: the checkout directory, and why this run has no worktree. */
+    dir?: string;
+    reason?: string;
 }
 export interface LockInfo {
     token: string;
@@ -20,7 +23,12 @@ export interface LockInfo {
     heartbeat_at: string;
     /** Held by an operation that needs the project to itself (a memory tidy). */
     exclusive?: boolean;
+    /** `true`: works in the project checkout; `false`: in its own worktree (or holds no files, like `clear`). Absent: an older version's run, treated as a checkout run. */
+    checkout?: boolean;
 }
+export type LockKind = "checkout" | "whole" | "worktree";
+/** What a lock protects: the checkout, the whole project (tidy/restore), or nothing shared (a worktree run). Locks of older versions count as checkout runs. */
+export declare function lockKind(l: Pick<LockInfo, "exclusive" | "checkout">): LockKind;
 export interface ProjectLease {
     readonly info: LockInfo;
     /** True once another process replaced our lock file; the run should stop writing. */

package/dist/project-lock.js

@@ -10,6 +10,16 @@ export const LOCK_FILE = "lock.json";
 export const LOCKS_DIR = "locks";
 const ADMIT_FILE = ".admit";
 const HEARTBEAT_MS = 5000;
+/** What a lock protects: the checkout, the whole project (tidy/restore), or nothing shared (a worktree run). Locks of older versions count as checkout runs. */
+export function lockKind(l) {
+    if (l.exclusive && l.checkout === true)
+        return "checkout";
+    if (l.exclusive)
+        return "whole";
+    if (l.checkout === false)
+        return "worktree";
+    return "checkout";
+}
 /** Field 22 (starttime, in clock ticks) of a /proc/<pid>/stat line. The command name (field 2) may contain spaces and ")". */
 export function parseProcStat(text) {
     const end = text.lastIndexOf(")");
@@ -137,10 +147,9 @@ function heldError(info) {
     return new Error(`Run ${info.run_id} is still running (pid ${info.pid}, heartbeat ${Number.isFinite(late) ? late : "?"}s ago). ` +
         `A run cannot be started or resumed twice; wait for it to end, or stop it first.`);
 }
-function limitError(active, max) {
-    const list = active.map((l) => `${l.run_id} (pid ${l.pid})`).join(", ");
-    return new Error(`This project already has ${active.length} run(s) active: ${list}. At most ${max} may run at once (dispatcher.max_concurrent_runs: ${max}); ` +
-        `wait for one to end, stop one, or raise max_concurrent_runs in project.yaml.`);
+function checkoutBusyError(holder, dir, reason) {
+    return new Error(`Run ${holder.run_id} (pid ${holder.pid}) is working directly in ${dir}, and this run would too (${reason}), so only one can be active. ` +
+        `Wait for it to end or stop it; in a git repo with a commit, runs work in their own worktrees and can run side by side.`);
 }
 function exclusiveError(holder) {
     return new Error(`${holder.run_id} (pid ${holder.pid}) needs the project to itself (a memory tidy or restore); wait for it to finish, then try again.`);
@@ -214,7 +223,6 @@ export function acquireProjectLock(root, runId, opts = {}) {
     assertRunId(runId);
     fs.mkdirSync(path.join(root, LOCKS_DIR), { recursive: true });
     const file = runLockFile(root, runId);
-    const max = opts.maxConcurrent ?? 1;
     const now = new Date().toISOString();
     const info = {
         token: crypto.randomBytes(16).toString("hex"),
@@ -224,8 +232,10 @@ export function acquireProjectLock(root, runId, opts = {}) {
         run_id: runId,
         acquired_at: now,
         heartbeat_at: now,
-        ...(opts.exclusive ? { exclusive: true } : {}),
+        ...(opts.exclusive || opts.checkout ? { exclusive: true } : {}),
+        checkout: opts.checkout === true,
     };
+    const kind = lockKind(info);
     withAdmission(root, () => {
         // 1. This run's own lock: a live holder means it is already running; a dead one is replaced.
         const own = readLockFile(file);
@@ -246,13 +256,14 @@ export function acquireProjectLock(root, runId, opts = {}) {
             fs.rmSync(legacyFile(root), { force: true });
         // 3. The other runs that are active now.
         const active = listRunLocks(root).filter((l) => l.run_id !== runId && lockHolderAlive(l));
-        const exclusiveHolder = active.find((l) => l.exclusive);
-        if (exclusiveHolder)
-            throw exclusiveError(exclusiveHolder);
-        if (opts.exclusive && active.length)
+        const whole = active.find((l) => lockKind(l) === "whole");
+        if (whole)
+            throw exclusiveError(whole);
+        if (kind === "whole" && active.length)
             throw needsIdleError(active);
-        if (active.length >= max)
-            throw limitError(active, max);
+        const busy = kind === "checkout" ? active.find((l) => lockKind(l) === "checkout") : undefined;
+        if (busy)
+            throw checkoutBusyError(busy, opts.dir ?? root, opts.reason ?? "no worktree is available for it");
         if (!tryCreate(file, info))
             throw new Error(`Could not take the run lock ${file}; another process just took it. Try again.`);
     });

package/dist/prompt.js

@@ -131,9 +131,6 @@ export function buildSystemPrompt(project, agent) {
     lines.push("", "## Rules");
     lines.push("- Never edit any `AGENT.md`, `COMMON.md`, or the repository's own `CLAUDE.md`/`AGENTS.md`" +
         (isLead || agent.canEditAgentMd ? " unless you need to as lead (changes are logged)." : "."), "- Never touch another agent's memory, inbox or outbox, or the team's config files.", `- The shared team context is in \`${commonFile(project)}\`${isLead ? " (you maintain it; keep it short)" : " (read-only)"}.`, PR_ATTRIBUTION_RULE, NO_DAEMONS_RULE);
-    if (project.dispatcher.max_parallel > 1 && agent.owns.length > 0 && !isLead) {
-        lines.push(`- You own these repo paths and must only change files there: ${agent.owns.join(", ")}.`);
-    }
     return lines.join("\n");
 }
 /** Messages one wake-up handles: the oldest one, or for the lead a run of `reply`/`failure` mail (up to LEAD_BATCH_LIMIT) so it decides once on all of it. */

package/dist/run-session.d.ts

@@ -1,7 +1,7 @@
 import { type Invoker } from "./adapters/index.js";
 import type { ResolvedProject } from "./config.js";
 import type { RunOutcome } from "./schema.js";
-import { type ResultBranch } from "./worktree.js";
+import { type ResultBranch, type WorkspacePlan } from "./worktree.js";
 import { newRunId, type EndReason, type RunState } from "./run-store.js";
 import { type PreparedTask } from "./task.js";
 import { type CommandRunner, type PrOutcome } from "./open-pr.js";
@@ -52,6 +52,8 @@ export interface RunOptions {
     task?: PreparedTask;
     /** Continue this earlier run (same run dir, sessions and counters) instead of starting a new one. */
     resume?: RunState;
+    /** Where the run's agents work, decided by `planWorkspace` before the run's lock was taken; the session never recomputes it. */
+    plan: WorkspacePlan;
     /** Reopen a done run: this text becomes a new task for the lead. Only with `resume` of a run that ended `done`. */
     followup?: {
         text: string;

package/dist/run-session.js

@@ -6,13 +6,12 @@ import { ProtectedGuard } from "./guard.js";
 import { addBatch, askersWithAnswers, askReplyPath, checkAnswers, describeCheck, isComplete, markDelivered, parseAskBody, readAskReply, renderAnswers, resolveOptionLetters, 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";
 import { createRunLog } from "./run-log.js";
 import { endOutcome, resolveDoneOutcome } from "./run-outcome.js";
-import { outboxDir, ownsDirs, sharedIndex } from "./policy.js";
+import { outboxDir, sharedIndex } from "./policy.js";
 import { buildSystemPrompt, buildUserPrompt, pickMessages } from "./prompt.js";
 import { atomicWrite, readFileCapped } from "./fs-util.js";
-import { assertWorktreeRunnable, collectAgentChanges, dirtyPaths, existingAgentWorkspace, finishLeadBranch, integrateAgentChanges, prepareAgentWorkspace, recutLeadWorkspace, refusedIntegration, resolveWorkspaceMode, snapshotBase, snapshotHead, toplevel } from "./worktree.js";
+import { assertWorktreeRunnable, collectAgentChanges, dirtyPaths, existingAgentWorkspace, finishLeadBranch, integrateAgentChanges, prepareAgentWorkspace, recutLeadWorkspace, refusedIntegration, snapshotBase, snapshotHead, toplevel } from "./worktree.js";
 import { bindRunProject, newRunId, newRunState, roundLimit, roundsLabel, saveRunState } from "./run-store.js";
 import { soloProject } from "./solo.js";
 import { taskMessageBody } from "./task.js";
@@ -91,12 +90,13 @@ export class RunSession {
         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(base, runDir, layout);
-        // Parallel agents work in their own git worktrees; refuse early (before anything is written) when that cannot be done.
-        // Whether the lead has its own worktree is decided when the run starts and kept for its resumes, whatever the config says by then.
-        const concurrent = resume ? resume.lead_workspace === true : cfg.max_concurrent_runs > 1;
-        const wsMode = concurrent ? "worktree" : resolveWorkspaceMode({ ...cfg, max_concurrent_runs: 1 });
-        if (wsMode === "worktree")
-            assertWorktreeRunnable(project, { fresh: !resume, concurrent });
+        // Where agents work was decided before the lock was taken and is kept for the run's resumes. A resumed run that uses worktrees
+        // is refused early (before anything is written) when its repo can no longer give them.
+        const { plan } = opts;
+        const concurrent = plan.leadWorktree;
+        const wsMode = plan.mode;
+        if (resume && wsMode === "worktree")
+            assertWorktreeRunnable(project);
         // Concurrent runs: the lead works in its own worktree cut from HEAD, so no other run (and not you) shares its files.
         let leadSpace;
         let recut = false;
@@ -123,6 +123,9 @@ export class RunSession {
             say(`  starting from HEAD ${leadSpace.base.slice(0, 8)}${uncommitted ? ` (your ${uncommitted} uncommitted file(s) are not part of this run)` : ""}; ${project.lead} works on branch ${leadSpace.branch}`);
             log("lead-workspace", { base: leadSpace.base, branch: leadSpace.branch, dir: leadSpace.dir, uncommitted });
         }
+        if (!resume && plan.mode === "shared" && plan.reason) {
+            say(`  agents take turns in ${project.dir} (no separate git worktrees: ${plan.reason}); commit to a git repo to run them in parallel`);
+        }
         let state;
         if (resume) {
             state = { ...resume, max_rounds: roundLimit(resume, cfg.max_rounds), pid: process.pid, ended_at: undefined, end_reason: undefined, failure: undefined, workspace_mode: wsMode, outcome: undefined, outcome_note: undefined, verification: undefined, active: {}, wakes: [...resume.wakes] };
@@ -261,26 +264,13 @@ export class RunSession {
         return rows.map((r) => r.a);
     }
     pickBatch(pending) {
-        const { cfg, project } = this;
+        const { project } = this;
         const lead = pending.find((a) => a.name === project.lead);
-        if (lead || cfg.max_parallel <= 1)
-            return [must(lead ?? pending[0], "an agent to wake")];
-        const batch = [];
-        const taken = [];
-        for (const a of pending) {
-            if (batch.length >= cfg.max_parallel)
-                break;
-            const mine = ownsDirs(project, a);
-            const clash = mine.some((x) => taken.some((y) => isInside(x, y) || isInside(y, x)));
-            if (clash || mine.length === 0) {
-                if (batch.length === 0)
-                    batch.push(a);
-                continue;
-            }
-            batch.push(a);
-            taken.push(...mine);
-        }
-        return batch;
+        if (lead)
+            return [lead];
+        if (this.opts.plan.mode !== "worktree")
+            return [must(pending[0], "an agent to wake")];
+        return pending;
     }
     async wake(agent) {
         const { invoke, say, cfg, runDir, project, log, state, claims, attempts, noSessionNoted, opts } = this;
@@ -399,7 +389,7 @@ export class RunSession {
         let changes;
         let r;
         try {
-            changes = collectAgentChanges(ws, agent.owns);
+            changes = collectAgentChanges(ws);
             r = integrateAgentChanges(project, changes, this.leadSpace);
         }
         catch (e) {
@@ -669,7 +659,7 @@ export class RunSession {
         if (endReason !== "done" || outcome !== "completed")
             return skip(`the run did not end completed (${endReason}, outcome ${outcome}).`);
         if (!this.leadSpace)
-            return skip("this run has no worktree of its own, so there is no branch to push. Set dispatcher.max_concurrent_runs: 2 (or more) in project.yaml.");
+            return skip(`this run works directly in ${this.project.dir} (not a git repo with a commit), so there is no branch to push.`);
         if (!rb)
             return skip(`the work could not be committed on ${this.leadSpace.branch}.`);
         if (!rb.files)

package/dist/run-store.d.ts

@@ -78,7 +78,7 @@ export interface RunState {
     snapshots?: number;
     /** Concurrent runs: where the lead's work ended up (`git merge <branch>`). Set when the run ends. */
     result_branch?: ResultBranch;
-    /** Set when the run started with the lead in its own worktree (max_concurrent_runs > 1 then); its resumes keep that, whatever the config says later. */
+    /** Set when the run started with the lead in its own worktree (isolation mode); its resumes keep that, whatever the config says later. */
     lead_workspace?: true;
     /** The pull request the dispatcher opened for this run (when the lead asked for one and it worked). */
     pr_url?: string;

package/dist/scaffold.js

@@ -86,9 +86,6 @@ team:
   lead: lead
 dispatcher:
   max_rounds: 0         # 0 = no limit on wake-ups; set a number to stop a run after that many
-  max_parallel: 1       # >1 needs non-overlapping "owns" for every non-lead agent, and a git repo
-  max_concurrent_runs: 1  # >1 lets several runs of this project be active at once, each in its own git worktree (needs a git repo); every run's work stays on its own branch
-  workspace_mode: auto  # auto = a git worktree per non-lead agent when max_parallel > 1; shared | worktree to force
   wake_timeout_sec: 600
   retry: 2              # an agent that fails is called again up to this many times; if it still fails the run stops (resume it after fixing the cause)
   log_max_bytes: 8388608  # log.jsonl is renamed to log.1.jsonl past this size; 0 = never
@@ -101,11 +98,9 @@ agents:
     can_edit_agent_md: true
   fe-member:
     can_message: [lead]
-    # owns: ["src/web/**"]
     # memory: { project: agents/fe-member/memory }
   qa-member:
     can_message: [lead]
-    # owns: ["tests/**"]
 `;
     fs.writeFileSync(pp.config, yaml);
     const common = path.join(pp.shared, "common", "COMMON.md");

package/dist/schema.d.ts

@@ -39,23 +39,22 @@ export declare const AgentPartial: z.ZodObject<{
         none: "none";
         search: "search";
     }>>;
-    owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    owns: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strict>;
 export type AgentPartialT = z.infer<typeof AgentPartial>;
 export declare const DispatcherPartial: z.ZodObject<{
     max_rounds: z.ZodOptional<z.ZodNumber>;
-    max_parallel: z.ZodOptional<z.ZodNumber>;
-    max_concurrent_runs: z.ZodOptional<z.ZodNumber>;
+    max_parallel: z.ZodOptional<z.ZodUnknown>;
+    max_concurrent_runs: z.ZodOptional<z.ZodUnknown>;
     wake_timeout_sec: z.ZodOptional<z.ZodNumber>;
     retry: z.ZodOptional<z.ZodNumber>;
     strict: z.ZodOptional<z.ZodBoolean>;
-    workspace_mode: z.ZodOptional<z.ZodEnum<{
-        auto: "auto";
-        shared: "shared";
-        worktree: "worktree";
-    }>>;
+    workspace_mode: z.ZodOptional<z.ZodUnknown>;
     log_max_bytes: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
+/** Settings that no longer exist; files that still carry them load, and `validate` warns. */
+export declare const REMOVED_DISPATCHER_KEYS: readonly ["max_parallel", "max_concurrent_runs", "workspace_mode"];
+export declare const REMOVED_AGENT_KEYS: readonly ["owns"];
 export declare const GlobalConfig: z.ZodObject<{
     agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         runtime: z.ZodOptional<z.ZodEnum<{
@@ -85,7 +84,7 @@ export declare const GlobalConfig: z.ZodObject<{
             none: "none";
             search: "search";
         }>>;
-        owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        owns: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const ProjectConfig: z.ZodObject<{
@@ -95,16 +94,12 @@ export declare const ProjectConfig: z.ZodObject<{
     }, z.core.$strict>;
     dispatcher: z.ZodDefault<z.ZodObject<{
         max_rounds: z.ZodOptional<z.ZodNumber>;
-        max_parallel: z.ZodOptional<z.ZodNumber>;
-        max_concurrent_runs: z.ZodOptional<z.ZodNumber>;
+        max_parallel: z.ZodOptional<z.ZodUnknown>;
+        max_concurrent_runs: z.ZodOptional<z.ZodUnknown>;
         wake_timeout_sec: z.ZodOptional<z.ZodNumber>;
         retry: z.ZodOptional<z.ZodNumber>;
         strict: z.ZodOptional<z.ZodBoolean>;
-        workspace_mode: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            shared: "shared";
-            worktree: "worktree";
-        }>>;
+        workspace_mode: z.ZodOptional<z.ZodUnknown>;
         log_max_bytes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
     agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -135,19 +130,14 @@ export declare const ProjectConfig: z.ZodObject<{
             none: "none";
             search: "search";
         }>>;
-        owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        owns: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export interface DispatcherSettings {
     max_rounds: number;
-    max_parallel: number;
-    /** How many runs of one project may be active at once. Above 1, every run works in its own git worktree. */
-    max_concurrent_runs: number;
     wake_timeout_sec: number;
     retry: number;
     strict: boolean;
-    /** "auto": a git worktree per non-lead agent when agents can run in parallel, otherwise one shared checkout. */
-    workspace_mode: "auto" | "shared" | "worktree";
     /** log.jsonl is rotated to log.1.jsonl past this size; 0 = never. */
     log_max_bytes: number;
 }

package/dist/schema.js

@@ -38,21 +38,25 @@ export const AgentPartial = z
     can_edit_agent_md: z.boolean().optional(),
     can_ask_user: z.boolean().optional(),
     allow_web: z.enum(WEB_LEVELS).optional(),
-    owns: z.array(z.string()).optional(),
+    /** Removed setting: still accepted (any value) so old files load; ignored, with a warning from `validate`. */
+    owns: z.unknown().optional(),
 })
     .strict();
 export const DispatcherPartial = z
     .object({
     max_rounds: z.number().int().min(0).optional(),
-    max_parallel: z.number().int().positive().optional(),
-    max_concurrent_runs: z.number().int().positive().optional(),
+    max_parallel: z.unknown().optional(),
+    max_concurrent_runs: z.unknown().optional(),
     wake_timeout_sec: z.number().int().positive().optional(),
     retry: z.number().int().min(0).optional(),
     strict: z.boolean().optional(),
-    workspace_mode: z.enum(["auto", "shared", "worktree"]).optional(),
+    workspace_mode: z.unknown().optional(),
     log_max_bytes: z.number().int().min(0).optional(),
 })
     .strict();
+/** Settings that no longer exist; files that still carry them load, and `validate` warns. */
+export const REMOVED_DISPATCHER_KEYS = ["max_parallel", "max_concurrent_runs", "workspace_mode"];
+export const REMOVED_AGENT_KEYS = ["owns"];
 export const GlobalConfig = z
     .object({
     agents: z.record(z.string(), AgentPartial).default({}),
@@ -68,12 +72,9 @@ export const ProjectConfig = z
     .strict();
 export const DISPATCHER_DEFAULTS = {
     max_rounds: 0,
-    max_parallel: 1,
-    max_concurrent_runs: 1,
     wake_timeout_sec: 600,
     retry: 2,
     strict: false,
-    workspace_mode: "auto",
     log_max_bytes: 8 * 1024 * 1024,
 };
 /** How a run turned out, independent of why it stopped (`EndReason`). Only "completed" means success. */

package/dist/solo.js

@@ -15,8 +15,7 @@ export function soloProject(project, name, hints = {}) {
         ...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: [] } },
+        agents: { ...project.agents, [name]: { ...a, canMessage: [], canAskUser: false, canEditAgentMd: false } },
     };
 }
 /** `project` with only `name` listed: what a preflight of a solo run needs to look at. */

package/dist/validate.js

@@ -1,8 +1,7 @@
 import fs from "node:fs";
-import { enforcementFor, memoryDirs, ownsDirs } from "./policy.js";
+import { enforcementFor, memoryDirs } from "./policy.js";
 import { isInside } from "./paths.js";
 import { inferRuntime, RUNTIME_EFFORTS } from "./schema.js";
-import { isGitRepo, resolveWorkspaceMode } from "./worktree.js";
 import { must } from "./assert.js";
 export function validateProject(project) {
     const issues = [];
@@ -55,40 +54,8 @@ export function validateProject(project) {
             }
         }
     }
-    // Parallelism requires disjoint `owns`.
-    if (project.dispatcher.max_parallel > 1) {
-        const withOwns = Object.values(project.agents).filter((a) => a.name !== project.lead);
-        for (const a of withOwns) {
-            if (a.owns.length === 0)
-                err(`max_parallel > 1 requires "owns" for agent "${a.name}".`);
-        }
-        for (let i = 0; i < withOwns.length; i++) {
-            for (let j = i + 1; j < withOwns.length; j++) {
-                const ai = must(withOwns[i], "agent");
-                const aj = must(withOwns[j], "agent");
-                for (const x of ownsDirs(project, ai)) {
-                    for (const y of ownsDirs(project, aj)) {
-                        if (isInside(x, y) || isInside(y, x)) {
-                            err(`"owns" overlap: ${ai.name} (${x}) vs ${aj.name} (${y})`);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Parallel agents and concurrent runs each need their own checkout, which needs git.
-    const concurrent = project.dispatcher.max_concurrent_runs > 1;
-    if (concurrent && project.dispatcher.workspace_mode === "shared") {
-        err(`dispatcher.workspace_mode "shared" cannot be combined with max_concurrent_runs > 1: every run needs its own git worktree (use "auto" or "worktree").`);
-    }
-    else if (concurrent && fs.existsSync(project.dir) && !isGitRepo(project.dir)) {
-        err(`max_concurrent_runs > 1 needs ${project.dir} to be a git repository (each run works in its own git worktree). Set max_concurrent_runs: 1.`);
-    }
-    else if (project.dispatcher.workspace_mode === "shared" && project.dispatcher.max_parallel > 1) {
-        err(`dispatcher.workspace_mode "shared" cannot be combined with max_parallel > 1: parallel agents need separate git worktrees (use "auto" or "worktree").`);
-    }
-    else if (!concurrent && resolveWorkspaceMode(project.dispatcher) === "worktree" && fs.existsSync(project.dir) && !isGitRepo(project.dir)) {
-        err(`Parallel runs (worktree workspaces) need ${project.dir} to be a git repository. Run sequentially instead (max_parallel: 1, workspace_mode: auto or shared).`);
+    for (const ig of project.ignoredSettings ?? []) {
+        warn(`${ig.file}: ignoring removed setting(s) ${ig.keys.join(", ")}. Concurrency needs no configuration now: in a git repo with a commit every run and every agent gets its own worktree. Delete these lines.`);
     }
     // Context paths should live outside the repo (the tool never writes into it).
     for (const a of Object.values(project.agents)) {
@@ -109,10 +76,10 @@ export function validateProject(project) {
     return { issues, enforcement, ok: !issues.some((i) => i.level === "error") };
 }
 export function formatEnforcement(list) {
-    const header = ["agent", "runtime", "memory", "AGENT.md", "others' ctx", "handoff", "repo CLAUDE/AGENTS", "owns"];
+    const header = ["agent", "runtime", "memory", "AGENT.md", "others' ctx", "handoff", "repo CLAUDE/AGENTS"];
     const rows = [header];
     for (const e of list)
-        rows.push([e.agent, e.runtime, e.memory, e.agentMd, e.otherContext, e.shared, e.repoInstructions, e.owns]);
+        rows.push([e.agent, e.runtime, e.memory, e.agentMd, e.otherContext, e.shared, e.repoInstructions]);
     const w = header.map((_, i) => Math.max(...rows.map((r) => (r[i] ?? "").length)));
     const lines = rows.map((r) => r.map((c, i) => c.padEnd(w[i] ?? 0)).join("  ").trimEnd());
     lines.splice(1, 0, w.map((n) => "-".repeat(n)).join("  "));

package/dist/worktree.d.ts

@@ -1,8 +1,6 @@
 import type { ResolvedProject } from "./config.js";
-import type { DispatcherSettings } from "./schema.js";
+import type { RunState } from "./run-store.js";
 export type WorkspaceMode = "shared" | "worktree";
-/** Agents share the repo, or each non-lead agent gets its own git worktree. `auto` picks worktrees as soon as agents can run in parallel; several concurrent runs always do. */
-export declare function resolveWorkspaceMode(d: Pick<DispatcherSettings, "workspace_mode" | "max_parallel"> & Partial<Pick<DispatcherSettings, "max_concurrent_runs">>): WorkspaceMode;
 export interface AgentWorkspace {
     agent: string;
     /** Root of the git worktree. */
@@ -58,11 +56,22 @@ export declare function isGitRepo(dir: string): boolean;
 export declare const toplevel: (dir: string) => string;
 /** Files in the repo with changes nobody committed (modified, staged or new and not ignored). Paths are relative to the repo root. */
 export declare function dirtyPaths(dir: string): string[];
-/** Refuse to start a worktree run when it cannot be isolated; returns nothing when it is fine. */
-export declare function assertWorktreeRunnable(project: ResolvedProject, opts: {
-    fresh: boolean;
-    concurrent?: boolean;
-}): void;
+/** Why `dir` cannot give every run and agent its own git worktree, or undefined when it can. */
+export declare function isolationBlocker(dir: string): string | undefined;
+export interface WorkspacePlan {
+    mode: WorkspaceMode;
+    /** The lead works in its own worktree (isolation mode); otherwise it works in the checkout. */
+    leadWorktree: boolean;
+    /** Why the run works in the checkout, when it was probed. */
+    reason?: string;
+}
+/**
+ * Where a run's agents work. A new run is isolated when the project dir can be (see `isolationBlocker`), otherwise it shares the
+ * checkout. A resumed run keeps what its state recorded, whatever the repo looks like now. Decided once, before the run's lock is taken.
+ */
+export declare function planWorkspace(project: ResolvedProject, resume?: RunState): WorkspacePlan;
+/** Refuse to resume a worktree run when its repo can no longer be isolated; returns nothing when it is fine. */
+export declare function assertWorktreeRunnable(project: ResolvedProject): void;
 /** `refs/agent-lyceum/<run>/base-0` pointing at the repo's HEAD: where a concurrent run starts. Nothing in the repo changes. */
 export declare function snapshotHead(project: ResolvedProject, runId: string): string;
 /**
@@ -97,8 +106,6 @@ export interface ChangeSet {
     /** Why these changes may not be integrated (empty when they may). */
     violations: string[];
 }
-/** Glob as used in `owns`: `**` crosses folders, `*` and `?` stay within one, `{a,b}` alternates. */
-export declare function globMatch(glob: string, file: string): boolean;
 /** Commit whatever is in an agent's worktree (no hooks, no signing, dispatcher identity). Returns the HEAD afterwards and whether a commit was made. */
 export declare function commitWorkspace(ws: AgentWorkspace, message: string): {
     head: string;
@@ -106,10 +113,10 @@ export declare function commitWorkspace(ws: AgentWorkspace, message: string): {
 };
 /**
  * Commit whatever the agent left in its worktree and list what changed since its snapshot, checking every
- * changed path (modified, added, deleted, or either end of a rename) against the agent's `owns`, the project
+ * changed path (modified, added, deleted, or either end of a rename) against the project
  * folder, the protected instruction files, and symlink/submodule rules. Nothing is applied here.
  */
-export declare function collectAgentChanges(workspace: AgentWorkspace, owns: string[]): ChangeSet;
+export declare function collectAgentChanges(workspace: AgentWorkspace): ChangeSet;
 export type IntegrationResult = {
     status: "integrated";
     files: ChangedFile[];