@voybio/ace-swarm 2.4.3 → 2.4.4

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [2.4.3] - 2026-05-23
+
+### Changed
+
+- Reduced default packaged workspace gates to portable ACE lifecycle gates only (`gate-autonomy`, `gate-completeness`, `gate-security`, `gate-operability`).
+- Made `execute_gates({})` resolve the active ACE stage from `STATUS.md` and `TEAL_CONFIG.md` and only run stage-activated workspace gates by default.
+- Added automatic exact-match migration for legacy package-seeded gate assets during store bootstrap and `ace repair`, while preserving customized project gates.
+- Kept TypeScript public-surface verification in the package maintenance path instead of default workspace gate execution.
+
 ## [2.4.1] - 2026-05-08
 
 ### Changed

package/assets/agent-state/INTERFACE_REGISTRY.md

@@ -54,9 +54,9 @@
 
 ## Public Surface Gate
 
-- `audit_public_surface` is the canonical TypeScript public-surface gate for MCP tools, resources, prompts, and registered event names.
+- `audit_public_surface` is the canonical TypeScript public-surface audit for MCP tools, resources, prompts, and registered event names.
 - `PUBLIC_SURFACE_REPORT.md` is the durable audit artifact written by that gate.
-- `MODULES/gates/gate-typescript-public-surface.json` is the executable gate manifest for CI or operator use.
+- The package-level public-surface check remains an explicit package maintenance tool or CI gate; it is not seeded into initialized ACE workspaces as a default stage gate.
 
 ## Provenance Contract
 

package/assets/agent-state/MODULES/gates/gate-autonomy.json

@@ -1,7 +1,9 @@
 {
   "id": "gate-autonomy",
   "type": "artifact_scan",
-  "invariant": "Every execution cycle records objective, strategy, evidence, and next state",
+  "scope": "workspace",
+  "activation": "stage",
+  "invariant": "ACE lifecycle state records objective, evidence, and handoff continuity for the active stage",
   "command": "",
-  "evidence_requirement": "STATUS + EVIDENCE_LOG + HANDOFF pointers"
+  "evidence_requirement": "STATUS.md + EVIDENCE_LOG.md + HANDOFF.json"
 }

package/assets/agent-state/MODULES/gates/gate-completeness.json

@@ -1,7 +1,9 @@
 {
   "id": "gate-completeness",
   "type": "artifact_scan",
-  "invariant": "All required artifacts exist and are non-empty",
+  "scope": "workspace",
+  "activation": "stage",
+  "invariant": "Required ACE lifecycle state artifacts exist and are non-empty",
   "command": "",
-  "evidence_requirement": "File presence and section completeness evidence"
+  "evidence_requirement": "TASK.md + SCOPE.md + QUALITY_GATES.md + STATUS.md + HANDOFF.json + EVIDENCE_LOG.md + DECISIONS.md + RISKS.md + TEAL_CONFIG.md + PROVENANCE_LOG.md + ARTIFACT_MANIFEST.json"
 }

package/assets/agent-state/MODULES/gates/gate-operability.json

@@ -1,7 +1,9 @@
 {
   "id": "gate-operability",
   "type": "artifact_scan",
-  "invariant": "Runbooks, ownership, and incident routing are defined for release",
+  "scope": "workspace",
+  "activation": "stage",
+  "invariant": "Release-stage operability evidence records observability coverage and a release decision",
   "command": "",
-  "evidence_requirement": "COMMUNICATION_CHANNELS.md + observability/release artifacts"
+  "evidence_requirement": "OBSERVABILITY_REPORT.md + RELEASE_DECISION.md"
 }

package/assets/agent-state/MODULES/gates/gate-security.json

@@ -1,7 +1,9 @@
 {
   "id": "gate-security",
   "type": "manual_review",
+  "scope": "workspace",
+  "activation": "stage",
   "invariant": "No unmitigated high-severity security or policy risks",
   "command": "",
-  "evidence_requirement": "SECURITY_REPORT.md with explicit mitigations or accepted residual risk"
+  "evidence_requirement": "RISKS.md + SECURITY_REPORT.md"
 }

package/assets/agent-state/MODULES/registry.json

@@ -19,12 +19,9 @@
   ],
   "gates": [
     "gate-completeness",
-    "gate-correctness",
     "gate-autonomy",
     "gate-security",
-    "gate-operability",
-    "gate-evaluation",
-    "gate-typescript-public-surface"
+    "gate-operability"
   ],
   "schemas": [
     "STATUS_EVENT.schema.json",

package/assets/agent-state/MODULES/roles/capability-build.json

@@ -18,8 +18,7 @@
   ],
   "outputs": [
     {
-      "file": "ARTIFACT_MANIFEST.json",
-      "validation_gate": "gate-correctness"
+      "file": "ARTIFACT_MANIFEST.json"
     }
   ],
   "events": {

package/assets/agent-state/MODULES/roles/capability-eval.json

@@ -11,7 +11,7 @@
     {"file": "EVIDENCE_LOG.md", "critical": true}
   ],
   "outputs": [
-    {"file": "EVAL_REPORT.md", "validation_gate": "gate-evaluation"}
+    {"file": "EVAL_REPORT.md"}
   ],
   "failure_routing": {
     "missing_input": "BLOCK_AND_REQUEST_INFO",

package/assets/agent-state/MODULES/roles/capability-qa.json

@@ -18,8 +18,7 @@
   ],
   "outputs": [
     {
-      "file": "VERIFICATION_REPORT.md",
-      "validation_gate": "gate-correctness"
+      "file": "VERIFICATION_REPORT.md"
     }
   ],
   "events": {

package/assets/agent-state/QUALITY_GATES.md

@@ -1,15 +1,31 @@
 # QUALITY GATES
 
+Portable default workspace gates cover ACE lifecycle verification only. Product correctness, evaluation, and package public-surface checks must be added explicitly when a project needs them.
+
 ## gate-completeness
 
-- Invariant: required artifacts exist and are non-empty.
-- Pass condition: all required files are present with required sections.
-- Fail condition: any missing required artifact or empty required section.
-- Evidence: file list + section checks in `EVIDENCE_LOG.md`.
+- Invariant: required ACE lifecycle state artifacts exist and are non-empty.
+- Pass condition: the seeded ACE state surface is present and readable.
+- Fail condition: any required ACE state artifact is missing or empty.
+- Evidence: `TASK.md`, `SCOPE.md`, `QUALITY_GATES.md`, `STATUS.md`, `HANDOFF.json`, `EVIDENCE_LOG.md`, `DECISIONS.md`, `RISKS.md`, `TEAL_CONFIG.md`, `PROVENANCE_LOG.md`, and `ARTIFACT_MANIFEST.json`.
+
+## gate-autonomy
+
+- Invariant: the active ACE stage records status, evidence, and handoff continuity.
+- Pass condition: `STATUS.md`, `EVIDENCE_LOG.md`, and `HANDOFF.json` exist for the active stage.
+- Fail condition: any of those lifecycle artifacts is missing.
+- Evidence: `STATUS.md`, `EVIDENCE_LOG.md`, and `HANDOFF.json`.
+
+## gate-security
+
+- Invariant: security review has explicit risk context and a review artifact.
+- Pass condition: the active security review records `RISKS.md` and `SECURITY_REPORT.md`, then the manual review is completed.
+- Fail condition: required review artifacts are missing or manual review is still pending.
+- Evidence: `RISKS.md` and `SECURITY_REPORT.md`.
 
-## gate-correctness
+## gate-operability
 
-- Invariant: behavior satisfies spec acceptance criteria.
-- Pass condition: mapped tests pass and no unresolved critical failures.
-- Fail condition: failing mapped test, unresolved regression, or invalid provenance.
-- Evidence: test output and verification report pointers.
+- Invariant: release readiness includes observability evidence and a release decision.
+- Pass condition: `OBSERVABILITY_REPORT.md` and `RELEASE_DECISION.md` exist for the release stage.
+- Fail condition: either release-stage artifact is missing.
+- Evidence: `OBSERVABILITY_REPORT.md` and `RELEASE_DECISION.md`.

package/assets/agent-state/TEAL_CONFIG.md

@@ -37,7 +37,7 @@ modules:
   qa:
     version: "1.0.0"
     depends_on: ["build"]
-    gates: ["gate-completeness", "gate-correctness", "gate-autonomy"]
+    gates: ["gate-completeness"]
 
   docs:
     version: "1.0.0"
@@ -64,7 +64,6 @@ modules:
   eval:
     version: "1.0.0"
     depends_on: ["qa"]
-    gates: ["gate-evaluation"]
 
   release:
     version: "1.0.0"
@@ -93,11 +92,7 @@ pipelines:
 gates:
   gate-completeness:
     module: qa
-    inputs: ["SPEC_CONTRACT.json", "artifact_set"]
-
-  gate-correctness:
-    module: qa
-    inputs: ["test_results", "EVIDENCE_LOG.md"]
+    inputs: ["TASK.md", "SCOPE.md", "QUALITY_GATES.md", "STATUS.md", "HANDOFF.json", "EVIDENCE_LOG.md", "DECISIONS.md", "RISKS.md", "TEAL_CONFIG.md", "PROVENANCE_LOG.md", "ARTIFACT_MANIFEST.json"]
 
   gate-autonomy:
     module: skeptic
@@ -107,10 +102,6 @@ gates:
     module: security
     inputs: ["RISKS.md", "SECURITY_REPORT.md"]
 
-  gate-evaluation:
-    module: eval
-    inputs: ["EVAL_REPORT.md"]
-
   gate-operability:
     module: release
     inputs: ["OBSERVABILITY_REPORT.md", "RELEASE_DECISION.md"]

package/dist/astgrep-index.d.ts

@@ -10,11 +10,17 @@ interface AstGrepMatch {
             line?: number;
             column?: number;
         };
+        byteOffset?: {
+            start?: number;
+            end?: number;
+        };
     };
-    metaVariables?: Record<string, unknown>;
+    metaVariables?: unknown;
     kind?: string;
     nodeKind?: string;
+    replacement?: string;
 }
+export declare function flattenMetaVariables(raw: unknown): Record<string, string>;
 export interface AstgrepMatch {
     file: string;
     line: number;

package/dist/astgrep-index.js

@@ -4,6 +4,57 @@ import { isAbsolute, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { appendStatusEventSafe } from "./status-events.js";
 import { safeRead, safeWrite, WORKSPACE_ROOT, wsPath } from "./helpers.js";
+function textFromMetaValue(value) {
+    if (typeof value === "string")
+        return value;
+    if (value && typeof value === "object") {
+        const text = value.text;
+        if (typeof text === "string")
+            return text;
+    }
+    return undefined;
+}
+const META_SINGLE_BUCKETS = ["single", "transformed"];
+const META_MULTI_BUCKETS = ["multi"];
+export function flattenMetaVariables(raw) {
+    const out = {};
+    if (!raw || typeof raw !== "object")
+        return out;
+    const root = raw;
+    for (const bucketKey of META_SINGLE_BUCKETS) {
+        const bucket = root[bucketKey];
+        if (bucket && typeof bucket === "object") {
+            for (const [name, value] of Object.entries(bucket)) {
+                const text = textFromMetaValue(value);
+                if (typeof text === "string" && text.length > 0)
+                    out[name] = text;
+            }
+        }
+    }
+    for (const bucketKey of META_MULTI_BUCKETS) {
+        const bucket = root[bucketKey];
+        if (bucket && typeof bucket === "object") {
+            for (const [name, value] of Object.entries(bucket)) {
+                if (!Array.isArray(value))
+                    continue;
+                const texts = value
+                    .map(textFromMetaValue)
+                    .filter((text) => typeof text === "string" && text.length > 0);
+                if (texts.length > 0)
+                    out[name] = texts.join("");
+            }
+        }
+    }
+    const reserved = new Set([...META_SINGLE_BUCKETS, ...META_MULTI_BUCKETS]);
+    for (const [name, value] of Object.entries(root)) {
+        if (reserved.has(name) || out[name] !== undefined)
+            continue;
+        const text = textFromMetaValue(value);
+        if (typeof text === "string" && text.length > 0)
+            out[name] = text;
+    }
+    return out;
+}
 export function runAstgrepQuery(pattern, lang, roots, _contextLines) {
     const cmd = detectAstgrepCommand();
     const raw = runAstgrep(cmd, pattern, lang, roots);
@@ -32,15 +83,8 @@ function nodeKindForMatch(match) {
     return undefined;
 }
 function captureMapForMatch(match) {
-    if (!match.metaVariables)
-        return undefined;
-    const captures = Object.entries(match.metaVariables).reduce((acc, [key]) => {
-        const text = extractMetaVarText(match, key);
-        if (typeof text === "string" && text.length > 0)
-            acc[key] = text;
-        return acc;
-    }, {});
-    return Object.keys(captures).length > 0 ? captures : undefined;
+    const flat = flattenMetaVariables(match.metaVariables);
+    return Object.keys(flat).length > 0 ? flat : undefined;
 }
 function computeMatchId(input) {
     const encoded = [
@@ -59,12 +103,8 @@ function computeMatchId(input) {
 function matchUsesSymbolHint(match, symbolHint) {
     if ((match.text ?? "").includes(symbolHint))
         return true;
-    if (!match.metaVariables)
-        return false;
-    return Object.keys(match.metaVariables).some((key) => {
-        const text = extractMetaVarText(match, key);
-        return typeof text === "string" && text.includes(symbolHint);
-    });
+    const flat = flattenMetaVariables(match.metaVariables);
+    return Object.values(flat).some((text) => text.includes(symbolHint));
 }
 export function locateAstgrepMatches(input) {
     const scope = resolveScope(input.scope ?? "src");
@@ -109,6 +149,14 @@ export function locateAstgrepMatches(input) {
                 line: match.range.end?.line ?? 0,
                 column: match.range.end?.column ?? 0,
             },
+            ...(match.range.byteOffset
+                ? {
+                    byteOffset: {
+                        start: match.range.byteOffset.start ?? 0,
+                        end: match.range.byteOffset.end ?? 0,
+                    },
+                }
+                : {}),
         };
         return [{
                 match_id: computeMatchId({
@@ -270,27 +318,6 @@ function runAstgrep(astgrepCmd, pattern, lang, paths) {
         return [];
     return parseAstgrepOutput(res.stdout);
 }
-function extractMetaVarText(match, key) {
-    const raw = match.metaVariables?.[key];
-    if (!raw)
-        return undefined;
-    if (typeof raw === "string")
-        return raw;
-    if (raw && typeof raw === "object" && "text" in raw && typeof raw.text === "string") {
-        return raw.text;
-    }
-    if (Array.isArray(raw)) {
-        const first = raw[0];
-        if (typeof first === "string")
-            return first;
-        if (first && typeof first === "object" && "text" in first) {
-            const text = first.text;
-            if (typeof text === "string")
-                return text;
-        }
-    }
-    return undefined;
-}
 function uniqueSorted(values, limit) {
     return [...new Set(values.filter(Boolean))].sort((a, b) => a.localeCompare(b)).slice(0, limit);
 }
@@ -357,13 +384,13 @@ export async function refreshAstgrepIndex(input = {}) {
     const pyTestMatches = runAstgrep(astgrepCmd, "def test_$NAME($$$ARGS):", "python", pyRoots);
     const handoffRefMatches = runAstgrep(astgrepCmd, '$X(\"SWARM_HANDOFF.$Y\")', "ts", tsRoots);
     const exportedFunctions = uniqueSorted(exportedFnMatches
-        .map((m) => extractMetaVarText(m, "NAME"))
+        .map((m) => flattenMetaVariables(m.metaVariables).NAME)
         .filter((v) => Boolean(v)), 40);
     const exportedClasses = uniqueSorted(exportedClassMatches
-        .map((m) => extractMetaVarText(m, "NAME"))
+        .map((m) => flattenMetaVariables(m.metaVariables).NAME)
         .filter((v) => Boolean(v)), 30);
     const asyncFunctions = uniqueSorted(asyncFnMatches
-        .map((m) => extractMetaVarText(m, "NAME"))
+        .map((m) => flattenMetaVariables(m.metaVariables).NAME)
         .filter((v) => Boolean(v)), 40);
     // Fallback symbol extraction when AST match shapes differ across language versions.
     const tsFiles = codeFiles.filter((file) => /\.(ts|tsx|js)$/i.test(file));

package/dist/gate-contract.d.ts

@@ -0,0 +1,63 @@
+export type GateScope = "workspace" | "package";
+export type GateActivation = "stage" | "explicit_only";
+export type GateManifestType = "executable" | "artifact_scan" | "manual_review";
+export type GateManifestSource = "workspace" | "store" | "none";
+export type GateSelectionMode = "explicit" | "active_stage";
+export interface GateManifest {
+    id: string;
+    type: GateManifestType;
+    invariant: string;
+    command: string;
+    evidence_requirement: string;
+    scope?: GateScope;
+    activation?: GateActivation;
+    source_ref?: string;
+}
+export interface GateSelectionContext {
+    active_role?: string;
+    active_module?: string;
+    active_pipeline?: string;
+}
+export interface TealModuleConfig {
+    version?: string;
+    interface?: string;
+    sidecar?: boolean;
+    depends_on?: string[];
+    outputs?: string[];
+    gates?: string[];
+}
+export interface TealGateConfig {
+    module?: string;
+    inputs?: string[];
+}
+export interface TealConfig {
+    modules?: Record<string, TealModuleConfig>;
+    pipelines?: Record<string, unknown>;
+    gates?: Record<string, TealGateConfig>;
+}
+export interface GateSelectionResult extends GateSelectionContext {
+    selection_mode: GateSelectionMode;
+    manifest_source: GateManifestSource;
+    selected: GateManifest[];
+    selected_gate_ids: string[];
+    skipped_gate_ids: string[];
+    all_gate_ids: string[];
+    missing_explicit_gate_ids: string[];
+    note?: string;
+}
+export declare function normalizeActiveModuleName(value?: string): string | undefined;
+export declare function parseGateManifest(raw: string, sourceRef: string): GateManifest | undefined;
+export declare function extractFencedYamlBlock(content: string): {
+    language: string;
+    yaml: string;
+} | undefined;
+export declare function parseTealConfigMarkdown(content: string): TealConfig | undefined;
+export declare function parseStatusStageContext(content: string): GateSelectionContext;
+export declare function resolveGateSelection(params: {
+    gates: GateManifest[];
+    manifestSource: GateManifestSource;
+    statusRaw: string;
+    tealRaw: string;
+    gateIds?: string[];
+}): GateSelectionResult;
+//# sourceMappingURL=gate-contract.d.ts.map

package/dist/gate-contract.js

@@ -0,0 +1,178 @@
+import { parseDocument } from "yaml";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeLineEndings(value) {
+    return value.replace(/\r\n/g, "\n");
+}
+function uniquePush(target, value) {
+    if (!target.includes(value))
+        target.push(value);
+}
+export function normalizeActiveModuleName(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim().replace(/^`|`$/g, "");
+    if (!trimmed)
+        return undefined;
+    return trimmed.replace(/^(capability|agent)-/, "");
+}
+export function parseGateManifest(raw, sourceRef) {
+    try {
+        const gate = JSON.parse(raw);
+        if (!isRecord(gate))
+            return undefined;
+        const id = typeof gate.id === "string" ? gate.id.trim() : "";
+        if (!id)
+            return undefined;
+        const type = gate.type === "executable" || gate.type === "artifact_scan" || gate.type === "manual_review"
+            ? gate.type
+            : "manual_review";
+        const scope = gate.scope === "workspace" || gate.scope === "package" ? gate.scope : undefined;
+        const activation = gate.activation === "stage" || gate.activation === "explicit_only"
+            ? gate.activation
+            : undefined;
+        return {
+            id,
+            type,
+            invariant: typeof gate.invariant === "string" ? gate.invariant : "",
+            command: typeof gate.command === "string" ? gate.command : "",
+            evidence_requirement: typeof gate.evidence_requirement === "string" ? gate.evidence_requirement : "",
+            ...(scope ? { scope } : {}),
+            ...(activation ? { activation } : {}),
+            source_ref: sourceRef,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function extractFencedYamlBlock(content) {
+    const normalized = normalizeLineEndings(content);
+    const fenceCount = (normalized.match(/```/g) ?? []).length;
+    const fencedBlocks = [...normalized.matchAll(/```([^\n]*)\n([\s\S]*?)```/g)];
+    if (fenceCount !== 2 || fencedBlocks.length !== 1) {
+        return undefined;
+    }
+    const block = fencedBlocks[0];
+    return {
+        language: block[1].trim().toLowerCase(),
+        yaml: block[2].trim(),
+    };
+}
+export function parseTealConfigMarkdown(content) {
+    const block = extractFencedYamlBlock(content);
+    if (!block || block.language !== "yaml" || !block.yaml) {
+        return undefined;
+    }
+    const document = parseDocument(block.yaml);
+    if (document.errors.length > 0) {
+        return undefined;
+    }
+    const parsed = document.toJS();
+    return isRecord(parsed) ? parsed : undefined;
+}
+function extractStatusField(content, label) {
+    const normalized = normalizeLineEndings(content);
+    const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = normalized.match(new RegExp(`^-\\s*${escapedLabel}:\\s*(.+)$`, "im"));
+    if (!match)
+        return undefined;
+    const value = match[1].trim().replace(/^`|`$/g, "");
+    return value || undefined;
+}
+export function parseStatusStageContext(content) {
+    const activeRole = extractStatusField(content, "Current role");
+    const explicitModule = extractStatusField(content, "Current module");
+    return {
+        active_role: activeRole,
+        active_module: normalizeActiveModuleName(explicitModule ?? activeRole),
+        active_pipeline: extractStatusField(content, "Active pipeline"),
+    };
+}
+function readStageAssignedGateIds(tealConfig, activeModule) {
+    if (!tealConfig || !activeModule)
+        return [];
+    const gateIds = [];
+    const moduleConfig = tealConfig.modules?.[activeModule];
+    if (moduleConfig && Array.isArray(moduleConfig.gates)) {
+        for (const gateId of moduleConfig.gates) {
+            if (typeof gateId === "string" && gateId.trim()) {
+                uniquePush(gateIds, gateId.trim());
+            }
+        }
+    }
+    if (tealConfig.gates) {
+        for (const [gateId, gateConfig] of Object.entries(tealConfig.gates)) {
+            if (gateConfig &&
+                typeof gateConfig.module === "string" &&
+                normalizeActiveModuleName(gateConfig.module) === activeModule) {
+                uniquePush(gateIds, gateId);
+            }
+        }
+    }
+    return gateIds;
+}
+function effectiveGateScope(gate) {
+    return gate.scope ?? "workspace";
+}
+function effectiveGateActivation(gate, assignedStageGateIds) {
+    return gate.activation ?? (assignedStageGateIds.has(gate.id) ? "stage" : "explicit_only");
+}
+export function resolveGateSelection(params) {
+    const { gates, manifestSource, statusRaw, tealRaw, gateIds } = params;
+    const allGateIds = gates.map((gate) => gate.id);
+    const statusContext = parseStatusStageContext(statusRaw);
+    if (Array.isArray(gateIds) && gateIds.length > 0) {
+        const gateMap = new Map(gates.map((gate) => [gate.id, gate]));
+        const selected = [];
+        const missingExplicitGateIds = [];
+        for (const gateId of gateIds) {
+            const gate = gateMap.get(gateId);
+            if (gate) {
+                selected.push(gate);
+            }
+            else if (!missingExplicitGateIds.includes(gateId)) {
+                missingExplicitGateIds.push(gateId);
+            }
+        }
+        return {
+            selection_mode: "explicit",
+            manifest_source: manifestSource,
+            selected,
+            selected_gate_ids: selected.map((gate) => gate.id),
+            skipped_gate_ids: allGateIds.filter((gateId) => !selected.some((gate) => gate.id === gateId)),
+            all_gate_ids: allGateIds,
+            missing_explicit_gate_ids: missingExplicitGateIds,
+            ...statusContext,
+        };
+    }
+    const tealConfig = parseTealConfigMarkdown(tealRaw);
+    const mappedGateIds = readStageAssignedGateIds(tealConfig, statusContext.active_module);
+    const mappedGateIdSet = new Set(mappedGateIds);
+    const selected = gates.filter((gate) => mappedGateIdSet.has(gate.id) &&
+        effectiveGateScope(gate) === "workspace" &&
+        effectiveGateActivation(gate, mappedGateIdSet) === "stage");
+    let note;
+    if (!statusContext.active_module) {
+        note = "No active ACE role/module could be resolved from STATUS.md. Use explicit gate_ids when needed.";
+    }
+    else if (mappedGateIds.length === 0) {
+        note = `No stage-activated workspace gates are configured for active module "${statusContext.active_module}". Use explicit gate_ids when needed.`;
+    }
+    else if (selected.length === 0) {
+        note = `No implicitly runnable workspace gates matched active module "${statusContext.active_module}". Package-scope and explicit-only gates require explicit gate_ids.`;
+    }
+    return {
+        selection_mode: "active_stage",
+        manifest_source: manifestSource,
+        selected,
+        selected_gate_ids: selected.map((gate) => gate.id),
+        skipped_gate_ids: allGateIds.filter((gateId) => !selected.some((gate) => gate.id === gateId)),
+        all_gate_ids: allGateIds,
+        missing_explicit_gate_ids: [],
+        note,
+        ...statusContext,
+    };
+}
+//# sourceMappingURL=gate-contract.js.map