agent-lyceum 0.17.3 → 0.18.0

package/README.md

@@ -10,7 +10,7 @@ Give a task to a **team of agents** (Claude Code and/or Codex) instead of one ov
 
 - **Roles that stay in role.** Each agent has its own persona (`AGENT.md`) and long-term memory, so a reviewer keeps reviewing instead of drifting into writing code.
 - **Agents can't rewrite the rules.** An agent can only write its own memory and outbox. It can't touch other agents' context or its own persona, and this is enforced by the OS sandbox where possible, not just by a prompt. See [Write scope](docs/write-scope.md).
-- **Mix runtimes.** Claude Code and Codex agents work in the same team, and each can be limited to the paths it owns.
+- **Mix runtimes.** Claude Code and Codex agents work in the same team.
 - **Nothing hidden.** Agents talk through plain-file mailboxes, so every message, decision and memory is a file you can read, grep and diff. The dispatcher never merges for you.
 
 **Not a fit** for small, one-shot edits: a single Claude Code or Codex session is faster and cheaper. Use a team when the task is big enough to split, review or run in parallel.
@@ -39,7 +39,7 @@ Latest unreleased code: `npx github:gogogohuang/agent-lyceum <command>`.
 3. Agents reply by writing mail to their own `outbox/`; the dispatcher checks `can_message` and delivers it.
 4. The run ends when the lead sends `done`.
 
-Its own data (config, mailboxes, logs, memory, worktrees) lives in `~/agent-lyceum-config/`, not in your repo. Agents edit your repo directly, or in git worktrees when running in parallel. agent-lyceum never merges. More: [How a run works](docs/how-it-works.md), [Configuration](docs/configuration.md).
+Its own data (config, mailboxes, logs, memory, worktrees) lives in `~/agent-lyceum-config/`, not in your repo. Concurrency needs no configuration. In a git repo with a commit, every run works in its own git worktree and ends on its own branch (`agent-lyceum/<run>/…`), members with pending mail wake in parallel, and any number of runs can be active at once; the result is not written into your working tree, so use `git merge <branch>` or `open_pr`, and note that a run starts from `HEAD` and does not see your uncommitted edits. In a non-git folder, a repo with no commit, or a repo using reftable, the run works directly in the folder, one agent at a time (an info line says why), and only one such run can be active. agent-lyceum never merges. Upgrading from a version with `owns`, `max_parallel`, `max_concurrent_runs` or `workspace_mode`: see [Upgrading](docs/upgrading-run-v2.md). More: [How a run works](docs/how-it-works.md), [Configuration](docs/configuration.md).
 
 ## Commands
 
@@ -68,7 +68,7 @@ dir: ~/code/web-app
 team: { lead: lead }
 agents:
   lead:      { can_message: all, can_edit_agent_md: true }
-  fe-member: { runtime: codex, can_message: [lead], owns: ["src/web/**"] }
+  fe-member: { runtime: codex, can_message: [lead] }
   pm:        { can_message: [lead], allow_web: fetch }
 ```
 

package/README.zh-TW.md

@@ -10,7 +10,7 @@
 
 - **角色不會跑掉。** 每個 agent 有自己的人設（`AGENT.md`）與長期記憶，reviewer 會一直做 review，不會漸漸變成在寫程式。
 - **agent 改不了規則。** agent 只能寫自己的記憶與寄件匣（outbox），不能改其他 agent 的 context，也不能改自己的人設；能做到的地方由 OS 沙箱強制，而不只靠 prompt。見 [Write scope](docs/write-scope.zh-TW.md)。
-- **混用 runtime。** Claude Code 與 Codex agent 可在同一個團隊，並各自限制可寫的路徑。
+- **混用 runtime。** Claude Code 與 Codex agent 可在同一個團隊。
 - **沒有黑箱。** agent 透過純檔案信箱溝通，每則訊息、決策與記憶都是你能讀、能 grep、能 diff 的檔案；dispatcher 不會替你 merge。
 
 **不適合**小而單次的修改：單一 Claude Code 或 Codex session 更快更省。任務大到值得拆分、review 或平行執行時，再用團隊。
@@ -39,7 +39,7 @@ npx agent-lyceum status
 3. agent 把回信寫進自己的 `outbox/`，dispatcher 檢查 `can_message` 後投遞。
 4. lead 寄出 `done` 時，run 結束。
 
-工具自己的資料（設定、信箱、log、記憶、worktree）放在 `~/agent-lyceum-config/`，不放進你的 repo。agent 直接修改你的 repo；平行執行時則在各自的 git worktree 修改。agent-lyceum 不會幫你合併。詳見[一次執行如何運作](docs/how-it-works.zh-TW.md)、[設定](docs/configuration.zh-TW.md)。
+工具自己的資料（設定、信箱、log、記憶、worktree）放在 `~/agent-lyceum-config/`，不放進你的 repo。並行不需要任何設定。在有 commit 的 git repo 裡，每個 run 都在自己的 git worktree 工作，並結束在自己的 branch（`agent-lyceum/<run>/…`）；有待處理信件的成員會平行喚醒，同時也可有任意多個 run；結果不會寫進你的工作目錄，請用 `git merge <branch>` 或 `open_pr`，且 run 從 `HEAD` 起跑，看不到你未提交的修改。在非 git 資料夾、沒有 commit 的 repo 或使用 reftable 的 repo，run 直接在該資料夾工作、一次只跑一個 agent（會有一行說明原因），且同時只能有一個這樣的 run。agent-lyceum 不會幫你合併。從有 `owns`、`max_parallel`、`max_concurrent_runs` 或 `workspace_mode` 的版本升級：見[升級](docs/upgrading-run-v2.md)。詳見[一次執行如何運作](docs/how-it-works.zh-TW.md)、[設定](docs/configuration.zh-TW.md)。
 
 ## 指令
 
@@ -68,7 +68,7 @@ dir: ~/code/web-app
 team: { lead: lead }
 agents:
   lead:      { can_message: all, can_edit_agent_md: true }
-  fe-member: { runtime: codex, can_message: [lead], owns: ["src/web/**"] }
+  fe-member: { runtime: codex, can_message: [lead] }
   pm:        { can_message: [lead], allow_web: fetch }
 ```
 

package/dist/adapters/claude.js

@@ -27,13 +27,7 @@ export function buildClaudeSettings(project, agent) {
         allow.push("WebSearch");
     if (agent.allowWeb === "fetch")
         allow.push("WebFetch");
-    if (pol.restrictRepoToOwns) {
-        for (const g of pol.owns)
-            allow.push(rule("Edit", path.join(repo, g)));
-    }
-    else {
-        allow.push(rule("Edit", `${repo}/**`));
-    }
+    allow.push(rule("Edit", `${repo}/**`));
     for (const d of pol.allowDirs)
         allow.push(rule("Edit", `${d}/**`));
     for (const f of pol.allowFiles)

package/dist/call.js

@@ -33,7 +33,6 @@ export function resolveCallAgent(home, name) {
         canMessage: [],
         canAskUser: false,
         canEditAgentMd: false,
-        owns: [],
     };
 }
 /** The made-up project a call runs in: the working directory is its repo, and every other path is inside the call's own folder. */
@@ -54,7 +53,7 @@ export function callProject(home, agent, dir, callDir) {
         name: CALL_PROJECT,
         dir,
         lead: agent.name,
-        dispatcher: { ...DISPATCHER_DEFAULTS, max_parallel: 1, workspace_mode: "shared" },
+        dispatcher: DISPATCHER_DEFAULTS,
         agents: { [agent.name]: agent },
         paths,
         solo: "call",

package/dist/cli.js

@@ -11,6 +11,7 @@ import { RESULT_FILE, runTeam } from "./dispatcher.js";
 import { executeRunCleanup, planRunCleanup } from "./run-cleanup.js";
 import { diagnoseProject, formatDoctor, preflightRuntimes } from "./doctor.js";
 import { acquireProjectLock, forceUnlock, inspectRunLock, listRunLocks, listUnreadableRunLocks, LOCK_FILE, lockHolderAlive } from "./project-lock.js";
+import { planWorkspace } from "./worktree.js";
 import { loadRunState, newRunId, outcomeOf, resolveRun, roundLimit, roundsLabel, runLabel, slugify, uniqueName } from "./run-store.js";
 import { failureGuide } from "./run-outcome.js";
 import { exitCodeForOutcome, RUNTIMES } from "./schema.js";
@@ -132,10 +133,10 @@ function findRun(pr, query) {
     const list = r.candidates.map((c) => `  ${c.state.name ?? "(no name)"}  ${c.state.run_id}  ${c.state.task_summary}`).join("\n");
     return fail(`"${query}" matches several runs:\n${list}\nGive more of the name or id.`);
 }
-/** Take the lock of one run, or exit with the reason. `ignoreLimit`: the caller does not start a run (e.g. `clear`). `exclusive`: it needs the whole project (memory tidy). */
+/** Take the lock of one run, or exit with the reason. `checkout`: the run works in the project checkout, so only one may be active. `exclusive`: it needs the whole project (memory tidy). */
 function takeLock(pr, runId, opts = {}) {
     try {
-        return acquireProjectLock(pr.paths.root, runId, { maxConcurrent: opts.ignoreLimit ? Number.MAX_SAFE_INTEGER : pr.dispatcher.max_concurrent_runs, exclusive: opts.exclusive });
+        return acquireProjectLock(pr.paths.root, runId, { checkout: opts.checkout, exclusive: opts.exclusive, dir: pr.dir, reason: opts.reason });
     }
     catch (e) {
         return fail(e.message);
@@ -197,17 +198,23 @@ function reportRun(summary, runDir) {
 const firstLine = (t) => t.trim().split("\n")[0].trim();
 /** Take the lock and continue a run; the lock is released when it stops (also when it stops because it waits for answers). */
 async function continueRun(pr, dir, runId, followup) {
-    const lease = takeLock(pr, runId);
+    const planned = loadRunState(dir);
+    // Where the run works is decided (from its state) before the lock is taken, and handed to the session as is.
+    const plan = planWorkspace(pr, planned);
+    const lease = takeLock(pr, runId, { checkout: !plan.leadWorktree, reason: "it was started without its own worktree" });
     const cancel = cancelOnSignals();
     try {
-        console.log(`Project ${pr.name} — repo ${pr.dir}`);
+        // Read the state again under the lock: another process may have changed it while we were checking.
         const state = loadRunState(dir);
+        if (state.lead_workspace !== planned.lead_workspace || state.workspace_mode !== planned.workspace_mode) {
+            throw new Error(`Run ${runId} changed while it was starting (where it works was ${planned.lead_workspace ? "its own worktree" : planned.workspace_mode ?? "unset"}, now ${state.lead_workspace ? "its own worktree" : state.workspace_mode ?? "unset"}); try again.`);
+        }
+        console.log(`Project ${pr.name} — repo ${pr.dir}`);
         if (followup)
             console.log(`Reopening run ${runLabel(state)} (follow-up ${(state.reopened?.length ?? 0) + 1}): ${firstLine(followup.text)}`);
         else
             console.log(`Resuming run ${runLabel(state)} (${state.end_reason ?? "interrupted"}) at round ${roundsLabel(state.rounds, roundLimit(state, pr.dispatcher.max_rounds))}: ${state.task_summary}`);
-        // Read the state again under the lock: another process may have changed it while we were checking.
-        return await runTeam({ project: pr, resume: state, runDir: dir, signal: cancel.signal, followup });
+        return await runTeam({ project: pr, resume: state, plan, runDir: dir, signal: cancel.signal, followup });
     }
     finally {
         cancel.dispose();
@@ -289,7 +296,8 @@ program
         }
         const runId = newRunId();
         const runDir = path.join(pr.paths.runs, runId);
-        const lease = takeLock(pr, runId);
+        const plan = planWorkspace(pr);
+        const lease = takeLock(pr, runId, { checkout: !plan.leadWorktree, reason: plan.reason });
         let summary;
         const cancel = cancelOnSignals();
         try {
@@ -297,7 +305,7 @@ program
             console.log(`Project ${pr.name} — repo ${pr.dir}${opts.agent ? ` — solo: ${opts.agent}` : ""}`);
             console.log(`Task: ${prepared.source === "file" ? `file ${prepared.sourcePath}` : "text"} (${prepared.bytes} bytes${prepared.inline ? "" : ", passed by reference"})`);
             const name = opts.name ?? uniqueName(slugify(taskMessageBody(prepared).subject), taken);
-            summary = await runTeam({ project: pr, name, task: prepared, runDir, soloAgent: opts.agent, signal: cancel.signal });
+            summary = await runTeam({ project: pr, name, plan, task: prepared, runDir, soloAgent: opts.agent, signal: cancel.signal });
         }
         finally {
             cancel.dispose();
@@ -514,7 +522,7 @@ program
                 refuse(plan);
             return;
         }
-        const lease = takeLock(pr, full, { ignoreLimit: true });
+        const lease = takeLock(pr, full, { checkout: false });
         try {
             const plan = planRunCleanup(pr, full, { keepWorktrees: opts.keepWorktrees });
             if (plan.refusals.length)

package/dist/config.d.ts

@@ -22,7 +22,6 @@ export interface ResolvedAgent {
     canAskUser: boolean;
     /** Web access for this agent; undefined = not configured, so the runtime keeps its own default. */
     allowWeb?: WebLevel;
-    owns: string[];
     /** Where each field's value came from (for `validate` output). */
     sources: Record<string, Source>;
 }
@@ -35,6 +34,11 @@ export interface ResolvedProject {
     dispatcher: DispatcherSettings;
     agents: Record<string, ResolvedAgent>;
     paths: ProjectPaths;
+    /** Removed settings still present in config files (ignored); `validate` warns once per file. */
+    ignoredSettings?: {
+        file: string;
+        keys: string[];
+    }[];
     /** Set once the project is bound to one run (see `bindRunProject`): which run, and where its mail lives. */
     run?: {
         id: string;
@@ -61,7 +65,7 @@ export declare function loadGlobal(home: string): {
         can_edit_agent_md?: boolean | undefined;
         can_ask_user?: boolean | undefined;
         allow_web?: "fetch" | "none" | "search" | undefined;
-        owns?: string[] | undefined;
+        owns?: unknown;
     }>;
 };
 export declare function loadProjectRaw(home: string, name: string): {
@@ -71,12 +75,12 @@ export declare function loadProjectRaw(home: string, name: string): {
     };
     dispatcher: {
         max_rounds?: number | undefined;
-        max_parallel?: number | undefined;
-        max_concurrent_runs?: number | undefined;
+        max_parallel?: unknown;
+        max_concurrent_runs?: unknown;
         wake_timeout_sec?: number | undefined;
         retry?: number | undefined;
         strict?: boolean | undefined;
-        workspace_mode?: "auto" | "shared" | "worktree" | undefined;
+        workspace_mode?: unknown;
         log_max_bytes?: number | undefined;
     };
     agents: Record<string, {
@@ -93,7 +97,7 @@ export declare function loadProjectRaw(home: string, name: string): {
         can_edit_agent_md?: boolean | undefined;
         can_ask_user?: boolean | undefined;
         allow_web?: "fetch" | "none" | "search" | undefined;
-        owns?: string[] | undefined;
+        owns?: unknown;
     }>;
 };
 export declare function resolveProject(home: string, name: string): ResolvedProject;

package/dist/config.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import YAML from "yaml";
 import { absPath, homePaths, projectPaths, } from "./paths.js";
-import { DISPATCHER_DEFAULTS, GlobalConfig, ProjectConfig, inferRuntime, } from "./schema.js";
+import { DISPATCHER_DEFAULTS, GlobalConfig, REMOVED_AGENT_KEYS, REMOVED_DISPATCHER_KEYS, ProjectConfig, inferRuntime, } from "./schema.js";
 export class ConfigError extends Error {
 }
 function readYaml(file, schema, label) {
@@ -58,7 +58,8 @@ export function resolveProjectFrom(home, name, g, p) {
     const paths = projectPaths(home, name);
     const hp = homePaths(home);
     const lead = p.team.lead;
-    const dispatcher = { ...DISPATCHER_DEFAULTS, ...stripUndef(p.dispatcher) };
+    const { max_parallel: _mp, max_concurrent_runs: _mc, workspace_mode: _wm, ...liveDispatcher } = p.dispatcher;
+    const dispatcher = { ...DISPATCHER_DEFAULTS, ...stripUndef(liveDispatcher) };
     const agents = {};
     for (const agentName of Object.keys(p.agents)) {
         const gl = resolveLayer(g.agents[agentName], home);
@@ -134,13 +135,11 @@ export function resolveProjectFrom(home, name, g, p) {
         const canEdit = pick("can_edit_agent_md");
         const canAsk = pick("can_ask_user");
         const allowWeb = pick("allow_web");
-        const owns = pick("owns");
         for (const [k, v] of [
             ["resume", resume],
             ["can_message", canMessage],
             ["can_edit_agent_md", canEdit],
             ["can_ask_user", canAsk],
-            ["owns", owns],
         ]) {
             if (v === undefined)
                 sources[k] = "default";
@@ -157,7 +156,6 @@ export function resolveProjectFrom(home, name, g, p) {
             canEditAgentMd: canEdit ?? isLead,
             canAskUser: canAsk ?? isLead,
             allowWeb,
-            owns: owns ?? [],
             sources,
         };
     }
@@ -169,8 +167,28 @@ export function resolveProjectFrom(home, name, g, p) {
         dispatcher,
         agents,
         paths,
+        ignoredSettings: collectIgnored(hp.globalConfig, g, paths.config, p),
     };
 }
+/** The removed keys present in the global and project files, by full path, per file (empty files omitted). */
+function collectIgnored(globalFile, g, projectFile, p) {
+    const out = [];
+    const scan = (file, dispatcher, agents) => {
+        const keys = [];
+        for (const k of REMOVED_DISPATCHER_KEYS)
+            if (dispatcher?.[k] !== undefined)
+                keys.push(`dispatcher.${k}`);
+        for (const [name, a] of Object.entries(agents))
+            for (const k of REMOVED_AGENT_KEYS)
+                if (a[k] !== undefined)
+                    keys.push(`agents.${name}.${k}`);
+        if (keys.length)
+            out.push({ file, keys });
+    };
+    scan(globalFile, undefined, g.agents);
+    scan(projectFile, p.dispatcher, p.agents);
+    return out;
+}
 function stripUndef(o) {
     return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));
 }
@@ -205,7 +223,7 @@ export function findProjectForCwd(home, cwd) {
     }
     return best?.name;
 }
-const AGENT_FIELDS = ["runtime", "model", "effort", "agent_md", "memory.global", "memory.project", "resume", "can_message", "can_edit_agent_md", "can_ask_user", "allow_web", "owns"];
+const AGENT_FIELDS = ["runtime", "model", "effort", "agent_md", "memory.global", "memory.project", "resume", "can_message", "can_edit_agent_md", "can_ask_user", "allow_web"];
 /** The resolved project plus, for every setting, the file and key it was taken from (or "default"). */
 export function resolveProjectWithSources(home, name) {
     const project = resolveProject(home, name);
@@ -264,7 +282,6 @@ export function flattenResolved(project) {
         v[`${p}.can_edit_agent_md`] = a.canEditAgentMd;
         v[`${p}.can_ask_user`] = a.canAskUser;
         v[`${p}.allow_web`] = a.allowWeb;
-        v[`${p}.owns`] = a.owns;
     }
     return v;
 }

package/dist/demo.js

@@ -82,7 +82,6 @@ export function prepareDemo(dir, runtime) {
     // One runtime for the whole team, and the roles scoped to the sample repo.
     for (const agent of ["lead", "fe-member", "qa-member"])
         yaml = yaml.replace(`  ${agent}:\n`, `  ${agent}:\n    runtime: ${runtime}\n`);
-    yaml = yaml.replace('# owns: ["src/web/**"]', 'owns: ["src/**"]').replace('# owns: ["tests/**"]', 'owns: ["test/**"]');
     fs.writeFileSync(cfg, yaml);
     return { dir: root, home, repo };
 }

package/dist/dispatcher.d.ts

@@ -3,4 +3,5 @@ import { newRunId } from "./run-store.js";
 export { newRunId };
 export type { ActiveWake, EndReason, RunState, SentTopic, WakeRecord, WakeTopic } from "./run-store.js";
 export { MAX_DONE_REJECTIONS, RESULT_FILE, type RunOptions, type RunSummary } from "./run-session.js";
-export declare function runTeam(opts: RunOptions): Promise<RunSummary>;
+/** `plan` is what the CLI decided before taking the run's lock. The CLI always passes it; the fallback exists only for direct callers and tests. */
+export declare function runTeam(opts: Omit<RunOptions, "plan"> & Partial<Pick<RunOptions, "plan">>): Promise<RunSummary>;

package/dist/dispatcher.js

@@ -1,7 +1,9 @@
 import { RunSession } from "./run-session.js";
 import { newRunId } from "./run-store.js";
+import { planWorkspace } from "./worktree.js";
 export { newRunId };
 export { MAX_DONE_REJECTIONS, RESULT_FILE } from "./run-session.js";
+/** `plan` is what the CLI decided before taking the run's lock. The CLI always passes it; the fallback exists only for direct callers and tests. */
 export async function runTeam(opts) {
-    return new RunSession(opts).run();
+    return new RunSession({ ...opts, plan: opts.plan ?? planWorkspace(opts.project, opts.resume) }).run();
 }

package/dist/doctor.js

@@ -6,7 +6,7 @@ import { tidyAdvice } from "./memory-tidy.js";
 import { listRunLocks, listUnreadableRunLocks, lockHolderAlive } from "./project-lock.js";
 import { runInvocation } from "./process-runner.js";
 import { validateProject } from "./validate.js";
-import { dirtyPaths, git, isGitRepo, resolveWorkspaceMode } from "./worktree.js";
+import { dirtyPaths, git, isolationBlocker } from "./worktree.js";
 const BINARY = { "claude-code": "claude", codex: "codex" };
 /** Run a read-only CLI query (`--version`, `--help`): bounded in time and output, never an agent task. */
 async function query(cmd, args, opts) {
@@ -116,20 +116,19 @@ export async function diagnoseProject(project, opts = {}) {
         checks.push({ level: i.level === "error" ? "error" : "warn", subject: "config", message: i.message });
     if (!v.issues.length)
         checks.push({ level: "ok", subject: "config", message: "Configuration is valid." });
-    if (fs.existsSync(project.dir) && isGitRepo(project.dir)) {
-        if (resolveWorkspaceMode(project.dispatcher) === "worktree") {
+    const blocker = fs.existsSync(project.dir) ? isolationBlocker(project.dir) : undefined;
+    if (fs.existsSync(project.dir)) {
+        if (blocker) {
+            checks.push({ level: "info", subject: "git", message: `Runs work directly in ${project.dir}, one agent at a time (${blocker}).` });
+        }
+        else {
             const dirty = dirtyPaths(project.dir);
-            if (dirty.length && project.dispatcher.max_concurrent_runs > 1) {
-                checks.push({ level: "info", subject: "git", message: `${dirty.length} uncommitted change(s) in ${project.dir}: concurrent runs start from HEAD and do not see them.` });
-            }
-            else if (dirty.length) {
-                checks.push({ level: "warn", subject: "git", message: `${dirty.length} uncommitted change(s) in ${project.dir}: a parallel run would refuse to start until they are committed or stashed.` });
-            }
-            else
-                checks.push({ level: "ok", subject: "git", message: "Repo is clean; parallel runs can start." });
+            checks.push(dirty.length
+                ? { level: "info", subject: "git", message: `${dirty.length} uncommitted change(s) in ${project.dir}: runs start from HEAD and do not see them.` }
+                : { level: "ok", subject: "git", message: "git repo with a commit: runs and agents work in their own worktrees." });
         }
     }
-    if (project.dispatcher.max_concurrent_runs > 1 && fs.existsSync(project.dir) && isGitRepo(project.dir)) {
+    if (fs.existsSync(project.dir) && !blocker) {
         const missing = [];
         if (!findOnPath("gh", opts.env?.PATH ?? process.env.PATH))
             missing.push("`gh` is not on PATH");

package/dist/paths.d.ts

@@ -26,5 +26,3 @@ export interface ProjectPaths {
 export declare function projectPaths(home: string, project: string): ProjectPaths;
 /** True when `child` is `parent` or inside it. */
 export declare function isInside(parent: string, child: string): boolean;
-/** Directory part of a glob that precedes the first wildcard segment. */
-export declare function globStaticPrefix(glob: string): string;

package/dist/paths.js

@@ -49,14 +49,3 @@ export function isInside(parent, child) {
     const rel = path.relative(parent, child);
     return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
 }
-/** Directory part of a glob that precedes the first wildcard segment. */
-export function globStaticPrefix(glob) {
-    const segs = glob.split("/");
-    const out = [];
-    for (const s of segs) {
-        if (/[*?[\]{}]/.test(s))
-            break;
-        out.push(s);
-    }
-    return out.join("/");
-}

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[];

package/dist/worktree.js

@@ -4,16 +4,6 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { atomicWrite } from "./fs-util.js";
-/** 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 function resolveWorkspaceMode(d) {
-    if ((d.max_concurrent_runs ?? 1) > 1)
-        return "worktree";
-    if (d.workspace_mode === "worktree")
-        return "worktree";
-    if (d.workspace_mode === "shared")
-        return "shared";
-    return d.max_parallel > 1 ? "worktree" : "shared";
-}
 const IDENTITY = {
     GIT_AUTHOR_NAME: "agent-lyceum",
     GIT_AUTHOR_EMAIL: "agent-lyceum@localhost",
@@ -227,33 +217,42 @@ export const toplevel = (dir) => git(dir, ["rev-parse", "--show-toplevel"]);
 export function dirtyPaths(dir) {
     return parseStatus(execFileSync("git", ["status", "--porcelain", "-z", "--untracked-files=all"], { cwd: dir, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 }));
 }
-/** Refuse to start a worktree run when it cannot be isolated; returns nothing when it is fine. */
-export function assertWorktreeRunnable(project, opts) {
-    if (!isGitRepo(project.dir)) {
-        throw new Error(`Parallel runs (worktree workspaces) need ${project.dir} to be a git repository. Run sequentially instead: dispatcher.max_parallel: 1.`);
-    }
+/** Why `dir` cannot give every run and agent its own git worktree, or undefined when it can. */
+export function isolationBlocker(dir) {
+    if (!isGitRepo(dir))
+        return "not a git repository";
+    if (tryGit(dir, ["rev-parse", "--verify", "-q", "HEAD"]) === undefined)
+        return "no commit yet";
     // With git's reftable ref storage a linked worktree's HEAD lives in `<gitDir>/reftable/`, a place the agent can write, and the
     // file `<gitDir>/HEAD` only says `ref: refs/heads/.invalid`: the check that a worktree's HEAD is its own branch cannot hold
-    // there, so every worktree would be refused in the middle of the run. Say so up front instead. (`rev-parse --show-ref-format`
-    // does not exist in older git, which only knows `files`.)
-    if (tryGit(project.dir, ["rev-parse", "--show-ref-format"]) === "reftable") {
-        throw new Error(`${project.dir} uses git's reftable ref storage, whose worktrees agent-lyceum cannot yet verify as isolated, so parallel agents and concurrent runs are not supported there. ` +
-            `Use a repository with the default "files" ref storage, or run one agent at a time without worktrees: dispatcher.max_parallel: 1 and dispatcher.max_concurrent_runs: 1.`);
-    }
-    if (!opts.fresh)
-        return;
-    if (opts.concurrent) {
-        // A concurrent run starts from HEAD and never touches the working tree, so uncommitted changes are fine.
-        if (tryGit(project.dir, ["rev-parse", "--verify", "-q", "HEAD"]) === undefined) {
-            throw new Error(`Concurrent runs start from HEAD, but ${project.dir} has no commit yet. Make an initial commit, or set dispatcher.max_concurrent_runs: 1.`);
-        }
-        return;
+    // there, so every worktree would be refused in the middle of the run. (`rev-parse --show-ref-format` does not exist in older
+    // git, which only knows `files`.)
+    if (tryGit(dir, ["rev-parse", "--show-ref-format"]) === "reftable")
+        return "reftable ref storage";
+    return undefined;
+}
+/**
+ * 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 function planWorkspace(project, resume) {
+    if (resume) {
+        if (resume.lead_workspace === true)
+            return { mode: "worktree", leadWorktree: true };
+        if (resume.workspace_mode === "worktree")
+            return { mode: "worktree", leadWorktree: false };
+        return { mode: "shared", leadWorktree: false };
+    }
+    const reason = isolationBlocker(project.dir);
+    return reason === undefined ? { mode: "worktree", leadWorktree: true } : { mode: "shared", leadWorktree: false, reason };
+}
+/** Refuse to resume a worktree run when its repo can no longer be isolated; returns nothing when it is fine. */
+export function assertWorktreeRunnable(project) {
+    if (!isGitRepo(project.dir)) {
+        throw new Error(`This run works in git worktrees, but ${project.dir} is no longer a git repository.`);
     }
-    const dirty = dirtyPaths(project.dir);
-    if (dirty.length) {
-        const shown = dirty.slice(0, 5).join(", ") + (dirty.length > 5 ? `, ... (${dirty.length} in all)` : "");
-        throw new Error(`Parallel runs start from a clean repo, but ${project.dir} has uncommitted changes: ${shown}. ` +
-            `Commit or stash them first (agent-lyceum never touches your own edits), or run sequentially with dispatcher.max_parallel: 1.`);
+    if (tryGit(project.dir, ["rev-parse", "--show-ref-format"]) === "reftable") {
+        throw new Error(`This run works in git worktrees, but ${project.dir} now uses git's reftable ref storage, whose worktrees agent-lyceum cannot yet verify as isolated.`);
     }
 }
 /** `refs/agent-lyceum/<run>/base-0` pointing at the repo's HEAD: where a concurrent run starts. Nothing in the repo changes. */
@@ -427,39 +426,6 @@ export function removeAgentWorkspace(project, runId, agent) {
         tryGit(top, ["branch", "-D", branch]);
     fs.rmSync(`${root}.json`, { force: true });
 }
-/** Glob as used in `owns`: `**` crosses folders, `*` and `?` stay within one, `{a,b}` alternates. */
-export function globMatch(glob, file) {
-    let re = "";
-    for (let i = 0; i < glob.length; i++) {
-        const c = glob.charAt(i);
-        if (c === "*" && glob[i + 1] === "*") {
-            if (glob[i + 2] === "/") {
-                re += "(?:.*/)?";
-                i += 2;
-            }
-            else {
-                re += ".*";
-                i += 1;
-            }
-        }
-        else if (c === "*")
-            re += "[^/]*";
-        else if (c === "?")
-            re += "[^/]";
-        else if (c === "{") {
-            const end = glob.indexOf("}", i);
-            if (end < 0)
-                re += "\\{";
-            else {
-                re += `(?:${glob.slice(i + 1, end).split(",").map((s) => s.replace(/[.+^$()|[\]\\]/g, "\\$&")).join("|")})`;
-                i = end;
-            }
-        }
-        else
-            re += c.replace(/[.+^$()|[\]\\}]/g, "\\$&");
-    }
-    return new RegExp(`^${re}$`).test(file);
-}
 const PROTECTED_NAMES = ["CLAUDE.md", "AGENTS.md"];
 /** 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 function commitWorkspace(ws, message) {
@@ -475,10 +441,10 @@ export function commitWorkspace(ws, message) {
 }
 /**
  * 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 function collectAgentChanges(workspace, owns) {
+export function collectAgentChanges(workspace) {
     const { head } = commitWorkspace(workspace, `agent-lyceum: changes by ${workspace.agent}`);
     const base = workspace.base;
     const raw = base === head ? "" : agentGit(workspace, ["diff", "--raw", "-z", "--no-renames", "--no-abbrev", base, head]);
@@ -501,9 +467,6 @@ export function collectAgentChanges(workspace, owns) {
         const p = rel === "" ? f.path : path.posix.relative(rel, f.path);
         if (PROTECTED_NAMES.includes(p))
             violations.push(`${f.path}: protected instruction file; only the lead may change it, by hand`);
-        const allowed = (candidate) => owns.length === 0 || owns.some((g) => globMatch(g, candidate));
-        if (!allowed(p))
-            violations.push(`${f.path}: outside this agent's owns (${owns.join(", ")})`);
         if (f.mode === "160000")
             violations.push(`${f.path}: submodule changes are not integrated`);
         if (f.mode === "120000" && f.status !== "D") {
@@ -513,8 +476,6 @@ export function collectAgentChanges(workspace, owns) {
                 violations.push(`${f.path}: symlink to an absolute path (${target})`);
             else if (resolved.startsWith(".."))
                 violations.push(`${f.path}: symlink leaves the project directory (${target})`);
-            else if (!allowed(resolved))
-                violations.push(`${f.path}: symlink points outside this agent's owns (${target})`);
         }
     }
     return { workspace, base, head, files, violations };

package/package.json

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