@aiwg/cli 2026.8.2 → 2026.8.4

package/dist/src/extensions/project-local-remove.js

@@ -93,6 +93,34 @@ export async function hashBundleArtifacts(bundleAbsPath) {
     }
     return out;
 }
+/**
+ * Hash the provider-transformed files produced by a successful deployment.
+ * The source hash map supplies the canonical inventory/key shape; values are
+ * read from the first canonical provider path that exists.
+ */
+export async function hashDeployedBundleArtifacts(projectDir, provider, sourceHashes) {
+    const deployed = {};
+    for (const [sourceRel, sourceHash] of Object.entries(sourceHashes)) {
+        // Keep the complete inventory if a provider path unexpectedly cannot be
+        // resolved. Removal then fails safely instead of clearing the registry
+        // while leaving an untracked provider artifact behind.
+        deployed[sourceRel] = sourceHash;
+        for (const candidate of candidateDeployedPaths(projectDir, provider, sourceRel)) {
+            try {
+                deployed[sourceRel] = await sha256Hex(candidate);
+                break;
+            }
+            catch {
+                // Try translated/provider-alternate paths before leaving it absent.
+            }
+        }
+    }
+    return deployed;
+}
+/** Resolve current provider hashes while preserving old registry entries. */
+export function artifactHashesForProvider(entry, provider) {
+    return entry.deployedArtifactHashes?.[provider] ?? entry.artifactHashes ?? {};
+}
 /** Resolve a recorded source-relative artifact through the canonical provider
  * definition rather than assuming every artifact lives directly under the
  * provider prefix (#1869). Returned paths are absolute for both project- and
@@ -111,6 +139,11 @@ export function candidateDeployedPaths(projectDir, provider, sourceRel) {
     const tail = sourceRel.slice(separator + 1);
     const absoluteRoot = isAbsolute(root) ? root : resolve(projectDir, root);
     const candidates = [join(absoluteRoot, tail)];
+    // Codex discovers project skills from the shared native `.agents/skills`
+    // root while retaining `.codex` as its compatibility deployment surface.
+    if (provider === 'codex' && artifactType === 'skills') {
+        candidates.unshift(join(resolve(projectDir, '.agents', 'skills'), tail));
+    }
     // Provider adapters may translate source extensions.
     if (provider === 'cursor' && artifactType === 'rules' && tail.endsWith('.md')) {
         candidates.push(join(absoluteRoot, `${tail.slice(0, -3)}.mdc`));
@@ -186,12 +219,10 @@ function resolveOwnership(config, selfBundleId, provider, sourceRel) {
             continue;
         if (entry.source !== 'project-local')
             continue;
-        if (!entry.artifactHashes)
-            continue;
-        if (sourceRel in entry.artifactHashes) {
+        const hashes = artifactHashesForProvider(entry, provider);
+        if (sourceRel in hashes) {
             // Same source-rel path claimed by another project-local bundle —
             // the deployed file (if present) is theirs, not ours.
-            void provider;
             return name;
         }
     }
@@ -219,12 +250,12 @@ export async function removeProjectLocalBundle(config, projectDir, bundleId, opt
     const { force = false, provider: onlyProvider, dryRun = false, keepRegistry = false } = opts;
     const confirmMutation = opts.confirmMutation ?? (async () => false);
     const installedEntry = entry;
-    const artifactHashes = installedEntry.artifactHashes ?? {};
     const providers = Object.keys(installedEntry.deployedTo).filter(p => !onlyProvider || p === onlyProvider);
     const outcomes = [];
     const revertedProviders = [];
     const partialProviders = [];
     for (const provider of providers) {
+        const artifactHashes = artifactHashesForProvider(installedEntry, provider);
         let providerHadSkip = false;
         for (const sourceRel of Object.keys(artifactHashes)) {
             const owner = resolveOwnership(config, bundleId, provider, sourceRel);
@@ -334,6 +365,12 @@ export async function removeProjectLocalBundle(config, projectDir, bundleId, opt
         // Mutate registry for fully-reverted providers
         if (!dryRun && !keepRegistry && !providerHadSkip) {
             delete installedEntry.deployedTo[provider];
+            if (installedEntry.deployedArtifactHashes) {
+                delete installedEntry.deployedArtifactHashes[provider];
+                if (Object.keys(installedEntry.deployedArtifactHashes).length === 0) {
+                    delete installedEntry.deployedArtifactHashes;
+                }
+            }
         }
     }
     // Top-level remove activity entry

package/dist/src/mcp/cli.mjs

@@ -47,6 +47,8 @@ Server Options (for add/update):
   --args <a1,a2,...>   Command arguments (comma-separated, for stdio)
   --env <K=V,...>      Environment variables (comma-separated K=V pairs)
   --headers <K=V,...>  HTTP headers (comma-separated K=V pairs)
+  --header-env <K=ENV,...>
+                       Resolve HTTP header values from environment variables
   --description <text> Optional description
 
 Inject Options:
@@ -62,6 +64,8 @@ Serve Options:
 Examples:
   # Define MCP servers
   aiwg mcp add fortemi --url https://memory.s9.internal/mcp --type http
+  aiwg mcp add fortemi-enterprise --url https://memory.example.internal/mcp --type http \
+    --header-env Authorization=AIWG_FORTEMI_TOKEN
   aiwg mcp add gitea --url https://mcp-gitea.integrolabs.net/mcp
   aiwg mcp add mytools --type stdio --command npx --args mcp-server-mytools
 
@@ -498,6 +502,7 @@ async function handleAdd(args) {
   const argsStr = parseFlag(args, '--args');
   const envStr = parseFlag(args, '--env');
   const headersStr = parseFlag(args, '--headers');
+  const headerEnvStr = parseFlag(args, '--header-env');
   const description = parseFlag(args, '--description');
 
   if (type === 'stdio' && !command) {
@@ -518,6 +523,7 @@ async function handleAdd(args) {
     args: argsStr ? argsStr.split(',') : undefined,
     env: parseKVPairs(envStr),
     headers: parseKVPairs(headersStr),
+    headerEnv: parseKVPairs(headerEnvStr),
     description,
   });
 
@@ -564,6 +570,7 @@ async function handleUpdate(args) {
   const argsStr = parseFlag(args, '--args');
   const envStr = parseFlag(args, '--env');
   const headersStr = parseFlag(args, '--headers');
+  const headerEnvStr = parseFlag(args, '--header-env');
   const description = parseFlag(args, '--description');
 
   if (url !== undefined) updates.url = url;
@@ -572,6 +579,7 @@ async function handleUpdate(args) {
   if (argsStr !== undefined) updates.args = argsStr.split(',');
   if (envStr !== undefined) updates.env = parseKVPairs(envStr);
   if (headersStr !== undefined) updates.headers = parseKVPairs(headersStr);
+  if (headerEnvStr !== undefined) updates.headerEnv = parseKVPairs(headerEnvStr);
   if (description !== undefined) updates.description = description;
 
   if (Object.keys(updates).length === 0) {
@@ -608,6 +616,10 @@ async function handleList() {
     console.log(`    Type: ${server.type}`);
     if (server.url) console.log(`    URL: ${server.url}`);
     if (server.command) console.log(`    Command: ${server.command}${server.args ? ' ' + server.args.join(' ') : ''}`);
+    if (server.headerEnv) {
+      const refs = Object.entries(server.headerEnv).map(([header, envName]) => `${header}←${envName}`);
+      console.log(`    Credential refs: ${refs.join(', ')}`);
+    }
     if (server.description) console.log(`    Description: ${server.description}`);
     if (server.injectedProviders && server.injectedProviders.length > 0) {
       console.log(`    Injected into: ${server.injectedProviders.join(', ')}`);

package/dist/src/mcp/registry.js

@@ -20,6 +20,16 @@ const DEFAULT_REGISTRY = {
     kind: 'McpServerRegistry',
     servers: {},
 };
+const ENV_REFERENCE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function validateCredentialReferences(def) {
+    for (const [header, envName] of Object.entries(def.headerEnv ?? {})) {
+        if (!header.trim())
+            throw new Error('MCP header-env header name must not be empty');
+        if (!ENV_REFERENCE_NAME.test(envName)) {
+            throw new Error(`Invalid MCP header environment variable reference "${envName}"`);
+        }
+    }
+}
 export class McpServerRegistry {
     configDir;
     cache = null;
@@ -59,6 +69,7 @@ export class McpServerRegistry {
     }
     /** Add a new MCP server definition */
     async add(def) {
+        validateCredentialReferences(def);
         const data = await this.load();
         if (data.servers[def.name]) {
             throw new Error(`Server "${def.name}" already exists. Use "update" to modify it.`);
@@ -86,12 +97,14 @@ export class McpServerRegistry {
         if (!data.servers[name]) {
             throw new Error(`Server "${name}" not found.`);
         }
-        data.servers[name] = {
+        const next = {
             ...data.servers[name],
             ...updates,
             name, // preserve original name
             updatedAt: new Date().toISOString(),
         };
+        validateCredentialReferences(next);
+        data.servers[name] = next;
         await this.save();
     }
     /** Get a specific server definition */

package/dist/src/mcp/registry.mjs

@@ -60,6 +60,17 @@ const DEFAULT_REGISTRY = {
   servers: {},
 };
 
+const ENV_REFERENCE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function validateCredentialReferences(def) {
+  for (const [header, envName] of Object.entries(def.headerEnv || {})) {
+    if (!header.trim()) throw new Error('MCP header-env header name must not be empty');
+    if (!ENV_REFERENCE_NAME.test(envName)) {
+      throw new Error(`Invalid MCP header environment variable reference "${envName}"`);
+    }
+  }
+}
+
 export class McpServerRegistry {
   #configDir;
   #cache = null;
@@ -99,6 +110,7 @@ export class McpServerRegistry {
   }
 
   async add(def) {
+    validateCredentialReferences(def);
     const data = await this.load();
 
     if (data.servers[def.name]) {
@@ -133,12 +145,14 @@ export class McpServerRegistry {
       throw new Error(`Server "${name}" not found.`);
     }
 
-    data.servers[name] = {
+    const next = {
       ...data.servers[name],
       ...updates,
       name,
       updatedAt: new Date().toISOString(),
     };
+    validateCredentialReferences(next);
+    data.servers[name] = next;
 
     await this.save();
   }

package/dist/src/research/query-cli.js

@@ -40,7 +40,7 @@ function usage() {
     return [
         "Usage: aiwg research-query <question> [--backend fortemi-core|local] [--graph <name>]",
         "                           [--depth quick|thorough] [--sources-only] [--max-sources N]",
-        "                           [--json] [--save]",
+        "                           [--include-diagnostics] [--json] [--save]",
     ].join("\n");
 }
 function flagValue(args, flag, errorMessage) {
@@ -73,7 +73,12 @@ function stripFlags(args) {
         "--depth",
         "--max-sources",
     ]);
-    const bareFlags = new Set(["--sources-only", "--json", "--save"]);
+    const bareFlags = new Set([
+        "--sources-only",
+        "--include-diagnostics",
+        "--json",
+        "--save",
+    ]);
     const question = [];
     for (let index = 0; index < args.length; index++) {
         const arg = args[index];
@@ -96,8 +101,7 @@ function parseArgs(args) {
     if (backend && backend !== "local" && backend !== "fortemi-core") {
         throw new Error("--backend must be local or fortemi-core");
     }
-    const depth = (flagValue(args, "--depth", "--depth must be quick or thorough") ??
-        "thorough");
+    const depth = (flagValue(args, "--depth", "--depth must be quick or thorough") ?? "thorough");
     if (depth !== "quick" && depth !== "thorough") {
         throw new Error("--depth must be quick or thorough");
     }
@@ -113,6 +117,7 @@ function parseArgs(args) {
         depth,
         maxSources,
         sourcesOnly: hasFlag(args, "--sources-only"),
+        includeDiagnostics: hasFlag(args, "--include-diagnostics"),
         json: hasFlag(args, "--json"),
         save: hasFlag(args, "--save"),
     };
@@ -140,18 +145,40 @@ function entryId(entry) {
         text.match(/\bPROF-[A-Z0-9-]+/i)?.[0]?.toUpperCase() ??
         path.basename(entry.path).replace(/\.[^.]+$/, ""));
 }
-function gradeFromText(text) {
-    const normalized = text.toUpperCase();
-    if (/\bVERY\s+LOW\b/.test(normalized))
+function normalizedGrade(value) {
+    const normalized = value.trim().toUpperCase();
+    if (/^(VERY\s+LOW|D)$/.test(normalized))
         return "VERY LOW";
-    if (/\bHIGH\b/.test(normalized))
+    if (/^(HIGH|A(?:-)?)$/.test(normalized))
         return "HIGH";
-    if (/\bMODERATE\b/.test(normalized))
+    if (/^(MODERATE|B(?:-)?)$/.test(normalized))
         return "MODERATE";
-    if (/\bLOW\b/.test(normalized))
+    if (/^(LOW|C(?:-)?)$/.test(normalized))
         return "LOW";
     return "UNKNOWN";
 }
+/**
+ * Extract only an explicitly declared research grade. Generic severity words
+ * in scan reports must never become evidence-quality signals.
+ */
+function gradeForEntry(entry, body) {
+    for (const tag of entry.tags) {
+        const tagged = tag.match(/^grade[-_: ](very[-_ ]low|high|moderate|low|[a-d](?:-)?)$/i);
+        if (tagged)
+            return normalizedGrade(tagged[1].replace(/[-_]/g, " "));
+    }
+    const text = [entry.summary, body].join("\n");
+    const declarations = [
+        /\bGRADE(?:\s+(?:quality|rating|level|assessment))?\s*[:=]\s*\*{0,2}\s*(VERY\s+LOW|HIGH|MODERATE|LOW|[A-D](?:-)?)\b/i,
+        /##\s+GRADE[^\n]*\n(?:[^\n]*\n){0,3}?[^\n]*?(?:overall|rating|level)?\s*[:=]\s*\*{0,2}\s*(VERY\s+LOW|HIGH|MODERATE|LOW|[A-D](?:-)?)\b/i,
+    ];
+    for (const declaration of declarations) {
+        const match = declaration.exec(text);
+        if (match)
+            return normalizedGrade(match[1]);
+    }
+    return "UNKNOWN";
+}
 function relevance(score) {
     if (score >= 0.55)
         return "direct";
@@ -191,26 +218,58 @@ function isResearchEntry(entry) {
         entryPath.includes("/research/") ||
         entryPath.includes("/kb/"));
 }
+/** Generated diagnostics are searchable only by explicit operator opt-in. */
+function isDiagnosticEntry(entry) {
+    const type = entry.type.toLowerCase();
+    const entryPath = entry.path.toLowerCase().replaceAll("\\", "/");
+    const tags = entry.tags.map((tag) => tag.toLowerCase());
+    return (entryPath.includes("/.aiwg/research/quarantine/") ||
+        entryPath.includes("/research/quarantine/") ||
+        /(?:^|\/)no-ref-[^/]*artifact-scan\.md$/.test(entryPath) ||
+        /(?:llm|integrity|artifact)-scan\.md$/.test(entryPath) ||
+        /(?:integrity|artifact|llm)[-_ ]scan|quarantine|diagnostic/.test(type) ||
+        tags.some((tag) => /^(?:integrity|artifact|llm)[-_ ]scan$|^quarantine$|^diagnostic$/.test(tag)));
+}
 function localEntries(cwd, graph) {
     const index = loadGraphIndexFile(cwd, "metadata.json", graph);
-    return index ? Object.values(index.entries) : [];
+    return index ? Object.values(index.entries).map((entry) => ({ entry })) : [];
+}
+function cachedRecordBody(record) {
+    return [
+        record.search?.body,
+        record.text,
+        ...(record.chunks ?? []).map((chunk) => chunk.text),
+    ]
+        .filter((part) => Boolean(part))
+        .join("\n");
 }
 async function backendEntries(cwd, graph, backend) {
     if (backend === "fortemi-core") {
-        const { loadFortemiCoreMetadataEntries } = await import("../artifacts/fortemi-core-query-adapter.js");
+        const { loadFortemiCoreExport, loadFortemiCoreMetadataEntries } = await import("../artifacts/fortemi-core-query-adapter.js");
         const loaded = loadFortemiCoreMetadataEntries(cwd, graph);
-        return { entries: loaded.entries, hint: loaded.reason };
+        if (loaded.reason)
+            return { entries: [], hint: loaded.reason };
+        const exported = loadFortemiCoreExport(cwd, graph);
+        if (!exported.exported)
+            return { entries: [], hint: exported.reason };
+        const records = new Map(exported.exported.items.map((record) => [record.source.path, record]));
+        return {
+            entries: loaded.entries.map((entry) => {
+                const record = records.get(entry.path);
+                return {
+                    entry,
+                    cachedBody: record ? cachedRecordBody(record) : "",
+                };
+            }),
+        };
     }
     return { entries: localEntries(cwd, graph) };
 }
-function sourceForEntry(cwd, entry, question, depth) {
-    const body = depth === "thorough" ? readEntryBody(cwd, entry.path) : "";
-    const sourceText = [
-        entry.title,
-        entry.summary,
-        entry.tags.join(" "),
-        body,
-    ].join("\n");
+function sourceForEntry(cwd, candidate, question, depth) {
+    const { entry } = candidate;
+    const body = depth === "thorough"
+        ? (candidate.cachedBody ?? readEntryBody(cwd, entry.path))
+        : "";
     const score = scoreEntry(entry, question, body, depth);
     if (score <= 0)
         return null;
@@ -219,7 +278,7 @@ function sourceForEntry(cwd, entry, question, depth) {
         path: entry.path,
         title: entry.title,
         type: entry.type,
-        grade: gradeFromText(sourceText),
+        grade: gradeForEntry(entry, body),
         relevance: relevance(score),
         score: Math.round(score * 1000) / 1000,
         summary: entry.summary,
@@ -236,13 +295,24 @@ export async function runResearchQuery(cwd, options) {
         throw new Error(loaded.hint);
     }
     const sources = loaded.entries
-        .filter(isResearchEntry)
-        .map((entry) => sourceForEntry(cwd, entry, options.question, depth))
+        .filter(({ entry }) => isResearchEntry(entry))
+        .filter(({ entry }) => options.includeDiagnostics || !isDiagnosticEntry(entry))
+        .map((candidate) => sourceForEntry(cwd, candidate, options.question, depth))
         .filter((source) => source !== null)
         .sort((left, right) => {
         const scoreCmp = right.score - left.score;
         if (scoreCmp !== 0)
             return scoreCmp;
+        const gradeOrder = [
+            "HIGH",
+            "MODERATE",
+            "LOW",
+            "VERY LOW",
+            "UNKNOWN",
+        ];
+        const gradeCmp = gradeOrder.indexOf(left.grade) - gradeOrder.indexOf(right.grade);
+        if (gradeCmp !== 0)
+            return gradeCmp;
         return left.path.localeCompare(right.path);
     })
         .slice(0, maxSources);

package/dist/src/serve/shared-host-scheduler.js

@@ -0,0 +1,260 @@
+/**
+ * Cross-orchestrator scheduling and admission for shared execution hosts.
+ *
+ * The store is the global serialization boundary. Multiple AIWG processes must
+ * use the same durable implementation; the in-memory store is for tests and
+ * single-process embedding only. Executor substrates report capacity and run
+ * admitted work, but do not own this policy.
+ *
+ * @implements #1566
+ */
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { dirname } from 'node:path';
+export class InMemoryAdmissionStore {
+    snapshot = { revision: 0, records: {} };
+    transact(mutate) {
+        const draft = structuredClone(this.snapshot);
+        const result = mutate(draft);
+        draft.revision += 1;
+        this.snapshot = draft;
+        return result;
+    }
+    read() {
+        return structuredClone(this.snapshot);
+    }
+}
+/** Durable cross-process store. The lock is deliberately non-blocking: a
+ * concurrent writer receives a conflict and retries through its control loop. */
+export class FileAdmissionStore {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    transact(mutate) {
+        mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+        const lockPath = `${this.path}.lock`;
+        let descriptor;
+        try {
+            descriptor = openSync(lockPath, 'wx', 0o600);
+        }
+        catch (error) {
+            if (error.code === 'EEXIST') {
+                throw new Error('shared-host admission store is busy; retry the request');
+            }
+            throw error;
+        }
+        try {
+            const snapshot = this.readUnsafe();
+            const result = mutate(snapshot);
+            snapshot.revision += 1;
+            const temporary = `${this.path}.${process.pid}.tmp`;
+            writeFileSync(temporary, `${JSON.stringify(snapshot, null, 2)}\n`, { mode: 0o600 });
+            renameSync(temporary, this.path);
+            return result;
+        }
+        finally {
+            closeSync(descriptor);
+            try {
+                unlinkSync(lockPath);
+            }
+            catch { /* best-effort lock cleanup */ }
+        }
+    }
+    read() {
+        return structuredClone(this.readUnsafe());
+    }
+    readUnsafe() {
+        if (!existsSync(this.path))
+            return { revision: 0, records: {} };
+        return JSON.parse(readFileSync(this.path, 'utf8'));
+    }
+}
+const terminalStates = new Set([
+    'denied', 'cancelled', 'timed-out', 'preempted',
+]);
+export class SharedHostScheduler {
+    store;
+    policy;
+    clock;
+    constructor(store, policy, clock = Date.now) {
+        this.store = store;
+        this.policy = policy;
+        this.clock = clock;
+        if (!Number.isInteger(policy.maxConcurrent) || policy.maxConcurrent < 1) {
+            throw new Error('maxConcurrent must be a positive integer');
+        }
+        if (policy.leaseTtlMs < 1 || policy.agingIntervalMs < 1) {
+            throw new Error('leaseTtlMs and agingIntervalMs must be positive');
+        }
+    }
+    submit(request) {
+        this.validateRequest(request);
+        return this.store.transact(snapshot => {
+            const existing = snapshot.records[request.requestId];
+            if (existing) {
+                if (!sameRequest(existing, request)) {
+                    throw new Error(`request '${request.requestId}' conflicts with an existing admission`);
+                }
+                return existing;
+            }
+            snapshot.records[request.requestId] = {
+                ...structuredClone(request),
+                state: 'queued',
+                revision: 1,
+                reason: 'awaiting shared-host capacity',
+            };
+            this.reconcile(snapshot);
+            return structuredClone(snapshot.records[request.requestId]);
+        });
+    }
+    reconcileNow() {
+        return this.store.transact(snapshot => {
+            this.reconcile(snapshot);
+            return structuredClone(snapshot);
+        });
+    }
+    renew(requestId) {
+        return this.store.transact(snapshot => {
+            const record = this.required(snapshot, requestId);
+            if (record.state !== 'admitted')
+                throw new Error(`cannot renew ${record.state} admission`);
+            record.leaseExpiresAt = new Date(this.clock() + this.policy.leaseTtlMs).toISOString();
+            record.revision += 1;
+            record.reason = 'lease renewed';
+            return structuredClone(record);
+        });
+    }
+    release(requestId) {
+        return this.store.transact(snapshot => {
+            const record = this.required(snapshot, requestId);
+            delete snapshot.records[requestId];
+            if (record.state === 'admitted')
+                this.reconcile(snapshot);
+            return structuredClone(snapshot);
+        });
+    }
+    cancel(requestId) {
+        return this.store.transact(snapshot => {
+            const record = this.required(snapshot, requestId);
+            if (terminalStates.has(record.state))
+                return structuredClone(record);
+            record.state = 'cancelled';
+            record.reason = 'cancelled by orchestrator';
+            record.finishedAt = new Date(this.clock()).toISOString();
+            record.revision += 1;
+            this.reconcile(snapshot);
+            return structuredClone(record);
+        });
+    }
+    snapshot() {
+        return this.store.read();
+    }
+    reconcile(snapshot) {
+        const now = this.clock();
+        for (const record of Object.values(snapshot.records)) {
+            if (record.state === 'admitted' && Date.parse(record.leaseExpiresAt ?? '') <= now) {
+                record.state = 'timed-out';
+                record.reason = 'admission lease expired; capacity recovered';
+                record.finishedAt = new Date(now).toISOString();
+                record.revision += 1;
+            }
+            else if (record.state === 'queued' && Date.parse(record.submittedAt) + record.queueTimeoutMs <= now) {
+                record.state = 'timed-out';
+                record.reason = 'queue deadline elapsed';
+                record.finishedAt = new Date(now).toISOString();
+                record.revision += 1;
+            }
+        }
+        let queued = Object.values(snapshot.records)
+            .filter(record => record.state === 'queued')
+            .sort((a, b) => this.compare(a, b, now));
+        for (const candidate of queued) {
+            if (!this.hasCapacity(snapshot, candidate)) {
+                if (this.policy.allowPreemption)
+                    this.tryPreempt(snapshot, candidate, now);
+            }
+            if (!this.hasCapacity(snapshot, candidate))
+                continue;
+            candidate.state = 'admitted';
+            candidate.reason = 'admitted by shared-host policy';
+            candidate.admittedAt = new Date(now).toISOString();
+            candidate.leaseExpiresAt = new Date(now + this.policy.leaseTtlMs).toISOString();
+            candidate.revision += 1;
+        }
+        queued = [];
+    }
+    tryPreempt(snapshot, candidate, now) {
+        const victims = Object.values(snapshot.records)
+            .filter(record => record.state === 'admitted' && record.preemptible === true)
+            .sort((a, b) => this.compare(b, a, now));
+        const victim = victims.find(record => {
+            if (this.effectivePriority(record, now) >= this.effectivePriority(candidate, now))
+                return false;
+            const priorState = record.state;
+            record.state = 'preempted';
+            const freesRequiredCapacity = this.hasCapacity(snapshot, candidate);
+            record.state = priorState;
+            return freesRequiredCapacity;
+        });
+        if (!victim)
+            return;
+        victim.state = 'preempted';
+        victim.reason = `preempted by higher-priority request '${candidate.requestId}'`;
+        victim.preemptedBy = candidate.requestId;
+        victim.finishedAt = new Date(now).toISOString();
+        victim.revision += 1;
+    }
+    hasCapacity(snapshot, candidate) {
+        const active = Object.values(snapshot.records).filter(record => record.state === 'admitted');
+        if (active.length >= this.policy.maxConcurrent)
+            return false;
+        if (!belowQuota(active, 'environment', candidate.environment, this.policy.environmentQuotas))
+            return false;
+        if (!belowQuota(active, 'provider', candidate.provider, this.policy.providerQuotas))
+            return false;
+        const runtimeQuotas = {
+            host: this.policy.defaultHostQuota ?? 1,
+            ...this.policy.runtimeQuotas,
+        };
+        return belowQuota(active, 'runtimeKind', candidate.runtimeKind, runtimeQuotas);
+    }
+    effectivePriority(record, now) {
+        const waited = Math.max(0, now - Date.parse(record.submittedAt));
+        return record.priority + Math.floor(waited / this.policy.agingIntervalMs);
+    }
+    compare(a, b, now) {
+        return this.effectivePriority(b, now) - this.effectivePriority(a, now)
+            || Date.parse(a.submittedAt) - Date.parse(b.submittedAt)
+            || a.requestId.localeCompare(b.requestId);
+    }
+    required(snapshot, requestId) {
+        const record = snapshot.records[requestId];
+        if (!record)
+            throw new Error(`unknown admission request '${requestId}'`);
+        return record;
+    }
+    validateRequest(request) {
+        if (!request.requestId || !request.orchestratorId || !request.environment || !request.provider) {
+            throw new Error('request identity, orchestrator, environment, and provider are required');
+        }
+        if (!Number.isFinite(request.priority))
+            throw new Error('priority must be finite');
+        if (!Number.isFinite(Date.parse(request.submittedAt)))
+            throw new Error('submittedAt must be a timestamp');
+        if (request.queueTimeoutMs < 1)
+            throw new Error('queueTimeoutMs must be positive');
+    }
+}
+function belowQuota(active, field, value, quotas) {
+    const quota = quotas?.[String(value)];
+    if (quota === undefined)
+        return true;
+    return active.filter(record => record[field] === value).length < quota;
+}
+function sameRequest(record, request) {
+    return record.orchestratorId === request.orchestratorId
+        && record.environment === request.environment
+        && record.provider === request.provider
+        && record.runtimeKind === request.runtimeKind;
+}
+//# sourceMappingURL=shared-host-scheduler.js.map