sortie-dogs 0.7.1 → 0.8.0

package/README.md

@@ -24,7 +24,7 @@ Requirements: Node.js 22.6 or newer, npm, and OpenCode.
 
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) · [CLI testing](docs/cli-testing.md)
 
-Release: [v0.7.1](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.7.1)
+Release: [v0.8.0](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.8.0)
 
 ## Quick start
 
@@ -184,10 +184,14 @@ global file for durable global settings.
   Remove the directory only when no Sortie run is active.
 - `readOnlyTools` adds host-specific tool names that never change files, such as
   MCP tools. Unknown tools are denied for a bound session by default.
-- `dedicatedWorkerModel` selects the single model every worker role resolves to.
-  It defaults to `openai/gpt-5.6-luna` with variant `max`; declare your own when
-  that model is unavailable or when you want a different worker effort. Worker
-  roles always resolve to this one target and cannot be routed per role.
+- `dedicatedWorkerModel` selects the serial implementation target used by
+  `implementation`, `remediation`, `blocker-resolution`, `sol-worker-mk2a2`, and
+  `dog-worker`. It defaults to `openai/gpt-5.6-sol` with variant `medium`.
+  The installed `dog-luna-worker` fabric route remains fixed to
+  `openai/gpt-5.6-luna` with variant `max`; pointing the serial target at that
+  Luna model is invalid because it would collapse the two route identities. The
+  coordinator dispatches this role only for a ready descriptor of a prepared
+  `luna-fabric` run; a `sol-serial` run keeps `dog-worker`.
 - `continuation` bounds the batch loop. After a terminal unit and its checkpoint,
   `dog-coordinator` calls `sortie_compact_and_continue`, which compacts the run
   and resumes the same root session on the next independent unit. Only a root
@@ -223,9 +227,9 @@ global file for durable global settings.
   requests are not repeated.
 - **Writes stay inside the assignment.** Exact source or operation manifests
   gate edits and handoffs.
-- **Autonomous sequential implementation.** A normal request may use as many sequential
-  workers as its accepted scope requires. Concurrent fan-out still needs the explicit
-  parallel contract.
+- **Autonomous implementation routing.** An accepted scope with at least two safe independent
+  units defaults to Luna fabric without opt-in. An explicit serial/no-parallel request wins;
+  other work uses sequential workers. The separate parallel contract remains explicit.
 - **Runtime overlap protection.** Active equal or ancestor write scopes are rejected
   before mutation, and full validation waits until every parallel unit joins.
 - **Evidence before completion.** Canonical validation, risk-based review, and
@@ -321,29 +325,40 @@ where the curve gives the most per unit of cost. Nobody selects a model for a
 session the loop spawns, which is why delegated roles carry defaults and the
 coordinator does not. Project-local routing can override this default.
 
-The `implementation`, `remediation`, `blocker-resolution`, and `dog-worker`
-roles always use the dedicated worker target, `openai/gpt-5.6-luna` with the
-`max` variant. Worker effort stays at the top of that model's range while review
-effort stays above it on a stronger model, which is what mandatory source review
-is for. Declare `dedicatedWorkerModel` as `openai/gpt-5.6-sol` when you would
-rather pay for the stronger worker model up front; that target stays in the
-built-in catalog for exactly this reason. `modelRouting`
-cannot replace those routes, and only `dedicatedWorkerModel` moves them. For other explicitly
-routed roles, resolution is deterministic: Sortie-dogs tries the preferred
-target, then ordered fallbacks. Roles without either a built-in default or an
-explicit route keep OpenCode's already selected model.
+The `implementation`, `remediation`, `blocker-resolution`, `sol-worker-mk2a2`,
+and `dog-worker` roles always use the stable serial target,
+`openai/gpt-5.6-sol` with the `medium` variant. `dedicatedWorkerModel` may move
+that serial target when a host cannot serve it. The installed `dog-luna-worker`
+route is separately fixed to `openai/gpt-5.6-luna` with the `max` variant. Its
+shared worker contract requires one validated fabric descriptor: the coordinator
+admits a v0.8 DAG contract with `sortie_admit_luna_fabric`, prepares it with
+`sortie_prepare_luna_fabric`, and materializes only the current ready wave, with
+at most five distinct Luna units. The complete DAG may contain up to 64 units.
+After every active artifact is verified, `sortie_advance_luna_fabric_wave`
+integrates them into a runtime-owned hidden candidate, cleans those worktrees,
+and creates fresh worktrees from that exact snapshot. After the final wave,
+`sortie_validate_luna_fabric_candidate` runs canonical validation once and
+`sortie_accept_luna_fabric_candidate` records review before one target CAS.
+Declared shared-path ownership serializes overlapping units
+across waves; unowned overlap or any admission defect routes the whole job back
+to one `dog-worker`. The fabric never duplicates one unit across lanes.
+`modelRouting` cannot replace either fixed
+route, and a serial override naming the Luna fabric model is invalid rather than
+silently collapsing both identities. Version 0.7.0 routed `dog-worker` to Luna
+Max; v0.8 intentionally preserves that history while splitting stable Sol and
+fabric Luna roles. Other explicit routes try the preferred target, then ordered
+fallbacks. Roles without a built-in default or explicit route keep OpenCode's
+already selected model.
 
 `dog-reviewer` and `dog-advisor` must never inherit the caller's model, because
 review and strategy lose their value when they run on the model that produced
 the candidate. Both default to `anthropic/claude-opus-5` when the catalog
 declares it, and otherwise fall back to `openai/gpt-5.6-sol` with the `xhigh`
-variant. That fallback stays on the stronger model rather than matching the
-worker target, because review has to be able to reject work the worker just
-produced. A host that redeclares
-`dedicatedWorkerModel` keeps that target as its first fallback, since such a
-host may not serve the shipped model at all. Nothing here requires a particular
-vendor: both roles stay fully configurable, so declare whichever model you can
-actually serve.
+variant. That fallback uses higher effort than the Sol Medium worker because
+review has to be able to reject work the worker just produced. Moving
+`dedicatedWorkerModel` does not change consultation policy. Nothing here requires
+a particular vendor: both roles stay fully configurable, so declare whichever
+model you can actually serve.
 
 ```json
 {

package/dist/asset-version.d.ts

@@ -2,5 +2,5 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export declare const RUNTIME_ASSET_VERSION = "0.3.52-acceptance-continuity-v1";
+export declare const RUNTIME_ASSET_VERSION = "0.3.69-luna-combined-validation-replay-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -2,4 +2,4 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export const RUNTIME_ASSET_VERSION = "0.3.52-acceptance-continuity-v1";
+export const RUNTIME_ASSET_VERSION = "0.3.69-luna-combined-validation-replay-v1";

package/dist/core/acceptance-continuity.js

@@ -38,13 +38,13 @@ export function inspectAcceptanceContinuity(handoff) {
         raw.task_id.length === 0 || raw.task_id.length > MAX_TASK_ID || !Array.isArray(raw.criteria) ||
         raw.criteria.length === 0 || raw.criteria.length > MAX_ACCEPTANCE_CRITERIA ||
         !raw.criteria.every((criterion) => typeof criterion === "string" && criterion.length > 0 && criterion.length <= MAX_CRITERION) ||
-        new Set(raw.criteria).size !== raw.criteria.length || typeof raw.fingerprint !== "string" ||
+        typeof raw.fingerprint !== "string" ||
         !FINGERPRINT.test(raw.fingerprint) || !(raw.parent_fingerprint === "none" ||
         (typeof raw.parent_fingerprint === "string" && FINGERPRINT.test(raw.parent_fingerprint)))) {
         return { ledger: undefined, error: "malformed" };
     }
     const criteria = normalizeAcceptanceCriteria(raw.criteria);
-    if (new Set(criteria).size !== criteria.length || acceptanceContinuityFingerprint(criteria) !== raw.fingerprint) {
+    if (acceptanceContinuityFingerprint(criteria) !== raw.fingerprint) {
         return { ledger: undefined, error: "malformed" };
     }
     return {

package/dist/core/initialize.js

@@ -8,6 +8,8 @@ const { runtimeAssets } = assets;
 const OPEN_CODE_DIRECTORY = ".opencode";
 const VERSION_MARKER = `${OPEN_CODE_DIRECTORY}/sortie-dogs.version`;
 const GLOBAL_VERSION_MARKER = "sortie-dogs.version";
+const LUNA_FABRIC_CONTROL_IGNORE = `${OPEN_CODE_DIRECTORY}/.gitignore`;
+const LUNA_FABRIC_CONTROL_FILE = "sortie-dogs-luna-fabric.json";
 const LEGACY_RUNTIME_ASSETS = [
     {
         relativePath: ".opencode/agent/coordinator-mk2a2.md",
@@ -263,6 +265,44 @@ async function overwriteFileSafely(root, relativePath, content, beforeMutation)
         await handle?.close();
     }
 }
+async function appendFileSafely(root, relativePath, content) {
+    await assertSafeExistingPath(root, relativePath, true);
+    let handle;
+    try {
+        handle = await open(resolve(root, relativePath), constants.O_WRONLY | constants.O_APPEND | constants.O_NOFOLLOW);
+        if (!(await handle.stat()).isFile()) {
+            throw new ProjectInitializationError("conflict", "An initialization file path is not a regular file.");
+        }
+        await handle.writeFile(content, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ELOOP") {
+            throw new ProjectInitializationError("unsafe-path", "Initialization paths must not contain symbolic links.", {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function ensureProjectLunaControlIgnore(root, createdFiles = [], modifiedFiles = [], createdDirectories = []) {
+    const relativePath = LUNA_FABRIC_CONTROL_IGNORE;
+    const present = await assertSafeExistingPath(root, relativePath, true);
+    if (!present) {
+        await ensureDirectory(root, OPEN_CODE_DIRECTORY, createdDirectories);
+        await createFile(resolve(root, relativePath), `${LUNA_FABRIC_CONTROL_FILE}\n`, createdFiles);
+        return;
+    }
+    const current = await readFile(resolve(root, relativePath));
+    const text = current.toString("utf8");
+    if (new RegExp(`(?:^|\\r?\\n)${LUNA_FABRIC_CONTROL_FILE.replace(".", "\\.")}(?:\\r?\\n|$)`, "u").test(text))
+        return;
+    modifiedFiles.push({ relativePath, content: current });
+    const separator = text.endsWith("\n") ? "" : "\n";
+    await appendFileSafely(root, relativePath, `${separator}${LUNA_FABRIC_CONTROL_FILE}\n`);
+}
 const PROJECT_LAYOUT = {
     assetPrefix: OPEN_CODE_DIRECTORY,
     markerPath: VERSION_MARKER,
@@ -313,6 +353,8 @@ async function initializeRoot(requestedRoot, layout) {
     const matches = (entry, index) => existing[index]?.equals(Buffer.from(entry.content)) ?? false;
     const assetsMatch = assetEntries.every(matches);
     if (markerText !== undefined && parseMarker(markerText.toString("utf8")) === version && assetsMatch) {
+        if (!layout.preserveAllLegacy)
+            await ensureProjectLunaControlIgnore(root);
         return {
             status: "unchanged",
             version,
@@ -350,6 +392,9 @@ async function initializeRoot(requestedRoot, layout) {
     const removedFiles = [];
     const createdDirectories = [];
     try {
+        if (!layout.preserveAllLegacy) {
+            await ensureProjectLunaControlIgnore(root, createdFiles, modifiedFiles, createdDirectories);
+        }
         for (let index = 0; index < entries.length; index += 1) {
             const entry = entries[index];
             if (matches(entry, index))

package/dist/core/luna-fabric-contract.d.ts

@@ -0,0 +1,54 @@
+export declare const LUNA_FABRIC_CONTRACT_VERSION = "0.8.0";
+export type LunaFabricExternalEffect = "release" | "publish" | "tag" | "version" | "remote-state" | "credential" | "irreversible";
+export interface LunaFabricProvenance {
+    readonly source: "dog-coordinator";
+    readonly acceptance_fingerprint: string;
+    readonly target_branch: string;
+    readonly target_sha: string;
+}
+export interface LunaFabricValidation {
+    readonly level: "targeted" | "full";
+    readonly command: readonly string[];
+}
+export interface LunaFabricUnit {
+    readonly unit_id: string;
+    readonly acceptance_items: readonly string[];
+    readonly scope_read: readonly string[];
+    readonly scope_write: readonly string[];
+    readonly depends_on: readonly string[];
+    readonly validation: LunaFabricValidation;
+    readonly shared_path_keys: readonly string[];
+    readonly exclusive_resources: readonly string[];
+    readonly scheduler_order: number;
+}
+export interface LunaFabricSharedPath {
+    readonly key: string;
+    readonly path: string;
+}
+export interface LunaFabricContract {
+    readonly version: typeof LUNA_FABRIC_CONTRACT_VERSION;
+    readonly provenance: LunaFabricProvenance;
+    readonly acceptance_items: readonly string[];
+    readonly effects: readonly LunaFabricExternalEffect[];
+    readonly shared_paths: readonly LunaFabricSharedPath[];
+    readonly units: readonly LunaFabricUnit[];
+}
+export type LunaFabricSolReason = "malformed-contract" | "external-effect" | "fewer-than-two-units" | "invalid-scope" | "dependency-invalid" | "acceptance-unowned" | "shared-path-unowned" | "exclusive-resource-conflict" | "no-safe-parallel-width";
+export interface LunaFabricDiagnostic {
+    readonly code: LunaFabricSolReason;
+    readonly pointer: string;
+    readonly detail: string;
+}
+export type LunaFabricAdmission = {
+    readonly route: "luna-fabric";
+    readonly contract: LunaFabricContract;
+    readonly contract_fingerprint: string;
+    readonly width: number;
+    readonly depth: number;
+} | {
+    readonly route: "sol-serial";
+    readonly reason: LunaFabricSolReason;
+    readonly diagnostics: readonly LunaFabricDiagnostic[];
+};
+/** Pure automatic route decision. Unknown or unsafe input always resolves to the stable Sol route. */
+export declare function admitLunaFabric(value: unknown): LunaFabricAdmission;

package/dist/core/luna-fabric-contract.js

@@ -0,0 +1,286 @@
+import { createHash } from "node:crypto";
+import { normalizeWorktreeScopePath, worktreeScopesOverlap } from "./worktree-scope.js";
+export const LUNA_FABRIC_CONTRACT_VERSION = "0.8.0";
+const IDS = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const SHA = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u;
+const FINGERPRINT = /^[a-f0-9]{64}$/u;
+const EFFECTS = new Set([
+    "release", "publish", "tag", "version", "remote-state", "credential", "irreversible",
+]);
+const MAX_UNITS = 64;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function exactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function text(value, maximum = 512) {
+    return typeof value === "string" && value.length > 0 && value.length <= maximum &&
+        !/[\u0000-\u001f\u007f]/u.test(value);
+}
+function stringList(value, maximum = 256) {
+    return Array.isArray(value) && value.length <= maximum && value.every((entry) => text(entry));
+}
+function unique(values) {
+    return new Set(values).size === values.length;
+}
+function exactPath(value) {
+    if (!text(value))
+        return false;
+    try {
+        return normalizeWorktreeScopePath(value) === value;
+    }
+    catch {
+        return false;
+    }
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
+}
+function contractFingerprint(contract) {
+    return createHash("sha256").update(JSON.stringify(canonical(contract))).digest("hex");
+}
+function malformed(pointer, detail) {
+    return {
+        route: "sol-serial",
+        reason: "malformed-contract",
+        diagnostics: [{ code: "malformed-contract", pointer, detail }],
+    };
+}
+function parseContract(value) {
+    if (!isRecord(value) || !exactKeys(value, [
+        "acceptance_items", "effects", "provenance", "shared_paths", "units", "version",
+    ]))
+        return malformed("/", "contract shape must contain only the closed v0.8 fields");
+    if (value.version !== LUNA_FABRIC_CONTRACT_VERSION)
+        return malformed("/version", "unsupported version");
+    if (!isRecord(value.provenance) || !exactKeys(value.provenance, [
+        "acceptance_fingerprint", "source", "target_branch", "target_sha",
+    ]) || value.provenance.source !== "dog-coordinator" ||
+        typeof value.provenance.acceptance_fingerprint !== "string" ||
+        !FINGERPRINT.test(value.provenance.acceptance_fingerprint) || !text(value.provenance.target_branch, 256) ||
+        typeof value.provenance.target_sha !== "string" || !SHA.test(value.provenance.target_sha)) {
+        return malformed("/provenance", "provenance must identify dog-coordinator, acceptance, and exact target");
+    }
+    if (!stringList(value.acceptance_items) || value.acceptance_items.length === 0 ||
+        !unique(value.acceptance_items))
+        return malformed("/acceptance_items", "acceptance items must be unique");
+    if (!Array.isArray(value.effects) || !unique(value.effects) ||
+        value.effects.some((effect) => typeof effect !== "string" || !EFFECTS.has(effect))) {
+        return malformed("/effects", "effects must use known classifications");
+    }
+    if (!Array.isArray(value.shared_paths) || value.shared_paths.length > 256) {
+        return malformed("/shared_paths", "shared path ownership must be bounded");
+    }
+    const sharedPaths = [];
+    const sharedKeys = new Set();
+    const sharedPathIdentities = new Set();
+    for (let index = 0; index < value.shared_paths.length; index += 1) {
+        const entry = value.shared_paths[index];
+        if (isRecord(entry) && typeof entry.path === "string" && !exactPath(entry.path)) {
+            return reject("invalid-scope", `/shared_paths/${index}/path`, "shared path must be normalized repository-relative");
+        }
+        if (!isRecord(entry) || !exactKeys(entry, ["key", "path"]) || !text(entry.key, 128) ||
+            !IDS.test(entry.key) || !exactPath(entry.path) || sharedKeys.has(entry.key) ||
+            sharedPathIdentities.has(entry.path.toLowerCase())) {
+            return malformed(`/shared_paths/${index}`, "shared path key and exact path must be unique");
+        }
+        sharedKeys.add(entry.key);
+        sharedPathIdentities.add(entry.path.toLowerCase());
+        sharedPaths.push({ key: entry.key, path: entry.path });
+    }
+    if (!Array.isArray(value.units) || value.units.length === 0 || value.units.length > MAX_UNITS) {
+        return malformed("/units", "unit count must be bounded");
+    }
+    const units = [];
+    const unitIDs = new Set();
+    const schedulerOrders = new Set();
+    for (let index = 0; index < value.units.length; index += 1) {
+        const unit = value.units[index];
+        if (isRecord(unit)) {
+            for (const field of ["scope_read", "scope_write"]) {
+                if (Array.isArray(unit[field]) && unit[field].some((path) => typeof path === "string" && !exactPath(path))) {
+                    return reject("invalid-scope", `/units/${index}/${field}`, "scope must use normalized repository-relative paths");
+                }
+            }
+        }
+        if (!isRecord(unit) || !exactKeys(unit, [
+            "acceptance_items", "depends_on", "exclusive_resources", "scheduler_order", "scope_read",
+            "scope_write", "shared_path_keys", "unit_id", "validation",
+        ]) || !text(unit.unit_id, 128) || !IDS.test(unit.unit_id) || unitIDs.has(unit.unit_id) ||
+            !stringList(unit.acceptance_items) || unit.acceptance_items.length === 0 || !unique(unit.acceptance_items) ||
+            !stringList(unit.depends_on, MAX_UNITS) || !unique(unit.depends_on) ||
+            !stringList(unit.scope_read) || !unique(unit.scope_read) || !unit.scope_read.every(exactPath) ||
+            !stringList(unit.scope_write) || unit.scope_write.length === 0 || !unique(unit.scope_write) ||
+            !unit.scope_write.every(exactPath) || !stringList(unit.shared_path_keys) || !unique(unit.shared_path_keys) ||
+            !unit.shared_path_keys.every((key) => sharedKeys.has(key)) || !stringList(unit.exclusive_resources, 64) ||
+            !unique(unit.exclusive_resources) || !unit.exclusive_resources.every((resource) => IDS.test(resource)) ||
+            !Number.isInteger(unit.scheduler_order) || unit.scheduler_order < 0 ||
+            schedulerOrders.has(unit.scheduler_order) || !isRecord(unit.validation) ||
+            !exactKeys(unit.validation, ["command", "level"]) ||
+            (unit.validation.level !== "targeted" && unit.validation.level !== "full") ||
+            !Array.isArray(unit.validation.command) || unit.validation.command.length === 0 ||
+            unit.validation.command.length > 129 || !unit.validation.command.every((part) => text(part, 1000))) {
+            return malformed(`/units/${index}`, "unit identity, scope, ownership, resources, and validation must be exact");
+        }
+        unitIDs.add(unit.unit_id);
+        schedulerOrders.add(unit.scheduler_order);
+        units.push({
+            unit_id: unit.unit_id,
+            acceptance_items: Object.freeze([...unit.acceptance_items]),
+            scope_read: Object.freeze([...unit.scope_read]),
+            scope_write: Object.freeze([...unit.scope_write]),
+            depends_on: Object.freeze([...unit.depends_on]),
+            validation: Object.freeze({
+                level: unit.validation.level,
+                command: Object.freeze([...unit.validation.command]),
+            }),
+            shared_path_keys: Object.freeze([...unit.shared_path_keys]),
+            exclusive_resources: Object.freeze([...unit.exclusive_resources]),
+            scheduler_order: unit.scheduler_order,
+        });
+    }
+    return Object.freeze({
+        version: LUNA_FABRIC_CONTRACT_VERSION,
+        provenance: Object.freeze(value.provenance),
+        acceptance_items: Object.freeze([...value.acceptance_items]),
+        effects: Object.freeze([...value.effects]),
+        shared_paths: Object.freeze(sharedPaths.map((entry) => Object.freeze(entry))),
+        units: Object.freeze(units.map((unit) => Object.freeze(unit))),
+    });
+}
+function dependencyClosure(units) {
+    const byID = new Map(units.map((unit) => [unit.unit_id, unit]));
+    if (units.some((unit) => unit.depends_on.some((dependency) => dependency === unit.unit_id || !byID.has(dependency)))) {
+        return undefined;
+    }
+    const closure = new Map();
+    const visiting = new Set();
+    const visit = (unitID) => {
+        if (visiting.has(unitID))
+            return undefined;
+        const cached = closure.get(unitID);
+        if (cached !== undefined)
+            return cached;
+        visiting.add(unitID);
+        const result = new Set();
+        for (const dependency of byID.get(unitID).depends_on) {
+            const nested = visit(dependency);
+            if (nested === undefined)
+                return undefined;
+            result.add(dependency);
+            for (const ancestor of nested)
+                result.add(ancestor);
+        }
+        visiting.delete(unitID);
+        closure.set(unitID, result);
+        return result;
+    };
+    for (const unit of units)
+        if (visit(unit.unit_id) === undefined)
+            return undefined;
+    return closure;
+}
+function writeRelatedOverlap(left, right) {
+    return left.scope_write.some((path) => [...right.scope_write, ...right.scope_read]
+        .some((other) => worktreeScopesOverlap(path, other))) ||
+        right.scope_write.some((path) => left.scope_read.some((other) => worktreeScopesOverlap(path, other)));
+}
+function sharedOwnerCovers(left, right, sharedPaths) {
+    const common = new Set(left.shared_path_keys.filter((key) => right.shared_path_keys.includes(key)));
+    return sharedPaths.some((entry) => common.has(entry.key) &&
+        [...left.scope_write, ...left.scope_read].some((path) => worktreeScopesOverlap(entry.path, path)) &&
+        [...right.scope_write, ...right.scope_read].some((path) => worktreeScopesOverlap(entry.path, path)));
+}
+function incomparable(left, right, closure) {
+    return !closure.get(left.unit_id).has(right.unit_id) && !closure.get(right.unit_id).has(left.unit_id);
+}
+function maximumSafeWidth(units, closure) {
+    let maximum = 1;
+    for (let leftIndex = 0; leftIndex < units.length; leftIndex += 1) {
+        const selected = [units[leftIndex]];
+        for (let rightIndex = leftIndex + 1; rightIndex < units.length; rightIndex += 1) {
+            const candidate = units[rightIndex];
+            if (selected.every((existing) => incomparable(existing, candidate, closure) &&
+                !writeRelatedOverlap(existing, candidate) &&
+                !existing.exclusive_resources.some((resource) => candidate.exclusive_resources.includes(resource)))) {
+                selected.push(candidate);
+            }
+        }
+        maximum = Math.max(maximum, selected.length);
+    }
+    return maximum;
+}
+function dagDepth(units) {
+    const byID = new Map(units.map((unit) => [unit.unit_id, unit]));
+    const depths = new Map();
+    const depth = (unitID) => {
+        const cached = depths.get(unitID);
+        if (cached !== undefined)
+            return cached;
+        const dependencies = byID.get(unitID).depends_on;
+        const value = dependencies.length === 0 ? 1 : 1 + Math.max(...dependencies.map(depth));
+        depths.set(unitID, value);
+        return value;
+    };
+    return Math.max(...units.map((unit) => depth(unit.unit_id)));
+}
+function reject(reason, pointer, detail) {
+    return { route: "sol-serial", reason, diagnostics: [{ code: reason, pointer, detail }] };
+}
+/** Pure automatic route decision. Unknown or unsafe input always resolves to the stable Sol route. */
+export function admitLunaFabric(value) {
+    const parsed = parseContract(value);
+    if ("route" in parsed)
+        return parsed;
+    if (parsed.effects.length > 0)
+        return reject("external-effect", "/effects", parsed.effects.join(","));
+    if (parsed.units.length < 2)
+        return reject("fewer-than-two-units", "/units", "fabric needs useful width");
+    const closure = dependencyClosure(parsed.units);
+    if (closure === undefined)
+        return reject("dependency-invalid", "/units", "dependency is unknown or cyclic");
+    const accepted = new Map(parsed.acceptance_items.map((item) => [item, 0]));
+    for (const unit of parsed.units) {
+        for (const item of unit.acceptance_items) {
+            if (!accepted.has(item))
+                return reject("acceptance-unowned", "/units", `unknown acceptance item: ${item}`);
+            accepted.set(item, accepted.get(item) + 1);
+        }
+    }
+    const invalidAcceptance = [...accepted].find(([, count]) => count !== 1);
+    if (invalidAcceptance !== undefined) {
+        return reject("acceptance-unowned", "/acceptance_items", `${invalidAcceptance[0]} ownership=${invalidAcceptance[1]}`);
+    }
+    for (let leftIndex = 0; leftIndex < parsed.units.length; leftIndex += 1) {
+        const left = parsed.units[leftIndex];
+        for (let rightIndex = leftIndex + 1; rightIndex < parsed.units.length; rightIndex += 1) {
+            const right = parsed.units[rightIndex];
+            if (!incomparable(left, right, closure))
+                continue;
+            if (writeRelatedOverlap(left, right) && !sharedOwnerCovers(left, right, parsed.shared_paths)) {
+                return reject("shared-path-unowned", `/units/${rightIndex}/scope_write`, `${left.unit_id}:${right.unit_id}`);
+            }
+            const resource = left.exclusive_resources.find((entry) => right.exclusive_resources.includes(entry));
+            if (resource !== undefined) {
+                return reject("exclusive-resource-conflict", `/units/${rightIndex}/exclusive_resources`, resource);
+            }
+        }
+    }
+    const width = maximumSafeWidth(parsed.units, closure);
+    if (width < 2)
+        return reject("no-safe-parallel-width", "/units", "no independent disjoint pair");
+    return Object.freeze({
+        route: "luna-fabric",
+        contract: parsed,
+        contract_fingerprint: contractFingerprint(parsed),
+        width,
+        depth: dagDepth(parsed.units),
+    });
+}

package/dist/core/luna-fabric-scheduler.d.ts

@@ -0,0 +1,31 @@
+import type { LunaFabricContract } from "./luna-fabric-contract.js";
+export declare const LUNA_FABRIC_MAX_ACTIVE = 5;
+export interface LunaFabricWave {
+    readonly number: number;
+    readonly base_sha: string;
+    readonly unit_ids: readonly string[];
+    readonly lanes: Readonly<Record<string, number>>;
+}
+export interface LunaFabricSchedulerState {
+    readonly wave: number;
+    readonly base_sha: string;
+    readonly pending: readonly string[];
+    readonly completed: readonly string[];
+    readonly active: LunaFabricWave | null;
+    readonly lane_affinity: Readonly<Record<string, number>>;
+}
+export interface LunaFabricAdvance {
+    readonly candidate_base: string;
+    readonly completed_unit_ids: readonly string[];
+}
+export declare class LunaFabricScheduler {
+    private readonly contract;
+    private readonly byID;
+    constructor(contract: LunaFabricContract, base_sha: string, state?: LunaFabricSchedulerState);
+    private state;
+    snapshot(): LunaFabricSchedulerState;
+    nextWave(): LunaFabricWave | null;
+    advance(advancement: LunaFabricAdvance): LunaFabricSchedulerState;
+    private validateState;
+}
+export declare function createLunaFabricScheduler(contract: LunaFabricContract, base_sha: string, state?: LunaFabricSchedulerState): LunaFabricScheduler;